Fix displaying contact name

.gitignore

@@ -1,2 +1,6 @@
-/purple
+/libdelta.so
-/target
+/libetpan.so
+/libdeltachat.so
+/libnetpgp.so
+/vendor/deltachat-core-0.35.0
+/vendor/libetpan-1.8

Cargo.toml

@@ -1,28 +0,0 @@
-[package]
-name = "purple-plugin-delta"
-version = "0.1.0"
-authors = ["Nick Thomas <delta@ur.gs>"]
-
-[lib]
-name = "purple_delta"
-path = "src/lib.rs"
-crate-type = ["dylib"]
-
-[dependencies]
-deltachat = { git = "https://github.com/deltachat/deltachat-core-rust", tag="v1.51.0" }
-glib-sys = "*"
-glib = "*"
-lazy_static = "1.4.0"
-libc = "*"
-log = "0.4.8"
-paste ="*"
-purple-sys = { git = "https://github.com/lupine/libpurple-rust", branch="with-flared" }
-serde = "*"
-
-# Keep in sync with deltachat-core-rust
-[dependencies.async-std]
-version = "~1.8"
-features = ["unstable"]
-
-[profile.release]
-lto = true

Makefile

@@ -1,7 +1,27 @@
-run:
+CC ?= gcc
-	cargo build
+PREFIX ?= /usr/local
-	rm -rf purple/plugins
+
-	mkdir -p purple/plugins
+PKG_CONFIG ?= pkg-config
-	ln -s ../../target/debug/libpurple_delta.so purple/plugins/libpurple_delta.so
+LIB_TARGET = libdelta.so
-	ldd purple/plugins/libpurple_delta.so
+LIB_DEST = $(DESTDIR)`$(PKG_CONFIG) --variable=plugindir purple`
-	pidgin -d -c purple
+
+$(LIB_TARGET): *.c *.h Makefile
+	$(CC) -C \
+		-Wall -Wextra -Werror \
+		-std=c11 \
+		-shared \
+		-fpic \
+		$(shell $(PKG_CONFIG) --cflags purple deltachat) \
+		-o $(LIB_TARGET) \
+		*.c \
+		-shared \
+		$(shell $(PKG_CONFIG) --libs purple deltachat) \
+
+install:
+	install -D $(LIB_TARGET) $(LIB_DEST)
+
+uninstall:
+	rm -f $(LIB_DEST)/$(LIB_TARGET)
+
+clean:
+	rm $(LIB_TARGET)

README.md

