ft.c

/*
 *  This file is part of mrim-prpl.
 *
 *  mrim-prpl 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 2 of the License, or
 *  (at your option) any later version.
 *
 *  mrim-prpl 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 mrim-prpl.  If not, see <http://www.gnu.org/licenses/>.
 */


#include "mrim.h"
#include "package.h"
#include "ft.h"

#include "sys/stat.h"
#include <libgen.h>
#include "stdbool.h"

gboolean mrim_can_send_file(PurpleConnection *gc, const char *who) {
	MrimData *mrim = gc->proto_data;
	g_return_val_if_fail(mrim != NULL, FALSE); // WHY: -1 warning.
	PurpleBuddy *buddy = purple_find_buddy(mrim->account, who);
	MrimBuddy *mb = buddy ? buddy->proto_data : NULL;
	if (mb) {
		return (mb->com_support & FEATURE_FLAG_FILE_TRANSFER);
	} else {
		return FALSE;
	}
}

PurpleXfer *mrim_new_xfer(PurpleConnection *gc, const char *who) {
	purple_debug_info("mrim-prpl", "[%s]\n", __func__);
	PurpleXfer *xfer;
	xfer = purple_xfer_new(gc->account, PURPLE_XFER_SEND, who);
	g_return_val_if_fail(xfer != NULL, NULL);
	MrimFT *data = g_new0(MrimFT, 1);
	xfer->data = data;
	data->mrim = gc->proto_data;
	data->user_name = g_strdup(who);
	purple_xfer_set_init_fnc(xfer, mrim_xfer_send_rq);
	purple_xfer_set_cancel_send_fnc(xfer, mrim_xfer_cancel);
	return xfer;
}

void mrim_send_file(PurpleConnection *gc, const char *who, const char *file) {
	PurpleXfer *xfer = mrim_new_xfer(gc, who);
	if (file) {
		purple_xfer_request_accepted(xfer, file);
	} else {
		purple_xfer_request(xfer);
	}
}


void mrim_xfer_got_rq(MrimPackage *pack, MrimData *mrim) {
	purple_debug_info("mrim-prpl", "[%s] MRIM_CS_FILE_TRANSFER\n", __func__);
	gchar *user_name = mrim_package_read_LPSA(pack);
	guint32 wtf = mrim_package_read_UL(pack); //Unknown field
	guint32 file_size = mrim_package_read_UL(pack);
	guint32 id = mrim_package_read_UL(pack);
	gchar *file_list = mrim_package_read_LPSA(pack);
	guint32 wtf2 = mrim_package_read_UL(pack); //Unknown field
	gchar *remote_ip = mrim_package_read_LPSA(pack);
	MrimFile *files = NULL;
	guint file_count;
	{
		gchar **parts = g_strsplit(file_list, ";", 0);
		guint i = 0;
        guint file_pair = 0;
		while (parts[file_pair] && parts[file_pair + 1]) {
			gchar *file_name = g_strdup(parts[file_pair]);
			guint32 f_size = atoi(parts[file_pair + 1]);
			files = realloc(files, (i + 1) * sizeof(MrimFile));
			files[i].name = file_name;
			files[i].size = f_size;
			i++;
            file_pair = i * 2;
		}
		file_count = i;
		g_strfreev(parts);
	}
	purple_debug_info("mrim-prpl", "[%s] MRIM_CS_FILE_TRANSFER: user_name = '%s', file_size = '%u', file_count = '%u', id='%u'\n", __func__, user_name, file_size, file_count, id);
	g_free(file_list);
	MrimFT *ft = g_new0(MrimFT, 1);
	ft->mrim = mrim;
	ft->user_name = user_name;
	ft->id = id;
	ft->remote_ip = remote_ip;
	ft->files = files;
	ft->count = file_count;
	mrim_process_xfer(ft);
}

