diff libpurple/ft.c @ 15822:32c366eeeb99

sed -ie 's/gaim/purple/g'

--- a/libpurple/ft.c	Mon Mar 19 06:11:46 2007 +0000
+++ b/libpurple/ft.c	Mon Mar 19 07:01:17 2007 +0000
@@ -1,9 +1,9 @@
 /**
  * @file ft.c File Transfer API
  *
- * gaim
+ * purple
  *
- * Gaim is the legal property of its developers, whose names are too numerous
+ * Purple is the legal property of its developers, whose names are too numerous
  * to list here.  Please refer to the COPYRIGHT file distributed with this
  * source distribution.
  *
@@ -34,38 +34,38 @@
 #define FT_INITIAL_BUFFER_SIZE 4096
 #define FT_MAX_BUFFER_SIZE     65535
 
-static GaimXferUiOps *xfer_ui_ops = NULL;
+static PurpleXferUiOps *xfer_ui_ops = NULL;
 static GList *xfers;
 
-static int gaim_xfer_choose_file(GaimXfer *xfer);
+static int purple_xfer_choose_file(PurpleXfer *xfer);
 
 GList *
-gaim_xfers_get_all()
+purple_xfers_get_all()
 {
 	return xfers;
 }
 
-GaimXfer *
-gaim_xfer_new(GaimAccount *account, GaimXferType type, const char *who)
+PurpleXfer *
+purple_xfer_new(PurpleAccount *account, PurpleXferType type, const char *who)
 {
-	GaimXfer *xfer;
-	GaimXferUiOps *ui_ops;
+	PurpleXfer *xfer;
+	PurpleXferUiOps *ui_ops;
 
-	g_return_val_if_fail(type    != GAIM_XFER_UNKNOWN, NULL);
+	g_return_val_if_fail(type    != PURPLE_XFER_UNKNOWN, NULL);
 	g_return_val_if_fail(account != NULL,              NULL);
 	g_return_val_if_fail(who     != NULL,              NULL);
 
-	xfer = g_new0(GaimXfer, 1);
+	xfer = g_new0(PurpleXfer, 1);
 
 	xfer->ref = 1;
 	xfer->type    = type;
 	xfer->account = account;
 	xfer->who     = g_strdup(who);
-	xfer->ui_ops  = gaim_xfers_get_ui_ops();
+	xfer->ui_ops  = purple_xfers_get_ui_ops();
 	xfer->message = NULL;
 	xfer->current_buffer_size = FT_INITIAL_BUFFER_SIZE;
 
-	ui_ops = gaim_xfer_get_ui_ops(xfer);
+	ui_ops = purple_xfer_get_ui_ops(xfer);
 
 	if (ui_ops != NULL && ui_ops->new_xfer != NULL)
 		ui_ops->new_xfer(xfer);
@@ -75,19 +75,19 @@
 }
 
 static void
-gaim_xfer_destroy(GaimXfer *xfer)
+purple_xfer_destroy(PurpleXfer *xfer)
 {
-	GaimXferUiOps *ui_ops;
+	PurpleXferUiOps *ui_ops;
 
 	g_return_if_fail(xfer != NULL);
 
 	/* Close the file browser, if it's open */
-	gaim_request_close_with_handle(xfer);
+	purple_request_close_with_handle(xfer);
 
-	if (gaim_xfer_get_status(xfer) == GAIM_XFER_STATUS_STARTED)
-		gaim_xfer_cancel_local(xfer);
+	if (purple_xfer_get_status(xfer) == PURPLE_XFER_STATUS_STARTED)
+		purple_xfer_cancel_local(xfer);
 
-	ui_ops = gaim_xfer_get_ui_ops(xfer);
+	ui_ops = purple_xfer_get_ui_ops(xfer);
 
 	if (ui_ops != NULL && ui_ops->destroy != NULL)
 		ui_ops->destroy(xfer);
@@ -102,7 +102,7 @@
 }
 
 void
-gaim_xfer_ref(GaimXfer *xfer)
+purple_xfer_ref(PurpleXfer *xfer)
 {
 	g_return_if_fail(xfer != NULL);
 
@@ -110,7 +110,7 @@
 }
 
 void
-gaim_xfer_unref(GaimXfer *xfer)
+purple_xfer_unref(PurpleXfer *xfer)
 {
 	g_return_if_fail(xfer != NULL);
 	g_return_if_fail(xfer->ref > 0);
@@ -118,46 +118,46 @@
 	xfer->ref--;
 
 	if (xfer->ref == 0)
-		gaim_xfer_destroy(xfer);
+		purple_xfer_destroy(xfer);
 }
 
 static void