@@ -13,27 +13,24 @@ Delta has:
 * An electron [desktop application](https://github.com/deltachat/deltachat-desktop)
 
 This project is a [libpurple](https://developer.pidgin.im/wiki/WhatIsLibpurple)
-plugin that wraps `deltachat-core-rust`, allowing a number of existing desktop and
+plugin that wraps `deltachat-core`, allowing a number of existing desktop and
 mobile clients to send and receive IMs over SMTP+IMAP. It may be useful for
 [Linux-based mobile devices](https://source.puri.sm/Librem5/chatty), for
-GUI desktop usage **without** an Electron dependency, or desktop usage.
+GUI desktop usage **without** an Electron dependency, or console desktop usage.
 
-## Current status
+Current status is probably best described as "skunkworks", although connecting
+to an account and sending / receiving text and image messages should work
+reliably in pidgin. Chatty supports text messages, and can be coaxed into using
+this plugin, but there's a long way to go with that yet.
 
-Starting again from scratch in Rust. So currently, nothing works. TODO list:
+A big refactoring to use "proper" purple IM structures is necessary to make
-
+further progress, I think.
-- [~] Connect to email account
-- [ ] Full settings support
-- [ ] Show buddy list
-- [ ] Send/receive text messages to single contact
-- [ ] Send/receive text messages to group chat
-- [ ] IMEX setup
-- [ ] Send/receive image messages
-- [ ] Send/receive audio messages
-- [ ] Send/receive video messages
-- [ ] Send/receive arbitrary attachments
 
+I also need to implement support for the buddy list.
 
+We currrently build against deltachat v1.50.0. You'll need to build and install
+deltachat-ffi separately and ensure that it's available via `pkg-config` for
+deltachat to install.
 
 ## Build
 
@@ -50,17 +47,17 @@ There's no point to `purple-plugin-delta` adding the OpenSSL exemption because
 `libpurple` lacks it, and in any event, it will be unnecessary with the next
 major version of OpenSSL. So, time should resolve this for us one way or another.
 
-Significant code using the WTFPL includes the [libpurple-rust bindings](https://github.com/sbwtw/libpurple-rust)
-and the [pidgin-wechat plugin](https://github.com/sbwtw/pidgin-wechat), which
-I'm taking a lot of inspiration from. WTF I like happens to include building it
-against this mess.
-
 ## Use
 
 The easiest way to use this is to copy the `libdelta.so` file into
 `~/.purple/plugins`. When running pidgin, you'll now have the option to add
 a "Delta Chat" account.
 
+If it doesn't show up, chances are pidgin can't find the various shared
+libraries the .so depends on. You can run `ldd ~/.purple/plugins/libdelta.so`
+to confirm. I'll document fixing this after the build and install system is
+settled.
+
 At present, the "Username" and "Password" account fields correspond to email
 address and password, respectively. Many important settings also show up on the
 "Advanced" tab - if left blank, the plugin will attempt to automatically detect

delta-connection.c

@@ -0,0 +1,562 @@
+#include <connection.h>
+#include <debug.h>
+#include <eventloop.h>
+#include <imgstore.h>
+#include <util.h>
+
+#include <inttypes.h>
+#include <pthread.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "delta-connection.h"
+#include "libdelta.h"
+
+#define IMEX_RECEIVED_MESSAGE "Setup message received. To apply it, reply with:\nIMEX: %d nnnn-nnnn-nnnn-nnnn-nnnn-nnnn-nnnn-nnnn-nnnn\nNo whitespace in the setup-code!"
+
+void delta_recv_im(DeltaConnectionData *conn, dc_msg_t *msg);
+
+void
+_transpose_config(dc_context_t *mailbox, PurpleAccount *acct)
+{
+	const char *addr = acct->username;
+	const char *display = purple_account_get_string(acct, PLUGIN_ACCOUNT_OPT_DISPLAY_NAME, NULL);
+
+	const char *imap_host = purple_account_get_string(acct, PLUGIN_ACCOUNT_OPT_IMAP_SERVER_HOST, NULL);
+	const char *imap_user = purple_account_get_string(acct, PLUGIN_ACCOUNT_OPT_IMAP_USER, NULL);
+	const char *imap_pass = purple_account_get_password(acct);
+	const char *imap_port = purple_account_get_string(acct, PLUGIN_ACCOUNT_OPT_IMAP_SERVER_PORT, NULL);
+
+	const char *smtp_host = purple_account_get_string(acct, PLUGIN_ACCOUNT_OPT_SMTP_SERVER_HOST, NULL);
+	const char *smtp_user = purple_account_get_string(acct, PLUGIN_ACCOUNT_OPT_SMTP_USER, NULL);
+	const char *smtp_pass = purple_account_get_string(acct, PLUGIN_ACCOUNT_OPT_SMTP_PASS, NULL);
+	const char *smtp_port = purple_account_get_string(acct, PLUGIN_ACCOUNT_OPT_SMTP_SERVER_PORT, NULL);
+
+	gboolean bcc_self = purple_account_get_bool(acct, PLUGIN_ACCOUNT_OPT_BCC_SELF, FALSE);
+
+	dc_set_config(mailbox, PLUGIN_ACCOUNT_OPT_ADDR, addr);
+	dc_set_config(mailbox, PLUGIN_ACCOUNT_OPT_DISPLAY_NAME, display);
+
+	dc_set_config(mailbox, PLUGIN_ACCOUNT_OPT_IMAP_SERVER_HOST, imap_host);
+	dc_set_config(mailbox, PLUGIN_ACCOUNT_OPT_IMAP_USER, imap_user);
+	dc_set_config(mailbox, PLUGIN_ACCOUNT_OPT_IMAP_PASS, imap_pass);
+	dc_set_config(mailbox, PLUGIN_ACCOUNT_OPT_IMAP_SERVER_PORT, imap_port);
+
+	dc_set_config(mailbox, PLUGIN_ACCOUNT_OPT_SMTP_SERVER_HOST, smtp_host);
+	dc_set_config(mailbox, PLUGIN_ACCOUNT_OPT_SMTP_USER, smtp_user);
+	dc_set_config(mailbox, PLUGIN_ACCOUNT_OPT_SMTP_PASS, smtp_pass);
+	dc_set_config(mailbox, PLUGIN_ACCOUNT_OPT_SMTP_SERVER_PORT, smtp_port);
+
+	if (bcc_self) {
+		dc_set_config(mailbox, PLUGIN_ACCOUNT_OPT_BCC_SELF, "1");
+	} else {
+		dc_set_config(mailbox, PLUGIN_ACCOUNT_OPT_BCC_SELF, "0");
+	};
+}
+
+typedef struct {
+	DeltaConnectionData *conn;
+
+	// Used by delta_process_incoming_message
+	uint32_t msg_id;
+	gboolean msg_changed;
+
+	// Used by delta_process_connection_state
+	// int connection_state;
+} ProcessRequest;
+
+gboolean
+delta_process_incoming_message(void *data)
+{
+	ProcessRequest *pr = (ProcessRequest *)data;
+	g_assert(pr != NULL);
+	g_assert(pr->conn != NULL);
+
+	dc_msg_t *msg = dc_get_msg(pr->conn->mailbox, pr->msg_id);
+	delta_recv_im(pr->conn, msg);
+	dc_msg_unref(msg);
+	g_free(data);
+
+	return FALSE;
+}
+/*
+gboolean
+delta_process_connection_state(void *data)
+{
+	ProcessRequest *pr = (ProcessRequest *)data;
+	g_assert(pr != NULL);
+	g_assert(pr->conn != NULL);
+
+	purple_connection_update_progress(
+		pr->conn->pc,
+		"Connecting...",
+		pr->connection_state,
+		MAX_DELTA_CONFIGURE
+	);
+
+	if (pr->connection_state == MAX_DELTA_CONFIGURE) {
+
+	}
+
+	g_free(data);
+
+	return FALSE;
+}
+*/
+gboolean
+delta_process_fresh_messages(void *data)
+{
+	ProcessRequest *pr = (ProcessRequest *)data;
+	g_assert(pr != NULL);
+	g_assert(pr->conn != NULL);
+
+	dc_context_t *mailbox = pr->conn->mailbox;
+	g_assert(mailbox != NULL);
+
+	// Spot any messages received while offline
+	dc_array_t *fresh_msgs = dc_get_fresh_msgs(mailbox);
+	size_t fresh_count = dc_array_get_cnt(fresh_msgs);
+
+	purple_debug_info(PLUGIN_ID, "fresh_count: %zu\n", fresh_count);
+
+	for(size_t i = 0; i < fresh_count; i++) {
+		uint32_t msg_id = dc_array_get_id(fresh_msgs, i);
+		dc_msg_t *msg = dc_get_msg(mailbox, msg_id);
+
+		delta_recv_im(pr->conn, msg);
+	}
+
+	dc_array_unref(fresh_msgs);
+
+	return FALSE;
+}
+
+ProcessRequest *
+delta_build_process_request(DeltaConnectionData *conn)
+{
+	g_assert(conn != NULL);
+
+	ProcessRequest *pr = g_malloc(sizeof(ProcessRequest));
+	g_assert(pr != NULL);
+
+	pr->conn = conn;
+
+	return pr;
+}
+
+// Do not call any libpurple or delta functions in here, as it is not
+// thread-safe and events may be dispatched from any delta thread. Use
+// purple_timeout_add(0, callback, data) to run on the main thread instead
+void *
+delta_event_handler(void *context)
+{
+	DeltaConnectionData *conn = (DeltaConnectionData *)context;
+
+	g_assert(conn != NULL);
+
+	dc_context_t *mailbox = conn->mailbox;
+	dc_event_emitter_t* emitter = dc_get_event_emitter(mailbox);
+	dc_event_t* event;
+
+	// FIXME: do we still need runthreads?
+	while (conn->runthreads && (event = dc_get_next_event(emitter)) != NULL) {
+		ProcessRequest *pr = NULL;
+		int event_id = dc_event_get_id(event);
+
+		purple_debug_info(PLUGIN_ID, "Event %d received from Delta.\n", event_id);
+
+		switch (event_id) {
+		case DC_EVENT_SMTP_MESSAGE_SENT:
+		case DC_EVENT_IMAP_CONNECTED:
+		case DC_EVENT_SMTP_CONNECTED:
+		case DC_EVENT_IMAP_MESSAGE_DELETED:
+		case DC_EVENT_IMAP_MESSAGE_MOVED:
+		case DC_EVENT_INFO: {
+			char *info = dc_event_get_data2_str(event);
+			purple_debug_info(PLUGIN_ID, "INFO from Delta: %s\n", info);
+			dc_str_unref(info);
+			break;
+		}
+		case DC_EVENT_WARNING: {
+			char *warn = dc_event_get_data2_str(event);
+			purple_debug_info(PLUGIN_ID, "WARNING from Delta: %s\n", warn);
+			dc_str_unref(warn);
+			break;
+		}
+		case DC_EVENT_ERROR: {
+			int errcode = dc_event_get_data1_int(event);
+			char *err = dc_event_get_data2_str(event);
+			purple_debug_info(PLUGIN_ID, "ERROR from Delta: %d: %s\n", errcode, err);
+			dc_str_unref(err);
+			break;
+		}
+
+		case DC_EVENT_MSGS_CHANGED: {
+			// This event may be issued for a single message, in which case the
+			// message ID is in data2 and we should treat it as an incoming msg
+			// FIXME: this leads to duplicate messages when it's an outgoing
+			// message we just sent
+			uint32_t msg_id = dc_event_get_data2_int(event);
+
+			pr = delta_build_process_request(conn);
+			if (msg_id) {
+				// FIXME: for now, only display IMEX setup messages to avoid duplicates
+				pr->msg_id = msg_id;
+				pr->msg_changed = TRUE;
+
+				purple_timeout_add(0, delta_process_incoming_message, pr);
+			} else {
+				purple_timeout_add(0, delta_process_fresh_messages, pr);
+			}
+			break;
+		}
+
+		case DC_EVENT_INCOMING_MSG:
+			// data1 is chat_id, which we don't seem to need yet.
+			// TODO: It may be needed for group chats
+			pr = delta_build_process_request(conn);
+			pr->msg_id = (uint32_t)dc_event_get_data2_int(event);
+			purple_timeout_add(0, delta_process_incoming_message, pr);
+			break;
+
+		// Things left to do
+		case DC_EVENT_CHAT_EPHEMERAL_TIMER_MODIFIED:
+		case DC_EVENT_NEW_BLOB_FILE:
+		case DC_EVENT_DELETED_BLOB_FILE:
+		case DC_EVENT_MSG_DELIVERED:
+		case DC_EVENT_MSG_READ:
+		case DC_EVENT_MSG_FAILED:
+		case DC_EVENT_CHAT_MODIFIED:
+		case DC_EVENT_CONTACTS_CHANGED:
+		case DC_EVENT_ERROR_SELF_NOT_IN_GROUP:
+		case DC_EVENT_IMEX_FILE_WRITTEN:
+		case DC_EVENT_IMEX_PROGRESS:
+		case DC_EVENT_LOCATION_CHANGED:
+		case DC_EVENT_MSGS_NOTICED:
+		case DC_EVENT_SECUREJOIN_INVITER_PROGRESS:
+		case DC_EVENT_SECUREJOIN_JOINER_PROGRESS:
+			purple_debug_info(PLUGIN_ID, "Event %d is TODO\n", event_id);
+			break;
+
+		case DC_EVENT_CONFIGURE_PROGRESS:
+			//pr = delta_build_process_request(conn);
+			//pr->connection_state = dc_event_get_data1_int(event);
+			//purple_timeout_add(0, delta_process_connection_state, pr);
+			purple_debug_info(PLUGIN_ID, "Configure progress: %d\n", dc_event_get_data1_int(event));
+			break;
+
+		default:
+			purple_debug_info(PLUGIN_ID, "Unknown Delta event: %d\n", event_id);
+		}
+
+		dc_event_unref(event);
+	}
+	dc_event_emitter_unref(emitter);
+
+	return NULL;
+}
+
+void
+delta_connection_new(PurpleConnection *pc)
+{
+	DeltaConnectionData *conn = NULL;
+
+	g_assert(purple_connection_get_protocol_data(pc) == NULL);
+
+	conn = g_new0(DeltaConnectionData, 1);
+	conn->pc = pc;
+	purple_connection_set_protocol_data(pc, conn);
+}
+
+void
+delta_connection_free(PurpleConnection *pc)
+{
+	DeltaConnectionData *conn = purple_connection_get_protocol_data(pc);
+
+	g_assert(conn != NULL);
+
+	conn->runthreads = 0;
+	
+	if (conn->mailbox != NULL) {
+		dc_stop_ongoing_process(conn->mailbox);
+		dc_stop_io(conn->mailbox);
+
+		// TODO: correctly handle join failing
+		purple_debug_info(PLUGIN_ID, "Joining event thread\n");
+		if (pthread_join(conn->event_thread, NULL) != 0) {
+			purple_debug_info(PLUGIN_ID, "joining event thread failed\n");
+		}
+
+		dc_context_unref(conn->mailbox);
+	}
+
+	purple_connection_set_protocol_data(pc, NULL);
+
+	// TODO: free resources as they are added to DeltaConnectionData
+	conn->pc = NULL;
+	conn->mailbox = NULL;
+
+	g_free(conn);
+}
+
+void
+delta_connection_start_login(PurpleConnection *pc)
+{
+	char dbname[1024];
+	PurpleAccount *acct = pc->account;
+	DeltaConnectionData *conn = purple_connection_get_protocol_data(pc);
+	dc_context_t *mailbox = NULL; 
+
+	g_snprintf(
+		dbname, 1024, "%s%sdelta_db-%s",
+		purple_user_dir(), G_DIR_SEPARATOR_S, acct->username
+	);
+
+	mailbox = dc_context_new(PLUGIN_ID, dbname, NULL);
+
+	conn->mailbox = mailbox;
+	_transpose_config(mailbox, acct);
+
+	conn->runthreads = 1;
+	pthread_create(&conn->event_thread, NULL, delta_event_handler, conn);
+
+	dc_configure(mailbox);
+	dc_start_io(mailbox);
+	dc_maybe_network(mailbox);
+
+	purple_connection_set_state(pc, PURPLE_CONNECTED);
+
+	return;
+}
+
+gboolean delta_try_process_imex(dc_context_t *mailbox, char *text) {
+	if (!g_str_has_prefix(text, "IMEX: ")) {
+		return FALSE;
+	}
+
+	gchar **parts = g_strsplit(text, " ", 3);
+	if (g_strv_length(parts) != 3) {
+		g_strfreev(parts);
+		return FALSE;
+	}
+
+	int msg_id = atoi(parts[1]);
+	gboolean success = dc_continue_key_transfer(mailbox, msg_id, parts[2]);
+
+	g_strfreev(parts);
+
+	return success;
+}
+
+int
+delta_send_im(PurpleConnection *pc, const char *who, const char *message, PurpleMessageFlags flags)
+{
+	UNUSED(flags);
+
+	DeltaConnectionData *conn = (DeltaConnectionData *)purple_connection_get_protocol_data(pc);
+	g_assert(conn != NULL);
+
+	dc_context_t *mailbox = conn->mailbox;
+	g_assert(mailbox != NULL);
+
+	uint32_t contact_id = dc_create_contact(mailbox, NULL, who);
+	uint32_t chat_id = dc_create_chat_by_contact_id(mailbox, contact_id);
+
+	GData *attrs;
+	const char *msg_ptr, *start, *end;
+	msg_ptr = message;
+
+	// Send each image included in the message.
+	while (purple_markup_find_tag("img", msg_ptr, &start, &end, &attrs) == TRUE) {
+		char *id_str = g_datalist_id_get_data(&attrs, g_quark_from_string("id"));
+		purple_debug_info(PLUGIN_ID, "In a loop, got %s\n", id_str);
+
+		msg_ptr = end + 1;
+
+		if (id_str == NULL || strlen(id_str) == 0) {
+			g_datalist_clear(&attrs);
+			continue;
+		}
+
+		int id = atoi(id_str);
+		g_datalist_clear(&attrs);
+
+		if (id <= 0) {
+			continue;
+		}
+
+		GError *err = NULL;
+		char *tempdir = g_dir_make_tmp(NULL, &err);
+		if (err != NULL) {
+			purple_debug_info(PLUGIN_ID, "Couldn't get a temporary dir for image %d: %s", id, err->message);
+			g_free(err);
+			continue;
+		}
+
+		PurpleStoredImage *img = purple_imgstore_find_by_id(id);
+		const char *filename = purple_imgstore_get_filename(img);
+		const char *extension = purple_imgstore_get_extension(img);
+		gconstpointer data = purple_imgstore_get_data(img);
+
+		char *path = g_strdup_printf("%s/%s", tempdir, filename);
+
+		g_file_set_contents(path, data, purple_imgstore_get_size(img), &err);
+		if (err != NULL) {
+			purple_debug_info(PLUGIN_ID, "failed to write %s to temporary file: %s\n", filename, err->message);
+			g_free(err);
+			goto next;
+		}
+
+		purple_debug_info(PLUGIN_ID, "Sending image %s from imgstore: %d\n", filename, id);
+
+		dc_msg_t *img_msg = dc_msg_new(mailbox, DC_MSG_IMAGE);
+		dc_msg_set_file(img_msg, path, extension);
+		dc_send_msg(mailbox, chat_id, img_msg);
+		dc_msg_unref(img_msg);
+
+next:
+		remove(path);
+		remove(tempdir);
+		g_free(path);
+	}
+
+	// Send any text left
+	char *stripped_message = purple_markup_strip_html(message);
+	g_assert(stripped_message != NULL);
+	if (strlen(stripped_message) > 0) {
+		if (!delta_try_process_imex(mailbox, stripped_message)) {
+			dc_send_text_msg(mailbox, chat_id, stripped_message);
+		}
+	}
+	g_free(stripped_message);
+
+	return 0; // success; don't echo the message to the chat window since we display it anyway
+}
+
+void
+delta_recv_im(DeltaConnectionData *conn, dc_msg_t *msg)
+{
+	dc_context_t *mailbox = conn->mailbox;
+	g_assert(mailbox != NULL);
+
+	PurpleConnection *pc = conn->pc;
+	g_assert(pc != NULL);
+
+	uint32_t msg_id = dc_msg_get_id(msg);
+	int viewtype = dc_msg_get_viewtype(msg);
+	time_t timestamp = dc_msg_get_timestamp(msg);
+	char *text = dc_msg_get_text(msg);
+	uint32_t chat_id = dc_msg_get_chat_id(msg);
+	dc_contact_t *from = dc_get_contact(mailbox, dc_msg_get_from_id(msg));
+	dc_chat_t *chat = dc_get_chat(mailbox, chat_id);
+	dc_array_t *contacts = dc_get_chat_contacts(mailbox, chat_id);
+	int num_contacts = dc_array_get_cnt(contacts);
+
+	if (chat == NULL) {
+		purple_debug_info(PLUGIN_ID, "Receiving IM: unknown chat: %d\n", chat_id);
+		goto out;
+	}
+
+	if (dc_chat_get_type(chat) == DC_CHAT_TYPE_GROUP) {
+		purple_debug_info(PLUGIN_ID, "Receiving IM: group chat with ID %d! Not yet supported\n", chat_id);
+		goto out;
+	}
+
+	if (num_contacts != 1) {
+		purple_debug_info(PLUGIN_ID, "Receiving IM: 1-1 chat %d with %d contacts instead of 1!\n", chat_id, num_contacts);
+		goto out;
+	}
+
+	// FIXME: using dc_array_get_contact_id fails here, complaining that it's not an array of locations
+	dc_contact_t *contact = dc_get_contact(mailbox, dc_array_get_id(contacts, 0));
+	char *who = NULL;
+
+	// In the current architecture, delta_send_im and delta_recv_im must agree
+	// on the value for 'who'. Using the email address is an easy cheat for this
+	// but gets shaky in the long term.
+	if (contact != NULL) {
+		who = dc_contact_get_addr(contact);
+	} else {
+		who = dc_chat_get_name(chat);
+	}
+
+	int flags = 0;
+	int state = dc_msg_get_state(msg);
+
+	if (state == DC_STATE_IN_FRESH || state == DC_STATE_IN_NOTICED || state == DC_STATE_IN_SEEN) {
+		flags |= PURPLE_MESSAGE_RECV;
+	} else {
+		flags |= PURPLE_MESSAGE_SEND;
+	}
+
+	// FIXME: as a massive hack, convert IMEX setup messages into a text message
+	// prompting the user how to trigger the IMEX filter in outgoing messages.
+	if (dc_msg_is_setupmessage(msg)) {
+		purple_debug_info(PLUGIN_ID, "Receiving IMEX: ID=%d\n", msg_id);
+		viewtype = DC_MSG_TEXT;
+		dc_str_unref(text);
+		text = g_strndup("", 1024);
+		g_assert(text != NULL);
+
+		g_snprintf(text, 1024, IMEX_RECEIVED_MESSAGE, msg_id);
+	}
+
+	switch(viewtype) {
+	case DC_MSG_GIF:
+	case DC_MSG_IMAGE:
+	case DC_MSG_STICKER:
+		flags = flags | PURPLE_MESSAGE_IMAGES;
+		break;
+	case DC_MSG_TEXT:
+		flags = flags | PURPLE_MESSAGE_RAW;
+		break;
+	case DC_MSG_VIDEO: // Pidgin only supports these as files for download
+	case DC_MSG_FILE:
+	case DC_MSG_AUDIO: // Sound to play
+	case DC_MSG_VOICE:
+		break;
+	default:
+		purple_debug_info(PLUGIN_ID, "Message %d: unknown message type: %d\n", msg_id, viewtype);
+	}
+
+	int image_id = 0;
+
+	if ((flags & PURPLE_MESSAGE_IMAGES) > 0) {
+		char *filename = dc_msg_get_file(msg);
+		gchar *data;
+		gsize length;
+		GError *err = NULL;
+
+		g_file_get_contents(filename, &data, &length, &err);
+		if (err != NULL) {
+			purple_debug_info(PLUGIN_ID, "Failed to read image %s: %s\n", filename, err->message);
+			g_error_free(err);
+			goto out;
+		}
+
+		image_id = purple_imgstore_add_with_id(data, length, filename);
+		text = g_strdup_printf("<img id='%d'><br/>%s", image_id, text);
+	}
+
+	char *name = dc_contact_get_display_name(from);
+	int msglen = strlen(name) + 3 + strlen(text);
+
+	char *msgtext = malloc(msglen);
+	g_snprintf(msgtext, msglen, "%s: %s", name, text);
+
+	serv_got_im(pc, who, msgtext, flags, timestamp);
+
+	if (image_id > 0) {
+		purple_imgstore_unref_by_id(image_id);
+	}
+
+	dc_markseen_msgs(mailbox, &msg_id, 1);
+	g_free(msgtext);
+	dc_str_unref(who);
+	dc_str_unref(name);
+	dc_contact_unref(contact);
+out:
+	dc_str_unref(text);
+	dc_chat_unref(chat);
+	dc_array_unref(contacts);
+}

delta-connection.h

@@ -0,0 +1,30 @@
+#ifndef DELTA_CONNECTION_H
+#define DELTA_CONNECTION_H
+
+#include <glib.h>
+#include <deltachat.h>
+#include <pthread.h>
+
+struct _PurpleConnection;
+
+typedef struct _DeltaConnectionData {
+	struct _PurpleConnection *pc;
+	dc_context_t *mailbox;
+
+	// Set to 0 to convince threads to exit
+	int runthreads;
+
+	pthread_t event_thread;
+} DeltaConnectionData;
+
+#define MAX_DELTA_CONFIGURE 1000
+
+void delta_connection_new(struct _PurpleConnection *pc);
+void delta_connection_free(struct _PurpleConnection *pc);
+
+void delta_connection_start_login(PurpleConnection *pc);
+
+int delta_send_im(PurpleConnection *pc, const char *who, const char *message, PurpleMessageFlags flags);
+
+#endif
+

libdelta.c

@@ -0,0 +1,250 @@
+#define PURPLE_PLUGINS
+
+#include "libdelta.h"
+
+#include <glib.h>
+
+// All from libpurple
+#include <accountopt.h>
+#include <connection.h>
+#include <notify.h>
+#include <plugin.h>
+#include <prpl.h>
+#include <version.h>
+
+#include "delta-connection.h"
+#include "util.h"
+
+static GList *
+delta_status_types(PurpleAccount *acct)
+{
+	UNUSED(acct);
+
+	GList *types = NULL;
+
+	types = g_list_append(types, purple_status_type_new(PURPLE_STATUS_OFFLINE, "Offline", NULL, TRUE));
+	types = g_list_append(types, purple_status_type_new(PURPLE_STATUS_AVAILABLE, "Online", NULL, TRUE));
+
+	return types;
+}
+
+static void
+delta_login(PurpleAccount *acct)
+{
+	PurpleConnection *pc = purple_account_get_connection(acct);
+
+
+	delta_connection_new(pc);
+	delta_connection_start_login(pc);
+
+	pc->flags |= PURPLE_CONNECTION_NO_BGCOLOR;
+}
+
+static void
+delta_close(PurpleConnection *pc)
+{
+	// TODO: actually disconnect!
+	purple_connection_set_state(pc, PURPLE_DISCONNECTED);
+	delta_connection_free(pc);
+}
+
+static const char *
+delta_list_icon(PurpleAccount *acct, PurpleBuddy *buddy)
+{
+	UNUSED(acct);
+	UNUSED(buddy);
+
+	return "delta";
+}
+
+static PurpleAccountOption *
+str_opt(const char *text, const char *name, const char *def)
+{
+	return purple_account_option_string_new(text, name, def);
+}
+
+static PurpleAccountOption *
+pwd_opt(const char *text, const char *name, const char *def)
+{
+	PurpleAccountOption* option = str_opt(text, name, def);
+	purple_account_option_set_masked(option, TRUE);
+
+	return option;
+}
+
+static PurpleAccountOption *
+bool_opt(const char *text, const char *name, const gboolean def)
+{
+	return purple_account_option_bool_new(text, name, def);
+}
+
+static void
+delta_init_plugin(PurplePlugin *plugin)
+{
+	PurplePluginProtocolInfo *extra = (PurplePluginProtocolInfo *)plugin->info->extra_info;
+	GList *opts = NULL;
+
+	opts = g_list_prepend(opts, str_opt("Display Name", PLUGIN_ACCOUNT_OPT_DISPLAY_NAME, NULL));
+
+	opts = g_list_prepend(opts, str_opt("IMAP Server Host", PLUGIN_ACCOUNT_OPT_IMAP_SERVER_HOST, NULL));
+	opts = g_list_prepend(opts, str_opt("IMAP Server Port", PLUGIN_ACCOUNT_OPT_IMAP_SERVER_PORT, NULL));
+	opts = g_list_prepend(opts, str_opt("IMAP Username", PLUGIN_ACCOUNT_OPT_IMAP_USER, NULL));
+
+
+	// These are pidgin's built-in username & password options
+	// FIXME: it's not super-obvious or pleasant :/
+	// opts = g_list_prepend(opts, str_opt("Email Address", PLUGIN_ACCOUNT_OPT_EMAIL_ADDRESS, ""));
+	// opts = g_list_prepend(opts, pwd_opt("IMAP Password", PLUGIN_ACCOUNT_OPT_IMAP_PASS, ""));
+
+	opts = g_list_prepend(opts, str_opt("SMTP Server Host", PLUGIN_ACCOUNT_OPT_SMTP_SERVER_HOST, NULL));
+	opts = g_list_prepend(opts, str_opt("SMTP Server Port", PLUGIN_ACCOUNT_OPT_SMTP_SERVER_PORT, NULL));
+	opts = g_list_prepend(opts, str_opt("SMTP Username", PLUGIN_ACCOUNT_OPT_SMTP_USER, NULL));
+	opts = g_list_prepend(opts, pwd_opt("SMTP Password", PLUGIN_ACCOUNT_OPT_SMTP_PASS, NULL));
+
+	// Not exposed: server_flags, selfstatus, e2ee_enabled
+	// https://deltachat.github.io/api/classmrmailbox__t.html
+
+	opts = g_list_prepend(opts, bool_opt("Send copy to self", PLUGIN_ACCOUNT_OPT_BCC_SELF, FALSE));
+
+	extra->protocol_options = g_list_reverse(opts);
+}
+
+static void
+delta_destroy_plugin(PurplePlugin *plugin) {
+	UNUSED(plugin);
+}
+
+static gboolean
+delta_offline_message(const PurpleBuddy *buddy)
+{
+	UNUSED(buddy);
+
+	return TRUE;
+}
+
+static PurplePluginProtocolInfo extra_info =
+{
+	DELTA_PROTOCOL_OPTS,    /* options */
+    NULL,               /* user_splits */
+    NULL,               /* protocol_options, initialized in delta_init_plugin() */
+    {   /* icon_spec, a PurpleBuddyIconSpec */
+        "svg,png,jpg,gif",               /* format */
+        0,                               /* min_width */
+        0,                               /* min_height */
+        128,                             /* max_width */
+        128,                             /* max_height */
+        10000,                           /* max_filesize */
+        PURPLE_ICON_SCALE_DISPLAY,       /* scale_rules */
+    },
+    delta_list_icon,                       /* list_icon */
+    NULL,                                  /* list_emblem */
+    NULL,                                  /* status_text */
+    NULL,                                  /* tooltip_text */
+    delta_status_types,                    /* status_types */
+    NULL,                                  /* blist_node_menu */
+    NULL,                       /* chat_info */
+    NULL,              /* chat_info_defaults */
+    delta_login,                           /* login */
+    delta_close,                           /* close */
+    delta_send_im,                         /* send_im */
+    NULL,                                  /* set_info */
+    NULL,                                  /* send_typing */
+    NULL,                                  /* get_info */
+    NULL,                                  /* set_status */
+    NULL,                                  /* set_idle */
+    NULL,                                  /* change_passwd */
+    NULL,                                  /* add_buddy */
+    NULL,                                  /* add_buddies */
+    NULL,                                  /* remove_buddy */
+    NULL,                                  /* remove_buddies */
+    NULL,                                  /* add_permit */
+    NULL,                                  /* add_deny */
+    NULL,                                  /* rem_permit */
+    NULL,                                  /* rem_deny */
+    NULL,                                  /* set_permit_deny */
+    NULL,                  /* join_chat */
+    NULL,                /* reject_chat */
+    NULL,              /* get_chat_name */
+    NULL,                /* chat_invite */
+    NULL,                 /* chat_leave */
+    NULL,                                  /* chat_whisper */
+    NULL,                  /* chat_send */
+    NULL,                                  /* keepalive */
+    NULL,                                  /* register_user */
+    NULL,                                  /* get_cb_info */
+    NULL,                                  /* get_cb_away */
+    NULL,                                  /* alias_buddy */
+    NULL,                                  /* group_buddy */
+    NULL,                                  /* rename_group */
+    NULL,                                  /* buddy_free */
+    NULL,                                  /* convo_closed */
+    NULL,                                  /* normalize */
+    NULL,                                  /* set_buddy_icon */
+    NULL,                                  /* remove_group */
+    NULL,           /* get_cb_real_name */
+    NULL,                                  /* set_chat_topic */
+    NULL,                                  /* find_blist_chat */
+    NULL,                                  /* roomlist_get_list */
+    NULL,                                  /* roomlist_cancel */
+    NULL,                                  /* roomlist_expand_category */
+    NULL,                                  /* can_receive_file */
+    NULL,                                  /* send_file */
+    NULL,                                  /* new_xfer */
+    delta_offline_message,                 /* offline_message */
+    NULL,                                  /* whiteboard_prpl_ops */
+    NULL,                                  /* send_raw */
+    NULL,                                  /* roomlist_room_serialize */
+    NULL,                                  /* unregister_user */
+    NULL,                                  /* send_attention */
+    NULL,                                  /* get_attention_types */
+    sizeof(PurplePluginProtocolInfo),      /* struct_size */
+    NULL,                                  /* get_account_text_table */
+    NULL,                                  /* initiate_media */
+    NULL,                                  /* get_media_caps */
+    NULL,                                  /* get_moods */
+    NULL,                                  /* set_public_alias */
+    NULL,                                  /* get_public_alias */
+    NULL,                                  /* add_buddy_with_invite */
+    NULL,                                  /* add_buddies_with_invite */
+    // 2.14
+    NULL, /* get_cb_alias */
+    NULL, /* chat_can_send_file */
+    NULL /* some send file */
+};
+
+
+static PurplePluginInfo info = {
+	PURPLE_PLUGIN_MAGIC,
+	PURPLE_MAJOR_VERSION,
+	PURPLE_MINOR_VERSION,
+	PURPLE_PLUGIN_PROTOCOL,
+	NULL, // UI requirements
+	0, // flags
+	NULL, // dependencies
+	PURPLE_PRIORITY_DEFAULT,
+
+	PLUGIN_ID,
+	"Delta Chat",
+	"0.0.0",
+
+	"Delta Chat is an email-based instant messaging solution",
+	"See https://delta.chat for more information",
+	"Nick Thomas <delta@ur.gs>",
+	"https://delta.chat",
+
+	NULL, // plugin_load
+	NULL, // plugin_unload
+	delta_destroy_plugin, // plugin_destroy
+
+	NULL, // ui_info
+	&extra_info, // extra_info
+	NULL, // prefs_info
+	NULL, // actions
+
+	NULL, // reserved1
+	NULL, // reserved2
+	NULL, // reserved3
+	NULL  // reserved4
+};
+
+PURPLE_INIT_PLUGIN(delta, delta_init_plugin, info)

libdelta.h

@@ -0,0 +1,35 @@
+#ifndef LIBDELTA_H
+#define LIBDELTA_H
+
+#define PLUGIN_ID "prpl-delta"
+
+#define PLUGIN_CHAT_INFO_CHAT_ID "chat_id"
+
+#define DELTA_PROTOCOL_OPTS \
+	OPT_PROTO_UNIQUE_CHATNAME | \
+	OPT_PROTO_CHAT_TOPIC | \
+	OPT_PROTO_IM_IMAGE | \
+	OPT_PROTO_MAIL_CHECK
+
+// These two will instead be the pidgin "username" and "password" options that
+// I can't seem to get rid of.
+#define PLUGIN_ACCOUNT_OPT_ADDR             "addr"
+#define PLUGIN_ACCOUNT_OPT_IMAP_PASS        "mail_pw"
+
+// Share the remaining keys between purple and delta
+#define PLUGIN_ACCOUNT_OPT_DISPLAY_NAME     "displayname"
+
+#define PLUGIN_ACCOUNT_OPT_IMAP_SERVER_HOST "mail_server"
+#define PLUGIN_ACCOUNT_OPT_IMAP_SERVER_PORT "mail_port"
+#define PLUGIN_ACCOUNT_OPT_IMAP_USER        "mail_user"
+
+#define PLUGIN_ACCOUNT_OPT_SMTP_SERVER_HOST "send_server"
+#define PLUGIN_ACCOUNT_OPT_SMTP_SERVER_PORT "send_port"
+#define PLUGIN_ACCOUNT_OPT_SMTP_USER        "send_user"
+#define PLUGIN_ACCOUNT_OPT_SMTP_PASS        "send_pw"
+
+#define PLUGIN_ACCOUNT_OPT_BCC_SELF         "bcc_self"
+
+#define UNUSED(x) (void)(x)
+
+#endif

rust-toolchain

@@ -1 +0,0 @@
-1.50.0

src/chat_info.rs

@@ -1,136 +0,0 @@
-// This is a copy of https://github.com/Flared/purple-icq/blob/master/src/chat_info.rs
-
-use super::purple;
-use lazy_static::lazy_static;
-use std::ffi::CString;
-
-lazy_static! {
-    pub static ref SN: CString = CString::new("sn").unwrap();
-    pub static ref SN_NAME: CString = CString::new("Chat ID").unwrap();
-    pub static ref STAMP: CString = CString::new("stamp").unwrap();
-    pub static ref TITLE: CString = CString::new("title").unwrap();
-    pub static ref GROUP: CString = CString::new("group").unwrap();
-    pub static ref STATE: CString = CString::new("state").unwrap();
-}
-
-#[derive(Debug, Clone)]
-pub struct MemberRole(String);
-
-#[derive(Debug, Clone, Default)]
-pub struct PartialChatInfo {
-    pub sn: String,
-    pub title: String,
-    pub group: Option<String>,
-}
-
-#[derive(Debug, Clone, Default)]
-pub struct ChatInfo {
-    pub stamp: Option<String>,
-    pub group: Option<String>,
-    pub sn: String,
-    pub title: String,
-    pub about: Option<String>,
-    pub members_version: String,
-    pub info_version: String,
-    pub members: Vec<ChatMember>,
-}
-
-#[derive(Debug, Clone)]
-pub struct ChatMember {
-    pub sn: String,
-    pub friendly_name: Option<String>,
-    pub role: MemberRole,
-    pub last_seen: Option<u64>,
-    pub first_name: Option<String>,
-    pub last_name: Option<String>,
-}
-
-#[derive(Debug, Clone)]
-pub struct ChatInfoVersion {
-    pub members_version: String,
-    pub info_version: String,
-}
-
-impl MemberRole {
-    pub fn as_flags(&self) -> purple::PurpleConvChatBuddyFlags {
-        match self.0.as_str() {
-            "admin" => purple::PurpleConvChatBuddyFlags::PURPLE_CBFLAGS_OP,
-            "readonly" => purple::PurpleConvChatBuddyFlags::PURPLE_CBFLAGS_NONE,
-            _ => purple::PurpleConvChatBuddyFlags::PURPLE_CBFLAGS_VOICE,
-        }
-    }
-}
-
-impl PartialChatInfo {
-    pub fn from_hashtable(table: &purple::StrHashTable) -> Option<Self> {
-        Some(Self {
-            group: table.lookup(&GROUP).map(Into::into),
-            sn: table.lookup(&SN)?.into(),
-            title: table.lookup(&TITLE)?.into(),
-        })
-    }
-
-    pub fn as_hashtable(&self) -> purple::StrHashTable {
-        let mut table = purple::StrHashTable::default();
-        table.insert(&SN, &self.sn);
-        if let Some(group) = &self.group {
-            table.insert(&GROUP, &group);
-        }
-        table.insert(&TITLE, &self.title);
-        table
-    }
-}
-
-impl ChatInfo {
-    pub fn as_partial(&self) -> PartialChatInfo {
-        PartialChatInfo {
-            sn: self.sn.clone(),
-            title: self.title.clone(),
-            group: self.group.clone(),
-        }
-    }
-
-    pub fn need_update(&self, new_version: &ChatInfoVersion) -> bool {
-        self.members_version < new_version.members_version
-            || self.info_version < new_version.info_version
-    }
-}
-/*
-impl From<icq::client::GetChatInfoResponseData> for ChatInfo {
-    fn from(info: icq::client::GetChatInfoResponseData) -> Self {
-        Self {
-            sn: info.sn,
-            stamp: Some(info.stamp),
-            title: info.name,
-            members_version: info.members_version,
-            info_version: info.info_version,
-            about: info.about,
-            members: info
-                .members
-                .into_iter()
-                .map(|m| ChatMember {
-                    sn: m.sn,
-                    role: MemberRole(m.role),
-                    last_seen: m.user_state.last_seen.and_then(|t| match t {
-                        0 => None,
-                        t => Some(t),
-                    }),
-                    friendly_name: m.friendly,
-                    first_name: m.anketa.first_name,
-                    last_name: m.anketa.last_name,
-                })
-                .collect(),
-            ..Default::default()
-        }
-    }
-}
-
-impl From<icq::client::events::HistDlgStateMChatState> for ChatInfoVersion {
-    fn from(info: icq::client::events::HistDlgStateMChatState) -> Self {
-        Self {
-            members_version: info.members_version,
-            info_version: info.info_version,
-        }
-    }
-}
-*/

src/delta/mod.rs

@@ -1 +0,0 @@
-

src/lib.rs

@@ -1,828 +0,0 @@
-extern crate async_std;
-extern crate glib;
-extern crate lazy_static;
-extern crate libc;
-extern crate log;
-extern crate paste;
-pub extern crate purple_sys;
-extern crate serde;
-
-use async_std::sync::Arc; // RwLock
-use chat_info::{ChatInfo, PartialChatInfo}; //ChatInfoVersion
-use lazy_static::lazy_static;
-//use messages::{AccountInfo, ICQSystemHandle, PurpleMessage, SystemMessage};
-use purple::*;
-//use std::cell::RefCell;
-use std::ffi::{CStr, CString};
-//use std::io::Read;
-//use std::rc::Rc;
-use std::sync::atomic::{AtomicBool, Ordering};
-
-mod delta;
-#[macro_use]
-mod purple;
-mod chat_info;
-pub mod logging;
-//mod messages;
-
-pub mod status {
-    use lazy_static::lazy_static;
-    use std::ffi::CString;
-    lazy_static! {
-        pub static ref ONLINE_ID: CString = CString::new("online").unwrap();
-        pub static ref ONLINE_NAME: CString = CString::new("Online").unwrap();
-        pub static ref OFFLINE_ID: CString = CString::new("offline").unwrap();
-        pub static ref OFFLINE_NAME: CString = CString::new("Offline").unwrap();
-    }
-}
-
-lazy_static! {
-    static ref ICON_FILE: CString = CString::new("delta").unwrap();
-}
-
-mod blist_node {
-    pub const LAST_SEEN_TIMESTAMP: &str = "last_seen_timestamp";
-}
-
-mod commands {
-    pub const IMEX: &str = "imex";
-}
-
-pub mod chat_states {
-    pub const JOINED: &str = "joined";
-}
-
-pub mod conv_data {
-    use super::HistoryInfo;
-    use std::cell::RefCell;
-    use std::rc::Rc;
-
-    pub const CHAT_INFO: &str = "chat_info";
-    pub const HISTORY_INFO: &str = "history_info";
-    pub type HistoryInfoType = Rc<RefCell<HistoryInfo>>;
-}
-
-#[derive(Debug, Clone, Default)]
-pub struct HistoryInfo {
-    pub oldest_message_id: Option<String>,
-    pub oldest_message_timestamp: Option<i64>,
-}
-
-#[derive(Debug, Clone)]
-pub struct MsgInfo {
-    pub chat_sn: String,
-    pub author_sn: String,
-    pub author_friendly: String,
-    pub text: String,
-    pub time: i64,
-    pub message_id: String,
-}
-
-#[derive(Debug, Default)]
-pub struct AccountData {
-    display_name: String,
-    imap_host: String,
-    imap_port: i32,
-    imap_user: String,
-    imap_pass: String,
-    smtp_host: String,
-    smtp_port: i32,
-    smtp_user: String,
-    smtp_pass: String,
-    bcc_self: bool,
-
-    // Not exposed: server_flags, selfstatus, e2ee_enabled
-
-    session_closed: AtomicBool,
-    //    session: RwLock<Option<icq::protocol::SessionInfo>>,
-}
-
-impl Drop for AccountData {
-    fn drop(&mut self) {
-        log::info!("AccountData dropped");
-    }
-}
-
-pub type AccountDataBox = Arc<AccountData>;
-pub type Handle = purple::Handle<AccountDataBox>;
-pub type ProtocolData = purple::ProtocolData<AccountDataBox>;
-
-pub struct PurpleDelta {
-    //    system: ICQSystemHandle,
-    connections: purple::Connections<AccountDataBox>,
-    input_handle: Option<u32>,
-    imex_command_handle: Option<PurpleCmdId>,
-}
-
-impl purple::PrplPlugin for PurpleDelta {
-    type Plugin = Self;
-
-    fn new() -> Self {
-        logging::init(log::LevelFilter::Debug).expect("Failed to initialize logging");
-        //        let system = icq::system::spawn();
-        Self {
-            //            system,
-            input_handle: None,
-            imex_command_handle: None,
-            connections: purple::Connections::new(),
-        }
-    }
-    fn register(&self, context: RegisterContext<Self>) -> RegisterContext<Self> {
-        let info = purple::PrplInfo {
-            id: "prpl-delta".into(),
-            name: "Delta Chat".into(),
-            version: "0.1.0".into(),
-            summary: "Delta Chat is an email-based instant messaging solution".into(),
-            description: "See https://delta.chat for more information".into(),
-            author: "Nick Thomas <delta@ur.gs>".into(),
-            homepage: "https://code.ur.gs/lupine/purple-plugin-delta".into(),
-        };
-
-        context
-            .with_info(info)
-            .with_password()
-            .with_string_option("Display Name".into(), "displayname".into(), "".into())
-            .with_string_option(
-                "IMAP server hostname".into(),
-                "mail_server".into(),
-                "".into(),
-            )
-            .with_string_option("IMAP server port".into(), "mail_port".into(), "".into())
-            // Username and password are mail_user and mail_pw
-            .with_string_option(
-                "SMTP server hostname".into(),
-                "send_server".into(),
-                "".into(),
-            )
-            .with_string_option("SMTP server port".into(), "send_port".into(), "".into())
-            .with_string_option("SMTP server username".into(), "send_user".into(), "".into())
-            .with_password_option("SMTP server password".into(), "send_pw".into(), "".into())
-            .with_bool_option("Copy messages to self".into(), "bcc_self".into(), false)
-            .enable_login()
-            .enable_load()
-            .enable_close()
-/*
-            .enable_chat_info()
-            .enable_chat_info_defaults()
-            .enable_join_chat()
-            .enable_chat_leave()
-            .enable_send_im()
-            .enable_chat_send()
-            .enable_convo_closed()
-            .enable_get_chat_name()
-*/
-            .enable_list_icon()
-            .enable_status_types()
-    }
-}
-
-impl purple::LoginHandler for PurpleDelta {
-    fn login(&mut self, account: &mut Account) {
-        let display_name = account.get_string("displayname", "");
-
-        let imap_host = account.get_string("mail_server", "");
-        let imap_port = account.get_int("mail_port", 0);
-        let imap_user = account.get_username().unwrap().into();
-        let imap_pass = account.get_password().unwrap().into();
-
-        let smtp_host = account.get_string("send_server", "");
-        let smtp_port = account.get_int("send_port", 0);
-        let smtp_user = account.get_string("send_user", "");
-        let smtp_pass = account.get_string("send_pw", "");
-
-        let bcc_self = account.get_bool("bcc_self", false);
-
-        let protocol_data: AccountDataBox = Arc::new(AccountData {
-            display_name,
-
-            imap_host,
-            imap_port,
-            imap_user,
-            imap_pass,
-
-            smtp_host,
-            smtp_port,
-            smtp_user,
-            smtp_pass,
-
-            bcc_self,
-
-            session_closed: AtomicBool::new(false),
-            //            session: RwLock::new(None),
-        });
-
-        // Safe as long as we remove the account in "close".
-        unsafe {
-            self.connections
-                .add(account.get_connection().unwrap(), protocol_data.clone())
-        };
-        /*
-        self.system
-            .tx
-            .try_send(PurpleMessage::Login(AccountInfo {
-                handle: Handle::from(&mut *account),
-                protocol_data,
-            }))
-            .unwrap();*/
-    }
-}
-impl purple::CloseHandler for PurpleDelta {
-    fn close(&mut self, connection: &mut Connection) {
-        let handle = Handle::from(&mut *connection);
-        match self.connections.get(&handle) {
-            Some(protocol_data) => {
-                protocol_data
-                    .data
-                    .session_closed
-                    .store(true, Ordering::Relaxed);
-                self.connections.remove(*connection);
-            }
-            None => {
-                log::error!("Tried closing a closed connection");
-            }
-        }
-    }
-}
-impl purple::StatusTypeHandler for PurpleDelta {
-    fn status_types(_account: &mut Account) -> Vec<StatusType> {
-        vec![
-            StatusType::new(
-                PurpleStatusPrimitive::PURPLE_STATUS_AVAILABLE,
-                Some(&status::ONLINE_ID),
-                Some(&status::ONLINE_NAME),
-                true,
-            ),
-            StatusType::new(
-                PurpleStatusPrimitive::PURPLE_STATUS_OFFLINE,
-                Some(&status::OFFLINE_ID),
-                Some(&status::OFFLINE_NAME),
-                true,
-            ),
-        ]
-    }
-}
-impl purple::LoadHandler for PurpleDelta {
-    fn load(&mut self, _plugin: &purple::Plugin) -> bool {
-        logging::set_thread_logger(logging::PurpleDebugLogger);
-        //use std::os::unix::io::AsRawFd;
-        /*
-                self.input_handle = Some(self.enable_input(
-                    self.system.input_rx.as_raw_fd(),
-                    purple::PurpleInputCondition::PURPLE_INPUT_READ,
-                ));
-        */
-        self.imex_command_handle =
-            Some(self.enable_command(commands::IMEX, "w", "imex &lt;code&gt;"));
-
-        true
-    }
-}
-
-impl purple::ListIconHandler for PurpleDelta {
-    fn list_icon(_account: &mut Account) -> &'static CStr {
-        &ICON_FILE
-    }
-}
-/*
-impl purple::ChatInfoHandler for PurpleDelta {
-    fn chat_info(&mut self, _connection: &mut Connection) -> Vec<purple::prpl::ChatEntry> {
-        vec![purple::prpl::ChatEntry {
-            label: &chat_info::SN_NAME,
-            identifier: &chat_info::SN,
-            required: true,
-            is_int: false,
-            min: 0,
-            max: 0,
-            secret: false,
-        }]
-    }
-}
-
-impl purple::ChatInfoDefaultsHandler for PurpleDelta {
-    fn chat_info_defaults(
-        &mut self,
-        _connection: &mut Connection,
-        chat_name: Option<&str>,
-    ) -> purple::StrHashTable {
-        let mut defaults = purple::StrHashTable::default();
-        defaults.insert(chat_info::SN.as_c_str(), chat_name.unwrap_or(""));
-        defaults
-    }
-}
-
-impl purple::JoinChatHandler for PurpleDelta {
-    fn join_chat(&mut self, connection: &mut Connection, data: Option<&mut StrHashTable>) {
-        let data = match data {
-            Some(data) => data,
-            None => {
-                return;
-            }
-        };
-
-        let stamp = match Self::get_chat_name(Some(data)) {
-            Some(stamp) => stamp,
-            None => {
-                log::error!("No chat name provided");
-                return;
-            }
-        };
-
-        log::info!("Joining {}", stamp);
-
-        let handle = Handle::from(&mut *connection);
-        let protocol_data = self
-            .connections
-            .get(&handle)
-            .expect("Tried joining chat on closed connection");
-
-        if let Some(chat_states::JOINED) = data.lookup(&chat_info::STATE) {
-            match PartialChatInfo::from_hashtable(data) {
-                Some(chat_info) => {
-                    self.conversation_joined(connection, &chat_info);
-                    /*
-                    self.system
-                        .tx
-                        .try_send(PurpleMessage::get_chat_info(
-                            handle,
-                            protocol_data.data.clone(),
-                            chat_info.sn,
-                        ))
-                        .unwrap(); */
-                    return;
-                }
-                None => {
-                    log::error!("Unable to load chat info");
-                }
-            }
-        }
-        /*
-        self.system
-            .tx
-            .try_send(PurpleMessage::join_chat(
-                handle,
-                protocol_data.data.clone(),
-                stamp,
-            ))
-            .unwrap() */
-    }
-}
-
-impl purple::ChatLeaveHandler for PurpleDelta {
-    fn chat_leave(&mut self, connection: &mut Connection, id: i32) {
-        log::info!("Chat leave: {}", id);
-        match Conversation::find(connection, id) {
-            Some(mut conversation) => {
-                unsafe { conversation.remove_data::<ChatInfo>(conv_data::CHAT_INFO) };
-            }
-            None => {
-                log::warn!("Leaving chat without conversation");
-            }
-        }
-    }
-}
-
-impl purple::ConvoClosedHandler for PurpleDelta {
-    fn convo_closed(&mut self, _connection: &mut Connection, who: Option<&str>) {
-        log::info!("Convo closed: {:?}", who)
-    }
-}
-
-impl purple::GetChatNameHandler for PurpleDelta {
-    fn get_chat_name(data: Option<&mut purple::StrHashTable>) -> Option<String> {
-        data.and_then(|h| h.lookup(chat_info::SN.as_c_str()).map(Into::into))
-    }
-}
-
-impl purple::SendIMHandler for PurpleDelta {
-    fn send_im(
-        &mut self,
-        _connection: &mut Connection,
-        _who: &str,
-        _message: &str,
-        _flags: PurpleMessageFlags,
-    ) -> i32 {
-        log::warn!("SendIM is not implemented");
-        -1
-    }
-}
-
-impl purple::ChatSendHandler for PurpleDelta {
-    fn chat_send(
-        &mut self,
-        connection: &mut Connection,
-        id: i32,
-        message: &str,
-        flags: PurpleMessageFlags,
-    ) -> i32 {
-        log::info!("{}: {} [{:?}]", id, message, flags);
-        let mut conversation = match Conversation::find(connection, id) {
-            Some(c) => c,
-            None => {
-                log::error!("Conversation not found");
-                return -1;
-            }
-        };
-
-        let sn = match unsafe { conversation.get_data::<ChatInfo>(conv_data::CHAT_INFO) } {
-            Some(info) => info.sn.clone(),
-            None => {
-                log::error!("SN not found");
-                return -1;
-            }
-        };
-
-        let handle = Handle::from(&mut *connection);
-        let protocol_data = self.connections.get(&handle).expect("Connection closed");
-        /*
-        self.system
-            .tx
-            .try_send(PurpleMessage::send_msg(
-                handle,
-                protocol_data.data.clone(),
-                sn,
-                message.into(),
-            ))
-            .unwrap(); */
-        1
-    }
-}
-
-impl purple::InputHandler for PurpleDelta {
-    fn input(&mut self, _fd: i32, _cond: purple::PurpleInputCondition) {
-        log::debug!("Input");
-        /*
-                // Consume the byte from the input pipe.
-                let mut buf = [0; 1];
-
-                self.system
-                    .input_rx
-                    .read_exact(&mut buf)
-                    .expect("Failed to read input pipe");
-
-                // Consume the actual message.
-                match self.system.rx.try_recv() {
-                    Ok(message) => self.process_message(message),
-                    Err(async_std::sync::TryRecvError::Empty) => log::error!("Expected message, but empty"),
-                    Err(async_std::sync::TryRecvError::Disconnected) => {
-                        log::error!("System disconnected");
-                        if let Some(input_handle) = self.input_handle {
-                            self.disable_input(input_handle);
-                        }
-                    }
-                };
-        */
-    }
-}
-*/
-impl purple::CommandHandler for PurpleDelta {
-    fn command(
-        &mut self,
-        conversation: &mut Conversation,
-        command: &str,
-        args: &[&str],
-    ) -> PurpleCmdRet {
-        log::debug!(
-            "command: conv={} cmd={} args={:?}",
-            conversation.get_title().unwrap_or("unknown"),
-            command,
-            args
-        );
-        match command {
-            commands::IMEX => self.command_imex(conversation, args),
-            _ => {
-                log::error!("Unknown command: {}", command);
-                PurpleCmdRet::PURPLE_CMD_RET_FAILED
-            }
-        }
-    }
-}
-
-impl PurpleDelta {
-    fn command_imex(&mut self, conversation: &mut Conversation, args: &[&str]) -> PurpleCmdRet {
-        log::debug!("command_imex");
-
-        if args.len() != 1 {
-            log::error!(
-                "command_imex: Unsupported number of args. Got {}",
-                args.len()
-            );
-            return PurpleCmdRet::PURPLE_CMD_RET_FAILED;
-        }
-        /*
-                let count = {
-                    let input = match args[0].parse::<u32>() {
-                        Ok(count) => count,
-                        Err(_) => {
-                            log::error!("command_history: Could not parse count: {}", args[0]);
-                            return PurpleCmdRet::PURPLE_CMD_RET_FAILED;
-                        }
-                    };
-                    0 - input as i32
-                };
-
-                let sn = match conversation.get_name() {
-                    Some(name) => name.to_string(),
-                    None => {
-                        log::error!("command_history: SN not found");
-                        return PurpleCmdRet::PURPLE_CMD_RET_FAILED;
-                    }
-                };
-
-                let from_msg_id = {
-                    match unsafe {
-                        conversation.get_data::<conv_data::HistoryInfoType>(conv_data::HISTORY_INFO)
-                    } {
-                        Some(history_info) => {
-                            let history_info = history_info.borrow_mut();
-                            match &history_info.oldest_message_id {
-                                Some(oldest_message_id) => oldest_message_id.clone(),
-                                None => {
-                                    return PurpleCmdRet::PURPLE_CMD_RET_FAILED;
-                                }
-                            }
-                        }
-                        None => {
-                            log::error!("command_history: Can't find message id");
-                            return PurpleCmdRet::PURPLE_CMD_RET_FAILED;
-                        }
-                    }
-                };
-
-                let handle = Handle::from(&mut conversation.get_connection());
-
-                let protocol_data = self
-                    .connections
-                    .get(&handle)
-                    .expect("Tried joining chat on closed connection");
-
-                self.system
-                    .tx
-                    .try_send(PurpleMessage::fetch_history(
-                        handle,
-                        protocol_data.data.clone(),
-                        sn,
-                        from_msg_id,
-                        count,
-                    ))
-                    .unwrap();
-        */
-        PurpleCmdRet::PURPLE_CMD_RET_OK
-    }
-    /*
-        fn process_message(&mut self, message: SystemMessage) {
-            match message {
-                SystemMessage::ExecAccount { handle, function } => {
-                    self.connections
-                        .get(handle)
-                        .map(|protocol_data| function(&mut protocol_data.account))
-                        .or_else(|| {
-                            log::warn!("The account connection has been closed");
-                            None
-                        });
-                }
-                SystemMessage::ExecConnection { handle, function } => {
-                    self.connections
-                        .get(handle)
-                        .map(|protocol_data| function(&mut protocol_data.connection))
-                        .or_else(|| {
-                            log::warn!("The account connection has been closed");
-                            None
-                        });
-                }
-                SystemMessage::ExecHandle { handle, function } => {
-                    self.connections
-                        .get(handle)
-                        .map(|mut protocol_data| function(self, &mut protocol_data))
-                        .or_else(|| {
-                            log::warn!("The account connection has been closed");
-                            None
-                        });
-                }
-                SystemMessage::FlushLogs => logging::flush(),
-            }
-        }
-
-        pub fn serv_got_chat_in(&mut self, connection: &mut Connection, msg_info: MsgInfo) {
-            match purple::Chat::find(&mut connection.get_account(), &msg_info.chat_sn) {
-                Some(mut chat) => {
-                    // Get the chat and the last seen timestamp.
-                    let mut node = chat.as_blist_node();
-                    let last_timestamp: i64 = node
-                        .get_string(&blist_node::LAST_SEEN_TIMESTAMP)
-                        .and_then(|t| t.parse::<i64>().ok())
-                        .unwrap_or(0);
-                    let new_timestamp = msg_info.time;
-
-                    // Only trigger conversation_joined if this is a new message.
-                    let conversation = {
-                        if new_timestamp > last_timestamp {
-                            node.set_string(
-                                &blist_node::LAST_SEEN_TIMESTAMP,
-                                &new_timestamp.to_string(),
-                            );
-                            Some(self.conversation_joined(
-                                connection,
-                                &PartialChatInfo {
-                                    sn: msg_info.chat_sn.clone(),
-                                    title: msg_info.chat_sn.clone(),
-                                    ..Default::default()
-                                },
-                            ))
-                        } else {
-                            None
-                        }
-                    };
-
-                    // Get the conversation and set the oldest *displayed* messageId.
-                    // This is the oldest message that the user can see in the chat window.
-                    //
-                    // If there is no conversation yet, that is okay. It means that we haven't
-                    // seen new messages yet.
-                    if let Some(mut conversation) = conversation {
-                        let history_info = {
-                            match unsafe {
-                                conversation
-                                    .get_data::<conv_data::HistoryInfoType>(conv_data::HISTORY_INFO)
-                            } {
-                                Some(history_info) => history_info.clone(),
-                                None => {
-                                    let history_info = Rc::new(RefCell::new(HistoryInfo {
-                                        oldest_message_id: None,
-                                        oldest_message_timestamp: None,
-                                    }));
-                                    unsafe {
-                                        conversation.set_data::<conv_data::HistoryInfoType>(
-                                            conv_data::HISTORY_INFO,
-                                            history_info.clone(),
-                                        )
-                                    };
-                                    history_info
-                                }
-                            }
-                        };
-                        let mut history_info = history_info.borrow_mut();
-
-                        match history_info.oldest_message_timestamp {
-                            None => {
-                                history_info.oldest_message_id = Some(msg_info.message_id.clone());
-                                history_info.oldest_message_timestamp = Some(msg_info.time);
-                            }
-                            Some(existing_timestamp) => {
-                                if msg_info.time < existing_timestamp {
-                                    history_info.oldest_message_id = Some(msg_info.message_id.clone());
-                                    history_info.oldest_message_timestamp = Some(msg_info.time);
-                                }
-                            }
-                        }
-                    }
-                }
-                None => {
-                    // Don't log errors for DMs because they are not yet supported.
-                    // It happens all the time.
-                    if msg_info.chat_sn.ends_with("@chat.agent") {
-                        log::error!("Got message for unknown chat {}", msg_info.chat_sn);
-                    }
-                }
-            }
-
-            connection.serv_got_chat_in(msg_info);
-        }
-
-        pub fn chat_joined(&mut self, connection: &mut Connection, info: &PartialChatInfo) {
-            log::info!("chat joined: {}", info.sn);
-            if info.sn.ends_with("@chat.agent") {
-                self.group_chat_joined(connection, info)
-            } else {
-                todo!()
-            };
-        }
-
-        fn group_chat_joined(
-            &mut self,
-            connection: &mut Connection,
-            info: &PartialChatInfo,
-        ) -> purple::Chat {
-            let mut account = connection.get_account();
-            match purple::Chat::find(&mut account, &info.sn) {
-                Some(mut chat) => {
-                    // The chat already exists.
-
-                    // Should we replace the blist group?
-                    if let Some(info_group) = &info.group {
-                        let should_replace_group = {
-                            match chat.get_group() {
-                                Some(mut chat_group) => !chat_group.get_name().eq(info_group),
-                                None => true,
-                            }
-                        };
-                        if should_replace_group {
-                            chat.add_to_blist(&mut self.get_or_create_group(Some(&info_group)), None);
-                        }
-                    }
-
-                    // Replace the alias
-                    chat.set_alias(&info.title);
-                    chat
-                }
-                None => {
-                    let mut components = info.as_hashtable();
-                    components.insert(&chat_info::STATE, chat_states::JOINED);
-                    let mut chat = purple::Chat::new(&mut account, &info.title, components);
-                    chat.add_to_blist(&mut self.get_or_create_group(info.group.as_deref()), None);
-                    chat
-                }
-            }
-        }
-
-        fn get_or_create_group(&mut self, name: Option<&str>) -> purple::Group {
-            let name = name.unwrap_or("ICQ");
-            Group::find(name).unwrap_or_else(|| {
-                let mut group = purple::Group::new(name);
-                group.add_to_blist(None);
-                group
-            })
-        }
-
-    pub fn conversation_joined(
-        &mut self,
-        connection: &mut Connection,
-        info: &PartialChatInfo,
-    ) -> Conversation {
-        match connection.get_account().find_chat_conversation(&info.sn) {
-            Some(mut conversation) => {
-                if conversation.get_chat_data().unwrap().has_left() {
-                    log::error!("Trying to join left conversation");
-                } else {
-                    conversation.present();
-                }
-                conversation
-            }
-            None => {
-                let mut conversation = connection.serv_got_joined_chat(&info.sn).unwrap();
-                conversation.set_title(&info.title);
-                conversation
-            }
-        }
-    }
-
-        pub fn check_chat_info(
-            &mut self,
-            connection: &mut Connection,
-            sn: &str,
-            version: &ChatInfoVersion,
-        ) {
-            match connection.get_account().find_chat_conversation(&sn) {
-                Some(mut conversation) => {
-                    let chat_info = unsafe { conversation.get_data::<ChatInfo>(conv_data::CHAT_INFO) };
-                    if chat_info
-                        .map(|chat_info| chat_info.need_update(version))
-                        .unwrap_or(true)
-                    {
-                        log::info!("Fetching chat info: {}", sn);
-                        let handle = Handle::from(&mut *connection);
-                        let protocol_data = self
-                            .connections
-                            .get(&handle)
-                            .expect("Tried get chat info on closed connection");
-                        self.system
-                            .tx
-                            .try_send(PurpleMessage::get_chat_info(
-                                handle,
-                                protocol_data.data.clone(),
-                                sn.to_string(),
-                            ))
-                            .unwrap();
-                    }
-                }
-                None => {
-                    log::warn!("Checking chat info for no conversation");
-                }
-            }
-        }
-
-        pub fn load_chat_info(&mut self, connection: &mut Connection, info: &ChatInfo) {
-            log::debug!("loading chat info: {:?}", info);
-            match connection.get_account().find_chat_conversation(&info.sn) {
-                Some(mut conversation) => {
-                    conversation.set_title(&info.title);
-                    let mut chat_conversation = conversation.get_chat_data().unwrap();
-                    unsafe { conversation.set_data(conv_data::CHAT_INFO, info.clone()) };
-
-                    chat_conversation.clear_users();
-                    for member in &info.members {
-                        chat_conversation.add_user(&member.sn, "", member.role.as_flags(), false);
-                    }
-
-                    if let Some(about) = &info.about {
-                        chat_conversation.set_topic("unknown", about);
-                    }
-                }
-                None => {
-                    log::warn!("Loaded chat info for no conversation");
-                }
-            }
-        }
-    */
-}
-
-purple_prpl_plugin!(PurpleDelta);

