transport.cpp

iptux是linux下面能实现类似windows里面飞鸽传书的功能

//
// C++ Implementation: Transport
//
// Description:
//
//
// Author: Jally <[e-mail]>, (C) 2008
//
// Copyright: See COPYING file that comes with this distribution
//
//
#include "Transport.h"
#include "Command.h"
#include "Pal.h"
#include "my_file.h"
#include "baling.h"
#include "utils.h"

 Transport::Transport():transport(NULL), trans_view(NULL), trans_model(NULL),
flag(0)
{
}

Transport::~Transport()
{
	if (transport)
		gtk_widget_destroy(transport);
	g_object_unref(trans_model);
}

void Transport::InitSelf()
{
	trans_model = CreateTransModel();
}

bool Transport::TransportActive()
{
	GtkTreeIter iter;
	gint terminate;

	if (!gtk_tree_model_get_iter_first(trans_model, &iter))
		return false;
	do {
		gtk_tree_model_get(trans_model, &iter, 8, &terminate, -1);
		if (terminate == 0)	//Runing(0)
			return true;
	} while (gtk_tree_model_iter_next(trans_model, &iter));
	return false;
}

void Transport::TransportEntry()
{
	extern Transport trans;

	if (trans.CheckExist())
		return;
	trans.CreateTransView();
	trans.CreateTransDialog();
}

void Transport::RecvFileEntry(GtkTreePath * path)
{
	extern Transport trans;
	GtkTreeIter iter;
	uint32_t fileattr;
	gboolean result;

	gdk_threads_enter();
	result = gtk_tree_model_get_iter(trans.trans_model, &iter, path);
	gtk_tree_path_free(path);
	if (!result) {
		gdk_threads_leave();
		return;
	}
	gtk_tree_model_get(trans.trans_model, &iter, 12, &fileattr, -1);
	gdk_threads_leave();
	switch (GET_MODE(fileattr)) {
	case IPMSG_FILE_REGULAR:
		trans.RecvFileData(&iter);
		break;
	case IPMSG_FILE_DIR:
		trans.RecvDirFiles(&iter);
		break;
	default:
		break;
	}
}

void Transport::SendFileEntry(int sock, GtkTreeIter * iter, uint32_t fileattr)
{
	extern Transport trans;

	gdk_threads_enter();
	TransportEntry();
	gdk_threads_leave();

	switch (GET_MODE(fileattr)) {
	case IPMSG_FILE_REGULAR:
		trans.SendFileData(sock, iter);
		break;
	case IPMSG_FILE_DIR:
		trans.SendDirFiles(sock, iter);
		break;
	default:
		break;
	}
}

//传输 15,0 status,1 task,2 filename,3 side,4 finishsize,5 filesize,6 rate,7 progress,
//      8 terminate,9 packetn,10 fileid,11 size,12 type,13,dst,14 data
//terminate,0 Runing,1 Over,-1 Interrupt
GtkTreeModel *Transport::CreateTransModel()
{
	GtkListStore *model;

	model = gtk_list_store_new(15,
				   GDK_TYPE_PIXBUF, G_TYPE_STRING,
				   G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
				   G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT,
				   G_TYPE_INT, G_TYPE_UINT, G_TYPE_UINT,
				   G_TYPE_UINT, G_TYPE_UINT, G_TYPE_STRING,
				   G_TYPE_POINTER);

	return GTK_TREE_MODEL(model);
}

bool Transport::CheckExist()
{
	if (!transport)
		return false;
	gtk_window_present(GTK_WINDOW(transport));
	return true;
}