-gaim_xfer_set_status(GaimXfer *xfer, GaimXferStatusType status)
+purple_xfer_set_status(PurpleXfer *xfer, PurpleXferStatusType status)
 {
 	g_return_if_fail(xfer != NULL);
 
-	if(xfer->type == GAIM_XFER_SEND) {
+	if(xfer->type == PURPLE_XFER_SEND) {
 		switch(status) {
-			case GAIM_XFER_STATUS_ACCEPTED:
-				gaim_signal_emit(gaim_xfers_get_handle(), "file-send-accept", xfer);
+			case PURPLE_XFER_STATUS_ACCEPTED:
+				purple_signal_emit(purple_xfers_get_handle(), "file-send-accept", xfer);
 				break;
-			case GAIM_XFER_STATUS_STARTED:
-				gaim_signal_emit(gaim_xfers_get_handle(), "file-send-start", xfer);
+			case PURPLE_XFER_STATUS_STARTED:
+				purple_signal_emit(purple_xfers_get_handle(), "file-send-start", xfer);
 				break;
-			case GAIM_XFER_STATUS_DONE:
-				gaim_signal_emit(gaim_xfers_get_handle(), "file-send-complete", xfer);
+			case PURPLE_XFER_STATUS_DONE:
+				purple_signal_emit(purple_xfers_get_handle(), "file-send-complete", xfer);
 				break;
-			case GAIM_XFER_STATUS_CANCEL_LOCAL:
-			case GAIM_XFER_STATUS_CANCEL_REMOTE:
-				gaim_signal_emit(gaim_xfers_get_handle(), "file-send-cancel", xfer);
+			case PURPLE_XFER_STATUS_CANCEL_LOCAL:
+			case PURPLE_XFER_STATUS_CANCEL_REMOTE:
+				purple_signal_emit(purple_xfers_get_handle(), "file-send-cancel", xfer);
 				break;
 			default:
 				break;
 		}
-	} else if(xfer->type == GAIM_XFER_RECEIVE) {
+	} else if(xfer->type == PURPLE_XFER_RECEIVE) {
 		switch(status) {
-			case GAIM_XFER_STATUS_ACCEPTED:
-				gaim_signal_emit(gaim_xfers_get_handle(), "file-recv-accept", xfer);
+			case PURPLE_XFER_STATUS_ACCEPTED:
+				purple_signal_emit(purple_xfers_get_handle(), "file-recv-accept", xfer);
 				break;
-			case GAIM_XFER_STATUS_STARTED:
-				gaim_signal_emit(gaim_xfers_get_handle(), "file-recv-start", xfer);
+			case PURPLE_XFER_STATUS_STARTED:
+				purple_signal_emit(purple_xfers_get_handle(), "file-recv-start", xfer);
 				break;
-			case GAIM_XFER_STATUS_DONE:
-				gaim_signal_emit(gaim_xfers_get_handle(), "file-recv-complete", xfer);
+			case PURPLE_XFER_STATUS_DONE:
+				purple_signal_emit(purple_xfers_get_handle(), "file-recv-complete", xfer);
 				break;
-			case GAIM_XFER_STATUS_CANCEL_LOCAL:
-			case GAIM_XFER_STATUS_CANCEL_REMOTE:
-				gaim_signal_emit(gaim_xfers_get_handle(), "file-recv-cancel", xfer);
+			case PURPLE_XFER_STATUS_CANCEL_LOCAL:
+			case PURPLE_XFER_STATUS_CANCEL_REMOTE:
+				purple_signal_emit(purple_xfers_get_handle(), "file-recv-cancel", xfer);
 				break;
 			default:
 				break;
@@ -167,17 +167,17 @@
 	xfer->status = status;
 }
 
-void gaim_xfer_conversation_write(GaimXfer *xfer, char *message, gboolean is_error)
+void purple_xfer_conversation_write(PurpleXfer *xfer, char *message, gboolean is_error)
 {
-	GaimConversation *conv = NULL;
-	GaimMessageFlags flags = GAIM_MESSAGE_SYSTEM;
+	PurpleConversation *conv = NULL;
+	PurpleMessageFlags flags = PURPLE_MESSAGE_SYSTEM;
 	char *escaped;
 
 	g_return_if_fail(xfer != NULL);
 	g_return_if_fail(message != NULL);
 
-	conv = gaim_find_conversation_with_account(GAIM_CONV_TYPE_IM, xfer->who,
-											   gaim_xfer_get_account(xfer));
+	conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, xfer->who,
+											   purple_xfer_get_account(xfer));
 
 	if (conv == NULL)
 		return;
@@ -185,26 +185,26 @@
 	escaped = g_markup_escape_text(message, -1);
 
 	if (is_error)
-		flags = GAIM_MESSAGE_ERROR;
+		flags = PURPLE_MESSAGE_ERROR;
 
-	gaim_conversation_write(conv, NULL, escaped, flags, time(NULL));
+	purple_conversation_write(conv, NULL, escaped, flags, time(NULL));
 	g_free(escaped);
 }
 
-static void gaim_xfer_show_file_error(GaimXfer *xfer, const char *filename)
+static void purple_xfer_show_file_error(PurpleXfer *xfer, const char *filename)
 {
 	int err = errno;
 	gchar *msg = NULL, *utf8;
-	GaimXferType xfer_type = gaim_xfer_get_type(xfer);
-	GaimAccount *account = gaim_xfer_get_account(xfer);
+	PurpleXferType xfer_type = purple_xfer_get_type(xfer);
+	PurpleAccount *account = purple_xfer_get_account(xfer);
 
 	utf8 = g_filename_to_utf8(filename, -1, NULL, NULL, NULL);
 	switch(xfer_type) {
-		case GAIM_XFER_SEND:
+		case PURPLE_XFER_SEND:
 			msg = g_strdup_printf(_("Error reading %s: \n%s.\n"),
 								  utf8, strerror(err));
 			break;
-		case GAIM_XFER_RECEIVE:
+		case PURPLE_XFER_RECEIVE:
 			msg = g_strdup_printf(_("Error writing %s: \n%s.\n"),
 								  utf8, strerror(err));
 			break;
@@ -215,23 +215,23 @@
 	}
 	g_free(utf8);
 
-	gaim_xfer_conversation_write(xfer, msg, TRUE);
-	gaim_xfer_error(xfer_type, account, xfer->who, msg);
+	purple_xfer_conversation_write(xfer, msg, TRUE);
+	purple_xfer_error(xfer_type, account, xfer->who, msg);
 	g_free(msg);
 }
 
 static void
-gaim_xfer_choose_file_ok_cb(void *user_data, const char *filename)
+purple_xfer_choose_file_ok_cb(void *user_data, const char *filename)
 {
-	GaimXfer *xfer;
+	PurpleXfer *xfer;
 	struct stat st;
 	gchar *dir;
 
-	xfer = (GaimXfer *)user_data;
+	xfer = (PurpleXfer *)user_data;
 
 	if (g_stat(filename, &st) != 0) {
 		/* File not found. */
-		if (gaim_xfer_get_type(xfer) == GAIM_XFER_RECEIVE) {
+		if (purple_xfer_get_type(xfer) == PURPLE_XFER_RECEIVE) {
 #ifndef _WIN32
 			int mode = W_OK;
 #else
@@ -240,161 +240,161 @@
 			dir = g_path_get_dirname(filename);
 
 			if (g_access(dir, mode) == 0) {
-				gaim_xfer_request_accepted(xfer, filename);
+				purple_xfer_request_accepted(xfer, filename);
 			} else {
-				gaim_xfer_ref(xfer);
-				gaim_notify_message(
-					NULL, GAIM_NOTIFY_MSG_ERROR, NULL,
+				purple_xfer_ref(xfer);
+				purple_notify_message(
+					NULL, PURPLE_NOTIFY_MSG_ERROR, NULL,
 					_("Directory is not writable."), NULL,
-					(GaimNotifyCloseCallback)gaim_xfer_choose_file, xfer);
+					(PurpleNotifyCloseCallback)purple_xfer_choose_file, xfer);
 			}
 
 			g_free(dir);
 		}
 		else {
-			gaim_xfer_show_file_error(xfer, filename);
-			gaim_xfer_request_denied(xfer);
+			purple_xfer_show_file_error(xfer, filename);
+			purple_xfer_request_denied(xfer);
 		}
 	}
-	else if ((gaim_xfer_get_type(xfer) == GAIM_XFER_SEND) &&
+	else if ((purple_xfer_get_type(xfer) == PURPLE_XFER_SEND) &&
 			 (st.st_size == 0)) {
 
-		gaim_notify_error(NULL, NULL,
+		purple_notify_error(NULL, NULL,
 						  _("Cannot send a file of 0 bytes."), NULL);
 
-		gaim_xfer_request_denied(xfer);
+		purple_xfer_request_denied(xfer);
 	}
-	else if ((gaim_xfer_get_type(xfer) == GAIM_XFER_SEND) &&
+	else if ((purple_xfer_get_type(xfer) == PURPLE_XFER_SEND) &&
 			 S_ISDIR(st.st_mode)) {
 		/*
 		 * XXX - Sending a directory should be valid for some protocols.
 		 */
-		gaim_notify_error(NULL, NULL,
+		purple_notify_error(NULL, NULL,
 						  _("Cannot send a directory."), NULL);
 
-		gaim_xfer_request_denied(xfer);
+		purple_xfer_request_denied(xfer);
 	}
-	else if ((gaim_xfer_get_type(xfer) == GAIM_XFER_RECEIVE) &&
+	else if ((purple_xfer_get_type(xfer) == PURPLE_XFER_RECEIVE) &&
 			 S_ISDIR(st.st_mode)) {
 		char *msg, *utf8;
 		utf8 = g_filename_to_utf8(filename, -1, NULL, NULL, NULL);
 		msg = g_strdup_printf(
 					_("%s is not a regular file. Cowardly refusing to overwrite it.\n"), utf8);
 		g_free(utf8);
-		gaim_notify_error(NULL, NULL, msg, NULL);
+		purple_notify_error(NULL, NULL, msg, NULL);
 		g_free(msg);
-		gaim_xfer_request_denied(xfer);
+		purple_xfer_request_denied(xfer);
 	}
 	else {
-		gaim_xfer_request_accepted(xfer, filename);
+		purple_xfer_request_accepted(xfer, filename);
 	}
 
-	gaim_xfer_unref(xfer);
+	purple_xfer_unref(xfer);
 }
 
 static void
-gaim_xfer_choose_file_cancel_cb(void *user_data, const char *filename)
+purple_xfer_choose_file_cancel_cb(void *user_data, const char *filename)
 {
-	GaimXfer *xfer = (GaimXfer *)user_data;
+	PurpleXfer *xfer = (PurpleXfer *)user_data;
 
-	gaim_xfer_set_status(xfer, GAIM_XFER_STATUS_CANCEL_LOCAL);
-	gaim_xfer_request_denied(xfer);
+	purple_xfer_set_status(xfer, PURPLE_XFER_STATUS_CANCEL_LOCAL);
+	purple_xfer_request_denied(xfer);
 }
 
 static int
-gaim_xfer_choose_file(GaimXfer *xfer)
+purple_xfer_choose_file(PurpleXfer *xfer)
 {
-	gaim_request_file(xfer, NULL, gaim_xfer_get_filename(xfer),
-					  (gaim_xfer_get_type(xfer) == GAIM_XFER_RECEIVE),
-					  G_CALLBACK(gaim_xfer_choose_file_ok_cb),
-					  G_CALLBACK(gaim_xfer_choose_file_cancel_cb), xfer);
+	purple_request_file(xfer, NULL, purple_xfer_get_filename(xfer),
+					  (purple_xfer_get_type(xfer) == PURPLE_XFER_RECEIVE),
+					  G_CALLBACK(purple_xfer_choose_file_ok_cb),
+					  G_CALLBACK(purple_xfer_choose_file_cancel_cb), xfer);
 
 	return 0;
 }
 
 static int
-cancel_recv_cb(GaimXfer *xfer)
+cancel_recv_cb(PurpleXfer *xfer)
 {
-	gaim_xfer_set_status(xfer, GAIM_XFER_STATUS_CANCEL_LOCAL);
-	gaim_xfer_request_denied(xfer);
-	gaim_xfer_unref(xfer);
+	purple_xfer_set_status(xfer, PURPLE_XFER_STATUS_CANCEL_LOCAL);
+	purple_xfer_request_denied(xfer);
+	purple_xfer_unref(xfer);
 
 	return 0;
 }
 
 static void
-gaim_xfer_ask_recv(GaimXfer *xfer)
+purple_xfer_ask_recv(PurpleXfer *xfer)
 {
 	char *buf, *size_buf;
 	size_t size;
 
 	/* If we have already accepted the request, ask the destination file
 	   name directly */
-	if (gaim_xfer_get_status(xfer) != GAIM_XFER_STATUS_ACCEPTED) {
-		GaimBuddy *buddy = gaim_find_buddy(xfer->account, xfer->who);
+	if (purple_xfer_get_status(xfer) != PURPLE_XFER_STATUS_ACCEPTED) {
+		PurpleBuddy *buddy = purple_find_buddy(xfer->account, xfer->who);
 
-		if (gaim_xfer_get_filename(xfer) != NULL)
+		if (purple_xfer_get_filename(xfer) != NULL)
 		{
-			size = gaim_xfer_get_size(xfer);
-			size_buf = gaim_str_size_to_units(size);
+			size = purple_xfer_get_size(xfer);
+			size_buf = purple_str_size_to_units(size);
 			buf = g_strdup_printf(_("%s wants to send you %s (%s)"),
-						  buddy ? gaim_buddy_get_alias(buddy) : xfer->who,
-						  gaim_xfer_get_filename(xfer), size_buf);
+						  buddy ? purple_buddy_get_alias(buddy) : xfer->who,
+						  purple_xfer_get_filename(xfer), size_buf);
 			g_free(size_buf);
 		}
 		else
 		{
 			buf = g_strdup_printf(_("%s wants to send you a file"),
-						buddy ? gaim_buddy_get_alias(buddy) : xfer->who);
+						buddy ? purple_buddy_get_alias(buddy) : xfer->who);
 		}
 
 		if (xfer->message != NULL)
-			serv_got_im(gaim_account_get_connection(xfer->account),
+			serv_got_im(purple_account_get_connection(xfer->account),
 								 xfer->who, xfer->message, 0, time(NULL));
 
-		gaim_request_accept_cancel(xfer, NULL, buf, NULL,
-								  GAIM_DEFAULT_ACTION_NONE, xfer,
-								  G_CALLBACK(gaim_xfer_choose_file),
+		purple_request_accept_cancel(xfer, NULL, buf, NULL,
+								  PURPLE_DEFAULT_ACTION_NONE, xfer,
+								  G_CALLBACK(purple_xfer_choose_file),
 								  G_CALLBACK(cancel_recv_cb));
 
 		g_free(buf);
 	} else
-		gaim_xfer_choose_file(xfer);
+		purple_xfer_choose_file(xfer);
 }
 
 static int
-ask_accept_ok(GaimXfer *xfer)
+ask_accept_ok(PurpleXfer *xfer)
 {
-	gaim_xfer_request_accepted(xfer, NULL);
+	purple_xfer_request_accepted(xfer, NULL);
 
 	return 0;
 }
 
 static int
-ask_accept_cancel(GaimXfer *xfer)
+ask_accept_cancel(PurpleXfer *xfer)
 {
-	gaim_xfer_request_denied(xfer);
-	gaim_xfer_unref(xfer);
+	purple_xfer_request_denied(xfer);
+	purple_xfer_unref(xfer);
 
 	return 0;
 }
 
 static void
-gaim_xfer_ask_accept(GaimXfer *xfer)
+purple_xfer_ask_accept(PurpleXfer *xfer)
 {
 	char *buf, *buf2 = NULL;
-	GaimBuddy *buddy = gaim_find_buddy(xfer->account, xfer->who);
+	PurpleBuddy *buddy = purple_find_buddy(xfer->account, xfer->who);
 
 	buf = g_strdup_printf(_("Accept file transfer request from %s?"),
-				  buddy ? gaim_buddy_get_alias(buddy) : xfer->who);
-	if (gaim_xfer_get_remote_ip(xfer) &&
-		gaim_xfer_get_remote_port(xfer))
+				  buddy ? purple_buddy_get_alias(buddy) : xfer->who);
+	if (purple_xfer_get_remote_ip(xfer) &&
+		purple_xfer_get_remote_port(xfer))
 		buf2 = g_strdup_printf(_("A file is available for download from:\n"
 					 "Remote host: %s\nRemote port: %d"),
-					   gaim_xfer_get_remote_ip(xfer),
-					   gaim_xfer_get_remote_port(xfer));
-	gaim_request_accept_cancel(xfer, NULL, buf, buf2,
-							   GAIM_DEFAULT_ACTION_NONE, xfer,
+					   purple_xfer_get_remote_ip(xfer),
+					   purple_xfer_get_remote_port(xfer));
+	purple_request_accept_cancel(xfer, NULL, buf, buf2,
+							   PURPLE_DEFAULT_ACTION_NONE, xfer,
 							   G_CALLBACK(ask_accept_ok),
 							   G_CALLBACK(ask_accept_cancel));
 	g_free(buf);
@@ -402,69 +402,69 @@
 }
 
 void
-gaim_xfer_request(GaimXfer *xfer)
+purple_xfer_request(PurpleXfer *xfer)
 {
 	g_return_if_fail(xfer != NULL);
 	g_return_if_fail(xfer->ops.init != NULL);
 
-	gaim_xfer_ref(xfer);
+	purple_xfer_ref(xfer);
 
-	if (gaim_xfer_get_type(xfer) == GAIM_XFER_RECEIVE)
+	if (purple_xfer_get_type(xfer) == PURPLE_XFER_RECEIVE)
 	{
-		gaim_signal_emit(gaim_xfers_get_handle(), "file-recv-request", xfer);
-		if (gaim_xfer_get_status(xfer) == GAIM_XFER_STATUS_CANCEL_LOCAL)
+		purple_signal_emit(purple_xfers_get_handle(), "file-recv-request", xfer);
+		if (purple_xfer_get_status(xfer) == PURPLE_XFER_STATUS_CANCEL_LOCAL)
 		{
 			/* The file-transfer was cancelled by a plugin */
-			gaim_xfer_cancel_local(xfer);
+			purple_xfer_cancel_local(xfer);
 		}
-		else if (gaim_xfer_get_filename(xfer) ||
-		           gaim_xfer_get_status(xfer) == GAIM_XFER_STATUS_ACCEPTED)
+		else if (purple_xfer_get_filename(xfer) ||
+		           purple_xfer_get_status(xfer) == PURPLE_XFER_STATUS_ACCEPTED)
 		{
 			gchar* message = NULL;
-			GaimBuddy *buddy = gaim_find_buddy(xfer->account, xfer->who);
+			PurpleBuddy *buddy = purple_find_buddy(xfer->account, xfer->who);
 			message = g_strdup_printf(_("%s is offering to send file %s"),
-				buddy ? gaim_buddy_get_alias(buddy) : xfer->who, gaim_xfer_get_filename(xfer));
-			gaim_xfer_conversation_write(xfer, message, FALSE);
+				buddy ? purple_buddy_get_alias(buddy) : xfer->who, purple_xfer_get_filename(xfer));
+			purple_xfer_conversation_write(xfer, message, FALSE);
 			g_free(message);
 			/* Ask for a filename to save to if it's not already given by a plugin */
 			if (xfer->local_filename == NULL)
-				gaim_xfer_ask_recv(xfer);
+				purple_xfer_ask_recv(xfer);
 		}
 		else
 		{
-			gaim_xfer_ask_accept(xfer);
+			purple_xfer_ask_accept(xfer);
 		}
 	}
 	else
 	{
-		gaim_xfer_choose_file(xfer);
+		purple_xfer_choose_file(xfer);
 	}
 }
 
 void
-gaim_xfer_request_accepted(GaimXfer *xfer, const char *filename)
+purple_xfer_request_accepted(PurpleXfer *xfer, const char *filename)
 {
-	GaimXferType type;
+	PurpleXferType type;
 	struct stat st;
 	char *msg, *utf8;
-	GaimAccount *account;
-	GaimBuddy *buddy;
+	PurpleAccount *account;
+	PurpleBuddy *buddy;
 
 	if (xfer == NULL)
 		return;
 
-	type = gaim_xfer_get_type(xfer);
-	account = gaim_xfer_get_account(xfer);
+	type = purple_xfer_get_type(xfer);
+	account = purple_xfer_get_account(xfer);
 
-	if (!filename && type == GAIM_XFER_RECEIVE) {
-		xfer->status = GAIM_XFER_STATUS_ACCEPTED;
+	if (!filename && type == PURPLE_XFER_RECEIVE) {
+		xfer->status = PURPLE_XFER_STATUS_ACCEPTED;
 		xfer->ops.init(xfer);
 		return;
 	}
 
-	buddy = gaim_find_buddy(account, xfer->who);
+	buddy = purple_find_buddy(account, xfer->who);
 
-	if (type == GAIM_XFER_SEND) {
+	if (type == PURPLE_XFER_SEND) {
 		/* Sending a file */
 		/* Check the filename. */
 #ifdef _WIN32
@@ -475,106 +475,106 @@
 			char *utf8 = g_filename_to_utf8(filename, -1, NULL, NULL, NULL);
 
 			msg = g_strdup_printf(_("%s is not a valid filename.\n"), utf8);
-			gaim_xfer_error(type, account, xfer->who, msg);
+			purple_xfer_error(type, account, xfer->who, msg);
 			g_free(utf8);
 			g_free(msg);
 
-			gaim_xfer_unref(xfer);
+			purple_xfer_unref(xfer);
 			return;
 		}
 
 		if (g_stat(filename, &st) == -1) {
-			gaim_xfer_show_file_error(xfer, filename);
-			gaim_xfer_unref(xfer);
+			purple_xfer_show_file_error(xfer, filename);
+			purple_xfer_unref(xfer);
 			return;
 		}
 
-		gaim_xfer_set_local_filename(xfer, filename);
-		gaim_xfer_set_size(xfer, st.st_size);
+		purple_xfer_set_local_filename(xfer, filename);
+		purple_xfer_set_size(xfer, st.st_size);
 
 		utf8 = g_filename_to_utf8(g_basename(filename), -1, NULL, NULL, NULL);
-		gaim_xfer_set_filename(xfer, utf8);
+		purple_xfer_set_filename(xfer, utf8);
 
 		msg = g_strdup_printf(_("Offering to send %s to %s"),
-				utf8, buddy ? gaim_buddy_get_alias(buddy) : xfer->who);
+				utf8, buddy ? purple_buddy_get_alias(buddy) : xfer->who);
 		g_free(utf8);
 
-		gaim_xfer_conversation_write(xfer, msg, FALSE);
+		purple_xfer_conversation_write(xfer, msg, FALSE);
 		g_free(msg);
 	}
 	else {
 		/* Receiving a file */
-		xfer->status = GAIM_XFER_STATUS_ACCEPTED;
-		gaim_xfer_set_local_filename(xfer, filename);
+		xfer->status = PURPLE_XFER_STATUS_ACCEPTED;
+		purple_xfer_set_local_filename(xfer, filename);
 
 		msg = g_strdup_printf(_("Starting transfer of %s from %s"),
-				xfer->filename, buddy ? gaim_buddy_get_alias(buddy) : xfer->who);
-		gaim_xfer_conversation_write(xfer, msg, FALSE);
+				xfer->filename, buddy ? purple_buddy_get_alias(buddy) : xfer->who);
+		purple_xfer_conversation_write(xfer, msg, FALSE);
 		g_free(msg);
 	}
 
-	gaim_xfer_add(xfer);
+	purple_xfer_add(xfer);
 	xfer->ops.init(xfer);
 
 }
 
 void
-gaim_xfer_request_denied(GaimXfer *xfer)
+purple_xfer_request_denied(PurpleXfer *xfer)
 {
 	g_return_if_fail(xfer != NULL);
 
 	if (xfer->ops.request_denied != NULL)
 		xfer->ops.request_denied(xfer);
 
-	gaim_xfer_unref(xfer);
+	purple_xfer_unref(xfer);
 }
 
-GaimXferType
-gaim_xfer_get_type(const GaimXfer *xfer)
+PurpleXferType
+purple_xfer_get_type(const PurpleXfer *xfer)
 {
-	g_return_val_if_fail(xfer != NULL, GAIM_XFER_UNKNOWN);
+	g_return_val_if_fail(xfer != NULL, PURPLE_XFER_UNKNOWN);
 
 	return xfer->type;
 }
 
-GaimAccount *
-gaim_xfer_get_account(const GaimXfer *xfer)
+PurpleAccount *
+purple_xfer_get_account(const PurpleXfer *xfer)
 {
 	g_return_val_if_fail(xfer != NULL, NULL);
 
 	return xfer->account;
 }
 
-GaimXferStatusType
-gaim_xfer_get_status(const GaimXfer *xfer)
+PurpleXferStatusType
+purple_xfer_get_status(const PurpleXfer *xfer)
 {
-	g_return_val_if_fail(xfer != NULL, GAIM_XFER_STATUS_UNKNOWN);
+	g_return_val_if_fail(xfer != NULL, PURPLE_XFER_STATUS_UNKNOWN);
 
 	return xfer->status;
 }
 
 gboolean
-gaim_xfer_is_canceled(const GaimXfer *xfer)
+purple_xfer_is_canceled(const PurpleXfer *xfer)
 {
 	g_return_val_if_fail(xfer != NULL, TRUE);
 
-	if ((gaim_xfer_get_status(xfer) == GAIM_XFER_STATUS_CANCEL_LOCAL) ||
-	    (gaim_xfer_get_status(xfer) == GAIM_XFER_STATUS_CANCEL_REMOTE))
+	if ((purple_xfer_get_status(xfer) == PURPLE_XFER_STATUS_CANCEL_LOCAL) ||
+	    (purple_xfer_get_status(xfer) == PURPLE_XFER_STATUS_CANCEL_REMOTE))
 		return TRUE;
 	else
 		return FALSE;
 }
 
 gboolean
-gaim_xfer_is_completed(const GaimXfer *xfer)
+purple_xfer_is_completed(const PurpleXfer *xfer)
 {
 	g_return_val_if_fail(xfer != NULL, TRUE);
 
-	return (gaim_xfer_get_status(xfer) == GAIM_XFER_STATUS_DONE);
+	return (purple_xfer_get_status(xfer) == PURPLE_XFER_STATUS_DONE);
 }
 
 const char *
-gaim_xfer_get_filename(const GaimXfer *xfer)
+purple_xfer_get_filename(const PurpleXfer *xfer)
 {
 	g_return_val_if_fail(xfer != NULL, NULL);
 
@@ -582,7 +582,7 @@
 }
 
 const char *
-gaim_xfer_get_local_filename(const GaimXfer *xfer)
+purple_xfer_get_local_filename(const PurpleXfer *xfer)
 {
 	g_return_val_if_fail(xfer != NULL, NULL);
 
@@ -590,7 +590,7 @@
 }
 
 size_t
-gaim_xfer_get_bytes_sent(const GaimXfer *xfer)
+purple_xfer_get_bytes_sent(const PurpleXfer *xfer)
 {
 	g_return_val_if_fail(xfer != NULL, 0);
 
@@ -598,7 +598,7 @@
 }
 
 size_t
-gaim_xfer_get_bytes_remaining(const GaimXfer *xfer)
+purple_xfer_get_bytes_remaining(const PurpleXfer *xfer)
 {
 	g_return_val_if_fail(xfer != NULL, 0);
 
@@ -606,7 +606,7 @@
 }
 
 size_t
-gaim_xfer_get_size(const GaimXfer *xfer)
+purple_xfer_get_size(const PurpleXfer *xfer)
 {
 	g_return_val_if_fail(xfer != NULL, 0);
 
@@ -614,19 +614,19 @@
 }
 
 double
-gaim_xfer_get_progress(const GaimXfer *xfer)
+purple_xfer_get_progress(const PurpleXfer *xfer)
 {
 	g_return_val_if_fail(xfer != NULL, 0.0);
 
-	if (gaim_xfer_get_size(xfer) == 0)
+	if (purple_xfer_get_size(xfer) == 0)
 		return 0.0;
 
-	return ((double)gaim_xfer_get_bytes_sent(xfer) /
-			(double)gaim_xfer_get_size(xfer));
+	return ((double)purple_xfer_get_bytes_sent(xfer) /
+			(double)purple_xfer_get_size(xfer));
 }
 
 unsigned int
-gaim_xfer_get_local_port(const GaimXfer *xfer)
+purple_xfer_get_local_port(const PurpleXfer *xfer)
 {
 	g_return_val_if_fail(xfer != NULL, -1);
 
@@ -634,7 +634,7 @@
 }
 
 const char *
-gaim_xfer_get_remote_ip(const GaimXfer *xfer)
+purple_xfer_get_remote_ip(const PurpleXfer *xfer)
 {
 	g_return_val_if_fail(xfer != NULL, NULL);
 
@@ -642,7 +642,7 @@
 }
 
 unsigned int
-gaim_xfer_get_remote_port(const GaimXfer *xfer)
+purple_xfer_get_remote_port(const PurpleXfer *xfer)
 {
 	g_return_val_if_fail(xfer != NULL, -1);
 
@@ -650,33 +650,33 @@
 }
 
 void
-gaim_xfer_set_completed(GaimXfer *xfer, gboolean completed)
+purple_xfer_set_completed(PurpleXfer *xfer, gboolean completed)
 {
-	GaimXferUiOps *ui_ops;
+	PurpleXferUiOps *ui_ops;
 
 	g_return_if_fail(xfer != NULL);
 
 	if (completed == TRUE) {
 		char *msg = NULL;
-		gaim_xfer_set_status(xfer, GAIM_XFER_STATUS_DONE);
+		purple_xfer_set_status(xfer, PURPLE_XFER_STATUS_DONE);
 
-		if (gaim_xfer_get_filename(xfer) != NULL)
+		if (purple_xfer_get_filename(xfer) != NULL)
 			msg = g_strdup_printf(_("Transfer of file %s complete"),
-								gaim_xfer_get_filename(xfer));
+								purple_xfer_get_filename(xfer));
 		else
 			msg = g_strdup_printf(_("File transfer complete"));
-		gaim_xfer_conversation_write(xfer, msg, FALSE);
+		purple_xfer_conversation_write(xfer, msg, FALSE);
 		g_free(msg);
 	}
 
-	ui_ops = gaim_xfer_get_ui_ops(xfer);
+	ui_ops = purple_xfer_get_ui_ops(xfer);
 
 	if (ui_ops != NULL && ui_ops->update_progress != NULL)
-		ui_ops->update_progress(xfer, gaim_xfer_get_progress(xfer));
+		ui_ops->update_progress(xfer, purple_xfer_get_progress(xfer));
 }
 
 void
-gaim_xfer_set_message(GaimXfer *xfer, const char *message)
+purple_xfer_set_message(PurpleXfer *xfer, const char *message)
 {
 	g_return_if_fail(xfer != NULL);
 
@@ -685,7 +685,7 @@
 }
 
 void
-gaim_xfer_set_filename(GaimXfer *xfer, const char *filename)
+purple_xfer_set_filename(PurpleXfer *xfer, const char *filename)
 {
 	g_return_if_fail(xfer != NULL);
 
@@ -694,7 +694,7 @@
 }
 
 void
-gaim_xfer_set_local_filename(GaimXfer *xfer, const char *filename)
+purple_xfer_set_local_filename(PurpleXfer *xfer, const char *filename)
 {
 	g_return_if_fail(xfer != NULL);
 
@@ -703,25 +703,25 @@
 }
 
 void
-gaim_xfer_set_size(GaimXfer *xfer, size_t size)
+purple_xfer_set_size(PurpleXfer *xfer, size_t size)
 {
 	g_return_if_fail(xfer != NULL);
 
 	xfer->size = size;
-	xfer->bytes_remaining = xfer->size - gaim_xfer_get_bytes_sent(xfer);
+	xfer->bytes_remaining = xfer->size - purple_xfer_get_bytes_sent(xfer);
 }
 
 void
-gaim_xfer_set_bytes_sent(GaimXfer *xfer, size_t bytes_sent)
+purple_xfer_set_bytes_sent(PurpleXfer *xfer, size_t bytes_sent)
 {
 	g_return_if_fail(xfer != NULL);
 
 	xfer->bytes_sent = bytes_sent;
-	xfer->bytes_remaining = gaim_xfer_get_size(xfer) - bytes_sent;
+	xfer->bytes_remaining = purple_xfer_get_size(xfer) - bytes_sent;
 }
 
-GaimXferUiOps *
-gaim_xfer_get_ui_ops(const GaimXfer *xfer)
+PurpleXferUiOps *
+purple_xfer_get_ui_ops(const PurpleXfer *xfer)
 {
 	g_return_val_if_fail(xfer != NULL, NULL);
 
@@ -729,14 +729,14 @@
 }
 
 void
-gaim_xfer_set_init_fnc(GaimXfer *xfer, void (*fnc)(GaimXfer *))
+purple_xfer_set_init_fnc(PurpleXfer *xfer, void (*fnc)(PurpleXfer *))
 {
 	g_return_if_fail(xfer != NULL);
 
 	xfer->ops.init = fnc;
 }
 
-void gaim_xfer_set_request_denied_fnc(GaimXfer *xfer, void (*fnc)(GaimXfer *))
+void purple_xfer_set_request_denied_fnc(PurpleXfer *xfer, void (*fnc)(PurpleXfer *))
 {
 	g_return_if_fail(xfer != NULL);
 
@@ -744,7 +744,7 @@
 }
 
 void
-gaim_xfer_set_read_fnc(GaimXfer *xfer, gssize (*fnc)(guchar **, GaimXfer *))
+purple_xfer_set_read_fnc(PurpleXfer *xfer, gssize (*fnc)(guchar **, PurpleXfer *))
 {
 	g_return_if_fail(xfer != NULL);
 
@@ -752,8 +752,8 @@
 }
 
 void
-gaim_xfer_set_write_fnc(GaimXfer *xfer,
-						gssize (*fnc)(const guchar *, size_t, GaimXfer *))
+purple_xfer_set_write_fnc(PurpleXfer *xfer,
+						gssize (*fnc)(const guchar *, size_t, PurpleXfer *))
 {
 	g_return_if_fail(xfer != NULL);
 
@@ -761,8 +761,8 @@
 }
 
 void
-gaim_xfer_set_ack_fnc(GaimXfer *xfer,
-			  void (*fnc)(GaimXfer *, const guchar *, size_t))
+purple_xfer_set_ack_fnc(PurpleXfer *xfer,
+			  void (*fnc)(PurpleXfer *, const guchar *, size_t))
 {
 	g_return_if_fail(xfer != NULL);
 
@@ -770,7 +770,7 @@
 }
 
 void
-gaim_xfer_set_start_fnc(GaimXfer *xfer, void (*fnc)(GaimXfer *))
+purple_xfer_set_start_fnc(PurpleXfer *xfer, void (*fnc)(PurpleXfer *))
 {
 	g_return_if_fail(xfer != NULL);
 
@@ -778,7 +778,7 @@
 }
 
 void
-gaim_xfer_set_end_fnc(GaimXfer *xfer, void (*fnc)(GaimXfer *))
+purple_xfer_set_end_fnc(PurpleXfer *xfer, void (*fnc)(PurpleXfer *))
 {
 	g_return_if_fail(xfer != NULL);
 
@@ -786,7 +786,7 @@
 }
 
 void
-gaim_xfer_set_cancel_send_fnc(GaimXfer *xfer, void (*fnc)(GaimXfer *))
+purple_xfer_set_cancel_send_fnc(PurpleXfer *xfer, void (*fnc)(PurpleXfer *))
 {
 	g_return_if_fail(xfer != NULL);
 
@@ -794,7 +794,7 @@
 }
 
 void
-gaim_xfer_set_cancel_recv_fnc(GaimXfer *xfer, void (*fnc)(GaimXfer *))
+purple_xfer_set_cancel_recv_fnc(PurpleXfer *xfer, void (*fnc)(PurpleXfer *))
 {
 	g_return_if_fail(xfer != NULL);
 
@@ -802,24 +802,24 @@
 }
 
 static void
-gaim_xfer_increase_buffer_size(GaimXfer *xfer)
+purple_xfer_increase_buffer_size(PurpleXfer *xfer)
 {
 	xfer->current_buffer_size = MIN(xfer->current_buffer_size * 1.5,
 			FT_MAX_BUFFER_SIZE);
 }
 
 gssize
-gaim_xfer_read(GaimXfer *xfer, guchar **buffer)
+purple_xfer_read(PurpleXfer *xfer, guchar **buffer)
 {
 	gssize s, r;
 
 	g_return_val_if_fail(xfer   != NULL, 0);
 	g_return_val_if_fail(buffer != NULL, 0);
 
-	if (gaim_xfer_get_size(xfer) == 0)
+	if (purple_xfer_get_size(xfer) == 0)
 		s = xfer->current_buffer_size;
 	else
-		s = MIN(gaim_xfer_get_bytes_remaining(xfer), xfer->current_buffer_size);
+		s = MIN(purple_xfer_get_bytes_remaining(xfer), xfer->current_buffer_size);
 
 	if (xfer->ops.read != NULL)
 		r = (xfer->ops.read)(buffer, xfer);
@@ -831,9 +831,9 @@
 			r = 0;
 		else if (r < 0)
 			r = -1;
-		else if ((gaim_xfer_get_size(xfer) > 0) &&
-			((gaim_xfer_get_bytes_sent(xfer)+r) >= gaim_xfer_get_size(xfer)))
-			gaim_xfer_set_completed(xfer, TRUE);
+		else if ((purple_xfer_get_size(xfer) > 0) &&
+			((purple_xfer_get_bytes_sent(xfer)+r) >= purple_xfer_get_size(xfer)))
+			purple_xfer_set_completed(xfer, TRUE);
 		else if (r == 0)
 			r = -1;
 	}
@@ -844,13 +844,13 @@
 		 * network is fast and our buffer is too small, so make it
 		 * bigger.
 		 */
-		gaim_xfer_increase_buffer_size(xfer);
+		purple_xfer_increase_buffer_size(xfer);
 
 	return r;
 }
 
 gssize
-gaim_xfer_write(GaimXfer *xfer, const guchar *buffer, gsize size)
+purple_xfer_write(PurpleXfer *xfer, const guchar *buffer, gsize size)
 {
 	gssize r, s;
 
@@ -858,7 +858,7 @@
 	g_return_val_if_fail(buffer != NULL, 0);
 	g_return_val_if_fail(size   != 0,    0);
 
-	s = MIN(gaim_xfer_get_bytes_remaining(xfer), size);
+	s = MIN(purple_xfer_get_bytes_remaining(xfer), size);
 
 	if (xfer->ops.write != NULL) {
 		r = (xfer->ops.write)(buffer, s, xfer);
@@ -866,39 +866,39 @@
 		r = write(xfer->fd, buffer, s);
 		if (r < 0 && errno == EAGAIN)
 			r = 0;
-		if ((gaim_xfer_get_bytes_sent(xfer)+r) >= gaim_xfer_get_size(xfer))
-			gaim_xfer_set_completed(xfer, TRUE);
+		if ((purple_xfer_get_bytes_sent(xfer)+r) >= purple_xfer_get_size(xfer))
+			purple_xfer_set_completed(xfer, TRUE);
 	}
 
 	return r;
 }
 
 static void
-transfer_cb(gpointer data, gint source, GaimInputCondition condition)
+transfer_cb(gpointer data, gint source, PurpleInputCondition condition)
 {
-	GaimXferUiOps *ui_ops;
-	GaimXfer *xfer = (GaimXfer *)data;
+	PurpleXferUiOps *ui_ops;
+	PurpleXfer *xfer = (PurpleXfer *)data;
 	guchar *buffer = NULL;
 	gssize r = 0;
 
-	if (condition & GAIM_INPUT_READ) {
-		r = gaim_xfer_read(xfer, &buffer);
+	if (condition & PURPLE_INPUT_READ) {
+		r = purple_xfer_read(xfer, &buffer);
 		if (r > 0) {
 			fwrite(buffer, 1, r, xfer->dest_fp);
 		} else if(r <= 0) {
-			gaim_xfer_cancel_remote(xfer);
+			purple_xfer_cancel_remote(xfer);
 			return;
 		}
 	}
 
-	if (condition & GAIM_INPUT_WRITE) {
-		size_t s = MIN(gaim_xfer_get_bytes_remaining(xfer), xfer->current_buffer_size);
+	if (condition & PURPLE_INPUT_WRITE) {
+		size_t s = MIN(purple_xfer_get_bytes_remaining(xfer), xfer->current_buffer_size);
 
 		/* this is so the prpl can keep the connection open
 		   if it needs to for some odd reason. */
 		if (s == 0) {
 			if (xfer->watcher) {
-				gaim_input_remove(xfer->watcher);
+				purple_input_remove(xfer->watcher);
 				xfer->watcher = 0;
 			}
 			return;
@@ -909,10 +909,10 @@
 		fread(buffer, 1, s, xfer->dest_fp);
 
 		/* Write as much as we're allowed to. */
-		r = gaim_xfer_write(xfer, buffer, s);
+		r = purple_xfer_write(xfer, buffer, s);
 
 		if (r == -1) {
-			gaim_xfer_cancel_remote(xfer);
+			purple_xfer_cancel_remote(xfer);
 			g_free(buffer);
 			return;
 		} else if (r < s) {
@@ -924,12 +924,12 @@
 			 * network is fast and our buffer is too small, so make it
 			 * bigger.
 			 */
-			gaim_xfer_increase_buffer_size(xfer);
+			purple_xfer_increase_buffer_size(xfer);
 		}
 	}
 
 	if (r > 0) {
-		if (gaim_xfer_get_size(xfer) > 0)
+		if (purple_xfer_get_size(xfer) > 0)
 			xfer->bytes_remaining -= r;
 
 		xfer->bytes_sent += r;
@@ -939,34 +939,34 @@
 
 		g_free(buffer);
 
-		ui_ops = gaim_xfer_get_ui_ops(xfer);
+		ui_ops = purple_xfer_get_ui_ops(xfer);
 
 		if (ui_ops != NULL && ui_ops->update_progress != NULL)
 			ui_ops->update_progress(xfer,
-				gaim_xfer_get_progress(xfer));
+				purple_xfer_get_progress(xfer));
 	}
 
-	if (gaim_xfer_is_completed(xfer))
-		gaim_xfer_end(xfer);
+	if (purple_xfer_is_completed(xfer))
+		purple_xfer_end(xfer);
 }
 
 static void
-begin_transfer(GaimXfer *xfer, GaimInputCondition cond)
+begin_transfer(PurpleXfer *xfer, PurpleInputCondition cond)
 {
-	GaimXferType type = gaim_xfer_get_type(xfer);
+	PurpleXferType type = purple_xfer_get_type(xfer);
 
-	xfer->dest_fp = g_fopen(gaim_xfer_get_local_filename(xfer),
-						  type == GAIM_XFER_RECEIVE ? "wb" : "rb");
+	xfer->dest_fp = g_fopen(purple_xfer_get_local_filename(xfer),
+						  type == PURPLE_XFER_RECEIVE ? "wb" : "rb");
 
 	if (xfer->dest_fp == NULL) {
-		gaim_xfer_show_file_error(xfer, gaim_xfer_get_local_filename(xfer));
-		gaim_xfer_cancel_local(xfer);
+		purple_xfer_show_file_error(xfer, purple_xfer_get_local_filename(xfer));
+		purple_xfer_cancel_local(xfer);
 		return;
 	}
 
 	fseek(xfer->dest_fp, xfer->bytes_sent, SEEK_SET);
 
-	xfer->watcher = gaim_input_add(xfer->fd, cond, transfer_cb, xfer);
+	xfer->watcher = purple_input_add(xfer->fd, cond, transfer_cb, xfer);
 
 	xfer->start_time = time(NULL);
 
@@ -977,36 +977,36 @@
 static void
 connect_cb(gpointer data, gint source, const gchar *error_message)
 {
-	GaimXfer *xfer = (GaimXfer *)data;
+	PurpleXfer *xfer = (PurpleXfer *)data;
 
 	xfer->fd = source;
 
-	begin_transfer(xfer, GAIM_INPUT_READ);
+	begin_transfer(xfer, PURPLE_INPUT_READ);
 }
 
 void
-gaim_xfer_start(GaimXfer *xfer, int fd, const char *ip,
+purple_xfer_start(PurpleXfer *xfer, int fd, const char *ip,
 				unsigned int port)
 {
-	GaimInputCondition cond;
-	GaimXferType type;
+	PurpleInputCondition cond;
+	PurpleXferType type;
 
 	g_return_if_fail(xfer != NULL);
-	g_return_if_fail(gaim_xfer_get_type(xfer) != GAIM_XFER_UNKNOWN);
+	g_return_if_fail(purple_xfer_get_type(xfer) != PURPLE_XFER_UNKNOWN);
 
-	type = gaim_xfer_get_type(xfer);
+	type = purple_xfer_get_type(xfer);
 
-	gaim_xfer_set_status(xfer, GAIM_XFER_STATUS_STARTED);
+	purple_xfer_set_status(xfer, PURPLE_XFER_STATUS_STARTED);
 
-	if (type == GAIM_XFER_RECEIVE) {
-		cond = GAIM_INPUT_READ;
+	if (type == PURPLE_XFER_RECEIVE) {
+		cond = PURPLE_INPUT_READ;
 
 		if (ip != NULL) {
 			xfer->remote_ip   = g_strdup(ip);
 			xfer->remote_port = port;
 
 			/* Establish a file descriptor. */
-			gaim_proxy_connect(NULL, xfer->account, xfer->remote_ip,
+			purple_proxy_connect(NULL, xfer->account, xfer->remote_ip,
 							   xfer->remote_port, connect_cb, xfer);
 
 			return;
@@ -1016,7 +1016,7 @@
 		}
 	}
 	else {
-		cond = GAIM_INPUT_WRITE;
+		cond = PURPLE_INPUT_WRITE;
 
 		xfer->fd = fd;
 	}
@@ -1025,13 +1025,13 @@
 }
 
 void
-gaim_xfer_end(GaimXfer *xfer)
+purple_xfer_end(PurpleXfer *xfer)
 {
 	g_return_if_fail(xfer != NULL);
 
 	/* See if we are actually trying to cancel this. */
-	if (!gaim_xfer_is_completed(xfer)) {
-		gaim_xfer_cancel_local(xfer);
+	if (!purple_xfer_is_completed(xfer)) {
+		purple_xfer_cancel_local(xfer);
 		return;
 	}
 
@@ -1040,7 +1040,7 @@
 		xfer->ops.end(xfer);
 
 	if (xfer->watcher != 0) {
-		gaim_input_remove(xfer->watcher);
+		purple_input_remove(xfer->watcher);
 		xfer->watcher = 0;
 	}
 
@@ -1052,46 +1052,46 @@
 		xfer->dest_fp = NULL;
 	}
 
-	gaim_xfer_unref(xfer);
+	purple_xfer_unref(xfer);
 }
 
 void
-gaim_xfer_add(GaimXfer *xfer)
+purple_xfer_add(PurpleXfer *xfer)
 {
-	GaimXferUiOps *ui_ops;
+	PurpleXferUiOps *ui_ops;
 
 	g_return_if_fail(xfer != NULL);
 
-	ui_ops = gaim_xfer_get_ui_ops(xfer);
+	ui_ops = purple_xfer_get_ui_ops(xfer);
 
 	if (ui_ops != NULL && ui_ops->add_xfer != NULL)
 		ui_ops->add_xfer(xfer);
 }
 
 void
-gaim_xfer_cancel_local(GaimXfer *xfer)
+purple_xfer_cancel_local(PurpleXfer *xfer)
 {
-	GaimXferUiOps *ui_ops;
+	PurpleXferUiOps *ui_ops;
 	char *msg = NULL;
 
 	g_return_if_fail(xfer != NULL);
 
-	gaim_xfer_set_status(xfer, GAIM_XFER_STATUS_CANCEL_LOCAL);
+	purple_xfer_set_status(xfer, PURPLE_XFER_STATUS_CANCEL_LOCAL);
 	xfer->end_time = time(NULL);
 
-	if (gaim_xfer_get_filename(xfer) != NULL)
+	if (purple_xfer_get_filename(xfer) != NULL)
 	{
 		msg = g_strdup_printf(_("You canceled the transfer of %s"),
-							  gaim_xfer_get_filename(xfer));
+							  purple_xfer_get_filename(xfer));
 	}
 	else
 	{
 		msg = g_strdup_printf(_("File transfer cancelled"));
 	}
-	gaim_xfer_conversation_write(xfer, msg, FALSE);
+	purple_xfer_conversation_write(xfer, msg, FALSE);
 	g_free(msg);
 
-	if (gaim_xfer_get_type(xfer) == GAIM_XFER_SEND)
+	if (purple_xfer_get_type(xfer) == PURPLE_XFER_SEND)
 	{
 		if (xfer->ops.cancel_send != NULL)
 			xfer->ops.cancel_send(xfer);
@@ -1103,7 +1103,7 @@
 	}
 
 	if (xfer->watcher != 0) {
-		gaim_input_remove(xfer->watcher);
+		purple_input_remove(xfer->watcher);
 		xfer->watcher = 0;
 	}
 
@@ -1115,48 +1115,48 @@
 		xfer->dest_fp = NULL;
 	}
 
-	ui_ops = gaim_xfer_get_ui_ops(xfer);
+	ui_ops = purple_xfer_get_ui_ops(xfer);
 
 	if (ui_ops != NULL && ui_ops->cancel_local != NULL)
 		ui_ops->cancel_local(xfer);
 
 	xfer->bytes_remaining = 0;
 
-	gaim_xfer_unref(xfer);
+	purple_xfer_unref(xfer);
 }
 
 void
-gaim_xfer_cancel_remote(GaimXfer *xfer)
+purple_xfer_cancel_remote(PurpleXfer *xfer)
 {
-	GaimXferUiOps *ui_ops;
+	PurpleXferUiOps *ui_ops;
 	gchar *msg;
-	GaimAccount *account;
-	GaimBuddy *buddy;
+	PurpleAccount *account;
+	PurpleBuddy *buddy;
 
 	g_return_if_fail(xfer != NULL);
 
-	gaim_request_close_with_handle(xfer);
-	gaim_xfer_set_status(xfer, GAIM_XFER_STATUS_CANCEL_REMOTE);
+	purple_request_close_with_handle(xfer);
+	purple_xfer_set_status(xfer, PURPLE_XFER_STATUS_CANCEL_REMOTE);
 	xfer->end_time = time(NULL);
 
-	account = gaim_xfer_get_account(xfer);
-	buddy = gaim_find_buddy(account, xfer->who);
+	account = purple_xfer_get_account(xfer);
+	buddy = purple_find_buddy(account, xfer->who);
 
-	if (gaim_xfer_get_filename(xfer) != NULL)
+	if (purple_xfer_get_filename(xfer) != NULL)
 	{
 		msg = g_strdup_printf(_("%s canceled the transfer of %s"),
-				buddy ? gaim_buddy_get_alias(buddy) : xfer->who, gaim_xfer_get_filename(xfer));
+				buddy ? purple_buddy_get_alias(buddy) : xfer->who, purple_xfer_get_filename(xfer));
 	}
 	else
 	{
 		msg = g_strdup_printf(_("%s canceled the file transfer"),
-				buddy ? gaim_buddy_get_alias(buddy) : xfer->who);
+				buddy ? purple_buddy_get_alias(buddy) : xfer->who);
 	}
-	gaim_xfer_conversation_write(xfer, msg, TRUE);
-	gaim_xfer_error(gaim_xfer_get_type(xfer), account, xfer->who, msg);
+	purple_xfer_conversation_write(xfer, msg, TRUE);
+	purple_xfer_error(purple_xfer_get_type(xfer), account, xfer->who, msg);
 	g_free(msg);
 
-	if (gaim_xfer_get_type(xfer) == GAIM_XFER_SEND)
+	if (purple_xfer_get_type(xfer) == PURPLE_XFER_SEND)
 	{
 		if (xfer->ops.cancel_send != NULL)
 			xfer->ops.cancel_send(xfer);
@@ -1168,7 +1168,7 @@
 	}
 
 	if (xfer->watcher != 0) {
-		gaim_input_remove(xfer->watcher);
+		purple_input_remove(xfer->watcher);
 		xfer->watcher = 0;
 	}
 
@@ -1180,51 +1180,51 @@
 		xfer->dest_fp = NULL;
 	}
 
-	ui_ops = gaim_xfer_get_ui_ops(xfer);
+	ui_ops = purple_xfer_get_ui_ops(xfer);
 
 	if (ui_ops != NULL && ui_ops->cancel_remote != NULL)
 		ui_ops->cancel_remote(xfer);
 
 	xfer->bytes_remaining = 0;
 
-	gaim_xfer_unref(xfer);
+	purple_xfer_unref(xfer);
 }
 
 void
-gaim_xfer_error(GaimXferType type, GaimAccount *account, const char *who, const char *msg)
+purple_xfer_error(PurpleXferType type, PurpleAccount *account, const char *who, const char *msg)
 {
 	char *title;
 
 	g_return_if_fail(msg  != NULL);
-	g_return_if_fail(type != GAIM_XFER_UNKNOWN);
+	g_return_if_fail(type != PURPLE_XFER_UNKNOWN);
 
 	if (account) {
-		GaimBuddy *buddy;
-		buddy = gaim_find_buddy(account, who);
+		PurpleBuddy *buddy;
+		buddy = purple_find_buddy(account, who);
 		if (buddy)
-			who = gaim_buddy_get_alias(buddy);
+			who = purple_buddy_get_alias(buddy);
 	}
 
-	if (type == GAIM_XFER_SEND)
+	if (type == PURPLE_XFER_SEND)
 		title = g_strdup_printf(_("File transfer to %s failed."), who);
 	else
 		title = g_strdup_printf(_("File transfer from %s failed."), who);
 
-	gaim_notify_error(NULL, NULL, title, msg);
+	purple_notify_error(NULL, NULL, title, msg);
 
 	g_free(title);
 }
 
 void
-gaim_xfer_update_progress(GaimXfer *xfer)
+purple_xfer_update_progress(PurpleXfer *xfer)
 {
-	GaimXferUiOps *ui_ops;
+	PurpleXferUiOps *ui_ops;
 
 	g_return_if_fail(xfer != NULL);
 
-	ui_ops = gaim_xfer_get_ui_ops(xfer);
+	ui_ops = purple_xfer_get_ui_ops(xfer);
 	if (ui_ops != NULL && ui_ops->update_progress != NULL)
-		ui_ops->update_progress(xfer, gaim_xfer_get_progress(xfer));
+		ui_ops->update_progress(xfer, purple_xfer_get_progress(xfer));
 }
 
 
@@ -1232,66 +1232,66 @@
  * File Transfer Subsystem API
  **************************************************************************/
 void *
-gaim_xfers_get_handle(void) {
+purple_xfers_get_handle(void) {
 	static int handle = 0;
 
 	return &handle;
 }
 
 void
-gaim_xfers_init(void) {
-	void *handle = gaim_xfers_get_handle();
+purple_xfers_init(void) {
+	void *handle = purple_xfers_get_handle();
 
 	/* register signals */
-	gaim_signal_register(handle, "file-recv-accept",
-	                     gaim_marshal_VOID__POINTER, NULL, 1,
-	                     gaim_value_new(GAIM_TYPE_SUBTYPE,
-	                                    GAIM_SUBTYPE_XFER));
-	gaim_signal_register(handle, "file-send-accept",
-	                     gaim_marshal_VOID__POINTER, NULL, 1,
-	                     gaim_value_new(GAIM_TYPE_SUBTYPE,
-	                                    GAIM_SUBTYPE_XFER));
-	gaim_signal_register(handle, "file-recv-start",
-	                     gaim_marshal_VOID__POINTER, NULL, 1,
-	                     gaim_value_new(GAIM_TYPE_SUBTYPE,
-	                                    GAIM_SUBTYPE_XFER));
-	gaim_signal_register(handle, "file-send-start",
-	                     gaim_marshal_VOID__POINTER, NULL, 1,
-	                     gaim_value_new(GAIM_TYPE_SUBTYPE,
-	                                    GAIM_SUBTYPE_XFER));
-	gaim_signal_register(handle, "file-send-cancel",
-	                     gaim_marshal_VOID__POINTER, NULL, 1,
-	                     gaim_value_new(GAIM_TYPE_SUBTYPE,
-	                                    GAIM_SUBTYPE_XFER));
-	gaim_signal_register(handle, "file-recv-cancel",
-	                     gaim_marshal_VOID__POINTER, NULL, 1,
-	                     gaim_value_new(GAIM_TYPE_SUBTYPE,
-	                                    GAIM_SUBTYPE_XFER));
-	gaim_signal_register(handle, "file-send-complete",
-	                     gaim_marshal_VOID__POINTER, NULL, 1,
-	                     gaim_value_new(GAIM_TYPE_SUBTYPE,
-	                                    GAIM_SUBTYPE_XFER));
-	gaim_signal_register(handle, "file-recv-complete",
-	                     gaim_marshal_VOID__POINTER, NULL, 1,
-	                     gaim_value_new(GAIM_TYPE_SUBTYPE,
-	                                    GAIM_SUBTYPE_XFER));
-	gaim_signal_register(handle, "file-recv-request",
-	                     gaim_marshal_VOID__POINTER, NULL, 1,
-	                     gaim_value_new(GAIM_TYPE_SUBTYPE,
-	                                    GAIM_SUBTYPE_XFER));
+	purple_signal_register(handle, "file-recv-accept",
+	                     purple_marshal_VOID__POINTER, NULL, 1,
+	                     purple_value_new(PURPLE_TYPE_SUBTYPE,
+	                                    PURPLE_SUBTYPE_XFER));
+	purple_signal_register(handle, "file-send-accept",
+	                     purple_marshal_VOID__POINTER, NULL, 1,
+	                     purple_value_new(PURPLE_TYPE_SUBTYPE,
+	                                    PURPLE_SUBTYPE_XFER));
+	purple_signal_register(handle, "file-recv-start",
+	                     purple_marshal_VOID__POINTER, NULL, 1,
+	                     purple_value_new(PURPLE_TYPE_SUBTYPE,
+	                                    PURPLE_SUBTYPE_XFER));
+	purple_signal_register(handle, "file-send-start",
+	                     purple_marshal_VOID__POINTER, NULL, 1,
+	                     purple_value_new(PURPLE_TYPE_SUBTYPE,
+	                                    PURPLE_SUBTYPE_XFER));
+	purple_signal_register(handle, "file-send-cancel",
+	                     purple_marshal_VOID__POINTER, NULL, 1,
+	                     purple_value_new(PURPLE_TYPE_SUBTYPE,
+	                                    PURPLE_SUBTYPE_XFER));
+	purple_signal_register(handle, "file-recv-cancel",
+	                     purple_marshal_VOID__POINTER, NULL, 1,
+	                     purple_value_new(PURPLE_TYPE_SUBTYPE,
+	                                    PURPLE_SUBTYPE_XFER));
+	purple_signal_register(handle, "file-send-complete",
+	                     purple_marshal_VOID__POINTER, NULL, 1,
+	                     purple_value_new(PURPLE_TYPE_SUBTYPE,
+	                                    PURPLE_SUBTYPE_XFER));
+	purple_signal_register(handle, "file-recv-complete",
+	                     purple_marshal_VOID__POINTER, NULL, 1,
+	                     purple_value_new(PURPLE_TYPE_SUBTYPE,
+	                                    PURPLE_SUBTYPE_XFER));
+	purple_signal_register(handle, "file-recv-request",
+	                     purple_marshal_VOID__POINTER, NULL, 1,
+	                     purple_value_new(PURPLE_TYPE_SUBTYPE,
+	                                    PURPLE_SUBTYPE_XFER));
 }
 
 void
-gaim_xfers_uninit(void) {
-	gaim_signals_disconnect_by_handle(gaim_xfers_get_handle());
+purple_xfers_uninit(void) {
+	purple_signals_disconnect_by_handle(purple_xfers_get_handle());
 }
 
 void
-gaim_xfers_set_ui_ops(GaimXferUiOps *ops) {
+purple_xfers_set_ui_ops(PurpleXferUiOps *ops) {
 	xfer_ui_ops = ops;
 }
 
-GaimXferUiOps *
-gaim_xfers_get_ui_ops(void) {
+PurpleXferUiOps *
+purple_xfers_get_ui_ops(void) {
 	return xfer_ui_ops;
 }