src/logging.rs

@@ -1,121 +0,0 @@
-// This is a copy of https://github.com/Flared/purple-icq/blob/master/src/logging.rs
-
-//use crate::messages::{FdSender, SystemMessage};
-use crate::purple;
-use std::cell::RefCell;
-use std::sync::Mutex;
-
-std::thread_local! {
-    pub static LOGGER: RefCell<Option<Box<dyn log::Log>>> = RefCell::new(None);
-}
-
-lazy_static::lazy_static! {
-    static ref PURPLE_BUFFER: Mutex<Vec<(String, log::Level, String)>> = Default::default();
-}
-
-static TLS_LOGGER: ThreadLocalLogger = ThreadLocalLogger;
-
-pub struct ThreadLocalLogger;
-
-impl log::Log for ThreadLocalLogger {
-    fn enabled(&self, _metadata: &log::Metadata) -> bool {
-        true
-    }
-
-    fn log(&self, record: &log::Record) {
-        LOGGER.with(|cell| {
-            if let Some(ref logger) = cell.borrow().as_ref() {
-                logger.log(record);
-            }
-        })
-    }
-
-    fn flush(&self) {
-        LOGGER.with(|cell| {
-            if let Some(ref logger) = cell.borrow().as_ref() {
-                logger.flush()
-            }
-        })
-    }
-}
-
-pub struct PurpleDebugLogger;
-
-impl log::Log for PurpleDebugLogger {
-    fn enabled(&self, metadata: &log::Metadata) -> bool {
-        metadata.level() < log::Level::Debug
-    }
-
-    fn log(&self, record: &log::Record) {
-        let purple_level = match record.level() {
-            log::Level::Error => purple::PurpleDebugLevel::PURPLE_DEBUG_ERROR,
-            log::Level::Warn => purple::PurpleDebugLevel::PURPLE_DEBUG_WARNING,
-            log::Level::Info => purple::PurpleDebugLevel::PURPLE_DEBUG_INFO,
-            _ => purple::PurpleDebugLevel::PURPLE_DEBUG_MISC,
-        };
-
-        let target = if !record.target().is_empty() {
-            record.target()
-        } else {
-            record.module_path().unwrap_or_default()
-        };
-        let line = format!("[{}] {}\n", target, record.args());
-        purple::debug(purple_level, "", &line);
-    }
-
-    fn flush(&self) {
-        let buffer = {
-            match PURPLE_BUFFER.lock() {
-                Ok(mut buffer) => buffer.split_off(0),
-                Err(_) => return,
-            }
-        };
-        for (target, level, message) in buffer {
-            log::log!(target: &target, level, "{}", message);
-        }
-    }
-}
-
-/*
-pub struct RemoteLogger(pub FdSender<SystemMessage>);
-
-impl log::Log for RemoteLogger {
-    fn enabled(&self, metadata: &log::Metadata) -> bool {
-        metadata.level() < log::Level::Debug
-    }
-
-    fn log(&self, record: &log::Record) {
-        let target = if !record.target().is_empty() {
-            record.target()
-        } else {
-            record.module_path().unwrap_or_default()
-        };
-
-        if let Ok(mut buffer) = PURPLE_BUFFER.lock() {
-            buffer.push((target.into(), record.level(), record.args().to_string()));
-        }
-    }
-
-    fn flush(&self) {
-        self.0.clone().try_send(SystemMessage::FlushLogs);
-    }
-}
-*/
-pub fn init(level: log::LevelFilter) -> Result<(), log::SetLoggerError> {
-    log::set_logger(&TLS_LOGGER).map(|()| log::set_max_level(level))
-}
-
-pub fn set_thread_logger<T>(logger: T)
-where
-    T: log::Log + 'static,
-{
-    LOGGER.with(|cell| *cell.borrow_mut() = Some(Box::new(logger)))
-}
-
-pub fn flush() {
-    LOGGER.with(|cell| {
-        if let Some(ref logger) = cell.borrow().as_ref() {
-            logger.flush();
-        }
-    })
-}