void mrim_xfer_ack(MrimPackage *pack, MrimData *mrim) {
	purple_debug_info("mrim-prpl", "[%s] MRIM_CS_FILE_TRANSFER_ACK\n", __func__);
	guint32 status = mrim_package_read_UL(pack);
	gchar *user_name = mrim_package_read_LPSA(pack);
	guint32 id = mrim_package_read_UL(pack);
	gchar *remote_addr = mrim_package_read_LPSA(pack);
	purple_debug_info("mrim-prpl", "[%s] MRIM_CS_FILE_TRANSFER_ACK: status = %u, user_name = '%s', remote_addr = '%s'\n", __func__, status, user_name, remote_addr);
	PurpleXfer *xfer = g_hash_table_lookup(mrim->transfers, GUINT_TO_POINTER(id));
	if (xfer) {
		if (status == FILE_TRANSFER_MIRROR) {
			MrimFT *ft = xfer->data;
			purple_debug_info("mrim-prpl", "[%s] User='%s' accepted files! id='%xu'\n", __func__, user_name, id);
		//Допустим белого IP у нас нет и запросим зеркальный прокси TODO
			MrimPackage *ack = mrim_package_new(mrim->seq++, MRIM_CS_PROXY);
			mrim_package_add_LPSA(ack, user_name);
			mrim_package_add_UL(ack, id);
			mrim_package_add_UL(ack, MRIM_PROXY_TYPE_FILES);
			gchar *file_list = g_strdup_printf("%s;%u;", ft->files[0].name, ft->files[0].size);
			mrim_package_add_LPSA(ack, file_list);
			mrim_package_add_UL(ack, 0); // Много-
			mrim_package_add_UL(ack, 0); // много
			mrim_package_add_UL(ack, 0); // не
			mrim_package_add_UL(ack, 0); // нужных
			mrim_package_add_UL(ack, 0); // полей
			mrim_package_add_UL(ack, 4 + 4 + strlen(file_list) * 2); //Длина последующихъ данных
		// Судя по всему далее идёт повтор пакета, но в UTF16
			mrim_package_add_UL(ack, MRIM_PROXY_TYPE_FILES);
			mrim_package_add_LPSW(ack, file_list);
			mrim_package_add_UL(ack, 4); // Неизвестное поле
			mrim_package_add_UL(ack, 1); // Ещё одно неизвестно поле... Имеет смысл узнать, что это...
			mrim_package_send(ack, mrim);
		} else {
			purple_debug_info("mrim-prpl", "[%s] Transfer cancelled!\n", __func__);
			purple_xfer_unref(xfer);
		}
	}
	g_free(user_name);
	g_free(remote_addr);	
}

void mrim_xfer_proxy_ack(MrimPackage *pack, MrimData *mrim) {
	guint status = mrim_package_read_UL(pack);
	gchar *user_name = mrim_package_read_LPSA(pack);
	guint32 id = mrim_package_read_UL(pack);
	guint32 data_type = mrim_package_read_UL(pack);
	gchar *file_list = mrim_package_read_LPSA(pack);
	gchar *remote_ip = mrim_package_read_LPSA(pack);
	// В пакете есть ещё и другие поля, но они нам не нужны (*кроме proxy_id)
	g_return_if_fail(data_type != MRIM_PROXY_TYPE_FILES);
	PurpleXfer *xfer = g_hash_table_lookup(mrim->transfers, GUINT_TO_POINTER(id));
	if (xfer) {
		if (status == PROXY_STATUS_OK) {
			MrimFT *ft = xfer->data;
			purple_debug_info("mrim-prpl", "[%s] Proxy accepted! Address list = '%s'\n", __func__, remote_ip);
			gchar **addrs = g_strsplit(remote_ip, ";", 0);
			gchar **addr = addrs;
			gchar *ip = NULL;
			guint16 port;
			while (*addr) {
				gchar **parts = g_strsplit(*addr, ":", 2);
				ip = g_strdup(parts[0]);
				port = atoi(parts[1]);
				g_strfreev(parts);
				if (port != 443) { // Мы не умеем SSL ;D
					break;
				} else {
					g_free(ip);
				}
				addr++;
			}
			g_strfreev(addrs);
			purple_debug_info("mrim-prpl", "[%s] Proxy host = '%s', port = %u\n", __func__, ip, port);

			ft->proxy_id[0] = mrim_package_read_UL(pack);
			ft->proxy_id[1] = mrim_package_read_UL(pack);
			ft->proxy_id[2] = mrim_package_read_UL(pack);
			ft->proxy_id[3] = mrim_package_read_UL(pack);

			ft->proxy_conn = purple_proxy_connect(NULL, mrim->account, ip, port, mrim_send_xfer_connect_cb, ft);
		} else {
			purple_debug_info("mrim-prpl", "[%s] Proxy request failed!\n", __func__);
			purple_xfer_unref(xfer);
		}
	}
}

void mrim_xfer_connected(MrimFT *ft) {
	purple_debug_info("mrim-prpl", "[%s] Connected!\n", __func__);
}