void Transport::CreateTransView()
{
	GtkCellRenderer *renderer;
	GtkTreeViewColumn *column;

	trans_view = gtk_tree_view_new_with_model(trans_model);
	g_signal_connect(trans_view, "button-press-event",
			 G_CALLBACK(PopupControlMenu), this);
	gtk_widget_show(trans_view);

	column = gtk_tree_view_column_new();
	gtk_tree_view_column_set_resizable(column, TRUE);
	gtk_tree_view_column_set_title(column, _("state"));
	renderer = gtk_cell_renderer_pixbuf_new();
	gtk_tree_view_column_pack_start(column, renderer, FALSE);
	gtk_tree_view_column_set_attributes(column, renderer, "pixbuf", 0,
					    NULL);
	gtk_tree_view_append_column(GTK_TREE_VIEW(trans_view), column);

	column = gtk_tree_view_column_new();
	gtk_tree_view_column_set_resizable(column, TRUE);
	gtk_tree_view_column_set_title(column, _("task"));
	renderer = gtk_cell_renderer_text_new();
	gtk_tree_view_column_pack_start(column, renderer, FALSE);
	gtk_tree_view_column_set_attributes(column, renderer, "text", 1, NULL);
	gtk_tree_view_append_column(GTK_TREE_VIEW(trans_view), column);

	column = gtk_tree_view_column_new();
	gtk_tree_view_column_set_resizable(column, TRUE);
	gtk_tree_view_column_set_title(column, _("filename"));
	renderer = gtk_cell_renderer_text_new();
	gtk_tree_view_column_pack_start(column, renderer, FALSE);
	gtk_tree_view_column_set_attributes(column, renderer, "text", 2, NULL);
	gtk_tree_view_append_column(GTK_TREE_VIEW(trans_view), column);

	column = gtk_tree_view_column_new();
	gtk_tree_view_column_set_resizable(column, TRUE);
	gtk_tree_view_column_set_title(column, _("pal"));
	renderer = gtk_cell_renderer_text_new();
	gtk_tree_view_column_pack_start(column, renderer, FALSE);
	gtk_tree_view_column_set_attributes(column, renderer, "text", 3, NULL);
	gtk_tree_view_append_column(GTK_TREE_VIEW(trans_view), column);

	column = gtk_tree_view_column_new();
	gtk_tree_view_column_set_resizable(column, TRUE);
	gtk_tree_view_column_set_title(column, _("finished"));
	renderer = gtk_cell_renderer_text_new();
	gtk_tree_view_column_pack_start(column, renderer, FALSE);
	gtk_tree_view_column_set_attributes(column, renderer, "text", 4, NULL);
	gtk_tree_view_append_column(GTK_TREE_VIEW(trans_view), column);

	column = gtk_tree_view_column_new();
	gtk_tree_view_column_set_resizable(column, TRUE);
	gtk_tree_view_column_set_title(column, _("length"));
	renderer = gtk_cell_renderer_text_new();
	gtk_tree_view_column_pack_start(column, renderer, FALSE);
	gtk_tree_view_column_set_attributes(column, renderer, "text", 5, NULL);
	gtk_tree_view_append_column(GTK_TREE_VIEW(trans_view), column);

	column = gtk_tree_view_column_new();
	gtk_tree_view_column_set_resizable(column, TRUE);
	gtk_tree_view_column_set_title(column, _("rate"));
	renderer = gtk_cell_renderer_text_new();
	gtk_tree_view_column_pack_start(column, renderer, FALSE);
	gtk_tree_view_column_set_attributes(column, renderer, "text", 6, NULL);
	gtk_tree_view_append_column(GTK_TREE_VIEW(trans_view), column);

	column = gtk_tree_view_column_new();
	gtk_tree_view_column_set_resizable(column, TRUE);
	gtk_tree_view_column_set_title(column, _("progress"));
	renderer = gtk_cell_renderer_progress_new();
	gtk_tree_view_column_pack_start(column, renderer, TRUE);
	gtk_tree_view_column_set_attributes(column, renderer, "value", 7, NULL);
	gtk_tree_view_append_column(GTK_TREE_VIEW(trans_view), column);
}

void Transport::CreateTransDialog()
{
	GtkWidget *box, *sw;
	GtkWidget *hbb, *button;

	transport = create_window(_("Transmission management"), 132, 79);
	gtk_container_set_border_width(GTK_CONTAINER(transport), 5);
	g_signal_connect(transport, "destroy", G_CALLBACK(DestroyDialog), NULL);

	box = create_box();
	gtk_container_add(GTK_CONTAINER(transport), box);

	sw = create_scrolled_window();
	gtk_box_pack_start(GTK_BOX(box), sw, TRUE, TRUE, 0);
	gtk_container_add(GTK_CONTAINER(sw), trans_view);

	hbb = create_button_box(FALSE);
	gtk_box_pack_start(GTK_BOX(box), hbb, FALSE, FALSE, 0);
	button = gtk_button_new_from_stock(GTK_STOCK_CLEAR);
	gtk_widget_show(button);
	g_signal_connect_swapped(button, "clicked", G_CALLBACK(TidyTask), this);
	gtk_box_pack_start(GTK_BOX(hbb), button, FALSE, FALSE, 0);
}