src/purple/LICENSE

@@ -1,674 +0,0 @@
-                    GNU GENERAL PUBLIC LICENSE
-                       Version 3, 29 June 2007
-
- Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-                            Preamble
-
-  The GNU General Public License is a free, copyleft license for
-software and other kinds of works.
-
-  The licenses for most software and other practical works are designed
-to take away your freedom to share and change the works.  By contrast,
-the GNU General Public License is intended to guarantee your freedom to
-share and change all versions of a program--to make sure it remains free
-software for all its users.  We, the Free Software Foundation, use the
-GNU General Public License for most of our software; it applies also to
-any other work released this way by its authors.  You can apply it to
-your programs, too.
-
-  When we speak of free software, we are referring to freedom, not
-price.  Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-them if you wish), that you receive source code or can get it if you
-want it, that you can change the software or use pieces of it in new
-free programs, and that you know you can do these things.
-
-  To protect your rights, we need to prevent others from denying you
-these rights or asking you to surrender the rights.  Therefore, you have
-certain responsibilities if you distribute copies of the software, or if
-you modify it: responsibilities to respect the freedom of others.
-
-  For example, if you distribute copies of such a program, whether
-gratis or for a fee, you must pass on to the recipients the same
-freedoms that you received.  You must make sure that they, too, receive
-or can get the source code.  And you must show them these terms so they
-know their rights.
-
-  Developers that use the GNU GPL protect your rights with two steps:
-(1) assert copyright on the software, and (2) offer you this License
-giving you legal permission to copy, distribute and/or modify it.
-
-  For the developers' and authors' protection, the GPL clearly explains
-that there is no warranty for this free software.  For both users' and
-authors' sake, the GPL requires that modified versions be marked as
-changed, so that their problems will not be attributed erroneously to
-authors of previous versions.
-
-  Some devices are designed to deny users access to install or run
-modified versions of the software inside them, although the manufacturer
-can do so.  This is fundamentally incompatible with the aim of
-protecting users' freedom to change the software.  The systematic
-pattern of such abuse occurs in the area of products for individuals to
-use, which is precisely where it is most unacceptable.  Therefore, we
-have designed this version of the GPL to prohibit the practice for those
-products.  If such problems arise substantially in other domains, we
-stand ready to extend this provision to those domains in future versions
-of the GPL, as needed to protect the freedom of users.
-
-  Finally, every program is threatened constantly by software patents.
-States should not allow patents to restrict development and use of
-software on general-purpose computers, but in those that do, we wish to
-avoid the special danger that patents applied to a free program could
-make it effectively proprietary.  To prevent this, the GPL assures that
-patents cannot be used to render the program non-free.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.
-
-                       TERMS AND CONDITIONS
-
-  0. Definitions.
-
-  "This License" refers to version 3 of the GNU General Public License.
-
-  "Copyright" also means copyright-like laws that apply to other kinds of
-works, such as semiconductor masks.
-
-  "The Program" refers to any copyrightable work licensed under this
-License.  Each licensee is addressed as "you".  "Licensees" and
-"recipients" may be individuals or organizations.
-
-  To "modify" a work means to copy from or adapt all or part of the work
-in a fashion requiring copyright permission, other than the making of an
-exact copy.  The resulting work is called a "modified version" of the
-earlier work or a work "based on" the earlier work.
-
-  A "covered work" means either the unmodified Program or a work based
-on the Program.
-
-  To "propagate" a work means to do anything with it that, without
-permission, would make you directly or secondarily liable for
-infringement under applicable copyright law, except executing it on a
-computer or modifying a private copy.  Propagation includes copying,
-distribution (with or without modification), making available to the
-public, and in some countries other activities as well.
-
-  To "convey" a work means any kind of propagation that enables other
-parties to make or receive copies.  Mere interaction with a user through
-a computer network, with no transfer of a copy, is not conveying.
-
-  An interactive user interface displays "Appropriate Legal Notices"
-to the extent that it includes a convenient and prominently visible
-feature that (1) displays an appropriate copyright notice, and (2)
-tells the user that there is no warranty for the work (except to the
-extent that warranties are provided), that licensees may convey the
-work under this License, and how to view a copy of this License.  If
-the interface presents a list of user commands or options, such as a
-menu, a prominent item in the list meets this criterion.
-
-  1. Source Code.
-
-  The "source code" for a work means the preferred form of the work
-for making modifications to it.  "Object code" means any non-source
-form of a work.
-
-  A "Standard Interface" means an interface that either is an official
-standard defined by a recognized standards body, or, in the case of
-interfaces specified for a particular programming language, one that
-is widely used among developers working in that language.
-
-  The "System Libraries" of an executable work include anything, other
-than the work as a whole, that (a) is included in the normal form of
-packaging a Major Component, but which is not part of that Major
-Component, and (b) serves only to enable use of the work with that
-Major Component, or to implement a Standard Interface for which an
-implementation is available to the public in source code form.  A
-"Major Component", in this context, means a major essential component
-(kernel, window system, and so on) of the specific operating system
-(if any) on which the executable work runs, or a compiler used to
-produce the work, or an object code interpreter used to run it.
-
-  The "Corresponding Source" for a work in object code form means all
-the source code needed to generate, install, and (for an executable
-work) run the object code and to modify the work, including scripts to
-control those activities.  However, it does not include the work's
-System Libraries, or general-purpose tools or generally available free
-programs which are used unmodified in performing those activities but
-which are not part of the work.  For example, Corresponding Source
-includes interface definition files associated with source files for
-the work, and the source code for shared libraries and dynamically
-linked subprograms that the work is specifically designed to require,
-such as by intimate data communication or control flow between those
-subprograms and other parts of the work.
-
-  The Corresponding Source need not include anything that users
-can regenerate automatically from other parts of the Corresponding
-Source.
-
-  The Corresponding Source for a work in source code form is that
-same work.
-
-  2. Basic Permissions.
-
-  All rights granted under this License are granted for the term of
-copyright on the Program, and are irrevocable provided the stated
-conditions are met.  This License explicitly affirms your unlimited
-permission to run the unmodified Program.  The output from running a
-covered work is covered by this License only if the output, given its
-content, constitutes a covered work.  This License acknowledges your
-rights of fair use or other equivalent, as provided by copyright law.
-
-  You may make, run and propagate covered works that you do not
-convey, without conditions so long as your license otherwise remains
-in force.  You may convey covered works to others for the sole purpose
-of having them make modifications exclusively for you, or provide you
-with facilities for running those works, provided that you comply with
-the terms of this License in conveying all material for which you do
-not control copyright.  Those thus making or running the covered works
-for you must do so exclusively on your behalf, under your direction
-and control, on terms that prohibit them from making any copies of
-your copyrighted material outside their relationship with you.
-
-  Conveying under any other circumstances is permitted solely under
-the conditions stated below.  Sublicensing is not allowed; section 10
-makes it unnecessary.
-
-  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
-
-  No covered work shall be deemed part of an effective technological
-measure under any applicable law fulfilling obligations under article
-11 of the WIPO copyright treaty adopted on 20 December 1996, or
-similar laws prohibiting or restricting circumvention of such
-measures.
-
-  When you convey a covered work, you waive any legal power to forbid
-circumvention of technological measures to the extent such circumvention
-is effected by exercising rights under this License with respect to
-the covered work, and you disclaim any intention to limit operation or
-modification of the work as a means of enforcing, against the work's
-users, your or third parties' legal rights to forbid circumvention of
-technological measures.
-
-  4. Conveying Verbatim Copies.
-
-  You may convey verbatim copies of the Program's source code as you
-receive it, in any medium, provided that you conspicuously and
-appropriately publish on each copy an appropriate copyright notice;
-keep intact all notices stating that this License and any
-non-permissive terms added in accord with section 7 apply to the code;
-keep intact all notices of the absence of any warranty; and give all
-recipients a copy of this License along with the Program.
-
-  You may charge any price or no price for each copy that you convey,
-and you may offer support or warranty protection for a fee.
-
-  5. Conveying Modified Source Versions.
-
-  You may convey a work based on the Program, or the modifications to
-produce it from the Program, in the form of source code under the
-terms of section 4, provided that you also meet all of these conditions:
-
-    a) The work must carry prominent notices stating that you modified
-    it, and giving a relevant date.
-
-    b) The work must carry prominent notices stating that it is
-    released under this License and any conditions added under section
-    7.  This requirement modifies the requirement in section 4 to
-    "keep intact all notices".
-
-    c) You must license the entire work, as a whole, under this
-    License to anyone who comes into possession of a copy.  This
-    License will therefore apply, along with any applicable section 7
-    additional terms, to the whole of the work, and all its parts,
-    regardless of how they are packaged.  This License gives no
-    permission to license the work in any other way, but it does not
-    invalidate such permission if you have separately received it.
-
-    d) If the work has interactive user interfaces, each must display
-    Appropriate Legal Notices; however, if the Program has interactive
-    interfaces that do not display Appropriate Legal Notices, your
-    work need not make them do so.
-
-  A compilation of a covered work with other separate and independent
-works, which are not by their nature extensions of the covered work,
-and which are not combined with it such as to form a larger program,
-in or on a volume of a storage or distribution medium, is called an
-"aggregate" if the compilation and its resulting copyright are not
-used to limit the access or legal rights of the compilation's users
-beyond what the individual works permit.  Inclusion of a covered work
-in an aggregate does not cause this License to apply to the other
-parts of the aggregate.
-
-  6. Conveying Non-Source Forms.
-
-  You may convey a covered work in object code form under the terms
-of sections 4 and 5, provided that you also convey the
-machine-readable Corresponding Source under the terms of this License,
-in one of these ways:
-
-    a) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by the
-    Corresponding Source fixed on a durable physical medium
-    customarily used for software interchange.
-
-    b) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by a
-    written offer, valid for at least three years and valid for as
-    long as you offer spare parts or customer support for that product
-    model, to give anyone who possesses the object code either (1) a
-    copy of the Corresponding Source for all the software in the
-    product that is covered by this License, on a durable physical
-    medium customarily used for software interchange, for a price no
-    more than your reasonable cost of physically performing this
-    conveying of source, or (2) access to copy the
-    Corresponding Source from a network server at no charge.
-
-    c) Convey individual copies of the object code with a copy of the
-    written offer to provide the Corresponding Source.  This
-    alternative is allowed only occasionally and noncommercially, and
-    only if you received the object code with such an offer, in accord
-    with subsection 6b.
-
-    d) Convey the object code by offering access from a designated
-    place (gratis or for a charge), and offer equivalent access to the
-    Corresponding Source in the same way through the same place at no
-    further charge.  You need not require recipients to copy the
-    Corresponding Source along with the object code.  If the place to
-    copy the object code is a network server, the Corresponding Source
-    may be on a different server (operated by you or a third party)
-    that supports equivalent copying facilities, provided you maintain
-    clear directions next to the object code saying where to find the
-    Corresponding Source.  Regardless of what server hosts the
-    Corresponding Source, you remain obligated to ensure that it is
-    available for as long as needed to satisfy these requirements.
-
-    e) Convey the object code using peer-to-peer transmission, provided
-    you inform other peers where the object code and Corresponding
-    Source of the work are being offered to the general public at no
-    charge under subsection 6d.
-
-  A separable portion of the object code, whose source code is excluded
-from the Corresponding Source as a System Library, need not be
-included in conveying the object code work.
-
-  A "User Product" is either (1) a "consumer product", which means any
-tangible personal property which is normally used for personal, family,
-or household purposes, or (2) anything designed or sold for incorporation
-into a dwelling.  In determining whether a product is a consumer product,
-doubtful cases shall be resolved in favor of coverage.  For a particular
-product received by a particular user, "normally used" refers to a
-typical or common use of that class of product, regardless of the status
-of the particular user or of the way in which the particular user
-actually uses, or expects or is expected to use, the product.  A product
-is a consumer product regardless of whether the product has substantial
-commercial, industrial or non-consumer uses, unless such uses represent
-the only significant mode of use of the product.
-
-  "Installation Information" for a User Product means any methods,
-procedures, authorization keys, or other information required to install
-and execute modified versions of a covered work in that User Product from
-a modified version of its Corresponding Source.  The information must
-suffice to ensure that the continued functioning of the modified object
-code is in no case prevented or interfered with solely because
-modification has been made.
-
-  If you convey an object code work under this section in, or with, or
-specifically for use in, a User Product, and the conveying occurs as
-part of a transaction in which the right of possession and use of the
-User Product is transferred to the recipient in perpetuity or for a
-fixed term (regardless of how the transaction is characterized), the
-Corresponding Source conveyed under this section must be accompanied
-by the Installation Information.  But this requirement does not apply
-if neither you nor any third party retains the ability to install
-modified object code on the User Product (for example, the work has
-been installed in ROM).
-
-  The requirement to provide Installation Information does not include a
-requirement to continue to provide support service, warranty, or updates
-for a work that has been modified or installed by the recipient, or for
-the User Product in which it has been modified or installed.  Access to a
-network may be denied when the modification itself materially and
-adversely affects the operation of the network or violates the rules and
-protocols for communication across the network.
-
-  Corresponding Source conveyed, and Installation Information provided,
-in accord with this section must be in a format that is publicly
-documented (and with an implementation available to the public in
-source code form), and must require no special password or key for
-unpacking, reading or copying.
-
-  7. Additional Terms.
-
-  "Additional permissions" are terms that supplement the terms of this
-License by making exceptions from one or more of its conditions.
-Additional permissions that are applicable to the entire Program shall
-be treated as though they were included in this License, to the extent
-that they are valid under applicable law.  If additional permissions
-apply only to part of the Program, that part may be used separately
-under those permissions, but the entire Program remains governed by
-this License without regard to the additional permissions.
-
-  When you convey a copy of a covered work, you may at your option
-remove any additional permissions from that copy, or from any part of
-it.  (Additional permissions may be written to require their own
-removal in certain cases when you modify the work.)  You may place
-additional permissions on material, added by you to a covered work,
-for which you have or can give appropriate copyright permission.
-
-  Notwithstanding any other provision of this License, for material you
-add to a covered work, you may (if authorized by the copyright holders of
-that material) supplement the terms of this License with terms:
-
-    a) Disclaiming warranty or limiting liability differently from the
-    terms of sections 15 and 16 of this License; or
-
-    b) Requiring preservation of specified reasonable legal notices or
-    author attributions in that material or in the Appropriate Legal
-    Notices displayed by works containing it; or
-
-    c) Prohibiting misrepresentation of the origin of that material, or
-    requiring that modified versions of such material be marked in
-    reasonable ways as different from the original version; or
-
-    d) Limiting the use for publicity purposes of names of licensors or
-    authors of the material; or
-
-    e) Declining to grant rights under trademark law for use of some
-    trade names, trademarks, or service marks; or
-
-    f) Requiring indemnification of licensors and authors of that
-    material by anyone who conveys the material (or modified versions of
-    it) with contractual assumptions of liability to the recipient, for
-    any liability that these contractual assumptions directly impose on
-    those licensors and authors.
-
-  All other non-permissive additional terms are considered "further
-restrictions" within the meaning of section 10.  If the Program as you
-received it, or any part of it, contains a notice stating that it is
-governed by this License along with a term that is a further
-restriction, you may remove that term.  If a license document contains
-a further restriction but permits relicensing or conveying under this
-License, you may add to a covered work material governed by the terms
-of that license document, provided that the further restriction does
-not survive such relicensing or conveying.
-
-  If you add terms to a covered work in accord with this section, you
-must place, in the relevant source files, a statement of the
-additional terms that apply to those files, or a notice indicating
-where to find the applicable terms.
-
-  Additional terms, permissive or non-permissive, may be stated in the
-form of a separately written license, or stated as exceptions;
-the above requirements apply either way.
-
-  8. Termination.
-
-  You may not propagate or modify a covered work except as expressly
-provided under this License.  Any attempt otherwise to propagate or
-modify it is void, and will automatically terminate your rights under
-this License (including any patent licenses granted under the third
-paragraph of section 11).
-
-  However, if you cease all violation of this License, then your
-license from a particular copyright holder is reinstated (a)
-provisionally, unless and until the copyright holder explicitly and
-finally terminates your license, and (b) permanently, if the copyright
-holder fails to notify you of the violation by some reasonable means
-prior to 60 days after the cessation.
-
-  Moreover, your license from a particular copyright holder is
-reinstated permanently if the copyright holder notifies you of the
-violation by some reasonable means, this is the first time you have
-received notice of violation of this License (for any work) from that
-copyright holder, and you cure the violation prior to 30 days after
-your receipt of the notice.
-
-  Termination of your rights under this section does not terminate the
-licenses of parties who have received copies or rights from you under
-this License.  If your rights have been terminated and not permanently
-reinstated, you do not qualify to receive new licenses for the same
-material under section 10.
-
-  9. Acceptance Not Required for Having Copies.
-
-  You are not required to accept this License in order to receive or
-run a copy of the Program.  Ancillary propagation of a covered work
-occurring solely as a consequence of using peer-to-peer transmission
-to receive a copy likewise does not require acceptance.  However,
-nothing other than this License grants you permission to propagate or
-modify any covered work.  These actions infringe copyright if you do
-not accept this License.  Therefore, by modifying or propagating a
-covered work, you indicate your acceptance of this License to do so.
-
-  10. Automatic Licensing of Downstream Recipients.
-
-  Each time you convey a covered work, the recipient automatically
-receives a license from the original licensors, to run, modify and
-propagate that work, subject to this License.  You are not responsible
-for enforcing compliance by third parties with this License.
-
-  An "entity transaction" is a transaction transferring control of an
-organization, or substantially all assets of one, or subdividing an
-organization, or merging organizations.  If propagation of a covered
-work results from an entity transaction, each party to that
-transaction who receives a copy of the work also receives whatever
-licenses to the work the party's predecessor in interest had or could
-give under the previous paragraph, plus a right to possession of the
-Corresponding Source of the work from the predecessor in interest, if
-the predecessor has it or can get it with reasonable efforts.
-
-  You may not impose any further restrictions on the exercise of the
-rights granted or affirmed under this License.  For example, you may
-not impose a license fee, royalty, or other charge for exercise of
-rights granted under this License, and you may not initiate litigation
-(including a cross-claim or counterclaim in a lawsuit) alleging that
-any patent claim is infringed by making, using, selling, offering for
-sale, or importing the Program or any portion of it.
-
-  11. Patents.
-
-  A "contributor" is a copyright holder who authorizes use under this
-License of the Program or a work on which the Program is based.  The
-work thus licensed is called the contributor's "contributor version".
-
-  A contributor's "essential patent claims" are all patent claims
-owned or controlled by the contributor, whether already acquired or
-hereafter acquired, that would be infringed by some manner, permitted
-by this License, of making, using, or selling its contributor version,
-but do not include claims that would be infringed only as a
-consequence of further modification of the contributor version.  For
-purposes of this definition, "control" includes the right to grant
-patent sublicenses in a manner consistent with the requirements of
-this License.
-
-  Each contributor grants you a non-exclusive, worldwide, royalty-free
-patent license under the contributor's essential patent claims, to
-make, use, sell, offer for sale, import and otherwise run, modify and
-propagate the contents of its contributor version.
-
-  In the following three paragraphs, a "patent license" is any express
-agreement or commitment, however denominated, not to enforce a patent
-(such as an express permission to practice a patent or covenant not to
-sue for patent infringement).  To "grant" such a patent license to a
-party means to make such an agreement or commitment not to enforce a
-patent against the party.
-
-  If you convey a covered work, knowingly relying on a patent license,
-and the Corresponding Source of the work is not available for anyone
-to copy, free of charge and under the terms of this License, through a
-publicly available network server or other readily accessible means,
-then you must either (1) cause the Corresponding Source to be so
-available, or (2) arrange to deprive yourself of the benefit of the
-patent license for this particular work, or (3) arrange, in a manner
-consistent with the requirements of this License, to extend the patent
-license to downstream recipients.  "Knowingly relying" means you have
-actual knowledge that, but for the patent license, your conveying the
-covered work in a country, or your recipient's use of the covered work
-in a country, would infringe one or more identifiable patents in that
-country that you have reason to believe are valid.
-
-  If, pursuant to or in connection with a single transaction or
-arrangement, you convey, or propagate by procuring conveyance of, a
-covered work, and grant a patent license to some of the parties
-receiving the covered work authorizing them to use, propagate, modify
-or convey a specific copy of the covered work, then the patent license
-you grant is automatically extended to all recipients of the covered
-work and works based on it.
-
-  A patent license is "discriminatory" if it does not include within
-the scope of its coverage, prohibits the exercise of, or is
-conditioned on the non-exercise of one or more of the rights that are
-specifically granted under this License.  You may not convey a covered
-work if you are a party to an arrangement with a third party that is
-in the business of distributing software, under which you make payment
-to the third party based on the extent of your activity of conveying
-the work, and under which the third party grants, to any of the
-parties who would receive the covered work from you, a discriminatory
-patent license (a) in connection with copies of the covered work
-conveyed by you (or copies made from those copies), or (b) primarily
-for and in connection with specific products or compilations that
-contain the covered work, unless you entered into that arrangement,
-or that patent license was granted, prior to 28 March 2007.
-
-  Nothing in this License shall be construed as excluding or limiting
-any implied license or other defenses to infringement that may
-otherwise be available to you under applicable patent law.
-
-  12. No Surrender of Others' Freedom.
-
-  If conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot convey a
-covered work so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you may
-not convey it at all.  For example, if you agree to terms that obligate you
-to collect a royalty for further conveying from those to whom you convey
-the Program, the only way you could satisfy both those terms and this
-License would be to refrain entirely from conveying the Program.
-
-  13. Use with the GNU Affero General Public License.
-
-  Notwithstanding any other provision of this License, you have
-permission to link or combine any covered work with a work licensed
-under version 3 of the GNU Affero General Public License into a single
-combined work, and to convey the resulting work.  The terms of this
-License will continue to apply to the part which is the covered work,
-but the special requirements of the GNU Affero General Public License,
-section 13, concerning interaction through a network will apply to the
-combination as such.
-
-  14. Revised Versions of this License.
-
-  The Free Software Foundation may publish revised and/or new versions of
-the GNU General Public License from time to time.  Such new versions will
-be similar in spirit to the present version, but may differ in detail to
-address new problems or concerns.
-
-  Each version is given a distinguishing version number.  If the
-Program specifies that a certain numbered version of the GNU General
-Public License "or any later version" applies to it, you have the
-option of following the terms and conditions either of that numbered
-version or of any later version published by the Free Software
-Foundation.  If the Program does not specify a version number of the
-GNU General Public License, you may choose any version ever published
-by the Free Software Foundation.
-
-  If the Program specifies that a proxy can decide which future
-versions of the GNU General Public License can be used, that proxy's
-public statement of acceptance of a version permanently authorizes you
-to choose that version for the Program.
-
-  Later license versions may give you additional or different
-permissions.  However, no additional obligations are imposed on any
-author or copyright holder as a result of your choosing to follow a
-later version.
-
-  15. Disclaimer of Warranty.
-
-  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
-APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
-HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
-OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
-THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
-IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
-ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
-  16. Limitation of Liability.
-
-  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
-THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
-GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
-USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
-DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
-PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
-EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
-SUCH DAMAGES.
-
-  17. Interpretation of Sections 15 and 16.
-
-  If the disclaimer of warranty and limitation of liability provided
-above cannot be given local legal effect according to their terms,
-reviewing courts shall apply local law that most closely approximates
-an absolute waiver of all civil liability in connection with the
-Program, unless a warranty or assumption of liability accompanies a
-copy of the Program in return for a fee.
-
-                     END OF TERMS AND CONDITIONS
-
-            How to Apply These Terms to Your New Programs
-
-  If you develop a new program, and you want it to be of the greatest
-possible use to the public, the best way to achieve this is to make it
-free software which everyone can redistribute and change under these terms.
-
-  To do so, attach the following notices to the program.  It is safest
-to attach them to the start of each source file to most effectively
-state the exclusion of warranty; and each file should have at least
-the "copyright" line and a pointer to where the full notice is found.
-
-    <one line to give the program's name and a brief idea of what it does.>
-    Copyright (C) <year>  <name of author>
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-Also add information on how to contact you by electronic and paper mail.
-
-  If the program does terminal interaction, make it output a short
-notice like this when it starts in an interactive mode:
-
-    <program>  Copyright (C) <year>  <name of author>
-    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
-    This is free software, and you are welcome to redistribute it
-    under certain conditions; type `show c' for details.
-
-The hypothetical commands `show w' and `show c' should show the appropriate
-parts of the General Public License.  Of course, your program's commands
-might be different; for a GUI interface, you would use an "about box".
-
-  You should also get your employer (if you work as a programmer) or school,
-if any, to sign a "copyright disclaimer" for the program, if necessary.
-For more information on this, and how to apply and follow the GNU GPL, see
-<https://www.gnu.org/licenses/>.
-
-  The GNU General Public License does not permit incorporating your program
-into proprietary programs.  If your program is a subroutine library, you
-may consider it more useful to permit linking proprietary applications with
-the library.  If this is what you want to do, use the GNU Lesser General
-Public License instead of this License.  But first, please read
-<https://www.gnu.org/licenses/why-not-lgpl.html>.

