Mercurial > pidgin
comparison src/ft.c @ 6240:ac191233b816
[gaim-migrate @ 6734]
Updated the file transfer API to resemble that of the rest of Gaim's API.
committer: Tailor Script <tailor@pidgin.im>
author | Christian Hammond <chipx86@chipx86.com> |
---|---|
date | Sun, 20 Jul 2003 03:30:43 +0000 |
parents | 059d95c67cda |
children | 9ce44a7f9ae7 |
comparison
equal
deleted
inserted
replaced
6239:8d10cdfe1bb1 | 6240:ac191233b816 |
---|---|
23 #include "internal.h" | 23 #include "internal.h" |
24 #include "ft.h" | 24 #include "ft.h" |
25 #include "notify.h" | 25 #include "notify.h" |
26 #include "proxy.h" | 26 #include "proxy.h" |
27 | 27 |
28 static struct gaim_xfer_ui_ops *xfer_ui_ops = NULL; | 28 static GaimXferUiOps *xfer_ui_ops = NULL; |
29 | 29 |
30 struct gaim_xfer * | 30 GaimXfer * |
31 gaim_xfer_new(GaimAccount *account, GaimXferType type, | 31 gaim_xfer_new(GaimAccount *account, GaimXferType type, const char *who) |
32 const char *who) | 32 { |
33 { | 33 GaimXfer *xfer; |
34 struct gaim_xfer *xfer; | 34 GaimXferUiOps *ui_ops; |
35 struct gaim_xfer_ui_ops *ui_ops; | 35 |
36 | 36 g_return_val_if_fail(type != GAIM_XFER_UNKNOWN, NULL); |
37 if (account == NULL || type == GAIM_XFER_UNKNOWN || who == NULL) | 37 g_return_val_if_fail(account != NULL, NULL); |
38 return NULL; | 38 g_return_val_if_fail(who != NULL, NULL); |
39 | 39 |
40 xfer = g_malloc0(sizeof(struct gaim_xfer)); | 40 xfer = g_new0(GaimXfer, 1); |
41 | 41 |
42 xfer->type = type; | 42 xfer->type = type; |
43 xfer->account = account; | 43 xfer->account = account; |
44 xfer->who = g_strdup(who); | 44 xfer->who = g_strdup(who); |
45 xfer->ui_ops = gaim_get_xfer_ui_ops(); | 45 xfer->ui_ops = gaim_get_xfer_ui_ops(); |
46 | 46 |
47 ui_ops = gaim_xfer_get_ui_ops(xfer); | 47 ui_ops = gaim_xfer_get_ui_ops(xfer); |
48 | 48 |
49 if (ui_ops != NULL && ui_ops->new != NULL) | 49 if (ui_ops != NULL && ui_ops->new_xfer != NULL) |
50 ui_ops->new(xfer); | 50 ui_ops->new_xfer(xfer); |
51 | 51 |
52 return xfer; | 52 return xfer; |
53 } | 53 } |
54 | 54 |
55 void | 55 void |
56 gaim_xfer_destroy(struct gaim_xfer *xfer) | 56 gaim_xfer_destroy(GaimXfer *xfer) |
57 { | 57 { |
58 struct gaim_xfer_ui_ops *ui_ops; | 58 GaimXferUiOps *ui_ops; |
59 | 59 |
60 if (xfer == NULL) | 60 g_return_if_fail(xfer != NULL); |
61 return; | |
62 | 61 |
63 if (!xfer->completed) | 62 if (!xfer->completed) |
64 gaim_xfer_cancel_local(xfer); | 63 gaim_xfer_cancel_local(xfer); |
65 | 64 |
66 ui_ops = gaim_xfer_get_ui_ops(xfer); | 65 ui_ops = gaim_xfer_get_ui_ops(xfer); |
79 | 78 |
80 g_free(xfer); | 79 g_free(xfer); |
81 } | 80 } |
82 | 81 |
83 void | 82 void |
84 gaim_xfer_request(struct gaim_xfer *xfer) | 83 gaim_xfer_request(GaimXfer *xfer) |
85 { | 84 { |
86 struct gaim_xfer_ui_ops *ui_ops; | 85 GaimXferUiOps *ui_ops; |
87 | 86 |
88 if (xfer == NULL || xfer->ops.init == NULL) | 87 g_return_if_fail(xfer != NULL); |
89 return; | 88 g_return_if_fail(xfer->ops.init != NULL); |
90 | 89 |
91 ui_ops = gaim_get_xfer_ui_ops(); | 90 ui_ops = gaim_get_xfer_ui_ops(); |
92 | 91 |
93 if (ui_ops == NULL || ui_ops->request_file == NULL) | 92 if (ui_ops == NULL || ui_ops->request_file == NULL) |
94 return; | 93 return; |
95 | 94 |
96 ui_ops->request_file(xfer); | 95 ui_ops->request_file(xfer); |
97 } | 96 } |
98 | 97 |
99 void | 98 void |
100 gaim_xfer_request_accepted(struct gaim_xfer *xfer, char *filename) | 99 gaim_xfer_request_accepted(GaimXfer *xfer, char *filename) |
101 { | 100 { |
102 GaimXferType type; | 101 GaimXferType type; |
103 | 102 |
104 if (xfer == NULL || filename == NULL) { | 103 if (xfer == NULL || filename == NULL) { |
105 | 104 |
155 | 154 |
156 xfer->ops.init(xfer); | 155 xfer->ops.init(xfer); |
157 } | 156 } |
158 | 157 |
159 void | 158 void |
160 gaim_xfer_request_denied(struct gaim_xfer *xfer) | 159 gaim_xfer_request_denied(GaimXfer *xfer) |
161 { | 160 { |
162 if (xfer == NULL) | 161 g_return_if_fail(xfer != NULL); |
163 return; | |
164 | 162 |
165 gaim_xfer_destroy(xfer); | 163 gaim_xfer_destroy(xfer); |
166 | 164 |
167 /* TODO */ | 165 /* TODO */ |
168 } | 166 } |
169 | 167 |
170 GaimXferType | 168 GaimXferType |
171 gaim_xfer_get_type(const struct gaim_xfer *xfer) | 169 gaim_xfer_get_type(const GaimXfer *xfer) |
172 { | 170 { |
173 if (xfer == NULL) | 171 g_return_val_if_fail(xfer != NULL, GAIM_XFER_UNKNOWN); |
174 return GAIM_XFER_UNKNOWN; | |
175 | 172 |
176 return xfer->type; | 173 return xfer->type; |
177 } | 174 } |
178 | 175 |
179 GaimAccount * | 176 GaimAccount * |
180 gaim_xfer_get_account(const struct gaim_xfer *xfer) | 177 gaim_xfer_get_account(const GaimXfer *xfer) |
181 { | 178 { |
182 if (xfer == NULL) | 179 g_return_val_if_fail(xfer != NULL, NULL); |
183 return NULL; | |
184 | 180 |
185 return xfer->account; | 181 return xfer->account; |
186 } | 182 } |
187 | 183 |
188 gboolean | 184 gboolean |
189 gaim_xfer_is_completed(const struct gaim_xfer *xfer) | 185 gaim_xfer_is_completed(const GaimXfer *xfer) |
190 { | 186 { |
191 if (xfer == NULL) | 187 g_return_val_if_fail(xfer != NULL, TRUE); |
192 return TRUE; | |
193 | 188 |
194 return xfer->completed; | 189 return xfer->completed; |
195 } | 190 } |
196 | 191 |
197 const char * | 192 const char * |
198 gaim_xfer_get_filename(const struct gaim_xfer *xfer) | 193 gaim_xfer_get_filename(const GaimXfer *xfer) |
199 { | 194 { |
200 if (xfer == NULL) | 195 g_return_val_if_fail(xfer != NULL, NULL); |
201 return NULL; | |
202 | 196 |
203 return xfer->filename; | 197 return xfer->filename; |
204 } | 198 } |
205 | 199 |
206 const char * | 200 const char * |
207 gaim_xfer_get_local_filename(const struct gaim_xfer *xfer) | 201 gaim_xfer_get_local_filename(const GaimXfer *xfer) |
208 { | 202 { |
209 if (xfer == NULL) | 203 g_return_val_if_fail(xfer != NULL, NULL); |
210 return NULL; | |
211 | 204 |
212 return xfer->local_filename; | 205 return xfer->local_filename; |
213 } | 206 } |
214 | 207 |
215 size_t | 208 size_t |
216 gaim_xfer_get_bytes_sent(const struct gaim_xfer *xfer) | 209 gaim_xfer_get_bytes_sent(const GaimXfer *xfer) |
217 { | 210 { |
218 if (xfer == NULL) | 211 g_return_val_if_fail(xfer != NULL, 0); |
219 return 0; | |
220 | 212 |
221 return xfer->bytes_sent; | 213 return xfer->bytes_sent; |
222 } | 214 } |
223 | 215 |
224 size_t | 216 size_t |
225 gaim_xfer_get_bytes_remaining(const struct gaim_xfer *xfer) | 217 gaim_xfer_get_bytes_remaining(const GaimXfer *xfer) |
226 { | 218 { |
227 if (xfer == NULL) | 219 g_return_val_if_fail(xfer != NULL, 0); |
228 return 0; | |
229 | 220 |
230 return xfer->bytes_remaining; | 221 return xfer->bytes_remaining; |
231 } | 222 } |
232 | 223 |
233 size_t | 224 size_t |
234 gaim_xfer_get_size(const struct gaim_xfer *xfer) | 225 gaim_xfer_get_size(const GaimXfer *xfer) |
235 { | 226 { |
236 if (xfer == NULL) | 227 g_return_val_if_fail(xfer != NULL, 0); |
237 return 0; | |
238 | 228 |
239 return xfer->size; | 229 return xfer->size; |
240 } | 230 } |
241 | 231 |
242 double | 232 double |
243 gaim_xfer_get_progress(const struct gaim_xfer *xfer) | 233 gaim_xfer_get_progress(const GaimXfer *xfer) |
244 { | 234 { |
245 if (xfer == NULL) | 235 g_return_val_if_fail(xfer != NULL, 0.0); |
246 return 0.0; | |
247 | 236 |
248 if (gaim_xfer_get_size(xfer) == 0) | 237 if (gaim_xfer_get_size(xfer) == 0) |
249 return 0.0; | 238 return 0.0; |
250 | 239 |
251 return ((double)gaim_xfer_get_bytes_sent(xfer) / | 240 return ((double)gaim_xfer_get_bytes_sent(xfer) / |
252 (double)gaim_xfer_get_size(xfer)); | 241 (double)gaim_xfer_get_size(xfer)); |
253 } | 242 } |
254 | 243 |
255 const char * | 244 const char * |
256 gaim_xfer_get_local_ip(const struct gaim_xfer *xfer) | 245 gaim_xfer_get_local_ip(const GaimXfer *xfer) |
257 { | 246 { |
258 if (xfer == NULL) | 247 g_return_val_if_fail(xfer != NULL, NULL); |
259 return NULL; | |
260 | 248 |
261 return xfer->local_ip; | 249 return xfer->local_ip; |
262 } | 250 } |
263 | 251 |
264 unsigned int | 252 unsigned int |
265 gaim_xfer_get_local_port(const struct gaim_xfer *xfer) | 253 gaim_xfer_get_local_port(const GaimXfer *xfer) |
266 { | 254 { |
267 if (xfer == NULL) | 255 g_return_val_if_fail(xfer != NULL, -1); |
268 return -1; | |
269 | 256 |
270 return xfer->local_port; | 257 return xfer->local_port; |
271 } | 258 } |
272 | 259 |
273 const char * | 260 const char * |
274 gaim_xfer_get_remote_ip(const struct gaim_xfer *xfer) | 261 gaim_xfer_get_remote_ip(const GaimXfer *xfer) |
275 { | 262 { |
276 if (xfer == NULL) | 263 g_return_val_if_fail(xfer != NULL, NULL); |
277 return NULL; | |
278 | 264 |
279 return xfer->remote_ip; | 265 return xfer->remote_ip; |
280 } | 266 } |
281 | 267 |
282 unsigned int | 268 unsigned int |
283 gaim_xfer_get_remote_port(const struct gaim_xfer *xfer) | 269 gaim_xfer_get_remote_port(const GaimXfer *xfer) |
284 { | 270 { |
285 if (xfer == NULL) | 271 g_return_val_if_fail(xfer != NULL, -1); |
286 return -1; | |
287 | 272 |
288 return xfer->remote_port; | 273 return xfer->remote_port; |
289 } | 274 } |
290 | 275 |
291 void | 276 void |
292 gaim_xfer_set_completed(struct gaim_xfer *xfer, gboolean completed) | 277 gaim_xfer_set_completed(GaimXfer *xfer, gboolean completed) |
293 { | 278 { |
294 struct gaim_xfer_ui_ops *ui_ops; | 279 GaimXferUiOps *ui_ops; |
295 | 280 |
296 if (xfer == NULL) | 281 g_return_if_fail(xfer != NULL); |
297 return; | |
298 | 282 |
299 xfer->completed = completed; | 283 xfer->completed = completed; |
300 | 284 |
301 ui_ops = gaim_xfer_get_ui_ops(xfer); | 285 ui_ops = gaim_xfer_get_ui_ops(xfer); |
302 | 286 |
304 ui_ops->update_progress(xfer, gaim_xfer_get_progress(xfer)); | 288 ui_ops->update_progress(xfer, gaim_xfer_get_progress(xfer)); |
305 | 289 |
306 } | 290 } |
307 | 291 |
308 void | 292 void |
309 gaim_xfer_set_filename(struct gaim_xfer *xfer, const char *filename) | 293 gaim_xfer_set_filename(GaimXfer *xfer, const char *filename) |
310 { | 294 { |
311 if (xfer == NULL) | 295 g_return_if_fail(xfer != NULL); |
312 return; | |
313 | 296 |
314 if (xfer->filename != NULL) | 297 if (xfer->filename != NULL) |
315 g_free(xfer->filename); | 298 g_free(xfer->filename); |
316 | 299 |
317 xfer->filename = (filename == NULL ? NULL : g_strdup(filename)); | 300 xfer->filename = (filename == NULL ? NULL : g_strdup(filename)); |
318 } | 301 } |
319 | 302 |
320 void | 303 void |
321 gaim_xfer_set_local_filename(struct gaim_xfer *xfer, const char *filename) | 304 gaim_xfer_set_local_filename(GaimXfer *xfer, const char *filename) |
322 { | 305 { |
323 if (xfer == NULL) | 306 g_return_if_fail(xfer != NULL); |
324 return; | |
325 | 307 |
326 if (xfer->local_filename != NULL) | 308 if (xfer->local_filename != NULL) |
327 g_free(xfer->local_filename); | 309 g_free(xfer->local_filename); |
328 | 310 |
329 xfer->local_filename = (filename == NULL ? NULL : g_strdup(filename)); | 311 xfer->local_filename = (filename == NULL ? NULL : g_strdup(filename)); |
330 } | 312 } |
331 | 313 |
332 void | 314 void |
333 gaim_xfer_set_size(struct gaim_xfer *xfer, size_t size) | 315 gaim_xfer_set_size(GaimXfer *xfer, size_t size) |
334 { | 316 { |
335 if (xfer == NULL) | 317 g_return_if_fail(xfer != NULL); |
336 return; | |
337 | 318 |
338 if (xfer->size == 0) | 319 if (xfer->size == 0) |
339 xfer->bytes_remaining = size - xfer->bytes_sent; | 320 xfer->bytes_remaining = size - xfer->bytes_sent; |
340 | 321 |
341 xfer->size = size; | 322 xfer->size = size; |
342 } | 323 } |
343 | 324 |
344 struct gaim_xfer_ui_ops * | 325 GaimXferUiOps * |
345 gaim_xfer_get_ui_ops(const struct gaim_xfer *xfer) | 326 gaim_xfer_get_ui_ops(const GaimXfer *xfer) |
346 { | 327 { |
347 if (xfer == NULL) | 328 g_return_val_if_fail(xfer != NULL, NULL); |
348 return NULL; | |
349 | 329 |
350 return xfer->ui_ops; | 330 return xfer->ui_ops; |
351 } | 331 } |
352 | 332 |
353 void | 333 void |
354 gaim_xfer_set_init_fnc(struct gaim_xfer *xfer, | 334 gaim_xfer_set_init_fnc(GaimXfer *xfer, void (*fnc)(GaimXfer *)) |
355 void (*fnc)(struct gaim_xfer *)) | 335 { |
356 { | 336 g_return_if_fail(xfer != NULL); |
357 if (xfer == NULL) | |
358 return; | |
359 | 337 |
360 xfer->ops.init = fnc; | 338 xfer->ops.init = fnc; |
361 } | 339 } |
362 | 340 |
363 | 341 |
364 void | 342 void |
365 gaim_xfer_set_read_fnc(struct gaim_xfer *xfer, | 343 gaim_xfer_set_read_fnc(GaimXfer *xfer, size_t (*fnc)(char **, GaimXfer *)) |
366 size_t (*fnc)(char **, struct gaim_xfer *)) | 344 { |
367 { | 345 g_return_if_fail(xfer != NULL); |
368 if (xfer == NULL) | |
369 return; | |
370 | 346 |
371 xfer->ops.read = fnc; | 347 xfer->ops.read = fnc; |
372 } | 348 } |
373 | 349 |
374 void | 350 void |
375 gaim_xfer_set_write_fnc(struct gaim_xfer *xfer, | 351 gaim_xfer_set_write_fnc(GaimXfer *xfer, |
376 size_t (*fnc)(const char *, size_t, | 352 size_t (*fnc)(const char *, size_t, GaimXfer *)) |
377 struct gaim_xfer *)) | 353 { |
378 { | 354 g_return_if_fail(xfer != NULL); |
379 if (xfer == NULL) | |
380 return; | |
381 | 355 |
382 xfer->ops.write = fnc; | 356 xfer->ops.write = fnc; |
383 } | 357 } |
384 | 358 |
385 void | 359 void |
386 gaim_xfer_set_ack_fnc(struct gaim_xfer *xfer, | 360 gaim_xfer_set_ack_fnc(GaimXfer *xfer, |
387 void (*fnc)(struct gaim_xfer *, const char *, size_t)) | 361 void (*fnc)(GaimXfer *, const char *, size_t)) |
388 { | 362 { |
389 if (xfer == NULL) | 363 g_return_if_fail(xfer != NULL); |
390 return; | |
391 | 364 |
392 xfer->ops.ack = fnc; | 365 xfer->ops.ack = fnc; |
393 } | 366 } |
394 | 367 |
395 void | 368 void |
396 gaim_xfer_set_start_fnc(struct gaim_xfer *xfer, | 369 gaim_xfer_set_start_fnc(GaimXfer *xfer, void (*fnc)(GaimXfer *)) |
397 void (*fnc)(struct gaim_xfer *)) | 370 { |
398 { | 371 g_return_if_fail(xfer != NULL); |
399 if (xfer == NULL) | |
400 return; | |
401 | 372 |
402 xfer->ops.start = fnc; | 373 xfer->ops.start = fnc; |
403 } | 374 } |
404 | 375 |
405 void | 376 void |
406 gaim_xfer_set_end_fnc(struct gaim_xfer *xfer, | 377 gaim_xfer_set_end_fnc(GaimXfer *xfer, void (*fnc)(GaimXfer *)) |
407 void (*fnc)(struct gaim_xfer *)) | 378 { |
408 { | 379 g_return_if_fail(xfer != NULL); |
409 if (xfer == NULL) | |
410 return; | |
411 | 380 |
412 xfer->ops.end = fnc; | 381 xfer->ops.end = fnc; |
413 } | 382 } |
414 | 383 |
415 void | 384 void |
416 gaim_xfer_set_cancel_send_fnc(struct gaim_xfer *xfer, | 385 gaim_xfer_set_cancel_send_fnc(GaimXfer *xfer, void (*fnc)(GaimXfer *)) |
417 void (*fnc)(struct gaim_xfer *)) | 386 { |
418 { | 387 g_return_if_fail(xfer != NULL); |
419 if (xfer == NULL) | |
420 return; | |
421 | 388 |
422 xfer->ops.cancel_send = fnc; | 389 xfer->ops.cancel_send = fnc; |
423 } | 390 } |
424 | 391 |
425 void | 392 void |
426 gaim_xfer_set_cancel_recv_fnc(struct gaim_xfer *xfer, | 393 gaim_xfer_set_cancel_recv_fnc(GaimXfer *xfer, void (*fnc)(GaimXfer *)) |
427 void (*fnc)(struct gaim_xfer *)) | 394 { |
428 { | 395 g_return_if_fail(xfer != NULL); |
429 if (xfer == NULL) | |
430 return; | |
431 | 396 |
432 xfer->ops.cancel_recv = fnc; | 397 xfer->ops.cancel_recv = fnc; |
433 } | 398 } |
434 | 399 |
435 size_t | 400 size_t |
436 gaim_xfer_read(struct gaim_xfer *xfer, char **buffer) | 401 gaim_xfer_read(GaimXfer *xfer, char **buffer) |
437 { | 402 { |
438 size_t s, r; | 403 size_t s, r; |
439 | 404 |
440 if (xfer == NULL || buffer == NULL) | 405 g_return_val_if_fail(xfer != NULL, 0); |
441 return 0; | 406 g_return_val_if_fail(buffer != NULL, 0); |
442 | 407 |
443 if (gaim_xfer_get_size(xfer) == 0) | 408 if (gaim_xfer_get_size(xfer) == 0) |
444 s = 4096; | 409 s = 4096; |
445 else | 410 else |
446 s = MIN(gaim_xfer_get_bytes_remaining(xfer), 4096); | 411 s = MIN(gaim_xfer_get_bytes_remaining(xfer), 4096); |
458 | 423 |
459 return r; | 424 return r; |
460 } | 425 } |
461 | 426 |
462 size_t | 427 size_t |
463 gaim_xfer_write(struct gaim_xfer *xfer, const char *buffer, size_t size) | 428 gaim_xfer_write(GaimXfer *xfer, const char *buffer, size_t size) |
464 { | 429 { |
465 size_t r, s; | 430 size_t r, s; |
466 | 431 |
467 if (xfer == NULL || buffer == NULL || size == 0) | 432 g_return_val_if_fail(xfer != NULL, 0); |
468 return 0; | 433 g_return_val_if_fail(buffer != NULL, 0); |
434 g_return_val_if_fail(size != 0, 0); | |
469 | 435 |
470 s = MIN(gaim_xfer_get_bytes_remaining(xfer), size); | 436 s = MIN(gaim_xfer_get_bytes_remaining(xfer), size); |
471 | 437 |
472 if (xfer->ops.write != NULL) | 438 if (xfer->ops.write != NULL) |
473 r = (xfer->ops.write)(buffer, s, xfer); | 439 r = (xfer->ops.write)(buffer, s, xfer); |
478 } | 444 } |
479 | 445 |
480 static void | 446 static void |
481 transfer_cb(gpointer data, gint source, GaimInputCondition condition) | 447 transfer_cb(gpointer data, gint source, GaimInputCondition condition) |
482 { | 448 { |
483 struct gaim_xfer_ui_ops *ui_ops; | 449 GaimXferUiOps *ui_ops; |
484 struct gaim_xfer *xfer = (struct gaim_xfer *)data; | 450 GaimXfer *xfer = (GaimXfer *)data; |
485 char *buffer = NULL; | 451 char *buffer = NULL; |
486 size_t r; | 452 size_t r; |
487 | 453 |
488 if (condition & GAIM_INPUT_READ) { | 454 if (condition & GAIM_INPUT_READ) { |
489 r = gaim_xfer_read(xfer, &buffer); | 455 r = gaim_xfer_read(xfer, &buffer); |
524 if (gaim_xfer_is_completed(xfer)) | 490 if (gaim_xfer_is_completed(xfer)) |
525 gaim_xfer_end(xfer); | 491 gaim_xfer_end(xfer); |
526 } | 492 } |
527 | 493 |
528 static void | 494 static void |
529 begin_transfer(struct gaim_xfer *xfer, GaimInputCondition cond) | 495 begin_transfer(GaimXfer *xfer, GaimInputCondition cond) |
530 { | 496 { |
531 struct gaim_xfer_ui_ops *ui_ops; | 497 GaimXferUiOps *ui_ops; |
532 GaimXferType type = gaim_xfer_get_type(xfer); | 498 GaimXferType type = gaim_xfer_get_type(xfer); |
533 | 499 |
534 ui_ops = gaim_xfer_get_ui_ops(xfer); | 500 ui_ops = gaim_xfer_get_ui_ops(xfer); |
535 | 501 |
536 /* | 502 /* |
556 } | 522 } |
557 | 523 |
558 static void | 524 static void |
559 connect_cb(gpointer data, gint source, GaimInputCondition condition) | 525 connect_cb(gpointer data, gint source, GaimInputCondition condition) |
560 { | 526 { |
561 struct gaim_xfer *xfer = (struct gaim_xfer *)data; | 527 GaimXfer *xfer = (GaimXfer *)data; |
562 | 528 |
563 xfer->fd = source; | 529 xfer->fd = source; |
564 | 530 |
565 begin_transfer(xfer, condition); | 531 begin_transfer(xfer, condition); |
566 } | 532 } |
567 | 533 |
568 void | 534 void |
569 gaim_xfer_start(struct gaim_xfer *xfer, int fd, const char *ip, | 535 gaim_xfer_start(GaimXfer *xfer, int fd, const char *ip, |
570 unsigned int port) | 536 unsigned int port) |
571 { | 537 { |
572 GaimInputCondition cond; | 538 GaimInputCondition cond; |
573 GaimXferType type; | 539 GaimXferType type; |
574 | 540 |
575 if (xfer == NULL || gaim_xfer_get_type(xfer) == GAIM_XFER_UNKNOWN) | 541 g_return_if_fail(xfer != NULL); |
576 return; | 542 g_return_if_fail(gaim_xfer_get_type(xfer) != GAIM_XFER_UNKNOWN); |
577 | 543 |
578 type = gaim_xfer_get_type(xfer); | 544 type = gaim_xfer_get_type(xfer); |
579 | 545 |
580 xfer->bytes_remaining = gaim_xfer_get_size(xfer); | 546 xfer->bytes_remaining = gaim_xfer_get_size(xfer); |
581 xfer->bytes_sent = 0; | 547 xfer->bytes_sent = 0; |
605 | 571 |
606 begin_transfer(xfer, cond); | 572 begin_transfer(xfer, cond); |
607 } | 573 } |
608 | 574 |
609 void | 575 void |
610 gaim_xfer_end(struct gaim_xfer *xfer) | 576 gaim_xfer_end(GaimXfer *xfer) |
611 { | 577 { |
612 if (xfer == NULL) | 578 g_return_if_fail(xfer != NULL); |
613 return; | |
614 | 579 |
615 /* See if we are actually trying to cancel this. */ | 580 /* See if we are actually trying to cancel this. */ |
616 if (!xfer->completed) { | 581 if (!xfer->completed) { |
617 gaim_xfer_cancel_local(xfer); | 582 gaim_xfer_cancel_local(xfer); |
618 return; | 583 return; |
634 xfer->dest_fp = NULL; | 599 xfer->dest_fp = NULL; |
635 } | 600 } |
636 } | 601 } |
637 | 602 |
638 void | 603 void |
639 gaim_xfer_cancel_local(struct gaim_xfer *xfer) | 604 gaim_xfer_cancel_local(GaimXfer *xfer) |
640 { | 605 { |
641 struct gaim_xfer_ui_ops *ui_ops; | 606 GaimXferUiOps *ui_ops; |
642 | 607 |
643 if (xfer == NULL) | 608 g_return_if_fail(xfer != NULL); |
644 return; | |
645 | 609 |
646 if (gaim_xfer_get_type(xfer) == GAIM_XFER_SEND) | 610 if (gaim_xfer_get_type(xfer) == GAIM_XFER_SEND) |
647 { | 611 { |
648 if (xfer->ops.cancel_send != NULL) | 612 if (xfer->ops.cancel_send != NULL) |
649 xfer->ops.cancel_send(xfer); | 613 xfer->ops.cancel_send(xfer); |
674 | 638 |
675 xfer->bytes_remaining = 0; | 639 xfer->bytes_remaining = 0; |
676 } | 640 } |
677 | 641 |
678 void | 642 void |
679 gaim_xfer_cancel_remote(struct gaim_xfer *xfer) | 643 gaim_xfer_cancel_remote(GaimXfer *xfer) |
680 { | 644 { |
681 struct gaim_xfer_ui_ops *ui_ops; | 645 GaimXferUiOps *ui_ops; |
682 | 646 |
683 if (xfer == NULL) | 647 g_return_if_fail(xfer != NULL); |
684 return; | |
685 | 648 |
686 if (gaim_xfer_get_type(xfer) == GAIM_XFER_SEND) | 649 if (gaim_xfer_get_type(xfer) == GAIM_XFER_SEND) |
687 { | 650 { |
688 if (xfer->ops.cancel_send != NULL) | 651 if (xfer->ops.cancel_send != NULL) |
689 xfer->ops.cancel_send(xfer); | 652 xfer->ops.cancel_send(xfer); |
718 void | 681 void |
719 gaim_xfer_error(GaimXferType type, const char *who, const char *msg) | 682 gaim_xfer_error(GaimXferType type, const char *who, const char *msg) |
720 { | 683 { |
721 char *title; | 684 char *title; |
722 | 685 |
723 if (msg == NULL || type == GAIM_XFER_UNKNOWN) | 686 g_return_if_fail(msg != NULL); |
724 return; | 687 g_return_if_fail(type != GAIM_XFER_UNKNOWN); |
725 | 688 |
726 if (type == GAIM_XFER_SEND) | 689 if (type == GAIM_XFER_SEND) |
727 title = g_strdup_printf(_("File transfer to %s aborted.\n"), who); | 690 title = g_strdup_printf(_("File transfer to %s aborted.\n"), who); |
728 else | 691 else |
729 title = g_strdup_printf(_("File transfer from %s aborted.\n"), who); | 692 title = g_strdup_printf(_("File transfer from %s aborted.\n"), who); |
732 | 695 |
733 g_free(title); | 696 g_free(title); |
734 } | 697 } |
735 | 698 |
736 void | 699 void |
737 gaim_set_xfer_ui_ops(struct gaim_xfer_ui_ops *ops) | 700 gaim_set_xfer_ui_ops(GaimXferUiOps *ops) |
738 { | 701 { |
739 if (ops == NULL) | 702 g_return_if_fail(ops != NULL); |
740 return; | |
741 | 703 |
742 xfer_ui_ops = ops; | 704 xfer_ui_ops = ops; |
743 } | 705 } |
744 | 706 |
745 struct gaim_xfer_ui_ops * | 707 GaimXferUiOps * |
746 gaim_get_xfer_ui_ops(void) | 708 gaim_get_xfer_ui_ops(void) |
747 { | 709 { |
748 return xfer_ui_ops; | 710 return xfer_ui_ops; |
749 } | 711 } |
750 | 712 |