void Transport::RecvFileData(GtkTreeIter * iter)
{
	uint32_t packetno, fileid, filesize, size;
	gchar *filename, *pathname;
	char buf[MAX_SOCKBUF];
	my_file mf(true);
	Command cmd;
	int sock, fd;
	Pal *pal;

	gdk_threads_enter();
	gtk_tree_model_get(trans_model, iter, 2, &filename, 9, &packetno,
			   10, &fileid, 11, &filesize, 13, &pathname, 14, &pal,
			   -1);
	gdk_threads_leave();

	sock = Socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
	mf.chdir(pathname);
	fd = mf.open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_LARGEFILE,
		     00644);
	g_free(filename), g_free(pathname);
	if (fd == -1 || !cmd.SendAskData(sock, pal, packetno, fileid, 0)) {
		EndTransportData(sock, fd, iter, __TIP_DIR "/error.png");
		return;
	}

	size = RecvData(sock, fd, iter, filesize, buf, 0);
	if (size >= filesize)
		EndTransportData(sock, fd, iter, __TIP_DIR "/finish.png");
	else
		EndTransportData(sock, fd, iter, __TIP_DIR "/error.png");
}

void Transport::RecvDirFiles(GtkTreeIter * iter)
{
	uint32_t packetno, fileid, headsize, filesize, fileattr;
	gchar *dirname, *pathname, *filename;
	char buf[MAX_SOCKBUF], *ptr;
	my_file mf(true);
	Command cmd;
	gint terminate;
	int sock, fd;
	int layers;
	ssize_t size;
	bool result;
	size_t len;
	Pal *pal;

	gdk_threads_enter();
	gtk_tree_model_get(trans_model, iter, 2, &dirname, 9, &packetno,
			   10, &fileid, 13, &pathname, 14, &pal, -1);
	gdk_threads_leave();

	sock = Socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
	mf.chdir(pathname), g_free(pathname);
	if (!cmd.SendAskFiles(sock, pal, packetno, fileid)) {
		EndTransportData(sock, -1, iter, __TIP_DIR "/error.png");
		g_free(dirname);
		return;
	}

	layers = 0, len = 0, result = false;
	while (1) {
		if ((size = my_read2(sock, buf, MAX_SOCKBUF, len)) == -1)
			break;
		headsize = iptux_get_hex_number(buf, 0);
		pathname = ipmsg_get_filename(buf, 1);
		filesize = iptux_get_hex_number(buf, 2);
		fileattr = iptux_get_hex_number(buf, 3);

		len = size - headsize;
		if (!FLAG_ISSET(pal->flags, 0)) {
			filename =
			    transfer_encode(pathname, pal->encode, false);
			free(pathname);
		} else
			filename = pathname;
		if (GET_MODE(fileattr) != IPMSG_FILE_RETPARENT) {
			ptr = number_to_string(filesize);
			gdk_threads_enter();
			gtk_list_store_set(GTK_LIST_STORE(trans_model), iter, 2,
					   filename, 4, "0B", 5, ptr, 6, "0B/s",
					   7, 0, -1);
			gtk_tree_model_get(trans_model, iter, 8, &terminate,
					   -1);
			gdk_threads_leave();
			free(ptr);
			if (terminate == -1)
				goto end;
		}

		if (GET_MODE(fileattr) == IPMSG_FILE_DIR) {
			mf.chdir(filename), free(filename);
			memmove(buf, buf + headsize, len);
			layers++;
			continue;
		} else if (GET_MODE(fileattr) == IPMSG_FILE_RETPARENT) {
			mf.chdir(".."), free(filename);
			memmove(buf, buf + headsize, len);
			if ((--layers) <= 0)
				break;
			continue;
		} else if (GET_MODE(fileattr) == IPMSG_FILE_REGULAR) {
			fd = mf.open(filename,
				     O_WRONLY | O_CREAT | O_TRUNC | O_LARGEFILE,
				     00644);
			free(filename);
			if (fd == -1)
				goto end;
		} else {
			free(filename);
			if ((fd = Open("/dev/null", O_WRONLY)) == -1)
				goto end;
		}
		size = len < filesize ? len : filesize;
		if (Write(fd, buf + headsize, size) == -1) {
			close(fd);
			goto end;
		}
		if (size == filesize) {
			close(fd);
			if (len -= size)
				memmove(buf, buf + headsize + size, len);
			ptr = number_to_string(size);
			gdk_threads_enter();
			gtk_list_store_set(GTK_LIST_STORE(trans_model), iter,
					   4, ptr, 7, 100, -1);
			gdk_threads_leave();
			free(ptr);
			continue;
		}
		headsize = RecvData(sock, fd, iter, filesize, buf, size);
		close(fd), len = 0;
		if (headsize < filesize)
			goto end;
	}
	result = true;

 end:	if (result) {
		EndTransportData(sock, -1, iter, __TIP_DIR "/finish.png");
		EndTransportDirFiles(iter, dirname);
	} else {
		EndTransportData(sock, -1, iter, __TIP_DIR "/error.png");
		g_free(dirname);
	}
}

uint32_t Transport::RecvData(int sock, int fd, GtkTreeIter * iter,
			     uint32_t filesize, char *buf, uint32_t offset)
{