src/purple/account/mod.rs

@@ -1,252 +0,0 @@
-use super::ffi::{AsMutPtr, AsPtr};
-use super::{Connection, Conversation, PurpleConversationType};
-use std::borrow::Cow;
-use std::ffi::CStr;
-use std::ffi::CString;
-use std::os::raw::{c_char, c_void};
-use std::panic::catch_unwind;
-
-pub mod settings;
-
-impl AsMutPtr for Account {
-    type PtrType = purple_sys::PurpleAccount;
-    fn as_mut_ptr(&mut self) -> *mut purple_sys::PurpleAccount {
-        self.0
-    }
-}
-
-#[derive(Clone)]
-pub struct Account(*mut purple_sys::PurpleAccount);
-
-impl Account {
-    pub unsafe fn from_raw(ptr: *mut purple_sys::PurpleAccount) -> Self {
-        Account(ptr)
-    }
-
-    pub fn get_connection(&self) -> Option<Connection> {
-        let connection_ptr = unsafe { purple_sys::purple_account_get_connection(self.0) };
-        if connection_ptr.is_null() {
-            None
-        } else {
-            unsafe { Connection::from_raw(connection_ptr) }
-        }
-    }
-
-    pub fn get_username(&self) -> Option<Cow<str>> {
-        let username_ptr = unsafe { purple_sys::purple_account_get_username(self.0) };
-        if username_ptr.is_null() {
-            None
-        } else {
-            Some(unsafe { CStr::from_ptr(username_ptr) }.to_string_lossy())
-        }
-    }
-
-    pub fn get_password(&self) -> Option<Cow<str>> {
-        let password_ptr = unsafe { purple_sys::purple_account_get_password(self.0) };
-        if password_ptr.is_null() {
-            None
-        } else {
-            Some(unsafe { CStr::from_ptr(password_ptr) }.to_string_lossy())
-        }
-    }
-
-    pub fn is_disconnected(&self) -> bool {
-        let is_disconnected = unsafe { purple_sys::purple_account_is_disconnected(self.0) };
-        is_disconnected != 0
-    }
-
-    #[allow(dead_code)]
-    pub fn get_bool(&self, key: &str, default_value: bool) -> bool {
-        let c_key = CString::new(key).unwrap();
-        unsafe {
-            purple_sys::purple_account_get_bool(self.0, c_key.as_ptr(), default_value as i32) != 0
-        }
-    }
-    pub fn get_int(&self, key: &str, default_value: i32) -> i32 {
-        let c_key = CString::new(key).unwrap();
-        unsafe { purple_sys::purple_account_get_int(self.0, c_key.as_ptr(), default_value) }
-    }
-    pub fn get_string(&self, key: &str, default_value: &str) -> String {
-        let c_key = CString::new(key).unwrap();
-        let c_default_value = CString::new(default_value).unwrap();
-        let c_value = unsafe {
-            purple_sys::purple_account_get_string(self.0, c_key.as_ptr(), c_default_value.as_ptr())
-        };
-        unsafe { CStr::from_ptr(c_value).to_string_lossy().into_owned() }
-    }
-
-    pub fn set_bool(&self, key: &str, value: bool) {
-        log::info!("Set setting: {} = {}", key, value);
-        let c_key = CString::new(key).unwrap();
-        unsafe { purple_sys::purple_account_set_bool(self.0, c_key.as_ptr(), value as i32) };
-    }
-    pub fn set_int(&self, key: &str, value: i32) {
-        log::info!("Set setting: {} = {}", key, value);
-        let c_key = CString::new(key).unwrap();
-        unsafe { purple_sys::purple_account_set_int(self.0, c_key.as_ptr(), value) };
-    }
-    pub fn set_string(&self, key: &str, value: &str) {
-        log::info!("Set setting: {} = {}", key, value);
-        let c_key = CString::new(key).unwrap();
-        let c_value = CString::new(value).unwrap();
-        unsafe { purple_sys::purple_account_set_string(self.0, c_key.as_ptr(), c_value.as_ptr()) };
-    }
-
-    pub fn remove_setting(&self, key: &str) {
-        log::info!("Delete setting: {}", key);
-        let c_key = CString::new(key).unwrap();
-        unsafe { purple_sys::purple_account_remove_setting(self.0, c_key.as_ptr()) };
-    }
-
-    pub fn set_settings<T: serde::Serialize>(&self, settings: &T) -> settings::Result<()> {
-        settings::to_account(&self, settings)
-    }
-
-    pub fn find_chat_conversation(&mut self, name: &str) -> Option<Conversation> {
-        let c_name = CString::new(name).unwrap();
-        unsafe {
-            Conversation::from_ptr(purple_sys::purple_find_conversation_with_account(
-                PurpleConversationType::PURPLE_CONV_TYPE_CHAT,
-                c_name.as_ptr(),
-                self.0,
-            ))
-        }
-    }
-
-    #[allow(clippy::too_many_arguments)]
-    pub fn request_input<F>(
-        &self,
-        title: Option<&str>,
-        primary: Option<&str>,
-        secondary: Option<&str>,
-        default_value: Option<&str>,
-        multiline: bool,
-        masked: bool,
-        hint: Option<&str>,
-        ok_text: &str,
-        cancel_text: &str,
-        callback: F,
-        who: Option<&str>,
-    ) where
-        F: FnOnce(Option<Cow<str>>) + 'static,
-    {
-        let title = title.map(|v| CString::new(v).unwrap().into_raw());
-        let primary = primary.map(|v| CString::new(v).unwrap().into_raw());
-        let secondary = secondary.map(|v| CString::new(v).unwrap().into_raw());
-        let default_value = default_value.map(|v| CString::new(v).unwrap().into_raw());
-        let mut hint = hint.map(|v| CString::new(v).unwrap().into_raw());
-        let who = who.map(|v| CString::new(v).unwrap().into_raw());
-        let ok_text = CString::new(ok_text).unwrap().into_raw();
-        let cancel_text = CString::new(cancel_text).unwrap().into_raw();
-
-        let mut connection = self.get_connection().map(|c| c.as_ptr());
-
-        let callback_closure = move |value: Option<Cow<str>>| {
-            // Regain ownership over strings to free them.
-            // Safe since all of those pointer where generated from into_raw()
-            unsafe {
-                title.map(|p| CString::from_raw(p));
-                primary.map(|p| CString::from_raw(p));
-                secondary.map(|p| CString::from_raw(p));
-                default_value.map(|p| CString::from_raw(p));
-                hint.map(|p| CString::from_raw(p));
-                who.map(|p| CString::from_raw(p));
-                CString::from_raw(ok_text);
-                CString::from_raw(cancel_text);
-                who.map(|p| CString::from_raw(p));
-            }
-
-            callback(value);
-        };
-
-        unsafe {
-            purple_request_input_with_callback(
-                connection.as_mut_ptr() as *mut c_void,
-                title.as_ptr(),
-                primary.as_ptr(),
-                secondary.as_ptr(),
-                default_value.as_ptr(),
-                multiline as i32,
-                masked as i32,
-                hint.as_mut_ptr(),
-                ok_text,
-                cancel_text,
-                callback_closure,
-                self.0,
-                who.as_ptr(),
-                std::ptr::null_mut(),
-            );
-        }
-    }
-}
-
-#[allow(clippy::too_many_arguments)]
-unsafe fn purple_request_input_with_callback<F>(
-    connection: *mut c_void,
-    title: *const c_char,
-    primary: *const c_char,
-    secondary: *const c_char,
-    default_value: *const c_char,
-    multiline: i32,
-    masked: i32,
-    hint: *mut c_char,
-    ok_text: *const c_char,
-    cancel_text: *const c_char,
-    callback: F,
-    account: *mut purple_sys::PurpleAccount,
-    who: *const c_char,
-    conv: *mut purple_sys::PurpleConversation,
-) where
-    F: FnOnce(Option<Cow<str>>) + 'static,
-{
-    let user_data = Box::into_raw(Box::new(callback)) as *mut c_void;
-    let ok_cb_ptr: unsafe extern "C" fn(*mut c_void, *const c_char) =
-        request_input_ok_trampoline::<F>;
-    let cancel_cb_ptr: unsafe extern "C" fn(*mut c_void) = request_input_cancel_trampoline::<F>;
-
-    purple_sys::purple_request_input(
-        connection,
-        title,
-        primary,
-        secondary,
-        default_value,
-        multiline,
-        masked,
-        hint,
-        ok_text,
-        Some(std::mem::transmute(ok_cb_ptr)),
-        cancel_text,
-        Some(std::mem::transmute(cancel_cb_ptr)),
-        account,
-        who,
-        conv,
-        user_data,
-    );
-}
-
-unsafe extern "C" fn request_input_ok_trampoline<F>(user_data: *mut c_void, value: *const c_char)
-where
-    F: FnOnce(Option<Cow<str>>),
-{
-    log::debug!("request_input_ok_trampoline");
-    if let Err(error) = catch_unwind(|| {
-        let value = CStr::from_ptr(value);
-        let closure = Box::from_raw(user_data as *mut F);
-        closure(Some(value.to_string_lossy()));
-    }) {
-        log::error!("Error in request_input callback: {:?}", error);
-    }
-}
-
-unsafe extern "C" fn request_input_cancel_trampoline<F>(user_data: *mut c_void)
-where
-    F: FnOnce(Option<Cow<str>>),
-{
-    log::debug!("request_input_cancel_trampoline");
-    if let Err(error) = catch_unwind(|| {
-        let closure = Box::from_raw(user_data as *mut F);
-        closure(None);
-    }) {
-        log::error!("Error in request_input callback: {:?}", error);
-    }
-}

src/purple/account/settings.rs

