devs/profanity
2
0
Fork 0
mirror of https://git.jabber.space/devs/cproof.git synced 2026-07-25 05:46:21 +00:00
Code Issues Packages Projects Releases Wiki Activity

Apply coding style

Browse Source 
Regards https://github.com/profanity-im/profanity/issues/1396
This commit is contained in:
Michael Vetter
2020-07-07 09:43:28 +02:00
parent 66f9a6b721
commit 9b55f2dec0
214 changed files with 19572 additions and 17582 deletions
Download Patch File Download Diff File Expand all files Collapse all files

95
src/xmpp/avatar.c
View File

@@ -33,37 +33,38 @@
*
*/
#include <errno.h>
#include <glib.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <sys/stat.h>
#include "config/files.h"
#include "config/preferences.h"
#include "log.h"
#include "ui/ui.h"
#include "xmpp/connection.h"
#include "xmpp/form.h"
#include "xmpp/iq.h"
#include "xmpp/message.h"
#include "xmpp/stanza.h"
#include "ui/ui.h"
#include "config/files.h"
#include "config/preferences.h"
typedef struct avatar_metadata {
char *type;
char *id;
typedef struct avatar_metadata
{
char* type;
char* id;
} avatar_metadata;
static GHashTable *looking_for = NULL; // contains nicks/barejids from who we want to get the avatar
static GHashTable *shall_open = NULL; // contains a list of nicks that shall not just downloaded but also opened
static GHashTable* looking_for = NULL; // contains nicks/barejids from who we want to get the avatar
static GHashTable* shall_open = NULL; // contains a list of nicks that shall not just downloaded but also opened
static void _avatar_request_item_by_id(const char *jid, avatar_metadata *data);
static int _avatar_metadata_handler(xmpp_stanza_t *const stanza, void *const userdata);
static int _avatar_request_item_result_handler(xmpp_stanza_t *const stanza, void *const userdata);
static void _avatar_request_item_by_id(const char* jid, avatar_metadata* data);
static int _avatar_metadata_handler(xmpp_stanza_t* const stanza, void* const userdata);
static int _avatar_request_item_result_handler(xmpp_stanza_t* const stanza, void* const userdata);
static void
_free_avatar_data(avatar_metadata *data)
_free_avatar_data(avatar_metadata* data)
{
if (data) {
free(data->type);
@@ -110,21 +111,21 @@ avatar_get_by_nick(const char* nick, gboolean open)
}
static int
_avatar_metadata_handler(xmpp_stanza_t *const stanza, void *const userdata)
_avatar_metadata_handler(xmpp_stanza_t* const stanza, void* const userdata)
{
const char *from = xmpp_stanza_get_attribute(stanza, STANZA_ATTR_FROM);
const char* from = xmpp_stanza_get_attribute(stanza, STANZA_ATTR_FROM);
if (!g_hash_table_contains(looking_for, from)) {
return 1;
}
xmpp_stanza_t *root = NULL;
xmpp_stanza_t *event = xmpp_stanza_get_child_by_ns(stanza, STANZA_NS_PUBSUB_EVENT);
xmpp_stanza_t* root = NULL;
xmpp_stanza_t* event = xmpp_stanza_get_child_by_ns(stanza, STANZA_NS_PUBSUB_EVENT);
if (event) {
root = event;
}
xmpp_stanza_t *pubsub = xmpp_stanza_get_child_by_ns(stanza, STANZA_NS_PUBSUB);
xmpp_stanza_t* pubsub = xmpp_stanza_get_child_by_ns(stanza, STANZA_NS_PUBSUB);
if (pubsub) {
root = pubsub;
}
@@ -133,25 +134,25 @@ _avatar_metadata_handler(xmpp_stanza_t *const stanza, void *const userdata)
return 1;
}
xmpp_stanza_t *items = xmpp_stanza_get_child_by_name(root, "items");
xmpp_stanza_t* items = xmpp_stanza_get_child_by_name(root, "items");
if (!items) {
return 1;
}
xmpp_stanza_t *item = xmpp_stanza_get_child_by_name(items, "item");
xmpp_stanza_t* item = xmpp_stanza_get_child_by_name(items, "item");
if (item) {
xmpp_stanza_t *metadata = xmpp_stanza_get_child_by_name(item, "metadata");
xmpp_stanza_t* metadata = xmpp_stanza_get_child_by_name(item, "metadata");
if (!metadata)
return 1;
xmpp_stanza_t *info = xmpp_stanza_get_child_by_name(metadata, "info");
xmpp_stanza_t* info = xmpp_stanza_get_child_by_name(metadata, "info");
const char *id = xmpp_stanza_get_id(info);
const char *type = xmpp_stanza_get_attribute(info, "type");
const char* id = xmpp_stanza_get_id(info);
const char* type = xmpp_stanza_get_attribute(info, "type");
log_debug("Avatar ID for %s is: %s", from, id);
avatar_metadata *data = malloc(sizeof(avatar_metadata));
avatar_metadata* data = malloc(sizeof(avatar_metadata));
data->type = strdup(type);
data->id = strdup(id);
@@ -163,15 +164,15 @@ _avatar_metadata_handler(xmpp_stanza_t *const stanza, void *const userdata)
}
static void
_avatar_request_item_by_id(const char *jid, avatar_metadata *data)
_avatar_request_item_by_id(const char* jid, avatar_metadata* data)
{
caps_remove_feature(XMPP_FEATURE_USER_AVATAR_METADATA_NOTIFY);
xmpp_ctx_t * const ctx = connection_get_ctx();
xmpp_ctx_t* const ctx = connection_get_ctx();
char *uid = connection_create_stanza_id();
char* uid = connection_create_stanza_id();
xmpp_stanza_t *iq = stanza_create_avatar_retrieve_data_request(ctx, uid, data->id, jid);
xmpp_stanza_t* iq = stanza_create_avatar_retrieve_data_request(ctx, uid, data->id, jid);
iq_id_handler_add(uid, _avatar_request_item_result_handler, (ProfIqFreeCallback)_free_avatar_data, data);
free(uid);
@@ -181,9 +182,9 @@ _avatar_request_item_by_id(const char *jid, avatar_metadata *data)
}
static int
_avatar_request_item_result_handler(xmpp_stanza_t *const stanza, void *const userdata)
_avatar_request_item_result_handler(xmpp_stanza_t* const stanza, void* const userdata)
{
const char *from_attr = xmpp_stanza_get_attribute(stanza, STANZA_ATTR_FROM);
const char* from_attr = xmpp_stanza_get_attribute(stanza, STANZA_ATTR_FROM);
if (!from_attr) {
return 1;
@@ -194,33 +195,33 @@ _avatar_request_item_result_handler(xmpp_stanza_t *const stanza, void *const use
}
g_hash_table_remove(looking_for, from_attr);
xmpp_stanza_t *pubsub = xmpp_stanza_get_child_by_ns(stanza, STANZA_NS_PUBSUB);
xmpp_stanza_t* pubsub = xmpp_stanza_get_child_by_ns(stanza, STANZA_NS_PUBSUB);
if (!pubsub) {
return 1;
}
xmpp_stanza_t *items = xmpp_stanza_get_child_by_name(pubsub, "items");
xmpp_stanza_t* items = xmpp_stanza_get_child_by_name(pubsub, "items");
if (!items) {
return 1;
}
xmpp_stanza_t *item = xmpp_stanza_get_child_by_name(items, "item");
xmpp_stanza_t* item = xmpp_stanza_get_child_by_name(items, "item");
if (!item) {
return 1;
}
xmpp_stanza_t *st_data = stanza_get_child_by_name_and_ns(item, "data", STANZA_NS_USER_AVATAR_DATA);
xmpp_stanza_t* st_data = stanza_get_child_by_name_and_ns(item, "data", STANZA_NS_USER_AVATAR_DATA);
if (!st_data) {
return 1;
}
char *buf = xmpp_stanza_get_text(st_data);
char* buf = xmpp_stanza_get_text(st_data);
gsize size;
gchar *de = (gchar*)g_base64_decode(buf, &size);
gchar* de = (gchar*)g_base64_decode(buf, &size);
free(buf);
char *path = files_get_data_path("");
GString *filename = g_string_new(path);
char* path = files_get_data_path("");
GString* filename = g_string_new(path);
free(path);
g_string_append(filename, "avatars/");
@@ -228,7 +229,7 @@ _avatar_request_item_result_handler(xmpp_stanza_t *const stanza, void *const use
errno = 0;
int res = g_mkdir_with_parents(filename->str, S_IRWXU);
if (res == -1) {
char *errmsg = strerror(errno);
char* errmsg = strerror(errno);
if (errmsg) {
log_error("Avatar: error creating directory: %s, %s", filename->str, errmsg);
} else {
@@ -236,10 +237,10 @@ _avatar_request_item_result_handler(xmpp_stanza_t *const stanza, void *const use
}
}
gchar *from = str_replace(from_attr, "@", "_at_");
gchar* from = str_replace(from_attr, "@", "_at_");
g_string_append(filename, from);
avatar_metadata *data = (avatar_metadata*)userdata;
avatar_metadata* data = (avatar_metadata*)userdata;
// check a few image types ourselves
// if none matches we won't add an extension but linux will
@@ -255,8 +256,8 @@ _avatar_request_item_result_handler(xmpp_stanza_t *const stanza, void *const use
free(from);
GError *err = NULL;
if (g_file_set_contents (filename->str, de, size, &err) == FALSE) {
GError* err = NULL;
if (g_file_set_contents(filename->str, de, size, &err) == FALSE) {
log_error("Unable to save picture: %s", err->message);
cons_show("Unable to save picture %s", err->message);
g_error_free(err);
@@ -266,9 +267,9 @@ _avatar_request_item_result_handler(xmpp_stanza_t *const stanza, void *const use
// if we shall open it
if (g_hash_table_contains(shall_open, from_attr)) {
gchar *argv[] = {prefs_get_string(PREF_AVATAR_CMD), filename->str, NULL};
gchar* argv[] = { prefs_get_string(PREF_AVATAR_CMD), filename->str, NULL };
if (!call_external(argv, NULL, NULL)) {
cons_show_error("Unable to display avatar: check the logs for more information.");
cons_show_error("Unable to display avatar: check the logs for more information.");
}
g_hash_table_remove(shall_open, from_attr);
}

94
src/xmpp/blocking.c
View File

@@ -46,19 +46,19 @@
#include <glib.h>
#include "log.h"
#include "common.h"
#include "log.h"
#include "ui/ui.h"
#include "xmpp/session.h"
#include "xmpp/connection.h"
#include "xmpp/stanza.h"
#include "xmpp/iq.h"
#include "xmpp/session.h"
#include "xmpp/stanza.h"
static int _blocklist_result_handler(xmpp_stanza_t *const stanza, void *const userdata);
static int _block_add_result_handler(xmpp_stanza_t *const stanza, void *const userdata);
static int _block_remove_result_handler(xmpp_stanza_t *const stanza, void *const userdata);
static int _blocklist_result_handler(xmpp_stanza_t* const stanza, void* const userdata);
static int _block_add_result_handler(xmpp_stanza_t* const stanza, void* const userdata);
static int _block_remove_result_handler(xmpp_stanza_t* const stanza, void* const userdata);
static GList *blocked;
static GList* blocked;
static Autocomplete blocked_ac;
void
@@ -74,11 +74,11 @@ blocking_request(void)
}
blocked_ac = autocomplete_new();
char *id = connection_create_stanza_id();
char* id = connection_create_stanza_id();
iq_id_handler_add(id, _blocklist_result_handler, NULL, NULL);
xmpp_ctx_t *ctx = connection_get_ctx();
xmpp_stanza_t *iq = stanza_create_blocked_list_request(ctx);
xmpp_ctx_t* ctx = connection_get_ctx();
xmpp_stanza_t* iq = stanza_create_blocked_list_request(ctx);
xmpp_stanza_set_id(iq, id);
free(id);
@@ -93,7 +93,7 @@ blocked_list(void)
}
char*
blocked_ac_find(const char *const search_str, gboolean previous, void *context)
blocked_ac_find(const char* const search_str, gboolean previous, void* context)
{
return autocomplete_complete(blocked_ac, search_str, TRUE, previous);
}
@@ -107,23 +107,23 @@ blocked_ac_reset(void)
}
gboolean
blocked_add(char *jid)
blocked_add(char* jid)
{
GList *found = g_list_find_custom(blocked, jid, (GCompareFunc)g_strcmp0);
GList* found = g_list_find_custom(blocked, jid, (GCompareFunc)g_strcmp0);
if (found) {
return FALSE;
}
xmpp_ctx_t *ctx = connection_get_ctx();
xmpp_ctx_t* ctx = connection_get_ctx();
char *id = connection_create_stanza_id();
xmpp_stanza_t *iq = xmpp_iq_new(ctx, STANZA_TYPE_SET, id);
char* id = connection_create_stanza_id();
xmpp_stanza_t* iq = xmpp_iq_new(ctx, STANZA_TYPE_SET, id);
xmpp_stanza_t *block = xmpp_stanza_new(ctx);
xmpp_stanza_t* block = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(block, STANZA_NAME_BLOCK);
xmpp_stanza_set_ns(block, STANZA_NS_BLOCKING);
xmpp_stanza_t *item = xmpp_stanza_new(ctx);
xmpp_stanza_t* item = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(item, STANZA_NAME_ITEM);
xmpp_stanza_set_attribute(item, STANZA_ATTR_JID, jid);
@@ -143,23 +143,23 @@ blocked_add(char *jid)
}
gboolean
blocked_remove(char *jid)
blocked_remove(char* jid)
{
GList *found = g_list_find_custom(blocked, jid, (GCompareFunc)g_strcmp0);
GList* found = g_list_find_custom(blocked, jid, (GCompareFunc)g_strcmp0);
if (!found) {
return FALSE;
}
xmpp_ctx_t *ctx = connection_get_ctx();
xmpp_ctx_t* ctx = connection_get_ctx();
char *id = connection_create_stanza_id();
xmpp_stanza_t *iq = xmpp_iq_new(ctx, STANZA_TYPE_SET, id);
char* id = connection_create_stanza_id();
xmpp_stanza_t* iq = xmpp_iq_new(ctx, STANZA_TYPE_SET, id);
xmpp_stanza_t *block = xmpp_stanza_new(ctx);
xmpp_stanza_t* block = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(block, STANZA_NAME_UNBLOCK);
xmpp_stanza_set_ns(block, STANZA_NS_BLOCKING);
xmpp_stanza_t *item = xmpp_stanza_new(ctx);
xmpp_stanza_t* item = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(item, STANZA_NAME_ITEM);
xmpp_stanza_set_attribute(item, STANZA_ATTR_JID, jid);
@@ -179,28 +179,27 @@ blocked_remove(char *jid)
}
int
blocked_set_handler(xmpp_stanza_t *stanza)
blocked_set_handler(xmpp_stanza_t* stanza)
{
xmpp_stanza_t *block = xmpp_stanza_get_child_by_name(stanza, STANZA_NAME_BLOCK);
xmpp_stanza_t* block = xmpp_stanza_get_child_by_name(stanza, STANZA_NAME_BLOCK);
if (block) {
xmpp_stanza_t *child = xmpp_stanza_get_children(block);
xmpp_stanza_t* child = xmpp_stanza_get_children(block);
while (child) {
if (g_strcmp0(xmpp_stanza_get_name(child), STANZA_NAME_ITEM) == 0) {
const char *jid = xmpp_stanza_get_attribute(child, STANZA_ATTR_JID);
const char* jid = xmpp_stanza_get_attribute(child, STANZA_ATTR_JID);
if (jid) {
blocked = g_list_append(blocked, strdup(jid));
autocomplete_add(blocked_ac, jid);
}
}
child = xmpp_stanza_get_next(child);
}
}
xmpp_stanza_t *unblock = xmpp_stanza_get_child_by_name(stanza, STANZA_NAME_UNBLOCK);
xmpp_stanza_t* unblock = xmpp_stanza_get_child_by_name(stanza, STANZA_NAME_UNBLOCK);
if (unblock) {
xmpp_stanza_t *child = xmpp_stanza_get_children(unblock);
xmpp_stanza_t* child = xmpp_stanza_get_children(unblock);
if (!child) {
g_list_free_full(blocked, free);
blocked = NULL;
@@ -208,16 +207,15 @@ blocked_set_handler(xmpp_stanza_t *stanza)
} else {
while (child) {
if (g_strcmp0(xmpp_stanza_get_name(child), STANZA_NAME_ITEM) == 0) {
const char *jid = xmpp_stanza_get_attribute(child, STANZA_ATTR_JID);
const char* jid = xmpp_stanza_get_attribute(child, STANZA_ATTR_JID);
if (jid) {
GList *found = g_list_find_custom(blocked, jid, (GCompareFunc)g_strcmp0);
GList* found = g_list_find_custom(blocked, jid, (GCompareFunc)g_strcmp0);
if (found) {
blocked = g_list_remove_link(blocked, found);
g_list_free_full(found, free);
autocomplete_remove(blocked_ac, jid);
}
}
}
child = xmpp_stanza_get_next(child);
@@ -229,11 +227,11 @@ blocked_set_handler(xmpp_stanza_t *stanza)
}
static int
_block_add_result_handler(xmpp_stanza_t *const stanza, void *const userdata)
_block_add_result_handler(xmpp_stanza_t* const stanza, void* const userdata)
{
char *jid = (char*)userdata;
char* jid = (char*)userdata;
const char *type = xmpp_stanza_get_type(stanza);
const char* type = xmpp_stanza_get_type(stanza);
if (!type) {
log_info("Block response received for %s with no type attribute.", jid);
return 0;
@@ -250,11 +248,11 @@ _block_add_result_handler(xmpp_stanza_t *const stanza, void *const userdata)
}
static int
_block_remove_result_handler(xmpp_stanza_t *const stanza, void *const userdata)
_block_remove_result_handler(xmpp_stanza_t* const stanza, void* const userdata)
{
char *jid = (char*)userdata;
char* jid = (char*)userdata;
const char *type = xmpp_stanza_get_type(stanza);
const char* type = xmpp_stanza_get_type(stanza);
if (!type) {
log_info("Unblock response received for %s with no type attribute.", jid);
return 0;
@@ -271,17 +269,17 @@ _block_remove_result_handler(xmpp_stanza_t *const stanza, void *const userdata)
}
static int
_blocklist_result_handler(xmpp_stanza_t *const stanza, void *const userdata)
_blocklist_result_handler(xmpp_stanza_t* const stanza, void* const userdata)
{
log_debug("Blocked list result handler fired.");
const char *type = xmpp_stanza_get_type(stanza);
const char* type = xmpp_stanza_get_type(stanza);
if (g_strcmp0(type, "result") != 0) {
log_info("Received blocklist without result type");
return 0;
}
xmpp_stanza_t *blocklist = xmpp_stanza_get_child_by_name(stanza, STANZA_NAME_BLOCKLIST);
xmpp_stanza_t* blocklist = xmpp_stanza_get_child_by_name(stanza, STANZA_NAME_BLOCKLIST);
if (!blocklist) {
log_info("Received blocklist without blocklist element");
return 0;
@@ -292,17 +290,17 @@ _blocklist_result_handler(xmpp_stanza_t *const stanza, void *const userdata)
blocked = NULL;
}
xmpp_stanza_t *items = xmpp_stanza_get_children(blocklist);
xmpp_stanza_t* items = xmpp_stanza_get_children(blocklist);
if (!items) {
log_debug("No blocked users.");
return 0;
}
xmpp_stanza_t *curr = items;
xmpp_stanza_t* curr = items;
while (curr) {
const char *name = xmpp_stanza_get_name(curr);
const char* name = xmpp_stanza_get_name(curr);
if (g_strcmp0(name, "item") == 0) {
const char *jid = xmpp_stanza_get_attribute(curr, STANZA_ATTR_JID);
const char* jid = xmpp_stanza_get_attribute(curr, STANZA_ATTR_JID);
if (jid) {
blocked = g_list_append(blocked, strdup(jid));
autocomplete_add(blocked_ac, jid);

2
src/xmpp/blocking.h
View File

@@ -37,6 +37,6 @@
#define XMPP_BLOCKING_H
void blocking_request(void);
int blocked_set_handler(xmpp_stanza_t *stanza);
int blocked_set_handler(xmpp_stanza_t* stanza);
#endif

117
src/xmpp/bookmark.c
View File

@@ -36,10 +36,10 @@
#include "config.h"
#include <assert.h>
#include <glib.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <glib.h>
#ifdef HAVE_LIBMESODE
#include <mesode.h>
@@ -50,26 +50,26 @@
#endif
#include "common.h"
#include "log.h"
#include "event/server_events.h"
#include "log.h"
#include "plugins/plugins.h"
#include "ui/ui.h"
#include "xmpp/bookmark.h"
#include "xmpp/connection.h"
#include "xmpp/iq.h"
#include "xmpp/muc.h"
#include "xmpp/stanza.h"
#include "xmpp/xmpp.h"
#include "xmpp/bookmark.h"
#include "xmpp/muc.h"
#define BOOKMARK_TIMEOUT 5000
static Autocomplete bookmark_ac;
static GHashTable *bookmarks;
static GHashTable* bookmarks;
// id handlers
static int _bookmark_result_id_handler(xmpp_stanza_t *const stanza, void *const userdata);
static int _bookmark_result_id_handler(xmpp_stanza_t* const stanza, void* const userdata);
static void _bookmark_destroy(Bookmark *bookmark);
static void _bookmark_destroy(Bookmark* bookmark);
static void _send_bookmarks(void);
void
@@ -83,11 +83,11 @@ bookmark_request(void)
autocomplete_free(bookmark_ac);
bookmark_ac = autocomplete_new();
char *id = "bookmark_init_request";
char* id = "bookmark_init_request";
iq_id_handler_add(id, _bookmark_result_id_handler, free, NULL);
xmpp_ctx_t *ctx = connection_get_ctx();
xmpp_stanza_t *iq = stanza_create_bookmarks_storage_request(ctx);
xmpp_ctx_t* ctx = connection_get_ctx();
xmpp_stanza_t* iq = stanza_create_bookmarks_storage_request(ctx);
xmpp_stanza_set_id(iq, id);
iq_send_stanza(iq);
@@ -95,11 +95,11 @@ bookmark_request(void)
}
gboolean
bookmark_add(const char *jid, const char *nick, const char *password, const char *autojoin_str, const char *name)
bookmark_add(const char* jid, const char* nick, const char* password, const char* autojoin_str, const char* name)
{
assert(jid != NULL);
Jid *jidp = jid_create(jid);
Jid* jidp = jid_create(jid);
if (jidp->domainpart) {
muc_confserver_add(jidp->domainpart);
}
@@ -109,7 +109,7 @@ bookmark_add(const char *jid, const char *nick, const char *password, const char
return FALSE;
}
Bookmark *bookmark = malloc(sizeof(Bookmark));
Bookmark* bookmark = malloc(sizeof(Bookmark));
bookmark->barejid = strdup(jid);
if (nick) {
bookmark->nick = strdup(nick);
@@ -142,11 +142,11 @@ bookmark_add(const char *jid, const char *nick, const char *password, const char
}
gboolean
bookmark_update(const char *jid, const char *nick, const char *password, const char *autojoin_str, const char *name)
bookmark_update(const char* jid, const char* nick, const char* password, const char* autojoin_str, const char* name)
{
assert(jid != NULL);
Bookmark *bookmark = g_hash_table_lookup(bookmarks, jid);
Bookmark* bookmark = g_hash_table_lookup(bookmarks, jid);
if (!bookmark) {
return FALSE;
}
@@ -176,19 +176,19 @@ bookmark_update(const char *jid, const char *nick, const char *password, const c
}
gboolean
bookmark_join(const char *jid)
bookmark_join(const char* jid)
{
assert(jid != NULL);
Bookmark *bookmark = g_hash_table_lookup(bookmarks, jid);
Bookmark* bookmark = g_hash_table_lookup(bookmarks, jid);
if (!bookmark) {
return FALSE;
}
char *account_name = session_get_account_name();
ProfAccount *account = accounts_get_account(account_name);
char* account_name = session_get_account_name();
ProfAccount* account = accounts_get_account(account_name);
if (!muc_active(bookmark->barejid)) {
char *nick = bookmark->nick;
char* nick = bookmark->nick;
if (!nick) {
nick = account->muc_nick;
}
@@ -207,11 +207,11 @@ bookmark_join(const char *jid)
}
gboolean
bookmark_remove(const char *jid)
bookmark_remove(const char* jid)
{
assert(jid != NULL);
Bookmark *bookmark = g_hash_table_lookup(bookmarks, jid);
Bookmark* bookmark = g_hash_table_lookup(bookmarks, jid);
if (!bookmark) {
return FALSE;
}
@@ -231,7 +231,7 @@ bookmark_get_list(void)
}
char*
bookmark_find(const char *const search_str, gboolean previous, void *context)
bookmark_find(const char* const search_str, gboolean previous, void* context)
{
return autocomplete_complete(bookmark_ac, search_str, TRUE, previous);
}
@@ -245,24 +245,24 @@ bookmark_autocomplete_reset(void)
}
gboolean
bookmark_exists(const char *const room)
bookmark_exists(const char* const room)
{
return g_hash_table_contains(bookmarks, room);
}
static int
_bookmark_result_id_handler(xmpp_stanza_t *const stanza, void *const userdata)
_bookmark_result_id_handler(xmpp_stanza_t* const stanza, void* const userdata)
{
const char *name = xmpp_stanza_get_name(stanza);
const char* name = xmpp_stanza_get_name(stanza);
if (!name || strcmp(name, STANZA_NAME_IQ) != 0) {
return 0;
}
xmpp_stanza_t *query = xmpp_stanza_get_child_by_name(stanza, STANZA_NAME_QUERY);
xmpp_stanza_t* query = xmpp_stanza_get_child_by_name(stanza, STANZA_NAME_QUERY);
if (!query) {
return 0;
}
xmpp_stanza_t *storage = xmpp_stanza_get_child_by_name(query, STANZA_NAME_STORAGE);
xmpp_stanza_t* storage = xmpp_stanza_get_child_by_name(query, STANZA_NAME_STORAGE);
if (!storage) {
return 0;
}
@@ -271,14 +271,14 @@ _bookmark_result_id_handler(xmpp_stanza_t *const stanza, void *const userdata)
bookmark_ac = autocomplete_new();
}
xmpp_stanza_t *child = xmpp_stanza_get_children(storage);
xmpp_stanza_t* child = xmpp_stanza_get_children(storage);
while (child) {
name = xmpp_stanza_get_name(child);
if (!name || strcmp(name, STANZA_NAME_CONFERENCE) != 0) {
child = xmpp_stanza_get_next(child);
continue;
}
const char *barejid = xmpp_stanza_get_attribute(child, STANZA_ATTR_JID);
const char* barejid = xmpp_stanza_get_attribute(child, STANZA_ATTR_JID);
if (!barejid) {
child = xmpp_stanza_get_next(child);
continue;
@@ -286,21 +286,21 @@ _bookmark_result_id_handler(xmpp_stanza_t *const stanza, void *const userdata)
log_debug("Handle bookmark for %s", barejid);
const char *room_name = xmpp_stanza_get_attribute(child, "name");
const char* room_name = xmpp_stanza_get_attribute(child, "name");
char *nick = NULL;
xmpp_stanza_t *nick_st = xmpp_stanza_get_child_by_name(child, "nick");
char* nick = NULL;
xmpp_stanza_t* nick_st = xmpp_stanza_get_child_by_name(child, "nick");
if (nick_st) {
nick = stanza_text_strdup(nick_st);
}
char *password = NULL;
xmpp_stanza_t *password_st = xmpp_stanza_get_child_by_name(child, "password");
char* password = NULL;
xmpp_stanza_t* password_st = xmpp_stanza_get_child_by_name(child, "password");
if (password_st) {
password = stanza_text_strdup(password_st);
}
const char *autojoin = xmpp_stanza_get_attribute(child, "autojoin");
const char* autojoin = xmpp_stanza_get_attribute(child, "autojoin");
gboolean autojoin_val = FALSE;
if (autojoin && (strcmp(autojoin, "1") == 0 || strcmp(autojoin, "true") == 0)) {
autojoin_val = TRUE;
@@ -308,9 +308,9 @@ _bookmark_result_id_handler(xmpp_stanza_t *const stanza, void *const userdata)
// we save minimize, which is not standard, so that we don't remove it if it was set by gajim
int minimize = 0;
xmpp_stanza_t *minimize_st = stanza_get_child_by_name_and_ns(child, STANZA_NAME_MINIMIZE, STANZA_NS_EXT_GAJIM_BOOKMARKS);
xmpp_stanza_t* minimize_st = stanza_get_child_by_name_and_ns(child, STANZA_NAME_MINIMIZE, STANZA_NS_EXT_GAJIM_BOOKMARKS);
if (minimize_st) {
char *min_str = xmpp_stanza_get_text(minimize_st);
char* min_str = xmpp_stanza_get_text(minimize_st);
if (strcmp(min_str, "true") == 0) {
minimize = 1;
} else if (strcmp(min_str, "false") == 0) {
@@ -320,7 +320,7 @@ _bookmark_result_id_handler(xmpp_stanza_t *const stanza, void *const userdata)
}
autocomplete_add(bookmark_ac, barejid);
Bookmark *bookmark = malloc(sizeof(Bookmark));
Bookmark* bookmark = malloc(sizeof(Bookmark));
bookmark->barejid = strdup(barejid);
bookmark->nick = nick;
bookmark->password = password;
@@ -333,7 +333,7 @@ _bookmark_result_id_handler(xmpp_stanza_t *const stanza, void *const userdata)
sv_ev_bookmark_autojoin(bookmark);
}
Jid *jidp = jid_create(barejid);
Jid* jidp = jid_create(barejid);
if (jidp->domainpart) {
muc_confserver_add(jidp->domainpart);
}
@@ -346,7 +346,7 @@ _bookmark_result_id_handler(xmpp_stanza_t *const stanza, void *const userdata)
}
static void
_bookmark_destroy(Bookmark *bookmark)
_bookmark_destroy(Bookmark* bookmark)
{
if (bookmark) {
free(bookmark->barejid);
@@ -360,25 +360,25 @@ _bookmark_destroy(Bookmark *bookmark)
static void
_send_bookmarks(void)
{
xmpp_ctx_t *ctx = connection_get_ctx();
xmpp_ctx_t* ctx = connection_get_ctx();
char *id = connection_create_stanza_id();
xmpp_stanza_t *iq = xmpp_iq_new(ctx, STANZA_TYPE_SET, id);
char* id = connection_create_stanza_id();
xmpp_stanza_t* iq = xmpp_iq_new(ctx, STANZA_TYPE_SET, id);
free(id);
xmpp_stanza_t *query = xmpp_stanza_new(ctx);
xmpp_stanza_t* query = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(query, STANZA_NAME_QUERY);
xmpp_stanza_set_ns(query, "jabber:iq:private");
xmpp_stanza_t *storage = xmpp_stanza_new(ctx);
xmpp_stanza_t* storage = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(storage, STANZA_NAME_STORAGE);
xmpp_stanza_set_ns(storage, "storage:bookmarks");
GList *bookmark_list = g_hash_table_get_values(bookmarks);
GList *curr = bookmark_list;
GList* bookmark_list = g_hash_table_get_values(bookmarks);
GList* curr = bookmark_list;
while (curr) {
Bookmark *bookmark = curr->data;
xmpp_stanza_t *conference = xmpp_stanza_new(ctx);
Bookmark* bookmark = curr->data;
xmpp_stanza_t* conference = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(conference, STANZA_NAME_CONFERENCE);
xmpp_stanza_set_attribute(conference, STANZA_ATTR_JID, bookmark->barejid);
@@ -387,7 +387,7 @@ _send_bookmarks(void)
xmpp_stanza_set_attribute(conference, STANZA_ATTR_NAME, bookmark->name);
} else {
// use localpart of JID by if no name is specified
Jid *jidp = jid_create(bookmark->barejid);
Jid* jidp = jid_create(bookmark->barejid);
if (jidp->localpart) {
xmpp_stanza_set_attribute(conference, STANZA_ATTR_NAME, jidp->localpart);
}
@@ -401,9 +401,9 @@ _send_bookmarks(void)
}
if (bookmark->nick) {
xmpp_stanza_t *nick_st = xmpp_stanza_new(ctx);
xmpp_stanza_t* nick_st = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(nick_st, STANZA_NAME_NICK);
xmpp_stanza_t *nick_text = xmpp_stanza_new(ctx);
xmpp_stanza_t* nick_text = xmpp_stanza_new(ctx);
xmpp_stanza_set_text(nick_text, bookmark->nick);
xmpp_stanza_add_child(nick_st, nick_text);
xmpp_stanza_add_child(conference, nick_st);
@@ -413,9 +413,9 @@ _send_bookmarks(void)
}
if (bookmark->password) {
xmpp_stanza_t *password_st = xmpp_stanza_new(ctx);
xmpp_stanza_t* password_st = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(password_st, STANZA_NAME_PASSWORD);
xmpp_stanza_t *password_text = xmpp_stanza_new(ctx);
xmpp_stanza_t* password_text = xmpp_stanza_new(ctx);
xmpp_stanza_set_text(password_text, bookmark->password);
xmpp_stanza_add_child(password_st, password_text);
xmpp_stanza_add_child(conference, password_st);
@@ -424,13 +424,12 @@ _send_bookmarks(void)
xmpp_stanza_release(password_st);
}
if (bookmark->ext_gajim_minimize == 1 ||
bookmark->ext_gajim_minimize == 2) {
xmpp_stanza_t *minimize_st = xmpp_stanza_new(ctx);
if (bookmark->ext_gajim_minimize == 1 || bookmark->ext_gajim_minimize == 2) {
xmpp_stanza_t* minimize_st = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(minimize_st, STANZA_NAME_MINIMIZE);
xmpp_stanza_set_ns(minimize_st, STANZA_NS_EXT_GAJIM_BOOKMARKS);
xmpp_stanza_t *minimize_text = xmpp_stanza_new(ctx);
xmpp_stanza_t* minimize_text = xmpp_stanza_new(ctx);
if (bookmark->ext_gajim_minimize == 1) {
xmpp_stanza_set_text(minimize_text, "true");
} else {

138
src/xmpp/capabilities.c
View File

@@ -54,29 +54,29 @@
#endif
#include "common.h"
#include "log.h"
#include "event/client_events.h"
#include "plugins/plugins.h"
#include "config/files.h"
#include "config/preferences.h"
#include "xmpp/xmpp.h"
#include "xmpp/stanza.h"
#include "xmpp/form.h"
#include "event/client_events.h"
#include "log.h"
#include "plugins/plugins.h"
#include "xmpp/capabilities.h"
#include "xmpp/form.h"
#include "xmpp/stanza.h"
#include "xmpp/xmpp.h"
static char *cache_loc;
static GKeyFile *cache;
static char* cache_loc;
static GKeyFile* cache;
static GHashTable *jid_to_ver;
static GHashTable *jid_to_caps;
static GHashTable* jid_to_ver;
static GHashTable* jid_to_caps;
static GHashTable *prof_features;
static char *my_sha1;
static GHashTable* prof_features;
static char* my_sha1;
static void _save_cache(void);
static EntityCapabilities* _caps_by_ver(const char *const ver);
static EntityCapabilities* _caps_by_jid(const char *const jid);
static EntityCapabilities* _caps_copy(EntityCapabilities *caps);
static EntityCapabilities* _caps_by_ver(const char* const ver);
static EntityCapabilities* _caps_by_jid(const char* const jid);
static EntityCapabilities* _caps_copy(EntityCapabilities* caps);
void
caps_init(void)
@@ -121,7 +121,7 @@ caps_init(void)
}
void
caps_add_feature(char *feature)
caps_add_feature(char* feature)
{
if (g_hash_table_contains(prof_features, feature)) {
return;
@@ -139,7 +139,7 @@ caps_add_feature(char *feature)
}
void
caps_remove_feature(char *feature)
caps_remove_feature(char* feature)
{
if (!g_hash_table_contains(prof_features, feature)) {
return;
@@ -159,17 +159,17 @@ caps_remove_feature(char *feature)
GList*
caps_get_features(void)
{
GList *result = NULL;
GList* result = NULL;
GList *features_as_list = g_hash_table_get_keys(prof_features);
GList *curr = features_as_list;
GList* features_as_list = g_hash_table_get_keys(prof_features);
GList* curr = features_as_list;
while (curr) {
result = g_list_append(result, strdup(curr->data));
curr = g_list_next(curr);
}
g_list_free(features_as_list);
GList *plugin_features = plugins_get_disco_features();
GList* plugin_features = plugins_get_disco_features();
curr = plugin_features;
while (curr) {
result = g_list_append(result, strdup(curr->data));
@@ -182,15 +182,15 @@ caps_get_features(void)
}
EntityCapabilities*
caps_create(const char *const category, const char *const type, const char *const name,
const char *const software, const char *const software_version,
const char *const os, const char *const os_version,
GSList *features)
caps_create(const char* const category, const char* const type, const char* const name,
const char* const software, const char* const software_version,
const char* const os, const char* const os_version,
GSList* features)
{
EntityCapabilities *result = (EntityCapabilities *)malloc(sizeof(EntityCapabilities));
EntityCapabilities* result = (EntityCapabilities*)malloc(sizeof(EntityCapabilities));
if (category || type || name) {
DiscoIdentity *identity = (DiscoIdentity*)malloc(sizeof(DiscoIdentity));
DiscoIdentity* identity = (DiscoIdentity*)malloc(sizeof(DiscoIdentity));
identity->category = category ? strdup(category) : NULL;
identity->type = type ? strdup(type) : NULL;
identity->name = name ? strdup(name) : NULL;
@@ -200,7 +200,7 @@ caps_create(const char *const category, const char *const type, const char *cons
}
if (software || software_version || os || os_version) {
SoftwareVersion *software_versionp = (SoftwareVersion*)malloc(sizeof(SoftwareVersion));
SoftwareVersion* software_versionp = (SoftwareVersion*)malloc(sizeof(SoftwareVersion));
software_versionp->software = software ? strdup(software) : NULL;
software_versionp->software_version = software_version ? strdup(software_version) : NULL;
software_versionp->os = os ? strdup(os) : NULL;
@@ -211,7 +211,7 @@ caps_create(const char *const category, const char *const type, const char *cons
}
result->features = NULL;
GSList *curr = features;
GSList* curr = features;
while (curr) {
result->features = g_slist_append(result->features, strdup(curr->data));
curr = g_slist_next(curr);
@@ -221,7 +221,7 @@ caps_create(const char *const category, const char *const type, const char *cons
}
void
caps_add_by_ver(const char *const ver, EntityCapabilities *caps)
caps_add_by_ver(const char* const ver, EntityCapabilities* caps)
{
if (ver == NULL || caps == NULL) {
return;
@@ -233,7 +233,7 @@ caps_add_by_ver(const char *const ver, EntityCapabilities *caps)
}
if (caps->identity) {
DiscoIdentity *identity = caps->identity;
DiscoIdentity* identity = caps->identity;
if (identity->name) {
g_key_file_set_string(cache, ver, "name", identity->name);
}
@@ -246,7 +246,7 @@ caps_add_by_ver(const char *const ver, EntityCapabilities *caps)
}
if (caps->software_version) {
SoftwareVersion *software_version = caps->software_version;
SoftwareVersion* software_version = caps->software_version;
if (software_version->software) {
g_key_file_set_string(cache, ver, "software", software_version->software);
}
@@ -262,7 +262,7 @@ caps_add_by_ver(const char *const ver, EntityCapabilities *caps)
}
if (caps->features) {
GSList *curr_feature = caps->features;
GSList* curr_feature = caps->features;
int num = g_slist_length(caps->features);
const gchar* features_list[num];
int curr = 0;
@@ -277,35 +277,35 @@ caps_add_by_ver(const char *const ver, EntityCapabilities *caps)
}
void
caps_add_by_jid(const char *const jid, EntityCapabilities *caps)
caps_add_by_jid(const char* const jid, EntityCapabilities* caps)
{
g_hash_table_insert(jid_to_caps, strdup(jid), caps);
}
void
caps_map_jid_to_ver(const char *const jid, const char *const ver)
caps_map_jid_to_ver(const char* const jid, const char* const ver)
{
g_hash_table_insert(jid_to_ver, strdup(jid), strdup(ver));
}
gboolean
caps_cache_contains(const char *const ver)
caps_cache_contains(const char* const ver)
{
return (g_key_file_has_group(cache, ver));
}
EntityCapabilities*
caps_lookup(const char *const jid)
caps_lookup(const char* const jid)
{
char *ver = g_hash_table_lookup(jid_to_ver, jid);
char* ver = g_hash_table_lookup(jid_to_ver, jid);
if (ver) {
EntityCapabilities *caps = _caps_by_ver(ver);
EntityCapabilities* caps = _caps_by_ver(ver);
if (caps) {
log_debug("Capabilities lookup %s, found by verification string %s.", jid, ver);
return caps;
}
} else {
EntityCapabilities *caps = _caps_by_jid(jid);
EntityCapabilities* caps = _caps_by_jid(jid);
if (caps) {
log_debug("Capabilities lookup %s, found by JID.", jid);
return _caps_copy(caps);
@@ -317,15 +317,15 @@ caps_lookup(const char *const jid)
}
gboolean
caps_jid_has_feature(const char *const jid, const char *const feature)
caps_jid_has_feature(const char* const jid, const char* const feature)
{
EntityCapabilities *caps = caps_lookup(jid);
EntityCapabilities* caps = caps_lookup(jid);
if (caps == NULL) {
return FALSE;
}
GSList *found = g_slist_find_custom(caps->features, feature, (GCompareFunc)g_strcmp0);
GSList* found = g_slist_find_custom(caps->features, feature, (GCompareFunc)g_strcmp0);
gboolean result = found != NULL;
caps_destroy(caps);
@@ -334,10 +334,10 @@ caps_jid_has_feature(const char *const jid, const char *const feature)
}
char*
caps_get_my_sha1(xmpp_ctx_t *const ctx)
caps_get_my_sha1(xmpp_ctx_t* const ctx)
{
if (my_sha1 == NULL) {
xmpp_stanza_t *query = stanza_create_caps_query_element(ctx);
xmpp_stanza_t* query = stanza_create_caps_query_element(ctx);
my_sha1 = stanza_create_caps_sha1_from_query(query);
xmpp_stanza_release(query);
}
@@ -368,24 +368,24 @@ caps_close(void)
}
static EntityCapabilities*
_caps_by_ver(const char *const ver)
_caps_by_ver(const char* const ver)
{
if (!g_key_file_has_group(cache, ver)) {
return NULL;
}
char *category = g_key_file_get_string(cache, ver, "category", NULL);
char *type = g_key_file_get_string(cache, ver, "type", NULL);
char *name = g_key_file_get_string(cache, ver, "name", NULL);
char* category = g_key_file_get_string(cache, ver, "category", NULL);
char* type = g_key_file_get_string(cache, ver, "type", NULL);
char* name = g_key_file_get_string(cache, ver, "name", NULL);
char *software = g_key_file_get_string(cache, ver, "software", NULL);
char *software_version = g_key_file_get_string(cache, ver, "software_version", NULL);
char *os = g_key_file_get_string(cache, ver, "os", NULL);
char *os_version = g_key_file_get_string(cache, ver, "os_version", NULL);
char* software = g_key_file_get_string(cache, ver, "software", NULL);
char* software_version = g_key_file_get_string(cache, ver, "software_version", NULL);
char* os = g_key_file_get_string(cache, ver, "os", NULL);
char* os_version = g_key_file_get_string(cache, ver, "os_version", NULL);
gsize features_len = 0;
gchar **features_list = g_key_file_get_string_list(cache, ver, "features", &features_len, NULL);
GSList *features = NULL;
gchar** features_list = g_key_file_get_string_list(cache, ver, "features", &features_len, NULL);
GSList* features = NULL;
if (features_list && features_len > 0) {
int i;
for (i = 0; i < features_len; i++) {
@@ -393,7 +393,7 @@ _caps_by_ver(const char *const ver)
}
}
EntityCapabilities *result = caps_create(
EntityCapabilities* result = caps_create(
category, type, name,
software, software_version, os, os_version,
features);
@@ -414,32 +414,32 @@ _caps_by_ver(const char *const ver)
}
static EntityCapabilities*
_caps_by_jid(const char *const jid)
_caps_by_jid(const char* const jid)
{
return g_hash_table_lookup(jid_to_caps, jid);
}
static EntityCapabilities*
_caps_copy(EntityCapabilities *caps)
_caps_copy(EntityCapabilities* caps)
{
if (!caps) {
return NULL;
}
const char *const categoty = caps->identity ? caps->identity->category : NULL;
const char *const type = caps->identity ? caps->identity->type : NULL;
const char *const name = caps->identity ? caps->identity->name : NULL;
const char* const categoty = caps->identity ? caps->identity->category : NULL;
const char* const type = caps->identity ? caps->identity->type : NULL;
const char* const name = caps->identity ? caps->identity->name : NULL;
const char *const software = caps->software_version ? caps->software_version->software : NULL;
const char *const software_version = caps->software_version ? caps->software_version->software_version : NULL;
const char *const os = caps->software_version ? caps->software_version->os : NULL;
const char *const os_version = caps->software_version ? caps->software_version->os_version : NULL;
const char* const software = caps->software_version ? caps->software_version->software : NULL;
const char* const software_version = caps->software_version ? caps->software_version->software_version : NULL;
const char* const os = caps->software_version ? caps->software_version->os : NULL;
const char* const os_version = caps->software_version ? caps->software_version->os_version : NULL;
return caps_create(categoty, type, name, software, software_version, os, os_version, caps->features);
}
static void
_disco_identity_destroy(DiscoIdentity *disco_identity)
_disco_identity_destroy(DiscoIdentity* disco_identity)
{
if (disco_identity) {
free(disco_identity->category);
@@ -450,7 +450,7 @@ _disco_identity_destroy(DiscoIdentity *disco_identity)
}
static void
_software_version_destroy(SoftwareVersion *software_version)
_software_version_destroy(SoftwareVersion* software_version)
{
if (software_version) {
free(software_version->software);
@@ -462,7 +462,7 @@ _software_version_destroy(SoftwareVersion *software_version)
}
void
caps_destroy(EntityCapabilities *caps)
caps_destroy(EntityCapabilities* caps)
{
if (caps) {
_disco_identity_destroy(caps->identity);
@@ -478,7 +478,7 @@ static void
_save_cache(void)
{
gsize g_data_size;
gchar *g_cache_data = g_key_file_to_data(cache, &g_data_size, NULL);
gchar* g_cache_data = g_key_file_to_data(cache, &g_data_size, NULL);
g_file_set_contents(cache_loc, g_cache_data, g_data_size, NULL);
g_chmod(cache_loc, S_IRUSR | S_IWUSR);
g_free(g_cache_data);

18
src/xmpp/capabilities.h
View File

@@ -50,15 +50,15 @@
void caps_init(void);
EntityCapabilities* caps_create(const char *const category, const char *const type, const char *const name,
const char *const software, const char *const software_version,
const char *const os, const char *const os_version,
GSList *features);
void caps_add_by_ver(const char *const ver, EntityCapabilities *caps);
void caps_add_by_jid(const char *const jid, EntityCapabilities *caps);
void caps_map_jid_to_ver(const char *const jid, const char *const ver);
gboolean caps_cache_contains(const char *const ver);
EntityCapabilities* caps_create(const char* const category, const char* const type, const char* const name,
const char* const software, const char* const software_version,
const char* const os, const char* const os_version,
GSList* features);
void caps_add_by_ver(const char* const ver, EntityCapabilities* caps);
void caps_add_by_jid(const char* const jid, EntityCapabilities* caps);
void caps_map_jid_to_ver(const char* const jid, const char* const ver);
gboolean caps_cache_contains(const char* const ver);
GList* caps_get_features(void);
char* caps_get_my_sha1(xmpp_ctx_t *const ctx);
char* caps_get_my_sha1(xmpp_ctx_t* const ctx);
#endif

58
src/xmpp/chat_session.c
View File

@@ -33,28 +33,28 @@
*
*/
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <glib.h>
#include "log.h"
#include "config/preferences.h"
#include "xmpp/xmpp.h"
#include "xmpp/stanza.h"
#include "log.h"
#include "xmpp/chat_session.h"
#include "xmpp/stanza.h"
#include "xmpp/xmpp.h"
static GHashTable *sessions;
static GHashTable* sessions;
static void
_chat_session_new(const char *const barejid, const char *const resource, gboolean resource_override,
gboolean send_states)
_chat_session_new(const char* const barejid, const char* const resource, gboolean resource_override,
gboolean send_states)
{
assert(barejid != NULL);
assert(resource != NULL);
ChatSession *new_session = malloc(sizeof(struct chat_session_t));
ChatSession* new_session = malloc(sizeof(struct chat_session_t));
new_session->barejid = strdup(barejid);
new_session->resource = strdup(resource);
new_session->resource_override = resource_override;
@@ -64,7 +64,7 @@ _chat_session_new(const char *const barejid, const char *const resource, gboolea
}
static void
_chat_session_free(ChatSession *session)
_chat_session_free(ChatSession* session)
{
if (session) {
free(session->barejid);
@@ -91,24 +91,24 @@ chat_sessions_clear(void)
}
void
chat_session_resource_override(const char *const barejid, const char *const resource)
chat_session_resource_override(const char* const barejid, const char* const resource)
{
_chat_session_new(barejid, resource, TRUE, TRUE);
}
ChatSession*
chat_session_get(const char *const barejid)
chat_session_get(const char* const barejid)
{
return g_hash_table_lookup(sessions, barejid);
}
char*
chat_session_get_jid(const char *const barejid)
chat_session_get_jid(const char* const barejid)
{
ChatSession *session = chat_session_get(barejid);
char *jid = NULL;
ChatSession* session = chat_session_get(barejid);
char* jid = NULL;
if (session) {
Jid *jidp = jid_create_from_bare_and_resource(session->barejid, session->resource);
Jid* jidp = jid_create_from_bare_and_resource(session->barejid, session->resource);
jid = strdup(jidp->fulljid);
jid_destroy(jidp);
} else {
@@ -119,10 +119,10 @@ chat_session_get_jid(const char *const barejid)
}
char*
chat_session_get_state(const char *const barejid)
chat_session_get_state(const char* const barejid)
{
ChatSession *session = chat_session_get(barejid);
char *state = NULL;
ChatSession* session = chat_session_get(barejid);
char* state = NULL;
if (session) {
if (prefs_get_boolean(PREF_STATES) && session->send_states) {
state = STANZA_NAME_ACTIVE;
@@ -137,12 +137,12 @@ chat_session_get_state(const char *const barejid)
}
void
chat_session_recipient_gone(const char *const barejid, const char *const resource)
chat_session_recipient_gone(const char* const barejid, const char* const resource)
{
assert(barejid != NULL);
assert(resource != NULL);
ChatSession *session = g_hash_table_lookup(sessions, barejid);
ChatSession* session = g_hash_table_lookup(sessions, barejid);
if (session && g_strcmp0(session->resource, resource) == 0) {
if (!session->resource_override) {
chat_session_remove(barejid);
@@ -151,48 +151,48 @@ chat_session_recipient_gone(const char *const barejid, const char *const resourc
}
void
chat_session_recipient_typing(const char *const barejid, const char *const resource)
chat_session_recipient_typing(const char* const barejid, const char* const resource)
{
chat_session_recipient_active(barejid, resource, TRUE);
}
void
chat_session_recipient_paused(const char *const barejid, const char *const resource)
chat_session_recipient_paused(const char* const barejid, const char* const resource)
{
chat_session_recipient_active(barejid, resource, TRUE);
}
void
chat_session_recipient_inactive(const char *const barejid, const char *const resource)
chat_session_recipient_inactive(const char* const barejid, const char* const resource)
{
chat_session_recipient_active(barejid, resource, TRUE);
}
void
chat_session_recipient_active(const char *const barejid, const char *const resource,
gboolean send_states)
chat_session_recipient_active(const char* const barejid, const char* const resource,
gboolean send_states)
{
assert(barejid != NULL);
assert(resource != NULL);
ChatSession *session = g_hash_table_lookup(sessions, barejid);
ChatSession* session = g_hash_table_lookup(sessions, barejid);
if (session) {
// session exists with resource, update chat_states
if (g_strcmp0(session->resource, resource) == 0) {
session->send_states = send_states;
// session exists with different resource and no override, replace
// session exists with different resource and no override, replace
} else if (!session->resource_override) {
_chat_session_new(barejid, resource, FALSE, send_states);
}
// no session, create one
// no session, create one
} else {
_chat_session_new(barejid, resource, FALSE, send_states);
}
}
void
chat_session_remove(const char *const barejid)
chat_session_remove(const char* const barejid)
{
g_hash_table_remove(sessions, barejid);
}

27
src/xmpp/chat_session.h
View File

@@ -38,9 +38,10 @@
#include <glib.h>
typedef struct chat_session_t {
char *barejid;
char *resource;
typedef struct chat_session_t
{
char* barejid;
char* resource;
gboolean resource_override;
gboolean send_states;
@@ -49,17 +50,17 @@ typedef struct chat_session_t {
void chat_sessions_init(void);
void chat_sessions_clear(void);
void chat_session_resource_override(const char *const barejid, const char *const resource);
ChatSession* chat_session_get(const char *const barejid);
void chat_session_resource_override(const char* const barejid, const char* const resource);
ChatSession* chat_session_get(const char* const barejid);
void chat_session_recipient_active(const char *const barejid, const char *const resource, gboolean send_states);
void chat_session_recipient_typing(const char *const barejid, const char *const resource);
void chat_session_recipient_paused(const char *const barejid, const char *const resource);
void chat_session_recipient_gone(const char *const barejid, const char *const resource);
void chat_session_recipient_inactive(const char *const barejid, const char *const resource);
char* chat_session_get_jid(const char *const barejid);
char* chat_session_get_state(const char *const barejid);
void chat_session_recipient_active(const char* const barejid, const char* const resource, gboolean send_states);
void chat_session_recipient_typing(const char* const barejid, const char* const resource);
void chat_session_recipient_paused(const char* const barejid, const char* const resource);
void chat_session_recipient_gone(const char* const barejid, const char* const resource);
void chat_session_recipient_inactive(const char* const barejid, const char* const resource);
char* chat_session_get_jid(const char* const barejid);
char* chat_session_get_state(const char* const barejid);
void chat_session_remove(const char *const barejid);
void chat_session_remove(const char* const barejid);
#endif

47
src/xmpp/chat_state.c
View File

@@ -33,27 +33,27 @@
*
*/
#include <stdlib.h>
#include <assert.h>
#include <stdlib.h>
#include <glib.h>
#include "config/preferences.h"
#include "ui/window_list.h"
#include "ui/win_types.h"
#include "xmpp/xmpp.h"
#include "xmpp/chat_state.h"
#include "ui/window_list.h"
#include "xmpp/chat_session.h"
#include "xmpp/chat_state.h"
#include "xmpp/xmpp.h"
#define PAUSED_TIMEOUT 10.0
#define PAUSED_TIMEOUT 10.0
#define INACTIVE_TIMEOUT 30.0
static void _send_if_supported(const char *const barejid, void (*send_func)(const char *const));
static void _send_if_supported(const char* const barejid, void (*send_func)(const char* const));
ChatState*
chat_state_new(void)
{
ChatState *new_state = malloc(sizeof(struct prof_chat_state_t));
ChatState* new_state = malloc(sizeof(struct prof_chat_state_t));
new_state->type = CHAT_STATE_GONE;
new_state->timer = g_timer_new();
@@ -61,16 +61,16 @@ chat_state_new(void)
}
void
chat_state_free(ChatState *state)
chat_state_free(ChatState* state)
{
if (state && state->timer!= NULL) {
if (state && state->timer != NULL) {
g_timer_destroy(state->timer);
}
free(state);
}
void
chat_state_handle_idle(const char *const barejid, ChatState *state)
chat_state_handle_idle(const char* const barejid, ChatState* state)
{
gdouble elapsed = g_timer_elapsed(state->timer, NULL);
@@ -92,13 +92,12 @@ chat_state_handle_idle(const char *const barejid, ChatState *state)
_send_if_supported(barejid, message_send_inactive);
}
return;
}
// INACTIVE -> GONE
if (state->type == CHAT_STATE_INACTIVE) {
if (prefs_get_gone() != 0 && (elapsed > (prefs_get_gone() * 60.0))) {
ChatSession *session = chat_session_get(barejid);
ChatSession* session = chat_session_get(barejid);
if (session) {
// never move to GONE when resource override
if (!session->resource_override) {
@@ -122,7 +121,7 @@ chat_state_handle_idle(const char *const barejid, ChatState *state)
}
void
chat_state_handle_typing(const char *const barejid, ChatState *state)
chat_state_handle_typing(const char* const barejid, ChatState* state)
{
// ACTIVE|INACTIVE|PAUSED|GONE -> COMPOSING
if (state->type != CHAT_STATE_COMPOSING) {
@@ -135,14 +134,14 @@ chat_state_handle_typing(const char *const barejid, ChatState *state)
}
void
chat_state_active(ChatState *state)
chat_state_active(ChatState* state)
{
state->type = CHAT_STATE_ACTIVE;
g_timer_start(state->timer);
}
void
chat_state_gone(const char *const barejid, ChatState *state)
chat_state_gone(const char* const barejid, ChatState* state)
{
if (state->type != CHAT_STATE_GONE) {
if (prefs_get_boolean(PREF_STATES)) {
@@ -158,12 +157,12 @@ chat_state_idle(void)
{
jabber_conn_status_t status = connection_get_status();
if (status == JABBER_CONNECTED) {
GSList *recipients = wins_get_chat_recipients();
GSList *curr = recipients;
GSList* recipients = wins_get_chat_recipients();
GSList* curr = recipients;
while (curr) {
char *barejid = curr->data;
ProfChatWin *chatwin = wins_get_chat(barejid);
char* barejid = curr->data;
ProfChatWin* chatwin = wins_get_chat(barejid);
chat_state_handle_idle(chatwin->barejid, chatwin->state);
curr = g_slist_next(curr);
}
@@ -178,21 +177,21 @@ void
chat_state_activity(void)
{
jabber_conn_status_t status = connection_get_status();
ProfWin *current = wins_get_current();
ProfWin* current = wins_get_current();
if ((status == JABBER_CONNECTED) && (current->type == WIN_CHAT)) {
ProfChatWin *chatwin = (ProfChatWin*)current;
ProfChatWin* chatwin = (ProfChatWin*)current;
assert(chatwin->memcheck == PROFCHATWIN_MEMCHECK);
chat_state_handle_typing(chatwin->barejid, chatwin->state);
}
}
static void
_send_if_supported(const char *const barejid, void (*send_func)(const char *const))
_send_if_supported(const char* const barejid, void (*send_func)(const char* const))
{
gboolean send = TRUE;
GString *jid = g_string_new(barejid);
ChatSession *session = chat_session_get(barejid);
GString* jid = g_string_new(barejid);
ChatSession* session = chat_session_get(barejid);
if (session) {
if (session->send_states) {
g_string_append(jid, "/");

15
src/xmpp/chat_state.h
View File

@@ -46,20 +46,21 @@ typedef enum {
CHAT_STATE_GONE
} chat_state_type_t;
typedef struct prof_chat_state_t {
typedef struct prof_chat_state_t
{
chat_state_type_t type;
GTimer *timer;
GTimer* timer;
} ChatState;
ChatState* chat_state_new(void);
void chat_state_free(ChatState *state);
void chat_state_free(ChatState* state);
void chat_state_idle(void);
void chat_state_activity(void);
void chat_state_handle_idle(const char *const barejid, ChatState *state);
void chat_state_handle_typing(const char *const barejid, ChatState *state);
void chat_state_active(ChatState *state);
void chat_state_gone(const char *const barejid, ChatState *state);
void chat_state_handle_idle(const char* const barejid, ChatState* state);
void chat_state_handle_typing(const char* const barejid, ChatState* state);
void chat_state_active(ChatState* state);
void chat_state_gone(const char* const barejid, ChatState* state);
#endif

212
src/xmpp/connection.c
View File

@@ -36,9 +36,9 @@
#include "config.h"
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <glib.h>
#include <glib/gstdio.h>
@@ -52,48 +52,49 @@
#endif
#include "common.h"
#include "log.h"
#include "config/files.h"
#include "config/preferences.h"
#include "event/server_events.h"
#include "xmpp/connection.h"
#include "xmpp/session.h"
#include "xmpp/iq.h"
#include "log.h"
#include "ui/ui.h"
#include "xmpp/connection.h"
#include "xmpp/iq.h"
#include "xmpp/session.h"
typedef struct prof_conn_t {
xmpp_log_t *xmpp_log;
xmpp_ctx_t *xmpp_ctx;
xmpp_conn_t *xmpp_conn;
typedef struct prof_conn_t
{
xmpp_log_t* xmpp_log;
xmpp_ctx_t* xmpp_ctx;
xmpp_conn_t* xmpp_conn;
gboolean xmpp_in_event_loop;
jabber_conn_status_t conn_status;
xmpp_conn_event_t conn_last_event;
char *presence_message;
char* presence_message;
int priority;
char *domain;
GHashTable *available_resources;
GHashTable *features_by_jid;
GHashTable *requested_features;
char* domain;
GHashTable* available_resources;
GHashTable* features_by_jid;
GHashTable* requested_features;
} ProfConnection;
static ProfConnection conn;
static gchar *profanity_instance_id = NULL;
static gchar *prof_identifier = NULL;
static gchar* profanity_instance_id = NULL;
static gchar* prof_identifier = NULL;
static xmpp_log_t* _xmpp_get_file_logger(void);
static void _xmpp_file_logger(void *const userdata, const xmpp_log_level_t level, const char *const area, const char *const msg);
static void _xmpp_file_logger(void* const userdata, const xmpp_log_level_t level, const char* const area, const char* const msg);
static void _connection_handler(xmpp_conn_t *const xmpp_conn, const xmpp_conn_event_t status, const int error,
xmpp_stream_error_t *const stream_error, void *const userdata);
static void _connection_handler(xmpp_conn_t* const xmpp_conn, const xmpp_conn_event_t status, const int error,
xmpp_stream_error_t* const stream_error, void* const userdata);
#ifdef HAVE_LIBMESODE
TLSCertificate* _xmppcert_to_profcert(xmpp_tlscert_t *xmpptlscert);
static int _connection_certfail_cb(xmpp_tlscert_t *xmpptlscert, const char *const errormsg);
TLSCertificate* _xmppcert_to_profcert(xmpp_tlscert_t* xmpptlscert);
static int _connection_certfail_cb(xmpp_tlscert_t* xmpptlscert, const char* const errormsg);
#endif
static void _random_bytes_init(void);
static void _random_bytes_close(void);
static void _compute_identifier(const char *barejid);
static void _compute_identifier(const char* barejid);
void
connection_init(void)
@@ -110,7 +111,7 @@ connection_init(void)
conn.available_resources = g_hash_table_new_full(g_str_hash, g_str_equal, free, (GDestroyNotify)resource_destroy);
conn.requested_features = g_hash_table_new_full(g_str_hash, g_str_equal, free, NULL);
_random_bytes_init();
_random_bytes_init();
}
void
@@ -130,19 +131,19 @@ connection_shutdown(void)
free(conn.xmpp_log);
conn.xmpp_log = NULL;
_random_bytes_close();
_random_bytes_close();
}
jabber_conn_status_t
connection_connect(const char *const jid, const char *const passwd, const char *const altdomain, int port,
const char *const tls_policy, const char *const auth_policy)
connection_connect(const char* const jid, const char* const passwd, const char* const altdomain, int port,
const char* const tls_policy, const char* const auth_policy)
{
long flags;
assert(jid != NULL);
assert(passwd != NULL);
Jid *jidp = jid_create(jid);
Jid* jidp = jid_create(jid);
if (jidp == NULL) {
log_error("Malformed JID not able to connect: %s", jid);
conn.conn_status = JABBER_DISCONNECTED;
@@ -206,7 +207,10 @@ connection_connect(const char *const jid, const char *const passwd, const char *
/* Print debug logs that can help when users share the logs */
if (flags != 0) {
log_debug("Connecting with flags (0x%lx):", flags);
#define LOG_FLAG_IF_SET(name) if (flags & name) { log_debug(" " #name); }
#define LOG_FLAG_IF_SET(name) \
if (flags & name) { \
log_debug(" " #name); \
}
LOG_FLAG_IF_SET(XMPP_CONN_FLAG_MANDATORY_TLS);
LOG_FLAG_IF_SET(XMPP_CONN_FLAG_TRUST_TLS);
LOG_FLAG_IF_SET(XMPP_CONN_FLAG_DISABLE_TLS);
@@ -218,7 +222,7 @@ connection_connect(const char *const jid, const char *const passwd, const char *
}
#ifdef HAVE_LIBMESODE
char *cert_path = prefs_get_tls_certpath();
char* cert_path = prefs_get_tls_certpath();
if (cert_path) {
xmpp_conn_tlscert_path(conn.xmpp_conn, cert_path);
free(cert_path);
@@ -311,8 +315,8 @@ connection_clear_data(void)
TLSCertificate*
connection_get_tls_peer_cert(void)
{
xmpp_tlscert_t *xmpptlscert = xmpp_conn_tls_peer_cert(conn.xmpp_conn);
TLSCertificate *cert = _xmppcert_to_profcert(xmpptlscert);
xmpp_tlscert_t* xmpptlscert = xmpp_conn_tls_peer_cert(conn.xmpp_conn);
TLSCertificate* cert = _xmppcert_to_profcert(xmpptlscert);
xmpp_conn_free_tlscert(conn.xmpp_ctx, xmpptlscert);
return cert;
@@ -330,7 +334,7 @@ connection_is_secured(void)
}
gboolean
connection_send_stanza(const char *const stanza)
connection_send_stanza(const char* const stanza)
{
if (conn.conn_status != JABBER_CONNECTED) {
return FALSE;
@@ -341,15 +345,15 @@ connection_send_stanza(const char *const stanza)
}
gboolean
connection_supports(const char *const feature)
connection_supports(const char* const feature)
{
gboolean ret = FALSE;
GList *jids = g_hash_table_get_keys(conn.features_by_jid);
GList* jids = g_hash_table_get_keys(conn.features_by_jid);
GList *curr = jids;
GList* curr = jids;
while (curr) {
char *jid = curr->data;
GHashTable *features = g_hash_table_lookup(conn.features_by_jid, jid);
char* jid = curr->data;
GHashTable* features = g_hash_table_lookup(conn.features_by_jid, jid);
if (features && g_hash_table_lookup(features, feature)) {
ret = TRUE;
break;
@@ -364,18 +368,18 @@ connection_supports(const char *const feature)
}
char*
connection_jid_for_feature(const char *const feature)
connection_jid_for_feature(const char* const feature)
{
if (conn.features_by_jid == NULL) {
return NULL;
}
GList *jids = g_hash_table_get_keys(conn.features_by_jid);
GList* jids = g_hash_table_get_keys(conn.features_by_jid);
GList *curr = jids;
GList* curr = jids;
while (curr) {
char *jid = curr->data;
GHashTable *features = g_hash_table_lookup(conn.features_by_jid, jid);
char* jid = curr->data;
GHashTable* features = g_hash_table_lookup(conn.features_by_jid, jid);
if (features && g_hash_table_lookup(features, feature)) {
g_list_free(jids);
return jid;
@@ -398,14 +402,14 @@ connection_request_features(void)
}
void
connection_set_disco_items(GSList *items)
connection_set_disco_items(GSList* items)
{
GSList *curr = items;
GSList* curr = items;
while (curr) {
DiscoItem *item = curr->data;
DiscoItem* item = curr->data;
g_hash_table_insert(conn.requested_features, strdup(item->jid), NULL);
g_hash_table_insert(conn.features_by_jid, strdup(item->jid),
g_hash_table_new_full(g_str_hash, g_str_equal, free, NULL));
g_hash_table_new_full(g_str_hash, g_str_equal, free, NULL));
iq_disco_info_request_onconnect(item->jid);
@@ -434,7 +438,7 @@ connection_get_ctx(void)
const char*
connection_get_fulljid(void)
{
const char *jid = xmpp_conn_get_bound_jid(conn.xmpp_conn);
const char* jid = xmpp_conn_get_bound_jid(conn.xmpp_conn);
if (jid) {
return jid;
} else {
@@ -443,11 +447,12 @@ connection_get_fulljid(void)
}
char*
connection_get_barejid(void) {
const char *jid = connection_get_fulljid();
char *result;
connection_get_barejid(void)
{
const char* jid = connection_get_fulljid();
char* result;
Jid *jidp = jid_create(jid);
Jid* jidp = jid_create(jid);
result = strdup(jidp->barejid);
jid_destroy(jidp);
@@ -455,7 +460,7 @@ connection_get_barejid(void) {
}
void
connection_features_received(const char *const jid)
connection_features_received(const char* const jid)
{
if (g_hash_table_remove(conn.requested_features, jid) && g_hash_table_size(conn.requested_features) == 0) {
sv_ev_connection_features_received();
@@ -463,7 +468,7 @@ connection_features_received(const char *const jid)
}
GHashTable*
connection_get_features(const char *const jid)
connection_get_features(const char* const jid)
{
return g_hash_table_lookup(conn.features_by_jid, jid);
}
@@ -475,13 +480,13 @@ connection_get_available_resources(void)
}
void
connection_add_available_resource(Resource *resource)
connection_add_available_resource(Resource* resource)
{
g_hash_table_replace(conn.available_resources, strdup(resource->name), resource);
}
void
connection_remove_available_resource(const char *const resource)
connection_remove_available_resource(const char* const resource)
{
g_hash_table_remove(conn.available_resources, resource);
}
@@ -493,7 +498,7 @@ connection_create_uuid(void)
}
void
connection_free_uuid(char *uuid)
connection_free_uuid(char* uuid)
{
if (uuid) {
xmpp_free(conn.xmpp_ctx, uuid);
@@ -503,21 +508,21 @@ connection_free_uuid(char *uuid)
char*
connection_create_stanza_id(void)
{
char *uuid = connection_create_uuid();
char* uuid = connection_create_uuid();
assert(uuid != NULL);
gchar *hmac = g_compute_hmac_for_string(G_CHECKSUM_SHA256,
(guchar*)prof_identifier, strlen(prof_identifier),
uuid, strlen(uuid));
gchar* hmac = g_compute_hmac_for_string(G_CHECKSUM_SHA256,
(guchar*)prof_identifier, strlen(prof_identifier),
uuid, strlen(uuid));
GString *signature = g_string_new("");
GString* signature = g_string_new("");
g_string_printf(signature, "%s%s", uuid, hmac);
free(uuid);
g_free(hmac);
char *b64 = g_base64_encode((unsigned char*)signature->str, signature->len);
char* b64 = g_base64_encode((unsigned char*)signature->str, signature->len);
g_string_free(signature, TRUE);
assert(b64 != NULL);
@@ -538,7 +543,7 @@ connection_get_presence_msg(void)
}
void
connection_set_presence_msg(const char *const message)
connection_set_presence_msg(const char* const message)
{
FREE_SET_NULL(conn.presence_message);
if (message) {
@@ -553,8 +558,8 @@ connection_set_priority(const int priority)
}
static void
_connection_handler(xmpp_conn_t *const xmpp_conn, const xmpp_conn_event_t status, const int error,
xmpp_stream_error_t *const stream_error, void *const userdata)
_connection_handler(xmpp_conn_t* const xmpp_conn, const xmpp_conn_event_t status, const int error,
xmpp_stream_error_t* const stream_error, void* const userdata)
{
conn.conn_last_event = status;
@@ -565,7 +570,7 @@ _connection_handler(xmpp_conn_t *const xmpp_conn, const xmpp_conn_event_t status
log_debug("Connection handler: XMPP_CONN_CONNECT");
conn.conn_status = JABBER_CONNECTED;
Jid *my_jid = jid_create(xmpp_conn_get_jid(conn.xmpp_conn));
Jid* my_jid = jid_create(xmpp_conn_get_jid(conn.xmpp_conn));
conn.domain = strdup(my_jid->domainpart);
jid_destroy(my_jid);
@@ -585,7 +590,7 @@ _connection_handler(xmpp_conn_t *const xmpp_conn, const xmpp_conn_event_t status
log_debug("Connection handler: Lost connection for unknown reason");
session_lost_connection();
// login attempt failed
// login attempt failed
} else if (conn.conn_status != JABBER_DISCONNECTING) {
log_debug("Connection handler: Login failed");
session_login_failed();
@@ -610,9 +615,9 @@ _connection_handler(xmpp_conn_t *const xmpp_conn, const xmpp_conn_event_t status
#ifdef HAVE_LIBMESODE
static int
_connection_certfail_cb(xmpp_tlscert_t *xmpptlscert, const char *const errormsg)
_connection_certfail_cb(xmpp_tlscert_t* xmpptlscert, const char* const errormsg)
{
TLSCertificate *cert = _xmppcert_to_profcert(xmpptlscert);
TLSCertificate* cert = _xmppcert_to_profcert(xmpptlscert);
int res = sv_ev_certfail(errormsg, cert);
tlscerts_free(cert);
@@ -621,7 +626,7 @@ _connection_certfail_cb(xmpp_tlscert_t *xmpptlscert, const char *const errormsg)
}
TLSCertificate*
_xmppcert_to_profcert(xmpp_tlscert_t *xmpptlscert)
_xmppcert_to_profcert(xmpp_tlscert_t* xmpptlscert)
{
return tlscerts_new(
xmpp_conn_tlscert_fingerprint(xmpptlscert),
@@ -643,13 +648,21 @@ _xmpp_get_file_logger(void)
xmpp_log_level_t xmpp_level = XMPP_LEVEL_ERROR;
switch (prof_level) {
case PROF_LEVEL_DEBUG: xmpp_level = XMPP_LEVEL_DEBUG; break;
case PROF_LEVEL_INFO: xmpp_level = XMPP_LEVEL_INFO; break;
case PROF_LEVEL_WARN: xmpp_level = XMPP_LEVEL_WARN; break;
default: xmpp_level = XMPP_LEVEL_ERROR; break;
case PROF_LEVEL_DEBUG:
xmpp_level = XMPP_LEVEL_DEBUG;
break;
case PROF_LEVEL_INFO:
xmpp_level = XMPP_LEVEL_INFO;
break;
case PROF_LEVEL_WARN:
xmpp_level = XMPP_LEVEL_WARN;
break;
default:
xmpp_level = XMPP_LEVEL_ERROR;
break;
}
xmpp_log_t *file_log = malloc(sizeof(xmpp_log_t));
xmpp_log_t* file_log = malloc(sizeof(xmpp_log_t));
file_log->handler = _xmpp_file_logger;
file_log->userdata = &xmpp_level;
@@ -657,15 +670,23 @@ _xmpp_get_file_logger(void)
}
static void
_xmpp_file_logger(void *const userdata, const xmpp_log_level_t xmpp_level, const char *const area, const char *const msg)
_xmpp_file_logger(void* const userdata, const xmpp_log_level_t xmpp_level, const char* const area, const char* const msg)
{
log_level_t prof_level = PROF_LEVEL_ERROR;
switch (xmpp_level) {
case XMPP_LEVEL_DEBUG: prof_level = PROF_LEVEL_DEBUG; break;
case XMPP_LEVEL_INFO: prof_level = PROF_LEVEL_INFO; break;
case XMPP_LEVEL_WARN: prof_level = PROF_LEVEL_WARN; break;
default: prof_level = PROF_LEVEL_ERROR; break;
case XMPP_LEVEL_DEBUG:
prof_level = PROF_LEVEL_DEBUG;
break;
case XMPP_LEVEL_INFO:
prof_level = PROF_LEVEL_INFO;
break;
case XMPP_LEVEL_WARN:
prof_level = PROF_LEVEL_WARN;
break;
default:
prof_level = PROF_LEVEL_ERROR;
break;
}
log_msg(prof_level, area, msg);
@@ -675,10 +696,11 @@ _xmpp_file_logger(void *const userdata, const xmpp_log_level_t xmpp_level, const
}
}
static void _random_bytes_init(void)
static void
_random_bytes_init(void)
{
char *rndbytes_loc;
GKeyFile *rndbytes;
char* rndbytes_loc;
GKeyFile* rndbytes;
rndbytes_loc = files_get_data_path(FILE_PROFANITY_IDENTIFIER);
@@ -696,10 +718,10 @@ static void _random_bytes_init(void)
g_key_file_set_string(rndbytes, "identifier", "random_bytes", profanity_instance_id);
gsize g_data_size;
gchar *g_accounts_data = g_key_file_to_data(rndbytes, &g_data_size, NULL);
gchar* g_accounts_data = g_key_file_to_data(rndbytes, &g_data_size, NULL);
gchar *base = g_path_get_dirname(rndbytes_loc);
gchar *true_loc = get_file_or_linked(rndbytes_loc, base);
gchar* base = g_path_get_dirname(rndbytes_loc);
gchar* true_loc = get_file_or_linked(rndbytes_loc, base);
g_file_set_contents(true_loc, g_accounts_data, g_data_size, NULL);
g_free(base);
@@ -711,18 +733,20 @@ static void _random_bytes_init(void)
g_key_file_free(rndbytes);
}
static void _random_bytes_close(void)
static void
_random_bytes_close(void)
{
g_free(profanity_instance_id);
}
static void _compute_identifier(const char *barejid)
static void
_compute_identifier(const char* barejid)
{
gchar *hmac = g_compute_hmac_for_string(G_CHECKSUM_SHA256,
(guchar*)profanity_instance_id, strlen(profanity_instance_id),
barejid, strlen(barejid));
gchar* hmac = g_compute_hmac_for_string(G_CHECKSUM_SHA256,
(guchar*)profanity_instance_id, strlen(profanity_instance_id),
barejid, strlen(barejid));
char *b64 = g_base64_encode((guchar*)hmac, XMPP_SHA1_DIGEST_SIZE);
char* b64 = g_base64_encode((guchar*)hmac, XMPP_SHA1_DIGEST_SIZE);
assert(b64 != NULL);
g_free(hmac);
@@ -732,6 +756,8 @@ static void _compute_identifier(const char *barejid)
prof_identifier = b64;
}
const char* connection_get_profanity_identifier(void) {
const char*
connection_get_profanity_identifier(void)
{
return prof_identifier;
}

16
src/xmpp/connection.h
View File

@@ -42,26 +42,26 @@ void connection_init(void);
void connection_shutdown(void);
void connection_check_events(void);
jabber_conn_status_t connection_connect(const char *const fulljid, const char *const passwd, const char *const altdomain, int port,
const char *const tls_policy, const char *const auth_policy);
jabber_conn_status_t connection_connect(const char* const fulljid, const char* const passwd, const char* const altdomain, int port,
const char* const tls_policy, const char* const auth_policy);
void connection_disconnect(void);
void connection_set_disconnected(void);
void connection_set_priority(const int priority);
void connection_set_priority(int priority);
void connection_set_disco_items(GSList *items);
void connection_set_disco_items(GSList* items);
xmpp_conn_t* connection_get_conn(void);
xmpp_ctx_t* connection_get_ctx(void);
char *connection_get_domain(void);
char* connection_get_domain(void);
void connection_request_features(void);
void connection_features_received(const char *const jid);
GHashTable* connection_get_features(const char *const jid);
void connection_features_received(const char* const jid);
GHashTable* connection_get_features(const char* const jid);
void connection_clear_data(void);
void connection_add_available_resource(Resource *resource);
void connection_remove_available_resource(const char *const resource);
void connection_add_available_resource(Resource* resource);
void connection_remove_available_resource(const char* const resource);
char* connection_create_stanza_id(void);

86
src/xmpp/contact.c
View File

@@ -41,27 +41,28 @@
#include "common.h"
#include "tools/autocomplete.h"
#include "xmpp/resource.h"
#include "xmpp/contact.h"
#include "xmpp/resource.h"
struct p_contact_t {
char *barejid;
gchar *barejid_collate_key;
char *name;
gchar *name_collate_key;
GSList *groups;
char *subscription;
char *offline_message;
struct p_contact_t
{
char* barejid;
gchar* barejid_collate_key;
char* name;
gchar* name_collate_key;
GSList* groups;
char* subscription;
char* offline_message;
gboolean pending_out;
GDateTime *last_activity;
GHashTable *available_resources;
GDateTime* last_activity;
GHashTable* available_resources;
Autocomplete resource_ac;
};
PContact
p_contact_new(const char *const barejid, const char *const name,
GSList *groups, const char *const subscription,
const char *const offline_message, gboolean pending_out)
p_contact_new(const char* const barejid, const char* const name,
GSList* groups, const char* const subscription,
const char* const offline_message, gboolean pending_out)
{
PContact contact = malloc(sizeof(struct p_contact_t));
contact->barejid = strdup(barejid);
@@ -91,7 +92,7 @@ p_contact_new(const char *const barejid, const char *const name,
contact->last_activity = NULL;
contact->available_resources = g_hash_table_new_full(g_str_hash, g_str_equal, free,
(GDestroyNotify)resource_destroy);
(GDestroyNotify)resource_destroy);
contact->resource_ac = autocomplete_new();
@@ -99,7 +100,7 @@ p_contact_new(const char *const barejid, const char *const name,
}
void
p_contact_set_name(const PContact contact, const char *const name)
p_contact_set_name(const PContact contact, const char* const name)
{
FREE_SET_NULL(contact->name);
FREE_SET_NULL(contact->name_collate_key);
@@ -110,7 +111,7 @@ p_contact_set_name(const PContact contact, const char *const name)
}
void
p_contact_set_groups(const PContact contact, GSList *groups)
p_contact_set_groups(const PContact contact, GSList* groups)
{
if (contact->groups) {
g_slist_free_full(contact->groups, g_free);
@@ -121,9 +122,9 @@ p_contact_set_groups(const PContact contact, GSList *groups)
}
gboolean
p_contact_in_group(const PContact contact, const char *const group)
p_contact_in_group(const PContact contact, const char* const group)
{
GSList *groups = contact->groups;
GSList* groups = contact->groups;
while (groups) {
if (strcmp(groups->data, group) == 0) {
return TRUE;
@@ -141,7 +142,7 @@ p_contact_groups(const PContact contact)
}
gboolean
p_contact_remove_resource(PContact contact, const char *const resource)
p_contact_remove_resource(PContact contact, const char* const resource)
{
gboolean result = g_hash_table_remove(contact->available_resources, resource);
autocomplete_remove(contact->resource_ac, resource);
@@ -209,12 +210,12 @@ p_contact_name_or_jid(const PContact contact)
}
char*
p_contact_create_display_string(const PContact contact, const char *const resource)
p_contact_create_display_string(const PContact contact, const char* const resource)
{
GString *result_str = g_string_new("");
GString* result_str = g_string_new("");
// use nickname if exists
const char *display_name = p_contact_name_or_jid(contact);
const char* display_name = p_contact_name_or_jid(contact);
g_string_append(result_str, display_name);
// add resource if not default provided by profanity
@@ -224,14 +225,14 @@ p_contact_create_display_string(const PContact contact, const char *const resour
g_string_append(result_str, ")");
}
char *result = result_str->str;
char* result = result_str->str;
g_string_free(result_str, FALSE);
return result;
}
static Resource*
_highest_presence(Resource *first, Resource *second)
_highest_presence(Resource* first, Resource* second)
{
if (first->presence == RESOURCE_CHAT) {
return first;
@@ -264,10 +265,10 @@ _get_most_available_resource(PContact contact)
// away
// xa
// dnd
GList *resources = g_hash_table_get_values(contact->available_resources);
GList *curr = resources;
Resource *current = curr->data;
Resource *highest = current;
GList* resources = g_hash_table_get_values(contact->available_resources);
GList* curr = resources;
Resource* current = curr->data;
Resource* highest = current;
curr = g_list_next(curr);
while (curr) {
current = curr->data;
@@ -276,7 +277,7 @@ _get_most_available_resource(PContact contact)
if (current->priority == highest->priority) {
highest = _highest_presence(highest, current);
// priority higher than current highest, set new presence
// priority higher than current highest, set new presence
} else if (current->priority > highest->priority) {
highest = current;
}
@@ -298,7 +299,7 @@ p_contact_presence(const PContact contact)
return "offline";
}
Resource *resource = _get_most_available_resource(contact);
Resource* resource = _get_most_available_resource(contact);
return string_from_resource_presence(resource->presence);
}
@@ -313,7 +314,7 @@ p_contact_status(const PContact contact)
return contact->offline_message;
}
Resource *resource = _get_most_available_resource(contact);
Resource* resource = _get_most_available_resource(contact);
return resource->status;
}
@@ -339,7 +340,7 @@ p_contact_subscribed(const PContact contact)
}
Resource*
p_contact_get_resource(const PContact contact, const char *const resource)
p_contact_get_resource(const PContact contact, const char* const resource)
{
return g_hash_table_lookup(contact->available_resources, resource);
}
@@ -360,12 +361,12 @@ GList*
p_contact_get_available_resources(const PContact contact)
{
assert(contact != NULL);
GList *resources = g_hash_table_get_values(contact->available_resources);
GList *ordered = NULL;
GList* resources = g_hash_table_get_values(contact->available_resources);
GList* ordered = NULL;
GList *curr_resource = resources;
GList* curr_resource = resources;
while (curr_resource) {
Resource *resource = curr_resource->data;
Resource* resource = curr_resource->data;
ordered = g_list_insert_sorted(ordered, resource, (GCompareFunc)resource_compare_availability);
curr_resource = g_list_next(curr_resource);
}
@@ -384,9 +385,8 @@ p_contact_is_available(const PContact contact)
}
// if most available resource is CHAT or ONLINE, available
Resource *most_available = _get_most_available_resource(contact);
if ((most_available->presence == RESOURCE_ONLINE) ||
(most_available->presence == RESOURCE_CHAT)) {
Resource* most_available = _get_most_available_resource(contact);
if ((most_available->presence == RESOURCE_ONLINE) || (most_available->presence == RESOURCE_CHAT)) {
return TRUE;
} else {
return FALSE;
@@ -400,14 +400,14 @@ p_contact_has_available_resource(const PContact contact)
}
void
p_contact_set_presence(const PContact contact, Resource *resource)
p_contact_set_presence(const PContact contact, Resource* resource)
{
g_hash_table_replace(contact->available_resources, strdup(resource->name), resource);
autocomplete_add(contact->resource_ac, resource->name);
}
void
p_contact_set_subscription(const PContact contact, const char *const subscription)
p_contact_set_subscription(const PContact contact, const char* const subscription)
{
FREE_SET_NULL(contact->subscription);
if (subscription) {
@@ -422,7 +422,7 @@ p_contact_set_pending_out(const PContact contact, gboolean pending_out)
}
void
p_contact_set_last_activity(const PContact contact, GDateTime *last_activity)
p_contact_set_last_activity(const PContact contact, GDateTime* last_activity)
{
if (contact->last_activity) {
g_date_time_unref(contact->last_activity);

28
src/xmpp/contact.h
View File

@@ -39,12 +39,12 @@
#include "tools/autocomplete.h"
#include "xmpp/resource.h"
typedef struct p_contact_t *PContact;
typedef struct p_contact_t* PContact;
PContact p_contact_new(const char *const barejid, const char *const name, GSList *groups,
const char *const subscription, const char *const offline_message, gboolean pending_out);
void p_contact_add_resource(PContact contact, Resource *resource);
gboolean p_contact_remove_resource(PContact contact, const char *const resource);
PContact p_contact_new(const char* const barejid, const char* const name, GSList* groups,
const char* const subscription, const char* const offline_message, gboolean pending_out);
void p_contact_add_resource(PContact contact, Resource* resource);
gboolean p_contact_remove_resource(PContact contact, const char* const resource);
void p_contact_free(PContact contact);
const char* p_contact_barejid(PContact contact);
const char* p_contact_barejid_collate_key(PContact contact);
@@ -57,20 +57,20 @@ const char* p_contact_subscription(const PContact contact);
GList* p_contact_get_available_resources(const PContact contact);
GDateTime* p_contact_last_activity(const PContact contact);
gboolean p_contact_pending_out(const PContact contact);
void p_contact_set_presence(const PContact contact, Resource *resource);
void p_contact_set_status(const PContact contact, const char *const status);
void p_contact_set_name(const PContact contact, const char *const name);
void p_contact_set_subscription(const PContact contact, const char *const subscription);
void p_contact_set_presence(const PContact contact, Resource* resource);
void p_contact_set_status(const PContact contact, const char* const status);
void p_contact_set_name(const PContact contact, const char* const name);
void p_contact_set_subscription(const PContact contact, const char* const subscription);
void p_contact_set_pending_out(const PContact contact, gboolean pending_out);
void p_contact_set_last_activity(const PContact contact, GDateTime *last_activity);
void p_contact_set_last_activity(const PContact contact, GDateTime* last_activity);
gboolean p_contact_is_available(const PContact contact);
gboolean p_contact_has_available_resource(const PContact contact);
Resource* p_contact_get_resource(const PContact contact, const char *const resource);
void p_contact_set_groups(const PContact contact, GSList *groups);
Resource* p_contact_get_resource(const PContact contact, const char* const resource);
void p_contact_set_groups(const PContact contact, GSList* groups);
GSList* p_contact_groups(const PContact contact);
gboolean p_contact_in_group(const PContact contact, const char *const group);
gboolean p_contact_in_group(const PContact contact, const char* const group);
gboolean p_contact_subscribed(const PContact contact);
char* p_contact_create_display_string(const PContact contact, const char *const resource);
char* p_contact_create_display_string(const PContact contact, const char* const resource);
Autocomplete p_contact_resource_ac(const PContact contact);
void p_contact_resource_ac_reset(const PContact contact);

303
src/xmpp/form.c
View File

@@ -35,8 +35,8 @@
#include "config.h"
#include <string.h>
#include <stdlib.h>
#include <string.h>
#ifdef HAVE_LIBMESODE
#include <mesode.h>
@@ -49,30 +49,27 @@
#include <glib.h>
#include "log.h"
#include "xmpp/xmpp.h"
#include "xmpp/stanza.h"
#include "xmpp/connection.h"
#include "xmpp/stanza.h"
#include "xmpp/xmpp.h"
static gboolean
_is_valid_form_element(xmpp_stanza_t *stanza)
_is_valid_form_element(xmpp_stanza_t* stanza)
{
const char *name = xmpp_stanza_get_name(stanza);
const char* name = xmpp_stanza_get_name(stanza);
if (g_strcmp0(name, STANZA_NAME_X) != 0) {
log_error("Error parsing form, root element not <x/>.");
return FALSE;
}
const char *ns = xmpp_stanza_get_ns(stanza);
const char* ns = xmpp_stanza_get_ns(stanza);
if (g_strcmp0(ns, STANZA_NS_DATA) != 0) {
log_error("Error parsing form, namespace not %s.", STANZA_NS_DATA);
return FALSE;
}
const char *type = xmpp_stanza_get_type(stanza);
if ((g_strcmp0(type, "form") != 0) &&
(g_strcmp0(type, "submit") != 0) &&
(g_strcmp0(type, "cancel") != 0) &&
(g_strcmp0(type, "result") != 0)) {
const char* type = xmpp_stanza_get_type(stanza);
if ((g_strcmp0(type, "form") != 0) && (g_strcmp0(type, "submit") != 0) && (g_strcmp0(type, "cancel") != 0) && (g_strcmp0(type, "result") != 0)) {
log_error("Error parsing form, unknown type.");
return FALSE;
}
@@ -83,7 +80,7 @@ _is_valid_form_element(xmpp_stanza_t *stanza)
static DataForm*
_form_new(void)
{
DataForm *form = calloc(1, sizeof(DataForm));
DataForm* form = calloc(1, sizeof(DataForm));
return form;
}
@@ -91,20 +88,20 @@ _form_new(void)
static FormField*
_field_new(void)
{
FormField *field = calloc(1, sizeof(FormField));
FormField* field = calloc(1, sizeof(FormField));
return field;
}
static char*
_get_property(xmpp_stanza_t *const stanza, const char *const property)
_get_property(xmpp_stanza_t* const stanza, const char* const property)
{
char *result = NULL;
xmpp_ctx_t *ctx = connection_get_ctx();
char* result = NULL;
xmpp_ctx_t* ctx = connection_get_ctx();
xmpp_stanza_t *child = xmpp_stanza_get_child_by_name(stanza, property);
xmpp_stanza_t* child = xmpp_stanza_get_child_by_name(stanza, property);
if (child) {
char *child_text = xmpp_stanza_get_text(child);
char* child_text = xmpp_stanza_get_text(child);
if (child_text) {
result = strdup(child_text);
xmpp_free(ctx, child_text);
@@ -115,9 +112,9 @@ _get_property(xmpp_stanza_t *const stanza, const char *const property)
}
static char*
_get_attr(xmpp_stanza_t *const stanza, const char *const attr)
_get_attr(xmpp_stanza_t* const stanza, const char* const attr)
{
const char *result = xmpp_stanza_get_attribute(stanza, attr);
const char* result = xmpp_stanza_get_attribute(stanza, attr);
if (result) {
return strdup(result);
} else {
@@ -126,9 +123,9 @@ _get_attr(xmpp_stanza_t *const stanza, const char *const attr)
}
static gboolean
_is_required(xmpp_stanza_t *const stanza)
_is_required(xmpp_stanza_t* const stanza)
{
xmpp_stanza_t *child = xmpp_stanza_get_child_by_name(stanza, "required");
xmpp_stanza_t* child = xmpp_stanza_get_child_by_name(stanza, "required");
if (child) {
return TRUE;
} else {
@@ -137,7 +134,7 @@ _is_required(xmpp_stanza_t *const stanza)
}
static form_field_type_t
_get_field_type(const char *const type)
_get_field_type(const char* const type)
{
if (g_strcmp0(type, "hidden") == 0) {
return FIELD_HIDDEN;
@@ -173,15 +170,15 @@ _get_field_type(const char *const type)
}
DataForm*
form_create(xmpp_stanza_t *const form_stanza)
form_create(xmpp_stanza_t* const form_stanza)
{
xmpp_ctx_t *ctx = connection_get_ctx();
xmpp_ctx_t* ctx = connection_get_ctx();
if (!_is_valid_form_element(form_stanza)) {
return NULL;
}
DataForm *form = _form_new();
DataForm* form = _form_new();
form->type = _get_attr(form_stanza, "type");
form->title = _get_property(form_stanza, "title");
form->instructions = _get_property(form_stanza, "instructions");
@@ -193,13 +190,13 @@ form_create(xmpp_stanza_t *const form_stanza)
int tag_num = 1;
// get fields
xmpp_stanza_t *form_child = xmpp_stanza_get_children(form_stanza);
xmpp_stanza_t* form_child = xmpp_stanza_get_children(form_stanza);
while (form_child) {
const char *child_name = xmpp_stanza_get_name(form_child);
const char* child_name = xmpp_stanza_get_name(form_child);
if (g_strcmp0(child_name, "field") == 0) {
xmpp_stanza_t *field_stanza = form_child;
xmpp_stanza_t* field_stanza = form_child;
FormField *field = _field_new();
FormField* field = _field_new();
field->label = _get_attr(field_stanza, "label");
field->type = _get_attr(field_stanza, "type");
field->type_t = _get_field_type(field->type);
@@ -208,7 +205,7 @@ form_create(xmpp_stanza_t *const form_stanza)
field->var = _get_attr(field_stanza, "var");
if (field->type_t != FIELD_HIDDEN && field->var) {
GString *tag = g_string_new("");
GString* tag = g_string_new("");
g_string_printf(tag, "field%d", tag_num++);
g_hash_table_insert(form->var_to_tag, strdup(field->var), strdup(tag->str));
g_hash_table_insert(form->tag_to_var, strdup(tag->str), strdup(field->var));
@@ -220,19 +217,19 @@ form_create(xmpp_stanza_t *const form_stanza)
field->required = _is_required(field_stanza);
// handle repeated field children
xmpp_stanza_t *field_child = xmpp_stanza_get_children(field_stanza);
xmpp_stanza_t* field_child = xmpp_stanza_get_children(field_stanza);
int value_index = 1;
while (field_child) {
child_name = xmpp_stanza_get_name(field_child);
// handle values
if (g_strcmp0(child_name, "value") == 0) {
char *value = xmpp_stanza_get_text(field_child);
char* value = xmpp_stanza_get_text(field_child);
if (value) {
field->values = g_slist_append(field->values, strdup(value));
if (field->type_t == FIELD_TEXT_MULTI) {
GString *ac_val = g_string_new("");
GString* ac_val = g_string_new("");
g_string_printf(ac_val, "val%d", value_index++);
autocomplete_add(field->value_ac, ac_val->str);
g_string_free(ac_val, TRUE);
@@ -244,9 +241,9 @@ form_create(xmpp_stanza_t *const form_stanza)
xmpp_free(ctx, value);
}
// handle options
// handle options
} else if (g_strcmp0(child_name, "option") == 0) {
FormOption *option = malloc(sizeof(FormOption));
FormOption* option = malloc(sizeof(FormOption));
option->label = _get_attr(field_child, "label");
option->value = _get_property(field_child, "value");
@@ -270,74 +267,74 @@ form_create(xmpp_stanza_t *const form_stanza)
}
xmpp_stanza_t*
form_create_submission(DataForm *form)
form_create_submission(DataForm* form)
{
xmpp_ctx_t *ctx = connection_get_ctx();
xmpp_ctx_t* ctx = connection_get_ctx();
xmpp_stanza_t *x = xmpp_stanza_new(ctx);
xmpp_stanza_t* x = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(x, STANZA_NAME_X);
xmpp_stanza_set_ns(x, STANZA_NS_DATA);
xmpp_stanza_set_type(x, "submit");
GSList *curr_field = form->fields;
GSList* curr_field = form->fields;
while (curr_field) {
FormField *field = curr_field->data;
FormField* field = curr_field->data;
if (field->type_t != FIELD_FIXED) {
xmpp_stanza_t *field_stanza = xmpp_stanza_new(ctx);
xmpp_stanza_t* field_stanza = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(field_stanza, "field");
xmpp_stanza_set_attribute(field_stanza, "var", field->var);
xmpp_stanza_t *value_stanza = NULL;
GSList *curr_value = NULL;
xmpp_stanza_t* value_stanza = NULL;
GSList* curr_value = NULL;
switch (field->type_t) {
case FIELD_HIDDEN:
case FIELD_TEXT_SINGLE:
case FIELD_TEXT_PRIVATE:
case FIELD_BOOLEAN:
case FIELD_LIST_SINGLE:
case FIELD_JID_SINGLE:
case FIELD_HIDDEN:
case FIELD_TEXT_SINGLE:
case FIELD_TEXT_PRIVATE:
case FIELD_BOOLEAN:
case FIELD_LIST_SINGLE:
case FIELD_JID_SINGLE:
value_stanza = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(value_stanza, "value");
if (field->values) {
if (field->values->data) {
xmpp_stanza_t* text_stanza = xmpp_stanza_new(ctx);
xmpp_stanza_set_text(text_stanza, field->values->data);
xmpp_stanza_add_child(value_stanza, text_stanza);
xmpp_stanza_release(text_stanza);
}
}
xmpp_stanza_add_child(field_stanza, value_stanza);
xmpp_stanza_release(value_stanza);
break;
case FIELD_TEXT_MULTI:
case FIELD_LIST_MULTI:
case FIELD_JID_MULTI:
curr_value = field->values;
while (curr_value) {
char* value = curr_value->data;
value_stanza = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(value_stanza, "value");
if (field->values) {
if (field->values->data) {
xmpp_stanza_t *text_stanza = xmpp_stanza_new(ctx);
xmpp_stanza_set_text(text_stanza, field->values->data);
xmpp_stanza_add_child(value_stanza, text_stanza);
xmpp_stanza_release(text_stanza);
}
if (value) {
xmpp_stanza_t* text_stanza = xmpp_stanza_new(ctx);
xmpp_stanza_set_text(text_stanza, value);
xmpp_stanza_add_child(value_stanza, text_stanza);
xmpp_stanza_release(text_stanza);
}
xmpp_stanza_add_child(field_stanza, value_stanza);
xmpp_stanza_release(value_stanza);
break;
case FIELD_TEXT_MULTI:
case FIELD_LIST_MULTI:
case FIELD_JID_MULTI:
curr_value = field->values;
while (curr_value) {
char *value = curr_value->data;
value_stanza = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(value_stanza, "value");
if (value) {
xmpp_stanza_t *text_stanza = xmpp_stanza_new(ctx);
xmpp_stanza_set_text(text_stanza, value);
xmpp_stanza_add_child(value_stanza, text_stanza);
xmpp_stanza_release(text_stanza);
}
xmpp_stanza_add_child(field_stanza, value_stanza);
xmpp_stanza_release(value_stanza);
curr_value = g_slist_next(curr_value);
}
break;
case FIELD_FIXED:
default:
break;
curr_value = g_slist_next(curr_value);
}
break;
case FIELD_FIXED:
default:
break;
}
xmpp_stanza_add_child(x, field_stanza);
@@ -351,7 +348,7 @@ form_create_submission(DataForm *form)
}
static void
_free_option(FormOption *option)
_free_option(FormOption* option)
{
if (option) {
free(option->label);
@@ -361,7 +358,7 @@ _free_option(FormOption *option)
}
static void
_free_field(FormField *field)
_free_field(FormField* field)
{
if (field) {
free(field->label);
@@ -376,7 +373,7 @@ _free_field(FormField *field)
}
void
form_destroy(DataForm *form)
form_destroy(DataForm* form)
{
if (form) {
free(form->type);
@@ -391,18 +388,18 @@ form_destroy(DataForm *form)
}
static int
_field_compare_by_var(FormField *a, FormField *b)
_field_compare_by_var(FormField* a, FormField* b)
{
return g_strcmp0(a->var, b->var);
}
GSList*
form_get_non_form_type_fields_sorted(DataForm *form)
form_get_non_form_type_fields_sorted(DataForm* form)
{
GSList *sorted = NULL;
GSList *curr = form->fields;
GSList* sorted = NULL;
GSList* curr = form->fields;
while (curr) {
FormField *field = curr->data;
FormField* field = curr->data;
if (g_strcmp0(field->var, "FORM_TYPE") != 0) {
sorted = g_slist_insert_sorted(sorted, field, (GCompareFunc)_field_compare_by_var);
}
@@ -413,12 +410,12 @@ form_get_non_form_type_fields_sorted(DataForm *form)
}
GSList*
form_get_field_values_sorted(FormField *field)
form_get_field_values_sorted(FormField* field)
{
GSList *sorted = NULL;
GSList *curr = field->values;
GSList* sorted = NULL;
GSList* curr = field->values;
while (curr) {
char *value = curr->data;
char* value = curr->data;
if (value) {
sorted = g_slist_insert_sorted(sorted, value, (GCompareFunc)g_strcmp0);
}
@@ -429,11 +426,11 @@ form_get_field_values_sorted(FormField *field)
}
char*
form_get_form_type_field(DataForm *form)
form_get_form_type_field(DataForm* form)
{
GSList *curr = form->fields;
GSList* curr = form->fields;
while (curr) {
FormField *field = curr->data;
FormField* field = curr->data;
if (g_strcmp0(field->var, "FORM_TYPE") == 0) {
return field->values->data;
}
@@ -444,10 +441,10 @@ form_get_form_type_field(DataForm *form)
}
gboolean
form_tag_exists(DataForm *form, const char *const tag)
form_tag_exists(DataForm* form, const char* const tag)
{
GList *tags = g_hash_table_get_keys(form->tag_to_var);
GList *curr = tags;
GList* tags = g_hash_table_get_keys(form->tag_to_var);
GList* curr = tags;
while (curr) {
if (g_strcmp0(curr->data, tag) == 0) {
return TRUE;
@@ -460,13 +457,13 @@ form_tag_exists(DataForm *form, const char *const tag)
}
form_field_type_t
form_get_field_type(DataForm *form, const char *const tag)
form_get_field_type(DataForm* form, const char* const tag)
{
char *var = g_hash_table_lookup(form->tag_to_var, tag);
char* var = g_hash_table_lookup(form->tag_to_var, tag);
if (var) {
GSList *curr = form->fields;
GSList* curr = form->fields;
while (curr) {
FormField *field = curr->data;
FormField* field = curr->data;
if (g_strcmp0(field->var, var) == 0) {
return field->type_t;
}
@@ -477,13 +474,13 @@ form_get_field_type(DataForm *form, const char *const tag)
}
void
form_set_value(DataForm *form, const char *const tag, char *value)
form_set_value(DataForm* form, const char* const tag, char* value)
{
char *var = g_hash_table_lookup(form->tag_to_var, tag);
char* var = g_hash_table_lookup(form->tag_to_var, tag);
if (var) {
GSList *curr = form->fields;
GSList* curr = form->fields;
while (curr) {
FormField *field = curr->data;
FormField* field = curr->data;
if (g_strcmp0(field->var, var) == 0) {
if (g_slist_length(field->values) == 0) {
field->values = g_slist_append(field->values, strdup(value));
@@ -502,18 +499,18 @@ form_set_value(DataForm *form, const char *const tag, char *value)
}
void
form_add_value(DataForm *form, const char *const tag, char *value)
form_add_value(DataForm* form, const char* const tag, char* value)
{
char *var = g_hash_table_lookup(form->tag_to_var, tag);
char* var = g_hash_table_lookup(form->tag_to_var, tag);
if (var) {
GSList *curr = form->fields;
GSList* curr = form->fields;
while (curr) {
FormField *field = curr->data;
FormField* field = curr->data;
if (g_strcmp0(field->var, var) == 0) {
field->values = g_slist_append(field->values, strdup(value));
if (field->type_t == FIELD_TEXT_MULTI) {
int total = g_slist_length(field->values);
GString *value_index = g_string_new("");
GString* value_index = g_string_new("");
g_string_printf(value_index, "val%d", total);
autocomplete_add(field->value_ac, value_index->str);
g_string_free(value_index, TRUE);
@@ -527,15 +524,15 @@ form_add_value(DataForm *form, const char *const tag, char *value)
}
gboolean
form_add_unique_value(DataForm *form, const char *const tag, char *value)
form_add_unique_value(DataForm* form, const char* const tag, char* value)
{
char *var = g_hash_table_lookup(form->tag_to_var, tag);
char* var = g_hash_table_lookup(form->tag_to_var, tag);
if (var) {
GSList *curr = form->fields;
GSList* curr = form->fields;
while (curr) {
FormField *field = curr->data;
FormField* field = curr->data;
if (g_strcmp0(field->var, var) == 0) {
GSList *curr_value = field->values;
GSList* curr_value = field->values;
while (curr_value) {
if (g_strcmp0(curr_value->data, value) == 0) {
return FALSE;
@@ -558,15 +555,15 @@ form_add_unique_value(DataForm *form, const char *const tag, char *value)
}
gboolean
form_remove_value(DataForm *form, const char *const tag, char *value)
form_remove_value(DataForm* form, const char* const tag, char* value)
{
char *var = g_hash_table_lookup(form->tag_to_var, tag);
char* var = g_hash_table_lookup(form->tag_to_var, tag);
if (var) {
GSList *curr = form->fields;
GSList* curr = form->fields;
while (curr) {
FormField *field = curr->data;
FormField* field = curr->data;
if (g_strcmp0(field->var, var) == 0) {
GSList *found = g_slist_find_custom(field->values, value, (GCompareFunc)g_strcmp0);
GSList* found = g_slist_find_custom(field->values, value, (GCompareFunc)g_strcmp0);
if (found) {
free(found->data);
found->data = NULL;
@@ -588,22 +585,22 @@ form_remove_value(DataForm *form, const char *const tag, char *value)
}
gboolean
form_remove_text_multi_value(DataForm *form, const char *const tag, int index)
form_remove_text_multi_value(DataForm* form, const char* const tag, int index)
{
index--;
char *var = g_hash_table_lookup(form->tag_to_var, tag);
char* var = g_hash_table_lookup(form->tag_to_var, tag);
if (var) {
GSList *curr = form->fields;
GSList* curr = form->fields;
while (curr) {
FormField *field = curr->data;
FormField* field = curr->data;
if (g_strcmp0(field->var, var) == 0) {
GSList *item = g_slist_nth(field->values, index);
GSList* item = g_slist_nth(field->values, index);
if (item) {
free(item->data);
item->data = NULL;
field->values = g_slist_delete_link(field->values, item);
GString *value_index = g_string_new("");
g_string_printf(value_index, "val%d", index+1);
GString* value_index = g_string_new("");
g_string_printf(value_index, "val%d", index + 1);
autocomplete_remove(field->value_ac, value_index->str);
g_string_free(value_index, TRUE);
form->modified = TRUE;
@@ -620,13 +617,13 @@ form_remove_text_multi_value(DataForm *form, const char *const tag, int index)
}
int
form_get_value_count(DataForm *form, const char *const tag)
form_get_value_count(DataForm* form, const char* const tag)
{
char *var = g_hash_table_lookup(form->tag_to_var, tag);
char* var = g_hash_table_lookup(form->tag_to_var, tag);
if (var) {
GSList *curr = form->fields;
GSList* curr = form->fields;
while (curr) {
FormField *field = curr->data;
FormField* field = curr->data;
if (g_strcmp0(field->var, var) == 0) {
if ((g_slist_length(field->values) == 1) && (field->values->data == NULL)) {
return 0;
@@ -642,17 +639,17 @@ form_get_value_count(DataForm *form, const char *const tag)
}
gboolean
form_field_contains_option(DataForm *form, const char *const tag, char *value)
form_field_contains_option(DataForm* form, const char* const tag, char* value)
{
char *var = g_hash_table_lookup(form->tag_to_var, tag);
char* var = g_hash_table_lookup(form->tag_to_var, tag);
if (var) {
GSList *curr = form->fields;
GSList* curr = form->fields;
while (curr) {
FormField *field = curr->data;
FormField* field = curr->data;
if (g_strcmp0(field->var, var) == 0) {
GSList *curr_option = field->options;
GSList* curr_option = field->options;
while (curr_option) {
FormOption *option = curr_option->data;
FormOption* option = curr_option->data;
if (g_strcmp0(option->value, value) == 0) {
return TRUE;
}
@@ -667,13 +664,13 @@ form_field_contains_option(DataForm *form, const char *const tag, char *value)
}
FormField*
form_get_field_by_tag(DataForm *form, const char *const tag)
form_get_field_by_tag(DataForm* form, const char* const tag)
{
char *var = g_hash_table_lookup(form->tag_to_var, tag);
char* var = g_hash_table_lookup(form->tag_to_var, tag);
if (var) {
GSList *curr = form->fields;
GSList* curr = form->fields;
while (curr) {
FormField *field = curr->data;
FormField* field = curr->data;
if (g_strcmp0(field->var, var) == 0) {
return field;
}
@@ -684,13 +681,13 @@ form_get_field_by_tag(DataForm *form, const char *const tag)
}
Autocomplete
form_get_value_ac(DataForm *form, const char *const tag)
form_get_value_ac(DataForm* form, const char* const tag)
{
char *var = g_hash_table_lookup(form->tag_to_var, tag);
char* var = g_hash_table_lookup(form->tag_to_var, tag);
if (var) {
GSList *curr = form->fields;
GSList* curr = form->fields;
while (curr) {
FormField *field = curr->data;
FormField* field = curr->data;
if (g_strcmp0(field->var, var) == 0) {
return field->value_ac;
}
@@ -701,12 +698,12 @@ form_get_value_ac(DataForm *form, const char *const tag)
}
void
form_reset_autocompleters(DataForm *form)
form_reset_autocompleters(DataForm* form)
{
autocomplete_reset(form->tag_ac);
GSList *curr_field = form->fields;
GSList* curr_field = form->fields;
while (curr_field) {
FormField *field = curr_field->data;
FormField* field = curr_field->data;
autocomplete_reset(field->value_ac);
curr_field = g_slist_next(curr_field);
}

10
src/xmpp/form.h
View File

@@ -46,10 +46,10 @@
#include "xmpp/xmpp.h"
DataForm* form_create(xmpp_stanza_t *const stanza);
xmpp_stanza_t* form_create_submission(DataForm *form);
char* form_get_form_type_field(DataForm *form);
GSList* form_get_non_form_type_fields_sorted(DataForm *form);
GSList* form_get_field_values_sorted(FormField *field);
DataForm* form_create(xmpp_stanza_t* const stanza);
xmpp_stanza_t* form_create_submission(DataForm* form);
char* form_get_form_type_field(DataForm* form);
GSList* form_get_non_form_type_fields_sorted(DataForm* form);
GSList* form_get_field_values_sorted(FormField* field);
#endif

1136
src/xmpp/iq.c
View File

File diff suppressed because it is too large Load Diff

22
src/xmpp/iq.h
View File

@@ -36,18 +36,18 @@
#ifndef XMPP_IQ_H
#define XMPP_IQ_H
typedef int(*ProfIqCallback)(xmpp_stanza_t *const stanza, void *const userdata);
typedef void(*ProfIqFreeCallback)(void *userdata);
typedef int (*ProfIqCallback)(xmpp_stanza_t* const stanza, void* const userdata);
typedef void (*ProfIqFreeCallback)(void* userdata);
void iq_handlers_init(void);
void iq_send_stanza(xmpp_stanza_t *const stanza);
void iq_id_handler_add(const char *const id, ProfIqCallback func, ProfIqFreeCallback free_func, void *userdata);
void iq_disco_info_request_onconnect(gchar *jid);
void iq_disco_items_request_onconnect(gchar *jid);
void iq_send_caps_request(const char *const to, const char *const id, const char *const node, const char *const ver);
void iq_send_caps_request_for_jid(const char *const to, const char *const id, const char *const node,
const char *const ver);
void iq_send_caps_request_legacy(const char *const to, const char *const id, const char *const node,
const char *const ver);
void iq_send_stanza(xmpp_stanza_t* const stanza);
void iq_id_handler_add(const char* const id, ProfIqCallback func, ProfIqFreeCallback free_func, void* userdata);
void iq_disco_info_request_onconnect(gchar* jid);
void iq_disco_items_request_onconnect(gchar* jid);
void iq_send_caps_request(const char* const to, const char* const id, const char* const node, const char* const ver);
void iq_send_caps_request_for_jid(const char* const to, const char* const id, const char* const node,
const char* const ver);
void iq_send_caps_request_legacy(const char* const to, const char* const id, const char* const node,
const char* const ver);
#endif

45
src/xmpp/jid.c
View File

@@ -42,12 +42,12 @@
#include "xmpp/jid.h"
Jid*
jid_create(const gchar *const str)
jid_create(const gchar* const str)
{
Jid *result = NULL;
Jid* result = NULL;
/* if str is NULL g_strdup returns NULL */
gchar *trimmed = g_strdup(str);
gchar* trimmed = g_strdup(str);
if (trimmed == NULL) {
return NULL;
}
@@ -75,9 +75,9 @@ jid_create(const gchar *const str)
result->barejid = NULL;
result->fulljid = NULL;
gchar *atp = g_utf8_strchr(trimmed, -1, '@');
gchar *slashp = g_utf8_strchr(trimmed, -1, '/');
gchar *domain_start = trimmed;
gchar* atp = g_utf8_strchr(trimmed, -1, '@');
gchar* slashp = g_utf8_strchr(trimmed, -1, '/');
gchar* domain_start = trimmed;
if (atp) {
result->localpart = g_utf8_substring(trimmed, 0, g_utf8_pointer_to_offset(trimmed, atp));
@@ -87,7 +87,7 @@ jid_create(const gchar *const str)
if (slashp) {
result->resourcepart = g_strdup(slashp + 1);
result->domainpart = g_utf8_substring(domain_start, 0, g_utf8_pointer_to_offset(domain_start, slashp));
char *barejidraw = g_utf8_substring(trimmed, 0, g_utf8_pointer_to_offset(trimmed, slashp));
char* barejidraw = g_utf8_substring(trimmed, 0, g_utf8_pointer_to_offset(trimmed, slashp));
result->barejid = g_utf8_strdown(barejidraw, -1);
result->fulljid = g_strdup(trimmed);
g_free(barejidraw);
@@ -107,10 +107,10 @@ jid_create(const gchar *const str)
}
Jid*
jid_create_from_bare_and_resource(const char *const barejid, const char *const resource)
jid_create_from_bare_and_resource(const char* const barejid, const char* const resource)
{
Jid *result;
char *jid = create_fulljid(barejid, resource);
Jid* result;
char* jid = create_fulljid(barejid, resource);
result = jid_create(jid);
free(jid);
@@ -118,7 +118,7 @@ jid_create_from_bare_and_resource(const char *const barejid, const char *const r
}
void
jid_destroy(Jid *jid)
jid_destroy(Jid* jid)
{
if (jid == NULL) {
return;
@@ -134,7 +134,7 @@ jid_destroy(Jid *jid)
}
gboolean
jid_is_valid_room_form(Jid *jid)
jid_is_valid_room_form(Jid* jid)
{
return (jid->fulljid != NULL);
}
@@ -145,15 +145,15 @@ jid_is_valid_room_form(Jid *jid)
* Will return a newly created string that must be freed by the caller
*/
char*
create_fulljid(const char *const barejid, const char *const resource)
create_fulljid(const char* const barejid, const char* const resource)
{
gchar *barejidlower = g_utf8_strdown(barejid, -1);
GString *full_jid = g_string_new(barejidlower);
gchar* barejidlower = g_utf8_strdown(barejid, -1);
GString* full_jid = g_string_new(barejidlower);
g_free(barejidlower);
g_string_append(full_jid, "/");
g_string_append(full_jid, resource);
char *result = strdup(full_jid->str);
char* result = strdup(full_jid->str);
g_string_free(full_jid, TRUE);
@@ -166,10 +166,10 @@ create_fulljid(const char *const barejid, const char *const resource)
* returns "person"
*/
char*
get_nick_from_full_jid(const char *const full_room_jid)
get_nick_from_full_jid(const char* const full_room_jid)
{
char **tokens = g_strsplit(full_room_jid, "/", 0);
char *nick_part = NULL;
char** tokens = g_strsplit(full_room_jid, "/", 0);
char* nick_part = NULL;
if (tokens) {
if (tokens[0] && tokens[1]) {
@@ -182,12 +182,11 @@ get_nick_from_full_jid(const char *const full_room_jid)
return nick_part;
}
/*
* get the fulljid, fall back to the barejid
*/
char*
jid_fulljid_or_barejid(Jid *jid)
jid_fulljid_or_barejid(Jid* jid)
{
if (jid->fulljid) {
return jid->fulljid;
@@ -199,9 +198,9 @@ jid_fulljid_or_barejid(Jid *jid)
char*
jid_random_resource(void)
{
char *rand = get_random_string(4);
char* rand = get_random_string(4);
gchar *result = g_strdup_printf("profanity.%s", rand);
gchar* result = g_strdup_printf("profanity.%s", rand);
free(rand);
return result;

29
src/xmpp/jid.h
View File

@@ -38,26 +38,27 @@
#include <glib.h>
struct jid_t {
char *str;
char *localpart;
char *domainpart;
char *resourcepart;
char *barejid;
char *fulljid;
struct jid_t
{
char* str;
char* localpart;
char* domainpart;
char* resourcepart;
char* barejid;
char* fulljid;
};
typedef struct jid_t Jid;
Jid* jid_create(const gchar *const str);
Jid* jid_create_from_bare_and_resource(const char *const barejid, const char *const resource);
void jid_destroy(Jid *jid);
Jid* jid_create(const gchar* const str);
Jid* jid_create_from_bare_and_resource(const char* const barejid, const char* const resource);
void jid_destroy(Jid* jid);
gboolean jid_is_valid_room_form(Jid *jid);
char* create_fulljid(const char *const barejid, const char *const resource);
char* get_nick_from_full_jid(const char *const full_room_jid);
gboolean jid_is_valid_room_form(Jid* jid);
char* create_fulljid(const char* const barejid, const char* const resource);
char* get_nick_from_full_jid(const char* const full_room_jid);
char* jid_fulljid_or_barejid(Jid *jid);
char* jid_fulljid_or_barejid(Jid* jid);
char* jid_random_resource(void);
#endif

568
src/xmpp/message.c
View File

File diff suppressed because it is too large Load Diff

10
src/xmpp/message.h
View File

@@ -38,13 +38,13 @@
#include "xmpp/xmpp.h"
typedef int(*ProfMessageCallback)(xmpp_stanza_t *const stanza, void *const userdata);
typedef void(*ProfMessageFreeCallback)(void *userdata);
typedef int (*ProfMessageCallback)(xmpp_stanza_t* const stanza, void* const userdata);
typedef void (*ProfMessageFreeCallback)(void* userdata);
ProfMessage *message_init(void);
void message_free(ProfMessage *message);
ProfMessage* message_init(void);
void message_free(ProfMessage* message);
void message_handlers_init(void);
void message_handlers_clear(void);
void message_pubsub_event_handler_add(const char *const node, ProfMessageCallback func, ProfMessageFreeCallback free_func, void *userdata);
void message_pubsub_event_handler_add(const char* const node, ProfMessageCallback func, ProfMessageFreeCallback free_func, void* userdata);
#endif

319
src/xmpp/muc.c
View File

@@ -33,9 +33,9 @@
*
*/
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <glib.h>
@@ -43,50 +43,51 @@
#include "tools/autocomplete.h"
#include "ui/ui.h"
#include "ui/window_list.h"
#include "xmpp/contact.h"
#include "xmpp/jid.h"
#include "xmpp/muc.h"
#include "xmpp/contact.h"
#ifdef HAVE_OMEMO
#include "omemo/omemo.h"
#endif
typedef struct _muc_room_t {
char *room; // e.g. test@conference.server
char *nick; // e.g. Some User
typedef struct _muc_room_t
{
char* room; // e.g. test@conference.server
char* nick; // e.g. Some User
muc_role_t role;
muc_affiliation_t affiliation;
char *password;
char *subject;
char *autocomplete_prefix;
char* password;
char* subject;
char* autocomplete_prefix;
gboolean pending_config;
GList *pending_broadcasts;
GList* pending_broadcasts;
gboolean autojoin;
gboolean pending_nick_change;
GHashTable *roster;
GHashTable *members;
GHashTable* roster;
GHashTable* members;
Autocomplete nick_ac;
Autocomplete jid_ac;
GHashTable *nick_changes;
GHashTable* nick_changes;
gboolean roster_received;
muc_member_type_t member_type;
muc_anonymity_type_t anonymity_type;
} ChatRoom;
GHashTable *rooms = NULL;
GHashTable *invite_passwords = NULL;
GHashTable* rooms = NULL;
GHashTable* invite_passwords = NULL;
Autocomplete invite_ac = NULL;
Autocomplete confservers_ac = NULL;
static void _free_room(ChatRoom *room);
static gint _compare_occupants(Occupant *a, Occupant *b);
static muc_role_t _role_from_string(const char *const role);
static muc_affiliation_t _affiliation_from_string(const char *const affiliation);
static void _free_room(ChatRoom* room);
static gint _compare_occupants(Occupant* a, Occupant* b);
static muc_role_t _role_from_string(const char* const role);
static muc_affiliation_t _affiliation_from_string(const char* const affiliation);
static char* _role_to_string(muc_role_t role);
static char* _affiliation_to_string(muc_affiliation_t affiliation);
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);
static void _occupant_free(Occupant *occupant);
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);
static void _occupant_free(Occupant* occupant);
void
muc_init(void)
@@ -111,13 +112,13 @@ muc_close(void)
}
void
muc_confserver_add(const char *const server)
muc_confserver_add(const char* const server)
{
autocomplete_add(confservers_ac, server);
}
void
muc_invites_add(const char *const room, const char *const password)
muc_invites_add(const char* const room, const char* const password)
{
autocomplete_add(invite_ac, room);
if (password) {
@@ -126,7 +127,7 @@ muc_invites_add(const char *const room, const char *const password)
}
void
muc_invites_remove(const char *const room)
muc_invites_remove(const char* const room)
{
autocomplete_remove(invite_ac, room);
g_hash_table_remove(invite_passwords, room);
@@ -145,16 +146,16 @@ muc_invites(void)
}
char*
muc_invite_password(const char *const room)
muc_invite_password(const char* const room)
{
return g_hash_table_lookup(invite_passwords, room);
}
gboolean
muc_invites_contain(const char *const room)
muc_invites_contain(const char* const room)
{
GList *invites = autocomplete_create_list(invite_ac);
GList *curr = invites;
GList* invites = autocomplete_create_list(invite_ac);
GList* curr = invites;
while (curr) {
if (strcmp(curr->data, room) == 0) {
g_list_free_full(invites, g_free);
@@ -181,13 +182,13 @@ muc_confserver_reset_ac(void)
}
char*
muc_invites_find(const char *const search_str, gboolean previous, void *context)
muc_invites_find(const char* const search_str, gboolean previous, void* context)
{
return autocomplete_complete(invite_ac, search_str, TRUE, previous);
}
char*
muc_confserver_find(const char *const search_str, gboolean previous, void *context)
muc_confserver_find(const char* const search_str, gboolean previous, void* context)
{
return autocomplete_complete(confservers_ac, search_str, TRUE, previous);
}
@@ -208,9 +209,9 @@ muc_confserver_clear(void)
}
void
muc_join(const char *const room, const char *const nick, const char *const password, gboolean autojoin)
muc_join(const char* const room, const char* const nick, const char* const password, gboolean autojoin)
{
ChatRoom *new_room = malloc(sizeof(ChatRoom));
ChatRoom* new_room = malloc(sizeof(ChatRoom));
new_room->room = strdup(room);
new_room->nick = strdup(nick);
new_room->role = MUC_ROLE_NONE;
@@ -239,36 +240,35 @@ muc_join(const char *const room, const char *const nick, const char *const passw
}
void
muc_leave(const char *const room)
muc_leave(const char* const room)
{
g_hash_table_remove(rooms, room);
}
gboolean
muc_requires_config(const char *const room)
muc_requires_config(const char* const room)
{
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
ChatRoom* chat_room = g_hash_table_lookup(rooms, room);
if (chat_room) {
return chat_room->pending_config;
} else {
return FALSE;
}
}
void
muc_set_requires_config(const char *const room, gboolean val)
muc_set_requires_config(const char* const room, gboolean val)
{
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
ChatRoom* chat_room = g_hash_table_lookup(rooms, room);
if (chat_room) {
chat_room->pending_config = val;
}
}
void
muc_set_features(const char *const room, GSList *features)
muc_set_features(const char* const room, GSList* features)
{
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
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;
@@ -289,16 +289,16 @@ muc_set_features(const char *const room, GSList *features)
* Returns TRUE if the user is currently in the room
*/
gboolean
muc_active(const char *const room)
muc_active(const char* const room)
{
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
ChatRoom* chat_room = g_hash_table_lookup(rooms, room);
return (chat_room != NULL);
}
gboolean
muc_autojoin(const char *const room)
muc_autojoin(const char* const room)
{
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
ChatRoom* chat_room = g_hash_table_lookup(rooms, room);
if (chat_room) {
return chat_room->autojoin;
} else {
@@ -307,9 +307,9 @@ muc_autojoin(const char *const room)
}
void
muc_set_subject(const char *const room, const char *const subject)
muc_set_subject(const char* const room, const char* const subject)
{
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
ChatRoom* chat_room = g_hash_table_lookup(rooms, room);
if (chat_room) {
free(chat_room->subject);
if (subject) {
@@ -321,9 +321,9 @@ muc_set_subject(const char *const room, const char *const subject)
}
char*
muc_subject(const char *const room)
muc_subject(const char* const room)
{
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
ChatRoom* chat_room = g_hash_table_lookup(rooms, room);
if (chat_room) {
return chat_room->subject;
} else {
@@ -332,18 +332,18 @@ muc_subject(const char *const room)
}
void
muc_pending_broadcasts_add(const char *const room, const char *const message)
muc_pending_broadcasts_add(const char* const room, const char* const message)
{
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
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));
}
}
GList*
muc_pending_broadcasts(const char *const room)
muc_pending_broadcasts(const char* const room)
{
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
ChatRoom* chat_room = g_hash_table_lookup(rooms, room);
if (chat_room) {
return chat_room->pending_broadcasts;
} else {
@@ -352,9 +352,9 @@ muc_pending_broadcasts(const char *const room)
}
char*
muc_old_nick(const char *const room, const char *const new_nick)
muc_old_nick(const char* const room, const char* const new_nick)
{
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
ChatRoom* chat_room = g_hash_table_lookup(rooms, room);
if (chat_room && chat_room->pending_nick_change) {
return g_hash_table_lookup(chat_room->nick_changes, new_nick);
} else {
@@ -367,9 +367,9 @@ muc_old_nick(const char *const room, const char *const new_nick)
* and is awaiting the response
*/
void
muc_nick_change_start(const char *const room, const char *const new_nick)
muc_nick_change_start(const char* const room, const char* const new_nick)
{
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
ChatRoom* chat_room = g_hash_table_lookup(rooms, room);
if (chat_room) {
chat_room->pending_nick_change = TRUE;
g_hash_table_insert(chat_room->nick_changes, strdup(new_nick), strdup(chat_room->nick));
@@ -381,9 +381,9 @@ muc_nick_change_start(const char *const room, const char *const new_nick)
* nick change
*/
gboolean
muc_nick_change_pending(const char *const room)
muc_nick_change_pending(const char* const room)
{
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
ChatRoom* chat_room = g_hash_table_lookup(rooms, room);
if (chat_room) {
return chat_room->pending_nick_change;
} else {
@@ -396,9 +396,9 @@ muc_nick_change_pending(const char *const room)
* the service has responded
*/
void
muc_nick_change_complete(const char *const room, const char *const nick)
muc_nick_change_complete(const char* const room, const char* const nick)
{
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
ChatRoom* chat_room = g_hash_table_lookup(rooms, room);
if (chat_room) {
g_hash_table_remove(chat_room->roster, chat_room->nick);
autocomplete_remove(chat_room->nick_ac, chat_room->nick);
@@ -425,9 +425,9 @@ muc_rooms(void)
* The nickname is owned by the chat room and should not be modified or freed
*/
char*
muc_nick(const char *const room)
muc_nick(const char* const room)
{
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
ChatRoom* chat_room = g_hash_table_lookup(rooms, room);
if (chat_room) {
return chat_room->nick;
} else {
@@ -440,9 +440,9 @@ muc_nick(const char *const room)
* The password is owned by the chat room and should not be modified or freed
*/
char*
muc_password(const char *const room)
muc_password(const char* const room)
{
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
ChatRoom* chat_room = g_hash_table_lookup(rooms, room);
if (chat_room) {
return chat_room->password;
} else {
@@ -454,11 +454,11 @@ muc_password(const char *const room)
* Returns TRUE if the specified nick exists in the room's roster
*/
gboolean
muc_roster_contains_nick(const char *const room, const char *const nick)
muc_roster_contains_nick(const char* const room, const char* const nick)
{
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
ChatRoom* chat_room = g_hash_table_lookup(rooms, room);
if (chat_room) {
Occupant *occupant = g_hash_table_lookup(chat_room->roster, nick);
Occupant* occupant = g_hash_table_lookup(chat_room->roster, nick);
return (occupant != NULL);
} else {
return FALSE;
@@ -469,32 +469,31 @@ muc_roster_contains_nick(const char *const room, const char *const nick)
* Add a new chat room member to the room's roster
*/
gboolean
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)
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)
{
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
ChatRoom* chat_room = g_hash_table_lookup(rooms, room);
gboolean updated = FALSE;
resource_presence_t new_presence = resource_presence_from_string(show);
if (chat_room) {
Occupant *old = g_hash_table_lookup(chat_room->roster, nick);
Occupant* old = g_hash_table_lookup(chat_room->roster, nick);
if (!old) {
updated = TRUE;
autocomplete_add(chat_room->nick_ac, nick);
} else if (old->presence != new_presence ||
(g_strcmp0(old->status, status) != 0)) {
} else if (old->presence != new_presence || (g_strcmp0(old->status, status) != 0)) {
updated = TRUE;
}
resource_presence_t presence = resource_presence_from_string(show);
muc_role_t role_t = _role_from_string(role);
muc_affiliation_t affiliation_t = _affiliation_from_string(affiliation);
Occupant *occupant = _muc_occupant_new(nick, jid, role_t, affiliation_t, presence, status);
Occupant* occupant = _muc_occupant_new(nick, jid, role_t, affiliation_t, presence, status);
g_hash_table_replace(chat_room->roster, strdup(nick), occupant);
if (jid) {
Jid *jidp = jid_create(jid);
Jid* jidp = jid_create(jid);
if (jidp->barejid) {
autocomplete_add(chat_room->jid_ac, jidp->barejid);
}
@@ -509,9 +508,9 @@ muc_roster_add(const char *const room, const char *const nick, const char *const
* Remove a room member from the room's roster
*/
void
muc_roster_remove(const char *const room, const char *const nick)
muc_roster_remove(const char* const room, const char* const nick)
{
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
ChatRoom* chat_room = g_hash_table_lookup(rooms, room);
if (chat_room) {
g_hash_table_remove(chat_room->roster, nick);
autocomplete_remove(chat_room->nick_ac, nick);
@@ -519,11 +518,11 @@ muc_roster_remove(const char *const room, const char *const nick)
}
Occupant*
muc_roster_item(const char *const room, const char *const nick)
muc_roster_item(const char* const room, const char* const nick)
{
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
ChatRoom* chat_room = g_hash_table_lookup(rooms, room);
if (chat_room) {
Occupant *occupant = g_hash_table_lookup(chat_room->roster, nick);
Occupant* occupant = g_hash_table_lookup(chat_room->roster, nick);
return occupant;
} else {
return NULL;
@@ -534,14 +533,14 @@ muc_roster_item(const char *const room, const char *const nick)
* Return a list of PContacts representing the room members in the room's roster
*/
GList*
muc_roster(const char *const room)
muc_roster(const char* const room)
{
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
ChatRoom* chat_room = g_hash_table_lookup(rooms, room);
if (chat_room) {
GList *result = NULL;
GList *occupants = g_hash_table_get_values(chat_room->roster);
GList* result = NULL;
GList* occupants = g_hash_table_get_values(chat_room->roster);
GList *curr = occupants;
GList* curr = occupants;
while (curr) {
result = g_list_insert_sorted(result, curr->data, (GCompareFunc)_compare_occupants);
curr = g_list_next(curr);
@@ -559,9 +558,9 @@ muc_roster(const char *const room)
* Return a Autocomplete representing the room member's in the roster
*/
Autocomplete
muc_roster_ac(const char *const room)
muc_roster_ac(const char* const room)
{
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
ChatRoom* chat_room = g_hash_table_lookup(rooms, room);
if (chat_room) {
return chat_room->nick_ac;
} else {
@@ -570,9 +569,9 @@ muc_roster_ac(const char *const room)
}
Autocomplete
muc_roster_jid_ac(const char *const room)
muc_roster_jid_ac(const char* const room)
{
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
ChatRoom* chat_room = g_hash_table_lookup(rooms, room);
if (chat_room) {
return chat_room->jid_ac;
} else {
@@ -584,9 +583,9 @@ muc_roster_jid_ac(const char *const room)
* Set to TRUE when the rooms roster has been fully received
*/
void
muc_roster_set_complete(const char *const room)
muc_roster_set_complete(const char* const room)
{
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
ChatRoom* chat_room = g_hash_table_lookup(rooms, room);
if (chat_room) {
chat_room->roster_received = TRUE;
}
@@ -596,9 +595,9 @@ muc_roster_set_complete(const char *const room)
* Returns TRUE id the rooms roster has been fully received
*/
gboolean
muc_roster_complete(const char *const room)
muc_roster_complete(const char* const room)
{
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
ChatRoom* chat_room = g_hash_table_lookup(rooms, room);
if (chat_room) {
return chat_room->roster_received;
} else {
@@ -607,36 +606,36 @@ muc_roster_complete(const char *const room)
}
gboolean
muc_occupant_available(Occupant *occupant)
muc_occupant_available(Occupant* occupant)
{
return (occupant->presence == RESOURCE_ONLINE || occupant->presence == RESOURCE_CHAT);
}
const char*
muc_occupant_affiliation_str(Occupant *occupant)
muc_occupant_affiliation_str(Occupant* occupant)
{
return _affiliation_to_string(occupant->affiliation);
}
const char*
muc_occupant_role_str(Occupant *occupant)
muc_occupant_role_str(Occupant* occupant)
{
return _role_to_string(occupant->role);
}
GSList*
muc_occupants_by_role(const char *const room, muc_role_t role)
muc_occupants_by_role(const char* const room, muc_role_t role)
{
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
ChatRoom* chat_room = g_hash_table_lookup(rooms, room);
if (chat_room) {
GSList *result = NULL;
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;
Occupant* occupant = (Occupant*)value;
if (occupant->role == role) {
result = g_slist_insert_sorted(result, value, (GCompareFunc)_compare_occupants);
}
@@ -648,18 +647,18 @@ muc_occupants_by_role(const char *const room, muc_role_t role)
}
GSList*
muc_occupants_by_affiliation(const char *const room, muc_affiliation_t affiliation)
muc_occupants_by_affiliation(const char* const room, muc_affiliation_t affiliation)
{
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
ChatRoom* chat_room = g_hash_table_lookup(rooms, room);
if (chat_room) {
GSList *result = NULL;
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;
Occupant* occupant = (Occupant*)value;
if (occupant->affiliation == affiliation) {
result = g_slist_insert_sorted(result, value, (GCompareFunc)_compare_occupants);
}
@@ -675,9 +674,9 @@ muc_occupants_by_affiliation(const char *const room, muc_affiliation_t affiliati
* is in progress
*/
void
muc_occupant_nick_change_start(const char *const room, const char *const new_nick, const char *const old_nick)
muc_occupant_nick_change_start(const char* const room, const char* const new_nick, const char* const old_nick)
{
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
ChatRoom* chat_room = g_hash_table_lookup(rooms, room);
if (chat_room) {
g_hash_table_insert(chat_room->nick_changes, strdup(new_nick), strdup(old_nick));
muc_roster_remove(room, old_nick);
@@ -691,13 +690,13 @@ muc_occupant_nick_change_start(const char *const room, const char *const new_nic
* the caller
*/
char*
muc_roster_nick_change_complete(const char *const room, const char *const nick)
muc_roster_nick_change_complete(const char* const room, const char* const nick)
{
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
ChatRoom* chat_room = g_hash_table_lookup(rooms, room);
if (chat_room) {
char *old_nick = g_hash_table_lookup(chat_room->nick_changes, nick);
char* old_nick = g_hash_table_lookup(chat_room->nick_changes, nick);
if (old_nick) {
char *old_nick_cpy = strdup(old_nick);
char* old_nick_cpy = strdup(old_nick);
g_hash_table_remove(chat_room->nick_changes, nick);
return old_nick_cpy;
@@ -708,40 +707,40 @@ muc_roster_nick_change_complete(const char *const room, const char *const nick)
}
char*
muc_autocomplete(ProfWin *window, const char *const input, gboolean previous)
muc_autocomplete(ProfWin* window, const char* const input, gboolean previous)
{
if (window->type != WIN_MUC) {
return NULL;
}
ProfMucWin *mucwin = (ProfMucWin*)window;
ProfMucWin* mucwin = (ProfMucWin*)window;
assert(mucwin->memcheck == PROFMUCWIN_MEMCHECK);
ChatRoom *chat_room = g_hash_table_lookup(rooms, mucwin->roomjid);
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;
const char* search_str = NULL;
gchar *last_space = g_strrstr(input, " ");
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;
search_str = last_space + 1;
if (!chat_room->autocomplete_prefix) {
chat_room->autocomplete_prefix = g_strndup(input, search_str - input);
}
}
char *result = autocomplete_complete(chat_room->nick_ac, search_str, FALSE, previous);
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);
GString* replace_with = g_string_new(chat_room->autocomplete_prefix);
g_string_append(replace_with, result);
if (strlen(chat_room->autocomplete_prefix) == 0) {
@@ -754,9 +753,9 @@ muc_autocomplete(ProfWin *window, const char *const input, gboolean previous)
}
void
muc_jid_autocomplete_reset(const char *const room)
muc_jid_autocomplete_reset(const char* const room)
{
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
ChatRoom* chat_room = g_hash_table_lookup(rooms, room);
if (chat_room) {
if (chat_room->jid_ac) {
autocomplete_reset(chat_room->jid_ac);
@@ -765,15 +764,15 @@ muc_jid_autocomplete_reset(const char *const room)
}
void
muc_jid_autocomplete_add_all(const char *const room, GSList *jids)
muc_jid_autocomplete_add_all(const char* const room, GSList* jids)
{
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
ChatRoom* chat_room = g_hash_table_lookup(rooms, room);
if (chat_room) {
if (chat_room->jid_ac) {
GSList *curr_jid = jids;
GSList* curr_jid = jids;
while (curr_jid) {
const char *jid = curr_jid->data;
Jid *jidp = jid_create(jid);
const char* jid = curr_jid->data;
Jid* jidp = jid_create(jid);
if (jidp) {
if (jidp->barejid) {
autocomplete_add(chat_room->jid_ac, jidp->barejid);
@@ -787,9 +786,9 @@ muc_jid_autocomplete_add_all(const char *const room, GSList *jids)
}
void
muc_autocomplete_reset(const char *const room)
muc_autocomplete_reset(const char* const room)
{
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
ChatRoom* chat_room = g_hash_table_lookup(rooms, room);
if (chat_room) {
if (chat_room->nick_ac) {
autocomplete_reset(chat_room->nick_ac);
@@ -803,9 +802,9 @@ muc_autocomplete_reset(const char *const room)
}
char*
muc_role_str(const char *const room)
muc_role_str(const char* const room)
{
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
ChatRoom* chat_room = g_hash_table_lookup(rooms, room);
if (chat_room) {
return _role_to_string(chat_room->role);
} else {
@@ -814,18 +813,18 @@ muc_role_str(const char *const room)
}
void
muc_set_role(const char *const room, const char *const role)
muc_set_role(const char* const room, const char* const role)
{
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
ChatRoom* chat_room = g_hash_table_lookup(rooms, room);
if (chat_room) {
chat_room->role = _role_from_string(role);
}
}
char*
muc_affiliation_str(const char *const room)
muc_affiliation_str(const char* const room)
{
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
ChatRoom* chat_room = g_hash_table_lookup(rooms, room);
if (chat_room) {
return _affiliation_to_string(chat_room->affiliation);
} else {
@@ -834,18 +833,18 @@ muc_affiliation_str(const char *const room)
}
void
muc_set_affiliation(const char *const room, const char *const affiliation)
muc_set_affiliation(const char* const room, const char* const affiliation)
{
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
ChatRoom* chat_room = g_hash_table_lookup(rooms, room);
if (chat_room) {
chat_room->affiliation = _affiliation_from_string(affiliation);
}
}
muc_member_type_t
muc_member_type(const char *const room)
muc_member_type(const char* const room)
{
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
ChatRoom* chat_room = g_hash_table_lookup(rooms, room);
if (chat_room) {
return chat_room->member_type;
} else {
@@ -854,9 +853,9 @@ muc_member_type(const char *const room)
}
muc_anonymity_type_t
muc_anonymity_type(const char *const room)
muc_anonymity_type(const char* const room)
{
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
ChatRoom* chat_room = g_hash_table_lookup(rooms, room);
if (chat_room) {
return chat_room->anonymity_type;
} else {
@@ -868,9 +867,9 @@ muc_anonymity_type(const char *const room)
* Return the list of jid affiliated as member in the room
*/
GList*
muc_members(const char *const room)
muc_members(const char* const room)
{
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
ChatRoom* chat_room = g_hash_table_lookup(rooms, room);
if (chat_room) {
return g_hash_table_get_keys(chat_room->members);
} else {
@@ -879,14 +878,14 @@ muc_members(const char *const room)
}
void
muc_members_add(const char *const room, const char *const jid)
muc_members_add(const char* const room, const char* const jid)
{
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
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
if(chat_room->anonymity_type == MUC_ANONYMITY_TYPE_NONANONYMOUS ) {
char *our_barejid = connection_get_barejid();
if (chat_room->anonymity_type == MUC_ANONYMITY_TYPE_NONANONYMOUS) {
char* our_barejid = connection_get_barejid();
if (strcmp(jid, our_barejid) != 0) {
omemo_start_session(jid);
}
@@ -898,16 +897,16 @@ muc_members_add(const char *const room, const char *const jid)
}
void
muc_members_remove(const char *const room, const char *const jid)
muc_members_remove(const char* const room, const char* const jid)
{
ChatRoom *chat_room = g_hash_table_lookup(rooms, room);
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)
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);
@@ -917,7 +916,7 @@ muc_members_update(const char *const room, const char *const jid, const char *co
}
static void
_free_room(ChatRoom *room)
_free_room(ChatRoom* room)
{
if (room) {
free(room->room);
@@ -944,10 +943,10 @@ _free_room(ChatRoom *room)
}
static gint
_compare_occupants(Occupant *a, Occupant *b)
_compare_occupants(Occupant* a, Occupant* b)
{
const char * utf8_str_a = a->nick_collate_key;
const char * utf8_str_b = b->nick_collate_key;
const char* utf8_str_a = a->nick_collate_key;
const char* utf8_str_b = b->nick_collate_key;
gint result = g_strcmp0(utf8_str_a, utf8_str_b);
@@ -955,7 +954,7 @@ _compare_occupants(Occupant *a, Occupant *b)
}
static muc_role_t
_role_from_string(const char *const role)
_role_from_string(const char* const role)
{
if (role) {
if (g_strcmp0(role, "visitor") == 0) {
@@ -975,7 +974,7 @@ _role_from_string(const char *const role)
static char*
_role_to_string(muc_role_t role)
{
char *result = NULL;
char* result = NULL;
switch (role) {
case MUC_ROLE_NONE:
@@ -999,7 +998,7 @@ _role_to_string(muc_role_t role)
}
static muc_affiliation_t
_affiliation_from_string(const char *const affiliation)
_affiliation_from_string(const char* const affiliation)
{
if (affiliation) {
if (g_strcmp0(affiliation, "outcast") == 0) {
@@ -1021,7 +1020,7 @@ _affiliation_from_string(const char *const affiliation)
static char*
_affiliation_to_string(muc_affiliation_t affiliation)
{
char *result = NULL;
char* result = NULL;
switch (affiliation) {
case MUC_AFFILIATION_NONE:
@@ -1048,10 +1047,10 @@ _affiliation_to_string(muc_affiliation_t affiliation)
}
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)
_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)
{
Occupant *occupant = malloc(sizeof(Occupant));
Occupant* occupant = malloc(sizeof(Occupant));
if (nick) {
occupant->nick = strdup(nick);
@@ -1082,7 +1081,7 @@ _muc_occupant_new(const char *const nick, const char *const jid, muc_role_t role
}
static void
_occupant_free(Occupant *occupant)
_occupant_free(Occupant* occupant)
{
if (occupant) {
free(occupant->nick);

121
src/xmpp/muc.h
View File

@@ -70,98 +70,99 @@ typedef enum {
MUC_ANONYMITY_TYPE_SEMIANONYMOUS
} muc_anonymity_type_t;
typedef struct _muc_occupant_t {
char *nick;
gchar *nick_collate_key;
char *jid;
typedef struct _muc_occupant_t
{
char* nick;
gchar* nick_collate_key;
char* jid;
muc_role_t role;
muc_affiliation_t affiliation;
resource_presence_t presence;
char *status;
char* status;
} Occupant;
void muc_init(void);
void muc_close(void);
void muc_join(const char *const room, const char *const nick, const char *const password, gboolean autojoin);
void muc_leave(const char *const room);
void muc_join(const char* const room, const char* const nick, const char* const password, gboolean autojoin);
void muc_leave(const char* const room);
gboolean muc_active(const char *const room);
gboolean muc_autojoin(const char *const room);
gboolean muc_active(const char* const room);
gboolean muc_autojoin(const char* const room);
GList* muc_rooms(void);
void muc_set_features(const char *const room, GSList *features);
void muc_set_features(const char* const room, GSList* features);
char* muc_nick(const char *const room);
char* muc_password(const char *const room);
char* muc_nick(const char* const room);
char* muc_password(const char* const room);
void muc_nick_change_start(const char *const room, const char *const new_nick);
void muc_nick_change_complete(const char *const room, const char *const nick);
gboolean muc_nick_change_pending(const char *const room);
char* muc_old_nick(const char *const room, const char *const new_nick);
void muc_nick_change_start(const char* const room, const char* const new_nick);
void muc_nick_change_complete(const char* const room, const char* const nick);
gboolean muc_nick_change_pending(const char* const room);
char* muc_old_nick(const char* const room, const char* const new_nick);
gboolean muc_roster_contains_nick(const char *const room, const char *const nick);
gboolean muc_roster_complete(const char *const room);
gboolean 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);
void muc_roster_remove(const char *const room, const char *const nick);
void muc_roster_set_complete(const char *const room);
GList* muc_roster(const char *const room);
Autocomplete muc_roster_ac(const char *const room);
Autocomplete muc_roster_jid_ac(const char *const room);
void muc_jid_autocomplete_reset(const char *const room);
void muc_jid_autocomplete_add_all(const char *const room, GSList *jids);
gboolean muc_roster_contains_nick(const char* const room, const char* const nick);
gboolean muc_roster_complete(const char* const room);
gboolean 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);
void muc_roster_remove(const char* const room, const char* const nick);
void muc_roster_set_complete(const char* const room);
GList* muc_roster(const char* const room);
Autocomplete muc_roster_ac(const char* const room);
Autocomplete muc_roster_jid_ac(const char* const room);
void muc_jid_autocomplete_reset(const char* const room);
void muc_jid_autocomplete_add_all(const char* const room, GSList* jids);
Occupant* muc_roster_item(const char *const room, const char *const nick);
Occupant* muc_roster_item(const char* const room, const char* const nick);
gboolean muc_occupant_available(Occupant *occupant);
const char* muc_occupant_affiliation_str(Occupant *occupant);
const char* muc_occupant_role_str(Occupant *occupant);
GSList* muc_occupants_by_role(const char *const room, muc_role_t role);
GSList* muc_occupants_by_affiliation(const char *const room, muc_affiliation_t affiliation);
gboolean muc_occupant_available(Occupant* occupant);
const char* muc_occupant_affiliation_str(Occupant* occupant);
const char* muc_occupant_role_str(Occupant* occupant);
GSList* muc_occupants_by_role(const char* const room, muc_role_t role);
GSList* muc_occupants_by_affiliation(const char* const room, muc_affiliation_t affiliation);
void muc_occupant_nick_change_start(const char *const room, const char *const new_nick, const char *const old_nick);
char* muc_roster_nick_change_complete(const char *const room, const char *const nick);
void muc_occupant_nick_change_start(const char* const room, const char* const new_nick, const char* const old_nick);
char* muc_roster_nick_change_complete(const char* const room, const char* const nick);
void muc_confserver_add(const char *const server);
void muc_confserver_add(const char* const server);
void muc_confserver_reset_ac(void);
char* muc_confserver_find(const char *const search_str, gboolean previous, void *context);
char* muc_confserver_find(const char* const search_str, gboolean previous, void* context);
void muc_confserver_clear(void);
void muc_invites_add(const char *const room, const char *const password);
void muc_invites_remove(const char *const room);
void muc_invites_add(const char* const room, const char* const password);
void muc_invites_remove(const char* const room);
gint muc_invites_count(void);
GList* muc_invites(void);
gboolean muc_invites_contain(const char *const room);
gboolean muc_invites_contain(const char* const room);
void muc_invites_reset_ac(void);
char* muc_invites_find(const char *const search_str, gboolean previous, void *context);
char* muc_invites_find(const char* const search_str, gboolean previous, void* context);
void muc_invites_clear(void);
char* muc_invite_password(const char *const room);
char* muc_invite_password(const char* const room);
void muc_set_subject(const char *const room, const char *const subject);
char* muc_subject(const char *const room);
void muc_set_subject(const char* const room, const char* const subject);
char* muc_subject(const char* const room);
void muc_pending_broadcasts_add(const char *const room, const char *const message);
GList* muc_pending_broadcasts(const char *const room);
void muc_pending_broadcasts_add(const char* const room, const char* const message);
GList* muc_pending_broadcasts(const char* const room);
char* muc_autocomplete(ProfWin *window, const char *const input, gboolean previous);
void muc_autocomplete_reset(const char *const room);
char* muc_autocomplete(ProfWin* window, const char* const input, gboolean previous);
void muc_autocomplete_reset(const char* const room);
gboolean muc_requires_config(const char *const room);
void muc_set_requires_config(const char *const room, gboolean val);
gboolean muc_requires_config(const char* const room);
void muc_set_requires_config(const char* const room, gboolean val);
void muc_set_role(const char *const room, const char *const role);
void muc_set_affiliation(const char *const room, const char *const affiliation);
char* muc_role_str(const char *const room);
char* muc_affiliation_str(const char *const room);
void muc_set_role(const char* const room, const char* const role);
void muc_set_affiliation(const char* const room, const char* const affiliation);
char* muc_role_str(const char* const room);
char* muc_affiliation_str(const char* const room);
muc_member_type_t muc_member_type(const char *const room);
muc_anonymity_type_t muc_anonymity_type(const char *const room);
muc_member_type_t muc_member_type(const char* const room);
muc_anonymity_type_t muc_anonymity_type(const char* const room);
GList* muc_members(const char *const room);
void muc_members_add(const char *const room, const char *const jid);
void muc_members_remove(const char *const room, const char *const jid);
void muc_members_update(const char *const room, const char *const jid, const char *const affiliation);
GList* muc_members(const char* const room);
void muc_members_add(const char* const room, const char* const jid);
void muc_members_remove(const char* const room, const char* const jid);
void muc_members_update(const char* const room, const char* const jid, const char* const affiliation);
#endif

232
src/xmpp/omemo.c
View File

@@ -44,10 +44,10 @@
#include "omemo/omemo.h"
static int _omemo_receive_devicelist(xmpp_stanza_t *const stanza, void *const userdata);
static int _omemo_bundle_publish_result(xmpp_stanza_t *const stanza, void *const userdata);
static int _omemo_bundle_publish_configure(xmpp_stanza_t *const stanza, void *const userdata);
static int _omemo_bundle_publish_configure_result(xmpp_stanza_t *const stanza, void *const userdata);
static int _omemo_receive_devicelist(xmpp_stanza_t* const stanza, void* const userdata);
static int _omemo_bundle_publish_result(xmpp_stanza_t* const stanza, void* const userdata);
static int _omemo_bundle_publish_configure(xmpp_stanza_t* const stanza, void* const userdata);
static int _omemo_bundle_publish_configure_result(xmpp_stanza_t* const stanza, void* const userdata);
void
omemo_devicelist_subscribe(void)
@@ -58,10 +58,10 @@ omemo_devicelist_subscribe(void)
}
void
omemo_devicelist_publish(GList *device_list)
omemo_devicelist_publish(GList* device_list)
{
xmpp_ctx_t * const ctx = connection_get_ctx();
xmpp_stanza_t *iq = stanza_create_omemo_devicelist_publish(ctx, device_list);
xmpp_ctx_t* const ctx = connection_get_ctx();
xmpp_stanza_t* iq = stanza_create_omemo_devicelist_publish(ctx, device_list);
if (connection_supports(XMPP_FEATURE_PUBSUB_PUBLISH_OPTIONS)) {
stanza_attach_publish_options(ctx, iq, "pubsub#access_model", "open");
@@ -72,12 +72,12 @@ omemo_devicelist_publish(GList *device_list)
}
void
omemo_devicelist_request(const char * const jid)
omemo_devicelist_request(const char* const jid)
{
xmpp_ctx_t * const ctx = connection_get_ctx();
char *id = connection_create_stanza_id();
xmpp_ctx_t* const ctx = connection_get_ctx();
char* id = connection_create_stanza_id();
xmpp_stanza_t *iq = stanza_create_omemo_devicelist_request(ctx, id, jid);
xmpp_stanza_t* iq = stanza_create_omemo_devicelist_request(ctx, id, jid);
iq_id_handler_add(id, _omemo_receive_devicelist, NULL, NULL);
iq_send_stanza(iq);
@@ -89,12 +89,12 @@ omemo_devicelist_request(const char * const jid)
void
omemo_bundle_publish(gboolean first)
{
xmpp_ctx_t * const ctx = connection_get_ctx();
unsigned char *identity_key = NULL;
xmpp_ctx_t* const ctx = connection_get_ctx();
unsigned char* identity_key = NULL;
size_t identity_key_length;
unsigned char *signed_prekey = NULL;
unsigned char* signed_prekey = NULL;
size_t signed_prekey_length;
unsigned char *signed_prekey_signature = NULL;
unsigned char* signed_prekey_signature = NULL;
size_t signed_prekey_signature_length;
GList *prekeys = NULL, *ids = NULL, *lengths = NULL;
@@ -103,11 +103,11 @@ omemo_bundle_publish(gboolean first)
omemo_signed_prekey_signature(&signed_prekey_signature, &signed_prekey_signature_length);
omemo_prekeys(&prekeys, &ids, &lengths);
char *id = connection_create_stanza_id();
xmpp_stanza_t *iq = stanza_create_omemo_bundle_publish(ctx, id,
omemo_device_id(), identity_key, identity_key_length, signed_prekey,
signed_prekey_length, signed_prekey_signature,
signed_prekey_signature_length, prekeys, ids, lengths);
char* id = connection_create_stanza_id();
xmpp_stanza_t* iq = stanza_create_omemo_bundle_publish(ctx, id,
omemo_device_id(), identity_key, identity_key_length, signed_prekey,
signed_prekey_length, signed_prekey_signature,
signed_prekey_signature_length, prekeys, ids, lengths);
g_list_free_full(prekeys, free);
g_list_free(lengths);
@@ -129,12 +129,12 @@ omemo_bundle_publish(gboolean first)
}
void
omemo_bundle_request(const char * const jid, uint32_t device_id, ProfIqCallback func, ProfIqFreeCallback free_func, void *userdata)
omemo_bundle_request(const char* const jid, uint32_t device_id, ProfIqCallback func, ProfIqFreeCallback free_func, void* userdata)
{
xmpp_ctx_t * const ctx = connection_get_ctx();
char *id = connection_create_stanza_id();
xmpp_ctx_t* const ctx = connection_get_ctx();
char* id = connection_create_stanza_id();
xmpp_stanza_t *iq = stanza_create_omemo_bundle_request(ctx, id, jid, device_id);
xmpp_stanza_t* iq = stanza_create_omemo_bundle_request(ctx, id, jid, device_id);
iq_id_handler_add(id, func, free_func, userdata);
iq_send_stanza(iq);
@@ -144,17 +144,17 @@ omemo_bundle_request(const char * const jid, uint32_t device_id, ProfIqCallback
}
int
omemo_start_device_session_handle_bundle(xmpp_stanza_t *const stanza, void *const userdata)
omemo_start_device_session_handle_bundle(xmpp_stanza_t* const stanza, void* const userdata)
{
GList *prekeys_list = NULL;
unsigned char *signed_prekey_raw = NULL;
unsigned char *signed_prekey_signature_raw = NULL;
char *from = NULL;
GList* prekeys_list = NULL;
unsigned char* signed_prekey_raw = NULL;
unsigned char* signed_prekey_signature_raw = NULL;
char* from = NULL;
const char *from_attr = xmpp_stanza_get_attribute(stanza, STANZA_ATTR_FROM);
const char* from_attr = xmpp_stanza_get_attribute(stanza, STANZA_ATTR_FROM);
if (!from_attr) {
Jid *jid = jid_create(connection_get_fulljid());
Jid* jid = jid_create(connection_get_fulljid());
from = strdup(jid->barejid);
jid_destroy(jid);
} else {
@@ -165,62 +165,62 @@ omemo_start_device_session_handle_bundle(xmpp_stanza_t *const stanza, void *cons
goto out;
}
xmpp_stanza_t *pubsub = xmpp_stanza_get_child_by_ns(stanza, STANZA_NS_PUBSUB);
xmpp_stanza_t* pubsub = xmpp_stanza_get_child_by_ns(stanza, STANZA_NS_PUBSUB);
if (!pubsub) {
goto out;
}
xmpp_stanza_t *items = xmpp_stanza_get_child_by_name(pubsub, "items");
xmpp_stanza_t* items = xmpp_stanza_get_child_by_name(pubsub, "items");
if (!items) {
goto out;
}
const char *node = xmpp_stanza_get_attribute(items, "node");
char *device_id_str = strstr(node, ":");
const char* node = xmpp_stanza_get_attribute(items, "node");
char* device_id_str = strstr(node, ":");
if (!device_id_str) {
goto out;
}
uint32_t device_id = strtoul(++device_id_str, NULL, 10);
xmpp_stanza_t *item = xmpp_stanza_get_child_by_name(items, "item");
xmpp_stanza_t* item = xmpp_stanza_get_child_by_name(items, "item");
if (!item) {
goto out;
}
xmpp_stanza_t *bundle = xmpp_stanza_get_child_by_ns(item, STANZA_NS_OMEMO);
xmpp_stanza_t* bundle = xmpp_stanza_get_child_by_ns(item, STANZA_NS_OMEMO);
if (!bundle) {
goto out;
}
xmpp_stanza_t *prekeys = xmpp_stanza_get_child_by_name(bundle, "prekeys");
xmpp_stanza_t* prekeys = xmpp_stanza_get_child_by_name(bundle, "prekeys");
if (!prekeys) {
goto out;
}
xmpp_stanza_t *prekey;
xmpp_stanza_t* prekey;
for (prekey = xmpp_stanza_get_children(prekeys); prekey != NULL; prekey = xmpp_stanza_get_next(prekey)) {
if (g_strcmp0(xmpp_stanza_get_name(prekey), "preKeyPublic") != 0) {
continue;
}
omemo_key_t *key = malloc(sizeof(omemo_key_t));
omemo_key_t* key = malloc(sizeof(omemo_key_t));
key->data = NULL;
const char *prekey_id_text = xmpp_stanza_get_attribute(prekey, "preKeyId");
const char* prekey_id_text = xmpp_stanza_get_attribute(prekey, "preKeyId");
if (!prekey_id_text) {
omemo_key_free(key);
continue;
}
key->id = strtoul(prekey_id_text, NULL, 10);
xmpp_stanza_t *prekey_text = xmpp_stanza_get_children(prekey);
xmpp_stanza_t* prekey_text = xmpp_stanza_get_children(prekey);
if (!prekey_text) {
omemo_key_free(key);
continue;
}
char *prekey_b64 = xmpp_stanza_get_text(prekey_text);
char* prekey_b64 = xmpp_stanza_get_text(prekey_text);
key->data = g_base64_decode(prekey_b64, &key->length);
free(prekey_b64);
if (!key->data) {
@@ -233,64 +233,64 @@ omemo_start_device_session_handle_bundle(xmpp_stanza_t *const stanza, void *cons
prekeys_list = g_list_append(prekeys_list, key);
}
xmpp_stanza_t *signed_prekey = xmpp_stanza_get_child_by_name(bundle, "signedPreKeyPublic");
xmpp_stanza_t* signed_prekey = xmpp_stanza_get_child_by_name(bundle, "signedPreKeyPublic");
if (!signed_prekey) {
goto out;
}
const char *signed_prekey_id_text = xmpp_stanza_get_attribute(signed_prekey, "signedPreKeyId");
const char* signed_prekey_id_text = xmpp_stanza_get_attribute(signed_prekey, "signedPreKeyId");
if (!signed_prekey_id_text) {
goto out;
}
uint32_t signed_prekey_id = strtoul(signed_prekey_id_text, NULL, 10);
xmpp_stanza_t *signed_prekey_text = xmpp_stanza_get_children(signed_prekey);
xmpp_stanza_t* signed_prekey_text = xmpp_stanza_get_children(signed_prekey);
if (!signed_prekey_text) {
goto out;
}
size_t signed_prekey_len;
char *signed_prekey_b64 = xmpp_stanza_get_text(signed_prekey_text);
char* signed_prekey_b64 = xmpp_stanza_get_text(signed_prekey_text);
signed_prekey_raw = g_base64_decode(signed_prekey_b64, &signed_prekey_len);
free(signed_prekey_b64);
if (!signed_prekey_raw) {
goto out;
}
xmpp_stanza_t *signed_prekey_signature = xmpp_stanza_get_child_by_name(bundle, "signedPreKeySignature");
xmpp_stanza_t* signed_prekey_signature = xmpp_stanza_get_child_by_name(bundle, "signedPreKeySignature");
if (!signed_prekey_signature) {
goto out;
}
xmpp_stanza_t *signed_prekey_signature_text = xmpp_stanza_get_children(signed_prekey_signature);
xmpp_stanza_t* signed_prekey_signature_text = xmpp_stanza_get_children(signed_prekey_signature);
if (!signed_prekey_signature_text) {
goto out;
}
size_t signed_prekey_signature_len;
char *signed_prekey_signature_b64 = xmpp_stanza_get_text(signed_prekey_signature_text);
char* signed_prekey_signature_b64 = xmpp_stanza_get_text(signed_prekey_signature_text);
signed_prekey_signature_raw = g_base64_decode(signed_prekey_signature_b64, &signed_prekey_signature_len);
free(signed_prekey_signature_b64);
if (!signed_prekey_signature_raw) {
goto out;
}
xmpp_stanza_t *identity_key = xmpp_stanza_get_child_by_name(bundle, "identityKey");
xmpp_stanza_t* identity_key = xmpp_stanza_get_child_by_name(bundle, "identityKey");
if (!identity_key) {
goto out;
}
xmpp_stanza_t *identity_key_text = xmpp_stanza_get_children(identity_key);
xmpp_stanza_t* identity_key_text = xmpp_stanza_get_children(identity_key);
if (!identity_key_text) {
goto out;
}
size_t identity_key_len;
char *identity_key_b64 = xmpp_stanza_get_text(identity_key_text);
unsigned char *identity_key_raw = g_base64_decode(identity_key_b64, &identity_key_len);
char* identity_key_b64 = xmpp_stanza_get_text(identity_key_text);
unsigned char* identity_key_raw = g_base64_decode(identity_key_b64, &identity_key_len);
free(identity_key_b64);
if (!identity_key_raw) {
goto out;
}
omemo_start_device_session(from, device_id, prekeys_list, signed_prekey_id,
signed_prekey_raw, signed_prekey_len, signed_prekey_signature_raw,
signed_prekey_signature_len, identity_key_raw, identity_key_len);
signed_prekey_raw, signed_prekey_len, signed_prekey_signature_raw,
signed_prekey_signature_len, identity_key_raw, identity_key_len);
g_free(identity_key_raw);
@@ -308,34 +308,34 @@ out:
return 1;
}
char *
omemo_receive_message(xmpp_stanza_t *const stanza, gboolean *trusted)
char*
omemo_receive_message(xmpp_stanza_t* const stanza, gboolean* trusted)
{
char *plaintext = NULL;
const char *type = xmpp_stanza_get_type(stanza);
GList *keys = NULL;
unsigned char *iv_raw = NULL;
unsigned char *payload_raw = NULL;
char *iv_text = NULL;
char *payload_text = NULL;
char* plaintext = NULL;
const char* type = xmpp_stanza_get_type(stanza);
GList* keys = NULL;
unsigned char* iv_raw = NULL;
unsigned char* payload_raw = NULL;
char* iv_text = NULL;
char* payload_text = NULL;
xmpp_stanza_t *encrypted = xmpp_stanza_get_child_by_ns(stanza, STANZA_NS_OMEMO);
xmpp_stanza_t* encrypted = xmpp_stanza_get_child_by_ns(stanza, STANZA_NS_OMEMO);
if (!encrypted) {
return NULL;
}
xmpp_stanza_t *header = xmpp_stanza_get_child_by_name(encrypted, "header");
xmpp_stanza_t* header = xmpp_stanza_get_child_by_name(encrypted, "header");
if (!header) {
return NULL;
}
const char *sid_text = xmpp_stanza_get_attribute(header, "sid");
const char* sid_text = xmpp_stanza_get_attribute(header, "sid");
if (!sid_text) {
return NULL;
}
uint32_t sid = strtoul(sid_text, NULL, 10);
xmpp_stanza_t *iv = xmpp_stanza_get_child_by_name(header, "iv");
xmpp_stanza_t* iv = xmpp_stanza_get_child_by_name(header, "iv");
if (!iv) {
return NULL;
}
@@ -349,7 +349,7 @@ omemo_receive_message(xmpp_stanza_t *const stanza, gboolean *trusted)
goto out;
}
xmpp_stanza_t *payload = xmpp_stanza_get_child_by_name(encrypted, "payload");
xmpp_stanza_t* payload = xmpp_stanza_get_child_by_name(encrypted, "payload");
if (!payload) {
goto out;
}
@@ -363,19 +363,19 @@ omemo_receive_message(xmpp_stanza_t *const stanza, gboolean *trusted)
goto out;
}
xmpp_stanza_t *key_stanza;
xmpp_stanza_t* key_stanza;
for (key_stanza = xmpp_stanza_get_children(header); key_stanza != NULL; key_stanza = xmpp_stanza_get_next(key_stanza)) {
if (g_strcmp0(xmpp_stanza_get_name(key_stanza), "key") != 0) {
continue;
}
omemo_key_t *key = malloc(sizeof(omemo_key_t));
char *key_text = xmpp_stanza_get_text(key_stanza);
omemo_key_t* key = malloc(sizeof(omemo_key_t));
char* key_text = xmpp_stanza_get_text(key_stanza);
if (!key_text) {
goto skip;
}
const char *rid_text = xmpp_stanza_get_attribute(key_stanza, "rid");
const char* rid_text = xmpp_stanza_get_attribute(key_stanza, "rid");
key->device_id = strtoul(rid_text, NULL, 10);
if (!key->device_id) {
goto skip;
@@ -386,21 +386,20 @@ omemo_receive_message(xmpp_stanza_t *const stanza, gboolean *trusted)
if (!key->data) {
goto skip;
}
key->prekey =
g_strcmp0(xmpp_stanza_get_attribute(key_stanza, "prekey"), "true") == 0
|| g_strcmp0(xmpp_stanza_get_attribute(key_stanza, "prekey"), "1") == 0;
key->prekey = g_strcmp0(xmpp_stanza_get_attribute(key_stanza, "prekey"), "true") == 0
|| g_strcmp0(xmpp_stanza_get_attribute(key_stanza, "prekey"), "1") == 0;
keys = g_list_append(keys, key);
continue;
skip:
skip:
free(key);
}
const char *from = xmpp_stanza_get_from(stanza);
const char* from = xmpp_stanza_get_from(stanza);
plaintext = omemo_on_message_recv(from, sid, iv_raw, iv_len,
keys, payload_raw, payload_len,
g_strcmp0(type, STANZA_TYPE_GROUPCHAT) == 0, trusted);
keys, payload_raw, payload_len,
g_strcmp0(type, STANZA_TYPE_GROUPCHAT) == 0, trusted);
out:
if (keys) {
@@ -416,18 +415,18 @@ out:
}
static int
_omemo_receive_devicelist(xmpp_stanza_t *const stanza, void *const userdata)
_omemo_receive_devicelist(xmpp_stanza_t* const stanza, void* const userdata)
{
GList *device_list = NULL;
const char *from = xmpp_stanza_get_attribute(stanza, STANZA_ATTR_FROM);
GList* device_list = NULL;
const char* from = xmpp_stanza_get_attribute(stanza, STANZA_ATTR_FROM);
xmpp_stanza_t *root = NULL;
xmpp_stanza_t *event = xmpp_stanza_get_child_by_ns(stanza, STANZA_NS_PUBSUB_EVENT);
xmpp_stanza_t* root = NULL;
xmpp_stanza_t* event = xmpp_stanza_get_child_by_ns(stanza, STANZA_NS_PUBSUB_EVENT);
if (event) {
root = event;
}
xmpp_stanza_t *pubsub = xmpp_stanza_get_child_by_ns(stanza, STANZA_NS_PUBSUB);
xmpp_stanza_t* pubsub = xmpp_stanza_get_child_by_ns(stanza, STANZA_NS_PUBSUB);
if (pubsub) {
root = pubsub;
}
@@ -436,21 +435,20 @@ _omemo_receive_devicelist(xmpp_stanza_t *const stanza, void *const userdata)
return 1;
}
xmpp_stanza_t *items = xmpp_stanza_get_child_by_name(root, "items");
xmpp_stanza_t* items = xmpp_stanza_get_child_by_name(root, "items");
if (!items) {
return 1;
}
// Looking for "current" item - if there is no current, take the first item.
xmpp_stanza_t* first = NULL;
xmpp_stanza_t* current = NULL;
xmpp_stanza_t *item = xmpp_stanza_get_children(items);
while ( item ) {
xmpp_stanza_t* item = xmpp_stanza_get_children(items);
while (item) {
if (g_strcmp0(xmpp_stanza_get_name(item), "item") == 0) {
first = item;
if (g_strcmp0(xmpp_stanza_get_id(item), "current") == 0 ) {
if (g_strcmp0(xmpp_stanza_get_id(item), "current") == 0) {
current = item;
break;
}
@@ -458,27 +456,27 @@ _omemo_receive_devicelist(xmpp_stanza_t *const stanza, void *const userdata)
item = xmpp_stanza_get_next(item);
}
if(current) {
if (current) {
item = current;
} else if( first ) {
} else if (first) {
log_warning("OMEMO: User %s has a non 'current' device item list: %s.", from, xmpp_stanza_get_id(first));
item = first;
} else {
return 1;
}
xmpp_stanza_t *list = xmpp_stanza_get_child_by_ns(item, STANZA_NS_OMEMO);
xmpp_stanza_t* list = xmpp_stanza_get_child_by_ns(item, STANZA_NS_OMEMO);
if (!list) {
return 1;
}
xmpp_stanza_t *device;
xmpp_stanza_t* device;
for (device = xmpp_stanza_get_children(list); device != NULL; device = xmpp_stanza_get_next(device)) {
if (g_strcmp0(xmpp_stanza_get_name(device), "device") != 0) {
continue;
}
const char *id = xmpp_stanza_get_id(device);
const char* id = xmpp_stanza_get_id(device);
if (id != NULL) {
device_list = g_list_append(device_list, GINT_TO_POINTER(strtoul(id, NULL, 10)));
} else {
@@ -492,9 +490,9 @@ _omemo_receive_devicelist(xmpp_stanza_t *const stanza, void *const userdata)
}
static int
_omemo_bundle_publish_result(xmpp_stanza_t *const stanza, void *const userdata)
_omemo_bundle_publish_result(xmpp_stanza_t* const stanza, void* const userdata)
{
const char *type = xmpp_stanza_get_type(stanza);
const char* type = xmpp_stanza_get_type(stanza);
if (g_strcmp0(type, STANZA_TYPE_ERROR) != 0) {
return 0;
@@ -506,11 +504,11 @@ _omemo_bundle_publish_result(xmpp_stanza_t *const stanza, void *const userdata)
}
log_info("OMEMO: cannot publish bundle with open access model, trying to configure node");
xmpp_ctx_t * const ctx = connection_get_ctx();
Jid *jid = jid_create(connection_get_fulljid());
char *id = connection_create_stanza_id();
char *node = g_strdup_printf("%s:%d", STANZA_NS_OMEMO_BUNDLES, omemo_device_id());
xmpp_stanza_t *iq = stanza_create_pubsub_configure_request(ctx, id, jid->barejid, node);
xmpp_ctx_t* const ctx = connection_get_ctx();
Jid* jid = jid_create(connection_get_fulljid());
char* id = connection_create_stanza_id();
char* node = g_strdup_printf("%s:%d", STANZA_NS_OMEMO_BUNDLES, omemo_device_id());
xmpp_stanza_t* iq = stanza_create_pubsub_configure_request(ctx, id, jid->barejid, node);
g_free(node);
iq_id_handler_add(id, _omemo_bundle_publish_configure, NULL, userdata);
@@ -524,26 +522,26 @@ _omemo_bundle_publish_result(xmpp_stanza_t *const stanza, void *const userdata)
}
static int
_omemo_bundle_publish_configure(xmpp_stanza_t *const stanza, void *const userdata)
_omemo_bundle_publish_configure(xmpp_stanza_t* const stanza, void* const userdata)
{
/* TODO handle error */
xmpp_stanza_t *pubsub = xmpp_stanza_get_child_by_name(stanza, "pubsub");
xmpp_stanza_t *configure = xmpp_stanza_get_child_by_name(pubsub, STANZA_NAME_CONFIGURE);
xmpp_stanza_t *x = xmpp_stanza_get_child_by_name(configure, "x");
xmpp_stanza_t* pubsub = xmpp_stanza_get_child_by_name(stanza, "pubsub");
xmpp_stanza_t* configure = xmpp_stanza_get_child_by_name(pubsub, STANZA_NAME_CONFIGURE);
xmpp_stanza_t* x = xmpp_stanza_get_child_by_name(configure, "x");
DataForm* form = form_create(x);
char *tag = g_hash_table_lookup(form->var_to_tag, "pubsub#access_model");
char* tag = g_hash_table_lookup(form->var_to_tag, "pubsub#access_model");
if (!tag) {
log_info("OMEMO: cannot configure bundle to an open access model");
return 0;
}
form_set_value(form, tag, "open");
xmpp_ctx_t * const ctx = connection_get_ctx();
Jid *jid = jid_create(connection_get_fulljid());
char *id = connection_create_stanza_id();
char *node = g_strdup_printf("%s:%d", STANZA_NS_OMEMO_BUNDLES, omemo_device_id());
xmpp_stanza_t *iq = stanza_create_pubsub_configure_submit(ctx, id, jid->barejid, node, form);
xmpp_ctx_t* const ctx = connection_get_ctx();
Jid* jid = jid_create(connection_get_fulljid());
char* id = connection_create_stanza_id();
char* node = g_strdup_printf("%s:%d", STANZA_NS_OMEMO_BUNDLES, omemo_device_id());
xmpp_stanza_t* iq = stanza_create_pubsub_configure_submit(ctx, id, jid->barejid, node, form);
g_free(node);
iq_id_handler_add(id, _omemo_bundle_publish_configure_result, NULL, userdata);
@@ -557,9 +555,9 @@ _omemo_bundle_publish_configure(xmpp_stanza_t *const stanza, void *const userdat
}
static int
_omemo_bundle_publish_configure_result(xmpp_stanza_t *const stanza, void *const userdata)
_omemo_bundle_publish_configure_result(xmpp_stanza_t* const stanza, void* const userdata)
{
const char *type = xmpp_stanza_get_type(stanza);
const char* type = xmpp_stanza_get_type(stanza);
if (g_strcmp0(type, STANZA_TYPE_ERROR) == 0) {
log_error("OMEMO: cannot configure bundle to an open access model");

10
src/xmpp/omemo.h
View File

@@ -38,9 +38,9 @@
#include "xmpp/iq.h"
void omemo_devicelist_subscribe(void);
void omemo_devicelist_publish(GList *device_list);
void omemo_devicelist_request(const char * const jid);
void omemo_devicelist_publish(GList* device_list);
void omemo_devicelist_request(const char* const jid);
void omemo_bundle_publish(gboolean first);
void omemo_bundle_request(const char * const jid, uint32_t device_id, ProfIqCallback func, ProfIqFreeCallback free_func, void *userdata);
int omemo_start_device_session_handle_bundle(xmpp_stanza_t *const stanza, void *const userdata);
char * omemo_receive_message(xmpp_stanza_t *const stanza, gboolean *trusted);
void omemo_bundle_request(const char* const jid, uint32_t device_id, ProfIqCallback func, ProfIqFreeCallback free_func, void* userdata);
int omemo_start_device_session_handle_bundle(xmpp_stanza_t* const stanza, void* const userdata);
char* omemo_receive_message(xmpp_stanza_t* const stanza, gboolean* trusted);

74
src/xmpp/ox.c
View File

@@ -33,15 +33,14 @@
*
*/
#include <glib.h>
#include <assert.h>
#include <glib.h>
#include "log.h"
#include "pgp/gpg.h"
#include "ui/ui.h"
#include "xmpp/connection.h"
#include "xmpp/stanza.h"
#include "pgp/gpg.h"
static void _ox_metadata_node__public_key(const char* const fingerprint);
@@ -77,8 +76,9 @@ static char* _gettimestamp();
*
*/
gboolean
ox_announce_public_key(const char* const filename) {
gboolean
ox_announce_public_key(const char* const filename)
{
assert(filename);
cons_show("Annonuce OpenPGP Key for OX %s ...", filename);
@@ -89,13 +89,13 @@ ox_announce_public_key(const char* const filename) {
char* fp = NULL;
p_ox_gpg_readkey(filename, &key, &fp);
if( !(key && fp) ) {
if (!(key && fp)) {
cons_show("Error during OpenPGP OX announce. See log file for more information");
return FALSE;
} else {
log_info("Annonuce OpenPGP Key for Fingerprint: %s", fp);
xmpp_ctx_t * const ctx = connection_get_ctx();
char *id = xmpp_uuid_gen(ctx);
xmpp_ctx_t* const ctx = connection_get_ctx();
char* id = xmpp_uuid_gen(ctx);
xmpp_stanza_t* iq = xmpp_iq_new(ctx, STANZA_TYPE_SET, id);
xmpp_stanza_set_from(iq, xmpp_conn_get_jid(connection_get_conn()));
@@ -108,22 +108,21 @@ ox_announce_public_key(const char* const filename) {
g_string_append(node_name, fp);
xmpp_stanza_t* publish = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(publish, STANZA_NAME_PUBLISH);
xmpp_stanza_set_attribute(publish, STANZA_ATTR_NODE, node_name->str) ;
xmpp_stanza_set_name(publish, STANZA_NAME_PUBLISH);
xmpp_stanza_set_attribute(publish, STANZA_ATTR_NODE, node_name->str);
xmpp_stanza_t* item = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(item, STANZA_NAME_ITEM);
xmpp_stanza_set_attribute(item, STANZA_ATTR_ID, _gettimestamp()) ;
xmpp_stanza_set_name(item, STANZA_NAME_ITEM);
xmpp_stanza_set_attribute(item, STANZA_ATTR_ID, _gettimestamp());
xmpp_stanza_t* pubkey = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(pubkey, STANZA_NAME_PUPKEY);
xmpp_stanza_set_name(pubkey, STANZA_NAME_PUPKEY);
xmpp_stanza_set_ns(pubkey, STANZA_NS_OPENPGP_0);
xmpp_stanza_t* data = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(data, STANZA_NAME_DATA);
xmpp_stanza_t* keydata = xmpp_stanza_new(ctx);
xmpp_stanza_set_text(keydata,key);
xmpp_stanza_set_name(data, STANZA_NAME_DATA);
xmpp_stanza_t* keydata = xmpp_stanza_new(ctx);
xmpp_stanza_set_text(keydata, key);
xmpp_stanza_add_child(data, keydata);
xmpp_stanza_add_child(pubkey, data);
@@ -131,10 +130,9 @@ ox_announce_public_key(const char* const filename) {
xmpp_stanza_add_child(publish, item);
xmpp_stanza_add_child(pubsub, publish);
xmpp_stanza_add_child(iq, pubsub);
xmpp_send (connection_get_conn(), iq);
xmpp_send(connection_get_conn(), iq);
_ox_metadata_node__public_key(fp);
}
return TRUE;
}
@@ -166,14 +164,15 @@ ox_announce_public_key(const char* const filename) {
*
*/
void
_ox_metadata_node__public_key(const char* const fingerprint) {
void
_ox_metadata_node__public_key(const char* const fingerprint)
{
log_info("Annonuce OpenPGP metadata: %s", fingerprint);
assert(fingerprint);
assert(strlen(fingerprint) == 40);
// iq
xmpp_ctx_t * const ctx = connection_get_ctx();
char *id = xmpp_uuid_gen(ctx);
xmpp_ctx_t* const ctx = connection_get_ctx();
char* id = xmpp_uuid_gen(ctx);
xmpp_stanza_t* iq = xmpp_iq_new(ctx, STANZA_TYPE_SET, id);
xmpp_stanza_set_from(iq, xmpp_conn_get_jid(connection_get_conn()));
// pubsub
@@ -182,31 +181,33 @@ _ox_metadata_node__public_key(const char* const fingerprint) {
xmpp_stanza_set_ns(pubsub, XMPP_FEATURE_PUBSUB);
// publish
xmpp_stanza_t* publish = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(publish, STANZA_NAME_PUBLISH);
xmpp_stanza_set_attribute(publish, STANZA_ATTR_NODE, STANZA_NS_OPENPGP_0_PUBLIC_KEYS) ;
xmpp_stanza_set_name(publish, STANZA_NAME_PUBLISH);
xmpp_stanza_set_attribute(publish, STANZA_ATTR_NODE, STANZA_NS_OPENPGP_0_PUBLIC_KEYS);
// item
xmpp_stanza_t* item = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(item, STANZA_NAME_ITEM);
// public-keys-list
// public-keys-list
xmpp_stanza_t* publickeyslist = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(publickeyslist, STANZA_NAME_PUBLIC_KEYS_LIST);
xmpp_stanza_set_name(publickeyslist, STANZA_NAME_PUBLIC_KEYS_LIST);
xmpp_stanza_set_ns(publickeyslist, STANZA_NS_OPENPGP_0);
// pubkey-metadata
xmpp_stanza_t* pubkeymetadata = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(pubkeymetadata, STANZA_NAME_PUBKEY_METADATA);
xmpp_stanza_set_name(pubkeymetadata, STANZA_NAME_PUBKEY_METADATA);
xmpp_stanza_set_attribute(pubkeymetadata, STANZA_ATTR_V4_FINGERPRINT, fingerprint);
xmpp_stanza_set_attribute(pubkeymetadata, STANZA_ATTR_DATE, _gettimestamp());
xmpp_stanza_add_child(publickeyslist,pubkeymetadata );
xmpp_stanza_add_child(item, publickeyslist );
xmpp_stanza_add_child(publish,item );
xmpp_stanza_add_child(publickeyslist, pubkeymetadata);
xmpp_stanza_add_child(item, publickeyslist);
xmpp_stanza_add_child(publish, item);
xmpp_stanza_add_child(pubsub, publish);
xmpp_stanza_add_child(iq, pubsub);
xmpp_send (connection_get_conn(), iq);
}
xmpp_send(connection_get_conn(), iq);
}
// Date and Time (XEP-0082)
char* _gettimestamp() {
char*
_gettimestamp()
{
time_t now = time(NULL);
struct tm* tm = localtime(&now);
char buf[255];
@@ -215,4 +216,3 @@ char* _gettimestamp() {
g_string_append(d, "Z");
return strdup(d->str);
}

3
src/xmpp/ox.h
View File

@@ -43,7 +43,6 @@
* https://xmpp.org/extensions/xep-0373.html
*/
/*!
* \brief Announcing OpenPGP public key from file to PEP.
*
@@ -57,5 +56,3 @@
*/
gboolean ox_announce_public_key(const char* const filename);

416
src/xmpp/presence.c
View File

@@ -50,36 +50,36 @@
#include <strophe.h>
#endif
#include "profanity.h"
#include "log.h"
#include "common.h"
#include "config/preferences.h"
#include "event/server_events.h"
#include "log.h"
#include "plugins/plugins.h"
#include "profanity.h"
#include "ui/ui.h"
#include "xmpp/connection.h"
#include "xmpp/capabilities.h"
#include "xmpp/connection.h"
#include "xmpp/iq.h"
#include "xmpp/muc.h"
#include "xmpp/session.h"
#include "xmpp/stanza.h"
#include "xmpp/iq.h"
#include "xmpp/xmpp.h"
#include "xmpp/muc.h"
static Autocomplete sub_requests_ac;
static int _presence_handler(xmpp_conn_t *const conn, xmpp_stanza_t *const stanza, void *const userdata);
static int _presence_handler(xmpp_conn_t* const conn, xmpp_stanza_t* const stanza, void* const userdata);
static void _presence_error_handler(xmpp_stanza_t *const stanza);
static void _unavailable_handler(xmpp_stanza_t *const stanza);
static void _subscribe_handler(xmpp_stanza_t *const stanza);
static void _subscribed_handler(xmpp_stanza_t *const stanza);
static void _unsubscribed_handler(xmpp_stanza_t *const stanza);
static void _muc_user_handler(xmpp_stanza_t *const stanza);
static void _available_handler(xmpp_stanza_t *const stanza);
static void _presence_error_handler(xmpp_stanza_t* const stanza);
static void _unavailable_handler(xmpp_stanza_t* const stanza);
static void _subscribe_handler(xmpp_stanza_t* const stanza);
static void _subscribed_handler(xmpp_stanza_t* const stanza);
static void _unsubscribed_handler(xmpp_stanza_t* const stanza);
static void _muc_user_handler(xmpp_stanza_t* const stanza);
static void _available_handler(xmpp_stanza_t* const stanza);
void _send_caps_request(char *node, char *caps_key, char *id, char *from);
static void _send_room_presence(xmpp_stanza_t *presence);
static void _send_presence_stanza(xmpp_stanza_t *const stanza);
void _send_caps_request(char* node, char* caps_key, char* id, char* from);
static void _send_room_presence(xmpp_stanza_t* presence);
static void _send_presence_stanza(xmpp_stanza_t* const stanza);
void
presence_sub_requests_init(void)
@@ -90,46 +90,45 @@ presence_sub_requests_init(void)
void
presence_handlers_init(void)
{
xmpp_conn_t * const conn = connection_get_conn();
xmpp_ctx_t * const ctx = connection_get_ctx();
xmpp_conn_t* const conn = connection_get_conn();
xmpp_ctx_t* const ctx = connection_get_ctx();
xmpp_handler_add(conn, _presence_handler, NULL, STANZA_NAME_PRESENCE, NULL, ctx);
}
void
presence_subscription(const char *const jid, const jabber_subscr_t action)
presence_subscription(const char* const jid, const jabber_subscr_t action)
{
assert(jid != NULL);
Jid *jidp = jid_create(jid);
Jid* jidp = jid_create(jid);
autocomplete_remove(sub_requests_ac, jidp->barejid);
const char *type = NULL;
switch (action)
{
case PRESENCE_SUBSCRIBE:
log_debug("Sending presence subscribe: %s", jid);
type = STANZA_TYPE_SUBSCRIBE;
break;
case PRESENCE_SUBSCRIBED:
log_debug("Sending presence subscribed: %s", jid);
type = STANZA_TYPE_SUBSCRIBED;
break;
case PRESENCE_UNSUBSCRIBED:
log_debug("Sending presence usubscribed: %s", jid);
type = STANZA_TYPE_UNSUBSCRIBED;
break;
default:
break;
const char* type = NULL;
switch (action) {
case PRESENCE_SUBSCRIBE:
log_debug("Sending presence subscribe: %s", jid);
type = STANZA_TYPE_SUBSCRIBE;
break;
case PRESENCE_SUBSCRIBED:
log_debug("Sending presence subscribed: %s", jid);
type = STANZA_TYPE_SUBSCRIBED;
break;
case PRESENCE_UNSUBSCRIBED:
log_debug("Sending presence usubscribed: %s", jid);
type = STANZA_TYPE_UNSUBSCRIBED;
break;
default:
break;
}
if (!type) {
log_error("Attempt to send unknown subscription action: %s", jid);
return;
}
xmpp_ctx_t * const ctx = connection_get_ctx();
xmpp_stanza_t *presence = xmpp_presence_new(ctx);
xmpp_ctx_t* const ctx = connection_get_ctx();
xmpp_stanza_t* presence = xmpp_presence_new(ctx);
char *id = connection_create_stanza_id();
char* id = connection_create_stanza_id();
xmpp_stanza_set_id(presence, id);
free(id);
@@ -161,18 +160,18 @@ presence_clear_sub_requests(void)
}
char*
presence_sub_request_find(const char *const search_str, gboolean previous, void *context)
presence_sub_request_find(const char* const search_str, gboolean previous, void* context)
{
return autocomplete_complete(sub_requests_ac, search_str, TRUE, previous);
}
gboolean
presence_sub_request_exists(const char *const bare_jid)
presence_sub_request_exists(const char* const bare_jid)
{
gboolean result = FALSE;
GList *requests = autocomplete_create_list(sub_requests_ac);
GList *curr = requests;
GList* requests = autocomplete_create_list(sub_requests_ac);
GList* curr = requests;
while (curr) {
if (strcmp(curr->data, bare_jid) == 0) {
result = TRUE;
@@ -192,14 +191,14 @@ presence_reset_sub_request_search(void)
}
void
presence_send(const resource_presence_t presence_type, const int idle, char *signed_status)
presence_send(const resource_presence_t presence_type, const int idle, char* signed_status)
{
if (connection_get_status() != JABBER_CONNECTED) {
log_warning("Error setting presence, not connected.");
return;
}
char *msg = connection_get_presence_msg();
char* msg = connection_get_presence_msg();
if (msg) {
log_debug("Updating presence: %s, \"%s\"", string_from_resource_presence(presence_type), msg);
} else {
@@ -209,24 +208,24 @@ presence_send(const resource_presence_t presence_type, const int idle, char *sig
const int pri = accounts_get_priority_for_presence_type(session_get_account_name(), presence_type);
connection_set_priority(pri);
xmpp_ctx_t * const ctx = connection_get_ctx();
xmpp_stanza_t *presence = xmpp_presence_new(ctx);
xmpp_ctx_t* const ctx = connection_get_ctx();
xmpp_stanza_t* presence = xmpp_presence_new(ctx);
char *id = connection_create_stanza_id();
char* id = connection_create_stanza_id();
xmpp_stanza_set_id(presence, id);
free(id);
const char *show = stanza_get_presence_string_from_type(presence_type);
const char* show = stanza_get_presence_string_from_type(presence_type);
stanza_attach_show(ctx, presence, show);
stanza_attach_status(ctx, presence, msg);
if (signed_status) {
xmpp_stanza_t *x = xmpp_stanza_new(ctx);
xmpp_stanza_t* x = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(x, STANZA_NAME_X);
xmpp_stanza_set_ns(x, STANZA_NS_SIGNED);
xmpp_stanza_t *signed_text = xmpp_stanza_new(ctx);
xmpp_stanza_t* signed_text = xmpp_stanza_new(ctx);
xmpp_stanza_set_text(signed_text, signed_status);
xmpp_stanza_add_child(x, signed_text);
@@ -250,27 +249,27 @@ presence_send(const resource_presence_t presence_type, const int idle, char *sig
xmpp_stanza_release(presence);
// set last presence for account
const char *last = show;
const char* last = show;
if (last == NULL) {
last = STANZA_TEXT_ONLINE;
}
char *account = session_get_account_name();
char* account = session_get_account_name();
accounts_set_last_presence(account, last);
accounts_set_last_status(account, msg);
}
static void
_send_room_presence(xmpp_stanza_t *presence)
_send_room_presence(xmpp_stanza_t* presence)
{
GList *rooms = muc_rooms();
GList *curr = rooms;
GList* rooms = muc_rooms();
GList* curr = rooms;
while (curr) {
const char *room = curr->data;
const char *nick = muc_nick(room);
const char* room = curr->data;
const char* nick = muc_nick(room);
if (nick) {
char *full_room_jid = create_fulljid(room, nick);
char* full_room_jid = create_fulljid(room, nick);
xmpp_stanza_set_to(presence, full_room_jid);
log_debug("Sending presence to room: %s", full_room_jid);
free(full_room_jid);
@@ -284,18 +283,18 @@ _send_room_presence(xmpp_stanza_t *presence)
}
void
presence_join_room(const char *const room, const char *const nick, const char *const passwd)
presence_join_room(const char* const room, const char* const nick, const char* const passwd)
{
Jid *jid = jid_create_from_bare_and_resource(room, nick);
Jid* jid = jid_create_from_bare_and_resource(room, nick);
log_debug("Sending room join presence to: %s", jid->fulljid);
resource_presence_t presence_type = accounts_get_last_presence(session_get_account_name());
const char *show = stanza_get_presence_string_from_type(presence_type);
char *status = connection_get_presence_msg();
const char* show = stanza_get_presence_string_from_type(presence_type);
char* status = connection_get_presence_msg();
int pri = accounts_get_priority_for_presence_type(session_get_account_name(), presence_type);
xmpp_ctx_t *ctx = connection_get_ctx();
xmpp_stanza_t *presence = stanza_create_room_join_presence(ctx, jid->fulljid, passwd);
xmpp_ctx_t* ctx = connection_get_ctx();
xmpp_stanza_t* presence = stanza_create_room_join_presence(ctx, jid->fulljid, passwd);
stanza_attach_show(ctx, presence, show);
stanza_attach_status(ctx, presence, status);
stanza_attach_priority(ctx, presence, pri);
@@ -308,20 +307,20 @@ presence_join_room(const char *const room, const char *const nick, const char *c
}
void
presence_change_room_nick(const char *const room, const char *const nick)
presence_change_room_nick(const char* const room, const char* const nick)
{
assert(room != NULL);
assert(nick != NULL);
log_debug("Sending room nickname change to: %s, nick: %s", room, nick);
resource_presence_t presence_type = accounts_get_last_presence(session_get_account_name());
const char *show = stanza_get_presence_string_from_type(presence_type);
char *status = connection_get_presence_msg();
const char* show = stanza_get_presence_string_from_type(presence_type);
char* status = connection_get_presence_msg();
int pri = accounts_get_priority_for_presence_type(session_get_account_name(), presence_type);
char *full_room_jid = create_fulljid(room, nick);
char* full_room_jid = create_fulljid(room, nick);
xmpp_ctx_t *ctx = connection_get_ctx();
xmpp_stanza_t *presence = stanza_create_room_newnick_presence(ctx, full_room_jid);
xmpp_ctx_t* ctx = connection_get_ctx();
xmpp_stanza_t* presence = stanza_create_room_newnick_presence(ctx, full_room_jid);
stanza_attach_show(ctx, presence, show);
stanza_attach_status(ctx, presence, status);
stanza_attach_priority(ctx, presence, pri);
@@ -334,11 +333,11 @@ presence_change_room_nick(const char *const room, const char *const nick)
}
void
presence_leave_chat_room(const char *const room_jid)
presence_leave_chat_room(const char* const room_jid)
{
assert(room_jid != NULL);
char *nick = muc_nick(room_jid);
char* nick = muc_nick(room_jid);
if (!nick) {
log_error("Could not get nickname for room: %s", room_jid);
return;
@@ -346,8 +345,8 @@ presence_leave_chat_room(const char *const room_jid)
log_debug("Sending room leave presence to: %s", room_jid);
xmpp_ctx_t *ctx = connection_get_ctx();
xmpp_stanza_t *presence = stanza_create_room_leave_presence(ctx, room_jid, nick);
xmpp_ctx_t* ctx = connection_get_ctx();
xmpp_stanza_t* presence = stanza_create_room_leave_presence(ctx, room_jid, nick);
_send_presence_stanza(presence);
@@ -355,11 +354,11 @@ presence_leave_chat_room(const char *const room_jid)
}
static int
_presence_handler(xmpp_conn_t *const conn, xmpp_stanza_t *const stanza, void *const userdata)
_presence_handler(xmpp_conn_t* const conn, xmpp_stanza_t* const stanza, void* const userdata)
{
log_debug("Presence stanza handler fired");
char *text = NULL;
char* text = NULL;
size_t text_size;
xmpp_stanza_to_text(stanza, &text, &text_size);
@@ -369,7 +368,7 @@ _presence_handler(xmpp_conn_t *const conn, xmpp_stanza_t *const stanza, void *co
return 1;
}
const char *type = xmpp_stanza_get_type(stanza);
const char* type = xmpp_stanza_get_type(stanza);
if (g_strcmp0(type, STANZA_TYPE_ERROR) == 0) {
_presence_error_handler(stanza);
@@ -391,7 +390,7 @@ _presence_handler(xmpp_conn_t *const conn, xmpp_stanza_t *const stanza, void *co
_unsubscribed_handler(stanza);
}
xmpp_stanza_t *mucuser = xmpp_stanza_get_child_by_ns(stanza, STANZA_NS_MUC_USER);
xmpp_stanza_t* mucuser = xmpp_stanza_get_child_by_ns(stanza, STANZA_NS_MUC_USER);
if (mucuser) {
_muc_user_handler(stanza);
}
@@ -402,21 +401,21 @@ _presence_handler(xmpp_conn_t *const conn, xmpp_stanza_t *const stanza, void *co
}
static void
_presence_error_handler(xmpp_stanza_t *const stanza)
_presence_error_handler(xmpp_stanza_t* const stanza)
{
const char *xmlns = NULL;
xmpp_stanza_t *x = xmpp_stanza_get_child_by_name(stanza, STANZA_NAME_X);
const char* xmlns = NULL;
xmpp_stanza_t* x = xmpp_stanza_get_child_by_name(stanza, STANZA_NAME_X);
if (x) {
xmlns = xmpp_stanza_get_ns(x);
}
const char *from = xmpp_stanza_get_from(stanza);
xmpp_stanza_t *error_stanza = xmpp_stanza_get_child_by_name(stanza, STANZA_NAME_ERROR);
const char* from = xmpp_stanza_get_from(stanza);
xmpp_stanza_t* error_stanza = xmpp_stanza_get_child_by_name(stanza, STANZA_NAME_ERROR);
// handle MUC join errors
if (g_strcmp0(xmlns, STANZA_NS_MUC) == 0) {
const char *error_cond = NULL;
xmpp_stanza_t *reason_st = xmpp_stanza_get_child_by_ns(error_stanza, STANZA_NS_STANZAS);
const char* error_cond = NULL;
xmpp_stanza_t* reason_st = xmpp_stanza_get_child_by_ns(error_stanza, STANZA_NS_STANZAS);
if (reason_st) {
error_cond = xmpp_stanza_get_name(reason_st);
}
@@ -424,7 +423,7 @@ _presence_error_handler(xmpp_stanza_t *const stanza)
error_cond = "unknown";
}
Jid *fulljid = jid_create(from);
Jid* fulljid = jid_create(from);
log_info("Error joining room: %s, reason: %s", fulljid->barejid, error_cond);
if (muc_active(fulljid->barejid)) {
muc_leave(fulljid->barejid);
@@ -435,8 +434,8 @@ _presence_error_handler(xmpp_stanza_t *const stanza)
return;
}
GString *log_msg = g_string_new("presence stanza error received");
const char *id = xmpp_stanza_get_id(stanza);
GString* log_msg = g_string_new("presence stanza error received");
const char* id = xmpp_stanza_get_id(stanza);
if (id) {
g_string_append(log_msg, " id=");
g_string_append(log_msg, id);
@@ -446,7 +445,7 @@ _presence_error_handler(xmpp_stanza_t *const stanza)
g_string_append(log_msg, from);
}
const char *type = NULL;
const char* type = NULL;
if (error_stanza) {
type = xmpp_stanza_get_type(error_stanza);
}
@@ -456,7 +455,7 @@ _presence_error_handler(xmpp_stanza_t *const stanza)
}
// stanza_get_error never returns NULL
char *err_msg = stanza_get_error_message(stanza);
char* err_msg = stanza_get_error_message(stanza);
g_string_append(log_msg, " error=");
g_string_append(log_msg, err_msg);
@@ -474,16 +473,16 @@ _presence_error_handler(xmpp_stanza_t *const stanza)
}
static void
_unsubscribed_handler(xmpp_stanza_t *const stanza)
_unsubscribed_handler(xmpp_stanza_t* const stanza)
{
const char *from = xmpp_stanza_get_from(stanza);
const char* from = xmpp_stanza_get_from(stanza);
if (!from) {
log_warning("Unsubscribed presence handler received with no from attribute");
return;
}
log_debug("Unsubscribed presence handler fired for %s", from);
Jid *from_jid = jid_create(from);
Jid* from_jid = jid_create(from);
sv_ev_subscription(from_jid->barejid, PRESENCE_UNSUBSCRIBED);
autocomplete_remove(sub_requests_ac, from_jid->barejid);
@@ -491,16 +490,16 @@ _unsubscribed_handler(xmpp_stanza_t *const stanza)
}
static void
_subscribed_handler(xmpp_stanza_t *const stanza)
_subscribed_handler(xmpp_stanza_t* const stanza)
{
const char *from = xmpp_stanza_get_from(stanza);
const char* from = xmpp_stanza_get_from(stanza);
if (!from) {
log_warning("Subscribed presence handler received with no from attribute");
return;
}
log_debug("Subscribed presence handler fired for %s", from);
Jid *from_jid = jid_create(from);
Jid* from_jid = jid_create(from);
sv_ev_subscription(from_jid->barejid, PRESENCE_SUBSCRIBED);
autocomplete_remove(sub_requests_ac, from_jid->barejid);
@@ -508,15 +507,15 @@ _subscribed_handler(xmpp_stanza_t *const stanza)
}
static void
_subscribe_handler(xmpp_stanza_t *const stanza)
_subscribe_handler(xmpp_stanza_t* const stanza)
{
const char *from = xmpp_stanza_get_from(stanza);
const char* from = xmpp_stanza_get_from(stanza);
if (!from) {
log_warning("Subscribe presence handler received with no from attribute", from);
}
log_debug("Subscribe presence handler fired for %s", from);
Jid *from_jid = jid_create(from);
Jid* from_jid = jid_create(from);
if (from_jid == NULL) {
return;
}
@@ -528,32 +527,32 @@ _subscribe_handler(xmpp_stanza_t *const stanza)
}
static void
_unavailable_handler(xmpp_stanza_t *const stanza)
_unavailable_handler(xmpp_stanza_t* const stanza)
{
inp_nonblocking(TRUE);
xmpp_conn_t *conn = connection_get_conn();
const char *jid = xmpp_conn_get_jid(conn);
const char *from = xmpp_stanza_get_from(stanza);
xmpp_conn_t* conn = connection_get_conn();
const char* jid = xmpp_conn_get_jid(conn);
const char* from = xmpp_stanza_get_from(stanza);
if (!from) {
log_warning("Unavailable presence received with no from attribute");
}
log_debug("Unavailable presence handler fired for %s", from);
Jid *my_jid = jid_create(jid);
Jid *from_jid = jid_create(from);
Jid* my_jid = jid_create(jid);
Jid* from_jid = jid_create(from);
if (my_jid == NULL || from_jid == NULL) {
jid_destroy(my_jid);
jid_destroy(from_jid);
return;
}
if (strcmp(my_jid->barejid, from_jid->barejid) !=0) {
char *status_str = stanza_get_status(stanza, NULL);
if (strcmp(my_jid->barejid, from_jid->barejid) != 0) {
char* status_str = stanza_get_status(stanza, NULL);
if (from_jid->resourcepart) {
sv_ev_contact_offline(from_jid->barejid, from_jid->resourcepart, status_str);
// hack for servers that do not send full jid with unavailable presence
// hack for servers that do not send full jid with unavailable presence
} else {
sv_ev_contact_offline(from_jid->barejid, "__prof_default", status_str);
}
@@ -569,7 +568,7 @@ _unavailable_handler(xmpp_stanza_t *const stanza)
}
static void
_handle_caps(const char *const jid, XMPPCaps *caps)
_handle_caps(const char* const jid, XMPPCaps* caps)
{
// hash supported, xep-0115, cache against ver
if (g_strcmp0(caps->hash, "sha-1") == 0) {
@@ -580,23 +579,23 @@ _handle_caps(const char *const jid, XMPPCaps *caps)
caps_map_jid_to_ver(jid, caps->ver);
} else {
log_debug("Capabilities cache miss: %s, for %s, sending service discovery request", caps->ver, jid);
char *id = connection_create_stanza_id();
char* id = connection_create_stanza_id();
iq_send_caps_request(jid, id, caps->node, caps->ver);
free(id);
}
}
// unsupported hash, xep-0115, associate with JID, no cache
// unsupported hash, xep-0115, associate with JID, no cache
} else if (caps->hash) {
log_info("Hash %s not supported: %s, sending service discovery request", caps->hash, jid);
char *id = connection_create_stanza_id();
char* id = connection_create_stanza_id();
iq_send_caps_request_for_jid(jid, id, caps->node, caps->ver);
free(id);
// no hash, legacy caps, cache against node#ver
} else if (caps->node && caps->ver) {
// no hash, legacy caps, cache against node#ver
} else if (caps->node && caps->ver) {
log_info("No hash specified: %s, legacy request made for %s#%s", jid, caps->node, caps->ver);
char *id = connection_create_stanza_id();
char* id = connection_create_stanza_id();
iq_send_caps_request_legacy(jid, id, caps->node, caps->ver);
free(id);
} else {
@@ -605,7 +604,7 @@ _handle_caps(const char *const jid, XMPPCaps *caps)
}
static void
_available_handler(xmpp_stanza_t *const stanza)
_available_handler(xmpp_stanza_t* const stanza)
{
inp_nonblocking(TRUE);
@@ -615,10 +614,7 @@ _available_handler(xmpp_stanza_t *const stanza)
}
// handler still fires if other types
if ((g_strcmp0(xmpp_stanza_get_type(stanza), STANZA_TYPE_UNAVAILABLE) == 0) ||
(g_strcmp0(xmpp_stanza_get_type(stanza), STANZA_TYPE_SUBSCRIBE) == 0) ||
(g_strcmp0(xmpp_stanza_get_type(stanza), STANZA_TYPE_SUBSCRIBED) == 0) ||
(g_strcmp0(xmpp_stanza_get_type(stanza), STANZA_TYPE_UNSUBSCRIBED) == 0)) {
if ((g_strcmp0(xmpp_stanza_get_type(stanza), STANZA_TYPE_UNAVAILABLE) == 0) || (g_strcmp0(xmpp_stanza_get_type(stanza), STANZA_TYPE_SUBSCRIBE) == 0) || (g_strcmp0(xmpp_stanza_get_type(stanza), STANZA_TYPE_SUBSCRIBED) == 0) || (g_strcmp0(xmpp_stanza_get_type(stanza), STANZA_TYPE_UNSUBSCRIBED) == 0)) {
return;
}
@@ -628,52 +624,52 @@ _available_handler(xmpp_stanza_t *const stanza)
}
int err = 0;
XMPPPresence *xmpp_presence = stanza_parse_presence(stanza, &err);
XMPPPresence* xmpp_presence = stanza_parse_presence(stanza, &err);
if (!xmpp_presence) {
const char *from = NULL;
switch(err) {
case STANZA_PARSE_ERROR_NO_FROM:
log_warning("Available presence handler fired with no from attribute.");
break;
case STANZA_PARSE_ERROR_INVALID_FROM:
from = xmpp_stanza_get_from(stanza);
log_warning("Available presence handler fired with invalid from attribute: %s", from);
break;
default:
log_warning("Available presence handler fired, could not parse stanza.");
break;
const char* from = NULL;
switch (err) {
case STANZA_PARSE_ERROR_NO_FROM:
log_warning("Available presence handler fired with no from attribute.");
break;
case STANZA_PARSE_ERROR_INVALID_FROM:
from = xmpp_stanza_get_from(stanza);
log_warning("Available presence handler fired with invalid from attribute: %s", from);
break;
default:
log_warning("Available presence handler fired, could not parse stanza.");
break;
}
return;
} else {
char *jid = jid_fulljid_or_barejid(xmpp_presence->jid);
char* jid = jid_fulljid_or_barejid(xmpp_presence->jid);
log_debug("Presence available handler fired for: %s", jid);
}
xmpp_conn_t *conn = connection_get_conn();
const char *my_jid_str = xmpp_conn_get_jid(conn);
Jid *my_jid = jid_create(my_jid_str);
xmpp_conn_t* conn = connection_get_conn();
const char* my_jid_str = xmpp_conn_get_jid(conn);
Jid* my_jid = jid_create(my_jid_str);
XMPPCaps *caps = stanza_parse_caps(stanza);
XMPPCaps* caps = stanza_parse_caps(stanza);
if ((g_strcmp0(my_jid->fulljid, xmpp_presence->jid->fulljid) != 0) && caps) {
log_debug("Presence contains capabilities.");
char *jid = jid_fulljid_or_barejid(xmpp_presence->jid);
char* jid = jid_fulljid_or_barejid(xmpp_presence->jid);
_handle_caps(jid, caps);
}
stanza_free_caps(caps);
Resource *resource = stanza_resource_from_presence(xmpp_presence);
Resource* resource = stanza_resource_from_presence(xmpp_presence);
if (g_strcmp0(xmpp_presence->jid->barejid, my_jid->barejid) == 0) {
connection_add_available_resource(resource);
} else {
char *pgpsig = NULL;
xmpp_stanza_t *x = xmpp_stanza_get_child_by_ns(stanza, STANZA_NS_SIGNED);
char* pgpsig = NULL;
xmpp_stanza_t* x = xmpp_stanza_get_child_by_ns(stanza, STANZA_NS_SIGNED);
if (x) {
pgpsig = xmpp_stanza_get_text(x);
}
sv_ev_contact_online(xmpp_presence->jid->barejid, resource, xmpp_presence->last_activity, pgpsig);
xmpp_ctx_t *ctx = connection_get_ctx();
xmpp_ctx_t* ctx = connection_get_ctx();
xmpp_free(ctx, pgpsig);
}
@@ -682,7 +678,7 @@ _available_handler(xmpp_stanza_t *const stanza)
}
void
_send_caps_request(char *node, char *caps_key, char *id, char *from)
_send_caps_request(char* node, char* caps_key, char* id, char* from)
{
if (!node) {
log_debug("No node string, not sending discovery IQ.");
@@ -696,8 +692,8 @@ _send_caps_request(char *node, char *caps_key, char *id, char *from)
}
log_debug("Capabilities not cached for '%s', sending discovery IQ.", from);
xmpp_ctx_t *ctx = connection_get_ctx();
xmpp_stanza_t *iq = stanza_create_disco_info_iq(ctx, id, from, node);
xmpp_ctx_t* ctx = connection_get_ctx();
xmpp_stanza_t* iq = stanza_create_disco_info_iq(ctx, id, from, node);
iq_send_stanza(iq);
@@ -705,51 +701,51 @@ _send_caps_request(char *node, char *caps_key, char *id, char *from)
}
static void
_muc_user_self_handler(xmpp_stanza_t *stanza)
_muc_user_self_handler(xmpp_stanza_t* stanza)
{
const char *from = xmpp_stanza_get_from(stanza);
Jid *from_jid = jid_create(from);
const char* from = xmpp_stanza_get_from(stanza);
Jid* from_jid = jid_create(from);
log_debug("Room self presence received from %s", from_jid->fulljid);
char *room = from_jid->barejid;
char* room = from_jid->barejid;
const char *type = xmpp_stanza_get_type(stanza);
const char* type = xmpp_stanza_get_type(stanza);
if (g_strcmp0(type, STANZA_TYPE_UNAVAILABLE) == 0) {
// handle nickname change
const char *new_nick = stanza_get_new_nick(stanza);
const char* new_nick = stanza_get_new_nick(stanza);
if (new_nick) {
muc_nick_change_start(room, new_nick);
// handle left room
// handle left room
} else {
GSList *status_codes = stanza_get_status_codes_by_ns(stanza, STANZA_NS_MUC_USER);
GSList* status_codes = stanza_get_status_codes_by_ns(stanza, STANZA_NS_MUC_USER);
// room destroyed
if (stanza_room_destroyed(stanza)) {
const char *new_jid = stanza_get_muc_destroy_alternative_room(stanza);
char *password = stanza_get_muc_destroy_alternative_password(stanza);
char *reason = stanza_get_muc_destroy_reason(stanza);
const char* new_jid = stanza_get_muc_destroy_alternative_room(stanza);
char* password = stanza_get_muc_destroy_alternative_password(stanza);
char* reason = stanza_get_muc_destroy_reason(stanza);
sv_ev_room_destroyed(room, new_jid, password, reason);
free(password);
free(reason);
// kicked from room
// kicked from room
} else if (g_slist_find_custom(status_codes, "307", (GCompareFunc)g_strcmp0)) {
const char *actor = stanza_get_actor(stanza);
char *reason = stanza_get_reason(stanza);
const char* actor = stanza_get_actor(stanza);
char* reason = stanza_get_reason(stanza);
sv_ev_room_kicked(room, actor, reason);
free(reason);
// banned from room
// banned from room
} else if (g_slist_find_custom(status_codes, "301", (GCompareFunc)g_strcmp0)) {
const char *actor = stanza_get_actor(stanza);
char *reason = stanza_get_reason(stanza);
const char* actor = stanza_get_actor(stanza);
char* reason = stanza_get_reason(stanza);
sv_ev_room_banned(room, actor, reason);
free(reason);
// normal exit
// normal exit
} else {
sv_ev_leave_room(room);
}
@@ -758,17 +754,17 @@ _muc_user_self_handler(xmpp_stanza_t *stanza)
}
} else {
gboolean config_required = stanza_muc_requires_config(stanza);
const char *actor = stanza_get_actor(stanza);
char *reason = stanza_get_reason(stanza);
char *nick = from_jid->resourcepart;
char *show_str = stanza_get_show(stanza, "online");
char *status_str = stanza_get_status(stanza, NULL);
const char *jid = NULL;
const char *role = NULL;
const char *affiliation = NULL;
xmpp_stanza_t *x = xmpp_stanza_get_child_by_ns(stanza, STANZA_NS_MUC_USER);
const char* actor = stanza_get_actor(stanza);
char* reason = stanza_get_reason(stanza);
char* nick = from_jid->resourcepart;
char* show_str = stanza_get_show(stanza, "online");
char* status_str = stanza_get_status(stanza, NULL);
const char* jid = NULL;
const char* role = NULL;
const char* affiliation = NULL;
xmpp_stanza_t* x = xmpp_stanza_get_child_by_ns(stanza, STANZA_NS_MUC_USER);
if (x) {
xmpp_stanza_t *item = xmpp_stanza_get_child_by_name(x, STANZA_NAME_ITEM);
xmpp_stanza_t* item = xmpp_stanza_get_child_by_name(x, STANZA_NAME_ITEM);
if (item) {
jid = xmpp_stanza_get_attribute(item, "jid");
role = xmpp_stanza_get_attribute(item, "role");
@@ -785,44 +781,44 @@ _muc_user_self_handler(xmpp_stanza_t *stanza)
}
static void
_muc_user_occupant_handler(xmpp_stanza_t *stanza)
_muc_user_occupant_handler(xmpp_stanza_t* stanza)
{
const char *from = xmpp_stanza_get_from(stanza);
Jid *from_jid = jid_create(from);
const char* from = xmpp_stanza_get_from(stanza);
Jid* from_jid = jid_create(from);
log_debug("Room presence received from %s", from_jid->fulljid);
char *room = from_jid->barejid;
char *nick = from_jid->resourcepart;
char *status_str = stanza_get_status(stanza, NULL);
char* room = from_jid->barejid;
char* nick = from_jid->resourcepart;
char* status_str = stanza_get_status(stanza, NULL);
const char *type = xmpp_stanza_get_type(stanza);
const char* type = xmpp_stanza_get_type(stanza);
if (g_strcmp0(type, STANZA_TYPE_UNAVAILABLE) == 0) {
// handle nickname change
const char *new_nick = stanza_get_new_nick(stanza);
const char* new_nick = stanza_get_new_nick(stanza);
if (new_nick) {
muc_occupant_nick_change_start(room, new_nick, nick);
// handle left room
// handle left room
} else {
GSList *status_codes = stanza_get_status_codes_by_ns(stanza, STANZA_NS_MUC_USER);
GSList* status_codes = stanza_get_status_codes_by_ns(stanza, STANZA_NS_MUC_USER);
// kicked from room
if (g_slist_find_custom(status_codes, "307", (GCompareFunc)g_strcmp0)) {
const char *actor = stanza_get_actor(stanza);
char *reason = stanza_get_reason(stanza);
const char* actor = stanza_get_actor(stanza);
char* reason = stanza_get_reason(stanza);
sv_ev_room_occupent_kicked(room, nick, actor, reason);
free(reason);
// banned from room
// banned from room
} else if (g_slist_find_custom(status_codes, "301", (GCompareFunc)g_strcmp0)) {
const char *actor = stanza_get_actor(stanza);
char *reason = stanza_get_reason(stanza);
const char* actor = stanza_get_actor(stanza);
char* reason = stanza_get_reason(stanza);
sv_ev_room_occupent_banned(room, nick, actor, reason);
free(reason);
// normal exit
// normal exit
} else {
sv_ev_room_occupant_offline(room, nick, "offline", status_str);
}
@@ -830,24 +826,24 @@ _muc_user_occupant_handler(xmpp_stanza_t *stanza)
g_slist_free_full(status_codes, free);
}
// room occupant online
// room occupant online
} else {
// send disco info for capabilities, if not cached
XMPPCaps *caps = stanza_parse_caps(stanza);
XMPPCaps* caps = stanza_parse_caps(stanza);
if (caps) {
_handle_caps(from, caps);
}
stanza_free_caps(caps);
const char *actor = stanza_get_actor(stanza);
char *show_str = stanza_get_show(stanza, "online");
char *reason = stanza_get_reason(stanza);
const char *jid = NULL;
const char *role = NULL;
const char *affiliation = NULL;
xmpp_stanza_t *x = xmpp_stanza_get_child_by_ns(stanza, STANZA_NS_MUC_USER);
const char* actor = stanza_get_actor(stanza);
char* show_str = stanza_get_show(stanza, "online");
char* reason = stanza_get_reason(stanza);
const char* jid = NULL;
const char* role = NULL;
const char* affiliation = NULL;
xmpp_stanza_t* x = xmpp_stanza_get_child_by_ns(stanza, STANZA_NS_MUC_USER);
if (x) {
xmpp_stanza_t *item = xmpp_stanza_get_child_by_name(x, STANZA_NAME_ITEM);
xmpp_stanza_t* item = xmpp_stanza_get_child_by_name(x, STANZA_NAME_ITEM);
if (item) {
jid = xmpp_stanza_get_attribute(item, "jid");
role = xmpp_stanza_get_attribute(item, "role");
@@ -864,23 +860,23 @@ _muc_user_occupant_handler(xmpp_stanza_t *stanza)
}
static void
_muc_user_handler(xmpp_stanza_t *const stanza)
_muc_user_handler(xmpp_stanza_t* const stanza)
{
inp_nonblocking(TRUE);
const char *type = xmpp_stanza_get_type(stanza);
const char* type = xmpp_stanza_get_type(stanza);
// handler still fires if error
if (g_strcmp0(type, STANZA_TYPE_ERROR) == 0) {
return;
}
const char *from = xmpp_stanza_get_from(stanza);
const char* from = xmpp_stanza_get_from(stanza);
if (!from) {
log_warning("MUC User stanza received with no from attribute");
return;
}
Jid *from_jid = jid_create(from);
Jid* from_jid = jid_create(from);
if (from_jid == NULL || from_jid->resourcepart == NULL) {
log_warning("MUC User stanza received with invalid from attribute: %s", from);
jid_destroy(from_jid);
@@ -896,14 +892,14 @@ _muc_user_handler(xmpp_stanza_t *const stanza)
}
static void
_send_presence_stanza(xmpp_stanza_t *const stanza)
_send_presence_stanza(xmpp_stanza_t* const stanza)
{
char *text;
char* text;
size_t text_size;
xmpp_stanza_to_text(stanza, &text, &text_size);
xmpp_conn_t *conn = connection_get_conn();
char *plugin_text = plugins_on_presence_stanza_send(text);
xmpp_conn_t* conn = connection_get_conn();
char* plugin_text = plugins_on_presence_stanza_send(text);
if (plugin_text) {
xmpp_send_raw_string(conn, "%s", plugin_text);
free(plugin_text);

62
src/xmpp/resource.c
View File

@@ -41,10 +41,10 @@
#include "xmpp/resource.h"
Resource*
resource_new(const char *const name, resource_presence_t presence, const char *const status, const int priority)
resource_new(const char* const name, resource_presence_t presence, const char* const status, const int priority)
{
assert(name != NULL);
Resource *new_resource = malloc(sizeof(struct resource_t));
Resource* new_resource = malloc(sizeof(struct resource_t));
new_resource->name = strdup(name);
new_resource->presence = presence;
if (status) {
@@ -58,7 +58,7 @@ resource_new(const char *const name, resource_presence_t presence, const char *c
}
int
resource_compare_availability(Resource *first, Resource *second)
resource_compare_availability(Resource* first, Resource* second)
{
if (first->priority > second->priority) {
return -1;
@@ -88,7 +88,7 @@ resource_compare_availability(Resource *first, Resource *second)
}
void
resource_destroy(Resource *resource)
resource_destroy(Resource* resource)
{
if (resource) {
free(resource->name);
@@ -98,12 +98,10 @@ resource_destroy(Resource *resource)
}
gboolean
valid_resource_presence_string(const char *const str)
valid_resource_presence_string(const char* const str)
{
assert(str != NULL);
if ((strcmp(str, "online") == 0) || (strcmp(str, "chat") == 0) ||
(strcmp(str, "away") == 0) || (strcmp(str, "xa") == 0) ||
(strcmp(str, "dnd") == 0)) {
if ((strcmp(str, "online") == 0) || (strcmp(str, "chat") == 0) || (strcmp(str, "away") == 0) || (strcmp(str, "xa") == 0) || (strcmp(str, "dnd") == 0)) {
return TRUE;
} else {
return FALSE;
@@ -113,23 +111,22 @@ valid_resource_presence_string(const char *const str)
const char*
string_from_resource_presence(resource_presence_t presence)
{
switch(presence)
{
case RESOURCE_CHAT:
return "chat";
case RESOURCE_AWAY:
return "away";
case RESOURCE_XA:
return "xa";
case RESOURCE_DND:
return "dnd";
default:
return "online";
switch (presence) {
case RESOURCE_CHAT:
return "chat";
case RESOURCE_AWAY:
return "away";
case RESOURCE_XA:
return "xa";
case RESOURCE_DND:
return "dnd";
default:
return "online";
}
}
resource_presence_t
resource_presence_from_string(const char *const str)
resource_presence_from_string(const char* const str)
{
if (str == NULL) {
return RESOURCE_ONLINE;
@@ -151,17 +148,16 @@ resource_presence_from_string(const char *const str)
contact_presence_t
contact_presence_from_resource_presence(resource_presence_t resource_presence)
{
switch(resource_presence)
{
case RESOURCE_CHAT:
return CONTACT_CHAT;
case RESOURCE_AWAY:
return CONTACT_AWAY;
case RESOURCE_XA:
return CONTACT_XA;
case RESOURCE_DND:
return CONTACT_DND;
default:
return CONTACT_ONLINE;
switch (resource_presence) {
case RESOURCE_CHAT:
return CONTACT_CHAT;
case RESOURCE_AWAY:
return CONTACT_AWAY;
case RESOURCE_XA:
return CONTACT_XA;
case RESOURCE_DND:
return CONTACT_DND;
default:
return CONTACT_ONLINE;
}
}

19
src/xmpp/resource.h
View File

@@ -38,21 +38,22 @@
#include "common.h"
typedef struct resource_t {
char *name;
typedef struct resource_t
{
char* name;
resource_presence_t presence;
char *status;
char* status;
int priority;
} Resource;
Resource* resource_new(const char *const name, resource_presence_t presence, const char *const status,
const int priority);
void resource_destroy(Resource *resource);
int resource_compare_availability(Resource *first, Resource *second);
Resource* resource_new(const char* const name, resource_presence_t presence, const char* const status,
const int priority);
void resource_destroy(Resource* resource);
int resource_compare_availability(Resource* first, Resource* second);
gboolean valid_resource_presence_string(const char *const str);
gboolean valid_resource_presence_string(const char* const str);
const char* string_from_resource_presence(resource_presence_t presence);
resource_presence_t resource_presence_from_string(const char *const str);
resource_presence_t resource_presence_from_string(const char* const str);
contact_presence_t contact_presence_from_resource_presence(resource_presence_t resource_presence);
#endif

150
src/xmpp/roster.c
View File

@@ -49,78 +49,79 @@
#include <strophe.h>
#endif
#include "profanity.h"
#include "log.h"
#include "config/preferences.h"
#include "plugins/plugins.h"
#include "event/server_events.h"
#include "event/client_events.h"
#include "event/server_events.h"
#include "log.h"
#include "plugins/plugins.h"
#include "profanity.h"
#include "tools/autocomplete.h"
#include "ui/ui.h"
#include "xmpp/session.h"
#include "xmpp/iq.h"
#include "xmpp/connection.h"
#include "xmpp/iq.h"
#include "xmpp/roster.h"
#include "xmpp/roster_list.h"
#include "xmpp/session.h"
#include "xmpp/stanza.h"
#include "xmpp/xmpp.h"
// callback data for group commands
typedef struct _group_data {
char *name;
char *group;
typedef struct _group_data
{
char* name;
char* group;
} GroupData;
// id handlers
static int _group_add_id_handler(xmpp_stanza_t *const stanza, void *const userdata);
static int _group_remove_id_handler(xmpp_stanza_t *const stanza, void *const userdata);
static void _free_group_data(GroupData *data);
static int _group_add_id_handler(xmpp_stanza_t* const stanza, void* const userdata);
static int _group_remove_id_handler(xmpp_stanza_t* const stanza, void* const userdata);
static void _free_group_data(GroupData* data);
void
roster_request(void)
{
xmpp_ctx_t * const ctx = connection_get_ctx();
xmpp_stanza_t *iq = stanza_create_roster_iq(ctx);
xmpp_ctx_t* const ctx = connection_get_ctx();
xmpp_stanza_t* iq = stanza_create_roster_iq(ctx);
iq_send_stanza(iq);
xmpp_stanza_release(iq);
}
void
roster_send_add_new(const char *const barejid, const char *const name)
roster_send_add_new(const char* const barejid, const char* const name)
{
xmpp_ctx_t * const ctx = connection_get_ctx();
char *id = connection_create_stanza_id();
xmpp_stanza_t *iq = stanza_create_roster_set(ctx, id, barejid, name, NULL);
xmpp_ctx_t* const ctx = connection_get_ctx();
char* id = connection_create_stanza_id();
xmpp_stanza_t* iq = stanza_create_roster_set(ctx, id, barejid, name, NULL);
free(id);
iq_send_stanza(iq);
xmpp_stanza_release(iq);
}
void
roster_send_remove(const char *const barejid)
roster_send_remove(const char* const barejid)
{
xmpp_ctx_t * const ctx = connection_get_ctx();
xmpp_stanza_t *iq = stanza_create_roster_remove_set(ctx, barejid);
xmpp_ctx_t* const ctx = connection_get_ctx();
xmpp_stanza_t* iq = stanza_create_roster_remove_set(ctx, barejid);
iq_send_stanza(iq);
xmpp_stanza_release(iq);
}
void
roster_send_name_change(const char *const barejid, const char *const new_name, GSList *groups)
roster_send_name_change(const char* const barejid, const char* const new_name, GSList* groups)
{
xmpp_ctx_t * const ctx = connection_get_ctx();
char *id = connection_create_stanza_id();
xmpp_stanza_t *iq = stanza_create_roster_set(ctx, id, barejid, new_name, groups);
xmpp_ctx_t* const ctx = connection_get_ctx();
char* id = connection_create_stanza_id();
xmpp_stanza_t* iq = stanza_create_roster_set(ctx, id, barejid, new_name, groups);
free(id);
iq_send_stanza(iq);
xmpp_stanza_release(iq);
}
void
roster_send_add_to_group(const char *const group, PContact contact)
roster_send_add_to_group(const char* const group, PContact contact)
{
GSList *groups = p_contact_groups(contact);
GSList *new_groups = NULL;
GSList* groups = p_contact_groups(contact);
GSList* new_groups = NULL;
while (groups) {
new_groups = g_slist_append(new_groups, strdup(groups->data));
groups = g_slist_next(groups);
@@ -128,8 +129,8 @@ roster_send_add_to_group(const char *const group, PContact contact)
new_groups = g_slist_append(new_groups, strdup(group));
// add an id handler to handle the response
char *unique_id = connection_create_stanza_id();
GroupData *data = malloc(sizeof(GroupData));
char* unique_id = connection_create_stanza_id();
GroupData* data = malloc(sizeof(GroupData));
data->group = strdup(group);
if (p_contact_name(contact)) {
data->name = strdup(p_contact_name(contact));
@@ -137,30 +138,30 @@ roster_send_add_to_group(const char *const group, PContact contact)
data->name = strdup(p_contact_barejid(contact));
}
xmpp_ctx_t * const ctx = connection_get_ctx();
xmpp_ctx_t* const ctx = connection_get_ctx();
iq_id_handler_add(unique_id, _group_add_id_handler, (ProfIqFreeCallback)_free_group_data, data);
xmpp_stanza_t *iq = stanza_create_roster_set(ctx, unique_id, p_contact_barejid(contact),
p_contact_name(contact), new_groups);
xmpp_stanza_t* iq = stanza_create_roster_set(ctx, unique_id, p_contact_barejid(contact),
p_contact_name(contact), new_groups);
iq_send_stanza(iq);
xmpp_stanza_release(iq);
free(unique_id);
}
static int
_group_add_id_handler(xmpp_stanza_t *const stanza, void *const userdata)
_group_add_id_handler(xmpp_stanza_t* const stanza, void* const userdata)
{
if (userdata) {
GroupData *data = userdata;
GroupData* data = userdata;
ui_group_added(data->name, data->group);
}
return 0;
}
void
roster_send_remove_from_group(const char *const group, PContact contact)
roster_send_remove_from_group(const char* const group, PContact contact)
{
GSList *groups = p_contact_groups(contact);
GSList *new_groups = NULL;
GSList* groups = p_contact_groups(contact);
GSList* new_groups = NULL;
while (groups) {
if (strcmp(groups->data, group) != 0) {
new_groups = g_slist_append(new_groups, strdup(groups->data));
@@ -168,11 +169,11 @@ roster_send_remove_from_group(const char *const group, PContact contact)
groups = g_slist_next(groups);
}
xmpp_ctx_t * const ctx = connection_get_ctx();
xmpp_ctx_t* const ctx = connection_get_ctx();
// add an id handler to handle the response
char *unique_id = connection_create_stanza_id();
GroupData *data = malloc(sizeof(GroupData));
char* unique_id = connection_create_stanza_id();
GroupData* data = malloc(sizeof(GroupData));
data->group = strdup(group);
if (p_contact_name(contact)) {
data->name = strdup(p_contact_name(contact));
@@ -181,38 +182,36 @@ roster_send_remove_from_group(const char *const group, PContact contact)
}
iq_id_handler_add(unique_id, _group_remove_id_handler, (ProfIqFreeCallback)_free_group_data, data);
xmpp_stanza_t *iq = stanza_create_roster_set(ctx, unique_id, p_contact_barejid(contact),
p_contact_name(contact), new_groups);
xmpp_stanza_t* iq = stanza_create_roster_set(ctx, unique_id, p_contact_barejid(contact),
p_contact_name(contact), new_groups);
iq_send_stanza(iq);
xmpp_stanza_release(iq);
free(unique_id);
}
static int
_group_remove_id_handler(xmpp_stanza_t *const stanza, void *const userdata)
_group_remove_id_handler(xmpp_stanza_t* const stanza, void* const userdata)
{
if (userdata) {
GroupData *data = userdata;
GroupData* data = userdata;
ui_group_removed(data->name, data->group);
}
return 0;
}
void
roster_set_handler(xmpp_stanza_t *const stanza)
roster_set_handler(xmpp_stanza_t* const stanza)
{
xmpp_stanza_t *query =
xmpp_stanza_get_child_by_name(stanza, STANZA_NAME_QUERY);
xmpp_stanza_t *item =
xmpp_stanza_get_child_by_name(query, STANZA_NAME_ITEM);
xmpp_stanza_t* query = xmpp_stanza_get_child_by_name(stanza, STANZA_NAME_QUERY);
xmpp_stanza_t* item = xmpp_stanza_get_child_by_name(query, STANZA_NAME_ITEM);
if (item == NULL) {
return;
}
// if from attribute exists and it is not current users barejid, ignore push
char *mybarejid = connection_get_barejid();
const char *from = xmpp_stanza_get_from(stanza);
char* mybarejid = connection_get_barejid();
const char* from = xmpp_stanza_get_from(stanza);
if (from && (strcmp(from, mybarejid) != 0)) {
log_warning("Received alleged roster push from: %s", from);
free(mybarejid);
@@ -220,11 +219,11 @@ roster_set_handler(xmpp_stanza_t *const stanza)
}
free(mybarejid);
const char *barejid = xmpp_stanza_get_attribute(item, STANZA_ATTR_JID);
gchar *barejid_lower = g_utf8_strdown(barejid, -1);
const char *name = xmpp_stanza_get_attribute(item, STANZA_ATTR_NAME);
const char *sub = xmpp_stanza_get_attribute(item, STANZA_ATTR_SUBSCRIPTION);
const char *ask = xmpp_stanza_get_attribute(item, STANZA_ATTR_ASK);
const char* barejid = xmpp_stanza_get_attribute(item, STANZA_ATTR_JID);
gchar* barejid_lower = g_utf8_strdown(barejid, -1);
const char* name = xmpp_stanza_get_attribute(item, STANZA_ATTR_NAME);
const char* sub = xmpp_stanza_get_attribute(item, STANZA_ATTR_SUBSCRIPTION);
const char* ask = xmpp_stanza_get_attribute(item, STANZA_ATTR_ASK);
// do not set nickname to empty string, set to NULL instead
if (name && (strlen(name) == 0)) {
@@ -240,7 +239,7 @@ roster_set_handler(xmpp_stanza_t *const stanza)
roster_remove(name, barejid_lower);
ui_roster_remove(barejid_lower);
// otherwise update local roster
// otherwise update local roster
} else {
// check for pending out subscriptions
@@ -249,7 +248,7 @@ roster_set_handler(xmpp_stanza_t *const stanza)
pending_out = TRUE;
}
GSList *groups = roster_get_groups_from_item(item);
GSList* groups = roster_get_groups_from_item(item);
// update the local roster
PContact contact = roster_get_contact(barejid_lower);
@@ -269,34 +268,35 @@ roster_set_handler(xmpp_stanza_t *const stanza)
}
void
roster_result_handler(xmpp_stanza_t *const stanza)
roster_result_handler(xmpp_stanza_t* const stanza)
{
const char *id = xmpp_stanza_get_id(stanza);
const char* id = xmpp_stanza_get_id(stanza);
if (g_strcmp0(id, "roster") != 0) {
return;
}
// handle initial roster response
xmpp_stanza_t *query = xmpp_stanza_get_child_by_name(stanza, STANZA_NAME_QUERY);
xmpp_stanza_t *item = xmpp_stanza_get_children(query);
xmpp_stanza_t* query = xmpp_stanza_get_child_by_name(stanza, STANZA_NAME_QUERY);
xmpp_stanza_t* item = xmpp_stanza_get_children(query);
while (item) {
const char *barejid = xmpp_stanza_get_attribute(item, STANZA_ATTR_JID);
gchar *barejid_lower = g_utf8_strdown(barejid, -1);
const char *name = xmpp_stanza_get_attribute(item, STANZA_ATTR_NAME);
const char *sub = xmpp_stanza_get_attribute(item, STANZA_ATTR_SUBSCRIPTION);
const char* barejid = xmpp_stanza_get_attribute(item, STANZA_ATTR_JID);
gchar* barejid_lower = g_utf8_strdown(barejid, -1);
const char* name = xmpp_stanza_get_attribute(item, STANZA_ATTR_NAME);
const char* sub = xmpp_stanza_get_attribute(item, STANZA_ATTR_SUBSCRIPTION);
// do not set nickname to empty string, set to NULL instead
if (name && (strlen(name) == 0)) name = NULL;
if (name && (strlen(name) == 0))
name = NULL;
gboolean pending_out = FALSE;
const char *ask = xmpp_stanza_get_attribute(item, STANZA_ATTR_ASK);
const char* ask = xmpp_stanza_get_attribute(item, STANZA_ATTR_ASK);
if (g_strcmp0(ask, "subscribe") == 0) {
pending_out = TRUE;
}
GSList *groups = roster_get_groups_from_item(item);
GSList* groups = roster_get_groups_from_item(item);
gboolean added = roster_add(barejid_lower, name, groups, sub, pending_out);
if (!added) {
@@ -313,14 +313,14 @@ roster_result_handler(xmpp_stanza_t *const stanza)
}
GSList*
roster_get_groups_from_item(xmpp_stanza_t *item)
roster_get_groups_from_item(xmpp_stanza_t* item)
{
GSList *groups = NULL;
xmpp_stanza_t *group_element = xmpp_stanza_get_children(item);
GSList* groups = NULL;
xmpp_stanza_t* group_element = xmpp_stanza_get_children(item);
while (group_element) {
if (strcmp(xmpp_stanza_get_name(group_element), STANZA_NAME_GROUP) == 0) {
char *groupname = xmpp_stanza_get_text(group_element);
char* groupname = xmpp_stanza_get_text(group_element);
if (groupname) {
groups = g_slist_append(groups, groupname);
}
@@ -332,7 +332,7 @@ roster_get_groups_from_item(xmpp_stanza_t *item)
}
static void
_free_group_data(GroupData *data)
_free_group_data(GroupData* data)
{
if (data) {
free(data->group);

6
src/xmpp/roster.h
View File

@@ -37,8 +37,8 @@
#define XMPP_ROSTER_H
void roster_request(void);
void roster_set_handler(xmpp_stanza_t *const stanza);
void roster_result_handler(xmpp_stanza_t *const stanza);
GSList* roster_get_groups_from_item(xmpp_stanza_t *const item);
void roster_set_handler(xmpp_stanza_t* const stanza);
void roster_result_handler(xmpp_stanza_t* const stanza);
GSList* roster_get_groups_from_item(xmpp_stanza_t* const item);
#endif

173
src/xmpp/roster_list.c
View File

@@ -33,23 +33,22 @@
*
*/
#include <string.h>
#include <stdlib.h>
#include <assert.h>
#include <glib.h>
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include "config/preferences.h"
#include "tools/autocomplete.h"
#include "xmpp/roster_list.h"
#include "xmpp/resource.h"
#include "xmpp/contact.h"
#include "xmpp/jid.h"
#include "xmpp/resource.h"
#include "xmpp/roster_list.h"
typedef struct prof_roster_t {
typedef struct prof_roster_t
{
// contacts, indexed on barejid
GHashTable *contacts;
GHashTable* contacts;
// nicknames
Autocomplete name_ac;
@@ -61,27 +60,28 @@ typedef struct prof_roster_t {
Autocomplete fulljid_ac;
// nickname to barejid map
GHashTable *name_to_barejid;
GHashTable* name_to_barejid;
// groups
Autocomplete groups_ac;
GHashTable *group_count;
GHashTable* group_count;
} ProfRoster;
typedef struct pending_presence {
char *barejid;
Resource *resource;
GDateTime *last_activity;
typedef struct pending_presence
{
char* barejid;
Resource* resource;
GDateTime* last_activity;
} ProfPendingPresence;
static ProfRoster *roster = NULL;
static ProfRoster* roster = NULL;
static gboolean roster_received = FALSE;
static GSList *roster_pending_presence = NULL;
static GSList* roster_pending_presence = NULL;
static gboolean _key_equals(void *key1, void *key2);
static gboolean _datetimes_equal(GDateTime *dt1, GDateTime *dt2);
static void _replace_name(const char *const current_name, const char *const new_name, const char *const barejid);
static void _add_name_and_barejid(const char *const name, const char *const barejid);
static gboolean _key_equals(void* key1, void* key2);
static gboolean _datetimes_equal(GDateTime* dt1, GDateTime* dt2);
static void _replace_name(const char* const current_name, const char* const new_name, const char* const barejid);
static void _add_name_and_barejid(const char* const name, const char* const barejid);
void
roster_create(void)
@@ -119,7 +119,7 @@ roster_destroy(void)
}
gboolean
roster_update_presence(const char *const barejid, Resource *resource, GDateTime *last_activity)
roster_update_presence(const char* const barejid, Resource* resource, GDateTime* last_activity)
{
assert(roster != NULL);
@@ -127,7 +127,7 @@ roster_update_presence(const char *const barejid, Resource *resource, GDateTime
assert(resource != NULL);
if (!roster_received) {
ProfPendingPresence *presence = malloc(sizeof(ProfPendingPresence));
ProfPendingPresence* presence = malloc(sizeof(ProfPendingPresence));
presence->barejid = strdup(barejid);
presence->resource = resource;
presence->last_activity = last_activity;
@@ -148,7 +148,7 @@ roster_update_presence(const char *const barejid, Resource *resource, GDateTime
p_contact_set_last_activity(contact, last_activity);
}
p_contact_set_presence(contact, resource);
Jid *jid = jid_create_from_bare_and_resource(barejid, resource->name);
Jid* jid = jid_create_from_bare_and_resource(barejid, resource->name);
autocomplete_add(roster->fulljid_ac, jid->fulljid);
jid_destroy(jid);
@@ -156,11 +156,11 @@ roster_update_presence(const char *const barejid, Resource *resource, GDateTime
}
PContact
roster_get_contact(const char *const barejid)
roster_get_contact(const char* const barejid)
{
assert(roster != NULL);
gchar *barejidlower = g_utf8_strdown(barejid, -1);
gchar* barejidlower = g_utf8_strdown(barejid, -1);
PContact contact = g_hash_table_lookup(roster->contacts, barejidlower);
g_free(barejidlower);
@@ -168,11 +168,11 @@ roster_get_contact(const char *const barejid)
}
char*
roster_get_msg_display_name(const char *const barejid, const char *const resource)
roster_get_msg_display_name(const char* const barejid, const char* const resource)
{
assert(roster != NULL);
GString *result = g_string_new("");
GString* result = g_string_new("");
PContact contact = roster_get_contact(barejid);
if (contact) {
@@ -190,14 +190,14 @@ roster_get_msg_display_name(const char *const barejid, const char *const resourc
g_string_append(result, resource);
}
char *result_str = result->str;
char* result_str = result->str;
g_string_free(result, FALSE);
return result_str;
}
gboolean
roster_contact_offline(const char *const barejid, const char *const resource, const char *const status)
roster_contact_offline(const char* const barejid, const char* const resource, const char* const status)
{
assert(roster != NULL);
@@ -211,7 +211,7 @@ roster_contact_offline(const char *const barejid, const char *const resource, co
} else {
gboolean result = p_contact_remove_resource(contact, resource);
if (result == TRUE) {
Jid *jid = jid_create_from_bare_and_resource(barejid, resource);
Jid* jid = jid_create_from_bare_and_resource(barejid, resource);
autocomplete_remove(roster->fulljid_ac, jid->fulljid);
jid_destroy(jid);
}
@@ -232,13 +232,13 @@ roster_reset_search_attempts(void)
}
void
roster_change_name(PContact contact, const char *const new_name)
roster_change_name(PContact contact, const char* const new_name)
{
assert(roster != NULL);
assert(contact != NULL);
char *current_name = NULL;
const char *barejid = p_contact_barejid(contact);
char* current_name = NULL;
const char* barejid = p_contact_barejid(contact);
if (p_contact_name(contact)) {
current_name = strdup(p_contact_name(contact));
@@ -250,7 +250,7 @@ roster_change_name(PContact contact, const char *const new_name)
}
void
roster_remove(const char *const name, const char *const barejid)
roster_remove(const char* const name, const char* const barejid)
{
assert(roster != NULL);
@@ -261,9 +261,9 @@ roster_remove(const char *const name, const char *const barejid)
// remove each fulljid
PContact contact = roster_get_contact(barejid);
if (contact) {
GList *resources = p_contact_get_available_resources(contact);
GList* resources = p_contact_get_available_resources(contact);
while (resources) {
GString *fulljid = g_string_new(barejid);
GString* fulljid = g_string_new(barejid);
g_string_append(fulljid, "/");
g_string_append(fulljid, resources->data);
autocomplete_remove(roster->fulljid_ac, fulljid->str);
@@ -272,10 +272,10 @@ roster_remove(const char *const name, const char *const barejid)
}
g_list_free(resources);
GSList *groups = p_contact_groups(contact);
GSList *curr = groups;
GSList* groups = p_contact_groups(contact);
GSList* curr = groups;
while (curr) {
gchar *group = curr->data;
gchar* group = curr->data;
if (g_hash_table_contains(roster->group_count, group)) {
int count = GPOINTER_TO_INT(g_hash_table_lookup(roster->group_count, group));
count--;
@@ -295,8 +295,8 @@ roster_remove(const char *const name, const char *const barejid)
}
void
roster_update(const char *const barejid, const char *const name, GSList *groups, const char *const subscription,
gboolean pending_out)
roster_update(const char* const barejid, const char* const name, GSList* groups, const char* const subscription,
gboolean pending_out)
{
assert(roster != NULL);
@@ -308,9 +308,9 @@ roster_update(const char *const barejid, const char *const name, GSList *groups,
roster_change_name(contact, name);
GSList *curr_new_group = groups;
GSList* curr_new_group = groups;
while (curr_new_group) {
char *new_group = curr_new_group->data;
char* new_group = curr_new_group->data;
// contact added to group
if (!p_contact_in_group(contact, new_group)) {
@@ -320,7 +320,7 @@ roster_update(const char *const barejid, const char *const name, GSList *groups,
g_hash_table_insert(roster->group_count, strdup(new_group), GINT_TO_POINTER(1));
autocomplete_add(roster->groups_ac, curr_new_group->data);
// increment count
// increment count
} else {
int count = GPOINTER_TO_INT(g_hash_table_lookup(roster->group_count, new_group));
g_hash_table_insert(roster->group_count, strdup(new_group), GINT_TO_POINTER(count + 1));
@@ -329,10 +329,10 @@ roster_update(const char *const barejid, const char *const name, GSList *groups,
curr_new_group = g_slist_next(curr_new_group);
}
GSList *old_groups = p_contact_groups(contact);
GSList *curr_old_group = old_groups;
GSList* old_groups = p_contact_groups(contact);
GSList* curr_old_group = old_groups;
while (curr_old_group) {
char *old_group = curr_old_group->data;
char* old_group = curr_old_group->data;
// removed from group
if (!g_slist_find_custom(groups, old_group, (GCompareFunc)g_strcmp0)) {
if (g_hash_table_contains(roster->group_count, old_group)) {
@@ -354,8 +354,8 @@ roster_update(const char *const barejid, const char *const name, GSList *groups,
}
gboolean
roster_add(const char *const barejid, const char *const name, GSList *groups, const char *const subscription,
gboolean pending_out)
roster_add(const char* const barejid, const char* const name, GSList* groups, const char* const subscription,
gboolean pending_out)
{
assert(roster != NULL);
@@ -367,9 +367,9 @@ roster_add(const char *const barejid, const char *const name, GSList *groups, co
contact = p_contact_new(barejid, name, groups, subscription, NULL, pending_out);
// add groups
GSList *curr_new_group = groups;
GSList* curr_new_group = groups;
while (curr_new_group) {
char *new_group = curr_new_group->data;
char* new_group = curr_new_group->data;
if (g_hash_table_contains(roster->group_count, new_group)) {
int count = GPOINTER_TO_INT(g_hash_table_lookup(roster->group_count, new_group));
g_hash_table_insert(roster->group_count, strdup(new_group), GINT_TO_POINTER(count + 1));
@@ -389,7 +389,7 @@ roster_add(const char *const barejid, const char *const name, GSList *groups, co
}
char*
roster_barejid_from_name(const char *const name)
roster_barejid_from_name(const char* const name)
{
assert(roster != NULL);
@@ -401,11 +401,11 @@ roster_barejid_from_name(const char *const name)
}
GSList*
roster_get_contacts_by_presence(const char *const presence)
roster_get_contacts_by_presence(const char* const presence)
{
assert(roster != NULL);
GSList *result = NULL;
GSList* result = NULL;
GHashTableIter iter;
gpointer key;
gpointer value;
@@ -427,16 +427,16 @@ roster_get_contacts(roster_ord_t order)
{
assert(roster != NULL);
GSList *result = NULL;
GSList* result = NULL;
GHashTableIter iter;
gpointer key;
gpointer value;
GCompareFunc cmp_func;
if (order == ROSTER_ORD_PRESENCE) {
cmp_func = (GCompareFunc) roster_compare_presence;
cmp_func = (GCompareFunc)roster_compare_presence;
} else {
cmp_func = (GCompareFunc) roster_compare_name;
cmp_func = (GCompareFunc)roster_compare_name;
}
g_hash_table_iter_init(&iter, roster->contacts);
@@ -453,14 +453,14 @@ roster_get_contacts_online(void)
{
assert(roster != NULL);
GSList *result = NULL;
GSList* result = NULL;
GHashTableIter iter;
gpointer key;
gpointer value;
g_hash_table_iter_init(&iter, roster->contacts);
while (g_hash_table_iter_next(&iter, &key, &value)) {
if(strcmp(p_contact_presence(value), "offline"))
if (strcmp(p_contact_presence(value), "offline"))
result = g_slist_insert_sorted(result, value, (GCompareFunc)roster_compare_name);
}
@@ -479,7 +479,7 @@ roster_has_pending_subscriptions(void)
g_hash_table_iter_init(&iter, roster->contacts);
while (g_hash_table_iter_next(&iter, &key, &value)) {
PContact contact = (PContact) value;
PContact contact = (PContact)value;
if (p_contact_pending_out(contact)) {
return TRUE;
}
@@ -489,7 +489,7 @@ roster_has_pending_subscriptions(void)
}
char*
roster_contact_autocomplete(const char *const search_str, gboolean previous, void *context)
roster_contact_autocomplete(const char* const search_str, gboolean previous, void* context)
{
assert(roster != NULL);
@@ -497,7 +497,7 @@ roster_contact_autocomplete(const char *const search_str, gboolean previous, voi
}
char*
roster_fulljid_autocomplete(const char *const search_str, gboolean previous, void *context)
roster_fulljid_autocomplete(const char* const search_str, gboolean previous, void* context)
{
assert(roster != NULL);
@@ -505,25 +505,25 @@ roster_fulljid_autocomplete(const char *const search_str, gboolean previous, voi
}
GSList*
roster_get_group(const char *const group, roster_ord_t order)
roster_get_group(const char* const group, roster_ord_t order)
{
assert(roster != NULL);
GSList *result = NULL;
GSList* result = NULL;
GHashTableIter iter;
gpointer key;
gpointer value;
GCompareFunc cmp_func;
if (order == ROSTER_ORD_PRESENCE) {
cmp_func = (GCompareFunc) roster_compare_presence;
cmp_func = (GCompareFunc)roster_compare_presence;
} else {
cmp_func = (GCompareFunc) roster_compare_name;
cmp_func = (GCompareFunc)roster_compare_name;
}
g_hash_table_iter_init(&iter, roster->contacts);
while (g_hash_table_iter_next(&iter, &key, &value)) {
GSList *groups = p_contact_groups(value);
GSList* groups = p_contact_groups(value);
if (group == NULL) {
if (groups == NULL) {
result = g_slist_insert_sorted(result, value, cmp_func);
@@ -552,7 +552,7 @@ roster_get_groups(void)
}
char*
roster_group_autocomplete(const char *const search_str, gboolean previous, void *context)
roster_group_autocomplete(const char* const search_str, gboolean previous, void* context)
{
assert(roster != NULL);
@@ -560,7 +560,7 @@ roster_group_autocomplete(const char *const search_str, gboolean previous, void
}
char*
roster_barejid_autocomplete(const char *const search_str, gboolean previous, void *context)
roster_barejid_autocomplete(const char* const search_str, gboolean previous, void* context)
{
assert(roster != NULL);
@@ -568,16 +568,16 @@ roster_barejid_autocomplete(const char *const search_str, gboolean previous, voi
}
static gboolean
_key_equals(void *key1, void *key2)
_key_equals(void* key1, void* key2)
{
gchar *str1 = (gchar *) key1;
gchar *str2 = (gchar *) key2;
gchar* str1 = (gchar*)key1;
gchar* str2 = (gchar*)key2;
return (g_strcmp0(str1, str2) == 0);
}
static gboolean
_datetimes_equal(GDateTime *dt1, GDateTime *dt2)
_datetimes_equal(GDateTime* dt1, GDateTime* dt2)
{
if ((dt1 == NULL) && (dt2 == NULL)) {
return TRUE;
@@ -591,7 +591,7 @@ _datetimes_equal(GDateTime *dt1, GDateTime *dt2)
}
static void
_replace_name(const char *const current_name, const char *const new_name, const char *const barejid)
_replace_name(const char* const current_name, const char* const new_name, const char* const barejid)
{
assert(roster != NULL);
@@ -600,7 +600,7 @@ _replace_name(const char *const current_name, const char *const new_name, const
autocomplete_remove(roster->name_ac, current_name);
g_hash_table_remove(roster->name_to_barejid, current_name);
_add_name_and_barejid(new_name, barejid);
// no current handle
// no current handle
} else if (new_name) {
autocomplete_remove(roster->name_ac, barejid);
g_hash_table_remove(roster->name_to_barejid, barejid);
@@ -609,7 +609,7 @@ _replace_name(const char *const current_name, const char *const new_name, const
}
static void
_add_name_and_barejid(const char *const name, const char *const barejid)
_add_name_and_barejid(const char* const name, const char* const barejid)
{
assert(roster != NULL);
@@ -625,8 +625,8 @@ _add_name_and_barejid(const char *const name, const char *const barejid)
gint
roster_compare_name(PContact a, PContact b)
{
const char * utf8_str_a = NULL;
const char * utf8_str_b = NULL;
const char* utf8_str_a = NULL;
const char* utf8_str_b = NULL;
if (p_contact_name_collate_key(a)) {
utf8_str_a = p_contact_name_collate_key(a);
@@ -645,7 +645,7 @@ roster_compare_name(PContact a, PContact b)
}
static gint
_get_presence_weight(const char *presence)
_get_presence_weight(const char* presence)
{
if (g_strcmp0(presence, "chat") == 0) {
return 0;
@@ -665,8 +665,8 @@ _get_presence_weight(const char *presence)
gint
roster_compare_presence(PContact a, PContact b)
{
const char *presence_a = p_contact_presence(a);
const char *presence_b = p_contact_presence(b);
const char* presence_a = p_contact_presence(a);
const char* presence_b = p_contact_presence(b);
// if presence different, order by presence
if (g_strcmp0(presence_a, presence_b) != 0) {
@@ -678,14 +678,14 @@ roster_compare_presence(PContact a, PContact b)
return 1;
}
// otherwise order by name
// otherwise order by name
} else {
return roster_compare_name(a, b);
}
}
static void
_pendingPresence_free(ProfPendingPresence *presence)
_pendingPresence_free(ProfPendingPresence* presence)
{
if (!presence)
return;
@@ -698,9 +698,9 @@ roster_process_pending_presence(void)
{
roster_received = TRUE;
GSList *iter;
GSList* iter;
for (iter = roster_pending_presence; iter != NULL; iter = iter->next) {
ProfPendingPresence *presence = iter->data;
ProfPendingPresence* presence = iter->data;
roster_update_presence(presence->barejid, presence->resource, presence->last_activity);
/* seems like resource isn't free on the calling side */
if (presence->last_activity) {
@@ -713,7 +713,8 @@ roster_process_pending_presence(void)
}
gboolean
roster_exists(void) {
roster_exists(void)
{
if (roster != NULL) {
return TRUE;
}

36
src/xmpp/roster_list.h
View File

@@ -38,8 +38,8 @@
#include <glib.h>
#include "xmpp/resource.h"
#include "xmpp/contact.h"
#include "xmpp/resource.h"
typedef enum {
ROSTER_ORD_NAME,
@@ -47,30 +47,30 @@ typedef enum {
} roster_ord_t;
void roster_clear(void);
gboolean roster_update_presence(const char *const barejid, Resource *resource, GDateTime *last_activity);
PContact roster_get_contact(const char *const barejid);
gboolean roster_contact_offline(const char *const barejid, const char *const resource, const char *const status);
gboolean roster_update_presence(const char* const barejid, Resource* resource, GDateTime* last_activity);
PContact roster_get_contact(const char* const barejid);
gboolean roster_contact_offline(const char* const barejid, const char* const resource, const char* const status);
void roster_reset_search_attempts(void);
void roster_create(void);
void roster_destroy(void);
void roster_change_name(PContact contact, const char *const new_name);
void roster_remove(const char *const name, const char *const barejid);
void roster_update(const char *const barejid, const char *const name, GSList *groups, const char *const subscription,
gboolean pending_out);
gboolean roster_add(const char *const barejid, const char *const name, GSList *groups, const char *const subscription,
gboolean pending_out);
char* roster_barejid_from_name(const char *const name);
void roster_change_name(PContact contact, const char* const new_name);
void roster_remove(const char* const name, const char* const barejid);
void roster_update(const char* const barejid, const char* const name, GSList* groups, const char* const subscription,
gboolean pending_out);
gboolean roster_add(const char* const barejid, const char* const name, GSList* groups, const char* const subscription,
gboolean pending_out);
char* roster_barejid_from_name(const char* const name);
GSList* roster_get_contacts(roster_ord_t order);
GSList* roster_get_contacts_online(void);
gboolean roster_has_pending_subscriptions(void);
char* roster_contact_autocomplete(const char *const search_str, gboolean previous, void *context);
char* roster_fulljid_autocomplete(const char *const search_str, gboolean previous, void *context);
GSList* roster_get_group(const char *const group, roster_ord_t order);
char* roster_contact_autocomplete(const char* const search_str, gboolean previous, void* context);
char* roster_fulljid_autocomplete(const char* const search_str, gboolean previous, void* context);
GSList* roster_get_group(const char* const group, roster_ord_t order);
GList* roster_get_groups(void);
char* roster_group_autocomplete(const char *const search_str, gboolean previous, void *context);
char* roster_barejid_autocomplete(const char *const search_str, gboolean previous, void *context);
GSList* roster_get_contacts_by_presence(const char *const presence);
char* roster_get_msg_display_name(const char *const barejid, const char *const resource);
char* roster_group_autocomplete(const char* const search_str, gboolean previous, void* context);
char* roster_barejid_autocomplete(const char* const search_str, gboolean previous, void* context);
GSList* roster_get_contacts_by_presence(const char* const presence);
char* roster_get_msg_display_name(const char* const barejid, const char* const resource);
gint roster_compare_name(PContact a, PContact b);
gint roster_compare_presence(PContact a, PContact b);
void roster_process_pending_presence(void);

90
src/xmpp/session.c
View File

@@ -36,30 +36,30 @@
#include "config.h"
#include <assert.h>
#include <string.h>
#include <stdlib.h>
#include <string.h>
#include "profanity.h"
#include "log.h"
#include "common.h"
#include "config/preferences.h"
#include "plugins/plugins.h"
#include "event/server_events.h"
#include "event/client_events.h"
#include "xmpp/bookmark.h"
#include "event/server_events.h"
#include "log.h"
#include "plugins/plugins.h"
#include "profanity.h"
#include "xmpp/blocking.h"
#include "xmpp/connection.h"
#include "xmpp/bookmark.h"
#include "xmpp/capabilities.h"
#include "xmpp/session.h"
#include "xmpp/chat_session.h"
#include "xmpp/connection.h"
#include "xmpp/iq.h"
#include "xmpp/jid.h"
#include "xmpp/message.h"
#include "xmpp/muc.h"
#include "xmpp/presence.h"
#include "xmpp/roster.h"
#include "xmpp/session.h"
#include "xmpp/stanza.h"
#include "xmpp/xmpp.h"
#include "xmpp/muc.h"
#include "xmpp/chat_session.h"
#include "xmpp/jid.h"
#ifdef HAVE_OMEMO
#include "omemo/omemo.h"
@@ -67,19 +67,21 @@
#endif
// for auto reconnect
static struct {
char *name;
char *passwd;
static struct
{
char* name;
char* passwd;
} saved_account;
static struct {
char *name;
char *jid;
char *passwd;
char *altdomain;
static struct
{
char* name;
char* jid;
char* passwd;
char* altdomain;
int port;
char *tls_policy;
char *auth_policy;
char* tls_policy;
char* auth_policy;
} saved_details;
typedef enum {
@@ -89,10 +91,10 @@ typedef enum {
ACTIVITY_ST_XA,
} activity_state_t;
static GTimer *reconnect_timer;
static GTimer* reconnect_timer;
static activity_state_t activity_state;
static resource_presence_t saved_presence;
static char *saved_status;
static char* saved_status;
static void _session_reconnect(void);
@@ -109,7 +111,7 @@ session_init(void)
}
jabber_conn_status_t
session_connect_with_account(const ProfAccount *const account)
session_connect_with_account(const ProfAccount* const account)
{
assert(account != NULL);
@@ -122,9 +124,9 @@ session_connect_with_account(const ProfAccount *const account)
saved_account.name = strdup(account->name);
saved_account.passwd = strdup(account->password);
char *jid = NULL;
char* jid = NULL;
if (account->resource) {
Jid *jidp = jid_create_from_bare_and_resource(account->jid, account->resource);
Jid* jidp = jid_create_from_bare_and_resource(account->jid, account->resource);
jid = strdup(jidp->fulljid);
jid_destroy(jidp);
} else {
@@ -144,8 +146,8 @@ session_connect_with_account(const ProfAccount *const account)
}
jabber_conn_status_t
session_connect_with_details(const char *const jid, const char *const passwd, const char *const altdomain,
const int port, const char *const tls_policy, const char *const auth_policy)
session_connect_with_details(const char* const jid, const char* const passwd, const char* const altdomain,
const int port, const char* const tls_policy, const char* const auth_policy)
{
assert(jid != NULL);
assert(passwd != NULL);
@@ -178,10 +180,10 @@ session_connect_with_details(const char *const jid, const char *const passwd, co
}
// use 'profanity' when no resourcepart in provided jid
Jid *jidp = jid_create(jid);
Jid* jidp = jid_create(jid);
if (jidp->resourcepart == NULL) {
jid_destroy(jidp);
char *resource = jid_random_resource();
char* resource = jid_random_resource();
jidp = jid_create_from_bare_and_resource(jid, resource);
free(resource);
saved_details.jid = strdup(jidp->fulljid);
@@ -215,8 +217,8 @@ session_disconnect(void)
if (connection_get_status() == JABBER_CONNECTED) {
log_info("Closing connection");
char *account_name = session_get_account_name();
const char *fulljid = connection_get_fulljid();
char* account_name = session_get_account_name();
const char* fulljid = connection_get_fulljid();
plugins_on_disconnect(account_name, fulljid);
accounts_set_last_activity(session_get_account_name());
@@ -256,8 +258,7 @@ session_process_events(void)
int reconnect_sec;
jabber_conn_status_t conn_status = connection_get_status();
switch (conn_status)
{
switch (conn_status) {
case JABBER_CONNECTED:
case JABBER_CONNECTING:
case JABBER_DISCONNECTING:
@@ -297,7 +298,7 @@ session_login_success(gboolean secured)
log_debug("Connection handler: logged in with account name: %s", saved_account.name);
sv_ev_login_account_success(saved_account.name, secured);
// logged in without account, use details to create new account
// logged in without account, use details to create new account
} else {
log_debug("Connection handler: logged in with jid: %s", saved_details.name);
accounts_add(saved_details.name, saved_details.altdomain, saved_details.port, saved_details.tls_policy, saved_details.auth_policy);
@@ -316,10 +317,10 @@ session_login_success(gboolean secured)
// items discovery
connection_request_features();
char *domain = connection_get_domain();
char* domain = connection_get_domain();
iq_disco_items_request_onconnect(domain);
if (prefs_get_boolean(PREF_CARBONS)){
if (prefs_get_boolean(PREF_CARBONS)) {
iq_enable_carbons();
}
@@ -378,16 +379,16 @@ session_check_autoaway(void)
return;
}
char *mode = prefs_get_string(PREF_AUTOAWAY_MODE);
char* mode = prefs_get_string(PREF_AUTOAWAY_MODE);
gboolean check = prefs_get_boolean(PREF_AUTOAWAY_CHECK);
gint away_time = prefs_get_autoaway_time();
gint xa_time = prefs_get_autoxa_time();
int away_time_ms = away_time * 60000;
int xa_time_ms = xa_time * 60000;
char *account = session_get_account_name();
char* account = session_get_account_name();
resource_presence_t curr_presence = accounts_get_last_presence(account);
char *curr_status = accounts_get_last_status(account);
char* curr_status = accounts_get_last_status(account);
unsigned long idle_ms = ui_get_idle_time();
@@ -410,7 +411,7 @@ session_check_autoaway(void)
}
// send away presence with last activity
char *message = prefs_get_string(PREF_AUTOAWAY_MESSAGE);
char* message = prefs_get_string(PREF_AUTOAWAY_MESSAGE);
connection_set_presence_msg(message);
if (prefs_get_boolean(PREF_LASTACTIVITY)) {
cl_ev_presence_send(RESOURCE_AWAY, idle_ms / 1000);
@@ -453,7 +454,7 @@ session_check_autoaway(void)
activity_state = ACTIVITY_ST_XA;
// send extended away presence with last activity
char *message = prefs_get_string(PREF_AUTOXA_MESSAGE);
char* message = prefs_get_string(PREF_AUTOXA_MESSAGE);
connection_set_presence_msg(message);
if (prefs_get_boolean(PREF_LASTACTIVITY)) {
cl_ev_presence_send(RESOURCE_XA, idle_ms / 1000);
@@ -505,13 +506,13 @@ static void
_session_reconnect(void)
{
// reconnect with account.
ProfAccount *account = accounts_get_account(saved_account.name);
ProfAccount* account = accounts_get_account(saved_account.name);
if (account == NULL) {
log_error("Unable to reconnect, account no longer exists: %s", saved_account.name);
return;
}
char *jid = NULL;
char* jid = NULL;
if (account->resource) {
jid = create_fulljid(account->jid, account->resource);
} else {
@@ -542,4 +543,3 @@ _session_free_saved_details(void)
FREE_SET_NULL(saved_details.tls_policy);
FREE_SET_NULL(saved_details.auth_policy);
}

1028
src/xmpp/stanza.c
View File

File diff suppressed because it is too large Load Diff

519
src/xmpp/stanza.h
View File

@@ -48,192 +48,193 @@
#include <xmpp/xmpp.h>
#define STANZA_NAME_ACTIVE "active"
#define STANZA_NAME_INACTIVE "inactive"
#define STANZA_NAME_ACTIVE "active"
#define STANZA_NAME_INACTIVE "inactive"
#define STANZA_NAME_COMPOSING "composing"
#define STANZA_NAME_PAUSED "paused"
#define STANZA_NAME_GONE "gone"
#define STANZA_NAME_PAUSED "paused"
#define STANZA_NAME_GONE "gone"
#define STANZA_NAME_MESSAGE "message"
#define STANZA_NAME_BODY "body"
#define STANZA_NAME_BLOCK "block"
#define STANZA_NAME_UNBLOCK "unblock"
#define STANZA_NAME_MESSAGE "message"
#define STANZA_NAME_BODY "body"
#define STANZA_NAME_BLOCK "block"
#define STANZA_NAME_UNBLOCK "unblock"
#define STANZA_NAME_BLOCKLIST "blocklist"
#define STANZA_NAME_PRESENCE "presence"
#define STANZA_NAME_PRIORITY "priority"
#define STANZA_NAME_X "x"
#define STANZA_NAME_PRESENCE "presence"
#define STANZA_NAME_PRIORITY "priority"
#define STANZA_NAME_X "x"
// XEP-0373: OpenPGP for XMPP
#define STANZA_NAME_OPENPGP "openpgp"
#define STANZA_NAME_PUPKEY "pubkey"
#define STANZA_NAME_OPENPGP "openpgp"
#define STANZA_NAME_PUPKEY "pubkey"
#define STANZA_NAME_PUBLIC_KEYS_LIST "public-keys-list"
#define STANZA_NAME_PUBKEY_METADATA "pubkey-metadata"
#define STANZA_NAME_DATA "data"
#define STANZA_NAME_SHOW "show"
#define STANZA_NAME_STATUS "status"
#define STANZA_NAME_IQ "iq"
#define STANZA_NAME_QUERY "query"
#define STANZA_NAME_REQUEST "request"
#define STANZA_NAME_DELAY "delay"
#define STANZA_NAME_ERROR "error"
#define STANZA_NAME_PING "ping"
#define STANZA_NAME_TEXT "text"
#define STANZA_NAME_SUBJECT "subject"
#define STANZA_NAME_ITEM "item"
#define STANZA_NAME_ITEMS "items"
#define STANZA_NAME_C "c"
#define STANZA_NAME_IDENTITY "identity"
#define STANZA_NAME_FEATURE "feature"
#define STANZA_NAME_INVITE "invite"
#define STANZA_NAME_REASON "reason"
#define STANZA_NAME_GROUP "group"
#define STANZA_NAME_PUBSUB "pubsub"
#define STANZA_NAME_PUBLISH "publish"
#define STANZA_NAME_PUBLISH_OPTIONS "publish-options"
#define STANZA_NAME_SUBSCRIBE "subscribe"
#define STANZA_NAME_FIELD "field"
#define STANZA_NAME_STORAGE "storage"
#define STANZA_NAME_NICK "nick"
#define STANZA_NAME_PASSWORD "password"
#define STANZA_NAME_CONFERENCE "conference"
#define STANZA_NAME_VALUE "value"
#define STANZA_NAME_DESTROY "destroy"
#define STANZA_NAME_ACTOR "actor"
#define STANZA_NAME_ENABLE "enable"
#define STANZA_NAME_DISABLE "disable"
#define STANZA_NAME_FILENAME "filename"
#define STANZA_NAME_SIZE "size"
#define STANZA_NAME_CONTENT_TYPE "content-type"
#define STANZA_NAME_SLOT "slot"
#define STANZA_NAME_PUT "put"
#define STANZA_NAME_GET "get"
#define STANZA_NAME_URL "url"
#define STANZA_NAME_COMMAND "command"
#define STANZA_NAME_CONFIGURE "configure"
#define STANZA_NAME_ORIGIN_ID "origin-id"
#define STANZA_NAME_MINIMIZE "minimize"
#define STANZA_NAME_PUBKEY_METADATA "pubkey-metadata"
#define STANZA_NAME_DATA "data"
#define STANZA_NAME_SHOW "show"
#define STANZA_NAME_STATUS "status"
#define STANZA_NAME_IQ "iq"
#define STANZA_NAME_QUERY "query"
#define STANZA_NAME_REQUEST "request"
#define STANZA_NAME_DELAY "delay"
#define STANZA_NAME_ERROR "error"
#define STANZA_NAME_PING "ping"
#define STANZA_NAME_TEXT "text"
#define STANZA_NAME_SUBJECT "subject"
#define STANZA_NAME_ITEM "item"
#define STANZA_NAME_ITEMS "items"
#define STANZA_NAME_C "c"
#define STANZA_NAME_IDENTITY "identity"
#define STANZA_NAME_FEATURE "feature"
#define STANZA_NAME_INVITE "invite"
#define STANZA_NAME_REASON "reason"
#define STANZA_NAME_GROUP "group"
#define STANZA_NAME_PUBSUB "pubsub"
#define STANZA_NAME_PUBLISH "publish"
#define STANZA_NAME_PUBLISH_OPTIONS "publish-options"
#define STANZA_NAME_SUBSCRIBE "subscribe"
#define STANZA_NAME_FIELD "field"
#define STANZA_NAME_STORAGE "storage"
#define STANZA_NAME_NICK "nick"
#define STANZA_NAME_PASSWORD "password"
#define STANZA_NAME_CONFERENCE "conference"
#define STANZA_NAME_VALUE "value"
#define STANZA_NAME_DESTROY "destroy"
#define STANZA_NAME_ACTOR "actor"
#define STANZA_NAME_ENABLE "enable"
#define STANZA_NAME_DISABLE "disable"
#define STANZA_NAME_FILENAME "filename"
#define STANZA_NAME_SIZE "size"
#define STANZA_NAME_CONTENT_TYPE "content-type"
#define STANZA_NAME_SLOT "slot"
#define STANZA_NAME_PUT "put"
#define STANZA_NAME_GET "get"
#define STANZA_NAME_URL "url"
#define STANZA_NAME_COMMAND "command"
#define STANZA_NAME_CONFIGURE "configure"
#define STANZA_NAME_ORIGIN_ID "origin-id"
#define STANZA_NAME_MINIMIZE "minimize"
// error conditions
#define STANZA_NAME_BAD_REQUEST "bad-request"
#define STANZA_NAME_CONFLICT "conflict"
#define STANZA_NAME_BAD_REQUEST "bad-request"
#define STANZA_NAME_CONFLICT "conflict"
#define STANZA_NAME_FEATURE_NOT_IMPLEMENTED "feature-not-implemented"
#define STANZA_NAME_FORBIDDEN "forbidden"
#define STANZA_NAME_GONE "gone"
#define STANZA_NAME_INTERNAL_SERVER_ERROR "internal-server-error"
#define STANZA_NAME_ITEM_NOT_FOUND "item-not-found"
#define STANZA_NAME_JID_MALFORMED "jid-malformed"
#define STANZA_NAME_NOT_ACCEPTABLE "not-acceptable"
#define STANZA_NAME_NOT_ALLOWED "not-allowed"
#define STANZA_NAME_NOT_AUTHORISED "not-authorised"
#define STANZA_NAME_POLICY_VIOLATION "policy-violation"
#define STANZA_NAME_RECIPIENT_UNAVAILABLE "recipient-unavailable"
#define STANZA_NAME_REDIRECT "redirect"
#define STANZA_NAME_REGISTRATION_REQUIRED "registration-required"
#define STANZA_NAME_FORBIDDEN "forbidden"
#define STANZA_NAME_GONE "gone"
#define STANZA_NAME_INTERNAL_SERVER_ERROR "internal-server-error"
#define STANZA_NAME_ITEM_NOT_FOUND "item-not-found"
#define STANZA_NAME_JID_MALFORMED "jid-malformed"
#define STANZA_NAME_NOT_ACCEPTABLE "not-acceptable"
#define STANZA_NAME_NOT_ALLOWED "not-allowed"
#define STANZA_NAME_NOT_AUTHORISED "not-authorised"
#define STANZA_NAME_POLICY_VIOLATION "policy-violation"
#define STANZA_NAME_RECIPIENT_UNAVAILABLE "recipient-unavailable"
#define STANZA_NAME_REDIRECT "redirect"
#define STANZA_NAME_REGISTRATION_REQUIRED "registration-required"
#define STANZA_NAME_REMOTE_SERVER_NOT_FOUND "remote-server-not-found"
#define STANZA_NAME_REMOTE_SERVER_TIMEOUT "remote-server-timeout"
#define STANZA_NAME_RESOURCE_CONSTRAINT "resource-constraint"
#define STANZA_NAME_SERVICE_UNAVAILABLE "service-unavailable"
#define STANZA_NAME_SUBSCRIPTION_REQUIRED "subscription-required"
#define STANZA_NAME_UNDEFINED_CONDITION "undefined-condition"
#define STANZA_NAME_UNEXPECTED_REQUEST "unexpected-request"
#define STANZA_NAME_REMOTE_SERVER_TIMEOUT "remote-server-timeout"
#define STANZA_NAME_RESOURCE_CONSTRAINT "resource-constraint"
#define STANZA_NAME_SERVICE_UNAVAILABLE "service-unavailable"
#define STANZA_NAME_SUBSCRIPTION_REQUIRED "subscription-required"
#define STANZA_NAME_UNDEFINED_CONDITION "undefined-condition"
#define STANZA_NAME_UNEXPECTED_REQUEST "unexpected-request"
#define STANZA_TYPE_CHAT "chat"
#define STANZA_TYPE_GROUPCHAT "groupchat"
#define STANZA_TYPE_HEADLINE "headline"
#define STANZA_TYPE_NORMAL "normal"
#define STANZA_TYPE_UNAVAILABLE "unavailable"
#define STANZA_TYPE_SUBSCRIBE "subscribe"
#define STANZA_TYPE_SUBSCRIBED "subscribed"
#define STANZA_TYPE_CHAT "chat"
#define STANZA_TYPE_GROUPCHAT "groupchat"
#define STANZA_TYPE_HEADLINE "headline"
#define STANZA_TYPE_NORMAL "normal"
#define STANZA_TYPE_UNAVAILABLE "unavailable"
#define STANZA_TYPE_SUBSCRIBE "subscribe"
#define STANZA_TYPE_SUBSCRIBED "subscribed"
#define STANZA_TYPE_UNSUBSCRIBED "unsubscribed"
#define STANZA_TYPE_GET "get"
#define STANZA_TYPE_SET "set"
#define STANZA_TYPE_ERROR "error"
#define STANZA_TYPE_RESULT "result"
#define STANZA_TYPE_GET "get"
#define STANZA_TYPE_SET "set"
#define STANZA_TYPE_ERROR "error"
#define STANZA_TYPE_RESULT "result"
#define STANZA_ATTR_TO "to"
#define STANZA_ATTR_FROM "from"
#define STANZA_ATTR_STAMP "stamp"
#define STANZA_ATTR_TYPE "type"
#define STANZA_ATTR_CODE "code"
#define STANZA_ATTR_JID "jid"
#define STANZA_ATTR_NAME "name"
#define STANZA_ATTR_SUBSCRIPTION "subscription"
#define STANZA_ATTR_XMLNS "xmlns"
#define STANZA_ATTR_NICK "nick"
#define STANZA_ATTR_ASK "ask"
#define STANZA_ATTR_ID "id"
#define STANZA_ATTR_SECONDS "seconds"
#define STANZA_ATTR_NODE "node"
#define STANZA_ATTR_VER "ver"
#define STANZA_ATTR_VAR "var"
#define STANZA_ATTR_HASH "hash"
#define STANZA_ATTR_CATEGORY "category"
#define STANZA_ATTR_REASON "reason"
#define STANZA_ATTR_AUTOJOIN "autojoin"
#define STANZA_ATTR_PASSWORD "password"
#define STANZA_ATTR_STATUS "status"
#define STANZA_ATTR_DATE "date"
#define STANZA_ATTR_TO "to"
#define STANZA_ATTR_FROM "from"
#define STANZA_ATTR_STAMP "stamp"
#define STANZA_ATTR_TYPE "type"
#define STANZA_ATTR_CODE "code"
#define STANZA_ATTR_JID "jid"
#define STANZA_ATTR_NAME "name"
#define STANZA_ATTR_SUBSCRIPTION "subscription"
#define STANZA_ATTR_XMLNS "xmlns"
#define STANZA_ATTR_NICK "nick"
#define STANZA_ATTR_ASK "ask"
#define STANZA_ATTR_ID "id"
#define STANZA_ATTR_SECONDS "seconds"
#define STANZA_ATTR_NODE "node"
#define STANZA_ATTR_VER "ver"
#define STANZA_ATTR_VAR "var"
#define STANZA_ATTR_HASH "hash"
#define STANZA_ATTR_CATEGORY "category"
#define STANZA_ATTR_REASON "reason"
#define STANZA_ATTR_AUTOJOIN "autojoin"
#define STANZA_ATTR_PASSWORD "password"
#define STANZA_ATTR_STATUS "status"
#define STANZA_ATTR_DATE "date"
#define STANZA_ATTR_V4_FINGERPRINT "v4-fingerprint"
#define STANZA_TEXT_AWAY "away"
#define STANZA_TEXT_DND "dnd"
#define STANZA_TEXT_CHAT "chat"
#define STANZA_TEXT_XA "xa"
#define STANZA_TEXT_AWAY "away"
#define STANZA_TEXT_DND "dnd"
#define STANZA_TEXT_CHAT "chat"
#define STANZA_TEXT_XA "xa"
#define STANZA_TEXT_ONLINE "online"
#define STANZA_NS_STANZAS "urn:ietf:params:xml:ns:xmpp-stanzas"
#define STANZA_NS_CHATSTATES "http://jabber.org/protocol/chatstates"
#define STANZA_NS_MUC "http://jabber.org/protocol/muc"
#define STANZA_NS_MUC_USER "http://jabber.org/protocol/muc#user"
#define STANZA_NS_MUC_OWNER "http://jabber.org/protocol/muc#owner"
#define STANZA_NS_MUC_ADMIN "http://jabber.org/protocol/muc#admin"
#define STANZA_NS_CAPS "http://jabber.org/protocol/caps"
#define STANZA_NS_PING "urn:xmpp:ping"
#define STANZA_NS_STANZAS "urn:ietf:params:xml:ns:xmpp-stanzas"
#define STANZA_NS_CHATSTATES "http://jabber.org/protocol/chatstates"
#define STANZA_NS_MUC "http://jabber.org/protocol/muc"
#define STANZA_NS_MUC_USER "http://jabber.org/protocol/muc#user"
#define STANZA_NS_MUC_OWNER "http://jabber.org/protocol/muc#owner"
#define STANZA_NS_MUC_ADMIN "http://jabber.org/protocol/muc#admin"
#define STANZA_NS_CAPS "http://jabber.org/protocol/caps"
#define STANZA_NS_PING "urn:xmpp:ping"
#define STANZA_NS_LASTACTIVITY "jabber:iq:last"
#define STANZA_NS_DATA "jabber:x:data"
#define STANZA_NS_VERSION "jabber:iq:version"
#define STANZA_NS_CONFERENCE "jabber:x:conference"
#define STANZA_NS_CAPTCHA "urn:xmpp:captcha"
#define STANZA_NS_PUBSUB "http://jabber.org/protocol/pubsub"
#define STANZA_NS_DATA "jabber:x:data"
#define STANZA_NS_VERSION "jabber:iq:version"
#define STANZA_NS_CONFERENCE "jabber:x:conference"
#define STANZA_NS_CAPTCHA "urn:xmpp:captcha"
#define STANZA_NS_PUBSUB "http://jabber.org/protocol/pubsub"
#define STANZA_NS_PUBSUB_OWNER "http://jabber.org/protocol/pubsub#owner"
#define STANZA_NS_PUBSUB_EVENT "http://jabber.org/protocol/pubsub#event"
#define STANZA_NS_CARBONS "urn:xmpp:carbons:2"
#define STANZA_NS_HINTS "urn:xmpp:hints"
#define STANZA_NS_FORWARD "urn:xmpp:forward:0"
#define STANZA_NS_RECEIPTS "urn:xmpp:receipts"
#define STANZA_NS_SIGNED "jabber:x:signed"
#define STANZA_NS_ENCRYPTED "jabber:x:encrypted"
#define STANZA_NS_CARBONS "urn:xmpp:carbons:2"
#define STANZA_NS_HINTS "urn:xmpp:hints"
#define STANZA_NS_FORWARD "urn:xmpp:forward:0"
#define STANZA_NS_RECEIPTS "urn:xmpp:receipts"
#define STANZA_NS_SIGNED "jabber:x:signed"
#define STANZA_NS_ENCRYPTED "jabber:x:encrypted"
// XEP-0373: OpenPGP for XMPP
#define STANZA_NS_OPENPGP_0 "urn:xmpp:openpgp:0"
#define STANZA_NS_OPENPGP_0_PUBLIC_KEYS "urn:xmpp:openpgp:0:public-keys"
#define STANZA_NS_HTTP_UPLOAD "urn:xmpp:http:upload"
#define STANZA_NS_X_OOB "jabber:x:oob"
#define STANZA_NS_BLOCKING "urn:xmpp:blocking"
#define STANZA_NS_COMMAND "http://jabber.org/protocol/commands"
#define STANZA_NS_OMEMO "eu.siacs.conversations.axolotl"
#define STANZA_NS_OMEMO_DEVICELIST "eu.siacs.conversations.axolotl.devicelist"
#define STANZA_NS_OMEMO_BUNDLES "eu.siacs.conversations.axolotl.bundles"
#define STANZA_NS_STABLE_ID "urn:xmpp:sid:0"
#define STANZA_NS_USER_AVATAR_DATA "urn:xmpp:avatar:data"
#define STANZA_NS_USER_AVATAR_METADATA "urn:xmpp:avatar:metadata"
#define STANZA_NS_OPENPGP_0 "urn:xmpp:openpgp:0"
#define STANZA_NS_OPENPGP_0_PUBLIC_KEYS "urn:xmpp:openpgp:0:public-keys"
#define STANZA_NS_HTTP_UPLOAD "urn:xmpp:http:upload"
#define STANZA_NS_X_OOB "jabber:x:oob"
#define STANZA_NS_BLOCKING "urn:xmpp:blocking"
#define STANZA_NS_COMMAND "http://jabber.org/protocol/commands"
#define STANZA_NS_OMEMO "eu.siacs.conversations.axolotl"
#define STANZA_NS_OMEMO_DEVICELIST "eu.siacs.conversations.axolotl.devicelist"
#define STANZA_NS_OMEMO_BUNDLES "eu.siacs.conversations.axolotl.bundles"
#define STANZA_NS_STABLE_ID "urn:xmpp:sid:0"
#define STANZA_NS_USER_AVATAR_DATA "urn:xmpp:avatar:data"
#define STANZA_NS_USER_AVATAR_METADATA "urn:xmpp:avatar:metadata"
#define STANZA_NS_LAST_MESSAGE_CORRECTION "urn:xmpp:message-correct:0"
#define STANZA_NS_MAM2 "urn:xmpp:mam:2"
#define STANZA_NS_EXT_GAJIM_BOOKMARKS "xmpp:gajim.org/bookmarks"
#define STANZA_NS_MAM2 "urn:xmpp:mam:2"
#define STANZA_NS_EXT_GAJIM_BOOKMARKS "xmpp:gajim.org/bookmarks"
#define STANZA_DATAFORM_SOFTWARE "urn:xmpp:dataforms:softwareinfo"
typedef struct caps_stanza_t {
char *hash;
char *node;
char *ver;
typedef struct caps_stanza_t
{
char* hash;
char* node;
char* ver;
} XMPPCaps;
typedef struct presence_stanza_t {
Jid *jid;
char *show;
char *status;
typedef struct presence_stanza_t
{
Jid* jid;
char* show;
char* status;
int priority;
GDateTime *last_activity;
GDateTime* last_activity;
} XMPPPresence;
typedef enum {
@@ -241,141 +242,141 @@ typedef enum {
STANZA_PARSE_ERROR_INVALID_FROM
} stanza_parse_error_t;
xmpp_stanza_t* stanza_create_bookmarks_storage_request(xmpp_ctx_t *ctx);
xmpp_stanza_t* stanza_create_bookmarks_storage_request(xmpp_ctx_t* ctx);
xmpp_stanza_t* stanza_create_blocked_list_request(xmpp_ctx_t *ctx);
xmpp_stanza_t* stanza_create_blocked_list_request(xmpp_ctx_t* ctx);
xmpp_stanza_t* stanza_create_http_upload_request(xmpp_ctx_t *ctx, const char *const id, const char *const jid, HTTPUpload *upload);
xmpp_stanza_t* stanza_create_http_upload_request(xmpp_ctx_t* ctx, const char* const id, const char* const jid, HTTPUpload* upload);
xmpp_stanza_t* stanza_enable_carbons(xmpp_ctx_t *ctx);
xmpp_stanza_t* stanza_enable_carbons(xmpp_ctx_t* ctx);
xmpp_stanza_t* stanza_disable_carbons(xmpp_ctx_t *ctx);
xmpp_stanza_t* stanza_disable_carbons(xmpp_ctx_t* ctx);
xmpp_stanza_t* stanza_create_chat_state(xmpp_ctx_t *ctx,
const char *const fulljid, const char *const state);
xmpp_stanza_t* stanza_create_chat_state(xmpp_ctx_t* ctx,
const char* const fulljid, const char* const state);
xmpp_stanza_t* stanza_attach_state(xmpp_ctx_t *ctx, xmpp_stanza_t *stanza, const char *const state);
xmpp_stanza_t* stanza_attach_carbons_private(xmpp_ctx_t *ctx, xmpp_stanza_t *stanza);
xmpp_stanza_t* stanza_attach_hints_no_copy(xmpp_ctx_t *ctx, xmpp_stanza_t *stanza);
xmpp_stanza_t* stanza_attach_hints_no_store(xmpp_ctx_t *ctx, xmpp_stanza_t *stanza);
xmpp_stanza_t* stanza_attach_hints_store(xmpp_ctx_t *ctx, xmpp_stanza_t *stanza);
xmpp_stanza_t* stanza_attach_receipt_request(xmpp_ctx_t *ctx, xmpp_stanza_t *stanza);
xmpp_stanza_t* stanza_attach_x_oob_url(xmpp_ctx_t *ctx, xmpp_stanza_t *stanza, const char *const url);
xmpp_stanza_t* stanza_attach_origin_id(xmpp_ctx_t *ctx, xmpp_stanza_t *stanza, const char *const id);
xmpp_stanza_t* stanza_attach_correction(xmpp_ctx_t *ctx, xmpp_stanza_t *stanza, const char *const replace_id);
xmpp_stanza_t* stanza_attach_state(xmpp_ctx_t* ctx, xmpp_stanza_t* stanza, const char* const state);
xmpp_stanza_t* stanza_attach_carbons_private(xmpp_ctx_t* ctx, xmpp_stanza_t* stanza);
xmpp_stanza_t* stanza_attach_hints_no_copy(xmpp_ctx_t* ctx, xmpp_stanza_t* stanza);
xmpp_stanza_t* stanza_attach_hints_no_store(xmpp_ctx_t* ctx, xmpp_stanza_t* stanza);
xmpp_stanza_t* stanza_attach_hints_store(xmpp_ctx_t* ctx, xmpp_stanza_t* stanza);
xmpp_stanza_t* stanza_attach_receipt_request(xmpp_ctx_t* ctx, xmpp_stanza_t* stanza);
xmpp_stanza_t* stanza_attach_x_oob_url(xmpp_ctx_t* ctx, xmpp_stanza_t* stanza, const char* const url);
xmpp_stanza_t* stanza_attach_origin_id(xmpp_ctx_t* ctx, xmpp_stanza_t* stanza, const char* const id);
xmpp_stanza_t* stanza_attach_correction(xmpp_ctx_t* ctx, xmpp_stanza_t* stanza, const char* const replace_id);
xmpp_stanza_t* stanza_create_room_join_presence(xmpp_ctx_t *const ctx,
const char *const full_room_jid, const char *const passwd);
xmpp_stanza_t* stanza_create_room_join_presence(xmpp_ctx_t* const ctx,
const char* const full_room_jid, const char* const passwd);
xmpp_stanza_t* stanza_create_room_newnick_presence(xmpp_ctx_t *ctx,
const char *const full_room_jid);
xmpp_stanza_t* stanza_create_room_newnick_presence(xmpp_ctx_t* ctx,
const char* const full_room_jid);
xmpp_stanza_t* stanza_create_room_leave_presence(xmpp_ctx_t *ctx,
const char *const room, const char *const nick);
xmpp_stanza_t* stanza_create_room_leave_presence(xmpp_ctx_t* ctx,
const char* const room, const char* const nick);
xmpp_stanza_t* stanza_create_roster_iq(xmpp_ctx_t *ctx);
xmpp_stanza_t* stanza_create_ping_iq(xmpp_ctx_t *ctx, const char *const target);
xmpp_stanza_t* stanza_create_disco_info_iq(xmpp_ctx_t *ctx, const char *const id,
const char *const to, const char *const node);
xmpp_stanza_t* stanza_create_roster_iq(xmpp_ctx_t* ctx);
xmpp_stanza_t* stanza_create_ping_iq(xmpp_ctx_t* ctx, const char* const target);
xmpp_stanza_t* stanza_create_disco_info_iq(xmpp_ctx_t* ctx, const char* const id,
const char* const to, const char* const node);
xmpp_stanza_t* stanza_create_last_activity_iq(xmpp_ctx_t *ctx, const char *const id,
const char *const to);
xmpp_stanza_t* stanza_create_last_activity_iq(xmpp_ctx_t* ctx, const char* const id,
const char* const to);
xmpp_stanza_t* stanza_create_invite(xmpp_ctx_t *ctx, const char *const room,
const char *const contact, const char *const reason, const char *const password);
xmpp_stanza_t* stanza_create_mediated_invite(xmpp_ctx_t *ctx, const char *const room,
const char *const contact, const char *const reason);
xmpp_stanza_t* stanza_create_invite(xmpp_ctx_t* ctx, const char* const room,
const char* const contact, const char* const reason, const char* const password);
xmpp_stanza_t* stanza_create_mediated_invite(xmpp_ctx_t* ctx, const char* const room,
const char* const contact, const char* const reason);
gboolean stanza_contains_chat_state(xmpp_stanza_t *stanza);
gboolean stanza_contains_chat_state(xmpp_stanza_t* stanza);
GDateTime* stanza_get_delay(xmpp_stanza_t *const stanza);
GDateTime* stanza_get_delay_from(xmpp_stanza_t *const stanza, gchar *from);
GDateTime* stanza_get_oldest_delay(xmpp_stanza_t *const stanza);
GDateTime* stanza_get_delay(xmpp_stanza_t* const stanza);
GDateTime* stanza_get_delay_from(xmpp_stanza_t* const stanza, gchar* from);
GDateTime* stanza_get_oldest_delay(xmpp_stanza_t* const stanza);
gboolean stanza_is_muc_presence(xmpp_stanza_t *const stanza);
gboolean stanza_is_muc_self_presence(xmpp_stanza_t *const stanza,
const char *const self_jid);
gboolean stanza_is_room_nick_change(xmpp_stanza_t *const stanza);
gboolean stanza_muc_requires_config(xmpp_stanza_t *const stanza);
gboolean stanza_is_muc_presence(xmpp_stanza_t* const stanza);
gboolean stanza_is_muc_self_presence(xmpp_stanza_t* const stanza,
const char* const self_jid);
gboolean stanza_is_room_nick_change(xmpp_stanza_t* const stanza);
gboolean stanza_muc_requires_config(xmpp_stanza_t* const stanza);
const char* stanza_get_new_nick(xmpp_stanza_t *const stanza);
xmpp_stanza_t* stanza_create_instant_room_request_iq(xmpp_ctx_t *ctx, const char *const room_jid);
xmpp_stanza_t* stanza_create_instant_room_destroy_iq(xmpp_ctx_t *ctx, const char *const room_jid);
xmpp_stanza_t* stanza_create_room_config_request_iq(xmpp_ctx_t *ctx, const char *const room_jid);
xmpp_stanza_t* stanza_create_room_config_cancel_iq(xmpp_ctx_t *ctx, const char *const room_jid);
xmpp_stanza_t* stanza_create_room_config_submit_iq(xmpp_ctx_t *ctx, const char *const room, DataForm *form);
xmpp_stanza_t* stanza_create_room_affiliation_list_iq(xmpp_ctx_t *ctx, const char *const room,
const char *const affiliation);
xmpp_stanza_t* stanza_create_room_affiliation_set_iq(xmpp_ctx_t *ctx, const char *const room, const char *const jid,
const char *const affiliation, const char *const reason);
xmpp_stanza_t* stanza_create_room_role_set_iq(xmpp_ctx_t *const ctx, const char *const room, const char *const jid,
const char *const role, const char *const reason);
xmpp_stanza_t* stanza_create_room_role_list_iq(xmpp_ctx_t *ctx, const char *const room, const char *const role);
const char* stanza_get_new_nick(xmpp_stanza_t* const stanza);
xmpp_stanza_t* stanza_create_instant_room_request_iq(xmpp_ctx_t* ctx, const char* const room_jid);
xmpp_stanza_t* stanza_create_instant_room_destroy_iq(xmpp_ctx_t* ctx, const char* const room_jid);
xmpp_stanza_t* stanza_create_room_config_request_iq(xmpp_ctx_t* ctx, const char* const room_jid);
xmpp_stanza_t* stanza_create_room_config_cancel_iq(xmpp_ctx_t* ctx, const char* const room_jid);
xmpp_stanza_t* stanza_create_room_config_submit_iq(xmpp_ctx_t* ctx, const char* const room, DataForm* form);
xmpp_stanza_t* stanza_create_room_affiliation_list_iq(xmpp_ctx_t* ctx, const char* const room,
const char* const affiliation);
xmpp_stanza_t* stanza_create_room_affiliation_set_iq(xmpp_ctx_t* ctx, const char* const room, const char* const jid,
const char* const affiliation, const char* const reason);
xmpp_stanza_t* stanza_create_room_role_set_iq(xmpp_ctx_t* const ctx, const char* const room, const char* const jid,
const char* const role, const char* const reason);
xmpp_stanza_t* stanza_create_room_role_list_iq(xmpp_ctx_t* ctx, const char* const room, const char* const role);
xmpp_stanza_t* stanza_create_room_subject_message(xmpp_ctx_t *ctx, const char *const room, const char *const subject);
xmpp_stanza_t* stanza_create_room_kick_iq(xmpp_ctx_t *const ctx, const char *const room, const char *const nick,
const char *const reason);
xmpp_stanza_t* stanza_create_room_subject_message(xmpp_ctx_t* ctx, const char* const room, const char* const subject);
xmpp_stanza_t* stanza_create_room_kick_iq(xmpp_ctx_t* const ctx, const char* const room, const char* const nick,
const char* const reason);
xmpp_stanza_t* stanza_create_command_exec_iq(xmpp_ctx_t *ctx, const char *const target, const char *const node);
xmpp_stanza_t* stanza_create_command_config_submit_iq(xmpp_ctx_t *ctx, const char *const room, const char *const node, const char *const sessionid, DataForm *form);
xmpp_stanza_t* stanza_create_command_exec_iq(xmpp_ctx_t* ctx, const char* const target, const char* const node);
xmpp_stanza_t* stanza_create_command_config_submit_iq(xmpp_ctx_t* ctx, const char* const room, const char* const node, const char* const sessionid, DataForm* form);
void stanza_attach_publish_options(xmpp_ctx_t *const ctx, xmpp_stanza_t *const publish, const char *const option, const char *const value);
void stanza_attach_publish_options(xmpp_ctx_t* const ctx, xmpp_stanza_t* const publish, const char* const option, const char* const value);
xmpp_stanza_t* stanza_create_omemo_devicelist_request(xmpp_ctx_t *ctx, const char *const id, const char *const jid);
xmpp_stanza_t* stanza_create_omemo_devicelist_subscribe(xmpp_ctx_t *ctx, const char *const jid);
xmpp_stanza_t* stanza_create_omemo_devicelist_publish(xmpp_ctx_t *ctx, GList *const ids);
xmpp_stanza_t* stanza_create_omemo_bundle_publish(xmpp_ctx_t *ctx, const char *const id, uint32_t device_id, const unsigned char * const identity_key, size_t identity_key_length, const unsigned char * const signed_prekey, size_t signed_prekey_length, const unsigned char * const signed_prekey_signature, size_t signed_prekey_signature_length, GList *const prekeys, GList *const prekeys_id, GList *const prekeys_length);
xmpp_stanza_t* stanza_create_omemo_bundle_request(xmpp_ctx_t *ctx, const char *const id, const char *const jid, uint32_t device_id);
xmpp_stanza_t* stanza_create_omemo_devicelist_request(xmpp_ctx_t* ctx, const char* const id, const char* const jid);
xmpp_stanza_t* stanza_create_omemo_devicelist_subscribe(xmpp_ctx_t* ctx, const char* const jid);
xmpp_stanza_t* stanza_create_omemo_devicelist_publish(xmpp_ctx_t* ctx, GList* const ids);
xmpp_stanza_t* stanza_create_omemo_bundle_publish(xmpp_ctx_t* ctx, const char* const id, uint32_t device_id, const unsigned char* const identity_key, size_t identity_key_length, const unsigned char* const signed_prekey, size_t signed_prekey_length, const unsigned char* const signed_prekey_signature, size_t signed_prekey_signature_length, GList* const prekeys, GList* const prekeys_id, GList* const prekeys_length);
xmpp_stanza_t* stanza_create_omemo_bundle_request(xmpp_ctx_t* ctx, const char* const id, const char* const jid, uint32_t device_id);
xmpp_stanza_t* stanza_create_pubsub_configure_request(xmpp_ctx_t *ctx, const char *const id, const char *const jid, const char *const node);
xmpp_stanza_t* stanza_create_pubsub_configure_submit(xmpp_ctx_t *ctx, const char *const id, const char *const jid, const char *const node, DataForm *form);
xmpp_stanza_t* stanza_create_pubsub_configure_request(xmpp_ctx_t* ctx, const char* const id, const char* const jid, const char* const node);
xmpp_stanza_t* stanza_create_pubsub_configure_submit(xmpp_ctx_t* ctx, const char* const id, const char* const jid, const char* const node, DataForm* form);
int stanza_get_idle_time(xmpp_stanza_t *const stanza);
int stanza_get_idle_time(xmpp_stanza_t* const stanza);
void stanza_attach_priority(xmpp_ctx_t *const ctx, xmpp_stanza_t *const presence, const int pri);
void stanza_attach_last_activity(xmpp_ctx_t *const ctx, xmpp_stanza_t *const presence, const int idle);
void stanza_attach_caps(xmpp_ctx_t *const ctx, xmpp_stanza_t *const presence);
void stanza_attach_show(xmpp_ctx_t *const ctx, xmpp_stanza_t *const presence, const char *const show);
void stanza_attach_status(xmpp_ctx_t *const ctx, xmpp_stanza_t *const presence, const char *const status);
void stanza_attach_priority(xmpp_ctx_t* const ctx, xmpp_stanza_t* const presence, const int pri);
void stanza_attach_last_activity(xmpp_ctx_t* const ctx, xmpp_stanza_t* const presence, const int idle);
void stanza_attach_caps(xmpp_ctx_t* const ctx, xmpp_stanza_t* const presence);
void stanza_attach_show(xmpp_ctx_t* const ctx, xmpp_stanza_t* const presence, const char* const show);
void stanza_attach_status(xmpp_ctx_t* const ctx, xmpp_stanza_t* const presence, const char* const status);
xmpp_stanza_t* stanza_create_caps_query_element(xmpp_ctx_t *ctx);
char* stanza_create_caps_sha1_from_query(xmpp_stanza_t *const query);
EntityCapabilities* stanza_create_caps_from_query_element(xmpp_stanza_t *query);
xmpp_stanza_t* stanza_create_caps_query_element(xmpp_ctx_t* ctx);
char* stanza_create_caps_sha1_from_query(xmpp_stanza_t* const query);
EntityCapabilities* stanza_create_caps_from_query_element(xmpp_stanza_t* query);
const char* stanza_get_presence_string_from_type(resource_presence_t presence_type);
xmpp_stanza_t* stanza_create_software_version_iq(xmpp_ctx_t *ctx, const char *const fulljid);
xmpp_stanza_t* stanza_create_disco_items_iq(xmpp_ctx_t *ctx, const char *const id, const char *const jid, const char *const node);
xmpp_stanza_t* stanza_create_software_version_iq(xmpp_ctx_t* ctx, const char* const fulljid);
xmpp_stanza_t* stanza_create_disco_items_iq(xmpp_ctx_t* ctx, const char* const id, const char* const jid, const char* const node);
char* stanza_get_status(xmpp_stanza_t *stanza, char *def);
char* stanza_get_show(xmpp_stanza_t *stanza, char *def);
char* stanza_get_status(xmpp_stanza_t* stanza, char* def);
char* stanza_get_show(xmpp_stanza_t* stanza, char* def);
xmpp_stanza_t* stanza_create_roster_set(xmpp_ctx_t *ctx, const char *const id, const char *const jid,
const char *const handle, GSList *groups);
xmpp_stanza_t* stanza_create_roster_remove_set(xmpp_ctx_t *ctx, const char *const barejid);
xmpp_stanza_t* stanza_create_roster_set(xmpp_ctx_t* ctx, const char* const id, const char* const jid,
const char* const handle, GSList* groups);
xmpp_stanza_t* stanza_create_roster_remove_set(xmpp_ctx_t* ctx, const char* const barejid);
char* stanza_get_error_message(xmpp_stanza_t *const stanza);
char* stanza_get_error_message(xmpp_stanza_t* const stanza);
GSList* stanza_get_status_codes_by_ns(xmpp_stanza_t *const stanza, char *ns);
gboolean stanza_room_destroyed(xmpp_stanza_t *stanza);
const char* stanza_get_muc_destroy_alternative_room(xmpp_stanza_t *stanza);
char* stanza_get_muc_destroy_alternative_password(xmpp_stanza_t *stanza);
char* stanza_get_muc_destroy_reason(xmpp_stanza_t *stanza);
const char* stanza_get_actor(xmpp_stanza_t *stanza);
char* stanza_get_reason(xmpp_stanza_t *stanza);
GSList* stanza_get_status_codes_by_ns(xmpp_stanza_t* const stanza, char* ns);
gboolean stanza_room_destroyed(xmpp_stanza_t* stanza);
const char* stanza_get_muc_destroy_alternative_room(xmpp_stanza_t* stanza);
char* stanza_get_muc_destroy_alternative_password(xmpp_stanza_t* stanza);
char* stanza_get_muc_destroy_reason(xmpp_stanza_t* stanza);
const char* stanza_get_actor(xmpp_stanza_t* stanza);
char* stanza_get_reason(xmpp_stanza_t* stanza);
Resource* stanza_resource_from_presence(XMPPPresence *presence);
XMPPPresence* stanza_parse_presence(xmpp_stanza_t *stanza, int *err);
void stanza_free_presence(XMPPPresence *presence);
Resource* stanza_resource_from_presence(XMPPPresence* presence);
XMPPPresence* stanza_parse_presence(xmpp_stanza_t* stanza, int* err);
void stanza_free_presence(XMPPPresence* presence);
char* stanza_text_strdup(xmpp_stanza_t *stanza);
char* stanza_text_strdup(xmpp_stanza_t* stanza);
XMPPCaps* stanza_parse_caps(xmpp_stanza_t *const stanza);
void stanza_free_caps(XMPPCaps *caps);
XMPPCaps* stanza_parse_caps(xmpp_stanza_t* const stanza);
void stanza_free_caps(XMPPCaps* caps);
xmpp_stanza_t* stanza_get_child_by_name_and_ns(xmpp_stanza_t * const stanza, const char * const name, const char * const ns);
xmpp_stanza_t* stanza_get_child_by_name_and_ns(xmpp_stanza_t* const stanza, const char* const name, const char* const ns);
xmpp_stanza_t* stanza_create_avatar_retrieve_data_request(xmpp_ctx_t *ctx, const char *stanza_id, const char *const item_id, const char *const jid);
xmpp_stanza_t* stanza_create_avatar_retrieve_data_request(xmpp_ctx_t* ctx, const char* stanza_id, const char* const item_id, const char* const jid);
xmpp_stanza_t* stanza_create_mam_iq(xmpp_ctx_t *ctx, const char *const jid, const char *const startdate);
xmpp_stanza_t* stanza_create_mam_iq(xmpp_ctx_t* ctx, const char* const jid, const char* const startdate);
#endif

280
src/xmpp/xmpp.h
View File

@@ -58,18 +58,18 @@
#define JABBER_PRIORITY_MIN -128
#define JABBER_PRIORITY_MAX 127
#define XMPP_FEATURE_PING "urn:xmpp:ping"
#define XMPP_FEATURE_BLOCKING "urn:xmpp:blocking"
#define XMPP_FEATURE_RECEIPTS "urn:xmpp:receipts"
#define XMPP_FEATURE_LASTACTIVITY "jabber:iq:last"
#define XMPP_FEATURE_MUC "http://jabber.org/protocol/muc"
#define XMPP_FEATURE_COMMANDS "http://jabber.org/protocol/commands"
#define XMPP_FEATURE_OMEMO_DEVICELIST_NOTIFY "eu.siacs.conversations.axolotl.devicelist+notify"
#define XMPP_FEATURE_PUBSUB "http://jabber.org/protocol/pubsub"
#define XMPP_FEATURE_PUBSUB_PUBLISH_OPTIONS "http://jabber.org/protocol/pubsub#publish-options"
#define XMPP_FEATURE_PING "urn:xmpp:ping"
#define XMPP_FEATURE_BLOCKING "urn:xmpp:blocking"
#define XMPP_FEATURE_RECEIPTS "urn:xmpp:receipts"
#define XMPP_FEATURE_LASTACTIVITY "jabber:iq:last"
#define XMPP_FEATURE_MUC "http://jabber.org/protocol/muc"
#define XMPP_FEATURE_COMMANDS "http://jabber.org/protocol/commands"
#define XMPP_FEATURE_OMEMO_DEVICELIST_NOTIFY "eu.siacs.conversations.axolotl.devicelist+notify"
#define XMPP_FEATURE_PUBSUB "http://jabber.org/protocol/pubsub"
#define XMPP_FEATURE_PUBSUB_PUBLISH_OPTIONS "http://jabber.org/protocol/pubsub#publish-options"
#define XMPP_FEATURE_USER_AVATAR_METADATA_NOTIFY "urn:xmpp:avatar:metadata+notify"
#define XMPP_FEATURE_LAST_MESSAGE_CORRECTION "urn:xmpp:message-correct:0"
#define XMPP_FEATURE_MAM2 "urn:xmpp:mam:2"
#define XMPP_FEATURE_LAST_MESSAGE_CORRECTION "urn:xmpp:message-correct:0"
#define XMPP_FEATURE_MAM2 "urn:xmpp:mam:2"
typedef enum {
JABBER_CONNECTING,
@@ -89,37 +89,42 @@ typedef enum {
INVITE_MEDIATED
} jabber_invite_t;
typedef struct bookmark_t {
char *barejid;
char *nick;
char *password;
char *name;
typedef struct bookmark_t
{
char* barejid;
char* nick;
char* password;
char* name;
gboolean autojoin;
int ext_gajim_minimize; //0 - non existant, 1 - true, 2 - false
} Bookmark;
typedef struct disco_identity_t {
char *name;
char *type;
char *category;
typedef struct disco_identity_t
{
char* name;
char* type;
char* category;
} DiscoIdentity;
typedef struct software_version_t {
char *software;
char *software_version;
char *os;
char *os_version;
typedef struct software_version_t
{
char* software;
char* software_version;
char* os;
char* os_version;
} SoftwareVersion;
typedef struct entity_capabilities_t {
DiscoIdentity *identity;
SoftwareVersion *software_version;
GSList *features;
typedef struct entity_capabilities_t
{
DiscoIdentity* identity;
SoftwareVersion* software_version;
GSList* features;
} EntityCapabilities;
typedef struct disco_item_t {
char *jid;
char *name;
typedef struct disco_item_t
{
char* jid;
char* name;
} DiscoItem;
typedef enum {
@@ -140,155 +145,156 @@ typedef enum {
PROF_MSG_TYPE_MUCPM
} prof_msg_type_t;
typedef struct prof_message_t {
Jid *from_jid;
Jid *to_jid;
/* regular <message id=""> */
char *id;
/* </origin-id> XEP-0359 */
char *originid;
/* <replace id> XEP-0308 LMC */
char *replace_id;
/* for MAM we will need archive_id (stanza-id in XEP-0359) (see database.c) */
/* The raw body from xmpp message, either plaintext or OTR encrypted text */
char *body;
/* The encrypted message as for PGP */
char *encrypted;
/* The message that will be printed on screen and logs */
char *plain;
GDateTime *timestamp;
prof_enc_t enc;
gboolean trusted;
gboolean is_mam;
prof_msg_type_t type;
typedef struct prof_message_t
{
Jid* from_jid;
Jid* to_jid;
/* regular <message id=""> */
char* id;
/* </origin-id> XEP-0359 */
char* originid;
/* <replace id> XEP-0308 LMC */
char* replace_id;
/* for MAM we will need archive_id (stanza-id in XEP-0359) (see database.c) */
/* The raw body from xmpp message, either plaintext or OTR encrypted text */
char* body;
/* The encrypted message as for PGP */
char* encrypted;
/* The message that will be printed on screen and logs */
char* plain;
GDateTime* timestamp;
prof_enc_t enc;
gboolean trusted;
gboolean is_mam;
prof_msg_type_t type;
} ProfMessage;
void session_init(void);
jabber_conn_status_t session_connect_with_details(const char *const jid, const char *const passwd,
const char *const altdomain, const int port, const char *const tls_policy, const char *const auth_policy);
jabber_conn_status_t session_connect_with_account(const ProfAccount *const account);
jabber_conn_status_t session_connect_with_details(const char* const jid, const char* const passwd,
const char* const altdomain, const int port, const char* const tls_policy, const char* const auth_policy);
jabber_conn_status_t session_connect_with_account(const ProfAccount* const account);
void session_disconnect(void);
void session_shutdown(void);
void session_process_events(void);
char* session_get_account_name(void);
jabber_conn_status_t connection_get_status(void);
char *connection_get_presence_msg(void);
void connection_set_presence_msg(const char *const message);
char* connection_get_presence_msg(void);
void connection_set_presence_msg(const char* const message);
const char* connection_get_fulljid(void);
char* connection_get_barejid(void);
char* connection_create_uuid(void);
void connection_free_uuid(char *uuid);
void connection_free_uuid(char* uuid);
#ifdef HAVE_LIBMESODE
TLSCertificate* connection_get_tls_peer_cert(void);
#endif
gboolean connection_is_secured(void);
gboolean connection_send_stanza(const char *const stanza);
gboolean connection_send_stanza(const char* const stanza);
GList* connection_get_available_resources(void);
gboolean connection_supports(const char *const feature);
char* connection_jid_for_feature(const char *const feature);
gboolean connection_supports(const char* const feature);
char* connection_jid_for_feature(const char* const feature);
const char* connection_get_profanity_identifier(void);
char* message_send_chat(const char *const barejid, const char *const msg, const char *const oob_url, gboolean request_receipt, const char *const replace_id);
char* message_send_chat_otr(const char *const barejid, const char *const msg, gboolean request_receipt, const char *const replace_id);
char* message_send_chat_pgp(const char *const barejid, const char *const msg, gboolean request_receipt, const char *const replace_id);
char* message_send_chat(const char* const barejid, const char* const msg, const char* const oob_url, gboolean request_receipt, const char* const replace_id);
char* message_send_chat_otr(const char* const barejid, const char* const msg, gboolean request_receipt, const char* const replace_id);
char* message_send_chat_pgp(const char* const barejid, const char* const msg, gboolean request_receipt, const char* const replace_id);
// XEP-0373: OpenPGP for XMPP
char* message_send_chat_ox(const char *const barejid, const char *const msg, gboolean request_receipt, const char *const replace_id);
char* message_send_chat_omemo(const char *const jid, uint32_t sid, GList *keys, const unsigned char *const iv, size_t iv_len, const unsigned char *const ciphertext, size_t ciphertext_len, gboolean request_receipt, gboolean muc, const char *const replace_id);
char* message_send_private(const char *const fulljid, const char *const msg, const char *const oob_url);
char* message_send_groupchat(const char *const roomjid, const char *const msg, const char *const oob_url, const char *const replace_id);
void message_send_groupchat_subject(const char *const roomjid, const char *const subject);
void message_send_inactive(const char *const jid);
void message_send_composing(const char *const jid);
void message_send_paused(const char *const jid);
void message_send_gone(const char *const jid);
void message_send_invite(const char *const room, const char *const contact, const char *const reason);
char* message_send_chat_ox(const char* const barejid, const char* const msg, gboolean request_receipt, const char* const replace_id);
char* message_send_chat_omemo(const char* const jid, uint32_t sid, GList* keys, const unsigned char* const iv, size_t iv_len, const unsigned char* const ciphertext, size_t ciphertext_len, gboolean request_receipt, gboolean muc, const char* const replace_id);
char* message_send_private(const char* const fulljid, const char* const msg, const char* const oob_url);
char* message_send_groupchat(const char* const roomjid, const char* const msg, const char* const oob_url, const char* const replace_id);
void message_send_groupchat_subject(const char* const roomjid, const char* const subject);
void message_send_inactive(const char* const jid);
void message_send_composing(const char* const jid);
void message_send_paused(const char* const jid);
void message_send_gone(const char* const jid);
void message_send_invite(const char* const room, const char* const contact, const char* const reason);
bool message_is_sent_by_us(const ProfMessage *const message, bool checkOID);
bool message_is_sent_by_us(const ProfMessage* const message, bool checkOID);
void presence_subscription(const char *const jid, const jabber_subscr_t action);
void presence_subscription(const char* const jid, const jabber_subscr_t action);
GList* presence_get_subscription_requests(void);
gint presence_sub_request_count(void);
void presence_reset_sub_request_search(void);
char* presence_sub_request_find(const char *const search_str, gboolean previous, void *context);
void presence_join_room(const char *const room, const char *const nick, const char *const passwd);
void presence_change_room_nick(const char *const room, const char *const nick);
void presence_leave_chat_room(const char *const room_jid);
void presence_send(resource_presence_t status, int idle, char *signed_status);
gboolean presence_sub_request_exists(const char *const bare_jid);
char* presence_sub_request_find(const char* const search_str, gboolean previous, void* context);
void presence_join_room(const char* const room, const char* const nick, const char* const passwd);
void presence_change_room_nick(const char* const room, const char* const nick);
void presence_leave_chat_room(const char* const room_jid);
void presence_send(resource_presence_t status, int idle, char* signed_status);
gboolean presence_sub_request_exists(const char* const bare_jid);
void iq_enable_carbons(void);
void iq_disable_carbons(void);
void iq_send_software_version(const char *const fulljid);
void iq_send_software_version(const char* const fulljid);
void iq_rooms_cache_clear(void);
void iq_handlers_clear();
void iq_room_list_request(gchar *conferencejid, gchar *filter);
void iq_disco_info_request(gchar *jid);
void iq_disco_items_request(gchar *jid);
void iq_last_activity_request(gchar *jid);
void iq_room_list_request(gchar* conferencejid, gchar* filter);
void iq_disco_info_request(gchar* jid);
void iq_disco_items_request(gchar* jid);
void iq_last_activity_request(gchar* jid);
void iq_set_autoping(int seconds);
void iq_confirm_instant_room(const char *const room_jid);
void iq_destroy_room(const char *const room_jid);
void iq_request_room_config_form(const char *const room_jid);
void iq_submit_room_config(ProfConfWin *confwin);
void iq_room_config_cancel(ProfConfWin *confwin);
void iq_send_ping(const char *const target);
void iq_room_info_request(const char *const room, gboolean display_result);
void iq_room_affiliation_list(const char *const room, char *affiliation, bool show);
void iq_room_affiliation_set(const char *const room, const char *const jid, char *affiliation,
const char *const reason);
void iq_room_kick_occupant(const char *const room, const char *const nick, const char *const reason);
void iq_room_role_set(const char *const room, const char *const nick, char *role, const char *const reason);
void iq_room_role_list(const char * const room, char *role);
void iq_confirm_instant_room(const char* const room_jid);
void iq_destroy_room(const char* const room_jid);
void iq_request_room_config_form(const char* const room_jid);
void iq_submit_room_config(ProfConfWin* confwin);
void iq_room_config_cancel(ProfConfWin* confwin);
void iq_send_ping(const char* const target);
void iq_room_info_request(const char* const room, gboolean display_result);
void iq_room_affiliation_list(const char* const room, char* affiliation, bool show);
void iq_room_affiliation_set(const char* const room, const char* const jid, char* affiliation,
const char* const reason);
void iq_room_kick_occupant(const char* const room, const char* const nick, const char* const reason);
void iq_room_role_set(const char* const room, const char* const nick, char* role, const char* const reason);
void iq_room_role_list(const char* const room, char* role);
void iq_autoping_timer_cancel(void);
void iq_autoping_check(void);
void iq_http_upload_request(HTTPUpload *upload);
void iq_command_list(const char *const target);
void iq_command_exec(const char *const target, const char *const command);
void iq_mam_request(ProfChatWin *win);
void iq_http_upload_request(HTTPUpload* upload);
void iq_command_list(const char* const target);
void iq_command_exec(const char* const target, const char* const command);
void iq_mam_request(ProfChatWin* win);
EntityCapabilities* caps_lookup(const char *const jid);
EntityCapabilities* caps_lookup(const char* const jid);
void caps_close(void);
void caps_destroy(EntityCapabilities *caps);
void caps_destroy(EntityCapabilities* caps);
void caps_reset_ver(void);
void caps_add_feature(char *feature);
void caps_remove_feature(char *feature);
gboolean caps_jid_has_feature(const char *const jid, const char *const feature);
void caps_add_feature(char* feature);
void caps_remove_feature(char* feature);
gboolean caps_jid_has_feature(const char* const jid, const char* const feature);
gboolean bookmark_add(const char *jid, const char *nick, const char *password, const char *autojoin_str, const char *name);
gboolean bookmark_update(const char *jid, const char *nick, const char *password, const char *autojoin_str, const char *name);
gboolean bookmark_remove(const char *jid);
gboolean bookmark_join(const char *jid);
gboolean bookmark_add(const char* jid, const char* nick, const char* password, const char* autojoin_str, const char* name);
gboolean bookmark_update(const char* jid, const char* nick, const char* password, const char* autojoin_str, const char* name);
gboolean bookmark_remove(const char* jid);
gboolean bookmark_join(const char* jid);
GList* bookmark_get_list(void);
char* bookmark_find(const char *const search_str, gboolean previous, void *context);
char* bookmark_find(const char* const search_str, gboolean previous, void* context);
void bookmark_autocomplete_reset(void);
gboolean bookmark_exists(const char *const room);
gboolean bookmark_exists(const char* const room);
void roster_send_name_change(const char *const barejid, const char *const new_name, GSList *groups);
void roster_send_add_to_group(const char *const group, PContact contact);
void roster_send_remove_from_group(const char *const group, PContact contact);
void roster_send_add_new(const char *const barejid, const char *const name);
void roster_send_remove(const char *const barejid);
void roster_send_name_change(const char* const barejid, const char* const new_name, GSList* groups);
void roster_send_add_to_group(const char* const group, PContact contact);
void roster_send_remove_from_group(const char* const group, PContact contact);
void roster_send_add_new(const char* const barejid, const char* const name);
void roster_send_remove(const char* const barejid);
GList* blocked_list(void);
gboolean blocked_add(char *jid);
gboolean blocked_remove(char *jid);
char* blocked_ac_find(const char *const search_str, gboolean previous, void *context);
gboolean blocked_add(char* jid);
gboolean blocked_remove(char* jid);
char* blocked_ac_find(const char* const search_str, gboolean previous, void* context);
void blocked_ac_reset(void);
void form_destroy(DataForm *form);
void form_set_value(DataForm *form, const char *const tag, char *value);
gboolean form_add_unique_value(DataForm *form, const char *const tag, char *value);
void form_add_value(DataForm *form, const char *const tag, char *value);
gboolean form_remove_value(DataForm *form, const char *const tag, char *value);
gboolean form_remove_text_multi_value(DataForm *form, const char *const tag, int index);
gboolean form_tag_exists(DataForm *form, const char *const tag);
form_field_type_t form_get_field_type(DataForm *form, const char *const tag);
gboolean form_field_contains_option(DataForm *form, const char *const tag, char *value);
int form_get_value_count(DataForm *form, const char *const tag);
FormField* form_get_field_by_tag(DataForm *form, const char *const tag);
Autocomplete form_get_value_ac(DataForm *form, const char *const tag);
void form_reset_autocompleters(DataForm *form);
void form_destroy(DataForm* form);
void form_set_value(DataForm* form, const char* const tag, char* value);
gboolean form_add_unique_value(DataForm* form, const char* const tag, char* value);
void form_add_value(DataForm* form, const char* const tag, char* value);
gboolean form_remove_value(DataForm* form, const char* const tag, char* value);
gboolean form_remove_text_multi_value(DataForm* form, const char* const tag, int index);
gboolean form_tag_exists(DataForm* form, const char* const tag);
form_field_type_t form_get_field_type(DataForm* form, const char* const tag);
gboolean form_field_contains_option(DataForm* form, const char* const tag, char* value);
int form_get_value_count(DataForm* form, const char* const tag);
FormField* form_get_field_by_tag(DataForm* form, const char* const tag);
Autocomplete form_get_value_ac(DataForm* form, const char* const tag);
void form_reset_autocompleters(DataForm* form);
#endif