Mercurial > gftp.yaz
annotate src/gtk/transfer.c @ 309:cc2eeb30b793
2003-11-7 Brian Masney <masneyb@gftp.org>
* lib/gftp.h lib/local.c lib/protocols.c lib/rfc2068.c lib/rfc959.c
lib/sshv2.c - added copy_param_options method to gftp_request
structure. When a gftp_request structure is copied, if a
copy_param_options method exists, this will be called so that the
local protocol data can be copied over. This is only used by the
FTP protocol at the moment to save the current state of Ascii or
Binary transfers.
* src/gtk/transfer.c (transfer_done) - when a transfer is
completed, copy the local protocol options back to the main window
* lib/rfc959.c (gftp_set_data_type) - check the return value of
rfc959_send_command() and if there is an error, return that
error.
* configure.in - added 'hr' to ALL_LINGUAS
author | masneyb |
---|---|
date | Sat, 08 Nov 2003 12:23:21 +0000 |
parents | 6d180e6a8ba5 |
children | 2ad0b9a00fdd |
rev | line source |
---|---|
1 | 1 /*****************************************************************************/ |
2 /* transfer.c - functions to handle transfering files */ | |
255 | 3 /* Copyright (C) 1998-2003 Brian Masney <masneyb@gftp.org> */ |
1 | 4 /* */ |
5 /* This program is free software; you can redistribute it and/or modify */ | |
6 /* it under the terms of the GNU General Public License as published by */ | |
7 /* the Free Software Foundation; either version 2 of the License, or */ | |
8 /* (at your option) any later version. */ | |
9 /* */ | |
10 /* This program is distributed in the hope that it will be useful, */ | |
11 /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ | |
12 /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */ | |
13 /* GNU General Public License for more details. */ | |
14 /* */ | |
15 /* You should have received a copy of the GNU General Public License */ | |
16 /* along with this program; if not, write to the Free Software */ | |
17 /* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ | |
18 /*****************************************************************************/ | |
19 | |
20 #include <gftp-gtk.h> | |
33 | 21 static const char cvsid[] = "$Id$"; |
1 | 22 |
23 static GtkWidget * dialog; | |
129 | 24 static int num_transfers_in_progress = 0; |
1 | 25 |
48 | 26 static void |
27 wakeup_main_thread (gpointer data, gint source, GdkInputCondition condition) | |
1 | 28 { |
48 | 29 gftp_request * request; |
30 char c; | |
31 | |
32 request = data; | |
33 if (request->wakeup_main_thread[0] > 0) | |
34 read (request->wakeup_main_thread[0], &c, 1); | |
35 } | |
33 | 36 |
1 | 37 |
48 | 38 static gint |
39 setup_wakeup_main_thread (gftp_request * request) | |
40 { | |
41 gint handler; | |
1 | 42 |
48 | 43 if (socketpair (AF_UNIX, SOCK_STREAM, 0, request->wakeup_main_thread) == 0) |
44 { | |
45 handler = gdk_input_add (request->wakeup_main_thread[0], | |
46 GDK_INPUT_READ, wakeup_main_thread, request); | |
47 } | |
48 else | |
49 { | |
50 request->wakeup_main_thread[0] = 0; | |
51 request->wakeup_main_thread[1] = 0; | |
52 handler = 0; | |
53 } | |
54 return (handler); | |
55 } | |
1 | 56 |
48 | 57 |
58 static void | |
59 teardown_wakeup_main_thread (gftp_request * request, gint handler) | |
60 { | |
61 if (request->wakeup_main_thread[0] > 0 && request->wakeup_main_thread[1] > 0) | |
62 { | |
63 gdk_input_remove (handler); | |
64 close (request->wakeup_main_thread[0]); | |
65 close (request->wakeup_main_thread[1]); | |
66 request->wakeup_main_thread[0] = 0; | |
67 request->wakeup_main_thread[1] = 0; | |
1 | 68 } |
69 } | |
70 | |
71 | |
72 static void * | |
73 getdir_thread (void * data) | |
74 { | |
75 int sj, havedotdot, got; | |
76 gftp_request * request; | |
77 gftp_file * fle; | |
78 GList * files; | |
79 | |
80 request = data; | |
81 | |
82 if (request->use_threads) | |
83 { | |
42 | 84 sj = sigsetjmp (jmp_environment, 1); |
85 use_jmp_environment = 1; | |
1 | 86 } |
87 else | |
88 sj = 0; | |
89 | |
90 files = NULL; | |
91 if (sj == 0 || sj == 2) | |
92 { | |
93 if (gftp_list_files (request) != 0 || !GFTP_IS_CONNECTED (request)) | |
94 { | |
95 if (request->use_threads) | |
42 | 96 use_jmp_environment = 0; |
97 | |
1 | 98 request->stopable = 0; |
99 if (request->wakeup_main_thread[1] > 0) | |
100 write (request->wakeup_main_thread[1], " ", 1); | |
101 return (NULL); | |
102 } | |
103 | |
104 request->gotbytes = 0; | |
105 havedotdot = 0; | |
106 fle = g_malloc0 (sizeof (*fle)); | |
274 | 107 while ((got = gftp_get_next_file (request, NULL, fle)) > 0 || |
108 got == GFTP_ERETRYABLE) | |
1 | 109 { |
274 | 110 if (got < 0) |
111 { | |
112 gftp_file_destroy (fle); | |
113 continue; | |
114 } | |
115 | |
1 | 116 request->gotbytes += got; |
117 if (strcmp (fle->file, ".") == 0) | |
118 { | |
119 gftp_file_destroy (fle); | |
120 continue; | |
121 } | |
122 else if (strcmp (fle->file, "..") == 0) | |
123 havedotdot = 1; | |
124 | |
125 files = g_list_append (files, fle); | |
126 fle = g_malloc0 (sizeof (*fle)); | |
127 } | |
128 g_free (fle); | |
129 | |
130 if (!GFTP_IS_CONNECTED (request)) | |
131 { | |
132 if (request->use_threads) | |
42 | 133 use_jmp_environment = 0; |
134 | |
1 | 135 request->stopable = 0; |
136 if (request->wakeup_main_thread[1] > 0) | |
137 write (request->wakeup_main_thread[1], " ", 1); | |
138 return (NULL); | |
139 } | |
140 | |
141 gftp_end_transfer (request); | |
142 request->gotbytes = -1; | |
143 | |
144 if (!havedotdot) | |
145 { | |
146 fle = g_malloc0 (sizeof (*fle)); | |
129 | 147 fle->file = g_strdup (".."); |
1 | 148 fle->user = g_malloc0 (1); |
149 fle->group = g_malloc0 (1); | |
150 fle->attribs = g_malloc0 (1); | |
151 *fle->attribs = '\0'; | |
152 fle->isdir = 1; | |
153 files = g_list_prepend (files, fle); | |
154 } | |
155 } | |
156 | |
157 if (request->use_threads) | |
43 | 158 use_jmp_environment = 0; |
42 | 159 |
1 | 160 request->stopable = 0; |
161 if (request->wakeup_main_thread[1] > 0) | |
162 write (request->wakeup_main_thread[1], " ", 1); | |
163 return (files); | |
164 } | |
165 | |
166 | |
48 | 167 int |
168 ftp_list_files (gftp_window_data * wdata, int usecache) | |
169 { | |
170 guint handler; | |
171 void *success; | |
172 | |
173 gtk_label_set (GTK_LABEL (wdata->hoststxt), _("Receiving file names...")); | |
174 | |
175 wdata->show_selected = 0; | |
176 if (wdata->files == NULL) | |
177 { | |
178 if (check_reconnect (wdata) < 0) | |
179 return (0); | |
180 | |
181 gtk_clist_freeze (GTK_CLIST (wdata->listbox)); | |
182 wdata->request->stopable = 1; | |
183 if (wdata->request->use_threads) | |
184 { | |
185 gtk_widget_set_sensitive (stop_btn, 1); | |
186 | |
187 handler = setup_wakeup_main_thread (wdata->request); | |
188 pthread_create (&wdata->tid, NULL, getdir_thread, wdata->request); | |
189 while (wdata->request->stopable) | |
190 { | |
191 GDK_THREADS_LEAVE (); | |
192 #if GTK_MAJOR_VERSION == 1 | |
193 g_main_iteration (TRUE); | |
194 #else | |
195 g_main_context_iteration (NULL, TRUE); | |
196 #endif | |
197 } | |
198 teardown_wakeup_main_thread (wdata->request, handler); | |
199 | |
200 pthread_join (wdata->tid, &success); | |
201 gtk_widget_set_sensitive (stop_btn, 0); | |
202 } | |
203 else | |
204 success = getdir_thread (wdata->request); | |
205 wdata->files = success; | |
206 gtk_clist_thaw (GTK_CLIST (wdata->listbox)); | |
207 memset (&wdata->tid, 0, sizeof (wdata->tid)); | |
208 } | |
209 | |
210 if (wdata->files == NULL || !GFTP_IS_CONNECTED (wdata->request)) | |
211 { | |
212 disconnect (wdata); | |
213 return (0); | |
214 } | |
215 | |
216 wdata->sorted = 0; | |
129 | 217 sortrows (GTK_CLIST (wdata->listbox), -1, (gpointer) wdata); |
48 | 218 if (IS_NONE_SELECTED (wdata)) |
219 gtk_clist_select_row (GTK_CLIST (wdata->listbox), 0, 0); | |
220 return (1); | |
221 } | |
222 | |
223 | |
19 | 224 static void |
225 try_connect_again (gftp_request * request, gftp_dialog_data * ddata) | |
226 { | |
227 gftp_set_password (request, gtk_entry_get_text (GTK_ENTRY (ddata->edit))); | |
228 request->stopable = 0; | |
229 } | |
230 | |
231 | |
232 static void | |
233 dont_connect_again (gftp_request * request, gftp_dialog_data * ddata) | |
234 { | |
235 request->stopable = 0; | |
236 } | |
237 | |
238 | |
48 | 239 static void * |
240 connect_thread (void *data) | |
241 { | |
129 | 242 int ret, sj, retries, sleep_time, network_timeout; |
48 | 243 static int conn_num; |
244 gftp_request * request; | |
245 | |
246 request = data; | |
247 | |
129 | 248 gftp_lookup_request_option (request, "retries", &retries); |
249 gftp_lookup_request_option (request, "sleep_time", &sleep_time); | |
250 gftp_lookup_request_option (request, "network_timeout", &network_timeout); | |
251 | |
48 | 252 conn_num = 0; |
253 if (request->use_threads) | |
254 { | |
255 sj = sigsetjmp (jmp_environment, 1); | |
256 use_jmp_environment = 1; | |
257 } | |
258 else | |
259 sj = 0; | |
260 | |
261 ret = 0; | |
262 if (sj != 0) | |
263 { | |
264 ret = 0; | |
265 gftp_disconnect (request); | |
266 } | |
267 | |
129 | 268 while (sj != 1 && (retries == 0 || conn_num < retries)) |
48 | 269 { |
270 conn_num++; | |
129 | 271 if (network_timeout > 0) |
272 alarm (network_timeout); | |
84 | 273 ret = gftp_connect (request); |
48 | 274 alarm (0); |
275 | |
84 | 276 if (ret == GFTP_EFATAL) |
277 { | |
278 ret = 0; | |
279 break; | |
280 } | |
281 else if (ret == 0) | |
282 { | |
283 ret = 1; | |
284 break; | |
285 } | |
129 | 286 else if (retries == 0 || conn_num < retries) |
48 | 287 { |
186 | 288 request->logging_function (gftp_logging_misc, request, |
48 | 289 _("Waiting %d seconds until trying to connect again\n"), |
129 | 290 sleep_time); |
291 alarm (sleep_time); | |
48 | 292 pause (); |
293 } | |
294 } | |
295 | |
296 if (request->use_threads) | |
297 use_jmp_environment = 0; | |
298 | |
299 request->stopable = 0; | |
300 if (request->wakeup_main_thread[1] > 0) | |
301 write (request->wakeup_main_thread[1], " ", 1); | |
195 | 302 return (GINT_TO_POINTER (ret)); |
48 | 303 } |
304 | |
305 | |
1 | 306 int |
307 ftp_connect (gftp_window_data * wdata, gftp_request * request, int getdir) | |
308 { | |
309 int success; | |
310 guint handler; | |
311 void *ret; | |
312 | |
313 ret = 0; | |
314 if (wdata->request == request) | |
315 { | |
316 gtk_label_set (GTK_LABEL (wdata->hoststxt), _("Connecting...")); | |
317 } | |
318 | |
7 | 319 if (request->need_userpass && request->username != NULL && |
320 *request->username != '\0' && | |
321 (request->password == NULL || *request->password == '\0')) | |
1 | 322 { |
323 if (wdata && wdata->request == request) | |
324 { | |
325 request->stopable = 1; | |
326 MakeEditDialog (_("Enter Password"), | |
327 _("Please enter your password for this site"), NULL, | |
19 | 328 0, NULL, gftp_dialog_button_connect, |
329 try_connect_again, request, | |
330 dont_connect_again, request); | |
31 | 331 |
1 | 332 while (request->stopable) |
31 | 333 { |
33 | 334 GDK_THREADS_LEAVE (); |
45 | 335 #if GTK_MAJOR_VERSION == 1 |
31 | 336 g_main_iteration (TRUE); |
41 | 337 #else |
338 g_main_context_iteration (NULL, TRUE); | |
339 #endif | |
31 | 340 } |
1 | 341 |
129 | 342 if (request->password == NULL || *request->password == '\0') |
1 | 343 return (0); |
344 } | |
345 else | |
346 gftp_set_password (request, ""); | |
347 } | |
348 | |
349 if (wdata && wdata->request == request && request->use_threads) | |
350 { | |
351 request->stopable = 1; | |
352 if (wdata) | |
353 gtk_clist_freeze (GTK_CLIST (wdata->listbox)); | |
354 gtk_widget_set_sensitive (stop_btn, 1); | |
355 pthread_create (&wdata->tid, NULL, connect_thread, request); | |
356 | |
357 handler = setup_wakeup_main_thread (wdata->request); | |
358 while (request->stopable) | |
31 | 359 { |
33 | 360 GDK_THREADS_LEAVE (); |
45 | 361 #if GTK_MAJOR_VERSION == 1 |
31 | 362 g_main_iteration (TRUE); |
41 | 363 #else |
364 g_main_context_iteration (NULL, TRUE); | |
365 #endif | |
31 | 366 } |
1 | 367 pthread_join (wdata->tid, &ret); |
368 teardown_wakeup_main_thread (wdata->request, handler); | |
369 | |
370 gtk_widget_set_sensitive (stop_btn, 0); | |
371 if (wdata) | |
372 gtk_clist_thaw (GTK_CLIST (wdata->listbox)); | |
373 } | |
374 else | |
375 ret = connect_thread (request); | |
195 | 376 |
377 success = GPOINTER_TO_INT (ret); | |
1 | 378 memset (&wdata->tid, 0, sizeof (wdata->tid)); |
379 | |
380 if (!GFTP_IS_CONNECTED (wdata->request)) | |
381 disconnect (wdata); | |
382 else if (success) | |
383 { | |
384 ftp_list_files (wdata, 1); | |
385 if (!GFTP_IS_CONNECTED (wdata->request)) | |
386 disconnect (wdata); | |
387 } | |
388 | |
389 return (success); | |
390 } | |
391 | |
392 | |
393 void | |
394 get_files (gpointer data) | |
395 { | |
396 transfer_window_files (&window2, &window1); | |
397 } | |
398 | |
399 | |
400 void | |
401 put_files (gpointer data) | |
402 { | |
403 transfer_window_files (&window1, &window2); | |
404 } | |
405 | |
406 | |
407 void | |
408 transfer_window_files (gftp_window_data * fromwdata, gftp_window_data * towdata) | |
409 { | |
410 gftp_file * tempfle, * newfle; | |
411 GList * templist, * filelist; | |
412 gftp_transfer * transfer; | |
413 guint timeout_num; | |
414 void *ret; | |
415 int num; | |
416 | |
417 if (!check_status (_("Transfer Files"), fromwdata, 1, 0, 1, | |
418 towdata->request->put_file != NULL && fromwdata->request->get_file != NULL)) | |
419 return; | |
420 | |
421 if (!GFTP_IS_CONNECTED (fromwdata->request) || | |
422 !GFTP_IS_CONNECTED (towdata->request)) | |
423 { | |
424 ftp_log (gftp_logging_misc, NULL, | |
425 _("Retrieve Files: Not connected to a remote site\n")); | |
426 return; | |
427 } | |
428 | |
429 if (check_reconnect (fromwdata) < 0 || check_reconnect (towdata) < 0) | |
430 return; | |
431 | |
432 transfer = g_malloc0 (sizeof (*transfer)); | |
151 | 433 transfer->fromreq = copy_request (fromwdata->request, 0); |
434 transfer->toreq = copy_request (towdata->request, 0); | |
1 | 435 transfer->fromwdata = fromwdata; |
436 transfer->towdata = towdata; | |
437 | |
438 num = 0; | |
439 templist = GTK_CLIST (fromwdata->listbox)->selection; | |
440 filelist = fromwdata->files; | |
441 while (templist != NULL) | |
442 { | |
443 templist = get_next_selection (templist, &filelist, &num); | |
444 tempfle = filelist->data; | |
445 if (strcmp (tempfle->file, "..") != 0) | |
446 { | |
447 newfle = copy_fdata (tempfle); | |
448 transfer->files = g_list_append (transfer->files, newfle); | |
449 } | |
450 } | |
451 | |
452 if (transfer->files != NULL) | |
453 { | |
63 | 454 gftp_swap_socks (transfer->fromreq, fromwdata->request); |
455 gftp_swap_socks (transfer->toreq, towdata->request); | |
1 | 456 |
457 if (transfer->fromreq->use_threads || | |
458 (transfer->toreq && transfer->toreq->use_threads)) | |
459 { | |
460 transfer->fromreq->stopable = 1; | |
461 pthread_create (&fromwdata->tid, NULL, do_getdir_thread, transfer); | |
462 | |
463 timeout_num = gtk_timeout_add (100, progress_timeout, transfer); | |
464 | |
465 while (transfer->fromreq->stopable) | |
31 | 466 { |
33 | 467 GDK_THREADS_LEAVE (); |
45 | 468 #if GTK_MAJOR_VERSION == 1 |
31 | 469 g_main_iteration (TRUE); |
41 | 470 #else |
471 g_main_context_iteration (NULL, TRUE); | |
472 #endif | |
31 | 473 } |
1 | 474 |
475 gtk_timeout_remove (timeout_num); | |
476 transfer->numfiles = transfer->numdirs = -1; | |
477 update_directory_download_progress (transfer); | |
478 | |
479 pthread_join (fromwdata->tid, &ret); | |
480 } | |
481 else | |
482 ret = do_getdir_thread (transfer); | |
483 | |
484 if (!GFTP_IS_CONNECTED (transfer->fromreq)) | |
485 { | |
486 disconnect (fromwdata); | |
487 return; | |
488 } | |
489 | |
490 if (!GFTP_IS_CONNECTED (transfer->toreq)) | |
491 { | |
492 disconnect (towdata); | |
493 return; | |
494 } | |
495 | |
63 | 496 gftp_swap_socks (fromwdata->request, transfer->fromreq); |
497 gftp_swap_socks (towdata->request, transfer->toreq); | |
1 | 498 } |
499 | |
500 if (transfer->files != NULL) | |
501 { | |
502 add_file_transfer (transfer->fromreq, transfer->toreq, | |
503 transfer->fromwdata, transfer->towdata, | |
504 transfer->files, 0); | |
505 g_free (transfer); | |
506 } | |
507 else | |
129 | 508 free_tdata (transfer); |
1 | 509 } |
510 | |
511 void * | |
512 do_getdir_thread (void * data) | |
513 { | |
514 gftp_transfer * transfer; | |
515 int success, sj; | |
516 | |
517 transfer = data; | |
518 | |
519 if (transfer->fromreq->use_threads || | |
520 (transfer->toreq && transfer->toreq->use_threads)) | |
521 { | |
42 | 522 sj = sigsetjmp (jmp_environment, 1); |
523 use_jmp_environment = 1; | |
1 | 524 } |
525 else | |
526 sj = 0; | |
527 | |
528 success = 0; | |
529 if (sj == 0) | |
530 success = gftp_get_all_subdirs (transfer, NULL) == 0; | |
531 else | |
532 { | |
533 gftp_disconnect (transfer->fromreq); | |
534 if (transfer->toreq) | |
535 gftp_disconnect (transfer->toreq); | |
536 transfer->fromreq->logging_function (gftp_logging_error, | |
186 | 537 transfer->fromreq, |
1 | 538 _("Operation canceled\n")); |
539 } | |
540 | |
541 if (transfer->fromreq->use_threads || | |
542 (transfer->toreq && transfer->toreq->use_threads)) | |
42 | 543 use_jmp_environment = 0; |
1 | 544 |
545 transfer->fromreq->stopable = 0; | |
195 | 546 return (GINT_TO_POINTER (success)); |
1 | 547 } |
548 | |
549 | |
305 | 550 static void |
551 _gftp_setup_fds (gftp_transfer * tdata, gftp_file * curfle, | |
552 int *fromfd, int *tofd) | |
553 { | |
554 *tofd = -1; | |
555 *fromfd = -1; | |
556 | |
557 if (curfle->is_fd) | |
558 { | |
559 if (tdata->toreq->protonum == GFTP_LOCAL_NUM) | |
560 *tofd = curfle->fd; | |
561 else if (tdata->fromreq->protonum == GFTP_LOCAL_NUM) | |
562 *fromfd = curfle->fd; | |
563 } | |
564 } | |
565 | |
566 | |
567 static void | |
568 _gftp_done_with_fds (gftp_transfer * tdata, gftp_file * curfle) | |
569 { | |
570 if (curfle->is_fd) | |
571 { | |
572 if (tdata->toreq->protonum == GFTP_LOCAL_NUM) | |
573 tdata->toreq->datafd = -1; | |
574 else | |
575 tdata->fromreq->datafd = -1; | |
576 } | |
577 } | |
578 | |
579 | |
1 | 580 void * |
581 gftp_gtk_transfer_files (void *data) | |
582 { | |
182 | 583 int i, mode, tofd, fromfd, preserve_permissions; |
1 | 584 gftp_transfer * transfer; |
129 | 585 char buf[8192]; |
1 | 586 off_t fromsize, total; |
587 gftp_file * curfle; | |
86 | 588 ssize_t num_read, ret; |
1 | 589 |
590 pthread_detach (pthread_self ()); | |
591 transfer = data; | |
592 transfer->curfle = transfer->files; | |
593 gettimeofday (&transfer->starttime, NULL); | |
594 memcpy (&transfer->lasttime, &transfer->starttime, | |
595 sizeof (transfer->lasttime)); | |
76 | 596 |
182 | 597 gftp_lookup_request_option (transfer->fromreq, "preserve_permissions", |
598 &preserve_permissions); | |
599 | |
1 | 600 while (transfer->curfle != NULL) |
601 { | |
129 | 602 num_read = -1; |
603 g_static_mutex_lock (&transfer->structmutex); | |
1 | 604 curfle = transfer->curfle->data; |
76 | 605 transfer->current_file_number++; |
129 | 606 g_static_mutex_unlock (&transfer->structmutex); |
1 | 607 |
608 if (curfle->transfer_action == GFTP_TRANS_ACTION_SKIP) | |
609 { | |
129 | 610 g_static_mutex_lock (&transfer->structmutex); |
1 | 611 transfer->next_file = 1; |
612 transfer->curfle = transfer->curfle->next; | |
129 | 613 g_static_mutex_unlock (&transfer->structmutex); |
1 | 614 continue; |
615 } | |
616 | |
617 fromsize = -1; | |
618 if (gftp_connect (transfer->fromreq) == 0 && | |
619 gftp_connect (transfer->toreq) == 0) | |
620 { | |
621 if (curfle->isdir) | |
622 { | |
623 if (transfer->toreq->mkdir != NULL) | |
624 { | |
625 transfer->toreq->mkdir (transfer->toreq, curfle->destfile); | |
626 if (!GFTP_IS_CONNECTED (transfer->toreq)) | |
627 break; | |
628 } | |
629 | |
129 | 630 g_static_mutex_lock (&transfer->structmutex); |
1 | 631 transfer->next_file = 1; |
632 transfer->curfle = transfer->curfle->next; | |
129 | 633 g_static_mutex_unlock (&transfer->structmutex); |
1 | 634 continue; |
635 } | |
636 | |
305 | 637 _gftp_setup_fds (transfer, curfle, &fromfd, &tofd); |
1 | 638 |
639 if (curfle->size == 0) | |
640 { | |
641 curfle->size = gftp_get_file_size (transfer->fromreq, curfle->file); | |
642 transfer->total_bytes += curfle->size; | |
643 } | |
644 | |
645 if (GFTP_IS_CONNECTED (transfer->fromreq) && | |
646 GFTP_IS_CONNECTED (transfer->toreq)) | |
647 { | |
648 fromsize = gftp_transfer_file (transfer->fromreq, curfle->file, | |
649 fromfd, | |
650 curfle->transfer_action == GFTP_TRANS_ACTION_RESUME ? | |
651 curfle->startsize : 0, | |
652 transfer->toreq, curfle->destfile, tofd, | |
653 curfle->transfer_action == GFTP_TRANS_ACTION_RESUME ? | |
654 curfle->startsize : 0); | |
655 } | |
656 } | |
657 | |
658 if (!GFTP_IS_CONNECTED (transfer->fromreq) || | |
659 !GFTP_IS_CONNECTED (transfer->toreq)) | |
660 { | |
661 transfer->fromreq->logging_function (gftp_logging_misc, | |
186 | 662 transfer->fromreq, |
1 | 663 _("Error: Remote site disconnected after trying to transfer file\n")); |
664 } | |
665 else if (fromsize < 0) | |
666 { | |
129 | 667 g_static_mutex_lock (&transfer->structmutex); |
1 | 668 curfle->transfer_action = GFTP_TRANS_ACTION_SKIP; |
669 transfer->next_file = 1; | |
670 transfer->curfle = transfer->curfle->next; | |
129 | 671 g_static_mutex_unlock (&transfer->structmutex); |
1 | 672 continue; |
673 } | |
674 else | |
675 { | |
129 | 676 g_static_mutex_lock (&transfer->structmutex); |
1 | 677 transfer->curtrans = 0; |
678 transfer->curresumed = curfle->transfer_action == GFTP_TRANS_ACTION_RESUME ? curfle->startsize : 0; | |
679 transfer->resumed_bytes += transfer->curresumed; | |
129 | 680 g_static_mutex_unlock (&transfer->structmutex); |
1 | 681 |
682 total = 0; | |
683 i = 0; | |
684 while (!transfer->cancel && | |
685 (num_read = gftp_get_next_file_chunk (transfer->fromreq, | |
686 buf, sizeof (buf))) > 0) | |
687 { | |
688 total += num_read; | |
129 | 689 gftp_calc_kbs (transfer, num_read); |
1 | 690 |
129 | 691 if ((ret = gftp_put_next_file_chunk (transfer->toreq, buf, |
86 | 692 num_read)) < 0) |
1 | 693 { |
86 | 694 num_read = (int) ret; |
1 | 695 break; |
696 } | |
697 } | |
698 } | |
699 | |
40 | 700 if (transfer->cancel) |
701 { | |
702 if (gftp_abort_transfer (transfer->fromreq) != 0) | |
703 gftp_disconnect (transfer->fromreq); | |
704 | |
705 if (gftp_abort_transfer (transfer->toreq) != 0) | |
706 gftp_disconnect (transfer->toreq); | |
707 } | |
708 else if (num_read < 0) | |
1 | 709 { |
710 transfer->fromreq->logging_function (gftp_logging_misc, | |
186 | 711 transfer->fromreq, |
1 | 712 _("Could not download %s from %s\n"), |
713 curfle->file, | |
714 transfer->fromreq->hostname); | |
715 | |
129 | 716 if (gftp_get_transfer_status (transfer, num_read) == GFTP_ERETRYABLE) |
40 | 717 continue; |
718 | |
1 | 719 break; |
720 } | |
721 else | |
722 { | |
305 | 723 _gftp_done_with_fds (transfer, curfle); |
1 | 724 if (gftp_end_transfer (transfer->fromreq) != 0) |
725 { | |
129 | 726 if (gftp_get_transfer_status (transfer, -1) == GFTP_ERETRYABLE) |
40 | 727 continue; |
728 | |
1 | 729 break; |
730 } | |
731 gftp_end_transfer (transfer->toreq); | |
732 | |
733 transfer->fromreq->logging_function (gftp_logging_misc, | |
186 | 734 transfer->fromreq, |
1 | 735 _("Successfully transferred %s at %.2f KB/s\n"), |
736 curfle->file, transfer->kbs); | |
737 } | |
738 | |
182 | 739 if (!curfle->is_fd && preserve_permissions) |
1 | 740 { |
741 if (curfle->attribs) | |
742 { | |
129 | 743 mode = gftp_parse_attribs (curfle->attribs); |
1 | 744 if (mode != 0) |
129 | 745 gftp_chmod (transfer->toreq, curfle->destfile, mode); |
1 | 746 } |
747 | |
748 if (curfle->datetime != 0) | |
749 gftp_set_file_time (transfer->toreq, curfle->destfile, | |
750 curfle->datetime); | |
751 } | |
752 | |
129 | 753 g_static_mutex_lock (&transfer->structmutex); |
278 | 754 transfer->curtrans = 0; |
1 | 755 transfer->next_file = 1; |
756 curfle->transfer_done = 1; | |
757 transfer->curfle = transfer->curfle->next; | |
129 | 758 g_static_mutex_unlock (&transfer->structmutex); |
1 | 759 |
760 if (transfer->cancel && !transfer->skip_file) | |
761 break; | |
762 transfer->cancel = 0; | |
42 | 763 transfer->fromreq->cancel = 0; |
764 transfer->toreq->cancel = 0; | |
1 | 765 } |
766 transfer->done = 1; | |
767 return (NULL); | |
768 } | |
769 | |
770 | |
303 | 771 gftp_transfer * |
1 | 772 add_file_transfer (gftp_request * fromreq, gftp_request * toreq, |
773 gftp_window_data * fromwdata, gftp_window_data * towdata, | |
774 GList * files, int copy_req) | |
775 { | |
305 | 776 int dialog, append_transfers, one_transfer; |
1 | 777 gftp_curtrans_data * transdata; |
778 GList * templist, *curfle; | |
779 gftp_transfer * tdata; | |
780 gftp_file * tempfle; | |
781 char *pos, *text[2]; | |
782 | |
783 for (templist = files; templist != NULL; templist = templist->next) | |
784 { | |
785 tempfle = templist->data; | |
786 if (tempfle->startsize > 0) | |
787 break; | |
788 } | |
789 dialog = templist != NULL; | |
790 | |
143 | 791 gftp_lookup_request_option (fromreq, "append_transfers", |
792 &append_transfers); | |
305 | 793 gftp_lookup_request_option (fromreq, "one_transfer", |
794 &one_transfer); | |
129 | 795 |
303 | 796 tdata = NULL; |
305 | 797 if (append_transfers && one_transfer) |
1 | 798 { |
799 pthread_mutex_lock (&transfer_mutex); | |
129 | 800 for (templist = gftp_file_transfers; templist != NULL; templist = templist->next) |
1 | 801 { |
802 tdata = templist->data; | |
129 | 803 g_static_mutex_lock (&tdata->structmutex); |
1 | 804 if (compare_request (tdata->fromreq, fromreq, 0) && |
805 compare_request (tdata->toreq, toreq, 0) && | |
806 tdata->curfle != NULL) | |
807 { | |
808 if (!copy_req) | |
809 { | |
67 | 810 gftp_request_destroy (fromreq, 1); |
811 gftp_request_destroy (toreq, 1); | |
1 | 812 } |
813 fromreq = NULL; | |
814 toreq = NULL; | |
815 | |
816 for (curfle = tdata->curfle; | |
817 curfle != NULL && curfle->next != NULL; | |
818 curfle = curfle->next); | |
819 if (curfle == NULL) | |
820 { | |
821 curfle = files; | |
822 files->prev = NULL; | |
823 } | |
824 else | |
825 { | |
826 curfle->next = files; | |
827 files->prev = curfle; | |
828 } | |
829 | |
830 for (curfle = files; curfle != NULL; curfle = curfle->next) | |
831 { | |
832 tempfle = curfle->data; | |
833 if (tempfle->isdir) | |
834 tdata->numdirs++; | |
835 else | |
836 tdata->numfiles++; | |
837 if ((pos = strrchr (tempfle->file, '/')) == NULL) | |
838 pos = tempfle->file; | |
839 else | |
840 pos++; | |
841 | |
842 text[0] = pos; | |
843 if (tempfle->transfer_action == GFTP_TRANS_ACTION_SKIP) | |
844 text[1] = _("Skipped"); | |
845 else | |
846 { | |
847 tdata->total_bytes += tempfle->size; | |
848 text[1] = _("Waiting..."); | |
849 } | |
850 | |
129 | 851 tempfle->user_data = gtk_ctree_insert_node (GTK_CTREE (dlwdw), |
852 tdata->user_data, NULL, text, 5, | |
853 NULL, NULL, NULL, NULL, | |
854 FALSE, FALSE); | |
1 | 855 transdata = g_malloc (sizeof (*transdata)); |
856 transdata->transfer = tdata; | |
857 transdata->curfle = curfle; | |
129 | 858 gtk_ctree_node_set_row_data (GTK_CTREE (dlwdw), tempfle->user_data, |
1 | 859 transdata); |
860 } | |
129 | 861 g_static_mutex_unlock (&tdata->structmutex); |
1 | 862 break; |
863 } | |
129 | 864 g_static_mutex_unlock (&tdata->structmutex); |
1 | 865 } |
866 pthread_mutex_unlock (&transfer_mutex); | |
867 } | |
868 else | |
869 templist = NULL; | |
870 | |
871 if (templist == NULL) | |
872 { | |
129 | 873 tdata = gftp_tdata_new (); |
1 | 874 if (copy_req) |
875 { | |
151 | 876 tdata->fromreq = copy_request (fromreq, 0); |
877 tdata->toreq = copy_request (toreq, 0); | |
1 | 878 } |
879 else | |
880 { | |
881 tdata->fromreq = fromreq; | |
882 tdata->toreq = toreq; | |
883 } | |
305 | 884 |
1 | 885 tdata->fromwdata = fromwdata; |
886 tdata->towdata = towdata; | |
887 if (!dialog) | |
888 tdata->show = tdata->ready = 1; | |
889 tdata->files = files; | |
890 for (curfle = files; curfle != NULL; curfle = curfle->next) | |
891 { | |
892 tempfle = curfle->data; | |
893 if (tempfle->isdir) | |
894 tdata->numdirs++; | |
895 else | |
896 tdata->numfiles++; | |
897 } | |
129 | 898 |
1 | 899 pthread_mutex_lock (&transfer_mutex); |
129 | 900 gftp_file_transfers = g_list_append (gftp_file_transfers, tdata); |
1 | 901 pthread_mutex_unlock (&transfer_mutex); |
129 | 902 |
1 | 903 if (dialog) |
904 gftp_gtk_ask_transfer (tdata); | |
905 } | |
303 | 906 |
907 return (tdata); | |
1 | 908 } |
909 | |
910 | |
48 | 911 static void |
912 remove_file (char *filename) | |
913 { | |
914 if (unlink (filename) == 0) | |
915 ftp_log (gftp_logging_misc, NULL, _("Successfully removed %s\n"), | |
916 filename); | |
917 else | |
918 ftp_log (gftp_logging_error, NULL, | |
919 _("Error: Could not remove file %s: %s\n"), filename, | |
920 g_strerror (errno)); | |
921 } | |
922 | |
923 | |
924 static void | |
925 free_edit_data (gftp_viewedit_data * ve_proc) | |
926 { | |
927 int i; | |
928 | |
294 | 929 if (ve_proc->torequest) |
930 gftp_request_destroy (ve_proc->torequest, 1); | |
48 | 931 if (ve_proc->filename) |
932 g_free (ve_proc->filename); | |
933 if (ve_proc->remote_filename) | |
934 g_free (ve_proc->remote_filename); | |
935 for (i = 0; ve_proc->argv[i] != NULL; i++) | |
936 g_free (ve_proc->argv[i]); | |
937 g_free (ve_proc->argv); | |
938 g_free (ve_proc); | |
939 } | |
940 | |
941 | |
942 static void | |
943 dont_upload (gftp_viewedit_data * ve_proc, gftp_dialog_data * ddata) | |
1 | 944 { |
48 | 945 remove_file (ve_proc->filename); |
946 free_edit_data (ve_proc); | |
947 } | |
948 | |
949 | |
950 static void | |
951 do_upload (gftp_viewedit_data * ve_proc, gftp_dialog_data * ddata) | |
952 { | |
303 | 953 gftp_transfer * tdata; |
48 | 954 gftp_file * tempfle; |
955 GList * newfile; | |
1 | 956 |
48 | 957 tempfle = g_malloc0 (sizeof (*tempfle)); |
294 | 958 tempfle->destfile = gftp_build_path (ve_proc->torequest->directory, |
959 ve_proc->remote_filename, NULL); | |
48 | 960 ve_proc->remote_filename = NULL; |
961 tempfle->file = ve_proc->filename; | |
962 ve_proc->filename = NULL; | |
963 tempfle->done_rm = 1; | |
964 newfile = g_list_append (NULL, tempfle); | |
303 | 965 tdata = add_file_transfer (ve_proc->fromwdata->request, ve_proc->torequest, |
966 ve_proc->fromwdata, ve_proc->towdata, newfile, 1); | |
48 | 967 free_edit_data (ve_proc); |
303 | 968 |
969 if (tdata != NULL) | |
970 tdata->conn_error_no_timeout = 1; | |
48 | 971 } |
972 | |
1 | 973 |
48 | 974 static void |
975 check_done_process (void) | |
976 { | |
977 gftp_viewedit_data * ve_proc; | |
978 GList * curdata, *deldata; | |
979 struct stat st; | |
980 int ret; | |
981 char *str; | |
982 pid_t pid; | |
983 | |
984 viewedit_process_done = 0; | |
985 while ((pid = waitpid (-1, &ret, WNOHANG)) > 0) | |
1 | 986 { |
48 | 987 curdata = viewedit_processes; |
988 while (curdata != NULL) | |
989 { | |
990 ve_proc = curdata->data; | |
991 deldata = curdata; | |
992 curdata = curdata->next; | |
993 if (ve_proc->pid == pid) | |
994 { | |
995 viewedit_processes = g_list_remove_link (viewedit_processes, | |
996 deldata); | |
997 if (ret != 0) | |
998 ftp_log (gftp_logging_error, NULL, | |
999 _("Error: Child %d returned %d\n"), pid, ret); | |
1000 else | |
1001 ftp_log (gftp_logging_misc, NULL, | |
1002 _("Child %d returned successfully\n"), pid); | |
1003 | |
1004 if (!ve_proc->view && !ve_proc->dontupload) | |
1005 { | |
1006 /* We was editing the file. Upload it */ | |
1007 if (stat (ve_proc->filename, &st) == -1) | |
1008 ftp_log (gftp_logging_error, NULL, | |
1009 _("Error: Cannot get information about file %s: %s\n"), | |
1010 ve_proc->filename, g_strerror (errno)); | |
1011 else if (st.st_mtime == ve_proc->st.st_mtime) | |
1012 { | |
1013 ftp_log (gftp_logging_misc, NULL, | |
1014 _("File %s was not changed\n"), | |
1015 ve_proc->filename); | |
1016 remove_file (ve_proc->filename); | |
1017 } | |
1018 else | |
1019 { | |
1020 memcpy (&ve_proc->st, &st, sizeof (ve_proc->st)); | |
1021 str = g_strdup_printf ( | |
1022 _("File %s has changed.\nWould you like to upload it?"), | |
1023 ve_proc->remote_filename); | |
1024 | |
1025 MakeYesNoDialog (_("Edit File"), str, | |
1026 do_upload, ve_proc, | |
1027 dont_upload, ve_proc); | |
1028 g_free (str); | |
1029 continue; | |
1030 } | |
1031 } | |
1032 | |
1033 free_edit_data (ve_proc); | |
1034 continue; | |
1035 } | |
1 | 1036 } |
1037 } | |
1038 } | |
1039 | |
1040 | |
1041 static void | |
1042 on_next_transfer (gftp_transfer * tdata) | |
1043 { | |
129 | 1044 int fd, refresh_files; |
1 | 1045 gftp_file * tempfle; |
1046 | |
1047 tdata->next_file = 0; | |
1048 for (; tdata->updfle != tdata->curfle; tdata->updfle = tdata->updfle->next) | |
1049 { | |
1050 tempfle = tdata->updfle->data; | |
1051 | |
1052 if (tempfle->is_fd) | |
58 | 1053 fd = tempfle->fd; |
1 | 1054 else |
1055 fd = 0; | |
1056 | |
1057 if (tempfle->done_view) | |
1058 { | |
1059 if (tempfle->transfer_action != GFTP_TRANS_ACTION_SKIP) | |
1060 view_file (tempfle->destfile, fd, 1, tempfle->done_rm, 1, 0, | |
1061 tempfle->file, NULL); | |
1062 | |
1063 if (tempfle->is_fd) | |
1064 { | |
58 | 1065 close (tempfle->fd); |
1066 tempfle->fd = -1; | |
1 | 1067 } |
1068 } | |
1069 else if (tempfle->done_edit) | |
1070 { | |
1071 if (tempfle->transfer_action != GFTP_TRANS_ACTION_SKIP) | |
1072 view_file (tempfle->destfile, fd, 0, tempfle->done_rm, 1, 0, | |
1073 tempfle->file, NULL); | |
1074 | |
1075 if (tempfle->is_fd) | |
1076 { | |
58 | 1077 close (tempfle->fd); |
1078 tempfle->fd = -1; | |
1 | 1079 } |
1080 } | |
1081 else if (tempfle->done_rm) | |
1082 tdata->fromreq->rmfile (tdata->fromreq, tempfle->file); | |
1083 | |
1084 if (tempfle->transfer_action == GFTP_TRANS_ACTION_SKIP) | |
129 | 1085 gtk_ctree_node_set_text (GTK_CTREE (dlwdw), tempfle->user_data, 1, |
1 | 1086 _("Skipped")); |
1087 else | |
129 | 1088 gtk_ctree_node_set_text (GTK_CTREE (dlwdw), tempfle->user_data, 1, |
1 | 1089 _("Finished")); |
1090 } | |
1091 | |
129 | 1092 gftp_lookup_request_option (tdata->fromreq, "refresh_files", &refresh_files); |
1093 | |
1 | 1094 if (refresh_files && tdata->curfle && tdata->curfle->next && |
1095 compare_request (tdata->toreq, | |
1096 ((gftp_window_data *) tdata->towdata)->request, 1)) | |
1097 refresh (tdata->towdata); | |
1098 } | |
1099 | |
1100 | |
1101 static void | |
19 | 1102 get_trans_password (gftp_request * request, gftp_dialog_data * ddata) |
1103 { | |
1104 gftp_set_password (request, gtk_entry_get_text (GTK_ENTRY (ddata->edit))); | |
1105 request->stopable = 0; | |
1106 } | |
1107 | |
1108 | |
1109 static void | |
1110 cancel_get_trans_password (gftp_transfer * tdata, gftp_dialog_data * ddata) | |
1111 { | |
1112 if (tdata->fromreq->stopable == 0) | |
1113 return; | |
1114 | |
129 | 1115 g_static_mutex_lock (&tdata->structmutex); |
19 | 1116 if (tdata->started) |
42 | 1117 { |
1118 tdata->cancel = 1; | |
1119 tdata->fromreq->cancel = 1; | |
1120 tdata->toreq->cancel = 1; | |
1121 } | |
19 | 1122 else |
1123 tdata->done = 1; | |
1124 | |
1125 tdata->fromreq->stopable = 0; | |
1126 tdata->toreq->stopable = 0; | |
129 | 1127 g_static_mutex_unlock (&tdata->structmutex); |
40 | 1128 |
19 | 1129 ftp_log (gftp_logging_misc, NULL, _("Stopping the transfer of %s\n"), |
1130 ((gftp_file *) tdata->curfle->data)->file); | |
1131 } | |
1132 | |
1133 | |
1134 static void | |
1 | 1135 show_transfer (gftp_transfer * tdata) |
1136 { | |
1137 GdkPixmap * closedir_pixmap, * opendir_pixmap; | |
1138 GdkBitmap * closedir_bitmap, * opendir_bitmap; | |
1139 gftp_curtrans_data * transdata; | |
1140 gftp_file * tempfle; | |
1141 char *pos, *text[2]; | |
1142 GList * templist; | |
1143 | |
1144 gftp_get_pixmap (dlwdw, "open_dir.xpm", &opendir_pixmap, &opendir_bitmap); | |
1145 gftp_get_pixmap (dlwdw, "dir.xpm", &closedir_pixmap, &closedir_bitmap); | |
1146 | |
129 | 1147 text[0] = tdata->fromreq->hostname; |
1 | 1148 text[1] = _("Waiting..."); |
129 | 1149 tdata->user_data = gtk_ctree_insert_node (GTK_CTREE (dlwdw), NULL, NULL, |
1150 text, 5, | |
1 | 1151 closedir_pixmap, closedir_bitmap, |
1152 opendir_pixmap, opendir_bitmap, | |
1153 FALSE, | |
1154 tdata->numdirs + tdata->numfiles < 50); | |
1155 transdata = g_malloc (sizeof (*transdata)); | |
1156 transdata->transfer = tdata; | |
1157 transdata->curfle = NULL; | |
129 | 1158 gtk_ctree_node_set_row_data (GTK_CTREE (dlwdw), tdata->user_data, transdata); |
1 | 1159 tdata->show = 0; |
1160 tdata->curfle = tdata->updfle = tdata->files; | |
1161 | |
1162 tdata->total_bytes = 0; | |
1163 for (templist = tdata->files; templist != NULL; templist = templist->next) | |
1164 { | |
1165 tempfle = templist->data; | |
1166 if ((pos = strrchr (tempfle->file, '/')) == NULL) | |
1167 pos = tempfle->file; | |
1168 else | |
1169 pos++; | |
1170 text[0] = pos; | |
1171 if (tempfle->transfer_action == GFTP_TRANS_ACTION_SKIP) | |
1172 text[1] = _("Skipped"); | |
1173 else | |
1174 { | |
1175 tdata->total_bytes += tempfle->size; | |
1176 text[1] = _("Waiting..."); | |
1177 } | |
1178 | |
129 | 1179 tempfle->user_data = gtk_ctree_insert_node (GTK_CTREE (dlwdw), |
1180 tdata->user_data, | |
1 | 1181 NULL, text, 5, NULL, NULL, NULL, |
1182 NULL, FALSE, FALSE); | |
1183 transdata = g_malloc (sizeof (*transdata)); | |
1184 transdata->transfer = tdata; | |
1185 transdata->curfle = templist; | |
129 | 1186 gtk_ctree_node_set_row_data (GTK_CTREE (dlwdw), tempfle->user_data, |
1187 transdata); | |
1 | 1188 } |
1189 | |
1190 if (!tdata->toreq->stopable && tdata->toreq->need_userpass && | |
1191 (tdata->toreq->password == NULL || *tdata->toreq->password == '\0')) | |
1192 { | |
1193 tdata->toreq->stopable = 1; | |
1194 MakeEditDialog (_("Enter Password"), | |
1195 _("Please enter your password for this site"), NULL, 0, | |
19 | 1196 NULL, gftp_dialog_button_connect, |
1197 get_trans_password, tdata->toreq, | |
1198 cancel_get_trans_password, tdata); | |
1 | 1199 } |
1200 | |
1201 if (!tdata->fromreq->stopable && tdata->fromreq->need_userpass && | |
1202 (tdata->fromreq->password == NULL || *tdata->fromreq->password == '\0')) | |
1203 { | |
1204 tdata->fromreq->stopable = 1; | |
1205 MakeEditDialog (_("Enter Password"), | |
1206 _("Please enter your password for this site"), NULL, 0, | |
19 | 1207 NULL, gftp_dialog_button_connect, |
1208 get_trans_password, tdata->fromreq, | |
1209 cancel_get_trans_password, tdata); | |
1 | 1210 } |
1211 } | |
1212 | |
1213 | |
1214 static void | |
1215 transfer_done (GList * node) | |
1216 { | |
1217 gftp_curtrans_data * transdata; | |
1218 gftp_request * fromreq; | |
1219 gftp_transfer * tdata; | |
1220 gftp_file * tempfle; | |
1221 GList * templist; | |
1222 | |
1223 tdata = node->data; | |
1224 if (tdata->started) | |
1225 { | |
56 | 1226 fromreq = tdata->fromwdata != NULL ? ((gftp_window_data *) tdata->fromwdata)->request : NULL; |
297 | 1227 |
1228 if (GFTP_IS_SAME_HOST_STOP_TRANS ((gftp_window_data *) tdata->fromwdata, | |
1229 tdata->fromreq)) | |
309 | 1230 { |
1231 gftp_copy_param_options (((gftp_window_data *) tdata->fromwdata)->request, tdata->fromreq); | |
1232 | |
1233 gftp_swap_socks (((gftp_window_data *) tdata->fromwdata)->request, | |
1234 tdata->fromreq); | |
1235 } | |
1 | 1236 else |
297 | 1237 gftp_disconnect (tdata->fromreq); |
1238 | |
1239 if (GFTP_IS_SAME_HOST_STOP_TRANS ((gftp_window_data *) tdata->towdata, | |
1240 tdata->toreq)) | |
309 | 1241 { |
1242 gftp_copy_param_options (((gftp_window_data *) tdata->towdata)->request, tdata->toreq); | |
1243 | |
1244 gftp_swap_socks (((gftp_window_data *) tdata->towdata)->request, | |
1245 tdata->toreq); | |
1246 } | |
297 | 1247 else |
1248 gftp_disconnect (tdata->toreq); | |
1 | 1249 |
305 | 1250 if (tdata->towdata != NULL && compare_request (tdata->toreq, |
1251 ((gftp_window_data *) tdata->towdata)->request, 1)) | |
1252 refresh (tdata->towdata); | |
1253 | |
129 | 1254 num_transfers_in_progress--; |
1 | 1255 } |
1256 | |
2
a171df6764a7
* Fixed crash if you was already transfering a file, and you started another
masneyb
parents:
1
diff
changeset
|
1257 if (!tdata->show && tdata->started) |
1 | 1258 { |
129 | 1259 transdata = gtk_ctree_node_get_row_data (GTK_CTREE (dlwdw), |
1260 tdata->user_data); | |
1 | 1261 if (transdata != NULL) |
1262 g_free (transdata); | |
1263 | |
1264 for (templist = tdata->files; templist != NULL; templist = templist->next) | |
1265 { | |
1266 tempfle = templist->data; | |
129 | 1267 transdata = gtk_ctree_node_get_row_data (GTK_CTREE (dlwdw), |
1268 tempfle->user_data); | |
1 | 1269 if (transdata != NULL) |
1270 g_free (transdata); | |
1271 } | |
1272 | |
129 | 1273 gtk_ctree_remove_node (GTK_CTREE (dlwdw), tdata->user_data); |
1 | 1274 } |
129 | 1275 |
1 | 1276 pthread_mutex_lock (&transfer_mutex); |
129 | 1277 gftp_file_transfers = g_list_remove_link (gftp_file_transfers, node); |
1 | 1278 pthread_mutex_unlock (&transfer_mutex); |
129 | 1279 |
1 | 1280 free_tdata (tdata); |
1281 } | |
1282 | |
1283 | |
1284 static void | |
1285 create_transfer (gftp_transfer * tdata) | |
1286 { | |
1287 pthread_t tid; | |
1288 | |
1289 if (!tdata->fromreq->stopable) | |
1290 { | |
297 | 1291 if (GFTP_IS_SAME_HOST_START_TRANS ((gftp_window_data *) tdata->fromwdata, |
1292 tdata->fromreq)) | |
1293 { | |
1294 gftp_swap_socks (tdata->fromreq, | |
1295 ((gftp_window_data *) tdata->fromwdata)->request); | |
1296 update_window (tdata->fromwdata); | |
1297 } | |
1298 | |
1299 if (GFTP_IS_SAME_HOST_START_TRANS ((gftp_window_data *) tdata->towdata, | |
1300 tdata->toreq)) | |
1301 { | |
63 | 1302 gftp_swap_socks (tdata->toreq, |
1303 ((gftp_window_data *) tdata->towdata)->request); | |
297 | 1304 update_window (tdata->towdata); |
1 | 1305 } |
297 | 1306 |
129 | 1307 num_transfers_in_progress++; |
1 | 1308 tdata->started = 1; |
1309 tdata->stalled = 1; | |
129 | 1310 gtk_ctree_node_set_text (GTK_CTREE (dlwdw), tdata->user_data, 1, |
1 | 1311 _("Connecting...")); |
1312 pthread_create (&tid, NULL, gftp_gtk_transfer_files, tdata); | |
1313 } | |
1314 } | |
1315 | |
1316 | |
1317 static void | |
1318 update_file_status (gftp_transfer * tdata) | |
1319 { | |
1320 char totstr[100], dlstr[100], gotstr[50], ofstr[50]; | |
1321 int hours, mins, secs, pcent, st; | |
246 | 1322 unsigned long remaining_secs, lkbs; |
1 | 1323 gftp_file * tempfle; |
1324 struct timeval tv; | |
1325 | |
129 | 1326 g_static_mutex_lock (&tdata->statmutex); |
1 | 1327 tempfle = tdata->curfle->data; |
1328 | |
1329 gettimeofday (&tv, NULL); | |
220 | 1330 |
1331 remaining_secs = (tdata->total_bytes - tdata->trans_bytes - tdata->resumed_bytes) / 1024; | |
246 | 1332 |
1333 lkbs = (unsigned long) tdata->kbs; | |
1334 if (lkbs > 0) | |
1335 remaining_secs /= lkbs; | |
1 | 1336 |
220 | 1337 hours = remaining_secs / 3600; |
1338 remaining_secs -= hours * 3600; | |
1339 mins = remaining_secs / 60; | |
1340 remaining_secs -= mins * 60; | |
1341 secs = remaining_secs; | |
1 | 1342 |
1343 if (hours < 0 || mins < 0 || secs < 0) | |
1344 { | |
129 | 1345 g_static_mutex_unlock (&tdata->statmutex); |
1 | 1346 return; |
1347 } | |
1348 | |
246 | 1349 if ((double) tdata->total_bytes > 0) |
1350 pcent = (int) ((double) (tdata->trans_bytes + tdata->resumed_bytes) / (double) tdata->total_bytes * 100.0); | |
1351 else | |
1 | 1352 pcent = 0; |
1353 | |
1354 g_snprintf (totstr, sizeof (totstr), | |
14
83090328581e
* More largefile support. Hopefully all that is left is the configure stuff
masneyb
parents:
7
diff
changeset
|
1355 _("%d%% complete, %02d:%02d:%02d est. time remaining. (File %ld of %ld)"), |
1 | 1356 pcent, hours, mins, secs, tdata->current_file_number, |
1357 tdata->numdirs + tdata->numfiles); | |
1358 | |
1359 *dlstr = '\0'; | |
1360 if (!tdata->stalled) | |
1361 { | |
1362 insert_commas (tdata->curtrans + tdata->curresumed, gotstr, sizeof (gotstr)); | |
1363 insert_commas (tempfle->size, ofstr, sizeof (ofstr)); | |
1364 st = 1; | |
1365 if (tv.tv_sec - tdata->lasttime.tv_sec <= 5) | |
1366 { | |
1367 if (tdata->curfle->next != NULL) | |
1368 { | |
220 | 1369 remaining_secs = (tempfle->size - tdata->curtrans - tdata->curresumed) / 1024; |
246 | 1370 |
1371 lkbs = (unsigned long) tdata->kbs; | |
1372 if (lkbs > 0) | |
1373 remaining_secs /= lkbs; | |
220 | 1374 |
1375 hours = remaining_secs / 3600; | |
1376 remaining_secs -= hours * 3600; | |
1377 mins = remaining_secs / 60; | |
1378 remaining_secs -= mins * 60; | |
1379 secs = remaining_secs; | |
1 | 1380 } |
1381 | |
1382 if (!(hours < 0 || mins < 0 || secs < 0)) | |
1383 { | |
1384 g_snprintf (dlstr, sizeof (dlstr), | |
1385 _("Recv %s of %s at %.2fKB/s, %02d:%02d:%02d est. time remaining"), gotstr, ofstr, tdata->kbs, hours, mins, secs); | |
1386 st = 0; | |
1387 } | |
1388 } | |
1389 | |
1390 if (st) | |
1391 { | |
1392 tdata->stalled = 1; | |
1393 g_snprintf (dlstr, sizeof (dlstr), | |
1394 _("Recv %s of %s, transfer stalled, unknown time remaining"), | |
1395 gotstr, ofstr); | |
1396 } | |
1397 } | |
1398 | |
129 | 1399 g_static_mutex_unlock (&tdata->statmutex); |
1 | 1400 |
129 | 1401 gtk_ctree_node_set_text (GTK_CTREE (dlwdw), tdata->user_data, 1, totstr); |
1 | 1402 |
1403 if (*dlstr != '\0') | |
129 | 1404 gtk_ctree_node_set_text (GTK_CTREE (dlwdw), tempfle->user_data, 1, dlstr); |
1 | 1405 } |
1406 | |
56 | 1407 static void |
1408 update_window_transfer_bytes (gftp_window_data * wdata) | |
1409 { | |
1410 char *tempstr, *temp1str; | |
1411 | |
1412 if (wdata->request->gotbytes == -1) | |
1413 { | |
1414 update_window_info (); | |
1415 wdata->request->gotbytes = 0; | |
1416 } | |
1417 else | |
1418 { | |
1419 tempstr = insert_commas (wdata->request->gotbytes, NULL, 0); | |
1420 temp1str = g_strdup_printf (_("Retrieving file names...%s bytes"), | |
1421 tempstr); | |
1422 gtk_label_set (GTK_LABEL (wdata->hoststxt), temp1str); | |
1423 g_free (tempstr); | |
1424 g_free (temp1str); | |
1425 } | |
1426 } | |
1427 | |
1 | 1428 |
48 | 1429 gint |
1430 update_downloads (gpointer data) | |
1431 { | |
207 | 1432 int do_one_transfer_at_a_time; |
48 | 1433 GList * templist, * next; |
1434 gftp_transfer * tdata; | |
1435 | |
129 | 1436 if (gftp_file_transfer_logs != NULL) |
48 | 1437 display_cached_logs (); |
1438 | |
56 | 1439 if (window1.request->gotbytes != 0) |
1440 update_window_transfer_bytes (&window1); | |
48 | 1441 if (window2.request->gotbytes != 0) |
56 | 1442 update_window_transfer_bytes (&window2); |
48 | 1443 |
1444 if (viewedit_process_done) | |
1445 check_done_process (); | |
1446 | |
129 | 1447 for (templist = gftp_file_transfers; templist != NULL;) |
48 | 1448 { |
1449 tdata = templist->data; | |
1450 if (tdata->ready) | |
1451 { | |
129 | 1452 g_static_mutex_lock (&tdata->structmutex); |
48 | 1453 |
1454 if (tdata->next_file) | |
1455 on_next_transfer (tdata); | |
1456 else if (tdata->show) | |
1457 show_transfer (tdata); | |
1458 else if (tdata->done) | |
1459 { | |
1460 next = templist->next; | |
129 | 1461 g_static_mutex_unlock (&tdata->structmutex); |
48 | 1462 transfer_done (templist); |
1463 templist = next; | |
1464 continue; | |
1465 } | |
1466 | |
1467 if (tdata->curfle != NULL) | |
1468 { | |
151 | 1469 gftp_lookup_global_option ("one_transfer", |
129 | 1470 &do_one_transfer_at_a_time); |
1471 | |
207 | 1472 if (!tdata->started && |
129 | 1473 (num_transfers_in_progress == 0 || !do_one_transfer_at_a_time)) |
48 | 1474 create_transfer (tdata); |
1475 | |
1476 if (tdata->started) | |
1477 update_file_status (tdata); | |
1478 } | |
129 | 1479 g_static_mutex_unlock (&tdata->structmutex); |
48 | 1480 } |
1481 templist = templist->next; | |
1482 } | |
1483 | |
1484 gtk_timeout_add (500, update_downloads, NULL); | |
1485 return (0); | |
1486 } | |
1487 | |
1488 | |
1 | 1489 void |
1490 start_transfer (gpointer data) | |
1491 { | |
1492 gftp_curtrans_data * transdata; | |
1493 GtkCTreeNode * node; | |
1494 | |
1495 if (GTK_CLIST (dlwdw)->selection == NULL) | |
1496 { | |
1497 ftp_log (gftp_logging_misc, NULL, | |
1498 _("There are no file transfers selected\n")); | |
1499 return; | |
1500 } | |
1501 node = GTK_CLIST (dlwdw)->selection->data; | |
1502 transdata = gtk_ctree_node_get_row_data (GTK_CTREE (dlwdw), node); | |
1503 | |
129 | 1504 g_static_mutex_lock (&transdata->transfer->structmutex); |
1 | 1505 if (!transdata->transfer->started) |
1506 create_transfer (transdata->transfer); | |
129 | 1507 g_static_mutex_unlock (&transdata->transfer->structmutex); |
1 | 1508 } |
1509 | |
1510 | |
1511 void | |
1512 stop_transfer (gpointer data) | |
1513 { | |
1514 gftp_curtrans_data * transdata; | |
1515 GtkCTreeNode * node; | |
1516 | |
1517 if (GTK_CLIST (dlwdw)->selection == NULL) | |
1518 { | |
1519 ftp_log (gftp_logging_misc, NULL, | |
1520 _("There are no file transfers selected\n")); | |
1521 return; | |
1522 } | |
1523 node = GTK_CLIST (dlwdw)->selection->data; | |
1524 transdata = gtk_ctree_node_get_row_data (GTK_CTREE (dlwdw), node); | |
1525 | |
129 | 1526 g_static_mutex_lock (&transdata->transfer->structmutex); |
1 | 1527 if (transdata->transfer->started) |
1528 { | |
1529 transdata->transfer->cancel = 1; | |
42 | 1530 transdata->transfer->fromreq->cancel = 1; |
1531 transdata->transfer->toreq->cancel = 1; | |
1 | 1532 transdata->transfer->skip_file = 0; |
1533 } | |
1534 else | |
1535 transdata->transfer->done = 1; | |
129 | 1536 g_static_mutex_unlock (&transdata->transfer->structmutex); |
40 | 1537 |
1 | 1538 ftp_log (gftp_logging_misc, NULL, _("Stopping the transfer on host %s\n"), |
1539 transdata->transfer->fromreq->hostname); | |
1540 } | |
1541 | |
1542 | |
1543 void | |
1544 skip_transfer (gpointer data) | |
1545 { | |
1546 gftp_curtrans_data * transdata; | |
1547 GtkCTreeNode * node; | |
1548 gftp_file * curfle; | |
40 | 1549 char *file; |
1 | 1550 |
1551 if (GTK_CLIST (dlwdw)->selection == NULL) | |
1552 { | |
1553 ftp_log (gftp_logging_misc, NULL, | |
1554 _("There are no file transfers selected\n")); | |
1555 return; | |
1556 } | |
1557 node = GTK_CLIST (dlwdw)->selection->data; | |
1558 transdata = gtk_ctree_node_get_row_data (GTK_CTREE (dlwdw), node); | |
1559 | |
129 | 1560 g_static_mutex_lock (&transdata->transfer->structmutex); |
1 | 1561 if (transdata->transfer->curfle != NULL) |
1562 { | |
1563 curfle = transdata->transfer->curfle->data; | |
1564 if (transdata->transfer->started) | |
1565 { | |
1566 transdata->transfer->cancel = 1; | |
42 | 1567 transdata->transfer->fromreq->cancel = 1; |
1568 transdata->transfer->toreq->cancel = 1; | |
1 | 1569 transdata->transfer->skip_file = 1; |
1570 } | |
1571 | |
1572 curfle->transfer_action = GFTP_TRANS_ACTION_SKIP; | |
40 | 1573 file = curfle->file; |
1 | 1574 } |
40 | 1575 else |
1576 file = NULL; | |
129 | 1577 g_static_mutex_unlock (&transdata->transfer->structmutex); |
40 | 1578 |
1579 ftp_log (gftp_logging_misc, NULL, _("Skipping file %s on host %s\n"), | |
1580 file, transdata->transfer->fromreq->hostname); | |
1 | 1581 } |
1582 | |
1583 | |
1584 void | |
1585 remove_file_transfer (gpointer data) | |
1586 { | |
1587 gftp_curtrans_data * transdata; | |
1588 GtkCTreeNode * node; | |
1589 gftp_file * curfle; | |
1590 | |
1591 if (GTK_CLIST (dlwdw)->selection == NULL) | |
1592 { | |
1593 ftp_log (gftp_logging_misc, NULL, | |
1594 _("There are no file transfers selected\n")); | |
1595 return; | |
1596 } | |
1597 | |
1598 node = GTK_CLIST (dlwdw)->selection->data; | |
1599 transdata = gtk_ctree_node_get_row_data (GTK_CTREE (dlwdw), node); | |
1600 | |
1601 | |
1602 if (transdata->curfle == NULL || transdata->curfle->data == NULL) | |
1603 return; | |
1604 | |
1605 curfle = transdata->curfle->data; | |
1606 | |
1607 if (curfle->transfer_action & GFTP_TRANS_ACTION_SKIP) | |
1608 return; | |
1609 | |
129 | 1610 g_static_mutex_lock (&transdata->transfer->structmutex); |
1 | 1611 |
1612 curfle->transfer_action = GFTP_TRANS_ACTION_SKIP; | |
1613 | |
1614 if (transdata->transfer->started && | |
1615 transdata->curfle == transdata->transfer->curfle) | |
1616 { | |
1617 transdata->transfer->cancel = 1; | |
42 | 1618 transdata->transfer->fromreq->cancel = 1; |
1619 transdata->transfer->toreq->cancel = 1; | |
1 | 1620 transdata->transfer->skip_file = 1; |
1621 } | |
1622 else if (transdata->curfle != transdata->transfer->curfle && | |
1623 !curfle->transfer_done) | |
1624 { | |
129 | 1625 gtk_ctree_node_set_text (GTK_CTREE (dlwdw), curfle->user_data, 1, |
1 | 1626 _("Skipped")); |
1627 transdata->transfer->total_bytes -= curfle->size; | |
1628 } | |
1629 | |
129 | 1630 g_static_mutex_unlock (&transdata->transfer->structmutex); |
40 | 1631 |
1 | 1632 ftp_log (gftp_logging_misc, NULL, _("Skipping file %s on host %s\n"), |
1633 curfle->file, transdata->transfer->fromreq->hostname); | |
1634 } | |
1635 | |
1636 | |
1637 void | |
1638 move_transfer_up (gpointer data) | |
1639 { | |
1640 GList * firstentry, * secentry, * lastentry; | |
1641 gftp_curtrans_data * transdata; | |
1642 GtkCTreeNode * node; | |
1643 | |
1644 if (GTK_CLIST (dlwdw)->selection == NULL) | |
1645 { | |
1646 ftp_log (gftp_logging_misc, NULL, | |
1647 _("There are no file transfers selected\n")); | |
1648 return; | |
1649 } | |
1650 node = GTK_CLIST (dlwdw)->selection->data; | |
1651 transdata = gtk_ctree_node_get_row_data (GTK_CTREE (dlwdw), node); | |
1652 | |
1653 if (transdata->curfle == NULL) | |
1654 return; | |
1655 | |
129 | 1656 g_static_mutex_lock (&transdata->transfer->structmutex); |
1 | 1657 if (transdata->curfle->prev != NULL && (!transdata->transfer->started || |
1658 (transdata->transfer->curfle != transdata->curfle && | |
1659 transdata->transfer->curfle != transdata->curfle->prev))) | |
1660 { | |
1661 if (transdata->curfle->prev->prev == NULL) | |
1662 { | |
1663 firstentry = transdata->curfle->prev; | |
1664 lastentry = transdata->curfle->next; | |
1665 transdata->transfer->files = transdata->curfle; | |
1666 transdata->curfle->next = firstentry; | |
1667 transdata->transfer->files->prev = NULL; | |
1668 firstentry->prev = transdata->curfle; | |
1669 firstentry->next = lastentry; | |
1670 if (lastentry != NULL) | |
1671 lastentry->prev = firstentry; | |
1672 } | |
1673 else | |
1674 { | |
1675 firstentry = transdata->curfle->prev->prev; | |
1676 secentry = transdata->curfle->prev; | |
1677 lastentry = transdata->curfle->next; | |
1678 firstentry->next = transdata->curfle; | |
1679 transdata->curfle->prev = firstentry; | |
1680 transdata->curfle->next = secentry; | |
1681 secentry->prev = transdata->curfle; | |
1682 secentry->next = lastentry; | |
1683 if (lastentry != NULL) | |
1684 lastentry->prev = secentry; | |
1685 } | |
1686 | |
1687 gtk_ctree_move (GTK_CTREE (dlwdw), | |
129 | 1688 ((gftp_file *) transdata->curfle->data)->user_data, |
1689 transdata->transfer->user_data, | |
1 | 1690 transdata->curfle->next != NULL ? |
129 | 1691 ((gftp_file *) transdata->curfle->next->data)->user_data: NULL); |
1 | 1692 } |
129 | 1693 g_static_mutex_unlock (&transdata->transfer->structmutex); |
1 | 1694 } |
1695 | |
1696 void | |
1697 move_transfer_down (gpointer data) | |
1698 { | |
1699 GList * firstentry, * secentry, * lastentry; | |
1700 gftp_curtrans_data * transdata; | |
1701 GtkCTreeNode * node; | |
1702 | |
1703 if (GTK_CLIST (dlwdw)->selection == NULL) | |
1704 { | |
1705 ftp_log (gftp_logging_misc, NULL, | |
1706 _("There are no file transfers selected\n")); | |
1707 return; | |
1708 } | |
1709 node = GTK_CLIST (dlwdw)->selection->data; | |
1710 transdata = gtk_ctree_node_get_row_data (GTK_CTREE (dlwdw), node); | |
1711 | |
1712 if (transdata->curfle == NULL) | |
1713 return; | |
1714 | |
129 | 1715 g_static_mutex_lock (&transdata->transfer->structmutex); |
1 | 1716 if (transdata->curfle->next != NULL && (!transdata->transfer->started || |
1717 (transdata->transfer->curfle != transdata->curfle && | |
1718 transdata->transfer->curfle != transdata->curfle->next))) | |
1719 { | |
1720 if (transdata->curfle->prev == NULL) | |
1721 { | |
1722 firstentry = transdata->curfle->next; | |
1723 lastentry = transdata->curfle->next->next; | |
1724 transdata->transfer->files = firstentry; | |
1725 transdata->transfer->files->prev = NULL; | |
1726 transdata->transfer->files->next = transdata->curfle; | |
1727 transdata->curfle->prev = transdata->transfer->files; | |
1728 transdata->curfle->next = lastentry; | |
1729 if (lastentry != NULL) | |
1730 lastentry->prev = transdata->curfle; | |
1731 } | |
1732 else | |
1733 { | |
1734 firstentry = transdata->curfle->prev; | |
1735 secentry = transdata->curfle->next; | |
1736 lastentry = transdata->curfle->next->next; | |
1737 firstentry->next = secentry; | |
1738 secentry->prev = firstentry; | |
1739 secentry->next = transdata->curfle; | |
1740 transdata->curfle->prev = secentry; | |
1741 transdata->curfle->next = lastentry; | |
1742 if (lastentry != NULL) | |
1743 lastentry->prev = transdata->curfle; | |
1744 } | |
1745 | |
1746 gtk_ctree_move (GTK_CTREE (dlwdw), | |
129 | 1747 ((gftp_file *) transdata->curfle->data)->user_data, |
1748 transdata->transfer->user_data, | |
1 | 1749 transdata->curfle->next != NULL ? |
129 | 1750 ((gftp_file *) transdata->curfle->next->data)->user_data: NULL); |
1 | 1751 } |
129 | 1752 g_static_mutex_unlock (&transdata->transfer->structmutex); |
1 | 1753 } |
1754 | |
1755 | |
48 | 1756 static void |
1757 trans_selectall (GtkWidget * widget, gpointer data) | |
1758 { | |
1759 gftp_transfer * tdata; | |
1760 tdata = data; | |
1761 | |
1762 gtk_clist_select_all (GTK_CLIST (tdata->clist)); | |
1763 } | |
1764 | |
1765 | |
1766 static void | |
1767 trans_unselectall (GtkWidget * widget, gpointer data) | |
1768 { | |
1769 gftp_transfer * tdata; | |
1770 tdata = data; | |
1771 | |
1772 gtk_clist_unselect_all (GTK_CLIST (tdata->clist)); | |
1773 } | |
1774 | |
1775 | |
1776 static void | |
1777 overwrite (GtkWidget * widget, gpointer data) | |
1778 { | |
1779 GList * templist, * filelist; | |
1780 gftp_transfer * tdata; | |
1781 gftp_file * tempfle; | |
1782 int curpos; | |
1783 | |
1784 tdata = data; | |
1785 curpos = 0; | |
1786 filelist = tdata->files; | |
1787 templist = GTK_CLIST (tdata->clist)->selection; | |
1788 while (templist != NULL) | |
1789 { | |
1790 templist = get_next_selection (templist, &filelist, &curpos); | |
1791 tempfle = filelist->data; | |
1792 tempfle->transfer_action = GFTP_TRANS_ACTION_OVERWRITE; | |
1793 gtk_clist_set_text (GTK_CLIST (tdata->clist), curpos, 3, _("Overwrite")); | |
1794 } | |
1795 } | |
1796 | |
1797 | |
1798 static void | |
1799 resume (GtkWidget * widget, gpointer data) | |
1800 { | |
1801 GList * templist, * filelist; | |
1802 gftp_transfer * tdata; | |
1803 gftp_file * tempfle; | |
1804 int curpos; | |
1805 | |
1806 tdata = data; | |
1807 curpos = 0; | |
1808 filelist = tdata->files; | |
1809 templist = GTK_CLIST (tdata->clist)->selection; | |
1810 while (templist != NULL) | |
1811 { | |
1812 templist = get_next_selection (templist, &filelist, &curpos); | |
1813 tempfle = filelist->data; | |
1814 tempfle->transfer_action = GFTP_TRANS_ACTION_RESUME; | |
1815 gtk_clist_set_text (GTK_CLIST (tdata->clist), curpos, 3, _("Resume")); | |
1816 } | |
1817 } | |
1818 | |
1819 | |
1820 static void | |
1821 skip (GtkWidget * widget, gpointer data) | |
1822 { | |
1823 GList * templist, * filelist; | |
1824 gftp_transfer * tdata; | |
1825 gftp_file * tempfle; | |
1826 int curpos; | |
1827 | |
1828 tdata = data; | |
1829 curpos = 0; | |
1830 filelist = tdata->files; | |
1831 templist = GTK_CLIST (tdata->clist)->selection; | |
1832 while (templist != NULL) | |
1833 { | |
1834 templist = get_next_selection (templist, &filelist, &curpos); | |
1835 tempfle = filelist->data; | |
1836 tempfle->transfer_action = GFTP_TRANS_ACTION_SKIP; | |
1837 gtk_clist_set_text (GTK_CLIST (tdata->clist), curpos, 3, _("Skip")); | |
1838 } | |
1839 } | |
1840 | |
1841 | |
1842 static void | |
1843 ok (GtkWidget * widget, gpointer data) | |
1844 { | |
1845 gftp_transfer * tdata; | |
1846 gftp_file * tempfle; | |
1847 GList * templist; | |
1848 | |
1849 tdata = data; | |
129 | 1850 g_static_mutex_lock (&tdata->structmutex); |
48 | 1851 for (templist = tdata->files; templist != NULL; templist = templist->next) |
1852 { | |
1853 tempfle = templist->data; | |
1854 if (tempfle->transfer_action != GFTP_TRANS_ACTION_SKIP) | |
1855 break; | |
1856 } | |
1857 | |
1858 if (templist == NULL) | |
1859 { | |
1860 tdata->show = 0; | |
1861 tdata->ready = tdata->done = 1; | |
1862 } | |
1863 else | |
1864 tdata->show = tdata->ready = 1; | |
129 | 1865 g_static_mutex_unlock (&tdata->structmutex); |
48 | 1866 } |
1867 | |
1868 | |
1869 static void | |
1870 cancel (GtkWidget * widget, gpointer data) | |
1871 { | |
1872 gftp_transfer * tdata; | |
1873 | |
1874 tdata = data; | |
129 | 1875 g_static_mutex_lock (&tdata->structmutex); |
48 | 1876 tdata->show = 0; |
1877 tdata->done = tdata->ready = 1; | |
129 | 1878 g_static_mutex_unlock (&tdata->structmutex); |
48 | 1879 } |
1880 | |
1881 | |
49 | 1882 #if GTK_MAJOR_VERSION > 1 |
1883 static void | |
1884 transfer_action (GtkWidget * widget, gint response, gpointer user_data) | |
1885 { | |
1886 switch (response) | |
1887 { | |
1888 case GTK_RESPONSE_OK: | |
1889 ok (widget, user_data); | |
1890 gtk_widget_destroy (widget); | |
1891 break; | |
1892 case GTK_RESPONSE_CANCEL: | |
1893 cancel (widget, user_data); | |
1894 /* no break */ | |
1895 default: | |
1896 gtk_widget_destroy (widget); | |
1897 } | |
1898 } | |
1899 #endif | |
1900 | |
1901 | |
1 | 1902 void |
1903 gftp_gtk_ask_transfer (gftp_transfer * tdata) | |
1904 { | |
1905 char *dltitles[4], *add_data[4] = { NULL, NULL, NULL, NULL }, | |
305 | 1906 tempstr[50], temp1str[50], *pos; |
1 | 1907 GtkWidget * tempwid, * scroll, * hbox; |
234 | 1908 int i, overwrite_default; |
1 | 1909 gftp_file * tempfle; |
1910 GList * templist; | |
1911 size_t len; | |
1912 | |
1913 dltitles[0] = _("Filename"); | |
305 | 1914 dltitles[1] = tdata->fromreq->hostname; |
1915 dltitles[2] = tdata->toreq->hostname; | |
1 | 1916 dltitles[3] = _("Action"); |
49 | 1917 |
1918 #if GTK_MAJOR_VERSION == 1 | |
1919 dialog = gtk_dialog_new (); | |
1 | 1920 gtk_grab_add (dialog); |
305 | 1921 gtk_window_set_title (GTK_WINDOW (dialog), _("Transfer Files")); |
49 | 1922 gtk_container_border_width (GTK_CONTAINER (GTK_DIALOG (dialog)->action_area), 5); |
1 | 1923 gtk_box_set_spacing (GTK_BOX (GTK_DIALOG (dialog)->action_area), 35); |
1924 gtk_box_set_homogeneous (GTK_BOX (GTK_DIALOG (dialog)->action_area), TRUE); | |
49 | 1925 |
1 | 1926 gtk_signal_connect_object (GTK_OBJECT (dialog), "delete_event", |
1927 GTK_SIGNAL_FUNC (gtk_widget_destroy), | |
1928 GTK_OBJECT (dialog)); | |
49 | 1929 #else |
305 | 1930 dialog = gtk_dialog_new_with_buttons (_("Transfer Files"), NULL, 0, |
49 | 1931 GTK_STOCK_OK, |
1932 GTK_RESPONSE_OK, | |
1933 GTK_STOCK_CANCEL, | |
1934 GTK_RESPONSE_CANCEL, | |
1935 NULL); | |
1936 #endif | |
1937 gtk_window_set_wmclass (GTK_WINDOW(dialog), "transfer", "gFTP"); | |
1938 gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE); | |
1939 gtk_container_border_width (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), 10); | |
1940 gtk_box_set_spacing (GTK_BOX (GTK_DIALOG (dialog)->vbox), 5); | |
1 | 1941 |
1942 tempwid = gtk_label_new (_("The following file(s) exist on both the local and remote computer\nPlease select what you would like to do")); | |
1943 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), tempwid, FALSE, | |
1944 FALSE, 0); | |
1945 gtk_widget_show (tempwid); | |
1946 | |
1947 scroll = gtk_scrolled_window_new (NULL, NULL); | |
1948 gtk_widget_set_size_request (scroll, 450, 200); | |
1949 | |
1950 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), | |
1951 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); | |
1952 tdata->clist = gtk_clist_new_with_titles (4, dltitles); | |
1953 gtk_container_add (GTK_CONTAINER (scroll), tdata->clist); | |
1954 | |
45 | 1955 #if GTK_MAJOR_VERSION == 1 |
1 | 1956 gtk_clist_set_selection_mode (GTK_CLIST (tdata->clist), |
1957 GTK_SELECTION_EXTENDED); | |
1958 #else | |
1959 gtk_clist_set_selection_mode (GTK_CLIST (tdata->clist), | |
1960 GTK_SELECTION_MULTIPLE); | |
1961 #endif | |
1962 gtk_clist_set_column_width (GTK_CLIST (tdata->clist), 0, 100); | |
1963 gtk_clist_set_column_justification (GTK_CLIST (tdata->clist), 1, | |
1964 GTK_JUSTIFY_RIGHT); | |
1965 gtk_clist_set_column_width (GTK_CLIST (tdata->clist), 1, 85); | |
1966 gtk_clist_set_column_justification (GTK_CLIST (tdata->clist), 2, | |
1967 GTK_JUSTIFY_RIGHT); | |
1968 gtk_clist_set_column_width (GTK_CLIST (tdata->clist), 2, 85); | |
1969 gtk_clist_set_column_width (GTK_CLIST (tdata->clist), 3, 85); | |
1970 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), scroll, TRUE, TRUE, | |
1971 0); | |
1972 gtk_widget_show (tdata->clist); | |
1973 gtk_widget_show (scroll); | |
1974 | |
234 | 1975 gftp_lookup_request_option (tdata->fromreq, "overwrite_default", |
1976 &overwrite_default); | |
129 | 1977 |
1 | 1978 for (templist = tdata->files; templist != NULL; |
1979 templist = templist->next) | |
1980 { | |
1981 tempfle = templist->data; | |
1982 if (tempfle->startsize == 0 || tempfle->isdir) | |
1983 { | |
1984 tempfle->shown = 0; | |
1985 continue; | |
1986 } | |
1987 tempfle->shown = 1; | |
1988 | |
1989 pos = tempfle->destfile; | |
129 | 1990 len = strlen (tdata->toreq->directory); |
1991 if (strncmp (pos, tdata->toreq->directory, len) == 0) | |
1 | 1992 pos = tempfle->destfile + len + 1; |
1993 add_data[0] = pos; | |
1994 | |
234 | 1995 if (overwrite_default) |
1 | 1996 add_data[3] = _("Overwrite"); |
1997 else | |
1998 { | |
1999 if (tempfle->startsize >= tempfle->size) | |
2000 { | |
2001 add_data[3] = _("Skip"); | |
2002 tempfle->transfer_action = GFTP_TRANS_ACTION_SKIP; | |
2003 } | |
2004 else | |
2005 { | |
2006 add_data[3] = _("Resume"); | |
2007 tempfle->transfer_action = GFTP_TRANS_ACTION_RESUME; | |
2008 } | |
2009 } | |
2010 | |
305 | 2011 add_data[1] = insert_commas (tempfle->size, tempstr, sizeof (tempstr)); |
2012 add_data[2] = insert_commas (tempfle->startsize, temp1str, | |
2013 sizeof (temp1str)); | |
2014 | |
1 | 2015 i = gtk_clist_append (GTK_CLIST (tdata->clist), add_data); |
2016 gtk_clist_set_row_data (GTK_CLIST (tdata->clist), i, tempfle); | |
2017 } | |
2018 | |
2019 gtk_clist_select_all (GTK_CLIST (tdata->clist)); | |
2020 | |
2021 hbox = gtk_hbox_new (TRUE, 20); | |
2022 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), hbox, TRUE, TRUE, 0); | |
2023 gtk_widget_show (hbox); | |
2024 | |
2025 tempwid = gtk_button_new_with_label (_("Overwrite")); | |
2026 gtk_box_pack_start (GTK_BOX (hbox), tempwid, TRUE, TRUE, 0); | |
2027 gtk_signal_connect (GTK_OBJECT (tempwid), "clicked", | |
2028 GTK_SIGNAL_FUNC (overwrite), (gpointer) tdata); | |
2029 gtk_widget_show (tempwid); | |
2030 | |
2031 tempwid = gtk_button_new_with_label (_("Resume")); | |
2032 gtk_box_pack_start (GTK_BOX (hbox), tempwid, TRUE, TRUE, 0); | |
2033 gtk_signal_connect (GTK_OBJECT (tempwid), "clicked", | |
2034 GTK_SIGNAL_FUNC (resume), (gpointer) tdata); | |
2035 gtk_widget_show (tempwid); | |
2036 | |
2037 tempwid = gtk_button_new_with_label (_("Skip File")); | |
2038 gtk_box_pack_start (GTK_BOX (hbox), tempwid, TRUE, TRUE, 0); | |
2039 gtk_signal_connect (GTK_OBJECT (tempwid), "clicked", GTK_SIGNAL_FUNC (skip), | |
2040 (gpointer) tdata); | |
2041 gtk_widget_show (tempwid); | |
2042 | |
2043 hbox = gtk_hbox_new (TRUE, 20); | |
2044 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), hbox, TRUE, TRUE, 0); | |
2045 gtk_widget_show (hbox); | |
2046 | |
2047 tempwid = gtk_button_new_with_label (_("Select All")); | |
2048 gtk_box_pack_start (GTK_BOX (hbox), tempwid, TRUE, TRUE, 0); | |
2049 gtk_signal_connect (GTK_OBJECT (tempwid), "clicked", | |
2050 GTK_SIGNAL_FUNC (trans_selectall), (gpointer) tdata); | |
2051 gtk_widget_show (tempwid); | |
2052 | |
2053 tempwid = gtk_button_new_with_label (_("Deselect All")); | |
2054 gtk_box_pack_start (GTK_BOX (hbox), tempwid, TRUE, TRUE, 0); | |
2055 gtk_signal_connect (GTK_OBJECT (tempwid), "clicked", | |
2056 GTK_SIGNAL_FUNC (trans_unselectall), (gpointer) tdata); | |
2057 gtk_widget_show (tempwid); | |
2058 | |
49 | 2059 #if GTK_MAJOR_VERSION == 1 |
1 | 2060 tempwid = gtk_button_new_with_label (_("OK")); |
2061 GTK_WIDGET_SET_FLAGS (tempwid, GTK_CAN_DEFAULT); | |
2062 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->action_area), tempwid, | |
2063 TRUE, TRUE, 0); | |
2064 gtk_signal_connect (GTK_OBJECT (tempwid), "clicked", GTK_SIGNAL_FUNC (ok), | |
2065 (gpointer) tdata); | |
2066 gtk_signal_connect_object (GTK_OBJECT (tempwid), "clicked", | |
2067 GTK_SIGNAL_FUNC (gtk_widget_destroy), | |
2068 GTK_OBJECT (dialog)); | |
2069 gtk_widget_grab_default (tempwid); | |
2070 gtk_widget_show (tempwid); | |
2071 | |
2072 tempwid = gtk_button_new_with_label (_(" Cancel ")); | |
2073 GTK_WIDGET_SET_FLAGS (tempwid, GTK_CAN_DEFAULT); | |
2074 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->action_area), tempwid, | |
2075 TRUE, TRUE, 0); | |
2076 gtk_signal_connect (GTK_OBJECT (tempwid), "clicked", | |
2077 GTK_SIGNAL_FUNC (cancel), (gpointer) tdata); | |
2078 gtk_signal_connect_object (GTK_OBJECT (tempwid), "clicked", | |
2079 GTK_SIGNAL_FUNC (gtk_widget_destroy), | |
2080 GTK_OBJECT (dialog)); | |
2081 gtk_widget_show (tempwid); | |
49 | 2082 #else |
2083 g_signal_connect (GTK_OBJECT (dialog), "response", | |
2084 G_CALLBACK (transfer_action), (gpointer) tdata); | |
2085 #endif | |
1 | 2086 |
2087 gtk_widget_show (dialog); | |
2088 dialog = NULL; | |
2089 } | |
2090 |