开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > Ftp客户端 > 查看源码
transfer.c
资源名称：FTP总集.rar　[点击查看]
上传用户：tjfeida
上传日期：2013-03-10
资源大小：1917k
文件大小：67k
源码类别：

Ftp客户端

开发平台：

Visual C++

transfer.c：源码内容
  1. /*****************************************************************************/
  2. /*  transfer.c - functions to handle transfering files                       */
  3. /*  Copyright (C) 1998-2002 Brian Masney <masneyb@gftp.org>                  */
  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. /*****************************************************************************/
  20. #include <gftp-gtk.h>
  21. static const char cvsid[] = "$Id: transfer.c,v 1.24 2002/12/05 00:43:07 masneyb Exp $";
  23. static GtkWidget * dialog;
  25. static void 
  26. wakeup_main_thread (gpointer data, gint source, GdkInputCondition condition)
  27. {
  28.   gftp_request * request;
  29.   char c;
  30.  
  31.   request = data; 
  32.   if (request->wakeup_main_thread[0] > 0)
  33.     read (request->wakeup_main_thread[0], &c, 1);
  34. }
  37. static gint
  38. setup_wakeup_main_thread (gftp_request * request)
  39. {
  40.   gint handler;
  42.   if (socketpair (AF_UNIX, SOCK_STREAM, 0, request->wakeup_main_thread) == 0)
  43.     {
  44.       handler = gdk_input_add (request->wakeup_main_thread[0], 
  45.                                GDK_INPUT_READ, wakeup_main_thread, request);
  46.     }
  47.   else
  48.     {
  49.       request->wakeup_main_thread[0] = 0;
  50.       request->wakeup_main_thread[1] = 0;
  51.       handler = 0;
  52.     }
  53.   return (handler);
  54. }
  57. static void
  58. teardown_wakeup_main_thread (gftp_request * request, gint handler)
  59. {
  60.   if (request->wakeup_main_thread[0] > 0 && request->wakeup_main_thread[1] > 0)
  61.     {
  62.       gdk_input_remove (handler);
  63.       close (request->wakeup_main_thread[0]);
  64.       close (request->wakeup_main_thread[1]);
  65.       request->wakeup_main_thread[0] = 0;
  66.       request->wakeup_main_thread[1] = 0;
  67.     }
  68. }
  71. static void *
  72. getdir_thread (void * data)
  73. {
  74.   int sj, havedotdot, got;
  75.   gftp_request * request;
  76.   gftp_file * fle;
  77.   GList * files;
  79.   request = data;
  80.   
  81.   if (request->use_threads)
  82.     {
  83.       sj = sigsetjmp (jmp_environment, 1);
  84.       use_jmp_environment = 1;
  85.     }
  86.   else
  87.     sj = 0;
  89.   files = NULL;
  90.   if (sj == 0 || sj == 2)
  91.     {
  92.       if (gftp_list_files (request) != 0 || !GFTP_IS_CONNECTED (request))
  93.         {
  94.           if (request->use_threads)
  95.             use_jmp_environment = 0;
  97.           request->stopable = 0;
  98.           if (request->wakeup_main_thread[1] > 0)
  99.             write (request->wakeup_main_thread[1], " ", 1);
  100.           return (NULL);
  101.         }
  103.       request->gotbytes = 0; 
  104.       havedotdot = 0; 
  105.       fle = g_malloc0 (sizeof (*fle));
  106.       while ((got = gftp_get_next_file (request, NULL, fle)) > 0)
  107.         { 
  108.           request->gotbytes += got;
  109.           if (strcmp (fle->file, ".") == 0)
  110.             {
  111.               gftp_file_destroy (fle);
  112.               continue;
  113.             }
  114.           else if (strcmp (fle->file, "..") == 0)
  115.             havedotdot = 1;
  117.           files = g_list_append (files, fle);
  118.           fle = g_malloc0 (sizeof (*fle));
  119.         }
  120.       g_free (fle);
  122.       if (!GFTP_IS_CONNECTED (request))
  123.         {
  124.           if (request->use_threads)
  125.             use_jmp_environment = 0;
  127.           request->stopable = 0;
  128.           if (request->wakeup_main_thread[1] > 0)
  129.             write (request->wakeup_main_thread[1], " ", 1);
  130.           return (NULL);
  131.         }
  133.       gftp_end_transfer (request); 
  134.       request->gotbytes = -1; 
  136.       if (!havedotdot)
  137.         {
  138.           fle = g_malloc0 (sizeof (*fle));
  139.           fle->file = g_malloc (3);
  140.           strcpy (fle->file, "..");
  141.           fle->user = g_malloc0 (1);
  142.           fle->group = g_malloc0 (1);
  143.           fle->attribs = g_malloc0 (1);
  144.           *fle->attribs = '';
  145.           fle->isdir = 1;
  146.           files = g_list_prepend (files, fle);
  147.         }
  148.     }
  150.   if (request->use_threads)
  151.     use_jmp_environment = 0;
  153.   request->stopable = 0;
  154.   if (request->wakeup_main_thread[1] > 0)
  155.     write (request->wakeup_main_thread[1], " ", 1);
  156.   return (files);
  157. }
  160. int
  161. ftp_list_files (gftp_window_data * wdata, int usecache)
  162. {
  163.   guint handler;
  164.   void *success;
  166.   gtk_label_set (GTK_LABEL (wdata->hoststxt), _("Receiving file names..."));
  168.   wdata->show_selected = 0;
  169.   if (wdata->files == NULL)
  170.     {
  171.       if (check_reconnect (wdata) < 0)
  172.         return (0);
  174.       gtk_clist_freeze (GTK_CLIST (wdata->listbox));
  175.       wdata->request->stopable = 1;
  176.       if (wdata->request->use_threads)
  177.         {
  178.           gtk_widget_set_sensitive (stop_btn, 1);
  180.           handler = setup_wakeup_main_thread (wdata->request);
  181.           pthread_create (&wdata->tid, NULL, getdir_thread, wdata->request);
  182.           while (wdata->request->stopable)
  183.             {
  184.               GDK_THREADS_LEAVE ();
  185. #if GTK_MAJOR_VERSION == 1
  186.               g_main_iteration (TRUE);
  187. #else
  188.               g_main_context_iteration (NULL, TRUE);
  189. #endif
  190.             }
  191.           teardown_wakeup_main_thread (wdata->request, handler);
  193.           pthread_join (wdata->tid, &success);
  194.           gtk_widget_set_sensitive (stop_btn, 0);
  195.         }
  196.       else
  197.         success = getdir_thread (wdata->request);
  198.       wdata->files = success;
  199.       gtk_clist_thaw (GTK_CLIST (wdata->listbox));
  200.       memset (&wdata->tid, 0, sizeof (wdata->tid));
  201.     }
  202.   
  203.   if (wdata->files == NULL || !GFTP_IS_CONNECTED (wdata->request))
  204.     {
  205.       disconnect (wdata);
  206.       return (0);
  207.     }
  209.   wdata->sorted = 0;
  210.   sortrows (GTK_CLIST (wdata->listbox), *wdata->sortcol, (gpointer) wdata);
  211.   if (IS_NONE_SELECTED (wdata))
  212.     gtk_clist_select_row (GTK_CLIST (wdata->listbox), 0, 0);
  213.   return (1);
  214. }
  217. static void
  218. try_connect_again (gftp_request * request, gftp_dialog_data * ddata)
  219. {
  220.   gftp_set_password (request, gtk_entry_get_text (GTK_ENTRY (ddata->edit)));
  221.   request->stopable = 0;
  222. }
  225. static void
  226. dont_connect_again (gftp_request * request, gftp_dialog_data * ddata)
  227. {
  228.   request->stopable = 0;
  229. }
  232. static void *
  233. connect_thread (void *data)
  234. {
  235.   static int conn_num;
  236.   gftp_request * request;
  237.   int ret, sj;
  239.   request = data;
  241.   conn_num = 0;
  242.   if (request->use_threads)
  243.     {
  244.       sj = sigsetjmp (jmp_environment, 1);
  245.       use_jmp_environment = 1;
  246.     }
  247.   else
  248.     sj = 0;
  250.   ret = 0;
  251.   if (sj != 0)
  252.     {
  253.       ret = 0;
  254.       gftp_disconnect (request);
  255.     }
  257.   while (sj != 1 && (request->retries == 0 || conn_num < request->retries))
  258.     {
  259.       conn_num++;
  260.       if (request->network_timeout > 0)
  261.         alarm (request->network_timeout);
  262.       ret = gftp_connect (request) == 0;
  263.       alarm (0);
  265.       if (ret)
  266.         break;
  267.       else if (request->retries == 0 || conn_num < request->retries)
  268.         {
  269.           request->logging_function (gftp_logging_misc, request->user_data,
  270.                      _("Waiting %d seconds until trying to connect againn"),
  271.      request->sleep_time);
  272.           alarm (request->sleep_time);
  273.           pause ();
  274.         }  
  275.     }
  277.   if (request->use_threads)
  278.     use_jmp_environment = 0;
  280.   request->stopable = 0;
  281.   if (request->wakeup_main_thread[1] > 0)
  282.     write (request->wakeup_main_thread[1], " ", 1);
  283.   return ((void *) ret);
  284. }
  287. int
  288. ftp_connect (gftp_window_data * wdata, gftp_request * request, int getdir)
  289. {
  290.   int success;
  291.   guint handler;
  292.   void *ret;
  294.   ret = 0;
  295.   if (wdata->request == request)
  296.     {
  297.       gtk_label_set (GTK_LABEL (wdata->hoststxt), _("Connecting..."));
  298.     }
  300.   if (request->need_userpass && request->username != NULL &&
  301.       *request->username != '' &&
  302.       (request->password == NULL || *request->password == ''))
  303.     {
  304.       if (wdata && wdata->request == request)
  305.         {
  306.           request->stopable = 1;
  307.           MakeEditDialog (_("Enter Password"),
  308.                           _("Please enter your password for this site"), NULL,
  309.                           0, NULL, gftp_dialog_button_connect, 
  310.                           try_connect_again, request, 
  311.                           dont_connect_again, request);
  313.           while (request->stopable)
  314.             {
  315.               GDK_THREADS_LEAVE ();
  316. #if GTK_MAJOR_VERSION == 1
  317.               g_main_iteration (TRUE);
  318. #else
  319.               g_main_context_iteration (NULL, TRUE);
  320. #endif
  321.             }
  323.           if (GFTP_GET_PASSWORD (request) == NULL || 
  324.               *GFTP_GET_PASSWORD (request) == '')
  325.             return (0);
  326.         }
  327.       else
  328.         gftp_set_password (request, "");
  329.     }
  331.   if (wdata && wdata->request == request && request->use_threads)
  332.     {
  333.       request->stopable = 1;
  334.       if (wdata)       
  335.         gtk_clist_freeze (GTK_CLIST (wdata->listbox));
  336.       gtk_widget_set_sensitive (stop_btn, 1);
  337.       pthread_create (&wdata->tid, NULL, connect_thread, request);
  339.       handler = setup_wakeup_main_thread (wdata->request);
  340.       while (request->stopable)
  341.         {
  342.           GDK_THREADS_LEAVE ();
  343. #if GTK_MAJOR_VERSION == 1
  344.           g_main_iteration (TRUE);
  345. #else
  346.           g_main_context_iteration (NULL, TRUE);
  347. #endif
  348.         }
  349.       pthread_join (wdata->tid, &ret);
  350.       teardown_wakeup_main_thread (wdata->request, handler);
  352.       gtk_widget_set_sensitive (stop_btn, 0);
  353.       if (wdata)
  354.         gtk_clist_thaw (GTK_CLIST (wdata->listbox));
  355.     }
  356.   else
  357.     ret = connect_thread (request);
  358.   success = (int) ret;
  359.   memset (&wdata->tid, 0, sizeof (wdata->tid));
  361.   if (!GFTP_IS_CONNECTED (wdata->request))
  362.     disconnect (wdata);
  363.   else if (success)
  364.     {
  365.       ftp_list_files (wdata, 1);
  366.       if (!GFTP_IS_CONNECTED (wdata->request))
  367.         disconnect (wdata);
  368.     }
  370.   return (success);
  371. }
  374. void 
  375. get_files (gpointer data)
  376. {
  377.   transfer_window_files (&window2, &window1);
  378. }
  381. void
  382. put_files (gpointer data)
  383. {
  384.   transfer_window_files (&window1, &window2);
  385. }
  388. void
  389. transfer_window_files (gftp_window_data * fromwdata, gftp_window_data * towdata)
  390. {
  391.   gftp_file * tempfle, * newfle;
  392.   GList * templist, * filelist;
  393.   gftp_transfer * transfer;
  394.   guint timeout_num;
  395.   void *ret;
  396.   int num;
  398.   if (!check_status (_("Transfer Files"), fromwdata, 1, 0, 1,
  399.        towdata->request->put_file != NULL && fromwdata->request->get_file != NULL))
  400.     return;
  402.   if (!GFTP_IS_CONNECTED (fromwdata->request) || 
  403.       !GFTP_IS_CONNECTED (towdata->request))
  404.     {
  405.       ftp_log (gftp_logging_misc, NULL,
  406.                _("Retrieve Files: Not connected to a remote siten"));
  407.       return;
  408.     }
  410.   if (check_reconnect (fromwdata) < 0 || check_reconnect (towdata) < 0)
  411.     return;
  413.   transfer = g_malloc0 (sizeof (*transfer));
  414.   transfer->fromreq = copy_request (fromwdata->request);
  415.   transfer->toreq = copy_request (towdata->request);
  416.   transfer->transfer_direction = fromwdata == &window2 ? 
  417.                            GFTP_DIRECTION_DOWNLOAD : GFTP_DIRECTION_UPLOAD;
  418.   transfer->fromwdata = fromwdata;
  419.   transfer->towdata = towdata;
  421.   num = 0;
  422.   templist = GTK_CLIST (fromwdata->listbox)->selection;
  423.   filelist = fromwdata->files;
  424.   while (templist != NULL)
  425.     {
  426.       templist = get_next_selection (templist, &filelist, &num);
  427.       tempfle = filelist->data;
  428.       if (strcmp (tempfle->file, "..") != 0)
  429.         {
  430.           newfle = copy_fdata (tempfle);
  431.           transfer->files = g_list_append (transfer->files, newfle);
  432.         }
  433.     }
  435.   if (transfer->files != NULL)
  436.     {
  437.       gftp_swap_socks (transfer->fromreq, fromwdata->request);
  438.       gftp_swap_socks (transfer->toreq, towdata->request);
  440.       if (transfer->fromreq->use_threads || 
  441.           (transfer->toreq && transfer->toreq->use_threads))
  442.         {
  443.           transfer->fromreq->stopable = 1;
  444.           pthread_create (&fromwdata->tid, NULL, do_getdir_thread, transfer);
  446.           timeout_num = gtk_timeout_add (100, progress_timeout, transfer);
  448.           while (transfer->fromreq->stopable)
  449.             {
  450.               GDK_THREADS_LEAVE ();
  451. #if GTK_MAJOR_VERSION == 1
  452.               g_main_iteration (TRUE);
  453. #else
  454.               g_main_context_iteration (NULL, TRUE);
  455. #endif
  456.             }
  458.           gtk_timeout_remove (timeout_num);
  459.           transfer->numfiles = transfer->numdirs = -1; 
  460.           update_directory_download_progress (transfer);
  462.           pthread_join (fromwdata->tid, &ret);
  463.         }
  464.       else
  465.         ret = do_getdir_thread (transfer);
  467.       if (!GFTP_IS_CONNECTED (transfer->fromreq))
  468.         {
  469.           disconnect (fromwdata);
  470.           return;
  471.         } 
  473.       if (!GFTP_IS_CONNECTED (transfer->toreq))
  474.         {
  475.           disconnect (towdata);
  476.           return;
  477.         } 
  479.       gftp_swap_socks (fromwdata->request, transfer->fromreq);
  480.       gftp_swap_socks (towdata->request, transfer->toreq);
  481.     }
  483.   if (transfer->files != NULL)
  484.     {
  485.       add_file_transfer (transfer->fromreq, transfer->toreq, 
  486.                          transfer->fromwdata, transfer->towdata, 
  487.                          transfer->files, 0);
  488.       g_free (transfer);
  489.     }
  490.   else
  491.     {
  492.       if (transfer->statmutex)
  493.         pthread_mutex_destroy (transfer->statmutex);
  494.       if (transfer->structmutex)
  495.         pthread_mutex_destroy (transfer->structmutex);
  496.       free_tdata (transfer);
  497.     }
  498. }
  500. void *
  501. do_getdir_thread (void * data)
  502. {
  503.   gftp_transfer * transfer;
  504.   int success, sj;
  506.   transfer = data;
  508.   if (transfer->fromreq->use_threads || 
  509.       (transfer->toreq && transfer->toreq->use_threads))
  510.     {
  511.       sj = sigsetjmp (jmp_environment, 1);
  512.       use_jmp_environment = 1;
  513.     }
  514.   else
  515.     sj = 0;
  517.   success = 0;
  518.   if (sj == 0)
  519.     success = gftp_get_all_subdirs (transfer, NULL) == 0;
  520.   else
  521.     {
  522.       gftp_disconnect (transfer->fromreq);
  523.       if (transfer->toreq)
  524.         gftp_disconnect (transfer->toreq);
  525.       transfer->fromreq->logging_function (gftp_logging_error,
  526.                                            transfer->fromreq->user_data,
  527.                                            _("Operation canceledn"));
  528.     }
  530.   if (transfer->fromreq->use_threads || 
  531.       (transfer->toreq && transfer->toreq->use_threads))
  532.     use_jmp_environment = 0;
  534.   transfer->fromreq->stopable = 0;
  535.   return ((void *) success);
  536. }
  539. static void
  540. gftp_gtk_calc_kbs (gftp_transfer * tdata, ssize_t num_read)
  541. {
  542.   unsigned long waitusecs;
  543.   double difftime, curkbs;
  544.   gftp_file * tempfle;
  545.   struct timeval tv;
  546.   unsigned long toadd;
  548.   gettimeofday (&tv, NULL);
  549.   pthread_mutex_lock (tdata->statmutex);
  551.   tempfle = tdata->curfle->data;
  552.   tdata->trans_bytes += num_read;
  553.   tdata->curtrans += num_read;
  554.   tdata->stalled = 0;
  556.   difftime = (tv.tv_sec - tdata->starttime.tv_sec) + ((double) (tv.tv_usec - tdata->starttime.tv_usec) / 1000000.0);
  557.   if (difftime <= 0)
  558.     tdata->kbs = (double) tdata->trans_bytes / 1024.0;
  559.   else
  560.     tdata->kbs = (double) tdata->trans_bytes / 1024.0 / difftime;
  562.   difftime = (tv.tv_sec - tdata->lasttime.tv_sec) + ((double) (tv.tv_usec - tdata->lasttime.tv_usec) / 1000000.0);
  564.   if (difftime <= 0)
  565.     curkbs = (double) (num_read / 1024.0);
  566.   else
  567.     curkbs = (double) (num_read / 1024.0 / difftime);
  569.   if (tdata->fromreq->maxkbs > 0 &&
  570.       curkbs > tdata->fromreq->maxkbs)
  571.     {
  572.       waitusecs = (double) num_read / 1024.0 / tdata->fromreq->maxkbs * 1000000.0 - difftime;
  574.       if (waitusecs > 0)
  575.         {
  576.           pthread_mutex_unlock (tdata->statmutex);
  577.           difftime += ((double) waitusecs / 1000000.0);
  578.           usleep (waitusecs);
  579.           pthread_mutex_lock (tdata->statmutex);
  580.         }
  581.     }
  583.   /* I don't call gettimeofday (&tdata->lasttime) here because this will use
  584.      less system resources. This will be close enough for what we need */
  585.   difftime += tdata->lasttime.tv_usec / 1000000.0;
  586.   toadd = (long) difftime;
  587.   difftime -= toadd;
  588.   tdata->lasttime.tv_sec += toadd;
  589.   tdata->lasttime.tv_usec = difftime * 1000000.0;
  591.   pthread_mutex_unlock (tdata->statmutex);
  592. }
  595. static int
  596. get_status (gftp_transfer * tdata, ssize_t num_read)
  597. {
  598.   gftp_file * tempfle;
  599.   struct timeval tv;
  601.   pthread_mutex_lock (tdata->structmutex);
  602.   if (tdata->curfle == NULL)
  603.     {
  604.       pthread_mutex_unlock (tdata->structmutex);
  605.       return (-1);
  606.     }
  607.   tempfle = tdata->curfle->data;
  608.   pthread_mutex_unlock (tdata->structmutex);
  610.   gftp_disconnect (tdata->fromreq);
  611.   gftp_disconnect (tdata->toreq);
  612.   if (num_read < 0 || tdata->skip_file)
  613.     {
  614.       if (tdata->fromreq->retries != 0 && tdata->current_file_retries >= tdata->fromreq->retries)
  615.         {
  616.           tdata->fromreq->logging_function (gftp_logging_error, 
  617.                    tdata->fromreq->user_data,
  618.                    _("Error: Remote site %s disconnected. Max retries reached...giving upn"),
  619.                    tdata->fromreq->hostname != NULL ? 
  620.                          tdata->fromreq->hostname : tdata->toreq->hostname);
  621.           return (-1);
  622.         }
  623.       else
  624.         {
  625.           tdata->fromreq->logging_function (gftp_logging_error, 
  626.                      tdata->fromreq->user_data,
  627.                      _("Error: Remote site %s disconnected. Will reconnect in %d secondsn"),
  628.                      tdata->fromreq->hostname != NULL ? 
  629.                            tdata->fromreq->hostname : tdata->toreq->hostname, 
  630.                      tdata->fromreq->sleep_time);
  631.         }
  633.       while (tdata->fromreq->retries == 0 || 
  634.              tdata->current_file_retries <= tdata->fromreq->retries)
  635.         {
  636.           if (!tdata->skip_file)
  637.             {
  638.               tv.tv_sec = tdata->fromreq->sleep_time;
  639.               tv.tv_usec = 0;
  640.               select (0, NULL, NULL, NULL, &tv);
  641.             }
  643.           if (gftp_connect (tdata->fromreq) == 0 &&
  644.               gftp_connect (tdata->toreq) == 0)
  645.             {
  646.               pthread_mutex_lock (tdata->structmutex);
  647.               tdata->resumed_bytes = tdata->resumed_bytes + tdata->trans_bytes - tdata->curresumed - tdata->curtrans;
  648.               tdata->trans_bytes = 0;
  649.               if (tdata->skip_file)
  650.                 {
  651.                   tdata->total_bytes -= tempfle->size;
  652.                   tdata->curtrans = 0;
  654.                   tdata->curfle = tdata->curfle->next;
  655.                   tdata->next_file = 1;
  656.                   tdata->skip_file = 0;
  657.                   tdata->cancel = 0;
  658.                   tdata->fromreq->cancel = 0;
  659.                   tdata->toreq->cancel = 0;
  660.                 }
  661.               else
  662.                 {
  663.                   tempfle->transfer_action = GFTP_TRANS_ACTION_RESUME;
  664.                   tempfle->startsize = tdata->curtrans + tdata->curresumed;
  665.                   /* We decrement this here because it will be incremented in 
  666.                      the loop again */
  667.                   tdata->curresumed = 0;
  668.                   tdata->current_file_number--; /* Decrement this because it 
  669.                                                    will be incremented when we 
  670.                                                    continue in the loop */
  671.                 }
  672.               gettimeofday (&tdata->starttime, NULL);
  673.               pthread_mutex_unlock (tdata->structmutex);
  674.               return (1);
  675.             }
  676.           else
  677.             tdata->current_file_retries++;
  678.         }
  679.     }
  680.   else if (tdata->cancel)
  681.     return (-1);
  683.   return (0);
  684. }
  687. static mode_t
  688. parse_attribs (char *attribs)
  689. {
  690.   mode_t mode;
  691.   int cur;
  693.   cur = 0;
  694.   if (attribs[1] == 'r')
  695.     cur += 4;
  696.   if (attribs[2] == 'w')
  697.     cur += 2;
  698.   if (attribs[3] == 'x' ||
  699.       attribs[3] == 's')
  700.     cur += 1;
  701.   mode = cur;
  703.   cur = 0;
  704.   if (attribs[4] == 'r')
  705.     cur += 4;
  706.   if (attribs[5] == 'w')
  707.     cur += 2;
  708.   if (attribs[6] == 'x' ||
  709.       attribs[6] == 's')
  710.     cur += 1;
  711.   mode = (mode * 10) + cur;
  713.   cur = 0;
  714.   if (attribs[7] == 'r')
  715.     cur += 4;
  716.   if (attribs[8] == 'w')
  717.     cur += 2;
  718.   if (attribs[9] == 'x' ||
  719.       attribs[9] == 's')
  720.     cur += 1;
  721.   mode = (mode * 10) + cur;
  723.   return (mode);
  724. }
  727. void * 
  728. gftp_gtk_transfer_files (void *data)
  729. {
  730.   int i, mode, dl_type, tofd, fromfd, old_from_datatype;
  731.   gftp_transfer * transfer;
  732.   char *tempstr, buf[8192];
  733.   off_t fromsize, total;
  734.   gftp_file * curfle; 
  735.   ssize_t num_read;
  737.   pthread_detach (pthread_self ());
  738.   transfer = data;
  739.   transfer->curfle = transfer->files;
  740.   gettimeofday (&transfer->starttime, NULL);
  741.   memcpy (&transfer->lasttime, &transfer->starttime, 
  742.           sizeof (transfer->lasttime));
  744.   dl_type = transfer->fromreq->data_type;
  745.   old_from_datatype = transfer->fromreq->data_type;
  747.   while (transfer->curfle != NULL)
  748.     {
  749.       pthread_mutex_lock (transfer->structmutex);
  750.       curfle = transfer->curfle->data;
  751.       transfer->current_file_number++; 
  752.       pthread_mutex_unlock (transfer->structmutex);
  753.  
  754.       if (curfle->transfer_action == GFTP_TRANS_ACTION_SKIP)
  755.         {
  756.           pthread_mutex_lock (transfer->structmutex);
  757.           transfer->next_file = 1;
  758.           transfer->curfle = transfer->curfle->next;
  759.           pthread_mutex_unlock (transfer->structmutex);
  760.           continue;
  761.         }
  763.       fromsize = -1;
  764.       if (gftp_connect (transfer->fromreq) == 0 &&
  765.           gftp_connect (transfer->toreq) == 0)
  766.         {
  767.           if (curfle->isdir)
  768.             {
  769.               if (transfer->toreq->mkdir != NULL)
  770.                 {
  771.                   transfer->toreq->mkdir (transfer->toreq, curfle->destfile);
  772.                   if (!GFTP_IS_CONNECTED (transfer->toreq))
  773.                     break;
  774.                 }
  776.               pthread_mutex_lock (transfer->structmutex);
  777.               transfer->next_file = 1;
  778.               transfer->curfle = transfer->curfle->next;
  779.               pthread_mutex_unlock (transfer->structmutex);
  780.               continue;
  781.             }
  783.           if (transfer->fromreq->maxkbs > 0)
  784.             {
  785.               transfer->fromreq->logging_function (gftp_logging_misc, 
  786.                             transfer->fromreq->user_data, 
  787.                             _("File transfer will be throttled to %.2f KB/sn"),
  788.                             transfer->fromreq->maxkbs);
  789.             }
  791.           if (curfle->is_fd)
  792.             {
  793.               if (transfer->transfer_direction == GFTP_DIRECTION_DOWNLOAD)
  794.                 {
  795.                   tofd = curfle->fd;
  796.                   fromfd = -1;
  797.                 }
  798.               else
  799.                 {
  800.                   tofd = -1;
  801.                   fromfd = curfle->fd;
  802.                 }
  803.             }
  804.           else
  805.             {
  806.               tofd = -1;
  807.               fromfd = -1;
  808.             }
  810.           if (curfle->size == 0)
  811.             {
  812.               curfle->size = gftp_get_file_size (transfer->fromreq, curfle->file);
  813.               transfer->total_bytes += curfle->size;
  814.             }
  816.           if (GFTP_IS_CONNECTED (transfer->fromreq) &&
  817.               GFTP_IS_CONNECTED (transfer->toreq))
  818.             {
  819.               if (!curfle->ascii && old_from_datatype == GFTP_TYPE_BINARY)
  820.                 dl_type = GFTP_TYPE_BINARY;
  821.               else
  822.                 dl_type = GFTP_GET_DATA_TYPE (transfer->fromreq) == GFTP_TYPE_ASCII || curfle->ascii ? GFTP_TYPE_ASCII : GFTP_TYPE_BINARY;
  824.               if (dl_type != transfer->fromreq->data_type)
  825.                 {
  826.                    if (gftp_set_data_type (transfer->fromreq, dl_type) != 0)
  827.                      gftp_disconnect (transfer->fromreq);
  828.                  }
  830.               if (dl_type != transfer->toreq->data_type)
  831.                 {
  832.                    if (gftp_set_data_type (transfer->toreq, dl_type) != 0)
  833.                      gftp_disconnect (transfer->toreq);
  834.                  }
  835.             }
  837.           if (GFTP_IS_CONNECTED (transfer->fromreq) &&
  838.               GFTP_IS_CONNECTED (transfer->toreq))
  839.             {
  840.               fromsize = gftp_transfer_file (transfer->fromreq, curfle->file, 
  841.                           fromfd,
  842.                           curfle->transfer_action == GFTP_TRANS_ACTION_RESUME ?
  843.                                                     curfle->startsize : 0,
  844.                           transfer->toreq, curfle->destfile, tofd,
  845.                           curfle->transfer_action == GFTP_TRANS_ACTION_RESUME ?
  846.                                                     curfle->startsize : 0);
  847.             }
  848.         }
  850.       if (!GFTP_IS_CONNECTED (transfer->fromreq) || 
  851.           !GFTP_IS_CONNECTED (transfer->toreq))
  852.         {
  853.           transfer->fromreq->logging_function (gftp_logging_misc, 
  854.                          transfer->fromreq->user_data, 
  855.                          _("Error: Remote site disconnected after trying to transfer filen"));
  856.           num_read = -1;
  857.         }
  858.       else if (fromsize < 0)
  859.         {
  860.           if (curfle->is_fd)
  861.             {
  862.               if (transfer->transfer_direction == GFTP_DIRECTION_DOWNLOAD)
  863.                 transfer->toreq->datafd = -1;
  864.               else
  865.                 transfer->fromreq->datafd = -1;
  866.             }
  868.           pthread_mutex_lock (transfer->structmutex);
  869.           curfle->transfer_action = GFTP_TRANS_ACTION_SKIP;
  870.           transfer->next_file = 1;
  871.           transfer->curfle = transfer->curfle->next;
  872.           pthread_mutex_unlock (transfer->structmutex);
  873.           continue;
  874.         }
  875.       else
  876.         {
  877.           pthread_mutex_lock (transfer->structmutex);
  878.           transfer->curtrans = 0;
  879.           transfer->curresumed = curfle->transfer_action == GFTP_TRANS_ACTION_RESUME ? curfle->startsize : 0;
  880.           transfer->resumed_bytes += transfer->curresumed;
  881.           pthread_mutex_unlock (transfer->structmutex);
  882.   
  883.           total = 0;
  884.           i = 0;
  885.           while (!transfer->cancel && 
  886.                  (num_read = gftp_get_next_file_chunk (transfer->fromreq,
  887.                                                        buf, sizeof (buf))) > 0)
  888.             {
  889.               total += num_read;
  890.               gftp_gtk_calc_kbs (transfer, num_read);
  892.               if (dl_type == GFTP_TYPE_ASCII)
  893.                 tempstr = gftp_convert_ascii (buf, &num_read, 1);
  894.               else
  895.                 tempstr = buf;
  897.               if (gftp_put_next_file_chunk (transfer->toreq, tempstr, 
  898.                                             num_read) < 0)
  899.                 {
  900.                   num_read = -1;
  901.                   break;
  902.                 }
  904.               /* We don't have to free tempstr for a download because new 
  905.                  memory is not allocated for it in that case */
  906.               if (dl_type == GFTP_TYPE_ASCII &&
  907.                   transfer->transfer_direction == GFTP_DIRECTION_UPLOAD)
  908.                 g_free (tempstr);
  909.             }
  910.         }
  912.       if (transfer->cancel)
  913.         {
  914.           if (gftp_abort_transfer (transfer->fromreq) != 0)
  915.             gftp_disconnect (transfer->fromreq);
  917.           if (gftp_abort_transfer (transfer->toreq) != 0)
  918.             gftp_disconnect (transfer->toreq);
  919.         }
  920.       else if (num_read < 0)
  921.         {
  922.           transfer->fromreq->logging_function (gftp_logging_misc, 
  923.                                         transfer->fromreq->user_data, 
  924.                                         _("Could not download %s from %sn"), 
  925.                                         curfle->file,
  926.                                         transfer->fromreq->hostname);
  928.           if (get_status (transfer, num_read) == 1)
  929.             continue;
  931.           break;
  932.         }
  933.       else
  934.         {
  935.           /* FIXME - this needs cleaned up. NOTE: view/edit file will be 
  936.              broken if the file has to be resumed */
  937.           if (curfle->is_fd)
  938.             {
  939.               if (transfer->transfer_direction == GFTP_DIRECTION_DOWNLOAD)
  940.                 transfer->toreq->datafd = -1;
  941.               else
  942.                 transfer->fromreq->datafd = -1;
  943.             }
  945.           if (gftp_end_transfer (transfer->fromreq) != 0)
  946.             {
  947.               if (get_status (transfer, -1) == 1)
  948.                 continue;
  950.               break;
  951.             }
  952.           gftp_end_transfer (transfer->toreq);
  954.           transfer->fromreq->logging_function (gftp_logging_misc, 
  955.                          transfer->fromreq->user_data, 
  956.                          _("Successfully transferred %s at %.2f KB/sn"),
  957.                          curfle->file, transfer->kbs);
  958.         }
  960.       if (!curfle->is_fd)
  961.         {
  962.           if (curfle->attribs)
  963.             {
  964.               mode = parse_attribs (curfle->attribs);
  965.               if (mode != 0)
  966.                 gftp_chmod (transfer->toreq, curfle->destfile,
  967.                             parse_attribs (curfle->attribs));
  968.             }
  970.           if (curfle->datetime != 0)
  971.             gftp_set_file_time (transfer->toreq, curfle->destfile,
  972.                                 curfle->datetime);
  973.         }
  975.       pthread_mutex_lock (transfer->structmutex);
  976.       transfer->next_file = 1;
  977.       curfle->transfer_done = 1;
  978.       transfer->curfle = transfer->curfle->next;
  979.       pthread_mutex_unlock (transfer->structmutex);
  981.       if (transfer->cancel && !transfer->skip_file)
  982.         break;
  983.       transfer->cancel = 0;
  984.       transfer->fromreq->cancel = 0;
  985.       transfer->toreq->cancel = 0;
  986.     }
  987.   transfer->done = 1; 
  988.   return (NULL);
  989. }
  992. void
  993. add_file_transfer (gftp_request * fromreq, gftp_request * toreq,
  994.                    gftp_window_data * fromwdata, gftp_window_data * towdata, 
  995.                    GList * files, int copy_req)
  996. {
  997.   gftp_curtrans_data * transdata;
  998.   GList * templist, *curfle;
  999.   gftp_transfer * tdata;
  1000.   gftp_file * tempfle;
  1001.   char *pos, *text[2];
  1002.   int dialog;
  1004.   for (templist = files; templist != NULL; templist = templist->next)
  1005.     { 
  1006.       tempfle = templist->data;
  1007.       if (tempfle->startsize > 0)
  1008.         break;
  1009.     }
  1010.   dialog = templist != NULL;
  1012.   if (append_file_transfers)
  1013.     {
  1014.       pthread_mutex_lock (&transfer_mutex);
  1015.       for (templist = file_transfers; templist != NULL; templist = templist->next)
  1016.         {
  1017.           tdata = templist->data;
  1018.           pthread_mutex_lock (tdata->structmutex);
  1019.           if (compare_request (tdata->fromreq, fromreq, 0) &&
  1020.               compare_request (tdata->toreq, toreq, 0) &&
  1021.               tdata->curfle != NULL)
  1022.             {
  1023.               if (!copy_req)
  1024.                 {
  1025.                   gftp_request_destroy (fromreq, 1);
  1026.                   gftp_request_destroy (toreq, 1);
  1027.                 }
  1028.               fromreq = NULL;
  1029.               toreq = NULL;
  1031.               for (curfle = tdata->curfle; 
  1032.                    curfle != NULL && curfle->next != NULL; 
  1033.                    curfle = curfle->next);
  1034.               if (curfle == NULL)
  1035.                 {
  1036.                   curfle = files;
  1037.                   files->prev = NULL;
  1038.                 }
  1039.               else
  1040.                 {
  1041.                   curfle->next = files;
  1042.                   files->prev = curfle;
  1043.                 }
  1045.               for (curfle = files; curfle != NULL; curfle = curfle->next)
  1046.                 {
  1047.                   tempfle = curfle->data;
  1048.                   if (tempfle->isdir)
  1049.                     tdata->numdirs++;
  1050.                   else
  1051.                     tdata->numfiles++;
  1052.                   if ((pos = strrchr (tempfle->file, '/')) == NULL)
  1053.                     pos = tempfle->file;
  1054.                   else
  1055.                     pos++;
  1057.                   text[0] = pos;
  1058.                   if (tempfle->transfer_action == GFTP_TRANS_ACTION_SKIP)
  1059.                     text[1] = _("Skipped");
  1060.                   else
  1061.                     {
  1062.                       tdata->total_bytes += tempfle->size;
  1063.                       text[1] = _("Waiting...");
  1064.                     }
  1066.                   tempfle->node = gtk_ctree_insert_node (GTK_CTREE (dlwdw),  
  1067.                                                          tdata->node, NULL, text, 5,
  1068.                                                          NULL, NULL, NULL, NULL, 
  1069.                                                          FALSE, FALSE);
  1070.                   transdata = g_malloc (sizeof (*transdata));
  1071.                   transdata->transfer = tdata;
  1072.                   transdata->curfle = curfle;
  1073.                   gtk_ctree_node_set_row_data (GTK_CTREE (dlwdw), tempfle->node, 
  1074.                                                transdata);
  1075.                 }
  1076.               pthread_mutex_unlock (tdata->structmutex);
  1077.               break; 
  1078.             }
  1079.           pthread_mutex_unlock (tdata->structmutex);
  1080.         }
  1081.       pthread_mutex_unlock (&transfer_mutex);
  1082.     }
  1083.   else
  1084.     templist = NULL;
  1085.     
  1086.   if (templist == NULL)
  1087.     {
  1088.       tdata = g_malloc0 (sizeof (*tdata));
  1089.       if (copy_req)
  1090.         {
  1091.           tdata->fromreq = copy_request (fromreq);
  1092.           tdata->toreq = copy_request (toreq); 
  1093.         }
  1094.       else
  1095.         {
  1096.           tdata->fromreq = fromreq;
  1097.           tdata->toreq = toreq; 
  1098.         } 
  1099.       tdata->transfer_direction = fromwdata && fromwdata == &window1 ?
  1100.                             GFTP_DIRECTION_UPLOAD : GFTP_DIRECTION_DOWNLOAD;
  1101.       tdata->fromwdata = fromwdata;
  1102.       tdata->towdata = towdata;
  1103.       if (!dialog)
  1104.         tdata->show = tdata->ready = 1;
  1105.       tdata->files = files;
  1106.       for (curfle = files; curfle != NULL; curfle = curfle->next)
  1107.         {
  1108.           tempfle = curfle->data;
  1109.           if (tempfle->isdir)
  1110.             tdata->numdirs++;
  1111.           else
  1112.             tdata->numfiles++;
  1113.         }
  1114.       tdata->structmutex = g_malloc (sizeof (pthread_mutex_t));
  1115.       pthread_mutex_init (tdata->structmutex, NULL);
  1116.       tdata->statmutex = g_malloc (sizeof (pthread_mutex_t));
  1117.       pthread_mutex_init (tdata->statmutex, NULL);
  1118.       pthread_mutex_lock (&transfer_mutex);
  1119.       file_transfers = g_list_append (file_transfers, tdata);
  1120.       pthread_mutex_unlock (&transfer_mutex);
  1121.       if (dialog)
  1122.         gftp_gtk_ask_transfer (tdata);
  1123.     }
  1124. }
  1127. static void
  1128. remove_file (char *filename)
  1129. {
  1130.   if (unlink (filename) == 0)
  1131.     ftp_log (gftp_logging_misc, NULL, _("Successfully removed %sn"),
  1132.              filename);
  1133.   else
  1134.     ftp_log (gftp_logging_error, NULL,
  1135.              _("Error: Could not remove file %s: %sn"), filename,
  1136.              g_strerror (errno));
  1137. }
  1140. static void
  1141. free_edit_data (gftp_viewedit_data * ve_proc)
  1142. {
  1143.   int i;
  1145.   if (ve_proc->filename)
  1146.     g_free (ve_proc->filename);
  1147.   if (ve_proc->remote_filename)
  1148.     g_free (ve_proc->remote_filename);
  1149.   for (i = 0; ve_proc->argv[i] != NULL; i++)
  1150.     g_free (ve_proc->argv[i]);
  1151.   g_free (ve_proc->argv);
  1152.   g_free (ve_proc);
  1153. }
  1156. static void
  1157. dont_upload (gftp_viewedit_data * ve_proc, gftp_dialog_data * ddata)
  1158. {
  1159.   remove_file (ve_proc->filename);
  1160.   free_edit_data (ve_proc);
  1161. }
  1164. static void
  1165. do_upload (gftp_viewedit_data * ve_proc, gftp_dialog_data * ddata)
  1166. {
  1167.   gftp_file * tempfle;
  1168.   GList * newfile;
  1170.   tempfle = g_malloc0 (sizeof (*tempfle));
  1171.   tempfle->destfile = ve_proc->remote_filename;
  1172.   ve_proc->remote_filename = NULL;
  1173.   tempfle->file = ve_proc->filename;
  1174.   ve_proc->filename = NULL;
  1175.   tempfle->done_rm = 1;
  1176.   newfile = g_list_append (NULL, tempfle);
  1177.   add_file_transfer (ve_proc->fromwdata->request, ve_proc->towdata->request,
  1178.                      ve_proc->fromwdata, ve_proc->towdata, newfile, 1);
  1179.   free_edit_data (ve_proc);
  1180. }
  1183. static void
  1184. check_done_process (void)
  1185. {
  1186.   gftp_viewedit_data * ve_proc;
  1187.   GList * curdata, *deldata;
  1188.   struct stat st;
  1189.   int ret;
  1190.   char *str;
  1191.   pid_t pid;
  1193.   viewedit_process_done = 0;
  1194.   while ((pid = waitpid (-1, &ret, WNOHANG)) > 0)
  1195.     {
  1196.       curdata = viewedit_processes;
  1197.       while (curdata != NULL)
  1198.         {
  1199.   ve_proc = curdata->data;
  1200.           deldata = curdata;
  1201.           curdata = curdata->next;
  1202.   if (ve_proc->pid == pid)
  1203.     {
  1204.       viewedit_processes = g_list_remove_link (viewedit_processes, 
  1205.                                                        deldata);
  1206.       if (ret != 0)
  1207. ftp_log (gftp_logging_error, NULL,
  1208.  _("Error: Child %d returned %dn"), pid, ret);
  1209.       else
  1210. ftp_log (gftp_logging_misc, NULL,
  1211.  _("Child %d returned successfullyn"), pid);
  1213.       if (!ve_proc->view && !ve_proc->dontupload)
  1214. {
  1215.   /* We was editing the file. Upload it */
  1216.   if (stat (ve_proc->filename, &st) == -1)
  1217.     ftp_log (gftp_logging_error, NULL,
  1218.          _("Error: Cannot get information about file %s: %sn"),
  1219.  ve_proc->filename, g_strerror (errno));
  1220.   else if (st.st_mtime == ve_proc->st.st_mtime)
  1221.                     {
  1222.       ftp_log (gftp_logging_misc, NULL,
  1223.           _("File %s was not changedn"),
  1224.        ve_proc->filename);
  1225.                       remove_file (ve_proc->filename);
  1226.                     }
  1227.   else
  1228.     {
  1229.       memcpy (&ve_proc->st, &st, sizeof (ve_proc->st));
  1230.       str = g_strdup_printf (
  1231. _("File %s has changed.nWould you like to upload it?"),
  1232.                         ve_proc->remote_filename);
  1234.       MakeYesNoDialog (_("Edit File"), str, 
  1235.                                        do_upload, ve_proc, 
  1236.                                        dont_upload, ve_proc);
  1237.       g_free (str);
  1238.       continue;
  1239.     }
  1240. }
  1242.               free_edit_data (ve_proc);
  1243.       continue;
  1244.     }
  1245. }
  1246.     }
  1247. }
  1250. static void
  1251. on_next_transfer (gftp_transfer * tdata)
  1252. {
  1253.   gftp_file * tempfle;
  1254.   int fd;
  1256.   tdata->next_file = 0;
  1257.   for (; tdata->updfle != tdata->curfle; tdata->updfle = tdata->updfle->next)
  1258.     {
  1259.       tempfle = tdata->updfle->data;
  1261.       if (tempfle->is_fd)
  1262.         fd = tempfle->fd;
  1263.       else
  1264.         fd = 0;
  1266.       if (tempfle->done_view)
  1267.         {
  1268.           if (tempfle->transfer_action != GFTP_TRANS_ACTION_SKIP)
  1269.             view_file (tempfle->destfile, fd, 1, tempfle->done_rm, 1, 0,
  1270.                        tempfle->file, NULL);
  1272.           if (tempfle->is_fd)
  1273.             {
  1274.               close (tempfle->fd);
  1275.               tempfle->fd = -1;
  1276.             }
  1277.         }
  1278.       else if (tempfle->done_edit)
  1279.         {
  1280.           if (tempfle->transfer_action != GFTP_TRANS_ACTION_SKIP)
  1281.     view_file (tempfle->destfile, fd, 0, tempfle->done_rm, 1, 0,
  1282.                        tempfle->file, NULL);
  1284.           if (tempfle->is_fd)
  1285.             {
  1286.               close (tempfle->fd);
  1287.               tempfle->fd = -1;
  1288.             }
  1289.         }
  1290.       else if (tempfle->done_rm)
  1291. tdata->fromreq->rmfile (tdata->fromreq, tempfle->file);
  1292.       
  1293.       if (tempfle->transfer_action == GFTP_TRANS_ACTION_SKIP)
  1294.         gtk_ctree_node_set_text (GTK_CTREE (dlwdw), tempfle->node, 1,
  1295.             _("Skipped"));
  1296.       else
  1297.         gtk_ctree_node_set_text (GTK_CTREE (dlwdw), tempfle->node, 1,
  1298.             _("Finished"));
  1299.     }
  1301.   if (refresh_files && tdata->curfle && tdata->curfle->next &&
  1302.       compare_request (tdata->toreq, 
  1303.                        ((gftp_window_data *) tdata->towdata)->request, 1))
  1304.     refresh (tdata->towdata);
  1305. }
  1308. static void
  1309. get_trans_password (gftp_request * request, gftp_dialog_data * ddata)
  1310. {
  1311.   gftp_set_password (request, gtk_entry_get_text (GTK_ENTRY (ddata->edit)));
  1312.   request->stopable = 0;
  1313. }
  1316. static void
  1317. cancel_get_trans_password (gftp_transfer * tdata, gftp_dialog_data * ddata)
  1318. {
  1319.   if (tdata->fromreq->stopable == 0)
  1320.     return;
  1322.   pthread_mutex_lock (tdata->structmutex);
  1323.   if (tdata->started)
  1324.     {
  1325.       tdata->cancel = 1;
  1326.       tdata->fromreq->cancel = 1;
  1327.       tdata->toreq->cancel = 1;
  1328.     }
  1329.   else
  1330.     tdata->done = 1;
  1332.   tdata->fromreq->stopable = 0;
  1333.   tdata->toreq->stopable = 0;
  1334.   pthread_mutex_unlock (tdata->structmutex);
  1336.   ftp_log (gftp_logging_misc, NULL, _("Stopping the transfer of %sn"),
  1337.    ((gftp_file *) tdata->curfle->data)->file);
  1338. }
  1341. static void
  1342. show_transfer (gftp_transfer * tdata)
  1343. {
  1344.   GdkPixmap * closedir_pixmap, * opendir_pixmap;
  1345.   GdkBitmap * closedir_bitmap, * opendir_bitmap;
  1346.   gftp_curtrans_data * transdata;
  1347.   gftp_file * tempfle;
  1348.   char *pos, *text[2];
  1349.   GList * templist;
  1351.   gftp_get_pixmap (dlwdw, "open_dir.xpm", &opendir_pixmap, &opendir_bitmap);
  1352.   gftp_get_pixmap (dlwdw, "dir.xpm", &closedir_pixmap, &closedir_bitmap);
  1354.   text[0] = GFTP_GET_HOSTNAME (tdata->fromreq);
  1355.   text[1] = _("Waiting...");
  1356.   tdata->node = gtk_ctree_insert_node (GTK_CTREE (dlwdw), NULL, NULL, text, 5,
  1357.                                        closedir_pixmap, closedir_bitmap, 
  1358.                                        opendir_pixmap, opendir_bitmap, 
  1359.                                        FALSE, 
  1360.                                        tdata->numdirs + tdata->numfiles < 50);
  1361.   transdata = g_malloc (sizeof (*transdata));
  1362.   transdata->transfer = tdata;
  1363.   transdata->curfle = NULL;
  1364.   gtk_ctree_node_set_row_data (GTK_CTREE (dlwdw), tdata->node, transdata);
  1365.   tdata->show = 0;
  1366.   tdata->curfle = tdata->updfle = tdata->files;
  1368.   tdata->total_bytes = 0;
  1369.   for (templist = tdata->files; templist != NULL; templist = templist->next)
  1370.     {
  1371.       tempfle = templist->data;
  1372.       if ((pos = strrchr (tempfle->file, '/')) == NULL)
  1373. pos = tempfle->file;
  1374.       else
  1375. pos++;
  1376.       text[0] = pos;
  1377.       if (tempfle->transfer_action == GFTP_TRANS_ACTION_SKIP)
  1378.         text[1] = _("Skipped");
  1379.       else
  1380.         {
  1381.           tdata->total_bytes += tempfle->size;
  1382.           text[1] = _("Waiting...");
  1383.         }
  1385.       tempfle->node = gtk_ctree_insert_node (GTK_CTREE (dlwdw), tdata->node, 
  1386.                                              NULL, text, 5, NULL, NULL, NULL, 
  1387.                                              NULL, FALSE, FALSE);
  1388.       transdata = g_malloc (sizeof (*transdata));
  1389.       transdata->transfer = tdata;
  1390.       transdata->curfle = templist;
  1391.       gtk_ctree_node_set_row_data (GTK_CTREE (dlwdw), tempfle->node, transdata);
  1392.     }
  1394.   if (!tdata->toreq->stopable && tdata->toreq->need_userpass &&
  1395.       (tdata->toreq->password == NULL || *tdata->toreq->password == ''))
  1396.     {
  1397.       tdata->toreq->stopable = 1;
  1398.       MakeEditDialog (_("Enter Password"),
  1399.       _("Please enter your password for this site"), NULL, 0,
  1400.       NULL, gftp_dialog_button_connect, 
  1401.                       get_trans_password, tdata->toreq,
  1402.       cancel_get_trans_password, tdata);
  1403.     }
  1405.   if (!tdata->fromreq->stopable && tdata->fromreq->need_userpass &&
  1406.       (tdata->fromreq->password == NULL || *tdata->fromreq->password == ''))
  1407.     {
  1408.       tdata->fromreq->stopable = 1;
  1409.       MakeEditDialog (_("Enter Password"),
  1410.       _("Please enter your password for this site"), NULL, 0,
  1411.       NULL, gftp_dialog_button_connect, 
  1412.                       get_trans_password, tdata->fromreq,
  1413.       cancel_get_trans_password, tdata);
  1414.     }
  1415. }
  1418. static void
  1419. transfer_done (GList * node)
  1420. {
  1421.   gftp_curtrans_data * transdata;
  1422.   gftp_request * fromreq;
  1423.   gftp_transfer * tdata;
  1424.   gftp_file * tempfle;
  1425.   GList * templist;
  1427.   tdata = node->data;
  1428.   if (tdata->started)
  1429.     {
  1430.       fromreq = tdata->fromwdata != NULL ? ((gftp_window_data *) tdata->fromwdata)->request : NULL;
  1431.       if (!tdata->fromreq->stopable && tdata->fromwdata &&
  1432.           ((fromreq->sockfd < 0 && fromreq->cached) || fromreq->always_connected) &&
  1433.           (tdata->fromreq->sockfd > 0 || tdata->fromreq->always_connected) &&
  1434.           compare_request (tdata->fromreq, fromreq, 0))
  1435. {
  1436.           gftp_swap_socks (((gftp_window_data *) tdata->towdata)->request, 
  1437.                            tdata->toreq);
  1438.           gftp_swap_socks (((gftp_window_data *) tdata->fromwdata)->request, 
  1439.                            tdata->fromreq);
  1440. }
  1441.       else
  1442.         {
  1443.   gftp_disconnect (tdata->fromreq);
  1444.           gftp_disconnect (tdata->toreq);
  1445.         }
  1447.       if (tdata->towdata != NULL && compare_request (tdata->toreq, 
  1448.                            ((gftp_window_data *) tdata->towdata)->request, 1)) 
  1449. refresh (tdata->towdata);
  1451.       transfer_in_progress--;
  1452.     }
  1454.   if (!tdata->show && tdata->started)
  1455.     {
  1456.       transdata = gtk_ctree_node_get_row_data (GTK_CTREE (dlwdw), tdata->node);
  1457.       if (transdata != NULL)
  1458.         g_free (transdata);
  1460.       for (templist = tdata->files; templist != NULL; templist = templist->next)
  1461.         {
  1462.           tempfle = templist->data;
  1463.           transdata = gtk_ctree_node_get_row_data (GTK_CTREE (dlwdw), tempfle->node);
  1464.           if (transdata != NULL)
  1465.             g_free (transdata);
  1466.         }
  1467.           
  1468.       gtk_ctree_remove_node (GTK_CTREE (dlwdw), tdata->node);
  1469.     }
  1470.   pthread_mutex_lock (&transfer_mutex);
  1471.   file_transfers = g_list_remove_link (file_transfers, node);
  1472.   pthread_mutex_unlock (&transfer_mutex);
  1473.   pthread_mutex_destroy (tdata->structmutex);
  1474.   pthread_mutex_destroy (tdata->statmutex);
  1475.   free_tdata (tdata);
  1476. }
  1479. static void
  1480. create_transfer (gftp_transfer * tdata)
  1481. {
  1482.   pthread_t tid;
  1484.   if (!tdata->fromreq->stopable)
  1485.     {
  1486.       if (tdata->fromwdata && 
  1487.           (((gftp_window_data *) tdata->fromwdata)->request->sockfd > 0 ||
  1488.            ((gftp_window_data *) tdata->fromwdata)->request->always_connected) && 
  1489.           !((gftp_window_data *) tdata->fromwdata)->request->stopable &&
  1490.           compare_request (tdata->fromreq, ((gftp_window_data *) tdata->fromwdata)->request, 0))
  1491. {
  1492.           gftp_swap_socks (tdata->toreq, 
  1493.                            ((gftp_window_data *) tdata->towdata)->request);
  1494.           gftp_swap_socks (tdata->fromreq, 
  1495.                            ((gftp_window_data *) tdata->fromwdata)->request);
  1496.   update_window_info ();
  1497. }
  1498.       transfer_in_progress++;
  1499.       tdata->started = 1;
  1500.       tdata->stalled = 1;
  1501.       gtk_ctree_node_set_text (GTK_CTREE (dlwdw), tdata->node, 1,
  1502.        _("Connecting..."));
  1503.       pthread_create (&tid, NULL, gftp_gtk_transfer_files, tdata);
  1504.     }
  1505. }
  1508. static void
  1509. update_file_status (gftp_transfer * tdata)
  1510. {
  1511.   char totstr[100], dlstr[100], gotstr[50], ofstr[50];
  1512.   int hours, mins, secs, pcent, st;
  1513.   double remaining;
  1514.   gftp_file * tempfle;
  1515.   struct timeval tv;
  1517.   pthread_mutex_lock (tdata->statmutex);
  1518.   tempfle = tdata->curfle->data;
  1520.   gettimeofday (&tv, NULL);
  1521.   if ((remaining = (double) (tv.tv_sec - tdata->starttime.tv_sec) + ((double) (tv.tv_usec - tdata->starttime.tv_usec) / 1000000.0)) == 0)
  1522.     remaining = 1.0;
  1524.   remaining = ((double) (tdata->total_bytes - tdata->trans_bytes - tdata->resumed_bytes)) / 1024.0 / tdata->kbs;
  1525.   hours = (off_t) remaining / 3600;
  1526.   remaining -= hours * 3600;
  1527.   mins = (off_t) remaining / 60;
  1528.   remaining -= mins * 60;
  1529.   secs = (off_t) remaining;
  1531.   if (hours < 0 || mins < 0 || secs < 0)
  1532.     {
  1533.       pthread_mutex_unlock (tdata->statmutex);
  1534.       return;
  1535.     }
  1537.   pcent = (int) ((double) (tdata->trans_bytes + tdata->resumed_bytes) / (double) tdata->total_bytes * 100.0);
  1538.   if (pcent < 0 || pcent > 100)
  1539.     pcent = 0;
  1541.   g_snprintf (totstr, sizeof (totstr),
  1542. _("%d%% complete, %02d:%02d:%02d est. time remaining. (File %ld of %ld)"),
  1543. pcent, hours, mins, secs, tdata->current_file_number,
  1544. tdata->numdirs + tdata->numfiles);
  1546.   *dlstr = '';
  1547.   if (!tdata->stalled)
  1548.     {
  1549.       insert_commas (tdata->curtrans + tdata->curresumed, gotstr, sizeof (gotstr));
  1550.       insert_commas (tempfle->size, ofstr, sizeof (ofstr));
  1551.       st = 1;
  1552.       if (tv.tv_sec - tdata->lasttime.tv_sec <= 5)
  1553.         {
  1554.           if (tdata->curfle->next != NULL)
  1555.             {
  1556.               remaining = ((double) (tempfle->size - tdata->curtrans - tdata->curresumed)) / 1024.0 / tdata->kbs;
  1557.               hours = (off_t) remaining / 3600;
  1558.               remaining -= hours * 3600;
  1559.               mins = (off_t) remaining / 60;
  1560.               remaining -= mins * 60;
  1561.               secs = (off_t) remaining;
  1562.             }
  1564.           if (!(hours < 0 || mins < 0 || secs < 0))
  1565.             {
  1566.               g_snprintf (dlstr, sizeof (dlstr),
  1567.                           _("Recv %s of %s at %.2fKB/s, %02d:%02d:%02d est. time remaining"), gotstr, ofstr, tdata->kbs, hours, mins, secs);
  1568.               st = 0;
  1569.             }
  1570.         }
  1572.       if (st)
  1573.         {
  1574.           tdata->stalled = 1;
  1575.           g_snprintf (dlstr, sizeof (dlstr),
  1576.      _("Recv %s of %s, transfer stalled, unknown time remaining"),
  1577.   gotstr, ofstr);
  1578.         }
  1579.     }
  1581.   pthread_mutex_unlock (tdata->statmutex);
  1583.   gtk_ctree_node_set_text (GTK_CTREE (dlwdw), tdata->node, 1, totstr);
  1585.   if (*dlstr != '')
  1586.     gtk_ctree_node_set_text (GTK_CTREE (dlwdw), tempfle->node, 1, dlstr);
  1587. }
  1589. static void
  1590. update_window_transfer_bytes (gftp_window_data * wdata)
  1591. {
  1592.   char *tempstr, *temp1str;
  1594.   if (wdata->request->gotbytes == -1)
  1595.     {
  1596.       update_window_info ();
  1597.       wdata->request->gotbytes = 0;
  1598.     }
  1599.   else
  1600.     {
  1601.       tempstr = insert_commas (wdata->request->gotbytes, NULL, 0);
  1602.       temp1str = g_strdup_printf (_("Retrieving file names...%s bytes"), 
  1603.                                   tempstr);
  1604.       gtk_label_set (GTK_LABEL (wdata->hoststxt), temp1str);
  1605.       g_free (tempstr);
  1606.       g_free (temp1str);
  1607.     }
  1608. }
  1611. gint
  1612. update_downloads (gpointer data)
  1613. {
  1614.   GList * templist, * next;
  1615.   gftp_transfer * tdata;
  1617.   if (file_transfer_logs != NULL)
  1618.     display_cached_logs ();
  1620.   if (window1.request->gotbytes != 0)
  1621.     update_window_transfer_bytes (&window1);
  1622.   if (window2.request->gotbytes != 0)
  1623.     update_window_transfer_bytes (&window2);
  1625.   if (viewedit_process_done)
  1626.     check_done_process ();
  1628.   for (templist = file_transfers; templist != NULL;)
  1629.     {
  1630.       tdata = templist->data;
  1631.       if (tdata->ready)
  1632.         {
  1633.           pthread_mutex_lock (tdata->structmutex);
  1635.   if (tdata->next_file)
  1636.     on_next_transfer (tdata);
  1637.         else if (tdata->show) 
  1638.     show_transfer (tdata);
  1639.   else if (tdata->done)
  1640.     {
  1641.       next = templist->next;
  1642.               pthread_mutex_unlock (tdata->structmutex);
  1643.       transfer_done (templist);
  1644.       templist = next;
  1645.       continue;
  1646.     }
  1648.   if (tdata->curfle != NULL)
  1649.     {
  1650.       if (!tdata->started && start_file_transfers &&
  1651.                   (transfer_in_progress == 0 || !do_one_transfer_at_a_time))
  1652.                 create_transfer (tdata);
  1654.       if (tdata->started)
  1655.                 update_file_status (tdata);
  1656.     }
  1657.           pthread_mutex_unlock (tdata->structmutex);
  1658.         }
  1659.       templist = templist->next;
  1660.     }
  1662.   gtk_timeout_add (500, update_downloads, NULL);
  1663.   return (0);
  1664. }
  1667. void
  1668. start_transfer (gpointer data)
  1669. {
  1670.   gftp_curtrans_data * transdata;
  1671.   GtkCTreeNode * node;
  1673.   if (GTK_CLIST (dlwdw)->selection == NULL)
  1674.     {
  1675.       ftp_log (gftp_logging_misc, NULL,
  1676.        _("There are no file transfers selectedn"));
  1677.       return;
  1678.     }
  1679.   node = GTK_CLIST (dlwdw)->selection->data;
  1680.   transdata = gtk_ctree_node_get_row_data (GTK_CTREE (dlwdw), node);
  1682.   pthread_mutex_lock (transdata->transfer->structmutex);
  1683.   if (!transdata->transfer->started)
  1684.     create_transfer (transdata->transfer);
  1685.   pthread_mutex_unlock (transdata->transfer->structmutex);
  1686. }
  1689. void
  1690. stop_transfer (gpointer data)
  1691. {
  1692.   gftp_curtrans_data * transdata;
  1693.   GtkCTreeNode * node;
  1695.   if (GTK_CLIST (dlwdw)->selection == NULL)
  1696.     {
  1697.       ftp_log (gftp_logging_misc, NULL,
  1698.       _("There are no file transfers selectedn"));
  1699.       return;
  1700.     }
  1701.   node = GTK_CLIST (dlwdw)->selection->data;
  1702.   transdata = gtk_ctree_node_get_row_data (GTK_CTREE (dlwdw), node);
  1704.   pthread_mutex_lock (transdata->transfer->structmutex);
  1705.   if (transdata->transfer->started)
  1706.     {
  1707.       transdata->transfer->cancel = 1;
  1708.       transdata->transfer->fromreq->cancel = 1;
  1709.       transdata->transfer->toreq->cancel = 1;
  1710.       transdata->transfer->skip_file = 0;
  1711.     }
  1712.   else
  1713.     transdata->transfer->done = 1;
  1714.   pthread_mutex_unlock (transdata->transfer->structmutex);
  1716.   ftp_log (gftp_logging_misc, NULL, _("Stopping the transfer on host %sn"),
  1717.    transdata->transfer->fromreq->hostname);
  1718. }
  1721. void
  1722. skip_transfer (gpointer data)
  1723. {
  1724.   gftp_curtrans_data * transdata;
  1725.   GtkCTreeNode * node;
  1726.   gftp_file * curfle;
  1727.   char *file;
  1729.   if (GTK_CLIST (dlwdw)->selection == NULL)
  1730.     {
  1731.       ftp_log (gftp_logging_misc, NULL,
  1732.       _("There are no file transfers selectedn"));
  1733.       return;
  1734.     }
  1735.   node = GTK_CLIST (dlwdw)->selection->data;
  1736.   transdata = gtk_ctree_node_get_row_data (GTK_CTREE (dlwdw), node);
  1738.   pthread_mutex_lock (transdata->transfer->structmutex);
  1739.   if (transdata->transfer->curfle != NULL)
  1740.     {
  1741.       curfle = transdata->transfer->curfle->data;
  1742.       if (transdata->transfer->started)
  1743.         {
  1744.           transdata->transfer->cancel = 1;
  1745.           transdata->transfer->fromreq->cancel = 1;
  1746.           transdata->transfer->toreq->cancel = 1;
  1747.           transdata->transfer->skip_file = 1;
  1748.         }
  1750.       curfle->transfer_action = GFTP_TRANS_ACTION_SKIP;
  1751.       file = curfle->file;
  1752.     }
  1753.   else
  1754.     file = NULL;
  1755.   pthread_mutex_unlock (transdata->transfer->structmutex);
  1757.   ftp_log (gftp_logging_misc, NULL, _("Skipping file %s on host %sn"), 
  1758.            file, transdata->transfer->fromreq->hostname);
  1759. }
  1762. void
  1763. remove_file_transfer (gpointer data)
  1764. {
  1765.   gftp_curtrans_data * transdata;
  1766.   GtkCTreeNode * node;
  1767.   gftp_file * curfle;
  1769.   if (GTK_CLIST (dlwdw)->selection == NULL)
  1770.     {
  1771.       ftp_log (gftp_logging_misc, NULL,
  1772.               _("There are no file transfers selectedn"));
  1773.       return;
  1774.     }
  1776.   node = GTK_CLIST (dlwdw)->selection->data;
  1777.   transdata = gtk_ctree_node_get_row_data (GTK_CTREE (dlwdw), node);
  1780.   if (transdata->curfle == NULL || transdata->curfle->data == NULL)
  1781.     return;
  1783.   curfle = transdata->curfle->data;
  1785.   if (curfle->transfer_action & GFTP_TRANS_ACTION_SKIP)
  1786.     return;
  1788.   pthread_mutex_lock (transdata->transfer->structmutex);
  1790.   curfle->transfer_action = GFTP_TRANS_ACTION_SKIP;
  1792.   if (transdata->transfer->started &&
  1793.       transdata->curfle == transdata->transfer->curfle)
  1794.     {
  1795.       transdata->transfer->cancel = 1;
  1796.       transdata->transfer->fromreq->cancel = 1;
  1797.       transdata->transfer->toreq->cancel = 1;
  1798.       transdata->transfer->skip_file = 1;
  1799.     }
  1800.   else if (transdata->curfle != transdata->transfer->curfle &&
  1801.            !curfle->transfer_done)
  1802.     {
  1803.       gtk_ctree_node_set_text (GTK_CTREE (dlwdw), curfle->node, 1,
  1804.                                _("Skipped"));
  1805.       transdata->transfer->total_bytes -= curfle->size;
  1806.     }
  1808.   pthread_mutex_unlock (transdata->transfer->structmutex);
  1810.   ftp_log (gftp_logging_misc, NULL, _("Skipping file %s on host %sn"),
  1811.            curfle->file, transdata->transfer->fromreq->hostname);
  1812. }
  1815. void
  1816. move_transfer_up (gpointer data)
  1817. {
  1818.   GList * firstentry, * secentry, * lastentry;
  1819.   gftp_curtrans_data * transdata;
  1820.   GtkCTreeNode * node;
  1822.   if (GTK_CLIST (dlwdw)->selection == NULL)
  1823.     {
  1824.       ftp_log (gftp_logging_misc, NULL,
  1825.       _("There are no file transfers selectedn"));
  1826.       return;
  1827.     }
  1828.   node = GTK_CLIST (dlwdw)->selection->data;
  1829.   transdata = gtk_ctree_node_get_row_data (GTK_CTREE (dlwdw), node);
  1831.   if (transdata->curfle == NULL)
  1832.     return;
  1834.   pthread_mutex_lock (transdata->transfer->structmutex);
  1835.   if (transdata->curfle->prev != NULL && (!transdata->transfer->started ||
  1836.       (transdata->transfer->curfle != transdata->curfle && 
  1837.        transdata->transfer->curfle != transdata->curfle->prev)))
  1838.     {
  1839.       if (transdata->curfle->prev->prev == NULL)
  1840.         {
  1841.           firstentry = transdata->curfle->prev;
  1842.           lastentry = transdata->curfle->next;
  1843.           transdata->transfer->files = transdata->curfle;
  1844.           transdata->curfle->next = firstentry;
  1845.           transdata->transfer->files->prev = NULL;
  1846.           firstentry->prev = transdata->curfle;
  1847.           firstentry->next = lastentry;
  1848.           if (lastentry != NULL)
  1849.             lastentry->prev = firstentry;
  1850.         }
  1851.       else
  1852.         {
  1853.           firstentry = transdata->curfle->prev->prev;
  1854.           secentry = transdata->curfle->prev;
  1855.           lastentry = transdata->curfle->next;
  1856.           firstentry->next = transdata->curfle;
  1857.           transdata->curfle->prev = firstentry;
  1858.           transdata->curfle->next = secentry;
  1859.           secentry->prev = transdata->curfle;
  1860.           secentry->next = lastentry;
  1861.           if (lastentry != NULL)
  1862.             lastentry->prev = secentry;
  1863.         }
  1865.       gtk_ctree_move (GTK_CTREE (dlwdw), 
  1866.                       ((gftp_file *) transdata->curfle->data)->node,
  1867.                       transdata->transfer->node, 
  1868.                       transdata->curfle->next != NULL ?
  1869.                           ((gftp_file *) transdata->curfle->next->data)->node :
  1870.                           NULL);
  1871.     }
  1872.   pthread_mutex_unlock (transdata->transfer->structmutex);
  1873. }
  1875. void
  1876. move_transfer_down (gpointer data)
  1877. {
  1878.   GList * firstentry, * secentry, * lastentry;
  1879.   gftp_curtrans_data * transdata;
  1880.   GtkCTreeNode * node;
  1882.   if (GTK_CLIST (dlwdw)->selection == NULL)
  1883.     {
  1884.       ftp_log (gftp_logging_misc, NULL,
  1885.       _("There are no file transfers selectedn"));
  1886.       return;
  1887.     }
  1888.   node = GTK_CLIST (dlwdw)->selection->data;
  1889.   transdata = gtk_ctree_node_get_row_data (GTK_CTREE (dlwdw), node);
  1891.   if (transdata->curfle == NULL)
  1892.     return;
  1894.   pthread_mutex_lock (transdata->transfer->structmutex);
  1895.   if (transdata->curfle->next != NULL && (!transdata->transfer->started ||
  1896.       (transdata->transfer->curfle != transdata->curfle && 
  1897.        transdata->transfer->curfle != transdata->curfle->next)))
  1898.     {
  1899.       if (transdata->curfle->prev == NULL)
  1900.         {
  1901.           firstentry = transdata->curfle->next;
  1902.           lastentry = transdata->curfle->next->next;
  1903.           transdata->transfer->files = firstentry;
  1904.           transdata->transfer->files->prev = NULL;
  1905.           transdata->transfer->files->next = transdata->curfle;
  1906.           transdata->curfle->prev = transdata->transfer->files;
  1907.           transdata->curfle->next = lastentry;
  1908.           if (lastentry != NULL)
  1909.             lastentry->prev = transdata->curfle;
  1910.         }
  1911.       else
  1912.         {
  1913.           firstentry = transdata->curfle->prev;
  1914.           secentry = transdata->curfle->next;
  1915.           lastentry = transdata->curfle->next->next;
  1916.           firstentry->next = secentry;
  1917.           secentry->prev = firstentry;
  1918.           secentry->next = transdata->curfle;
  1919.           transdata->curfle->prev = secentry;
  1920.           transdata->curfle->next = lastentry;
  1921.           if (lastentry != NULL)
  1922.             lastentry->prev = transdata->curfle;
  1923.         }
  1925.       gtk_ctree_move (GTK_CTREE (dlwdw), 
  1926.                       ((gftp_file *) transdata->curfle->data)->node,
  1927.                       transdata->transfer->node, 
  1928.                       transdata->curfle->next != NULL ?
  1929.                           ((gftp_file *) transdata->curfle->next->data)->node :
  1930.                           NULL);
  1931.     }
  1932.   pthread_mutex_unlock (transdata->transfer->structmutex);
  1933. }
  1936. static void
  1937. trans_selectall (GtkWidget * widget, gpointer data)
  1938. {
  1939.   gftp_transfer * tdata;
  1940.   tdata = data;
  1942.   gtk_clist_select_all (GTK_CLIST (tdata->clist));
  1943. }
  1946. static void
  1947. trans_unselectall (GtkWidget * widget, gpointer data)
  1948. {
  1949.   gftp_transfer * tdata;
  1950.   tdata = data;
  1952.   gtk_clist_unselect_all (GTK_CLIST (tdata->clist));
  1953. }
  1956. static void
  1957. overwrite (GtkWidget * widget, gpointer data)
  1958. {
  1959.   GList * templist, * filelist;
  1960.   gftp_transfer * tdata;
  1961.   gftp_file * tempfle;
  1962.   int curpos;
  1964.   tdata = data;
  1965.   curpos = 0;
  1966.   filelist = tdata->files;
  1967.   templist = GTK_CLIST (tdata->clist)->selection;
  1968.   while (templist != NULL)
  1969.     {
  1970.       templist = get_next_selection (templist, &filelist, &curpos);
  1971.       tempfle = filelist->data;
  1972.       tempfle->transfer_action = GFTP_TRANS_ACTION_OVERWRITE;
  1973.       gtk_clist_set_text (GTK_CLIST (tdata->clist), curpos, 3, _("Overwrite"));
  1974.     }
  1975. }
  1978. static void
  1979. resume (GtkWidget * widget, gpointer data)
  1980. {
  1981.   GList * templist, * filelist;
  1982.   gftp_transfer * tdata;
  1983.   gftp_file * tempfle;
  1984.   int curpos;
  1986.   tdata = data;
  1987.   curpos = 0;
  1988.   filelist = tdata->files;
  1989.   templist = GTK_CLIST (tdata->clist)->selection;
  1990.   while (templist != NULL)
  1991.     {
  1992.       templist = get_next_selection (templist, &filelist, &curpos);
  1993.       tempfle = filelist->data;
  1994.       tempfle->transfer_action = GFTP_TRANS_ACTION_RESUME;
  1995.       gtk_clist_set_text (GTK_CLIST (tdata->clist), curpos, 3, _("Resume"));
  1996.     }
  1997. }
  2000. static void
  2001. skip (GtkWidget * widget, gpointer data)
  2002. {
  2003.   GList * templist, * filelist;
  2004.   gftp_transfer * tdata;
  2005.   gftp_file * tempfle;
  2006.   int curpos;
  2008.   tdata = data;
  2009.   curpos = 0;
  2010.   filelist = tdata->files;
  2011.   templist = GTK_CLIST (tdata->clist)->selection;
  2012.   while (templist != NULL)
  2013.     {
  2014.       templist = get_next_selection (templist, &filelist, &curpos);
  2015.       tempfle = filelist->data;
  2016.       tempfle->transfer_action = GFTP_TRANS_ACTION_SKIP;
  2017.       gtk_clist_set_text (GTK_CLIST (tdata->clist), curpos, 3, _("Skip"));
  2018.     }
  2019. }
  2022. static void
  2023. ok (GtkWidget * widget, gpointer data)
  2024. {
  2025.   gftp_transfer * tdata;
  2026.   gftp_file * tempfle;
  2027.   GList * templist;
  2029.   tdata = data;
  2030.   pthread_mutex_lock ((pthread_mutex_t *) tdata->structmutex);
  2031.   for (templist = tdata->files; templist != NULL; templist = templist->next)
  2032.     {
  2033.       tempfle = templist->data;
  2034.       if (tempfle->transfer_action != GFTP_TRANS_ACTION_SKIP)
  2035.         break;
  2036.     }
  2038.   if (templist == NULL)
  2039.     {
  2040.       tdata->show = 0; 
  2041.       tdata->ready = tdata->done = 1;
  2042.     }
  2043.   else
  2044.     tdata->show = tdata->ready = 1;
  2045.   pthread_mutex_unlock ((pthread_mutex_t *) tdata->structmutex);
  2046. }
  2049. static void
  2050. cancel (GtkWidget * widget, gpointer data)
  2051. {
  2052.   gftp_transfer * tdata;
  2054.   tdata = data;
  2055.   pthread_mutex_lock ((pthread_mutex_t *) tdata->structmutex);
  2056.   tdata->show = 0;
  2057.   tdata->done = tdata->ready = 1;
  2058.   pthread_mutex_unlock ((pthread_mutex_t *) tdata->structmutex);
  2059. }
  2062. #if GTK_MAJOR_VERSION > 1
  2063. static void
  2064. transfer_action (GtkWidget * widget, gint response, gpointer user_data)
  2065. {
  2066.   switch (response)
  2067.     {
  2068.       case GTK_RESPONSE_OK:
  2069.         ok (widget, user_data);
  2070.         gtk_widget_destroy (widget);
  2071.         break;
  2072.       case GTK_RESPONSE_CANCEL:
  2073.         cancel (widget, user_data);
  2074.         /* no break */
  2075.       default:
  2076.         gtk_widget_destroy (widget);
  2077.     }
  2078. }   
  2079. #endif
  2082. void
  2083. gftp_gtk_ask_transfer (gftp_transfer * tdata)
  2084. {
  2085.   char *dltitles[4], *add_data[4] = { NULL, NULL, NULL, NULL },
  2086.        tempstr[50], temp1str[50], *pos, *title;
  2087.   GtkWidget * tempwid, * scroll, * hbox;
  2088.   gftp_file * tempfle;
  2089.   GList * templist;
  2090.   size_t len;
  2091.   int i;
  2093.   dltitles[0] = _("Filename");
  2094.   dltitles[1] = _("Local Size");
  2095.   dltitles[2] = _("Remote Size");
  2096.   dltitles[3] = _("Action");
  2097.   title = tdata->transfer_direction == GFTP_DIRECTION_DOWNLOAD ?  
  2098.                                _("Download Files") : _("Upload Files");
  2100. #if GTK_MAJOR_VERSION == 1
  2101.   dialog = gtk_dialog_new ();
  2102.   gtk_grab_add (dialog);
  2103.   gtk_window_set_title (GTK_WINDOW (dialog), title);
  2104.   gtk_container_border_width (GTK_CONTAINER (GTK_DIALOG (dialog)->action_area), 5);
  2105.   gtk_box_set_spacing (GTK_BOX (GTK_DIALOG (dialog)->action_area), 35);
  2106.   gtk_box_set_homogeneous (GTK_BOX (GTK_DIALOG (dialog)->action_area), TRUE);
  2108.   gtk_signal_connect_object (GTK_OBJECT (dialog), "delete_event",
  2109.                              GTK_SIGNAL_FUNC (gtk_widget_destroy),
  2110.                              GTK_OBJECT (dialog));
  2111. #else
  2112.   dialog = gtk_dialog_new_with_buttons (title, NULL, 0, 
  2113.                                         GTK_STOCK_OK,
  2114.                                         GTK_RESPONSE_OK,
  2115.                                         GTK_STOCK_CANCEL,
  2116.                                         GTK_RESPONSE_CANCEL,
  2117.                                         NULL);
  2118. #endif
  2119.   gtk_window_set_wmclass (GTK_WINDOW(dialog), "transfer", "gFTP");
  2120.   gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE);
  2121.   gtk_container_border_width (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), 10);
  2122.   gtk_box_set_spacing (GTK_BOX (GTK_DIALOG (dialog)->vbox), 5);
  2124.   tempwid = gtk_label_new (_("The following file(s) exist on both the local and remote computernPlease select what you would like to do"));
  2125.   gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), tempwid, FALSE,
  2126.       FALSE, 0);
  2127.   gtk_widget_show (tempwid);
  2129.   scroll = gtk_scrolled_window_new (NULL, NULL);
  2130.   gtk_widget_set_size_request (scroll, 450, 200);
  2132.   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll),
  2133.   GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
  2134.   tdata->clist = gtk_clist_new_with_titles (4, dltitles);
  2135.   gtk_container_add (GTK_CONTAINER (scroll), tdata->clist);
  2137. #if GTK_MAJOR_VERSION == 1
  2138.   gtk_clist_set_selection_mode (GTK_CLIST (tdata->clist),
  2139. GTK_SELECTION_EXTENDED);
  2140. #else
  2141.   gtk_clist_set_selection_mode (GTK_CLIST (tdata->clist),
  2142. GTK_SELECTION_MULTIPLE);
  2143. #endif
  2144.   gtk_clist_set_column_width (GTK_CLIST (tdata->clist), 0, 100);
  2145.   gtk_clist_set_column_justification (GTK_CLIST (tdata->clist), 1,
  2146.       GTK_JUSTIFY_RIGHT);
  2147.   gtk_clist_set_column_width (GTK_CLIST (tdata->clist), 1, 85);
  2148.   gtk_clist_set_column_justification (GTK_CLIST (tdata->clist), 2,
  2149.       GTK_JUSTIFY_RIGHT);
  2150.   gtk_clist_set_column_width (GTK_CLIST (tdata->clist), 2, 85);
  2151.   gtk_clist_set_column_width (GTK_CLIST (tdata->clist), 3, 85);
  2152.   gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), scroll, TRUE, TRUE,
  2153.       0);
  2154.   gtk_widget_show (tdata->clist);
  2155.   gtk_widget_show (scroll);
  2157.   for (templist = tdata->files; templist != NULL; 
  2158.        templist = templist->next)
  2159.     {
  2160.       tempfle = templist->data;
  2161.       if (tempfle->startsize == 0 || tempfle->isdir)
  2162.         {
  2163.            tempfle->shown = 0;
  2164.            continue;
  2165.         }
  2166.       tempfle->shown = 1;
  2168.       pos = tempfle->destfile;
  2169.       len = strlen (GFTP_GET_DIRECTORY (tdata->toreq));
  2170.       if (strncmp (pos, GFTP_GET_DIRECTORY (tdata->toreq), len) == 0)
  2171.         pos = tempfle->destfile + len + 1;
  2172.       add_data[0] = pos;
  2174.       if (overwrite_by_default)
  2175.         add_data[3] = _("Overwrite");
  2176.       else
  2177.         {
  2178.           if (tempfle->startsize >= tempfle->size)
  2179.             {
  2180.               add_data[3] = _("Skip");
  2181.               tempfle->transfer_action = GFTP_TRANS_ACTION_SKIP;
  2182.             }
  2183.           else
  2184.             {
  2185.               add_data[3] = _("Resume");
  2186.               tempfle->transfer_action = GFTP_TRANS_ACTION_RESUME;
  2187.             }
  2188.         }
  2190.       if (tdata->transfer_direction == GFTP_DIRECTION_DOWNLOAD)
  2191.         {
  2192.           add_data[2] = insert_commas (tempfle->size, tempstr,
  2193.                                        sizeof (tempstr));
  2194.           add_data[1] = insert_commas (tempfle->startsize, temp1str,
  2195.                                        sizeof (temp1str));
  2196.         }
  2197.       else
  2198.         {
  2199.           add_data[1] = insert_commas (tempfle->size, tempstr,
  2200.                                        sizeof (tempstr));
  2201.           add_data[2] = insert_commas (tempfle->startsize, temp1str,
  2202.                                        sizeof (temp1str));
  2203.         }
  2204.       i = gtk_clist_append (GTK_CLIST (tdata->clist), add_data);
  2205.       gtk_clist_set_row_data (GTK_CLIST (tdata->clist), i, tempfle);
  2206.     }
  2208.   gtk_clist_select_all (GTK_CLIST (tdata->clist));
  2210.   hbox = gtk_hbox_new (TRUE, 20);
  2211.   gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), hbox, TRUE, TRUE, 0);
  2212.   gtk_widget_show (hbox);
  2214.   tempwid = gtk_button_new_with_label (_("Overwrite"));
  2215.   gtk_box_pack_start (GTK_BOX (hbox), tempwid, TRUE, TRUE, 0);
  2216.   gtk_signal_connect (GTK_OBJECT (tempwid), "clicked",
  2217.       GTK_SIGNAL_FUNC (overwrite), (gpointer) tdata);
  2218.   gtk_widget_show (tempwid);
  2220.   tempwid = gtk_button_new_with_label (_("Resume"));
  2221.   gtk_box_pack_start (GTK_BOX (hbox), tempwid, TRUE, TRUE, 0);
  2222.   gtk_signal_connect (GTK_OBJECT (tempwid), "clicked",
  2223.       GTK_SIGNAL_FUNC (resume), (gpointer) tdata);
  2224.   gtk_widget_show (tempwid);
  2226.   tempwid = gtk_button_new_with_label (_("Skip File"));
  2227.   gtk_box_pack_start (GTK_BOX (hbox), tempwid, TRUE, TRUE, 0);
  2228.   gtk_signal_connect (GTK_OBJECT (tempwid), "clicked", GTK_SIGNAL_FUNC (skip),
  2229.       (gpointer) tdata);
  2230.   gtk_widget_show (tempwid);
  2232.   hbox = gtk_hbox_new (TRUE, 20);
  2233.   gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), hbox, TRUE, TRUE, 0);
  2234.   gtk_widget_show (hbox);
  2236.   tempwid = gtk_button_new_with_label (_("Select All"));
  2237.   gtk_box_pack_start (GTK_BOX (hbox), tempwid, TRUE, TRUE, 0);
  2238.   gtk_signal_connect (GTK_OBJECT (tempwid), "clicked",
  2239.       GTK_SIGNAL_FUNC (trans_selectall), (gpointer) tdata);
  2240.   gtk_widget_show (tempwid);
  2242.   tempwid = gtk_button_new_with_label (_("Deselect All"));
  2243.   gtk_box_pack_start (GTK_BOX (hbox), tempwid, TRUE, TRUE, 0);
  2244.   gtk_signal_connect (GTK_OBJECT (tempwid), "clicked",
  2245.       GTK_SIGNAL_FUNC (trans_unselectall), (gpointer) tdata);
  2246.   gtk_widget_show (tempwid);
  2248. #if GTK_MAJOR_VERSION == 1
  2249.   tempwid = gtk_button_new_with_label (_("OK"));
  2250.   GTK_WIDGET_SET_FLAGS (tempwid, GTK_CAN_DEFAULT);
  2251.   gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->action_area), tempwid,
  2252.       TRUE, TRUE, 0);
  2253.   gtk_signal_connect (GTK_OBJECT (tempwid), "clicked", GTK_SIGNAL_FUNC (ok),
  2254.       (gpointer) tdata);
  2255.   gtk_signal_connect_object (GTK_OBJECT (tempwid), "clicked",
  2256.      GTK_SIGNAL_FUNC (gtk_widget_destroy),
  2257.      GTK_OBJECT (dialog));
  2258.   gtk_widget_grab_default (tempwid);
  2259.   gtk_widget_show (tempwid);
  2261.   tempwid = gtk_button_new_with_label (_("  Cancel  "));
  2262.   GTK_WIDGET_SET_FLAGS (tempwid, GTK_CAN_DEFAULT);
  2263.   gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->action_area), tempwid,
  2264.       TRUE, TRUE, 0);
  2265.   gtk_signal_connect (GTK_OBJECT (tempwid), "clicked",
  2266.       GTK_SIGNAL_FUNC (cancel), (gpointer) tdata);
  2267.   gtk_signal_connect_object (GTK_OBJECT (tempwid), "clicked",
  2268.      GTK_SIGNAL_FUNC (gtk_widget_destroy),
  2269.      GTK_OBJECT (dialog));
  2270.   gtk_widget_show (tempwid);
  2271. #else
  2272.   g_signal_connect (GTK_OBJECT (dialog), "response",
  2273.                     G_CALLBACK (transfer_action), (gpointer) tdata);
  2274. #endif
  2276.   gtk_widget_show (dialog);
  2277.   dialog = NULL;
  2278. }