void mrim_xfer_connect_cb(gpointer data, gint source, const gchar *error_message) {
	purple_debug_info("mrim-prpl", "[%s]\n", __func__);

	MrimFT *ft = data;
	ft->proxy_conn = NULL;
	
	if (source >= 0) {
		ft->conn = source;
		mrim_xfer_connected(ft);
	} else {
		//TODO: Connect with proxy
	}
}

void mrim_process_xfer(MrimFT *ft) {
	if (ft->current < ft->count) {
		/* PurpleXfer *xfer = purple_xfer_new(ft->mrim->gc->account, PURPLE_XFER_RECEIVE, ft->user_name);
		purple_xfer_set_filename(xfer, ft->files[ft->current].name);
		purple_xfer_set_size(xfer, ft->files[ft->current].size);
		purple_xfer_request(xfer); */
		//MrimPackage *pack = mrim_package_new(, );
		gchar **parts = g_strsplit(ft->remote_ip, ":", 2);
		//ft->proxy_conn = purple_proxy_connect(ft->mrim->gc, ft->mrim->account, parts[0], parts[1], mrim_xfer_connect_cb, ft);
	} else {
		g_free(ft->user_name);
		g_free(ft->remote_ip);
		guint i;
		for (i = 0; i < ft->count; i++) {
			g_free(ft->files[i].name);
		}
		g_free(ft->files);
		g_free(ft);
	}
}

void mrim_ft_send_input_cb(gpointer data, gint source, PurpleInputCondition cond) {
	purple_debug_info("mrim-prpl", "[%s]\n", __func__);
	g_return_if_fail(source >= 0);
	MrimFT *ft = data;
	switch (ft->state)
	{
		case WAITING_FOR_HELLO_ACK:
		{
			MrimPackage *pack = mrim_package_read(ft->fake_mrim);
			if ((pack == NULL) || (pack->header->msg != MRIM_CS_PROXY_HELLO_ACK)) {
				//Что-то пошло не так... надо уходить отсюда...
				purple_debug_info("mrim-prpl", "[%s] Something went wrong... This is FAIL!\n", __func__);
				purple_input_remove(ft->inpa);
				close(ft->conn);
				purple_xfer_unref(ft->xfer);
				mrim_package_free(pack);
				return;
			} else {
				mrim_package_free(pack);
				purple_debug_info("mrim-prpl", "[%s] MRIM_CS_PROXY_HELLO_ACK received!\n", __func__);
				purple_debug_info("mrim-prpl", "[%s] MRIM_CS_PROXY_HELLO_ACK received!\n", __func__);
			}
			//
			g_free(ft->fake_mrim);
			ft->fake_mrim = NULL;
			//
			ft->state = WAITING_FOR_FT_HELLO;
			//
			gchar *buffer = g_strdup_printf("MRA_FT_HELLO %s", ft->mrim->user_name);
			if (send(ft->conn, buffer, strlen(buffer) + 1, 0) >= (strlen(buffer) + 1)) {
				purple_debug_info("mrim-prpl", "[%s] '%s' sent!\n", __func__, buffer);
			} else {
				purple_debug_info("mrim-prpl", "[%s] Failed to send MRA_FT_HELLO!\n", __func__);
				purple_xfer_unref(ft->xfer);
			}
			g_free(buffer);
			break;
		}
		case WAITING_FOR_FT_HELLO:
		{
			// we should read 'MRA_FT_HELLO user\0'
			gchar *buffer		= NULL;
			gchar buf_prev	= NULL;
			guint i = 0;
			do {
				buffer = realloc(buffer, i + 1);
				if (i) {
					buf_prev = buffer[i-1];
				}
				recv(ft->conn, &buffer[i], sizeof(gchar), 0);
				//purple_debug_info("mrim-prpl", "[%s] Received string: %s\n", __func__, buffer);
				i++;
			} while (buffer[i] || buf_prev);
			purple_debug_info("mrim-prpl", "[%s] Received string: %s\n", __func__, buffer);
			
			// wait for 'WAITING_FOR_FT_GET file_name'
			ft->state = WAITING_FOR_FT_GET;
			break;
		}
		case WAITING_FOR_FT_GET:
		{
			purple_debug_info("mrim-prpl", "[%s] FT: WAITING_FOR_FT_GET\n", __func__);
			// we should read 'WAITING_FOR_FT_GET file_name\0'
			gchar *buffer = NULL;
			gchar buf_prev	= NULL;
			guint i = 0;
			do {
				buffer = realloc(buffer, i + 1);
				if (i) {
					buf_prev = buffer[i-1];
				}
				recv(ft->conn, &buffer[i], sizeof(gchar), 0);
				//purple_debug_info("mrim-prpl", "[%s] Received string: %s\n", __func__, buffer);
				i++;
			} while (buffer[i] || buf_prev);
			purple_debug_info("mrim-prpl", "[%s] Received string: %s\n", __func__, buffer);
			ft->state = STREAMING_FT_FILE;
			// TODO
			break;
		}
	}
}

