Mercurial > pidgin.yaz

comparison libpurple/ft.c @ 15823:32c366eeeb99

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
sed -ie 's/gaim/purple/g'
author Sean Egan <seanegan@gmail.com>
date Mon, 19 Mar 2007 07:01:17 +0000
parents 35fa1d1c4ef2
children 08db93bbd798
comparison
equal deleted inserted replaced
15822:84b0f9b23ede 15823:32c366eeeb99
1 /** 1 /**
2 * @file ft.c File Transfer API 2 * @file ft.c File Transfer API
3 * 3 *
4 * gaim 4 * purple
5 * 5 *
6 * Gaim is the legal property of its developers, whose names are too numerous 6 * Purple is the legal property of its developers, whose names are too numerous
7 * to list here. Please refer to the COPYRIGHT file distributed with this 7 * to list here. Please refer to the COPYRIGHT file distributed with this
8 * source distribution. 8 * source distribution.
9 * 9 *
10 * This program is free software; you can redistribute it and/or modify 10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by 11 * it under the terms of the GNU General Public License as published by
32 #include "util.h" 32 #include "util.h"
33 33
34 #define FT_INITIAL_BUFFER_SIZE 4096 34 #define FT_INITIAL_BUFFER_SIZE 4096
35 #define FT_MAX_BUFFER_SIZE 65535 35 #define FT_MAX_BUFFER_SIZE 65535
36 36
37 static GaimXferUiOps *xfer_ui_ops = NULL; 37 static PurpleXferUiOps *xfer_ui_ops = NULL;
38 static GList *xfers; 38 static GList *xfers;
39 39
40 static int gaim_xfer_choose_file(GaimXfer *xfer); 40 static int purple_xfer_choose_file(PurpleXfer *xfer);
41 41
42 GList * 42 GList *
43 gaim_xfers_get_all() 43 purple_xfers_get_all()
44 { 44 {
45 return xfers; 45 return xfers;
46 } 46 }
47 47
48 GaimXfer * 48 PurpleXfer *
49 gaim_xfer_new(GaimAccount *account, GaimXferType type, const char *who) 49 purple_xfer_new(PurpleAccount *account, PurpleXferType type, const char *who)
50 { 50 {
51 GaimXfer *xfer; 51 PurpleXfer *xfer;
52 GaimXferUiOps *ui_ops; 52 PurpleXferUiOps *ui_ops;
53 53
54 g_return_val_if_fail(type != GAIM_XFER_UNKNOWN, NULL); 54 g_return_val_if_fail(type != PURPLE_XFER_UNKNOWN, NULL);
55 g_return_val_if_fail(account != NULL, NULL); 55 g_return_val_if_fail(account != NULL, NULL);
56 g_return_val_if_fail(who != NULL, NULL); 56 g_return_val_if_fail(who != NULL, NULL);
57 57
58 xfer = g_new0(GaimXfer, 1); 58 xfer = g_new0(PurpleXfer, 1);
59 59
60 xfer->ref = 1; 60 xfer->ref = 1;
61 xfer->type = type; 61 xfer->type = type;
62 xfer->account = account; 62 xfer->account = account;
63 xfer->who = g_strdup(who); 63 xfer->who = g_strdup(who);
64 xfer->ui_ops = gaim_xfers_get_ui_ops(); 64 xfer->ui_ops = purple_xfers_get_ui_ops();
65 xfer->message = NULL; 65 xfer->message = NULL;
66 xfer->current_buffer_size = FT_INITIAL_BUFFER_SIZE; 66 xfer->current_buffer_size = FT_INITIAL_BUFFER_SIZE;
67 67
68 ui_ops = gaim_xfer_get_ui_ops(xfer); 68 ui_ops = purple_xfer_get_ui_ops(xfer);
69 69
70 if (ui_ops != NULL && ui_ops->new_xfer != NULL) 70 if (ui_ops != NULL && ui_ops->new_xfer != NULL)
71 ui_ops->new_xfer(xfer); 71 ui_ops->new_xfer(xfer);
72 72
73 xfers = g_list_prepend(xfers, xfer); 73 xfers = g_list_prepend(xfers, xfer);
74 return xfer; 74 return xfer;
75 } 75 }
76 76
77 static void 77 static void
78 gaim_xfer_destroy(GaimXfer *xfer) 78 purple_xfer_destroy(PurpleXfer *xfer)
79 { 79 {
80 GaimXferUiOps *ui_ops; 80 PurpleXferUiOps *ui_ops;
81 81
82 g_return_if_fail(xfer != NULL); 82 g_return_if_fail(xfer != NULL);
83 83
84 /* Close the file browser, if it's open */ 84 /* Close the file browser, if it's open */
85 gaim_request_close_with_handle(xfer); 85 purple_request_close_with_handle(xfer);
86 86
87 if (gaim_xfer_get_status(xfer) == GAIM_XFER_STATUS_STARTED) 87 if (purple_xfer_get_status(xfer) == PURPLE_XFER_STATUS_STARTED)
88 gaim_xfer_cancel_local(xfer); 88 purple_xfer_cancel_local(xfer);
89 89
90 ui_ops = gaim_xfer_get_ui_ops(xfer); 90 ui_ops = purple_xfer_get_ui_ops(xfer);
91 91
92 if (ui_ops != NULL && ui_ops->destroy != NULL) 92 if (ui_ops != NULL && ui_ops->destroy != NULL)
93 ui_ops->destroy(xfer); 93 ui_ops->destroy(xfer);
94 94
95 g_free(xfer->who); 95 g_free(xfer->who);
100 g_free(xfer); 100 g_free(xfer);
101 xfers = g_list_remove(xfers, xfer); 101 xfers = g_list_remove(xfers, xfer);
102 } 102 }
103 103
104 void 104 void
105 gaim_xfer_ref(GaimXfer *xfer) 105 purple_xfer_ref(PurpleXfer *xfer)
106 { 106 {
107 g_return_if_fail(xfer != NULL); 107 g_return_if_fail(xfer != NULL);
108 108
109 xfer->ref++; 109 xfer->ref++;
110 } 110 }
111 111
112 void 112 void
113 gaim_xfer_unref(GaimXfer *xfer) 113 purple_xfer_unref(PurpleXfer *xfer)
114 { 114 {
115 g_return_if_fail(xfer != NULL); 115 g_return_if_fail(xfer != NULL);
116 g_return_if_fail(xfer->ref > 0); 116 g_return_if_fail(xfer->ref > 0);
117 117
118 xfer->ref--; 118 xfer->ref--;
119 119
120 if (xfer->ref == 0) 120 if (xfer->ref == 0)
121 gaim_xfer_destroy(xfer); 121 purple_xfer_destroy(xfer);
122 } 122 }
123 123
124 static void 124 static void
125 gaim_xfer_set_status(GaimXfer *xfer, GaimXferStatusType status) 125 purple_xfer_set_status(PurpleXfer *xfer, PurpleXferStatusType status)
126 { 126 {
127 g_return_if_fail(xfer != NULL); 127 g_return_if_fail(xfer != NULL);
128 128
129 if(xfer->type == GAIM_XFER_SEND) { 129 if(xfer->type == PURPLE_XFER_SEND) {
130 switch(status) { 130 switch(status) {
131 case GAIM_XFER_STATUS_ACCEPTED: 131 case PURPLE_XFER_STATUS_ACCEPTED:
132 gaim_signal_emit(gaim_xfers_get_handle(), "file-send-accept", xfer); 132 purple_signal_emit(purple_xfers_get_handle(), "file-send-accept", xfer);
133 break; 133 break;
134 case GAIM_XFER_STATUS_STARTED: 134 case PURPLE_XFER_STATUS_STARTED:
135 gaim_signal_emit(gaim_xfers_get_handle(), "file-send-start", xfer); 135 purple_signal_emit(purple_xfers_get_handle(), "file-send-start", xfer);
136 break; 136 break;
137 case GAIM_XFER_STATUS_DONE: 137 case PURPLE_XFER_STATUS_DONE:
138 gaim_signal_emit(gaim_xfers_get_handle(), "file-send-complete", xfer); 138 purple_signal_emit(purple_xfers_get_handle(), "file-send-complete", xfer);
139 break; 139 break;
140 case GAIM_XFER_STATUS_CANCEL_LOCAL: 140 case PURPLE_XFER_STATUS_CANCEL_LOCAL:
141 case GAIM_XFER_STATUS_CANCEL_REMOTE: 141 case PURPLE_XFER_STATUS_CANCEL_REMOTE:
142 gaim_signal_emit(gaim_xfers_get_handle(), "file-send-cancel", xfer); 142 purple_signal_emit(purple_xfers_get_handle(), "file-send-cancel", xfer);
143 break; 143 break;
144 default: 144 default:
145 break; 145 break;
146 } 146 }
147 } else if(xfer->type == GAIM_XFER_RECEIVE) { 147 } else if(xfer->type == PURPLE_XFER_RECEIVE) {
148 switch(status) { 148 switch(status) {
149 case GAIM_XFER_STATUS_ACCEPTED: 149 case PURPLE_XFER_STATUS_ACCEPTED:
150 gaim_signal_emit(gaim_xfers_get_handle(), "file-recv-accept", xfer); 150 purple_signal_emit(purple_xfers_get_handle(), "file-recv-accept", xfer);
151 break; 151 break;
152 case GAIM_XFER_STATUS_STARTED: 152 case PURPLE_XFER_STATUS_STARTED:
153 gaim_signal_emit(gaim_xfers_get_handle(), "file-recv-start", xfer); 153 purple_signal_emit(purple_xfers_get_handle(), "file-recv-start", xfer);
154 break; 154 break;
155 case GAIM_XFER_STATUS_DONE: 155 case PURPLE_XFER_STATUS_DONE:
156 gaim_signal_emit(gaim_xfers_get_handle(), "file-recv-complete", xfer); 156 purple_signal_emit(purple_xfers_get_handle(), "file-recv-complete", xfer);
157 break; 157 break;
158 case GAIM_XFER_STATUS_CANCEL_LOCAL: 158 case PURPLE_XFER_STATUS_CANCEL_LOCAL:
159 case GAIM_XFER_STATUS_CANCEL_REMOTE: 159 case PURPLE_XFER_STATUS_CANCEL_REMOTE:
160 gaim_signal_emit(gaim_xfers_get_handle(), "file-recv-cancel", xfer); 160 purple_signal_emit(purple_xfers_get_handle(), "file-recv-cancel", xfer);
161 break; 161 break;
162 default: 162 default:
163 break; 163 break;
164 } 164 }
165 } 165 }
166 166
167 xfer->status = status; 167 xfer->status = status;
168 } 168 }
169 169
170 void gaim_xfer_conversation_write(GaimXfer *xfer, char *message, gboolean is_error) 170 void purple_xfer_conversation_write(PurpleXfer *xfer, char *message, gboolean is_error)
171 { 171 {
172 GaimConversation *conv = NULL; 172 PurpleConversation *conv = NULL;
173 GaimMessageFlags flags = GAIM_MESSAGE_SYSTEM; 173 PurpleMessageFlags flags = PURPLE_MESSAGE_SYSTEM;
174 char *escaped; 174 char *escaped;
175 175
176 g_return_if_fail(xfer != NULL); 176 g_return_if_fail(xfer != NULL);
177 g_return_if_fail(message != NULL); 177 g_return_if_fail(message != NULL);
178 178
179 conv = gaim_find_conversation_with_account(GAIM_CONV_TYPE_IM, xfer->who, 179 conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, xfer->who,
180 gaim_xfer_get_account(xfer)); 180 purple_xfer_get_account(xfer));
181 181
182 if (conv == NULL) 182 if (conv == NULL)
183 return; 183 return;
184 184
185 escaped = g_markup_escape_text(message, -1); 185 escaped = g_markup_escape_text(message, -1);
186 186
187 if (is_error) 187 if (is_error)
188 flags = GAIM_MESSAGE_ERROR; 188 flags = PURPLE_MESSAGE_ERROR;
189 189
190 gaim_conversation_write(conv, NULL, escaped, flags, time(NULL)); 190 purple_conversation_write(conv, NULL, escaped, flags, time(NULL));
191 g_free(escaped); 191 g_free(escaped);
192 } 192 }
193 193
194 static void gaim_xfer_show_file_error(GaimXfer *xfer, const char *filename) 194 static void purple_xfer_show_file_error(PurpleXfer *xfer, const char *filename)
195 { 195 {
196 int err = errno; 196 int err = errno;
197 gchar *msg = NULL, *utf8; 197 gchar *msg = NULL, *utf8;
198 GaimXferType xfer_type = gaim_xfer_get_type(xfer); 198 PurpleXferType xfer_type = purple_xfer_get_type(xfer);
199 GaimAccount *account = gaim_xfer_get_account(xfer); 199 PurpleAccount *account = purple_xfer_get_account(xfer);
200 200
201 utf8 = g_filename_to_utf8(filename, -1, NULL, NULL, NULL); 201 utf8 = g_filename_to_utf8(filename, -1, NULL, NULL, NULL);
202 switch(xfer_type) { 202 switch(xfer_type) {
203 case GAIM_XFER_SEND: 203 case PURPLE_XFER_SEND:
204 msg = g_strdup_printf(_("Error reading %s: \n%s.\n"), 204 msg = g_strdup_printf(_("Error reading %s: \n%s.\n"),
205 utf8, strerror(err)); 205 utf8, strerror(err));
206 break; 206 break;
207 case GAIM_XFER_RECEIVE: 207 case PURPLE_XFER_RECEIVE:
208 msg = g_strdup_printf(_("Error writing %s: \n%s.\n"), 208 msg = g_strdup_printf(_("Error writing %s: \n%s.\n"),
209 utf8, strerror(err)); 209 utf8, strerror(err));
210 break; 210 break;
211 default: 211 default:
212 msg = g_strdup_printf(_("Error accessing %s: \n%s.\n"), 212 msg = g_strdup_printf(_("Error accessing %s: \n%s.\n"),
213 utf8, strerror(err)); 213 utf8, strerror(err));
214 break; 214 break;
215 } 215 }
216 g_free(utf8); 216 g_free(utf8);
217 217
218 gaim_xfer_conversation_write(xfer, msg, TRUE); 218 purple_xfer_conversation_write(xfer, msg, TRUE);
219 gaim_xfer_error(xfer_type, account, xfer->who, msg); 219 purple_xfer_error(xfer_type, account, xfer->who, msg);
220 g_free(msg); 220 g_free(msg);
221 } 221 }
222 222
223 static void 223 static void
224 gaim_xfer_choose_file_ok_cb(void *user_data, const char *filename) 224 purple_xfer_choose_file_ok_cb(void *user_data, const char *filename)
225 { 225 {
226 GaimXfer *xfer; 226 PurpleXfer *xfer;
227 struct stat st; 227 struct stat st;
228 gchar *dir; 228 gchar *dir;
229 229
230 xfer = (GaimXfer *)user_data; 230 xfer = (PurpleXfer *)user_data;
231 231
232 if (g_stat(filename, &st) != 0) { 232 if (g_stat(filename, &st) != 0) {
233 /* File not found. */ 233 /* File not found. */
234 if (gaim_xfer_get_type(xfer) == GAIM_XFER_RECEIVE) { 234 if (purple_xfer_get_type(xfer) == PURPLE_XFER_RECEIVE) {
235 #ifndef _WIN32 235 #ifndef _WIN32
236 int mode = W_OK; 236 int mode = W_OK;
237 #else 237 #else
238 int mode = F_OK; 238 int mode = F_OK;
239 #endif 239 #endif
240 dir = g_path_get_dirname(filename); 240 dir = g_path_get_dirname(filename);
241 241
242 if (g_access(dir, mode) == 0) { 242 if (g_access(dir, mode) == 0) {
243 gaim_xfer_request_accepted(xfer, filename); 243 purple_xfer_request_accepted(xfer, filename);
244 } else { 244 } else {
245 gaim_xfer_ref(xfer); 245 purple_xfer_ref(xfer);
246 gaim_notify_message( 246 purple_notify_message(
247 NULL, GAIM_NOTIFY_MSG_ERROR, NULL, 247 NULL, PURPLE_NOTIFY_MSG_ERROR, NULL,
248 _("Directory is not writable."), NULL, 248 _("Directory is not writable."), NULL,
249 (GaimNotifyCloseCallback)gaim_xfer_choose_file, xfer); 249 (PurpleNotifyCloseCallback)purple_xfer_choose_file, xfer);
250 } 250 }
251 251
252 g_free(dir); 252 g_free(dir);
253 } 253 }
254 else { 254 else {
255 gaim_xfer_show_file_error(xfer, filename); 255 purple_xfer_show_file_error(xfer, filename);
256 gaim_xfer_request_denied(xfer); 256 purple_xfer_request_denied(xfer);
257 } 257 }
258 } 258 }
259 else if ((gaim_xfer_get_type(xfer) == GAIM_XFER_SEND) && 259 else if ((purple_xfer_get_type(xfer) == PURPLE_XFER_SEND) &&
260 (st.st_size == 0)) { 260 (st.st_size == 0)) {
261 261
262 gaim_notify_error(NULL, NULL, 262 purple_notify_error(NULL, NULL,
263 _("Cannot send a file of 0 bytes."), NULL); 263 _("Cannot send a file of 0 bytes."), NULL);
264 264
265 gaim_xfer_request_denied(xfer); 265 purple_xfer_request_denied(xfer);
266 } 266 }
267 else if ((gaim_xfer_get_type(xfer) == GAIM_XFER_SEND) && 267 else if ((purple_xfer_get_type(xfer) == PURPLE_XFER_SEND) &&
268 S_ISDIR(st.st_mode)) { 268 S_ISDIR(st.st_mode)) {
269 /* 269 /*
270 * XXX - Sending a directory should be valid for some protocols. 270 * XXX - Sending a directory should be valid for some protocols.
271 */ 271 */
272 gaim_notify_error(NULL, NULL, 272 purple_notify_error(NULL, NULL,
273 _("Cannot send a directory."), NULL); 273 _("Cannot send a directory."), NULL);
274 274
275 gaim_xfer_request_denied(xfer); 275 purple_xfer_request_denied(xfer);
276 } 276 }
277 else if ((gaim_xfer_get_type(xfer) == GAIM_XFER_RECEIVE) && 277 else if ((purple_xfer_get_type(xfer) == PURPLE_XFER_RECEIVE) &&
278 S_ISDIR(st.st_mode)) { 278 S_ISDIR(st.st_mode)) {
279 char *msg, *utf8; 279 char *msg, *utf8;
280 utf8 = g_filename_to_utf8(filename, -1, NULL, NULL, NULL); 280 utf8 = g_filename_to_utf8(filename, -1, NULL, NULL, NULL);
281 msg = g_strdup_printf( 281 msg = g_strdup_printf(
282 _("%s is not a regular file. Cowardly refusing to overwrite it.\n"), utf8); 282 _("%s is not a regular file. Cowardly refusing to overwrite it.\n"), utf8);
283 g_free(utf8); 283 g_free(utf8);
284 gaim_notify_error(NULL, NULL, msg, NULL); 284 purple_notify_error(NULL, NULL, msg, NULL);
285 g_free(msg); 285 g_free(msg);
286 gaim_xfer_request_denied(xfer); 286 purple_xfer_request_denied(xfer);
287 } 287 }
288 else { 288 else {
289 gaim_xfer_request_accepted(xfer, filename); 289 purple_xfer_request_accepted(xfer, filename);
290 } 290 }
291 291
292 gaim_xfer_unref(xfer); 292 purple_xfer_unref(xfer);
293 } 293 }
294 294
295 static void 295 static void
296 gaim_xfer_choose_file_cancel_cb(void *user_data, const char *filename) 296 purple_xfer_choose_file_cancel_cb(void *user_data, const char *filename)
297 { 297 {
298 GaimXfer *xfer = (GaimXfer *)user_data; 298 PurpleXfer *xfer = (PurpleXfer *)user_data;
299 299
300 gaim_xfer_set_status(xfer, GAIM_XFER_STATUS_CANCEL_LOCAL); 300 purple_xfer_set_status(xfer, PURPLE_XFER_STATUS_CANCEL_LOCAL);
301 gaim_xfer_request_denied(xfer); 301 purple_xfer_request_denied(xfer);
302 } 302 }
303 303
304 static int 304 static int
305 gaim_xfer_choose_file(GaimXfer *xfer) 305 purple_xfer_choose_file(PurpleXfer *xfer)
306 { 306 {
307 gaim_request_file(xfer, NULL, gaim_xfer_get_filename(xfer), 307 purple_request_file(xfer, NULL, purple_xfer_get_filename(xfer),
308 (gaim_xfer_get_type(xfer) == GAIM_XFER_RECEIVE), 308 (purple_xfer_get_type(xfer) == PURPLE_XFER_RECEIVE),
309 G_CALLBACK(gaim_xfer_choose_file_ok_cb), 309 G_CALLBACK(purple_xfer_choose_file_ok_cb),
310 G_CALLBACK(gaim_xfer_choose_file_cancel_cb), xfer); 310 G_CALLBACK(purple_xfer_choose_file_cancel_cb), xfer);
311 311
312 return 0; 312 return 0;
313 } 313 }
314 314
315 static int 315 static int
316 cancel_recv_cb(GaimXfer *xfer) 316 cancel_recv_cb(PurpleXfer *xfer)
317 { 317 {
318 gaim_xfer_set_status(xfer, GAIM_XFER_STATUS_CANCEL_LOCAL); 318 purple_xfer_set_status(xfer, PURPLE_XFER_STATUS_CANCEL_LOCAL);
319 gaim_xfer_request_denied(xfer); 319 purple_xfer_request_denied(xfer);
320 gaim_xfer_unref(xfer); 320 purple_xfer_unref(xfer);
321 321
322 return 0; 322 return 0;
323 } 323 }
324 324
325 static void 325 static void
326 gaim_xfer_ask_recv(GaimXfer *xfer) 326 purple_xfer_ask_recv(PurpleXfer *xfer)
327 { 327 {
328 char *buf, *size_buf; 328 char *buf, *size_buf;
329 size_t size; 329 size_t size;
330 330
331 /* If we have already accepted the request, ask the destination file 331 /* If we have already accepted the request, ask the destination file
332 name directly */ 332 name directly */
333 if (gaim_xfer_get_status(xfer) != GAIM_XFER_STATUS_ACCEPTED) { 333 if (purple_xfer_get_status(xfer) != PURPLE_XFER_STATUS_ACCEPTED) {
334 GaimBuddy *buddy = gaim_find_buddy(xfer->account, xfer->who); 334 PurpleBuddy *buddy = purple_find_buddy(xfer->account, xfer->who);
335 335
336 if (gaim_xfer_get_filename(xfer) != NULL) 336 if (purple_xfer_get_filename(xfer) != NULL)
337 { 337 {
338 size = gaim_xfer_get_size(xfer); 338 size = purple_xfer_get_size(xfer);
339 size_buf = gaim_str_size_to_units(size); 339 size_buf = purple_str_size_to_units(size);
340 buf = g_strdup_printf(_("%s wants to send you %s (%s)"), 340 buf = g_strdup_printf(_("%s wants to send you %s (%s)"),
341 buddy ? gaim_buddy_get_alias(buddy) : xfer->who, 341 buddy ? purple_buddy_get_alias(buddy) : xfer->who,
342 gaim_xfer_get_filename(xfer), size_buf); 342 purple_xfer_get_filename(xfer), size_buf);
343 g_free(size_buf); 343 g_free(size_buf);
344 } 344 }
345 else 345 else
346 { 346 {
347 buf = g_strdup_printf(_("%s wants to send you a file"), 347 buf = g_strdup_printf(_("%s wants to send you a file"),
348 buddy ? gaim_buddy_get_alias(buddy) : xfer->who); 348 buddy ? purple_buddy_get_alias(buddy) : xfer->who);
349 } 349 }
350 350
351 if (xfer->message != NULL) 351 if (xfer->message != NULL)
352 serv_got_im(gaim_account_get_connection(xfer->account), 352 serv_got_im(purple_account_get_connection(xfer->account),
353 xfer->who, xfer->message, 0, time(NULL)); 353 xfer->who, xfer->message, 0, time(NULL));
354 354
355 gaim_request_accept_cancel(xfer, NULL, buf, NULL, 355 purple_request_accept_cancel(xfer, NULL, buf, NULL,
356 GAIM_DEFAULT_ACTION_NONE, xfer, 356 PURPLE_DEFAULT_ACTION_NONE, xfer,
357 G_CALLBACK(gaim_xfer_choose_file), 357 G_CALLBACK(purple_xfer_choose_file),
358 G_CALLBACK(cancel_recv_cb)); 358 G_CALLBACK(cancel_recv_cb));
359 359
360 g_free(buf); 360 g_free(buf);
361 } else 361 } else
362 gaim_xfer_choose_file(xfer); 362 purple_xfer_choose_file(xfer);
363 } 363 }
364 364
365 static int 365 static int
366 ask_accept_ok(GaimXfer *xfer) 366 ask_accept_ok(PurpleXfer *xfer)
367 { 367 {
368 gaim_xfer_request_accepted(xfer, NULL); 368 purple_xfer_request_accepted(xfer, NULL);
369 369
370 return 0; 370 return 0;
371 } 371 }
372 372
373 static int 373 static int
374 ask_accept_cancel(GaimXfer *xfer) 374 ask_accept_cancel(PurpleXfer *xfer)
375 { 375 {
376 gaim_xfer_request_denied(xfer); 376 purple_xfer_request_denied(xfer);
377 gaim_xfer_unref(xfer); 377 purple_xfer_unref(xfer);
378 378
379 return 0; 379 return 0;
380 } 380 }
381 381
382 static void 382 static void
383 gaim_xfer_ask_accept(GaimXfer *xfer) 383 purple_xfer_ask_accept(PurpleXfer *xfer)
384 { 384 {
385 char *buf, *buf2 = NULL; 385 char *buf, *buf2 = NULL;
386 GaimBuddy *buddy = gaim_find_buddy(xfer->account, xfer->who); 386 PurpleBuddy *buddy = purple_find_buddy(xfer->account, xfer->who);
387 387
388 buf = g_strdup_printf(_("Accept file transfer request from %s?"), 388 buf = g_strdup_printf(_("Accept file transfer request from %s?"),
389 buddy ? gaim_buddy_get_alias(buddy) : xfer->who); 389 buddy ? purple_buddy_get_alias(buddy) : xfer->who);
390 if (gaim_xfer_get_remote_ip(xfer) && 390 if (purple_xfer_get_remote_ip(xfer) &&
391 gaim_xfer_get_remote_port(xfer)) 391 purple_xfer_get_remote_port(xfer))
392 buf2 = g_strdup_printf(_("A file is available for download from:\n" 392 buf2 = g_strdup_printf(_("A file is available for download from:\n"
393 "Remote host: %s\nRemote port: %d"), 393 "Remote host: %s\nRemote port: %d"),
394 gaim_xfer_get_remote_ip(xfer), 394 purple_xfer_get_remote_ip(xfer),
395 gaim_xfer_get_remote_port(xfer)); 395 purple_xfer_get_remote_port(xfer));
396 gaim_request_accept_cancel(xfer, NULL, buf, buf2, 396 purple_request_accept_cancel(xfer, NULL, buf, buf2,
397 GAIM_DEFAULT_ACTION_NONE, xfer, 397 PURPLE_DEFAULT_ACTION_NONE, xfer,
398 G_CALLBACK(ask_accept_ok), 398 G_CALLBACK(ask_accept_ok),
399 G_CALLBACK(ask_accept_cancel)); 399 G_CALLBACK(ask_accept_cancel));
400 g_free(buf); 400 g_free(buf);
401 g_free(buf2); 401 g_free(buf2);
402 } 402 }
403 403
404 void 404 void
405 gaim_xfer_request(GaimXfer *xfer) 405 purple_xfer_request(PurpleXfer *xfer)
406 { 406 {
407 g_return_if_fail(xfer != NULL); 407 g_return_if_fail(xfer != NULL);
408 g_return_if_fail(xfer->ops.init != NULL); 408 g_return_if_fail(xfer->ops.init != NULL);
409 409
410 gaim_xfer_ref(xfer); 410 purple_xfer_ref(xfer);
411 411
412 if (gaim_xfer_get_type(xfer) == GAIM_XFER_RECEIVE) 412 if (purple_xfer_get_type(xfer) == PURPLE_XFER_RECEIVE)
413 { 413 {
414 gaim_signal_emit(gaim_xfers_get_handle(), "file-recv-request", xfer); 414 purple_signal_emit(purple_xfers_get_handle(), "file-recv-request", xfer);
415 if (gaim_xfer_get_status(xfer) == GAIM_XFER_STATUS_CANCEL_LOCAL) 415 if (purple_xfer_get_status(xfer) == PURPLE_XFER_STATUS_CANCEL_LOCAL)
416 { 416 {
417 /* The file-transfer was cancelled by a plugin */ 417 /* The file-transfer was cancelled by a plugin */
418 gaim_xfer_cancel_local(xfer); 418 purple_xfer_cancel_local(xfer);
419 } 419 }
420 else if (gaim_xfer_get_filename(xfer) || 420 else if (purple_xfer_get_filename(xfer) ||
421 gaim_xfer_get_status(xfer) == GAIM_XFER_STATUS_ACCEPTED) 421 purple_xfer_get_status(xfer) == PURPLE_XFER_STATUS_ACCEPTED)
422 { 422 {
423 gchar* message = NULL; 423 gchar* message = NULL;
424 GaimBuddy *buddy = gaim_find_buddy(xfer->account, xfer->who); 424 PurpleBuddy *buddy = purple_find_buddy(xfer->account, xfer->who);
425 message = g_strdup_printf(_("%s is offering to send file %s"), 425 message = g_strdup_printf(_("%s is offering to send file %s"),
426 buddy ? gaim_buddy_get_alias(buddy) : xfer->who, gaim_xfer_get_filename(xfer)); 426 buddy ? purple_buddy_get_alias(buddy) : xfer->who, purple_xfer_get_filename(xfer));
427 gaim_xfer_conversation_write(xfer, message, FALSE); 427 purple_xfer_conversation_write(xfer, message, FALSE);
428 g_free(message); 428 g_free(message);
429 /* Ask for a filename to save to if it's not already given by a plugin */ 429 /* Ask for a filename to save to if it's not already given by a plugin */
430 if (xfer->local_filename == NULL) 430 if (xfer->local_filename == NULL)
431 gaim_xfer_ask_recv(xfer); 431 purple_xfer_ask_recv(xfer);
432 } 432 }
433 else 433 else
434 { 434 {
435 gaim_xfer_ask_accept(xfer); 435 purple_xfer_ask_accept(xfer);
436 } 436 }
437 } 437 }
438 else 438 else
439 { 439 {
440 gaim_xfer_choose_file(xfer); 440 purple_xfer_choose_file(xfer);
441 } 441 }
442 } 442 }
443 443
444 void 444 void
445 gaim_xfer_request_accepted(GaimXfer *xfer, const char *filename) 445 purple_xfer_request_accepted(PurpleXfer *xfer, const char *filename)
446 { 446 {
447 GaimXferType type; 447 PurpleXferType type;
448 struct stat st; 448 struct stat st;
449 char *msg, *utf8; 449 char *msg, *utf8;
450 GaimAccount *account; 450 PurpleAccount *account;
451 GaimBuddy *buddy; 451 PurpleBuddy *buddy;
452 452
453 if (xfer == NULL) 453 if (xfer == NULL)
454 return; 454 return;
455 455
456 type = gaim_xfer_get_type(xfer); 456 type = purple_xfer_get_type(xfer);
457 account = gaim_xfer_get_account(xfer); 457 account = purple_xfer_get_account(xfer);
458 458
459 if (!filename && type == GAIM_XFER_RECEIVE) { 459 if (!filename && type == PURPLE_XFER_RECEIVE) {
460 xfer->status = GAIM_XFER_STATUS_ACCEPTED; 460 xfer->status = PURPLE_XFER_STATUS_ACCEPTED;
461 xfer->ops.init(xfer); 461 xfer->ops.init(xfer);
462 return; 462 return;
463 } 463 }
464 464
465 buddy = gaim_find_buddy(account, xfer->who); 465 buddy = purple_find_buddy(account, xfer->who);
466 466
467 if (type == GAIM_XFER_SEND) { 467 if (type == PURPLE_XFER_SEND) {
468 /* Sending a file */ 468 /* Sending a file */
469 /* Check the filename. */ 469 /* Check the filename. */
470 #ifdef _WIN32 470 #ifdef _WIN32
471 if (g_strrstr(filename, "../") || g_strrstr(filename, "..\\")) { 471 if (g_strrstr(filename, "../") || g_strrstr(filename, "..\\")) {
472 #else 472 #else
473 if (g_strrstr(filename, "../")) { 473 if (g_strrstr(filename, "../")) {
474 #endif 474 #endif
475 char *utf8 = g_filename_to_utf8(filename, -1, NULL, NULL, NULL); 475 char *utf8 = g_filename_to_utf8(filename, -1, NULL, NULL, NULL);
476 476
477 msg = g_strdup_printf(_("%s is not a valid filename.\n"), utf8); 477 msg = g_strdup_printf(_("%s is not a valid filename.\n"), utf8);
478 gaim_xfer_error(type, account, xfer->who, msg); 478 purple_xfer_error(type, account, xfer->who, msg);
479 g_free(utf8); 479 g_free(utf8);
480 g_free(msg); 480 g_free(msg);
481 481
482 gaim_xfer_unref(xfer); 482 purple_xfer_unref(xfer);
483 return; 483 return;
484 } 484 }
485 485
486 if (g_stat(filename, &st) == -1) { 486 if (g_stat(filename, &st) == -1) {
487 gaim_xfer_show_file_error(xfer, filename); 487 purple_xfer_show_file_error(xfer, filename);
488 gaim_xfer_unref(xfer); 488 purple_xfer_unref(xfer);
489 return; 489 return;
490 } 490 }
491 491
492 gaim_xfer_set_local_filename(xfer, filename); 492 purple_xfer_set_local_filename(xfer, filename);
493 gaim_xfer_set_size(xfer, st.st_size); 493 purple_xfer_set_size(xfer, st.st_size);
494 494
495 utf8 = g_filename_to_utf8(g_basename(filename), -1, NULL, NULL, NULL); 495 utf8 = g_filename_to_utf8(g_basename(filename), -1, NULL, NULL, NULL);
496 gaim_xfer_set_filename(xfer, utf8); 496 purple_xfer_set_filename(xfer, utf8);
497 497
498 msg = g_strdup_printf(_("Offering to send %s to %s"), 498 msg = g_strdup_printf(_("Offering to send %s to %s"),
499 utf8, buddy ? gaim_buddy_get_alias(buddy) : xfer->who); 499 utf8, buddy ? purple_buddy_get_alias(buddy) : xfer->who);
500 g_free(utf8); 500 g_free(utf8);
501 501
502 gaim_xfer_conversation_write(xfer, msg, FALSE); 502 purple_xfer_conversation_write(xfer, msg, FALSE);
503 g_free(msg); 503 g_free(msg);
504 } 504 }
505 else { 505 else {
506 /* Receiving a file */ 506 /* Receiving a file */
507 xfer->status = GAIM_XFER_STATUS_ACCEPTED; 507 xfer->status = PURPLE_XFER_STATUS_ACCEPTED;
508 gaim_xfer_set_local_filename(xfer, filename); 508 purple_xfer_set_local_filename(xfer, filename);
509 509
510 msg = g_strdup_printf(_("Starting transfer of %s from %s"), 510 msg = g_strdup_printf(_("Starting transfer of %s from %s"),
511 xfer->filename, buddy ? gaim_buddy_get_alias(buddy) : xfer->who); 511 xfer->filename, buddy ? purple_buddy_get_alias(buddy) : xfer->who);
512 gaim_xfer_conversation_write(xfer, msg, FALSE); 512 purple_xfer_conversation_write(xfer, msg, FALSE);
513 g_free(msg); 513 g_free(msg);
514 } 514 }
515 515
516 gaim_xfer_add(xfer); 516 purple_xfer_add(xfer);
517 xfer->ops.init(xfer); 517 xfer->ops.init(xfer);
518 518
519 } 519 }
520 520
521 void 521 void
522 gaim_xfer_request_denied(GaimXfer *xfer) 522 purple_xfer_request_denied(PurpleXfer *xfer)
523 { 523 {
524 g_return_if_fail(xfer != NULL); 524 g_return_if_fail(xfer != NULL);
525 525
526 if (xfer->ops.request_denied != NULL) 526 if (xfer->ops.request_denied != NULL)
527 xfer->ops.request_denied(xfer); 527 xfer->ops.request_denied(xfer);
528 528
529 gaim_xfer_unref(xfer); 529 purple_xfer_unref(xfer);
530 } 530 }
531 531
532 GaimXferType 532 PurpleXferType
533 gaim_xfer_get_type(const GaimXfer *xfer) 533 purple_xfer_get_type(const PurpleXfer *xfer)
534 { 534 {
535 g_return_val_if_fail(xfer != NULL, GAIM_XFER_UNKNOWN); 535 g_return_val_if_fail(xfer != NULL, PURPLE_XFER_UNKNOWN);
536 536
537 return xfer->type; 537 return xfer->type;
538 } 538 }
539 539
540 GaimAccount * 540 PurpleAccount *
541 gaim_xfer_get_account(const GaimXfer *xfer) 541 purple_xfer_get_account(const PurpleXfer *xfer)
542 { 542 {
543 g_return_val_if_fail(xfer != NULL, NULL); 543 g_return_val_if_fail(xfer != NULL, NULL);
544 544
545 return xfer->account; 545 return xfer->account;
546 } 546 }
547 547
548 GaimXferStatusType 548 PurpleXferStatusType
549 gaim_xfer_get_status(const GaimXfer *xfer) 549 purple_xfer_get_status(const PurpleXfer *xfer)
550 { 550 {
551 g_return_val_if_fail(xfer != NULL, GAIM_XFER_STATUS_UNKNOWN); 551 g_return_val_if_fail(xfer != NULL, PURPLE_XFER_STATUS_UNKNOWN);
552 552
553 return xfer->status; 553 return xfer->status;
554 } 554 }
555 555
556 gboolean 556 gboolean
557 gaim_xfer_is_canceled(const GaimXfer *xfer) 557 purple_xfer_is_canceled(const PurpleXfer *xfer)
558 { 558 {
559 g_return_val_if_fail(xfer != NULL, TRUE); 559 g_return_val_if_fail(xfer != NULL, TRUE);
560 560
561 if ((gaim_xfer_get_status(xfer) == GAIM_XFER_STATUS_CANCEL_LOCAL) || 561 if ((purple_xfer_get_status(xfer) == PURPLE_XFER_STATUS_CANCEL_LOCAL) ||
562 (gaim_xfer_get_status(xfer) == GAIM_XFER_STATUS_CANCEL_REMOTE)) 562 (purple_xfer_get_status(xfer) == PURPLE_XFER_STATUS_CANCEL_REMOTE))
563 return TRUE; 563 return TRUE;
564 else 564 else
565 return FALSE; 565 return FALSE;
566 } 566 }
567 567
568 gboolean 568 gboolean
569 gaim_xfer_is_completed(const GaimXfer *xfer) 569 purple_xfer_is_completed(const PurpleXfer *xfer)
570 { 570 {
571 g_return_val_if_fail(xfer != NULL, TRUE); 571 g_return_val_if_fail(xfer != NULL, TRUE);
572 572
573 return (gaim_xfer_get_status(xfer) == GAIM_XFER_STATUS_DONE); 573 return (purple_xfer_get_status(xfer) == PURPLE_XFER_STATUS_DONE);
574 } 574 }
575 575
576 const char * 576 const char *
577 gaim_xfer_get_filename(const GaimXfer *xfer) 577 purple_xfer_get_filename(const PurpleXfer *xfer)
578 { 578 {
579 g_return_val_if_fail(xfer != NULL, NULL); 579 g_return_val_if_fail(xfer != NULL, NULL);
580 580
581 return xfer->filename; 581 return xfer->filename;
582 } 582 }
583 583
584 const char * 584 const char *
585 gaim_xfer_get_local_filename(const GaimXfer *xfer) 585 purple_xfer_get_local_filename(const PurpleXfer *xfer)
586 { 586 {
587 g_return_val_if_fail(xfer != NULL, NULL); 587 g_return_val_if_fail(xfer != NULL, NULL);
588 588
589 return xfer->local_filename; 589 return xfer->local_filename;
590 } 590 }
591 591
592 size_t 592 size_t
593 gaim_xfer_get_bytes_sent(const GaimXfer *xfer) 593 purple_xfer_get_bytes_sent(const PurpleXfer *xfer)
594 { 594 {
595 g_return_val_if_fail(xfer != NULL, 0); 595 g_return_val_if_fail(xfer != NULL, 0);
596 596
597 return xfer->bytes_sent; 597 return xfer->bytes_sent;
598 } 598 }
599 599
600 size_t 600 size_t
601 gaim_xfer_get_bytes_remaining(const GaimXfer *xfer) 601 purple_xfer_get_bytes_remaining(const PurpleXfer *xfer)
602 { 602 {
603 g_return_val_if_fail(xfer != NULL, 0); 603 g_return_val_if_fail(xfer != NULL, 0);
604 604
605 return xfer->bytes_remaining; 605 return xfer->bytes_remaining;
606 } 606 }
607 607
608 size_t 608 size_t
609 gaim_xfer_get_size(const GaimXfer *xfer) 609 purple_xfer_get_size(const PurpleXfer *xfer)
610 { 610 {
611 g_return_val_if_fail(xfer != NULL, 0); 611 g_return_val_if_fail(xfer != NULL, 0);
612 612
613 return xfer->size; 613 return xfer->size;
614 } 614 }
615 615
616 double 616 double
617 gaim_xfer_get_progress(const GaimXfer *xfer) 617 purple_xfer_get_progress(const PurpleXfer *xfer)
618 { 618 {
619 g_return_val_if_fail(xfer != NULL, 0.0); 619 g_return_val_if_fail(xfer != NULL, 0.0);
620 620
621 if (gaim_xfer_get_size(xfer) == 0) 621 if (purple_xfer_get_size(xfer) == 0)
622 return 0.0; 622 return 0.0;
623 623
624 return ((double)gaim_xfer_get_bytes_sent(xfer) / 624 return ((double)purple_xfer_get_bytes_sent(xfer) /
625 (double)gaim_xfer_get_size(xfer)); 625 (double)purple_xfer_get_size(xfer));
626 } 626 }
627 627
628 unsigned int 628 unsigned int
629 gaim_xfer_get_local_port(const GaimXfer *xfer) 629 purple_xfer_get_local_port(const PurpleXfer *xfer)
630 { 630 {
631 g_return_val_if_fail(xfer != NULL, -1); 631 g_return_val_if_fail(xfer != NULL, -1);
632 632
633 return xfer->local_port; 633 return xfer->local_port;
634 } 634 }
635 635
636 const char * 636 const char *
637 gaim_xfer_get_remote_ip(const GaimXfer *xfer) 637 purple_xfer_get_remote_ip(const PurpleXfer *xfer)
638 { 638 {
639 g_return_val_if_fail(xfer != NULL, NULL); 639 g_return_val_if_fail(xfer != NULL, NULL);
640 640
641 return xfer->remote_ip; 641 return xfer->remote_ip;
642 } 642 }
643 643
644 unsigned int 644 unsigned int
645 gaim_xfer_get_remote_port(const GaimXfer *xfer) 645 purple_xfer_get_remote_port(const PurpleXfer *xfer)
646 { 646 {
647 g_return_val_if_fail(xfer != NULL, -1); 647 g_return_val_if_fail(xfer != NULL, -1);
648 648
649 return xfer->remote_port; 649 return xfer->remote_port;
650 } 650 }
651 651
652 void 652 void
653 gaim_xfer_set_completed(GaimXfer *xfer, gboolean completed) 653 purple_xfer_set_completed(PurpleXfer *xfer, gboolean completed)
654 { 654 {
655 GaimXferUiOps *ui_ops; 655 PurpleXferUiOps *ui_ops;
656 656
657 g_return_if_fail(xfer != NULL); 657 g_return_if_fail(xfer != NULL);
658 658
659 if (completed == TRUE) { 659 if (completed == TRUE) {
660 char *msg = NULL; 660 char *msg = NULL;
661 gaim_xfer_set_status(xfer, GAIM_XFER_STATUS_DONE); 661 purple_xfer_set_status(xfer, PURPLE_XFER_STATUS_DONE);
662 662
663 if (gaim_xfer_get_filename(xfer) != NULL) 663 if (purple_xfer_get_filename(xfer) != NULL)
664 msg = g_strdup_printf(_("Transfer of file %s complete"), 664 msg = g_strdup_printf(_("Transfer of file %s complete"),
665 gaim_xfer_get_filename(xfer)); 665 purple_xfer_get_filename(xfer));
666 else 666 else
667 msg = g_strdup_printf(_("File transfer complete")); 667 msg = g_strdup_printf(_("File transfer complete"));
668 gaim_xfer_conversation_write(xfer, msg, FALSE); 668 purple_xfer_conversation_write(xfer, msg, FALSE);
669 g_free(msg); 669 g_free(msg);
670 } 670 }
671 671
672 ui_ops = gaim_xfer_get_ui_ops(xfer); 672 ui_ops = purple_xfer_get_ui_ops(xfer);
673 673
674 if (ui_ops != NULL && ui_ops->update_progress != NULL) 674 if (ui_ops != NULL && ui_ops->update_progress != NULL)
675 ui_ops->update_progress(xfer, gaim_xfer_get_progress(xfer)); 675 ui_ops->update_progress(xfer, purple_xfer_get_progress(xfer));
676 } 676 }
677 677
678 void 678 void
679 gaim_xfer_set_message(GaimXfer *xfer, const char *message) 679 purple_xfer_set_message(PurpleXfer *xfer, const char *message)
680 { 680 {
681 g_return_if_fail(xfer != NULL); 681 g_return_if_fail(xfer != NULL);
682 682
683 g_free(xfer->message); 683 g_free(xfer->message);
684 xfer->message = g_strdup(message); 684 xfer->message = g_strdup(message);
685 } 685 }
686 686
687 void 687 void
688 gaim_xfer_set_filename(GaimXfer *xfer, const char *filename) 688 purple_xfer_set_filename(PurpleXfer *xfer, const char *filename)
689 { 689 {
690 g_return_if_fail(xfer != NULL); 690 g_return_if_fail(xfer != NULL);
691 691
692 g_free(xfer->filename); 692 g_free(xfer->filename);
693 xfer->filename = g_strdup(filename); 693 xfer->filename = g_strdup(filename);
694 } 694 }
695 695
696 void 696 void
697 gaim_xfer_set_local_filename(GaimXfer *xfer, const char *filename) 697 purple_xfer_set_local_filename(PurpleXfer *xfer, const char *filename)
698 { 698 {
699 g_return_if_fail(xfer != NULL); 699 g_return_if_fail(xfer != NULL);
700 700
701 g_free(xfer->local_filename); 701 g_free(xfer->local_filename);
702 xfer->local_filename = g_strdup(filename); 702 xfer->local_filename = g_strdup(filename);
703 } 703 }
704 704
705 void 705 void
706 gaim_xfer_set_size(GaimXfer *xfer, size_t size) 706 purple_xfer_set_size(PurpleXfer *xfer, size_t size)
707 { 707 {
708 g_return_if_fail(xfer != NULL); 708 g_return_if_fail(xfer != NULL);
709 709
710 xfer->size = size; 710 xfer->size = size;
711 xfer->bytes_remaining = xfer->size - gaim_xfer_get_bytes_sent(xfer); 711 xfer->bytes_remaining = xfer->size - purple_xfer_get_bytes_sent(xfer);
712 } 712 }
713 713
714 void 714 void
715 gaim_xfer_set_bytes_sent(GaimXfer *xfer, size_t bytes_sent) 715 purple_xfer_set_bytes_sent(PurpleXfer *xfer, size_t bytes_sent)
716 { 716 {
717 g_return_if_fail(xfer != NULL); 717 g_return_if_fail(xfer != NULL);
718 718
719 xfer->bytes_sent = bytes_sent; 719 xfer->bytes_sent = bytes_sent;
720 xfer->bytes_remaining = gaim_xfer_get_size(xfer) - bytes_sent; 720 xfer->bytes_remaining = purple_xfer_get_size(xfer) - bytes_sent;
721 } 721 }
722 722
723 GaimXferUiOps * 723 PurpleXferUiOps *
724 gaim_xfer_get_ui_ops(const GaimXfer *xfer) 724 purple_xfer_get_ui_ops(const PurpleXfer *xfer)
725 { 725 {
726 g_return_val_if_fail(xfer != NULL, NULL); 726 g_return_val_if_fail(xfer != NULL, NULL);
727 727
728 return xfer->ui_ops; 728 return xfer->ui_ops;
729 } 729 }
730 730
731 void 731 void
732 gaim_xfer_set_init_fnc(GaimXfer *xfer, void (*fnc)(GaimXfer *)) 732 purple_xfer_set_init_fnc(PurpleXfer *xfer, void (*fnc)(PurpleXfer *))
733 { 733 {
734 g_return_if_fail(xfer != NULL); 734 g_return_if_fail(xfer != NULL);
735 735
736 xfer->ops.init = fnc; 736 xfer->ops.init = fnc;
737 } 737 }
738 738
739 void gaim_xfer_set_request_denied_fnc(GaimXfer *xfer, void (*fnc)(GaimXfer *)) 739 void purple_xfer_set_request_denied_fnc(PurpleXfer *xfer, void (*fnc)(PurpleXfer *))
740 { 740 {
741 g_return_if_fail(xfer != NULL); 741 g_return_if_fail(xfer != NULL);
742 742
743 xfer->ops.request_denied = fnc; 743 xfer->ops.request_denied = fnc;
744 } 744 }
745 745
746 void 746 void
747 gaim_xfer_set_read_fnc(GaimXfer *xfer, gssize (*fnc)(guchar **, GaimXfer *)) 747 purple_xfer_set_read_fnc(PurpleXfer *xfer, gssize (*fnc)(guchar **, PurpleXfer *))
748 { 748 {
749 g_return_if_fail(xfer != NULL); 749 g_return_if_fail(xfer != NULL);
750 750
751 xfer->ops.read = fnc; 751 xfer->ops.read = fnc;
752 } 752 }
753 753
754 void 754 void
755 gaim_xfer_set_write_fnc(GaimXfer *xfer, 755 purple_xfer_set_write_fnc(PurpleXfer *xfer,
756 gssize (*fnc)(const guchar *, size_t, GaimXfer *)) 756 gssize (*fnc)(const guchar *, size_t, PurpleXfer *))
757 { 757 {
758 g_return_if_fail(xfer != NULL); 758 g_return_if_fail(xfer != NULL);
759 759
760 xfer->ops.write = fnc; 760 xfer->ops.write = fnc;
761 } 761 }
762 762
763 void 763 void
764 gaim_xfer_set_ack_fnc(GaimXfer *xfer, 764 purple_xfer_set_ack_fnc(PurpleXfer *xfer,
765 void (*fnc)(GaimXfer *, const guchar *, size_t)) 765 void (*fnc)(PurpleXfer *, const guchar *, size_t))
766 { 766 {
767 g_return_if_fail(xfer != NULL); 767 g_return_if_fail(xfer != NULL);
768 768
769 xfer->ops.ack = fnc; 769 xfer->ops.ack = fnc;
770 } 770 }
771 771
772 void 772 void
773 gaim_xfer_set_start_fnc(GaimXfer *xfer, void (*fnc)(GaimXfer *)) 773 purple_xfer_set_start_fnc(PurpleXfer *xfer, void (*fnc)(PurpleXfer *))
774 { 774 {
775 g_return_if_fail(xfer != NULL); 775 g_return_if_fail(xfer != NULL);
776 776
777 xfer->ops.start = fnc; 777 xfer->ops.start = fnc;
778 } 778 }
779 779
780 void 780 void
781 gaim_xfer_set_end_fnc(GaimXfer *xfer, void (*fnc)(GaimXfer *)) 781 purple_xfer_set_end_fnc(PurpleXfer *xfer, void (*fnc)(PurpleXfer *))
782 { 782 {
783 g_return_if_fail(xfer != NULL); 783 g_return_if_fail(xfer != NULL);
784 784
785 xfer->ops.end = fnc; 785 xfer->ops.end = fnc;
786 } 786 }
787 787
788 void 788 void
789 gaim_xfer_set_cancel_send_fnc(GaimXfer *xfer, void (*fnc)(GaimXfer *)) 789 purple_xfer_set_cancel_send_fnc(PurpleXfer *xfer, void (*fnc)(PurpleXfer *))
790 { 790 {
791 g_return_if_fail(xfer != NULL); 791 g_return_if_fail(xfer != NULL);
792 792
793 xfer->ops.cancel_send = fnc; 793 xfer->ops.cancel_send = fnc;
794 } 794 }
795 795
796 void 796 void
797 gaim_xfer_set_cancel_recv_fnc(GaimXfer *xfer, void (*fnc)(GaimXfer *)) 797 purple_xfer_set_cancel_recv_fnc(PurpleXfer *xfer, void (*fnc)(PurpleXfer *))
798 { 798 {
799 g_return_if_fail(xfer != NULL); 799 g_return_if_fail(xfer != NULL);
800 800
801 xfer->ops.cancel_recv = fnc; 801 xfer->ops.cancel_recv = fnc;
802 } 802 }
803 803
804 static void 804 static void
805 gaim_xfer_increase_buffer_size(GaimXfer *xfer) 805 purple_xfer_increase_buffer_size(PurpleXfer *xfer)
806 { 806 {
807 xfer->current_buffer_size = MIN(xfer->current_buffer_size * 1.5, 807 xfer->current_buffer_size = MIN(xfer->current_buffer_size * 1.5,
808 FT_MAX_BUFFER_SIZE); 808 FT_MAX_BUFFER_SIZE);
809 } 809 }
810 810
811 gssize 811 gssize
812 gaim_xfer_read(GaimXfer *xfer, guchar **buffer) 812 purple_xfer_read(PurpleXfer *xfer, guchar **buffer)
813 { 813 {
814 gssize s, r; 814 gssize s, r;
815 815
816 g_return_val_if_fail(xfer != NULL, 0); 816 g_return_val_if_fail(xfer != NULL, 0);
817 g_return_val_if_fail(buffer != NULL, 0); 817 g_return_val_if_fail(buffer != NULL, 0);
818 818
819 if (gaim_xfer_get_size(xfer) == 0) 819 if (purple_xfer_get_size(xfer) == 0)
820 s = xfer->current_buffer_size; 820 s = xfer->current_buffer_size;
821 else 821 else
822 s = MIN(gaim_xfer_get_bytes_remaining(xfer), xfer->current_buffer_size); 822 s = MIN(purple_xfer_get_bytes_remaining(xfer), xfer->current_buffer_size);
823 823
824 if (xfer->ops.read != NULL) 824 if (xfer->ops.read != NULL)
825 r = (xfer->ops.read)(buffer, xfer); 825 r = (xfer->ops.read)(buffer, xfer);
826 else { 826 else {
827 *buffer = g_malloc0(s); 827 *buffer = g_malloc0(s);
829 r = read(xfer->fd, *buffer, s); 829 r = read(xfer->fd, *buffer, s);
830 if (r < 0 && errno == EAGAIN) 830 if (r < 0 && errno == EAGAIN)
831 r = 0; 831 r = 0;
832 else if (r < 0) 832 else if (r < 0)
833 r = -1; 833 r = -1;
834 else if ((gaim_xfer_get_size(xfer) > 0) && 834 else if ((purple_xfer_get_size(xfer) > 0) &&
835 ((gaim_xfer_get_bytes_sent(xfer)+r) >= gaim_xfer_get_size(xfer))) 835 ((purple_xfer_get_bytes_sent(xfer)+r) >= purple_xfer_get_size(xfer)))
836 gaim_xfer_set_completed(xfer, TRUE); 836 purple_xfer_set_completed(xfer, TRUE);
837 else if (r == 0) 837 else if (r == 0)
838 r = -1; 838 r = -1;
839 } 839 }
840 840
841 if (r == xfer->current_buffer_size) 841 if (r == xfer->current_buffer_size)
842 /* 842 /*
843 * We managed to read the entire buffer. This means our this 843 * We managed to read the entire buffer. This means our this
844 * network is fast and our buffer is too small, so make it 844 * network is fast and our buffer is too small, so make it
845 * bigger. 845 * bigger.
846 */ 846 */
847 gaim_xfer_increase_buffer_size(xfer); 847 purple_xfer_increase_buffer_size(xfer);
848 848
849 return r; 849 return r;
850 } 850 }
851 851
852 gssize 852 gssize
853 gaim_xfer_write(GaimXfer *xfer, const guchar *buffer, gsize size) 853 purple_xfer_write(PurpleXfer *xfer, const guchar *buffer, gsize size)
854 { 854 {
855 gssize r, s; 855 gssize r, s;
856 856
857 g_return_val_if_fail(xfer != NULL, 0); 857 g_return_val_if_fail(xfer != NULL, 0);
858 g_return_val_if_fail(buffer != NULL, 0); 858 g_return_val_if_fail(buffer != NULL, 0);
859 g_return_val_if_fail(size != 0, 0); 859 g_return_val_if_fail(size != 0, 0);
860 860
861 s = MIN(gaim_xfer_get_bytes_remaining(xfer), size); 861 s = MIN(purple_xfer_get_bytes_remaining(xfer), size);
862 862
863 if (xfer->ops.write != NULL) { 863 if (xfer->ops.write != NULL) {
864 r = (xfer->ops.write)(buffer, s, xfer); 864 r = (xfer->ops.write)(buffer, s, xfer);
865 } else { 865 } else {
866 r = write(xfer->fd, buffer, s); 866 r = write(xfer->fd, buffer, s);
867 if (r < 0 && errno == EAGAIN) 867 if (r < 0 && errno == EAGAIN)
868 r = 0; 868 r = 0;
869 if ((gaim_xfer_get_bytes_sent(xfer)+r) >= gaim_xfer_get_size(xfer)) 869 if ((purple_xfer_get_bytes_sent(xfer)+r) >= purple_xfer_get_size(xfer))
870 gaim_xfer_set_completed(xfer, TRUE); 870 purple_xfer_set_completed(xfer, TRUE);
871 } 871 }
872 872
873 return r; 873 return r;
874 } 874 }
875 875
876 static void 876 static void
877 transfer_cb(gpointer data, gint source, GaimInputCondition condition) 877 transfer_cb(gpointer data, gint source, PurpleInputCondition condition)
878 { 878 {
879 GaimXferUiOps *ui_ops; 879 PurpleXferUiOps *ui_ops;
880 GaimXfer *xfer = (GaimXfer *)data; 880 PurpleXfer *xfer = (PurpleXfer *)data;
881 guchar *buffer = NULL; 881 guchar *buffer = NULL;
882 gssize r = 0; 882 gssize r = 0;
883 883
884 if (condition & GAIM_INPUT_READ) { 884 if (condition & PURPLE_INPUT_READ) {
885 r = gaim_xfer_read(xfer, &buffer); 885 r = purple_xfer_read(xfer, &buffer);
886 if (r > 0) { 886 if (r > 0) {
887 fwrite(buffer, 1, r, xfer->dest_fp); 887 fwrite(buffer, 1, r, xfer->dest_fp);
888 } else if(r <= 0) { 888 } else if(r <= 0) {
889 gaim_xfer_cancel_remote(xfer); 889 purple_xfer_cancel_remote(xfer);
890 return; 890 return;
891 } 891 }
892 } 892 }
893 893
894 if (condition & GAIM_INPUT_WRITE) { 894 if (condition & PURPLE_INPUT_WRITE) {
895 size_t s = MIN(gaim_xfer_get_bytes_remaining(xfer), xfer->current_buffer_size); 895 size_t s = MIN(purple_xfer_get_bytes_remaining(xfer), xfer->current_buffer_size);
896 896
897 /* this is so the prpl can keep the connection open 897 /* this is so the prpl can keep the connection open
898 if it needs to for some odd reason. */ 898 if it needs to for some odd reason. */
899 if (s == 0) { 899 if (s == 0) {
900 if (xfer->watcher) { 900 if (xfer->watcher) {
901 gaim_input_remove(xfer->watcher); 901 purple_input_remove(xfer->watcher);
902 xfer->watcher = 0; 902 xfer->watcher = 0;
903 } 903 }
904 return; 904 return;
905 } 905 }
906 906
907 buffer = g_malloc0(s); 907 buffer = g_malloc0(s);
908 908
909 fread(buffer, 1, s, xfer->dest_fp); 909 fread(buffer, 1, s, xfer->dest_fp);
910 910
911 /* Write as much as we're allowed to. */ 911 /* Write as much as we're allowed to. */
912 r = gaim_xfer_write(xfer, buffer, s); 912 r = purple_xfer_write(xfer, buffer, s);
913 913
914 if (r == -1) { 914 if (r == -1) {
915 gaim_xfer_cancel_remote(xfer); 915 purple_xfer_cancel_remote(xfer);
916 g_free(buffer); 916 g_free(buffer);
917 return; 917 return;
918 } else if (r < s) { 918 } else if (r < s) {
919 /* We have to seek back in the file now. */ 919 /* We have to seek back in the file now. */
920 fseek(xfer->dest_fp, r - s, SEEK_CUR); 920 fseek(xfer->dest_fp, r - s, SEEK_CUR);
922 /* 922 /*
923 * We managed to write the entire buffer. This means our 923 * We managed to write the entire buffer. This means our
924 * network is fast and our buffer is too small, so make it 924 * network is fast and our buffer is too small, so make it
925 * bigger. 925 * bigger.
926 */ 926 */
927 gaim_xfer_increase_buffer_size(xfer); 927 purple_xfer_increase_buffer_size(xfer);
928 } 928 }
929 } 929 }
930 930
931 if (r > 0) { 931 if (r > 0) {
932 if (gaim_xfer_get_size(xfer) > 0) 932 if (purple_xfer_get_size(xfer) > 0)
933 xfer->bytes_remaining -= r; 933 xfer->bytes_remaining -= r;
934 934
935 xfer->bytes_sent += r; 935 xfer->bytes_sent += r;
936 936
937 if (xfer->ops.ack != NULL) 937 if (xfer->ops.ack != NULL)
938 xfer->ops.ack(xfer, buffer, r); 938 xfer->ops.ack(xfer, buffer, r);
939 939
940 g_free(buffer); 940 g_free(buffer);
941 941
942 ui_ops = gaim_xfer_get_ui_ops(xfer); 942 ui_ops = purple_xfer_get_ui_ops(xfer);
943 943
944 if (ui_ops != NULL && ui_ops->update_progress != NULL) 944 if (ui_ops != NULL && ui_ops->update_progress != NULL)
945 ui_ops->update_progress(xfer, 945 ui_ops->update_progress(xfer,
946 gaim_xfer_get_progress(xfer)); 946 purple_xfer_get_progress(xfer));
947 } 947 }
948 948
949 if (gaim_xfer_is_completed(xfer)) 949 if (purple_xfer_is_completed(xfer))
950 gaim_xfer_end(xfer); 950 purple_xfer_end(xfer);
951 } 951 }
952 952
953 static void 953 static void
954 begin_transfer(GaimXfer *xfer, GaimInputCondition cond) 954 begin_transfer(PurpleXfer *xfer, PurpleInputCondition cond)
955 { 955 {
956 GaimXferType type = gaim_xfer_get_type(xfer); 956 PurpleXferType type = purple_xfer_get_type(xfer);
957 957
958 xfer->dest_fp = g_fopen(gaim_xfer_get_local_filename(xfer), 958 xfer->dest_fp = g_fopen(purple_xfer_get_local_filename(xfer),
959 type == GAIM_XFER_RECEIVE ? "wb" : "rb"); 959 type == PURPLE_XFER_RECEIVE ? "wb" : "rb");
960 960
961 if (xfer->dest_fp == NULL) { 961 if (xfer->dest_fp == NULL) {
962 gaim_xfer_show_file_error(xfer, gaim_xfer_get_local_filename(xfer)); 962 purple_xfer_show_file_error(xfer, purple_xfer_get_local_filename(xfer));
963 gaim_xfer_cancel_local(xfer); 963 purple_xfer_cancel_local(xfer);
964 return; 964 return;
965 } 965 }
966 966
967 fseek(xfer->dest_fp, xfer->bytes_sent, SEEK_SET); 967 fseek(xfer->dest_fp, xfer->bytes_sent, SEEK_SET);
968 968
969 xfer->watcher = gaim_input_add(xfer->fd, cond, transfer_cb, xfer); 969 xfer->watcher = purple_input_add(xfer->fd, cond, transfer_cb, xfer);
970 970
971 xfer->start_time = time(NULL); 971 xfer->start_time = time(NULL);
972 972
973 if (xfer->ops.start != NULL) 973 if (xfer->ops.start != NULL)
974 xfer->ops.start(xfer); 974 xfer->ops.start(xfer);
975 } 975 }
976 976
977 static void 977 static void
978 connect_cb(gpointer data, gint source, const gchar *error_message) 978 connect_cb(gpointer data, gint source, const gchar *error_message)
979 { 979 {
980 GaimXfer *xfer = (GaimXfer *)data; 980 PurpleXfer *xfer = (PurpleXfer *)data;
981 981
982 xfer->fd = source; 982 xfer->fd = source;
983 983
984 begin_transfer(xfer, GAIM_INPUT_READ); 984 begin_transfer(xfer, PURPLE_INPUT_READ);
985 } 985 }
986 986
987 void 987 void
988 gaim_xfer_start(GaimXfer *xfer, int fd, const char *ip, 988 purple_xfer_start(PurpleXfer *xfer, int fd, const char *ip,
989 unsigned int port) 989 unsigned int port)
990 { 990 {
991 GaimInputCondition cond; 991 PurpleInputCondition cond;
992 GaimXferType type; 992 PurpleXferType type;
993 993
994 g_return_if_fail(xfer != NULL); 994 g_return_if_fail(xfer != NULL);
995 g_return_if_fail(gaim_xfer_get_type(xfer) != GAIM_XFER_UNKNOWN); 995 g_return_if_fail(purple_xfer_get_type(xfer) != PURPLE_XFER_UNKNOWN);
996 996
997 type = gaim_xfer_get_type(xfer); 997 type = purple_xfer_get_type(xfer);
998 998
999 gaim_xfer_set_status(xfer, GAIM_XFER_STATUS_STARTED); 999 purple_xfer_set_status(xfer, PURPLE_XFER_STATUS_STARTED);
1000 1000
1001 if (type == GAIM_XFER_RECEIVE) { 1001 if (type == PURPLE_XFER_RECEIVE) {
1002 cond = GAIM_INPUT_READ; 1002 cond = PURPLE_INPUT_READ;
1003 1003
1004 if (ip != NULL) { 1004 if (ip != NULL) {
1005 xfer->remote_ip = g_strdup(ip); 1005 xfer->remote_ip = g_strdup(ip);
1006 xfer->remote_port = port; 1006 xfer->remote_port = port;
1007 1007
1008 /* Establish a file descriptor. */ 1008 /* Establish a file descriptor. */
1009 gaim_proxy_connect(NULL, xfer->account, xfer->remote_ip, 1009 purple_proxy_connect(NULL, xfer->account, xfer->remote_ip,
1010 xfer->remote_port, connect_cb, xfer); 1010 xfer->remote_port, connect_cb, xfer);
1011 1011
1012 return; 1012 return;
1013 } 1013 }
1014 else { 1014 else {
1015 xfer->fd = fd; 1015 xfer->fd = fd;
1016 } 1016 }
1017 } 1017 }
1018 else { 1018 else {
1019 cond = GAIM_INPUT_WRITE; 1019 cond = PURPLE_INPUT_WRITE;
1020 1020
1021 xfer->fd = fd; 1021 xfer->fd = fd;
1022 } 1022 }
1023 1023
1024 begin_transfer(xfer, cond); 1024 begin_transfer(xfer, cond);
1025 } 1025 }
1026 1026
1027 void 1027 void
1028 gaim_xfer_end(GaimXfer *xfer) 1028 purple_xfer_end(PurpleXfer *xfer)
1029 { 1029 {
1030 g_return_if_fail(xfer != NULL); 1030 g_return_if_fail(xfer != NULL);
1031 1031
1032 /* See if we are actually trying to cancel this. */ 1032 /* See if we are actually trying to cancel this. */
1033 if (!gaim_xfer_is_completed(xfer)) { 1033 if (!purple_xfer_is_completed(xfer)) {
1034 gaim_xfer_cancel_local(xfer); 1034 purple_xfer_cancel_local(xfer);
1035 return; 1035 return;
1036 } 1036 }
1037 1037
1038 xfer->end_time = time(NULL); 1038 xfer->end_time = time(NULL);
1039 if (xfer->ops.end != NULL) 1039 if (xfer->ops.end != NULL)
1040 xfer->ops.end(xfer); 1040 xfer->ops.end(xfer);
1041 1041
1042 if (xfer->watcher != 0) { 1042 if (xfer->watcher != 0) {
1043 gaim_input_remove(xfer->watcher); 1043 purple_input_remove(xfer->watcher);
1044 xfer->watcher = 0; 1044 xfer->watcher = 0;
1045 } 1045 }
1046 1046
1047 if (xfer->fd != 0) 1047 if (xfer->fd != 0)
1048 close(xfer->fd); 1048 close(xfer->fd);
1050 if (xfer->dest_fp != NULL) { 1050 if (xfer->dest_fp != NULL) {
1051 fclose(xfer->dest_fp); 1051 fclose(xfer->dest_fp);
1052 xfer->dest_fp = NULL; 1052 xfer->dest_fp = NULL;
1053 } 1053 }
1054 1054
1055 gaim_xfer_unref(xfer); 1055 purple_xfer_unref(xfer);
1056 } 1056 }
1057 1057
1058 void 1058 void
1059 gaim_xfer_add(GaimXfer *xfer) 1059 purple_xfer_add(PurpleXfer *xfer)
1060 { 1060 {
1061 GaimXferUiOps *ui_ops; 1061 PurpleXferUiOps *ui_ops;
1062 1062
1063 g_return_if_fail(xfer != NULL); 1063 g_return_if_fail(xfer != NULL);
1064 1064
1065 ui_ops = gaim_xfer_get_ui_ops(xfer); 1065 ui_ops = purple_xfer_get_ui_ops(xfer);
1066 1066
1067 if (ui_ops != NULL && ui_ops->add_xfer != NULL) 1067 if (ui_ops != NULL && ui_ops->add_xfer != NULL)
1068 ui_ops->add_xfer(xfer); 1068 ui_ops->add_xfer(xfer);
1069 } 1069 }
1070 1070
1071 void 1071 void
1072 gaim_xfer_cancel_local(GaimXfer *xfer) 1072 purple_xfer_cancel_local(PurpleXfer *xfer)
1073 { 1073 {
1074 GaimXferUiOps *ui_ops; 1074 PurpleXferUiOps *ui_ops;
1075 char *msg = NULL; 1075 char *msg = NULL;
1076 1076
1077 g_return_if_fail(xfer != NULL); 1077 g_return_if_fail(xfer != NULL);
1078 1078
1079 gaim_xfer_set_status(xfer, GAIM_XFER_STATUS_CANCEL_LOCAL); 1079 purple_xfer_set_status(xfer, PURPLE_XFER_STATUS_CANCEL_LOCAL);
1080 xfer->end_time = time(NULL); 1080 xfer->end_time = time(NULL);
1081 1081
1082 if (gaim_xfer_get_filename(xfer) != NULL) 1082 if (purple_xfer_get_filename(xfer) != NULL)
1083 { 1083 {
1084 msg = g_strdup_printf(_("You canceled the transfer of %s"), 1084 msg = g_strdup_printf(_("You canceled the transfer of %s"),
1085 gaim_xfer_get_filename(xfer)); 1085 purple_xfer_get_filename(xfer));
1086 } 1086 }
1087 else 1087 else
1088 { 1088 {
1089 msg = g_strdup_printf(_("File transfer cancelled")); 1089 msg = g_strdup_printf(_("File transfer cancelled"));
1090 } 1090 }
1091 gaim_xfer_conversation_write(xfer, msg, FALSE); 1091 purple_xfer_conversation_write(xfer, msg, FALSE);
1092 g_free(msg); 1092 g_free(msg);
1093 1093
1094 if (gaim_xfer_get_type(xfer) == GAIM_XFER_SEND) 1094 if (purple_xfer_get_type(xfer) == PURPLE_XFER_SEND)
1095 { 1095 {
1096 if (xfer->ops.cancel_send != NULL) 1096 if (xfer->ops.cancel_send != NULL)
1097 xfer->ops.cancel_send(xfer); 1097 xfer->ops.cancel_send(xfer);
1098 } 1098 }
1099 else 1099 else
1101 if (xfer->ops.cancel_recv != NULL) 1101 if (xfer->ops.cancel_recv != NULL)
1102 xfer->ops.cancel_recv(xfer); 1102 xfer->ops.cancel_recv(xfer);
1103 } 1103 }
1104 1104
1105 if (xfer->watcher != 0) { 1105 if (xfer->watcher != 0) {
1106 gaim_input_remove(xfer->watcher); 1106 purple_input_remove(xfer->watcher);
1107 xfer->watcher = 0; 1107 xfer->watcher = 0;
1108 } 1108 }
1109 1109
1110 if (xfer->fd != 0) 1110 if (xfer->fd != 0)
1111 close(xfer->fd); 1111 close(xfer->fd);
1113 if (xfer->dest_fp != NULL) { 1113 if (xfer->dest_fp != NULL) {
1114 fclose(xfer->dest_fp); 1114 fclose(xfer->dest_fp);
1115 xfer->dest_fp = NULL; 1115 xfer->dest_fp = NULL;
1116 } 1116 }
1117 1117
1118 ui_ops = gaim_xfer_get_ui_ops(xfer); 1118 ui_ops = purple_xfer_get_ui_ops(xfer);
1119 1119
1120 if (ui_ops != NULL && ui_ops->cancel_local != NULL) 1120 if (ui_ops != NULL && ui_ops->cancel_local != NULL)
1121 ui_ops->cancel_local(xfer); 1121 ui_ops->cancel_local(xfer);
1122 1122
1123 xfer->bytes_remaining = 0; 1123 xfer->bytes_remaining = 0;
1124 1124
1125 gaim_xfer_unref(xfer); 1125 purple_xfer_unref(xfer);
1126 } 1126 }
1127 1127
1128 void 1128 void
1129 gaim_xfer_cancel_remote(GaimXfer *xfer) 1129 purple_xfer_cancel_remote(PurpleXfer *xfer)
1130 { 1130 {
1131 GaimXferUiOps *ui_ops; 1131 PurpleXferUiOps *ui_ops;
1132 gchar *msg; 1132 gchar *msg;
1133 GaimAccount *account; 1133 PurpleAccount *account;
1134 GaimBuddy *buddy; 1134 PurpleBuddy *buddy;
1135 1135
1136 g_return_if_fail(xfer != NULL); 1136 g_return_if_fail(xfer != NULL);
1137 1137
1138 gaim_request_close_with_handle(xfer); 1138 purple_request_close_with_handle(xfer);
1139 gaim_xfer_set_status(xfer, GAIM_XFER_STATUS_CANCEL_REMOTE); 1139 purple_xfer_set_status(xfer, PURPLE_XFER_STATUS_CANCEL_REMOTE);
1140 xfer->end_time = time(NULL); 1140 xfer->end_time = time(NULL);
1141 1141
1142 account = gaim_xfer_get_account(xfer); 1142 account = purple_xfer_get_account(xfer);
1143 buddy = gaim_find_buddy(account, xfer->who); 1143 buddy = purple_find_buddy(account, xfer->who);
1144 1144
1145 if (gaim_xfer_get_filename(xfer) != NULL) 1145 if (purple_xfer_get_filename(xfer) != NULL)
1146 { 1146 {
1147 msg = g_strdup_printf(_("%s canceled the transfer of %s"), 1147 msg = g_strdup_printf(_("%s canceled the transfer of %s"),
1148 buddy ? gaim_buddy_get_alias(buddy) : xfer->who, gaim_xfer_get_filename(xfer)); 1148 buddy ? purple_buddy_get_alias(buddy) : xfer->who, purple_xfer_get_filename(xfer));
1149 } 1149 }
1150 else 1150 else
1151 { 1151 {
1152 msg = g_strdup_printf(_("%s canceled the file transfer"), 1152 msg = g_strdup_printf(_("%s canceled the file transfer"),
1153 buddy ? gaim_buddy_get_alias(buddy) : xfer->who); 1153 buddy ? purple_buddy_get_alias(buddy) : xfer->who);
1154 } 1154 }
1155 gaim_xfer_conversation_write(xfer, msg, TRUE); 1155 purple_xfer_conversation_write(xfer, msg, TRUE);
1156 gaim_xfer_error(gaim_xfer_get_type(xfer), account, xfer->who, msg); 1156 purple_xfer_error(purple_xfer_get_type(xfer), account, xfer->who, msg);
1157 g_free(msg); 1157 g_free(msg);
1158 1158
1159 if (gaim_xfer_get_type(xfer) == GAIM_XFER_SEND) 1159 if (purple_xfer_get_type(xfer) == PURPLE_XFER_SEND)
1160 { 1160 {
1161 if (xfer->ops.cancel_send != NULL) 1161 if (xfer->ops.cancel_send != NULL)
1162 xfer->ops.cancel_send(xfer); 1162 xfer->ops.cancel_send(xfer);
1163 } 1163 }
1164 else 1164 else
1166 if (xfer->ops.cancel_recv != NULL) 1166 if (xfer->ops.cancel_recv != NULL)
1167 xfer->ops.cancel_recv(xfer); 1167 xfer->ops.cancel_recv(xfer);
1168 } 1168 }
1169 1169
1170 if (xfer->watcher != 0) { 1170 if (xfer->watcher != 0) {
1171 gaim_input_remove(xfer->watcher); 1171 purple_input_remove(xfer->watcher);
1172 xfer->watcher = 0; 1172 xfer->watcher = 0;
1173 } 1173 }
1174 1174
1175 if (xfer->fd != 0) 1175 if (xfer->fd != 0)
1176 close(xfer->fd); 1176 close(xfer->fd);
1178 if (xfer->dest_fp != NULL) { 1178 if (xfer->dest_fp != NULL) {
1179 fclose(xfer->dest_fp); 1179 fclose(xfer->dest_fp);
1180 xfer->dest_fp = NULL; 1180 xfer->dest_fp = NULL;
1181 } 1181 }
1182 1182
1183 ui_ops = gaim_xfer_get_ui_ops(xfer); 1183 ui_ops = purple_xfer_get_ui_ops(xfer);
1184 1184
1185 if (ui_ops != NULL && ui_ops->cancel_remote != NULL) 1185 if (ui_ops != NULL && ui_ops->cancel_remote != NULL)
1186 ui_ops->cancel_remote(xfer); 1186 ui_ops->cancel_remote(xfer);
1187 1187
1188 xfer->bytes_remaining = 0; 1188 xfer->bytes_remaining = 0;
1189 1189
1190 gaim_xfer_unref(xfer); 1190 purple_xfer_unref(xfer);
1191 } 1191 }
1192 1192
1193 void 1193 void
1194 gaim_xfer_error(GaimXferType type, GaimAccount *account, const char *who, const char *msg) 1194 purple_xfer_error(PurpleXferType type, PurpleAccount *account, const char *who, const char *msg)
1195 { 1195 {
1196 char *title; 1196 char *title;
1197 1197
1198 g_return_if_fail(msg != NULL); 1198 g_return_if_fail(msg != NULL);
1199 g_return_if_fail(type != GAIM_XFER_UNKNOWN); 1199 g_return_if_fail(type != PURPLE_XFER_UNKNOWN);
1200 1200
1201 if (account) { 1201 if (account) {
1202 GaimBuddy *buddy; 1202 PurpleBuddy *buddy;
1203 buddy = gaim_find_buddy(account, who); 1203 buddy = purple_find_buddy(account, who);
1204 if (buddy) 1204 if (buddy)
1205 who = gaim_buddy_get_alias(buddy); 1205 who = purple_buddy_get_alias(buddy);
1206 } 1206 }
1207 1207
1208 if (type == GAIM_XFER_SEND) 1208 if (type == PURPLE_XFER_SEND)
1209 title = g_strdup_printf(_("File transfer to %s failed."), who); 1209 title = g_strdup_printf(_("File transfer to %s failed."), who);
1210 else 1210 else
1211 title = g_strdup_printf(_("File transfer from %s failed."), who); 1211 title = g_strdup_printf(_("File transfer from %s failed."), who);
1212 1212
1213 gaim_notify_error(NULL, NULL, title, msg); 1213 purple_notify_error(NULL, NULL, title, msg);
1214 1214
1215 g_free(title); 1215 g_free(title);
1216 } 1216 }
1217 1217
1218 void 1218 void
1219 gaim_xfer_update_progress(GaimXfer *xfer) 1219 purple_xfer_update_progress(PurpleXfer *xfer)
1220 { 1220 {
1221 GaimXferUiOps *ui_ops; 1221 PurpleXferUiOps *ui_ops;
1222 1222
1223 g_return_if_fail(xfer != NULL); 1223 g_return_if_fail(xfer != NULL);
1224 1224
1225 ui_ops = gaim_xfer_get_ui_ops(xfer); 1225 ui_ops = purple_xfer_get_ui_ops(xfer);
1226 if (ui_ops != NULL && ui_ops->update_progress != NULL) 1226 if (ui_ops != NULL && ui_ops->update_progress != NULL)
1227 ui_ops->update_progress(xfer, gaim_xfer_get_progress(xfer)); 1227 ui_ops->update_progress(xfer, purple_xfer_get_progress(xfer));
1228 } 1228 }
1229 1229
1230 1230
1231 /************************************************************************** 1231 /**************************************************************************
1232 * File Transfer Subsystem API 1232 * File Transfer Subsystem API
1233 **************************************************************************/ 1233 **************************************************************************/
1234 void * 1234 void *
1235 gaim_xfers_get_handle(void) { 1235 purple_xfers_get_handle(void) {
1236 static int handle = 0; 1236 static int handle = 0;
1237 1237
1238 return &handle; 1238 return &handle;
1239 } 1239 }
1240 1240
1241 void 1241 void
1242 gaim_xfers_init(void) { 1242 purple_xfers_init(void) {
1243 void *handle = gaim_xfers_get_handle(); 1243 void *handle = purple_xfers_get_handle();
1244 1244
1245 /* register signals */ 1245 /* register signals */
1246 gaim_signal_register(handle, "file-recv-accept", 1246 purple_signal_register(handle, "file-recv-accept",
1247 gaim_marshal_VOID__POINTER, NULL, 1, 1247 purple_marshal_VOID__POINTER, NULL, 1,
1248 gaim_value_new(GAIM_TYPE_SUBTYPE, 1248 purple_value_new(PURPLE_TYPE_SUBTYPE,
1249 GAIM_SUBTYPE_XFER)); 1249 PURPLE_SUBTYPE_XFER));
1250 gaim_signal_register(handle, "file-send-accept", 1250 purple_signal_register(handle, "file-send-accept",
1251 gaim_marshal_VOID__POINTER, NULL, 1, 1251 purple_marshal_VOID__POINTER, NULL, 1,
1252 gaim_value_new(GAIM_TYPE_SUBTYPE, 1252 purple_value_new(PURPLE_TYPE_SUBTYPE,
1253 GAIM_SUBTYPE_XFER)); 1253 PURPLE_SUBTYPE_XFER));
1254 gaim_signal_register(handle, "file-recv-start", 1254 purple_signal_register(handle, "file-recv-start",
1255 gaim_marshal_VOID__POINTER, NULL, 1, 1255 purple_marshal_VOID__POINTER, NULL, 1,
1256 gaim_value_new(GAIM_TYPE_SUBTYPE, 1256 purple_value_new(PURPLE_TYPE_SUBTYPE,
1257 GAIM_SUBTYPE_XFER)); 1257 PURPLE_SUBTYPE_XFER));
1258 gaim_signal_register(handle, "file-send-start", 1258 purple_signal_register(handle, "file-send-start",
1259 gaim_marshal_VOID__POINTER, NULL, 1, 1259 purple_marshal_VOID__POINTER, NULL, 1,
1260 gaim_value_new(GAIM_TYPE_SUBTYPE, 1260 purple_value_new(PURPLE_TYPE_SUBTYPE,
1261 GAIM_SUBTYPE_XFER)); 1261 PURPLE_SUBTYPE_XFER));
1262 gaim_signal_register(handle, "file-send-cancel", 1262 purple_signal_register(handle, "file-send-cancel",
1263 gaim_marshal_VOID__POINTER, NULL, 1, 1263 purple_marshal_VOID__POINTER, NULL, 1,
1264 gaim_value_new(GAIM_TYPE_SUBTYPE, 1264 purple_value_new(PURPLE_TYPE_SUBTYPE,
1265 GAIM_SUBTYPE_XFER)); 1265 PURPLE_SUBTYPE_XFER));
1266 gaim_signal_register(handle, "file-recv-cancel", 1266 purple_signal_register(handle, "file-recv-cancel",
1267 gaim_marshal_VOID__POINTER, NULL, 1, 1267 purple_marshal_VOID__POINTER, NULL, 1,
1268 gaim_value_new(GAIM_TYPE_SUBTYPE, 1268 purple_value_new(PURPLE_TYPE_SUBTYPE,
1269 GAIM_SUBTYPE_XFER)); 1269 PURPLE_SUBTYPE_XFER));
1270 gaim_signal_register(handle, "file-send-complete", 1270 purple_signal_register(handle, "file-send-complete",
1271 gaim_marshal_VOID__POINTER, NULL, 1, 1271 purple_marshal_VOID__POINTER, NULL, 1,
1272 gaim_value_new(GAIM_TYPE_SUBTYPE, 1272 purple_value_new(PURPLE_TYPE_SUBTYPE,
1273 GAIM_SUBTYPE_XFER)); 1273 PURPLE_SUBTYPE_XFER));
1274 gaim_signal_register(handle, "file-recv-complete", 1274 purple_signal_register(handle, "file-recv-complete",
1275 gaim_marshal_VOID__POINTER, NULL, 1, 1275 purple_marshal_VOID__POINTER, NULL, 1,
1276 gaim_value_new(GAIM_TYPE_SUBTYPE, 1276 purple_value_new(PURPLE_TYPE_SUBTYPE,
1277 GAIM_SUBTYPE_XFER)); 1277 PURPLE_SUBTYPE_XFER));
1278 gaim_signal_register(handle, "file-recv-request", 1278 purple_signal_register(handle, "file-recv-request",
1279 gaim_marshal_VOID__POINTER, NULL, 1, 1279 purple_marshal_VOID__POINTER, NULL, 1,
1280 gaim_value_new(GAIM_TYPE_SUBTYPE, 1280 purple_value_new(PURPLE_TYPE_SUBTYPE,
1281 GAIM_SUBTYPE_XFER)); 1281 PURPLE_SUBTYPE_XFER));
1282 } 1282 }
1283 1283
1284 void 1284 void
1285 gaim_xfers_uninit(void) { 1285 purple_xfers_uninit(void) {
1286 gaim_signals_disconnect_by_handle(gaim_xfers_get_handle()); 1286 purple_signals_disconnect_by_handle(purple_xfers_get_handle());
1287 } 1287 }
1288 1288
1289 void 1289 void
1290 gaim_xfers_set_ui_ops(GaimXferUiOps *ops) { 1290 purple_xfers_set_ui_ops(PurpleXferUiOps *ops) {
1291 xfer_ui_ops = ops; 1291 xfer_ui_ops = ops;
1292 } 1292 }
1293 1293
1294 GaimXferUiOps * 1294 PurpleXferUiOps *
1295 gaim_xfers_get_ui_ops(void) { 1295 purple_xfers_get_ui_ops(void) {
1296 return xfer_ui_ops; 1296 return xfer_ui_ops;
1297 } 1297 }