@@ -1,353 +0,0 @@
-use super::Account;
-use serde::{de, ser, Serialize};
-pub type Result<T> = std::result::Result<T, Error>;
-
-#[derive(Clone, Debug, PartialEq)]
-pub enum Error {
-    Message(String),
-    UnsupportedType(&'static str),
-    MissingKey,
-    PurpleFailed,
-}
-impl std::error::Error for Error {}
-
-impl ser::Error for Error {
-    fn custom<T: std::fmt::Display>(msg: T) -> Self {
-        Error::Message(msg.to_string())
-    }
-}
-
-impl de::Error for Error {
-    fn custom<T: std::fmt::Display>(msg: T) -> Self {
-        Error::Message(msg.to_string())
-    }
-}
-
-impl std::fmt::Display for Error {
-    fn fmt(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
-        match self {
-            Error::Message(msg) => formatter.write_str(msg),
-            Error::PurpleFailed => formatter.write_str("libpurple call failed"),
-            Error::MissingKey => formatter.write_str("Key unset for value"),
-            Error::UnsupportedType(t) => write!(formatter, "type '{}' is not supported", t),
-        }
-    }
-}
-
-pub struct Serializer<'a> {
-    current_key: Result<&'a str>,
-    account: &'a Account,
-}
-
-pub fn to_account<T>(account: &Account, value: &T) -> Result<()>
-where
-    T: Serialize,
-{
-    let mut serializer = Serializer {
-        account,
-        current_key: Err(Error::MissingKey),
-    };
-    value.serialize(&mut serializer)
-}
-
-impl<'a> Serializer<'a> {
-    fn serialize_int(&self, v: i32) -> Result<()> {
-        match &self.current_key {
-            Ok(k) => {
-                self.account.set_int(k, v);
-                Ok(())
-            }
-            Err(e) => Err(e.clone()),
-        }
-    }
-    fn serialize_string(&self, v: &str) -> Result<()> {
-        match &self.current_key {
-            Ok(k) => {
-                self.account.set_string(k, v);
-                Ok(())
-            }
-            Err(e) => Err(e.clone()),
-        }
-    }
-    fn remove_settings(&self) -> Result<()> {
-        match &self.current_key {
-            Ok(k) => {
-                self.account.remove_setting(k);
-                Ok(())
-            }
-            Err(e) => Err(e.clone()),
-        }
-    }
-}
-
-impl<'a, 'b> ser::Serializer for &'a mut Serializer<'b> {
-    type Ok = ();
-    type Error = Error;
-    type SerializeSeq = Self;
-    type SerializeTuple = Self;
-    type SerializeTupleStruct = Self;
-    type SerializeTupleVariant = Self;
-    type SerializeMap = Self;
-    type SerializeStruct = Self;
-    type SerializeStructVariant = Self;
-
-    fn serialize_bool(self, v: bool) -> Result<Self::Ok> {
-        match &self.current_key {
-            Ok(k) => {
-                self.account.set_bool(k, v);
-                Ok(())
-            }
-            Err(e) => Err(e.clone()),
-        }
-    }
-
-    fn serialize_i8(self, v: i8) -> Result<Self::Ok> {
-        self.serialize_int(v as i32)
-    }
-
-    fn serialize_i16(self, v: i16) -> Result<Self::Ok> {
-        self.serialize_int(v as i32)
-    }
-
-    fn serialize_i32(self, v: i32) -> Result<Self::Ok> {
-        self.serialize_int(v)
-    }
-
-    fn serialize_i64(self, _v: i64) -> Result<Self::Ok> {
-        Err(Error::UnsupportedType("i64"))
-    }
-
-    fn serialize_u8(self, v: u8) -> Result<Self::Ok> {
-        self.serialize_int(v as i32)
-    }
-
-    fn serialize_u16(self, v: u16) -> Result<Self::Ok> {
-        self.serialize_int(v as i32)
-    }
-
-    fn serialize_u32(self, v: u32) -> Result<Self::Ok> {
-        self.serialize_int(v as i32)
-    }
-
-    fn serialize_u64(self, _v: u64) -> Result<Self::Ok> {
-        Err(Error::UnsupportedType("u64"))
-    }
-
-    fn serialize_f32(self, _v: f32) -> Result<Self::Ok> {
-        Err(Error::UnsupportedType("f32"))
-    }
-
-    fn serialize_f64(self, _v: f64) -> Result<Self::Ok> {
-        Err(Error::UnsupportedType("f64"))
-    }
-
-    fn serialize_char(self, v: char) -> Result<Self::Ok> {
-        self.serialize_string(&v.to_string())
-    }
-
-    fn serialize_str(self, v: &str) -> Result<Self::Ok> {
-        self.serialize_string(v)
-    }
-
-    fn serialize_bytes(self, _v: &[u8]) -> Result<Self::Ok> {
-        Err(Error::UnsupportedType("bytes"))
-    }
-
-    fn serialize_none(self) -> Result<Self::Ok> {
-        self.remove_settings()
-    }
-
-    fn serialize_some<T: ?Sized + Serialize>(self, value: &T) -> Result<Self::Ok> {
-        value.serialize(self)
-    }
-
-    fn serialize_unit(self) -> Result<Self::Ok> {
-        Err(Error::UnsupportedType("unit"))
-    }
-
-    fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok> {
-        Err(Error::UnsupportedType("unit_struct"))
-    }
-
-    fn serialize_unit_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        variant: &'static str,
-    ) -> Result<Self::Ok> {
-        self.serialize_str(variant)
-    }
-
-    fn serialize_newtype_struct<T: ?Sized + Serialize>(
-        self,
-        _name: &'static str,
-        value: &T,
-    ) -> Result<Self::Ok> {
-        value.serialize(self)
-    }
-
-    fn serialize_newtype_variant<T: ?Sized + Serialize>(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        value: &T,
-    ) -> Result<Self::Ok> {
-        value.serialize(self)
-    }
-
-    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> {
-        Err(Error::UnsupportedType("seq"))
-    }
-
-    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
-        Err(Error::UnsupportedType("tuple"))
-    }
-
-    fn serialize_tuple_struct(
-        self,
-        _name: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeTupleStruct> {
-        Err(Error::UnsupportedType("tuple_struct"))
-    }
-
-    fn serialize_tuple_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeTupleVariant> {
-        Err(Error::UnsupportedType("tuple_variant"))
-    }
-
-    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
-        Err(Error::UnsupportedType("map"))
-    }
-
-    fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeStruct> {
-        Ok(self)
-    }
-
-    fn serialize_struct_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeStructVariant> {
-        Err(Error::UnsupportedType("struct_variant"))
-    }
-}
-
-impl<'a, 'b> ser::SerializeSeq for &'a mut Serializer<'b> {
-    type Ok = ();
-    type Error = Error;
-
-    fn serialize_element<T: ?Sized + Serialize>(&mut self, _value: &T) -> Result<()> {
-        unreachable!()
-    }
-
-    fn end(self) -> Result<Self::Ok> {
-        unreachable!()
-    }
-}
-
-impl<'a, 'b> ser::SerializeTuple for &'a mut Serializer<'b> {
-    type Ok = ();
-    type Error = Error;
-
-    fn serialize_element<T: ?Sized + Serialize>(&mut self, _value: &T) -> Result<()> {
-        unreachable!()
-    }
-
-    fn end(self) -> Result<Self::Ok> {
-        unreachable!()
-    }
-}
-
-impl<'a, 'b> ser::SerializeTupleStruct for &'a mut Serializer<'b> {
-    type Ok = ();
-    type Error = Error;
-
-    fn serialize_field<T: ?Sized + Serialize>(&mut self, _value: &T) -> Result<()> {
-        unreachable!()
-    }
-
-    fn end(self) -> Result<Self::Ok> {
-        unreachable!()
-    }
-}
-
-impl<'a, 'b> ser::SerializeTupleVariant for &'a mut Serializer<'b> {
-    type Ok = ();
-    type Error = Error;
-
-    fn serialize_field<T: ?Sized + Serialize>(&mut self, _value: &T) -> Result<()> {
-        unreachable!()
-    }
-
-    fn end(self) -> Result<Self::Ok> {
-        unreachable!()
-    }
-}
-
-impl<'a, 'b> ser::SerializeMap for &'a mut Serializer<'b> {
-    type Ok = ();
-    type Error = Error;
-
-    fn serialize_key<T: ?Sized + Serialize>(&mut self, _key: &T) -> Result<()> {
-        unreachable!()
-    }
-
-    fn serialize_value<T: ?Sized + Serialize>(&mut self, _value: &T) -> Result<()> {
-        unreachable!()
-    }
-
-    fn end(self) -> Result<Self::Ok> {
-        unreachable!()
-    }
-}
-
-impl<'a, 'b> ser::SerializeStruct for &'a mut Serializer<'b> {
-    type Ok = ();
-    type Error = Error;
-
-    fn serialize_field<T: ?Sized + Serialize>(
-        &mut self,
-        key: &'static str,
-        value: &T,
-    ) -> Result<()> {
-        // Shouldn't happen.
-        if self.current_key.is_ok() {
-            return Err(Error::Message("Key already set".into()));
-        }
-
-        self.current_key = Ok(key);
-        let value = value.serialize(&mut **self);
-        self.current_key = Err(Error::MissingKey);
-        value
-    }
-
-    fn end(self) -> Result<Self::Ok> {
-        Ok(())
-    }
-}
-
-impl<'a, 'b> ser::SerializeStructVariant for &'a mut Serializer<'b> {
-    type Ok = ();
-    type Error = Error;
-
-    fn serialize_field<T: ?Sized + Serialize>(
-        &mut self,
-        _key: &'static str,
-        _value: &T,
-    ) -> Result<()> {
-        unreachable!()
-    }
-
-    fn end(self) -> Result<Self::Ok> {
-        unreachable!()
-    }
-}

src/purple/blist.rs

@@ -1,45 +0,0 @@
-use super::ffi::AsPtr;
-use libc::c_char;
-use std::ffi::CStr;
-use std::ffi::CString;
-use std::ptr::NonNull;
-
-pub struct BlistNode(NonNull<purple_sys::PurpleBlistNode>);
-
-impl BlistNode {
-    pub unsafe fn from_ptr(ptr: *mut purple_sys::PurpleBlistNode) -> Option<Self> {
-        NonNull::new(ptr).map(Self)
-    }
-
-    pub fn get_string(&mut self, key: &str) -> Option<&str> {
-        let c_key = CString::new(key).unwrap();
-
-        unsafe {
-            let c_value = purple_sys::purple_blist_node_get_string(self.0.as_ptr(), c_key.as_ptr());
-            NonNull::new(c_value as *mut c_char).map(|p| {
-                CStr::from_ptr(p.as_ptr() as *const c_char)
-                    .to_str()
-                    .unwrap()
-            })
-        }
-    }
-
-    pub fn set_string(&mut self, key: &str, value: &str) {
-        let c_key = CString::new(key).unwrap();
-        let c_value = CString::new(value).unwrap();
-        unsafe {
-            purple_sys::purple_blist_node_set_string(
-                self.0.as_ptr(),
-                c_key.as_ptr(),
-                c_value.as_ptr(),
-            );
-        }
-    }
-}
-
-impl AsPtr for BlistNode {
-    type PtrType = purple_sys::PurpleBlistNode;
-    fn as_ptr(&self) -> *const Self::PtrType {
-        self.0.as_ptr()
-    }
-}

src/purple/chat.rs

@@ -1,72 +0,0 @@
-use super::blist::BlistNode;
-use super::ffi::{AsMutPtr, AsPtr, IntoGlibPtr};
-use crate::purple;
-use std::ffi::CString;
-use std::ptr::{null_mut, NonNull};
-
-pub struct Chat(NonNull<purple_sys::PurpleChat>);
-
-impl Chat {
-    pub fn new(
-        account: &mut purple::Account,
-        alias: &str,
-        components: purple::StrHashTable,
-    ) -> Self {
-        let c_alias = CString::new(alias).unwrap();
-        unsafe {
-            Self::from_ptr(purple_sys::purple_chat_new(
-                account.as_mut_ptr(),
-                c_alias.as_ptr(),
-                components.into_glib_full(),
-            ))
-            .unwrap()
-        }
-    }
-
-    pub unsafe fn from_ptr(ptr: *mut purple_sys::PurpleChat) -> Option<Self> {
-        NonNull::new(ptr).map(Self)
-    }
-
-    pub fn find(account: &mut purple::Account, name: &str) -> Option<Self> {
-        let c_name = CString::new(name).unwrap();
-        unsafe {
-            Self::from_ptr(purple_sys::purple_blist_find_chat(
-                account.as_mut_ptr(),
-                c_name.as_ptr(),
-            ))
-        }
-    }
-
-    pub fn as_blist_node(&mut self) -> BlistNode {
-        unsafe { BlistNode::from_ptr(self.0.as_ptr() as *mut purple_sys::PurpleBlistNode).unwrap() }
-    }
-
-    pub fn set_alias(&mut self, new_alias: &str) {
-        let c_alias = CString::new(new_alias).unwrap();
-        unsafe {
-            purple_sys::purple_blist_alias_chat(self.as_mut_ptr(), c_alias.as_ptr());
-        }
-    }
-
-    pub fn get_group(&mut self) -> Option<purple::Group> {
-        let c_group = unsafe { purple_sys::purple_chat_get_group(self.as_mut_ptr()) };
-        if c_group.is_null() {
-            None
-        } else {
-            unsafe { purple::Group::from_ptr(c_group) }
-        }
-    }
-
-    pub fn add_to_blist(&mut self, group: &mut purple::Group, _node: Option<()>) {
-        unsafe {
-            purple_sys::purple_blist_add_chat(self.as_mut_ptr(), group.as_mut_ptr(), null_mut())
-        }
-    }
-}
-
-impl AsPtr for Chat {
-    type PtrType = purple_sys::PurpleChat;
-    fn as_ptr(&self) -> *const Self::PtrType {
-        self.0.as_ptr()
-    }
-}

src/purple/connection/connections.rs

@@ -1,45 +0,0 @@
-use super::protocol_data::ProtocolData;
-use crate::purple::ffi::AsMutPtr;
-use crate::purple::Connection;
-use std::os::raw::c_void;
-
-pub struct Connections<T> {
-    protocol_datas: std::collections::HashSet<*mut ProtocolData<T>>,
-}
-
-impl<T> Connections<T> {
-    pub fn new() -> Self {
-        Self {
-            protocol_datas: Default::default(),
-        }
-    }
-
-    pub unsafe fn add(&mut self, connection: Connection, data: T) {
-        let account = connection.get_account();
-        let data_ptr = Box::new(ProtocolData::<T> {
-            account,
-            connection,
-            data,
-        });
-        let data_raw_ptr = Box::into_raw(data_ptr);
-        connection.set_protocol_data(data_raw_ptr as *mut c_void);
-        self.protocol_datas.insert(data_raw_ptr);
-    }
-
-    pub fn remove(&mut self, connection: Connection) {
-        let protocol_data_ptr = connection.get_protocol_data() as *mut ProtocolData<T>;
-        self.protocol_datas.remove(&protocol_data_ptr);
-        // Retake ownership of the protocol data to drop its data.
-        unsafe { Box::from_raw(protocol_data_ptr) };
-    }
-
-    pub fn get<'b, P>(&mut self, mut ptr: P) -> Option<&'b mut ProtocolData<T>>
-    where
-        P: AsMutPtr<PtrType = ProtocolData<T>>,
-    {
-        self.protocol_datas
-            .get(&ptr.as_mut_ptr())
-            .cloned()
-            .map(|p| unsafe { &mut *p })
-    }
-}

src/purple/connection/mod.rs

@@ -1,100 +0,0 @@
-use super::ffi::AsPtr;
-use super::{Conversation, Plugin};
-use crate::purple;
-use crate::purple::PurpleMessageFlags;
-use crate::MsgInfo;
-use std::ffi::CString;
-use std::os::raw::c_void;
-use std::ptr::NonNull;
-
-pub mod connections;
-pub mod protocol_data;
-
-pub use self::connections::Connections;
-pub use self::protocol_data::Handle;
-
-#[derive(Clone, Copy)]
-pub struct Connection(NonNull<purple_sys::PurpleConnection>);
-
-impl Connection {
-    pub unsafe fn from_raw(ptr: *mut purple_sys::PurpleConnection) -> Option<Self> {
-        NonNull::new(ptr).map(Self)
-    }
-
-    pub fn get_protocol_plugin(self) -> Option<Plugin> {
-        let plugin_ptr = unsafe { purple_sys::purple_connection_get_prpl(self.0.as_ptr()) };
-        if plugin_ptr.is_null() {
-            None
-        } else {
-            Some(unsafe { Plugin::from_raw(plugin_ptr) })
-        }
-    }
-
-    pub fn set_protocol_data(self, data: *mut c_void) {
-        unsafe { purple_sys::purple_connection_set_protocol_data(self.0.as_ptr(), data) };
-    }
-
-    pub fn get_protocol_data(self) -> *mut c_void {
-        unsafe { purple_sys::purple_connection_get_protocol_data(self.0.as_ptr()) }
-    }
-
-    pub fn get_account(self) -> purple::Account {
-        unsafe {
-            purple::Account::from_raw(purple_sys::purple_connection_get_account(self.0.as_ptr()))
-        }
-    }
-
-    pub fn set_state(self, state: purple::PurpleConnectionState) {
-        log::info!("Connection state: {:?}", state);
-        unsafe { purple_sys::purple_connection_set_state(self.0.as_ptr(), state) };
-    }
-
-    pub fn error_reason(self, reason: purple::PurpleConnectionError, description: &str) {
-        let c_description = CString::new(description).unwrap();
-        unsafe {
-            purple_sys::purple_connection_error_reason(
-                self.0.as_ptr(),
-                reason,
-                c_description.as_ptr(),
-            );
-        }
-    }
-
-    pub fn serv_got_chat_in(self, chat_input: MsgInfo) {
-        unsafe {
-            let c_sn = CString::new(chat_input.chat_sn).unwrap();
-            let sn_hash = glib_sys::g_str_hash(c_sn.as_ptr() as *mut c_void);
-            let c_sender = CString::new(chat_input.author_sn).unwrap();
-            let c_text = CString::new(chat_input.text).unwrap();
-
-            purple_sys::serv_got_chat_in(
-                self.0.as_ptr(),
-                sn_hash as i32,
-                c_sender.as_ptr(),
-                PurpleMessageFlags::PURPLE_MESSAGE_RECV,
-                c_text.as_ptr(),
-                chat_input.time as i64,
-            )
-        }
-    }
-
-    pub fn serv_got_joined_chat(self, name: &str) -> Option<Conversation> {
-        unsafe {
-            let c_name = CString::new(name).unwrap();
-            let name_hash = glib_sys::g_str_hash(c_name.as_ptr() as *mut c_void);
-            let conv = purple_sys::serv_got_joined_chat(
-                self.0.as_ptr(),
-                name_hash as i32,
-                c_name.as_ptr(),
-            );
-            Conversation::from_ptr(conv)
-        }
-    }
-}
-
-impl AsPtr for Connection {
-    type PtrType = purple_sys::PurpleConnection;
-    fn as_ptr(&self) -> *const purple_sys::PurpleConnection {
-        self.0.as_ptr()
-    }
-}

src/purple/connection/protocol_data.rs

@@ -1,51 +0,0 @@
-use crate::purple::ffi::AsPtr;
-use crate::purple::{Account, Connection};
-
-pub struct Handle<T>(*mut ProtocolData<T>);
-
-impl<T> std::fmt::Debug for Handle<T> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "Handle({:?})", self.0)
-    }
-}
-
-impl<T> From<&mut Connection> for Handle<T> {
-    fn from(connection: &mut Connection) -> Handle<T> {
-        Handle(connection.get_protocol_data() as *mut ProtocolData<T>)
-    }
-}
-
-impl<T> From<&mut Account> for Handle<T> {
-    fn from(account: &mut Account) -> Handle<T> {
-        Handle(account.get_connection().unwrap().get_protocol_data() as *mut ProtocolData<T>)
-    }
-}
-
-impl<T> Clone for Handle<T> {
-    fn clone(&self) -> Self {
-        Self(self.0)
-    }
-}
-
-unsafe impl<T> Send for Handle<T> {}
-unsafe impl<T> Sync for Handle<T> {}
-
-impl<T> AsPtr for Handle<T> {
-    type PtrType = ProtocolData<T>;
-    fn as_ptr(&self) -> *const ProtocolData<T> {
-        self.0
-    }
-}
-
-impl<T> AsPtr for &Handle<T> {
-    type PtrType = ProtocolData<T>;
-    fn as_ptr(&self) -> *const ProtocolData<T> {
-        self.0
-    }
-}
-
-pub struct ProtocolData<T> {
-    pub account: Account,
-    pub connection: Connection,
-    pub data: T,
-}

src/purple/conversation.rs