void mrim_send_xfer_connect_cb(gpointer data, gint source, const gchar *error_message) {
	purple_debug_info("mrim-prpl", "[%s]\n", __func__);
	MrimFT *ft = data;
	ft->proxy_conn = NULL;
	if (source >= 0) {
		purple_debug_info("mrim-prpl", "[%s] Connected!\n", __func__);
		ft->conn = source;
		ft->state = WAITING_FOR_HELLO_ACK;
		MrimData *mrim  = ft->mrim;
		MrimData *fake_mrim = g_new0(MrimData, 1);
		fake_mrim->fd = source;
		ft->fake_mrim = fake_mrim;
		MrimPackage *pack = mrim_package_new(0, MRIM_CS_PROXY_HELLO);
		pack->header->proto = 0x00010009;
		mrim_package_add_UL(pack, ft->proxy_id[0]);
		mrim_package_add_UL(pack, ft->proxy_id[1]);
		mrim_package_add_UL(pack, ft->proxy_id[2]);
		mrim_package_add_UL(pack, ft->proxy_id[3]);

		if (mrim_package_send(pack, fake_mrim)) {
			ft->inpa = purple_input_add(ft->conn, PURPLE_INPUT_READ, mrim_ft_send_input_cb, ft);
			purple_debug_info("mrim-prpl", "[%s] MRIM_CS_PROXY_HELLO sent!\n", __func__);
		} else {
			purple_debug_info("mrim-prpl", "[%s] Failed to send MRIM_CS_PROXY_HELLO!\n", __func__);
			purple_xfer_unref(ft->xfer);
		}
	} else {
		purple_debug_info("mrim-prpl", "[%s] Fail!\n", __func__);
		purple_xfer_unref(ft->xfer);
	}
}

void mrim_xfer_send_rq(PurpleXfer *xfer) {
	gchar *file_name = purple_xfer_get_local_filename(xfer);
	purple_debug_info("mrim-prpl", "[%s] Sending file '%s'\n", __func__, file_name);
	MrimFT *mrim_ft = xfer->data;
	mrim_ft->xfer = xfer;
	mrim_ft->count = 1;
	mrim_ft->files = g_new0(MrimFT, 1);
	mrim_ft->files[0].name = basename(file_name); // TODO: strdup???
	{
		GRand *rnd = g_rand_new();
		mrim_ft->id = g_rand_int(rnd);
		g_rand_free(rnd);
	}
	{
		struct stat st;
		stat(file_name, &st);
		mrim_ft->files[0].size = st.st_size;
	}
	MrimData *mrim = mrim_ft->mrim;
	MrimPackage *pack = mrim_package_new(mrim->seq++, MRIM_CS_FILE_TRANSFER);
	mrim_package_add_LPSA(pack, mrim_ft->user_name);
	mrim_package_add_UL(pack, mrim_ft->id);
	mrim_package_add_UL(pack, mrim_ft->files[0].size);
	gchar *file_list = g_strdup_printf("%s;%u;", mrim_ft->files[0].name, mrim_ft->files[0].size);
	gchar *my_ip = "1.2.3.4:1234;"; // Заведомо некорректное значение, чтобы клиент обломался и пошёл использовать зеркальный прокси TODO
	mrim_package_add_UL(pack, 4 + strlen(file_list) + 4 + 4 + strlen(my_ip));
	mrim_package_add_LPSA(pack, file_list);
	mrim_package_add_UL(pack, 0);
	mrim_package_add_LPSA(pack, my_ip);
	//mrim_add_ack_cb(mrim, pack->header->seq, mrim_xfer_ack, xfer);
	g_hash_table_insert(mrim->transfers, GUINT_TO_POINTER(mrim_ft->id), xfer);
	mrim_package_send(pack, mrim);
}


void mrim_xfer_cancel(PurpleXfer *xfer) {
	purple_debug_info("mrim-prpl", "[%s]\n", __func__);
	MrimFT *ft = xfer->data;
	if (ft) {
		g_hash_table_remove(ft->mrim->transfers, GUINT_TO_POINTER(ft->id));
	}
}