@@ -1,193 +0,0 @@
-use super::ffi::{AsMutPtr, AsPtr};
-use super::{Connection, PurpleConvChatBuddyFlags};
-use glib::translate::{FromGlib, ToGlib};
-use std::ffi::{CStr, CString};
-use std::os::raw::{c_char, c_void};
-use std::ptr::{null_mut, NonNull};
-
-pub struct ChatConversation(NonNull<purple_sys::PurpleConvChat>);
-pub struct Conversation(NonNull<purple_sys::PurpleConversation>);
-
-impl Conversation {
-    pub unsafe fn from_ptr(ptr: *mut purple_sys::PurpleConversation) -> Option<Self> {
-        NonNull::new(ptr).map(Self)
-    }
-
-    pub fn find(connection: &mut Connection, id: i32) -> Option<Self> {
-        unsafe { Self::from_ptr(purple_sys::purple_find_chat(connection.as_mut_ptr(), id)) }
-    }
-
-    pub fn find_by_name(connection: &mut Connection, name: &str) -> Option<Self> {
-        let c_name = CString::new(name).unwrap();
-        let sn_hash = unsafe { glib_sys::g_str_hash(c_name.as_ptr() as *mut c_void) };
-        Self::find(connection, sn_hash as i32)
-    }
-
-    pub fn set_title(&mut self, title: &str) {
-        unsafe {
-            let c_title = CString::new(title).unwrap();
-            purple_sys::purple_conversation_set_title(self.as_mut_ptr(), c_title.as_ptr());
-        }
-    }
-
-    pub fn get_title(&mut self) -> Option<&str> {
-        unsafe {
-            let c_value = purple_sys::purple_conversation_get_title(self.as_mut_ptr());
-            NonNull::new(c_value as *mut c_char).map(|p| {
-                CStr::from_ptr(p.as_ptr() as *const c_char)
-                    .to_str()
-                    .unwrap()
-            })
-        }
-    }
-
-    pub fn get_name(&mut self) -> Option<&str> {
-        unsafe {
-            let c_value = purple_sys::purple_conversation_get_name(self.as_mut_ptr());
-            NonNull::new(c_value as *mut c_char).map(|p| {
-                CStr::from_ptr(p.as_ptr() as *const c_char)
-                    .to_str()
-                    .unwrap()
-            })
-        }
-    }
-
-    pub fn get_connection(&mut self) -> Connection {
-        unsafe {
-            let c_connection = purple_sys::purple_conversation_get_gc(self.as_mut_ptr());
-            Connection::from_raw(c_connection).unwrap()
-        }
-    }
-
-    pub fn present(&mut self) {
-        unsafe { purple_sys::purple_conversation_present(self.as_mut_ptr()) }
-    }
-
-    // Unsafe since set_data check for an existing value and frees it as `T` type, while
-    // being unable to ensure the freed data is really ot `T` type.
-    pub unsafe fn set_data<T>(&mut self, key: &str, data: T) {
-        let c_key = CString::new(key).unwrap();
-        let existing_ptr =
-            purple_sys::purple_conversation_get_data(self.as_mut_ptr(), c_key.as_ptr());
-        if !existing_ptr.is_null() {
-            Box::<T>::from_raw(existing_ptr as *mut T);
-        }
-
-        let data_ptr = Box::into_raw(Box::new(data));
-        purple_sys::purple_conversation_set_data(
-            self.as_mut_ptr(),
-            c_key.as_ptr(),
-            data_ptr as *mut c_void,
-        );
-    }
-
-    // Unsafe since get_data doesn't validate the data stored at `key` is really of `T`
-    // type.
-    pub unsafe fn get_data<'a, T>(&'a mut self, key: &'_ str) -> Option<&'a mut T> {
-        let c_key = CString::new(key).unwrap();
-        NonNull::new(purple_sys::purple_conversation_get_data(
-            self.as_mut_ptr(),
-            c_key.as_ptr(),
-        ))
-        .map(|p| &mut *(p.as_ptr() as *mut T))
-    }
-
-    // Unsafe since it doesn't validate the data stored at `key` is really of `T`
-    // type.
-    pub unsafe fn remove_data<T>(&mut self, key: &str) {
-        let c_key = CString::new(key).unwrap();
-        let existing_ptr =
-            purple_sys::purple_conversation_get_data(self.as_mut_ptr(), c_key.as_ptr());
-        if !existing_ptr.is_null() {
-            Box::<T>::from_raw(existing_ptr as *mut T);
-            purple_sys::purple_conversation_set_data(self.as_mut_ptr(), c_key.as_ptr(), null_mut());
-        }
-    }
-
-    pub fn get_chat_data(&mut self) -> Option<ChatConversation> {
-        unsafe {
-            ChatConversation::from_ptr(purple_sys::purple_conversation_get_chat_data(
-                self.as_mut_ptr(),
-            ))
-        }
-    }
-}
-
-impl ChatConversation {
-    pub unsafe fn from_ptr(ptr: *mut purple_sys::PurpleConvChat) -> Option<Self> {
-        NonNull::new(ptr).map(Self)
-    }
-
-    pub fn has_left(&mut self) -> bool {
-        FromGlib::from_glib(unsafe { purple_sys::purple_conv_chat_has_left(self.0.as_ptr()) })
-    }
-
-    pub fn add_user(
-        &mut self,
-        user: &str,
-        extra_msg: &str,
-        flags: PurpleConvChatBuddyFlags,
-        new_arrival: bool,
-    ) {
-        let c_user = CString::new(user).unwrap();
-        let c_extra_msg = CString::new(extra_msg).unwrap();
-        log::info!(
-            "{:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}",
-            self.as_mut_ptr(),
-            c_user,
-            c_user.as_ptr(),
-            c_extra_msg,
-            c_extra_msg.as_ptr(),
-            flags,
-            new_arrival.to_glib()
-        );
-        unsafe {
-            purple_sys::purple_conv_chat_add_user(
-                self.as_mut_ptr(),
-                c_user.as_ptr(),
-                c_extra_msg.as_ptr(),
-                flags,
-                new_arrival.to_glib(),
-            )
-        }
-        log::info!("Added user");
-    }
-
-    pub fn clear_users(&mut self) {
-        unsafe { purple_sys::purple_conv_chat_clear_users(self.as_mut_ptr()) }
-    }
-
-    pub fn set_topic(&mut self, who: &str, topic: &str) {
-        let c_topic = CString::new(topic).unwrap();
-        let c_who = CString::new(who).unwrap();
-        unsafe {
-            purple_sys::purple_conv_chat_set_topic(
-                self.as_mut_ptr(),
-                c_who.as_ptr(),
-                c_topic.as_ptr(),
-            );
-        }
-    }
-
-    pub fn get_conversation(&mut self) -> Conversation {
-        unsafe {
-            Conversation::from_ptr(purple_sys::purple_conv_chat_get_conversation(
-                self.as_mut_ptr(),
-            ))
-            .unwrap()
-        }
-    }
-}
-
-impl AsPtr for Conversation {
-    type PtrType = purple_sys::PurpleConversation;
-    fn as_ptr(&self) -> *const Self::PtrType {
-        self.0.as_ptr()
-    }
-}
-impl AsPtr for ChatConversation {
-    type PtrType = purple_sys::PurpleConvChat;
-    fn as_ptr(&self) -> *const Self::PtrType {
-        self.0.as_ptr()
-    }
-}

src/purple/ffi.rs

@@ -1,106 +0,0 @@
-use glib::translate::{Ptr, ToGlibPtr};
-use std::ffi::CStr;
-use std::os::raw::c_char;
-use std::ptr::{null, null_mut, NonNull};
-
-pub fn mut_override<T>(ptr: *const T) -> *mut T {
-    ptr as *mut T
-}
-pub trait IntoGlibPtr<P> {
-    fn into_glib_full(self) -> *mut P;
-}
-
-impl<P: AsMutPtr> IntoGlibPtr<P::PtrType> for P {
-    fn into_glib_full(mut self) -> *mut P::PtrType {
-        let ptr = self.as_mut_ptr();
-        std::mem::forget(self);
-        ptr
-    }
-}
-
-pub trait ToGlibContainerFromIterator<P>
-where
-    Self: Sized,
-{
-    fn into_glib_full_from_iter<I: IntoIterator<Item = Self>>(iter: I) -> P;
-}
-
-impl<T, P> ToGlibContainerFromIterator<*mut glib_sys::GList> for T
-where
-    T: AsPtr<PtrType = P>,
-    T: IntoGlibPtr<P>,
-    P: 'static,
-{
-    fn into_glib_full_from_iter<I>(iter: I) -> *mut glib_sys::GList
-    where
-        I: IntoIterator<Item = Self>,
-    {
-        let mut list: *mut glib_sys::GList = std::ptr::null_mut();
-        unsafe {
-            for ptr in iter.into_iter().map(|v| v.into_glib_full()) {
-                list = glib_sys::g_list_prepend(list, Ptr::to(ptr));
-            }
-            glib_sys::g_list_reverse(list)
-        }
-    }
-}
-
-impl ToGlibContainerFromIterator<*mut glib_sys::GHashTable> for (&'static CStr, String) {
-    fn into_glib_full_from_iter<I>(iter: I) -> *mut glib_sys::GHashTable
-    where
-        I: IntoIterator<Item = Self>,
-    {
-        unsafe {
-            let ptr = glib_sys::g_hash_table_new_full(
-                Some(glib_sys::g_str_hash),
-                Some(glib_sys::g_str_equal),
-                None,
-                Some(glib_sys::g_free),
-            );
-            for (k, v) in iter {
-                let k: *const c_char = k.as_ptr();
-                let v: *mut c_char = v.to_glib_full();
-                glib_sys::g_hash_table_insert(ptr, k as *mut _, v as *mut _);
-            }
-            ptr
-        }
-    }
-}
-
-pub trait AsPtr {
-    type PtrType;
-    fn as_ptr(&self) -> *const Self::PtrType;
-}
-
-pub trait AsMutPtr {
-    type PtrType;
-    fn as_mut_ptr(&mut self) -> *mut Self::PtrType;
-}
-
-impl<T: AsPtr> AsMutPtr for T {
-    type PtrType = T::PtrType;
-    fn as_mut_ptr(&mut self) -> *mut Self::PtrType {
-        self.as_ptr() as *mut Self::PtrType
-    }
-}
-
-impl<T> AsPtr for Option<NonNull<T>> {
-    type PtrType = T;
-    fn as_ptr(&self) -> *const Self::PtrType {
-        self.map_or_else(null, |x| x.as_ptr())
-    }
-}
-
-impl<T> AsPtr for Option<*const T> {
-    type PtrType = T;
-    fn as_ptr(&self) -> *const T {
-        self.unwrap_or_else(null)
-    }
-}
-
-impl<T> AsPtr for Option<*mut T> {
-    type PtrType = T;
-    fn as_ptr(&self) -> *const T {
-        self.unwrap_or_else(null_mut)
-    }
-}

src/purple/group.rs

@@ -1,40 +0,0 @@
-use super::ffi::{AsMutPtr, AsPtr};
-use std::ffi::CStr;
-use std::ffi::CString;
-use std::ptr::{null_mut, NonNull};
-
-pub struct Group(NonNull<purple_sys::PurpleGroup>);
-
-impl Group {
-    pub unsafe fn from_ptr(ptr: *mut purple_sys::PurpleGroup) -> Option<Self> {
-        NonNull::new(ptr).map(Self)
-    }
-
-    pub fn find(name: &str) -> Option<Group> {
-        let c_name = CString::new(name).unwrap();
-        unsafe { Group::from_ptr(purple_sys::purple_find_group(c_name.as_ptr())) }
-    }
-
-    pub fn new(name: &str) -> Group {
-        let c_name = CString::new(name).unwrap();
-        unsafe { Group::from_ptr(purple_sys::purple_group_new(c_name.as_ptr())).unwrap() }
-    }
-
-    pub fn add_to_blist(&mut self, _node: Option<()>) {
-        unsafe { purple_sys::purple_blist_add_group(self.as_mut_ptr(), null_mut()) }
-    }
-
-    pub fn get_name(&mut self) -> String {
-        unsafe {
-            let name_ptr = purple_sys::purple_group_get_name(self.as_mut_ptr());
-            CStr::from_ptr(name_ptr).to_str().unwrap().to_string()
-        }
-    }
-}
-
-impl AsPtr for Group {
-    type PtrType = purple_sys::PurpleGroup;
-    fn as_ptr(&self) -> *const Self::PtrType {
-        self.0.as_ptr()
-    }
-}

src/purple/handlers/entrypoints.rs

@@ -1,297 +0,0 @@
-use super::super::{prpl, Account, Connection, Plugin, PurpleMessageFlags, StrHashTable};
-use super::traits;
-use crate::purple::ffi::{IntoGlibPtr, ToGlibContainerFromIterator};
-use glib::translate::{ToGlibContainerFromSlice, ToGlibPtr};
-use log::{debug, error};
-use std::ffi::CStr;
-use std::os::raw::{c_char, c_void};
-use std::panic::catch_unwind;
-use std::ptr::NonNull;
-
-pub extern "C" fn actions(
-    _: *mut purple_sys::PurplePlugin,
-    _: *mut c_void,
-) -> *mut glib_sys::GList {
-    std::ptr::null_mut()
-}
-
-pub extern "C" fn load<P: traits::LoadHandler>(plugin_ptr: *mut purple_sys::PurplePlugin) -> i32 {
-    match catch_unwind(|| {
-        debug!("load");
-        let mut plugin = unsafe { Plugin::from_raw(plugin_ptr) };
-        let prpl_plugin = unsafe { plugin.extra::<P>() };
-        prpl_plugin.load(&plugin) as i32
-    }) {
-        Ok(r) => r,
-        Err(_) => 0,
-    }
-}
-
-pub extern "C" fn login<P: traits::LoginHandler>(account_ptr: *mut purple_sys::PurpleAccount) {
-    if let Err(error) = catch_unwind(|| {
-        debug!("login");
-        let mut account = unsafe { Account::from_raw(account_ptr) };
-        let mut plugin = account
-            .get_connection()
-            .expect("No connection found for account")
-            .get_protocol_plugin()
-            .expect("No plugin found for connection");
-        let prpl_plugin = unsafe { plugin.extra::<P>() };
-        prpl_plugin.login(&mut account);
-    }) {
-        error!("Failure in login: {:?}", error)
-    };
-}
-
-pub extern "C" fn get_cb_alias<P: traits::GetChatBuddyAlias>(
-    connection_ptr: *mut purple_sys::PurpleConnection,
-    id: i32,
-    c_who: *const c_char,
-) -> *mut c_char {
-    match catch_unwind(|| {
-        debug!("get_cb_alias");
-        let mut connection = unsafe { Connection::from_raw(connection_ptr).unwrap() };
-        let mut plugin = connection
-            .get_protocol_plugin()
-            .expect("No plugin found for connection");
-        let prpl_plugin = unsafe { plugin.extra::<P>() };
-        let who = unsafe { CStr::from_ptr(c_who).to_str().unwrap() };
-        prpl_plugin
-            .get_cb_alias(&mut connection, id, who)
-            .as_ref()
-            .map(ToGlibPtr::to_glib_full)
-            .unwrap_or_else(std::ptr::null_mut)
-    }) {
-        Ok(r) => r,
-        Err(error) => {
-            error!("Failure in get_cb_alias: {:?}", error);
-            std::ptr::null_mut()
-        }
-    }
-}
-
-pub extern "C" fn chat_info<P: traits::ChatInfoHandler>(
-    connection_ptr: *mut purple_sys::PurpleConnection,
-) -> *mut glib_sys::GList {
-    match catch_unwind(|| {
-        debug!("chat_info");
-        let mut connection = unsafe { Connection::from_raw(connection_ptr).unwrap() };
-        let mut plugin = connection
-            .get_protocol_plugin()
-            .expect("No plugin found for connection");
-        let prpl_plugin = unsafe { plugin.extra::<P>() };
-        ToGlibContainerFromSlice::to_glib_full_from_slice(
-            &prpl_plugin
-                .chat_info(&mut connection)
-                .into_iter()
-                .map(|x| x.into())
-                .collect::<Vec<prpl::ProtoChatEntry>>(),
-        )
-    }) {
-        Ok(r) => r,
-        Err(error) => {
-            error!("Failure in chat_info: {:?}", error);
-            std::ptr::null_mut()
-        }
-    }
-}
-
-pub extern "C" fn close<P: traits::CloseHandler>(
-    connection_ptr: *mut purple_sys::PurpleConnection,
-) {
-    if let Err(error) = catch_unwind(|| {
-        debug!("close");
-        let mut connection = unsafe { Connection::from_raw(connection_ptr).unwrap() };
-        let mut plugin = connection
-            .get_protocol_plugin()
-            .expect("No plugin found for connection");
-        let prpl_plugin = unsafe { plugin.extra::<P>() };
-        prpl_plugin.close(&mut connection)
-    }) {
-        error!("Failure in close: {:?}", error)
-    }
-}
-
-pub extern "C" fn list_icon<P: traits::ListIconHandler>(
-    account_ptr: *mut purple_sys::PurpleAccount,
-    _: *mut purple_sys::PurpleBuddy,
-) -> *const c_char {
-    match catch_unwind(|| {
-        debug!("list_icon");
-        let mut account = unsafe { Account::from_raw(account_ptr) };
-        P::list_icon(&mut account).as_ptr()
-    }) {
-        Ok(r) => r,
-        Err(error) => {
-            error!("Failure in list_icon: {:?}", error);
-            std::ptr::null_mut()
-        }
-    }
-}
-
-pub extern "C" fn status_types<P: traits::StatusTypeHandler>(
-    account_ptr: *mut purple_sys::PurpleAccount,
-) -> *mut glib_sys::GList {
-    match catch_unwind(|| {
-        debug!("status_types");
-        let mut account = unsafe { Account::from_raw(account_ptr) };
-        ToGlibContainerFromIterator::into_glib_full_from_iter(P::status_types(&mut account))
-    }) {
-        Ok(r) => r,
-        Err(error) => {
-            error!("Failure in status_types: {:?}", error);
-            std::ptr::null_mut()
-        }
-    }
-}
-
-pub extern "C" fn join_chat<P: traits::JoinChatHandler>(
-    connection_ptr: *mut purple_sys::PurpleConnection,
-    components: *mut glib_sys::GHashTable,
-) {
-    if let Err(error) = catch_unwind(|| {
-        debug!("join_chat");
-        let mut connection = unsafe { Connection::from_raw(connection_ptr).unwrap() };
-        let mut plugin = connection
-            .get_protocol_plugin()
-            .expect("No plugin found for connection");
-        let prpl_plugin = unsafe { plugin.extra::<P>() };
-        let mut data = unsafe { StrHashTable::from_ptr(components) };
-        prpl_plugin.join_chat(&mut connection, data.as_mut())
-    }) {
-        error!("Failure in join_chat: {:?}", error)
-    }
-}
-
-pub extern "C" fn chat_leave<P: traits::ChatLeaveHandler>(
-    connection_ptr: *mut purple_sys::PurpleConnection,
-    id: i32,
-) {
-    if let Err(error) = catch_unwind(|| {
-        debug!("chat_leave");
-        let mut connection = unsafe { Connection::from_raw(connection_ptr).unwrap() };
-        let mut plugin = connection
-            .get_protocol_plugin()
-            .expect("No plugin found for connection");
-        let prpl_plugin = unsafe { plugin.extra::<P>() };
-        prpl_plugin.chat_leave(&mut connection, id)
-    }) {
-        error!("Failure in chat_leave: {:?}", error)
-    }
-}
-
-pub extern "C" fn convo_closed<P: traits::ConvoClosedHandler>(
-    connection_ptr: *mut purple_sys::PurpleConnection,
-    c_who: *const c_char,
-) {
-    if let Err(error) = catch_unwind(|| {
-        debug!("convo_closed");
-        let mut connection = unsafe { Connection::from_raw(connection_ptr).unwrap() };
-        let mut plugin = connection
-            .get_protocol_plugin()
-            .expect("No plugin found for connection");
-        let prpl_plugin = unsafe { plugin.extra::<P>() };
-        let who = NonNull::new(c_who as *mut _)
-            .map(|p| unsafe { CStr::from_ptr(p.as_ptr()).to_str().unwrap() });
-        prpl_plugin.convo_closed(&mut connection, who)
-    }) {
-        error!("Failure in convo_closed: {:?}", error)
-    }
-}
-
-pub extern "C" fn get_chat_name<P: traits::GetChatNameHandler>(
-    data: *mut glib_sys::GHashTable,
-) -> *mut c_char {
-    match catch_unwind(|| {
-        debug!("get_chat_name");
-        let mut data = unsafe { StrHashTable::from_ptr(data) };
-        let name = P::get_chat_name(data.as_mut());
-        name.to_glib_full()
-    }) {
-        Ok(r) => r,
-        Err(error) => {
-            error!("Failure in get_chat_name: {:?}", error);
-            std::ptr::null_mut()
-        }
-    }
-}
-
-pub extern "C" fn chat_info_defaults<P: traits::ChatInfoDefaultsHandler>(
-    connection_ptr: *mut purple_sys::PurpleConnection,
-    c_chat_name: *const c_char,
-) -> *mut glib_sys::GHashTable {
-    match catch_unwind(|| {
-        debug!("chat_info_defaults_handler");
-        let mut connection = unsafe { Connection::from_raw(connection_ptr).unwrap() };
-        let mut plugin = connection
-            .get_protocol_plugin()
-            .expect("No plugin found for connection");
-        let prpl_plugin = unsafe { plugin.extra::<P>() };
-
-        let chat_name = NonNull::new(c_chat_name as *mut _)
-            .map(|p| unsafe { CStr::from_ptr(p.as_ptr()).to_string_lossy() });
-        prpl_plugin
-            .chat_info_defaults(&mut connection, chat_name.as_deref())
-            .into_glib_full()
-    }) {
-        Ok(r) => r,
-        Err(error) => {
-            error!("Failure in chat_info_defaults: {:?}", error);
-            std::ptr::null_mut()
-        }
-    }
-}
-pub extern "C" fn roomlist_get_list_handler(
-    _: *mut purple_sys::PurpleConnection,
-) -> *mut purple_sys::PurpleRoomlist {
-    println!("roomlist_get_list_handler");
-    std::ptr::null_mut()
-}
-
-pub extern "C" fn chat_send<P: traits::ChatSendHandler>(
-    connection_ptr: *mut purple_sys::PurpleConnection,
-    id: i32,
-    c_message: *const c_char,
-    flags: PurpleMessageFlags,
-) -> i32 {
-    match catch_unwind(|| {
-        debug!("convo_closed");
-        let mut connection = unsafe { Connection::from_raw(connection_ptr).unwrap() };
-        let mut plugin = connection
-            .get_protocol_plugin()
-            .expect("No plugin found for connection");
-        let prpl_plugin = unsafe { plugin.extra::<P>() };
-        let message = unsafe { CStr::from_ptr(c_message).to_str().unwrap() };
-        prpl_plugin.chat_send(&mut connection, id, message, flags)
-    }) {
-        Ok(r) => r,
-        Err(error) => {
-            error!("Failure in convo_closed: {:?}", error);
-            -1
-        }
-    }
-}
-pub extern "C" fn send_im<P: traits::SendIMHandler>(
-    connection_ptr: *mut purple_sys::PurpleConnection,
-    c_who: *const c_char,
-    c_message: *const c_char,
-    flags: PurpleMessageFlags,
-) -> i32 {
-    match catch_unwind(|| {
-        debug!("convo_closed");
-        let mut connection = unsafe { Connection::from_raw(connection_ptr).unwrap() };
-        let mut plugin = connection
-            .get_protocol_plugin()
-            .expect("No plugin found for connection");
-        let prpl_plugin = unsafe { plugin.extra::<P>() };
-        let who = unsafe { CStr::from_ptr(c_who).to_str().unwrap() };
-        let message = unsafe { CStr::from_ptr(c_message).to_str().unwrap() };
-        prpl_plugin.send_im(&mut connection, who, message, flags)
-    }) {
-        Ok(r) => r,
-        Err(error) => {
-            error!("Failure in convo_closed: {:?}", error);
-            -1
-        }
-    }
-}

src/purple/handlers/mod.rs

@@ -1,2 +0,0 @@
-pub mod entrypoints;
-pub mod traits;

src/purple/handlers/traits.rs

@@ -1,116 +0,0 @@
-use super::super::{
-    prpl, Account, Connection, Conversation, Plugin, PurpleMessageFlags, StatusType, StrHashTable,
-};
-use std::ffi::CStr;
-
-pub trait LoadHandler {
-    fn load(&mut self, plugin: &Plugin) -> bool;
-}
-
-pub trait LoginHandler {
-    fn login(&mut self, account: &mut Account);
-}
-
-pub trait CloseHandler {
-    fn close(&mut self, connection: &mut Connection);
-}
-
-pub trait StatusTypeHandler {
-    fn status_types(account: &mut Account) -> Vec<StatusType>;
-}
-
-pub trait ListIconHandler {
-    fn list_icon(account: &mut Account) -> &'static CStr;
-}
-
-pub trait ChatInfoHandler {
-    fn chat_info(&mut self, connection: &mut Connection) -> Vec<prpl::ChatEntry>;
-}
-
-pub trait ChatInfoDefaultsHandler {
-    fn chat_info_defaults(
-        &mut self,
-        connection: &mut Connection,
-        chat_name: Option<&str>,
-    ) -> StrHashTable;
-}
-
-pub trait JoinChatHandler {
-    fn join_chat(&mut self, connection: &mut Connection, data: Option<&mut StrHashTable>);
-}
-
-pub trait ChatLeaveHandler {
-    fn chat_leave(&mut self, connection: &mut Connection, id: i32);
-}
-
-pub trait ConvoClosedHandler {
-    fn convo_closed(&mut self, connection: &mut Connection, who: Option<&str>);
-}
-
-pub trait GetChatBuddyAlias {
-    fn get_cb_alias(&mut self, connection: &mut Connection, id: i32, who: &str) -> Option<String>;
-}
-
-pub trait GetChatNameHandler {
-    fn get_chat_name(data: Option<&mut StrHashTable>) -> Option<String>;
-}
-
-pub trait SendIMHandler {
-    fn send_im(
-        &mut self,
-        connection: &mut Connection,
-        who: &str,
-        message: &str,
-        flags: PurpleMessageFlags,
-    ) -> i32;
-}
-
-pub trait ChatSendHandler {
-    fn chat_send(
-        &mut self,
-        connection: &mut Connection,
-        id: i32,
-        message: &str,
-        flags: PurpleMessageFlags,
-    ) -> i32;
-}
-
-pub trait InputHandler {
-    fn input(&mut self, fd: i32, cond: crate::purple::PurpleInputCondition);
-    fn enable_input(&mut self, fd: i32, cond: crate::purple::PurpleInputCondition) -> u32
-    where
-        Self: 'static,
-    {
-        let self_ptr: *mut Self = self;
-        crate::purple::input_add(fd, cond, move |fd, cond| {
-            let this = unsafe { &mut *self_ptr };
-            this.input(fd, cond);
-        })
-    }
-
-    fn disable_input(&self, input_handle: u32) -> bool {
-        unsafe { purple_sys::purple_input_remove(input_handle) != 0 }
-    }
-}
-
-pub trait CommandHandler {
-    fn command(
-        &mut self,
-        conversation: &mut Conversation,
-        command: &str,
-        args: &[&str],
-    ) -> purple_sys::PurpleCmdRet;
-    fn enable_command(&mut self, cmd: &str, args: &str, help_text: &str) -> purple_sys::PurpleCmdId
-    where
-        Self: 'static,
-    {
-        let self_ptr: *mut Self = self;
-        crate::purple::register_cmd(cmd, args, help_text, move |conversation, cmd, args| {
-            let this = unsafe { &mut *self_ptr };
-            this.command(conversation, cmd, args)
-        })
-    }
-    fn disable_command(&self, command_id: purple_sys::PurpleCmdId) {
-        unsafe { purple_sys::purple_cmd_unregister(command_id) }
-    }
-}

src/purple/hashtable.rs

@@ -1,71 +0,0 @@
-use super::ffi::{mut_override, AsPtr};
-use glib::translate::{FromGlib, FromGlibPtrContainer, ToGlibPtr};
-use std::ffi::CStr;
-use std::os::raw::{c_char, c_void};
-use std::ptr::NonNull;
-
-pub type StrHashTable<'a> = HashTable<&'static CStr, &'a str>;
-
-pub struct HashTable<K, V>(
-    NonNull<glib_sys::GHashTable>,
-    std::marker::PhantomData<(K, V)>,
-);
-
-impl Default for HashTable<&'static CStr, &str> {
-    fn default() -> Self {
-        Self(
-            NonNull::new(unsafe {
-                glib_sys::g_hash_table_new_full(
-                    Some(glib_sys::g_str_hash),
-                    Some(glib_sys::g_str_equal),
-                    None,
-                    Some(glib_sys::g_free),
-                )
-            })
-            .unwrap(),
-            std::marker::PhantomData,
-        )
-    }
-}
-
-impl HashTable<&'static CStr, &str> {
-    pub unsafe fn from_ptr(ptr: *mut glib_sys::GHashTable) -> Option<Self> {
-        NonNull::new(ptr).map(|p| Self(p, std::marker::PhantomData))
-    }
-
-    pub fn insert(&mut self, key: &'static CStr, value: &str) -> bool {
-        FromGlib::from_glib(unsafe {
-            glib_sys::g_hash_table_insert(
-                self.0.as_ptr(),
-                key.as_ptr() as *mut c_void,
-                ToGlibPtr::<*mut c_char>::to_glib_full(value) as *mut c_void,
-            )
-        })
-    }
-
-    pub fn lookup(&self, key: &'static CStr) -> Option<&str> {
-        unsafe {
-            NonNull::new(glib_sys::g_hash_table_lookup(
-                mut_override(self.as_ptr()),
-                key.as_ptr() as *const c_void,
-            ) as *mut c_char)
-            .map(|p| CStr::from_ptr(p.as_ptr()).to_str().unwrap())
-        }
-    }
-}
-
-impl<K, V> std::fmt::Debug for HashTable<K, V> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        use std::collections::HashMap;
-        let hashmap: HashMap<String, String> =
-            unsafe { FromGlibPtrContainer::from_glib_none(self.0.as_ptr()) };
-        write!(f, "HashTable({:?})", hashmap)
-    }
-}
-
-impl<K, V> AsPtr for HashTable<K, V> {
-    type PtrType = glib_sys::GHashTable;
-    fn as_ptr(&self) -> *const Self::PtrType {
-        self.0.as_ptr()
-    }
-}

src/purple/loader.rs

@@ -1,219 +0,0 @@
-use super::handlers::entrypoints;
-use crate::purple::PrplPlugin;
-use log::info;
-use std::ffi::CString;
-use std::marker::PhantomData;
-use std::os::raw::c_void;
-
-#[derive(Default)]
-pub struct RegisterContext<P> {
-    info: Box<purple_sys::PurplePluginInfo>,
-    extra_info: Box<purple_sys::PurplePluginProtocolInfo>,
-    _phantom_marker: PhantomData<P>,
-}
-
-impl<P> RegisterContext<P> {
-    pub fn new() -> Self {
-        RegisterContext {
-            info: Box::new(purple_sys::PurplePluginInfo::default()),
-            extra_info: Box::new(purple_sys::PurplePluginProtocolInfo::default()),
-            _phantom_marker: PhantomData,
-        }
-    }
-    pub fn into_raw(mut self) -> *mut purple_sys::PurplePluginInfo {
-        self.extra_info.roomlist_get_list = Some(entrypoints::roomlist_get_list_handler);
-
-        // If any protocol options have been set, they are back to front, so
-        // reverse the list now
-        unsafe {
-            self.extra_info.protocol_options =
-                glib_sys::g_list_reverse(self.extra_info.protocol_options);
-        }
-
-        self.info.extra_info = Box::into_raw(self.extra_info) as *mut c_void;
-
-        Box::into_raw(self.info)
-    }
-
-    pub fn with_info(mut self, info: PrplInfo) -> Self {
-        self.info.id = CString::new(info.id).unwrap().into_raw();
-        self.info.name = CString::new(info.name).unwrap().into_raw();
-        self.info.version = CString::new(info.version).unwrap().into_raw();
-        self.info.summary = CString::new(info.summary).unwrap().into_raw();
-        self.info.description = CString::new(info.description).unwrap().into_raw();
-        self.info.author = CString::new(info.author).unwrap().into_raw();
-        self.info.homepage = CString::new(info.homepage).unwrap().into_raw();
-        self.info.actions = Some(entrypoints::actions);
-        self
-    }
-
-    pub fn with_password(mut self) -> Self {
-        // purple_sys defaults extra_info.options to contain:
-        // OPT_PROTO_NO_PASSWORD | OPT_PROTO_IM_IMAGE | OPT_PROTO_CHAT_TOPIC
-        // All we have to do is remove the no_password one.
-        self.extra_info.options = purple_sys::PurpleProtocolOptions::OPT_PROTO_IM_IMAGE
-            | purple_sys::PurpleProtocolOptions::OPT_PROTO_CHAT_TOPIC;
-
-        self
-    }
-
-    fn with_option(mut self, option: PrplOption) -> Self {
-        let mut list: *mut glib_sys::GList = self.extra_info.protocol_options;
-        unsafe {
-            let ptr: *mut purple_sys::PurpleAccountOption = match option.def {
-                PrplOptionValue::String(def) => purple_sys::purple_account_option_string_new(
-                    CString::new(option.text).unwrap().into_raw(),
-                    CString::new(option.key).unwrap().into_raw(),
-                    CString::new(def).unwrap().into_raw(),
-                ),
-                PrplOptionValue::Bool(def) => purple_sys::purple_account_option_bool_new(
-                    CString::new(option.text).unwrap().into_raw(),
-                    CString::new(option.key).unwrap().into_raw(),
-                    def.into(),
-                ),
-            };
-
-            purple_sys::purple_account_option_set_masked(ptr, option.masked.into());
-
-            list = glib_sys::g_list_prepend(list, glib::translate::Ptr::to(ptr));
-        }
-
-        self.extra_info.protocol_options = list;
-
-        self
-    }
-
-    pub fn with_string_option(mut self, name: String, key: String, def: String) -> Self {
-        self.with_option(PrplOption {
-            text: name,
-            key: key,
-            def: PrplOptionValue::String(def),
-            masked: false,
-        })
-    }
-
-    pub fn with_password_option(mut self, name: String, key: String, def: String) -> Self {
-        self.with_option(PrplOption {
-            text: name,
-            key: key,
-            def: PrplOptionValue::String(def),
-            masked: true,
-        })
-    }
-
-    pub fn with_bool_option(mut self, name: String, key: String, def: bool) -> Self {
-        self.with_option(PrplOption {
-            text: name,
-            key: key,
-            def: PrplOptionValue::Bool(def),
-            masked: false,
-        })
-    }
-}
-
-pub struct PrplPluginLoader<P: PrplPlugin>(*mut purple_sys::PurplePlugin, PhantomData<P>);
-
-impl<P: PrplPlugin> PrplPluginLoader<P> {
-    pub unsafe fn from_raw(ptr: *mut purple_sys::PurplePlugin) -> Self {
-        Self(ptr, PhantomData)
-    }
-
-    pub fn init(&self) -> i32 {
-        let prpl_plugin = Box::new(P::new());
-        let register_context: RegisterContext<P::Plugin> = RegisterContext::new();
-        let register_context = prpl_plugin.register(register_context);
-
-        // Unsafe required to dereference the pointers and call
-        // purple_plugin_register. Safe otherwise.
-        unsafe {
-            (*self.0).info = register_context.into_raw();
-            (*self.0).extra = Box::into_raw(prpl_plugin) as *mut c_void;
-
-            info!("Registering");
-            purple_sys::purple_plugin_register(self.0)
-        }
-    }
-}
-
-pub struct PrplInfo {
-    pub id: String,
-    pub name: String,
-    pub version: String,
-    pub summary: String,
-    pub description: String,
-    pub author: String,
-    pub homepage: String,
-}
-
-enum PrplOptionValue {
-    Bool(bool),
-    String(String),
-}
-
-struct PrplOption {
-    text: String,
-    key: String,
-    def: PrplOptionValue,
-    masked: bool,
-}
-
-impl Default for PrplInfo {
-    fn default() -> Self {
-        PrplInfo {
-            id: "".into(),
-            name: "".into(),
-            version: "".into(),
-            summary: "".into(),
-            description: "".into(),
-            author: "".into(),
-            homepage: "".into(),
-        }
-    }
-}
-
-macro_rules! impl_handler_builder {
-    ($($f:ident => $t:ident)*) => ($(
-        paste::item! {
-            impl<T: crate::purple::handlers::traits::[<$t>]> RegisterContext<T> {
-                #[allow(dead_code)]
-                pub fn [<enable_$f>](mut self) -> Self {
-                    self.info.[<$f>] = Some(crate::purple::handlers::entrypoints::[<$f>]::<T>);
-                    self
-                }
-            }
-        }
-    )*)
-}
-
-macro_rules! impl_extra_handler_builder {
-    ($($f:ident => $t:ident)*) => ($(
-        paste::item! {
-            impl<T: crate::purple::handlers::traits::[<$t>]> RegisterContext<T> {
-                #[allow(dead_code)]
-                pub fn [<enable_$f>](mut self) -> Self {
-                    self.extra_info.[<$f>] = Some(crate::purple::handlers::entrypoints::[<$f>]::<T>);
-                    self
-                }
-            }
-        }
-    )*)
-}
-
-impl_handler_builder! {
-    load => LoadHandler
-}
-
-impl_extra_handler_builder! {
-    login => LoginHandler
-    chat_info => ChatInfoHandler
-    chat_info_defaults => ChatInfoDefaultsHandler
-    close => CloseHandler
-    status_types => StatusTypeHandler
-    list_icon => ListIconHandler
-    join_chat => JoinChatHandler
-    chat_leave => ChatLeaveHandler
-    convo_closed => ConvoClosedHandler
-    get_chat_name => GetChatNameHandler
-    send_im => SendIMHandler
-    chat_send => ChatSendHandler
-}

src/purple/mod.rs

@@ -1,150 +0,0 @@
-pub use self::account::Account;
-pub use self::blist::BlistNode;
-pub use self::chat::Chat;
-pub use self::connection::protocol_data::ProtocolData;
-pub use self::connection::{Connection, Connections, Handle};
-pub use self::conversation::Conversation;
-pub use self::group::Group;
-pub use self::handlers::traits::*;
-pub use self::hashtable::StrHashTable;
-pub use self::loader::{PrplInfo, PrplPluginLoader, RegisterContext};
-pub use self::plugin::Plugin;
-pub use self::status_type::{PurpleStatusPrimitive, StatusType};
-use glib::translate::FromGlibPtrContainer;
-pub use purple_sys;
-pub use purple_sys::{
-    PurpleCmdId, PurpleCmdRet, PurpleConnectionError, PurpleConnectionState,
-    PurpleConvChatBuddyFlags, PurpleConversationType, PurpleDebugLevel, PurpleInputCondition,
-    PurpleMessageFlags,
-};
-use std::ffi::{CStr, CString};
-use std::os::raw::{c_char, c_void};
-use std::panic::catch_unwind;
-use std::ptr;
-
-lazy_static::lazy_static! {
-    static ref STR_FORMAT: CString = CString::new("%s").unwrap();
-}
-
-pub mod account;
-mod blist;
-mod chat;
-mod connection;
-mod conversation;
-pub mod ffi;
-mod group;
-mod handlers;
-mod hashtable;
-mod loader;
-mod plugin;
-pub mod prpl;
-mod status_type;
-
-pub trait PrplPlugin {
-    type Plugin;
-    fn new() -> Self;
-    fn register(&self, context: RegisterContext<Self::Plugin>) -> RegisterContext<Self::Plugin>;
-}
-
-macro_rules! purple_prpl_plugin {
-    ($plugin:ty) => {
-        /// # Safety
-        /// This function is the plugin entrypoints and should not be called manually.
-        #[no_mangle]
-        pub unsafe extern "C" fn purple_init_plugin(
-            plugin_ptr: *mut purple_sys::PurplePlugin,
-        ) -> i32 {
-            // Safe as long as called from libpurple. Should be the
-            // case since this function is called by libpurple.
-            let plugin = purple::PrplPluginLoader::<$plugin>::from_raw(plugin_ptr);
-            plugin.init()
-        }
-    };
-}
-
-pub fn input_add<F>(fd: i32, cond: PurpleInputCondition, callback: F) -> u32
-where
-    F: Fn(i32, PurpleInputCondition) + 'static,
-{
-    let user_data = Box::into_raw(Box::new(callback)) as *mut c_void;
-    unsafe { purple_sys::purple_input_add(fd, cond, Some(trampoline::<F>), user_data) }
-}
-
-unsafe extern "C" fn trampoline<F>(user_data: *mut c_void, df: i32, cond: PurpleInputCondition)
-where
-    F: Fn(i32, PurpleInputCondition),
-{
-    if let Err(error) = catch_unwind(|| {
-        let closure = &*(user_data as *mut F);
-        closure(df, cond);
-    }) {
-        log::error!("Failure in input handler: {:?}", error);
-    }
-}
-
-pub fn register_cmd<F>(
-    cmd: &str,
-    args: &str,
-    help_text: &str,
-    callback: F,
-) -> purple_sys::PurpleCmdId
-where
-    F: Fn(&mut Conversation, &str, &[&str]) -> purple_sys::PurpleCmdRet + 'static,
-{
-    let user_data = Box::into_raw(Box::new(callback)) as *mut c_void;
-    let c_cmd = CString::new(cmd).unwrap();
-    let c_args = CString::new(args).unwrap();
-    let c_help = CString::new(help_text).unwrap();
-
-    unsafe {
-        purple_sys::purple_cmd_register(
-            c_cmd.as_ptr(),
-            c_args.as_ptr(),
-            purple_sys::PurpleCmdPriority::PURPLE_CMD_P_DEFAULT,
-            purple_sys::PurpleCmdFlag::PURPLE_CMD_FLAG_CHAT,
-            ptr::null(),
-            Some(trampoline_cmd::<F>),
-            c_help.as_ptr(),
-            user_data,
-        )
-    }
-}
-
-unsafe extern "C" fn trampoline_cmd<F>(
-    conversation_ptr: *mut purple_sys::PurpleConversation,
-    c_cmd: *const c_char,
-    c_args: *mut *mut c_char,
-    _c_error: *mut *mut c_char,
-    user_data: *mut c_void,
-) -> purple_sys::PurpleCmdRet
-where
-    F: Fn(&mut Conversation, &str, &[&str]) -> purple_sys::PurpleCmdRet,
-{
-    let closure = &*(user_data as *mut F);
-
-    let cmd = CStr::from_ptr(c_cmd).to_str().unwrap();
-    let args: Vec<String> = FromGlibPtrContainer::from_glib_none(c_args);
-    let mut conversation = Conversation::from_ptr(conversation_ptr).unwrap();
-
-    closure(
-        &mut conversation,
-        cmd,
-        args.iter()
-            .map(std::ops::Deref::deref)
-            .collect::<Vec<&str>>()
-            .as_slice(),
-    )
-}
-
-pub fn debug(level: PurpleDebugLevel, target: &str, message: &str) {
-    let c_target = CString::new(target).unwrap();
-    let c_message = CString::new(message).unwrap();
-    unsafe {
-        purple_sys::purple_debug(
-            level,
-            c_target.as_ptr(),
-            STR_FORMAT.as_ptr(),
-            c_message.as_ptr(),
-        )
-    }
-}

src/purple/plugin.rs

@@ -1,11 +0,0 @@
-pub struct Plugin(*mut purple_sys::PurplePlugin);
-
-impl Plugin {
-    pub unsafe fn from_raw(ptr: *mut purple_sys::PurplePlugin) -> Self {
-        Plugin(ptr)
-    }
-
-    pub unsafe fn extra<'a, T>(&mut self) -> &'a mut T {
-        &mut *((*self.0).extra as *mut T)
-    }
-}

src/purple/prpl.rs

@@ -1,50 +0,0 @@
-use glib::translate::{GlibPtrDefault, Stash, ToGlib, ToGlibPtr};
-use std::ffi::CStr;
-
-pub struct ChatEntry {
-    pub label: &'static CStr,
-    pub identifier: &'static CStr,
-    pub required: bool,
-    pub is_int: bool,
-    pub min: i32,
-    pub max: i32,
-    pub secret: bool,
-}
-
-pub struct ProtoChatEntry(purple_sys::proto_chat_entry);
-
-impl Into<ProtoChatEntry> for ChatEntry {
-    fn into(self) -> ProtoChatEntry {
-        ProtoChatEntry(purple_sys::proto_chat_entry {
-            label: self.label.as_ptr(),
-            identifier: self.identifier.as_ptr(),
-            required: self.required.to_glib(),
-            is_int: self.is_int.to_glib(),
-            min: self.min,
-            max: self.max,
-            secret: self.secret.to_glib(),
-        })
-    }
-}
-
-impl GlibPtrDefault for ProtoChatEntry {
-    type GlibType = *const purple_sys::proto_chat_entry;
-}
-
-impl<'a> ToGlibPtr<'a, *const purple_sys::proto_chat_entry> for ProtoChatEntry {
-    type Storage = &'a ProtoChatEntry;
-
-    fn to_glib_none(&'a self) -> Stash<'a, *const purple_sys::proto_chat_entry, Self> {
-        Stash(&self.0 as *const purple_sys::proto_chat_entry, self)
-    }
-
-    fn to_glib_full(&self) -> *const purple_sys::proto_chat_entry {
-        unsafe {
-            let res = glib_sys::g_malloc(std::mem::size_of::<purple_sys::proto_chat_entry>())
-                as *mut purple_sys::proto_chat_entry;
-
-            *res = self.0;
-            res
-        }
-    }
-}

src/purple/status_type.rs

@@ -1,31 +0,0 @@
-use super::ffi::{mut_override, AsPtr};
-use glib::translate::ToGlib;
-pub use purple_sys::PurpleStatusPrimitive;
-use std::ffi::CStr;
-
-pub struct StatusType(*mut purple_sys::PurpleStatusType);
-
-impl StatusType {
-    pub fn new(
-        primitive: PurpleStatusPrimitive,
-        id: Option<&'static CStr>,
-        name: Option<&'static CStr>,
-        user_settable: bool,
-    ) -> Self {
-        unsafe {
-            Self(purple_sys::purple_status_type_new(
-                primitive,
-                id.map_or_else(std::ptr::null_mut, |s| mut_override(s.as_ptr())),
-                name.map_or_else(std::ptr::null_mut, |s| mut_override(s.as_ptr())),
-                user_settable.to_glib(),
-            ))
-        }
-    }
-}
-
-impl AsPtr for StatusType {
-    type PtrType = purple_sys::PurpleStatusType;
-    fn as_ptr(&self) -> *const Self::PtrType {
-        self.0
-    }
-}