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

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

Ftp客户端

开发平台：

Visual C++

misc.c：源码内容
  1. /*****************************************************************************/
  2. /*  misc.c - general purpose routines                                        */
  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., 59 Temple Place - Suite 330, Boston, MA 02111 USA      */
  18. /*****************************************************************************/
  20. #include "gftp.h"
  21. #include "options.h"
  22. static const char cvsid[] = "$Id: misc.c,v 1.16 2002/12/06 02:28:19 masneyb Exp $";
  24. char *
  25. insert_commas (off_t number, char *dest_str, size_t dest_len)
  26. {
  27.   char *frompos, *topos, src[50], *dest;
  28.   int len, num, rem, i;
  30.   if (dest_str != NULL)
  31.     *dest_str = '';
  32.   len = (number > 0 ? log10 (number) : 0) + 2;
  34.   if (len <= 0) 
  35.     {
  36.       if (dest_str != NULL)
  37.         strncpy (dest_str, "0", dest_len);
  38.       else
  39.         dest_str = g_strdup ("0");
  40.       return (dest_str);
  41.     }
  43.   len += len / 3;
  44.   if (dest_str != NULL && len > dest_len)
  45.     {
  46.       
  47.       for (i=0; i<dest_len - 1; i++)
  48.         dest_str[i] = 'X';
  49.       dest_str[dest_len - 1] = '';
  50.       return (dest_str);
  51.     }
  53.   if (dest_str == NULL)
  54.     dest = g_malloc0 (len);
  55.   else
  56.     dest = dest_str;
  58. #if defined (_LARGEFILE_SOURCE)
  59.   g_snprintf (src, sizeof (src), "%lld", number);
  60. #else
  61.   g_snprintf (src, sizeof (src), "%ld", number);
  62. #endif
  64.   num = strlen (src) / 3 - 1;
  65.   rem = strlen (src) % 3;
  66.   frompos = src;
  67.   topos = dest;
  68.   for (i = 0; i < rem; i++)
  69.     *topos++ = *frompos++;
  71.   if (*frompos != '')
  72.     {
  73.       if (rem != 0)
  74. *topos++ = ',';
  75.       while (num > 0)
  76. {
  77.   for (i = 0; i < 3; i++)
  78.     *topos++ = *frompos++;
  79.   *topos++ = ',';
  80.   num--;
  81. }
  82.       for (i = 0; i < 3; i++)
  83. *topos++ = *frompos++;
  84.     }
  85.   *topos = '';
  86.   return (dest);
  87. }
  90. long
  91. file_countlf (int filefd, long endpos)
  92. {
  93.   char tempstr[255];
  94.   long num, mypos;
  95.   ssize_t n;
  96.   int i;
  98.   mypos = num = 0;
  99.   lseek (filefd, 0, SEEK_SET);
  100.   while ((n = read (filefd, tempstr, sizeof (tempstr))) > 0)
  101.     {
  102.       for (i = 0; i < n; i++)
  103. {
  104.   if ((tempstr[i] == 'n') && (i > 0) && (tempstr[i - 1] != 'r')
  105.       && (endpos == 0 || mypos + i <= endpos))
  106.     ++num;
  107. }
  108.       mypos += n;
  109.     }
  110.   lseek (filefd, 0, SEEK_SET);
  111.   return (num);
  112. }
  115. char *
  116. alltrim (char *str)
  117. {
  118.   char *pos, *newpos;
  119.   int diff;
  121.   pos = str + strlen (str) - 1;
  122.   while (pos >= str && *pos == ' ')
  123.     *pos-- = '';
  125.   pos = str;
  126.   diff = 0;
  127.   while (*pos++ == ' ')
  128.     diff++;
  130.   if (diff == 0)
  131.     return (str);
  133.   pos = str + diff;
  134.   newpos = str;
  135.   while (*pos != '')
  136.     *newpos++ = *pos++;
  137.   *newpos = '';
  139.   return (str);
  140. }
  143. char *
  144. expand_path (const char *src)
  145. {
  146.   char *str, *pos, *endpos, *prevpos, *newstr, *tempstr, tempchar;
  147.   struct passwd *pw;
  149.   pw = NULL;
  150.   str = g_malloc (strlen (src) + 1);
  151.   strcpy (str, src);
  153.   if (*str == '~')
  154.     {
  155.       if (*(str + 1) == '/' || *(str + 1) == '')
  156. pw = getpwuid (geteuid ());
  157.       else
  158. {
  159.           if ((pos = strchr (str, '/')) != NULL)
  160.     *pos = '';
  162.   pw = getpwnam (str + 1);
  164.           if (pos != NULL)
  165.             *pos = '/';
  166. }
  167.     }
  169.   endpos = str;
  170.   newstr = NULL;
  171.   while ((pos = strchr (endpos, '/')) != NULL)
  172.     {
  173.       pos++;
  174.       while (*pos == '/')
  175.         pos++;
  176.       if ((endpos = strchr (pos, '/')) == NULL)
  177. endpos = pos + strlen (pos);
  178.       tempchar = *endpos;
  179.       *endpos = '';
  180.       if (strcmp (pos, "..") == 0)
  181. {
  182.   *(pos - 1) = '';
  183.   if (newstr != NULL && (prevpos = strrchr (newstr, '/')) != NULL)
  184.     *prevpos = '';
  185. }
  186.       else if (strcmp (pos, ".") != 0)
  187. {
  188.   if (newstr == NULL)
  189.     newstr = g_strdup (pos - 1);
  190.   else
  191.     {
  192.       tempstr = g_strconcat (newstr, pos - 1, NULL);
  193.       g_free (newstr);
  194.       newstr = tempstr;
  195.     }
  196. }
  197.       *endpos = tempchar;
  198.       if (*endpos == '')
  199. break;
  200.       endpos = pos + 1;
  201.     }
  203.   if (newstr == NULL || *newstr == '')
  204.     {
  205.       if (newstr != NULL)
  206. g_free (newstr);
  207.       newstr = g_malloc0 (2);
  208.       *newstr = '/';
  209.     }
  211.   g_free (str);
  213.   if (pw != NULL)
  214.     {
  215.       if ((pos = strchr (newstr, '/')) == NULL)
  216. {
  217.   str = g_malloc (strlen (pw->pw_dir) + 1);
  218.   strcpy (str, pw->pw_dir);
  219. }
  220.       else
  221. str = g_strconcat (pw->pw_dir, pos, NULL);
  223.       g_free (newstr);
  224.       newstr = str;
  225.     }
  227.   return (newstr);
  228. }
  231. void
  232. remove_double_slashes (char *string)
  233. {
  234.   char *newpos, *oldpos;
  236.   oldpos = newpos = string;
  237.   while (*oldpos != '')
  238.     {
  239.       *newpos++ = *oldpos++;
  240.       if (*oldpos == '')
  241. break;
  242.       while (*(newpos - 1) == '/' && *(oldpos) == '/')
  243. oldpos++;
  244.     }
  245.   *newpos = '';
  246.   if (string[strlen (string) - 1] == '/')
  247.     string[strlen (string) - 1] = '';
  248. }
  251. void
  252. make_nonnull (char **str)
  253. {
  254.   if (*str == NULL)
  255.     *str = g_malloc0 (1);
  256. }
  259. int
  260. copyfile (char *source, char *dest)
  261. {
  262.   int srcfd, destfd;
  263.   char buf[8192];
  264.   ssize_t n;
  266.   if ((srcfd = open (source, O_RDONLY)) == -1)
  267.     {
  268.       printf (_("Error: Cannot open local file %s: %sn"),
  269.               source, g_strerror (errno));
  270.       exit (1);
  271.     }
  273.   if ((destfd = open (dest, O_WRONLY | O_CREAT, S_IRUSR | S_IWUSR)) == -1)
  274.     {
  275.       printf (_("Error: Cannot open local file %s: %sn"),
  276.               dest, g_strerror (errno));
  277.       close (srcfd);
  278.       exit (1);
  279.     }
  281.   while ((n = read (srcfd, buf, sizeof (buf))) > 0)
  282.     {
  283.       if (write (destfd, buf, n) == -1)
  284.         {
  285.           printf (_("Error: Could not write to socket: %sn"), 
  286.                   g_strerror (errno));
  287.           exit (1);
  288.         }
  289.     }
  291.   if (n == -1)
  292.     {
  293.       printf (_("Error: Could not read from socket: %sn"), g_strerror (errno));
  294.       exit (1);
  295.     }
  297.   close (srcfd);
  298.   close (destfd);
  300.   return (1);
  301. }
  304. int
  305. gftp_match_filespec (char *filename, char *filespec)
  306. {
  307.   char *filepos, *wcpos, *pos, *newpos, search_str[20];
  308.   size_t len, curlen;
  309.   
  310.   if (filename == NULL || *filename == '' || 
  311.       filespec == NULL || *filespec == '') 
  312.     return(1);
  314.   filepos = filename;
  315.   wcpos = filespec;
  316.   while(1) 
  317.     {
  318.       if (*wcpos == '') 
  319.         return (1);
  320.       else if (*filepos == '') 
  321.         return(0);
  322.       else if(*wcpos == '?') 
  323.         {
  324.           wcpos++;
  325.           filepos++;
  326.         }
  327.       else if(*wcpos == '*' && *(wcpos+1) == '') 
  328.         return(1);
  329.       else if(*wcpos == '*') 
  330.         {
  331.           len = sizeof (search_str);
  332.           for (pos = wcpos + 1, newpos = search_str, curlen = 0;
  333.                *pos != '*' && *pos != '?' && *pos != '' && curlen < len;
  334.                curlen++, *newpos++ = *pos++);
  335.           *newpos = '';
  337.           if ((filepos = strstr (filepos, search_str)) == NULL)
  338.             return(0);
  339.           wcpos += curlen + 1;
  340.           filepos += curlen;
  341.         }
  342.       else if(*wcpos++ != *filepos++) 
  343.         return(0);
  344.     }
  345.   return (1);
  346. }
  349. int
  350. gftp_parse_command_line (int *argc, char ***argv)
  351. {
  352.   if (*argc > 1)
  353.     {
  354.       if (strcmp (argv[0][1], "--help") == 0 || strcmp (argv[0][1], "-h") == 0)
  355. gftp_usage ();
  356.       else if (strcmp (argv[0][1], "--version") == 0 || strcmp (argv[0][1], "-v") == 0)
  357. {
  358.   printf ("%sn", version);
  359.   exit (0);
  360. }
  361.     }
  362.   return (0);
  363. }
  366. void
  367. gftp_usage (void)
  368. {
  369.   printf (_("usage: gftp [[ftp://][user:[pass]@]ftp-site[:port][/directory]]n"));
  370.   exit (0);
  371. }
  374. char *
  375. get_xpm_path (char *filename, int quit_on_err)
  376. {
  377.   char *tempstr, *exfile;
  379.   tempstr = g_strconcat (BASE_CONF_DIR, "/", filename, NULL);
  380.   exfile = expand_path (tempstr);
  381.   g_free (tempstr);
  382.   if (access (exfile, F_OK) != 0)
  383.     {
  384.       g_free (exfile);
  385.       tempstr = g_strconcat (SHARE_DIR, "/", filename, NULL);
  386.       exfile = expand_path (tempstr);
  387.       g_free (tempstr);
  388.       if (access (exfile, F_OK) != 0)
  389. {
  390.   g_free (exfile);
  391.   exfile = g_strconcat ("/usr/share/icons/", filename, NULL);
  392.   if (access (exfile, F_OK) != 0)
  393.     {
  394.       g_free (exfile);
  395.       if (!quit_on_err)
  396. return (NULL);
  397.       printf (_("gFTP Error: Cannot find file %s in %s or %sn"),
  398.       filename, SHARE_DIR, BASE_CONF_DIR);
  399.       exit (-1);
  400.     }
  401. }
  402.     }
  403.   return (exfile);
  404. }
  407. gint
  408. string_hash_compare (gconstpointer path1, gconstpointer path2)
  409. {
  410.   return (strcmp ((char *) path1, (char *) path2) == 0);
  411. }
  414. guint
  415. string_hash_function (gconstpointer key)
  416. {
  417.   guint ret;
  418.   int i;
  420.   ret = 0;
  421.   for (i=0; ((char *) key)[0] != '' && i < 3; i++)
  422.     ret += ((char *) key)[i];
  424.   return (ret);
  425. }
  428. void
  429. free_file_list (GList * filelist)
  430. {
  431.   gftp_file * tempfle;
  432.   GList * templist;
  434.   templist = filelist;
  435.   while (templist != NULL)
  436.     {
  437.       tempfle = templist->data;
  438.       free_fdata (tempfle);
  439.       templist = templist->next;
  440.     }
  441.   g_list_free (filelist);
  442. }
  445. void
  446. free_fdata (gftp_file * fle)
  447. {
  448.   if (fle->file)
  449.     g_free (fle->file);
  450.   if (fle->user)
  451.     g_free (fle->user);
  452.   if (fle->group)
  453.     g_free (fle->group);
  454.   if (fle->attribs)
  455.     g_free (fle->attribs);
  456.   if (fle->destfile)
  457.     g_free (fle->destfile);
  458.   if (fle->fd > 0)
  459.     close (fle->fd);
  460.   g_free (fle);
  461. }
  464. gftp_file *
  465. copy_fdata (gftp_file * fle)
  466. {
  467.   gftp_file * newfle;
  469.   newfle = g_malloc0 (sizeof (*newfle));
  470.   memcpy (newfle, fle, sizeof (*newfle));
  472.   if (fle->file)
  473.     {
  474.       newfle->file = g_malloc (strlen (fle->file) + 1);
  475.       strcpy (newfle->file, fle->file);
  476.     }
  478.   if (fle->user)
  479.     {
  480.       newfle->user = g_malloc (strlen (fle->user) + 1);
  481.       strcpy (newfle->user, fle->user);
  482.     }
  484.   if (fle->group)
  485.     {
  486.       newfle->group = g_malloc (strlen (fle->group) + 1);
  487.       strcpy (newfle->group, fle->group);
  488.     }
  490.   if (fle->attribs)
  491.     {
  492.       newfle->attribs = g_malloc (strlen (fle->attribs) + 1);
  493.       strcpy (newfle->attribs, fle->attribs);
  494.     }
  496.   if (fle->destfile)
  497.     {
  498.       newfle->destfile = g_malloc (strlen (fle->destfile) + 1);
  499.       strcpy (newfle->destfile, fle->destfile);
  500.     }
  501.   return (newfle);
  502. }
  505. int
  506. compare_request (gftp_request * request1, gftp_request * request2,
  507.                  int compare_dirs)
  508. {
  509.   char *strarr[3][2];
  510.   int i, ret;
  512.   ret = 1;
  513.   if (strcmp (request1->protocol_name, request2->protocol_name) == 0 &&
  514.       request1->port == request2->port)
  515.     {
  516.       strarr[0][0] = request1->hostname;
  517.       strarr[0][1] = request2->hostname;
  518.       strarr[1][0] = request1->username;
  519.       strarr[1][1] = request2->username;
  520.       if (compare_dirs)
  521.         {
  522.           strarr[2][0] = request1->directory;
  523.           strarr[2][1] = request2->directory;
  524.         }
  525.       else
  526.         strarr[2][0] = strarr[2][1] = "";
  528.       for (i = 0; i < 3; i++)
  529.         {
  530.           if ((strarr[i][0] && !strarr[i][1]) ||
  531.               (!strarr[i][0] && strarr[i][1]))
  532.             {
  533.               ret = 0;
  534.               break;
  535.             }
  537.           if (strarr[i][0] && strarr[i][1] &&
  538.               strcmp (strarr[i][0], strarr[i][1]) != 0)
  539.             {
  540.               ret = 0;
  541.               break;
  542.             }
  543.         }
  544.     }
  545.   else
  546.     ret = 0;
  547.   return (ret);
  548. }
  551. void
  552. free_tdata (gftp_transfer * tdata)
  553. {
  554.   if (tdata->statmutex)
  555.     g_free (tdata->statmutex);
  556.   if (tdata->structmutex)
  557.     g_free (tdata->structmutex);
  558.   if (tdata->fromreq != NULL)
  559.     gftp_request_destroy (tdata->fromreq, 1);
  560.   if (tdata->toreq != NULL)
  561.     gftp_request_destroy (tdata->toreq, 1);
  562.   free_file_list (tdata->files);
  563.   g_free (tdata);
  564. }
  567. gftp_request * 
  568. copy_request (gftp_request * req)
  569. {
  570.   gftp_request * newreq;
  572.   newreq = gftp_request_new ();
  574.   if (req->hostname)
  575.     newreq->hostname = g_strdup (req->hostname);
  576.   if (req->username)
  577.     newreq->username = g_strdup (req->username);
  578.   if (req->password)
  579.     newreq->password = g_strdup (req->password);
  580.   if (req->account)
  581.     newreq->account = g_strdup (req->account);
  582.   if (req->directory)
  583.     newreq->directory = g_strdup (req->directory);
  584.   newreq->port = req->port;
  585.   newreq->data_type = req->data_type;
  586.   newreq->use_proxy = req->use_proxy;
  587.   gftp_set_proxy_config (newreq, req->proxy_config);
  588.   newreq->transfer_type = req->transfer_type;
  589.   newreq->network_timeout = req->network_timeout;
  590.   newreq->retries = req->retries;
  591.   newreq->sleep_time = req->sleep_time;
  592.   newreq->passive_transfer = req->passive_transfer;
  593.   newreq->maxkbs = req->maxkbs;
  594.   newreq->logging_function = req->logging_function;
  596.   if (req->sftpserv_path != NULL)
  597.     newreq->sftpserv_path = g_strdup (req->sftpserv_path);
  599.   req->init (newreq);
  601.   return (newreq);
  602. }
  605. int
  606. ptym_open (char *pts_name)
  607. {
  608.   int fd;
  610. #ifdef __sgi
  611.   char *tempstr;
  613.   if ((tempstr = _getpty (&fd, O_RDWR, 0600, 0)) == NULL)
  614.     return (-1);
  616.   strcpy (pts_name, tempstr);
  617.   return (fd);
  619. #else /* !__sgi */
  621. #ifdef SYSV
  623.   char *tempstr;
  625.   strcpy (pts_name, "/dev/ptmx");
  626.   if ((fd = open (pts_name, O_RDWR)) < 0)
  627.     return (-1);
  629.   if (grantpt (fd) < 0)
  630.     {
  631.       close (fd);
  632.       return (-1);
  633.     }
  635.   if (unlockpt (fd) < 0)
  636.     {
  637.       close (fd);
  638.       return (-1);
  639.     }
  641.   if ((tempstr = ptsname (fd)) == NULL)
  642.     {
  643.       close (fd);
  644.       return (-1);
  645.     }
  647.   strcpy (pts_name, tempstr);
  648.   return (fd);
  650. #else /* !SYSV */
  652.   char *pos1, *pos2;
  654.   strcpy (pts_name, "/dev/ptyXY");
  655.   for (pos1 = "pqrstuvwxyzPQRST"; *pos1 != ''; pos1++) 
  656.     {
  657.       pts_name[8] = *pos1;
  658.       for (pos2 = "0123456789abcdef"; *pos2 != ''; pos2++)
  659.         {
  660.           pts_name[9] = *pos2;
  661.           if ((fd = open (pts_name, O_RDWR)) < 0)
  662.             continue;
  663.           pts_name[5] = 't';
  664.           return (fd);
  665.         }
  666.     }
  667.   return (-1);
  669. #endif
  671. #endif
  673. }
  676. int
  677. ptys_open (int fdm, char *pts_name)
  678. {
  679.   int fds;
  681. #if !defined (SYSV) && !defined (__sgi)
  683.   chmod (pts_name, S_IRUSR | S_IWUSR);
  684.   chown (pts_name, getuid (), -1);
  686. #endif
  688.   if ((fds = open (pts_name, O_RDWR)) < 0)
  689.     {
  690.       close (fdm);
  691.       return (-1);
  692.     }
  694. #ifdef SYSV
  696.   if (ioctl (fds, I_PUSH, "ptem") < 0)
  697.     {
  698.       close (fdm);
  699.       close (fds);
  700.       return (-1);
  701.     }
  703.   if (ioctl (fds, I_PUSH, "ldterm") < 0)
  704.     {
  705.       close (fdm);
  706.       close (fds);
  707.       return (-1);
  708.     }
  710.   if (ioctl (fds, I_PUSH, "ttcompat") < 0)
  711.     {
  712.       close (fdm);
  713.       close (fds);
  714.       return (-1);
  715.     }
  717. #endif
  719. #if !defined(SYSV) && !defined (__sgi) && defined(TIOCSCTTY) && !defined(CIBAUD)
  721.   if (ioctl (fds, TIOCSCTTY, (char *) 0) < 0)
  722.     {
  723.       close (fdm);
  724.       return (-1);
  725.     }
  727. #endif
  729.   return (fds);
  730. }
  733. int
  734. tty_raw (int fd)
  735. {
  736.   struct termios buf;
  738.   if (tcgetattr (fd, &buf) < 0)
  739.     return (-1);
  741.   buf.c_iflag |= IGNPAR;
  742.   buf.c_iflag &= ~(ICRNL | ISTRIP | IXON | IGNCR | IXANY | IXOFF | INLCR);
  743.   buf.c_lflag &= ~(ECHO | ICANON | ISIG | ECHOE | ECHOK | ECHONL);
  744. #ifdef IEXTEN
  745.   buf.c_lflag &= ~(IEXTEN);
  746. #endif
  748.   buf.c_oflag &= ~(OPOST);
  749.   buf.c_cc[VMIN] = 1;
  750.   buf.c_cc[VTIME] = 0;
  752.   if (tcsetattr (fd, TCSADRAIN, &buf) < 0)
  753.     return (-1);
  754.   return (0);
  755. }
  758. /* We have the caller send us a pointer to a string so we can write the port
  759.    into it. It makes it easier so we don't have to worry about freeing it 
  760.    later on, the caller can just send us an auto variable, The string
  761.    should be at least 6 chars. I know this is messy... */
  763. char **
  764. make_ssh_exec_args (gftp_request * request, char *execname, 
  765.                     int use_sftp_subsys, char *portstring)
  766. {
  767.   char **args, *oldstr, *tempstr;
  768.   struct servent serv_struct;
  769.   int i, j;
  771.   args = g_malloc (sizeof (char *) * (num_ssh_extra_params + 15));
  773.   args[0] = ssh_prog_name != NULL && *ssh_prog_name != '' ? 
  774.             ssh_prog_name : "ssh";
  775.   i = 1;
  776.   tempstr = g_strdup (args[0]);
  778.   if (ssh_extra_params_list != NULL)
  779.     {
  780.       for (j=0; ssh_extra_params_list[j] != NULL; j++)
  781.         {
  782.           oldstr = tempstr;
  783.           args[i++] = ssh_extra_params_list[j];
  784.           tempstr = g_strconcat (oldstr, " ", ssh_extra_params_list[j], NULL);
  785.           g_free (oldstr);
  786.         }
  787.     }
  789.   oldstr = tempstr;
  790.   tempstr = g_strconcat (oldstr, " -e none", NULL);
  791.   g_free (oldstr);
  792.   args[i++] = "-e";
  793.   args[i++] = "none";
  795.   if (request->username && *request->username != '')
  796.     {
  797.       oldstr = tempstr;
  798.       tempstr = g_strconcat (oldstr, " -l ", request->username, NULL);
  799.       g_free (oldstr);
  800.       args[i++] = "-l";
  801.       args[i++] = request->username;
  802.     }
  804.   if (request->port != 0)
  805.     {
  806.       g_snprintf (portstring, 6, "%d", request->port);
  807.       oldstr = tempstr;
  808.       tempstr = g_strconcat (oldstr, " -p ", portstring, NULL);
  809.       g_free (oldstr);
  810.       args[i++] = "-p";
  811.       args[i++] = portstring;
  812.     }
  813.   else
  814.     {
  815.       if (!r_getservbyname ("ssh", "tcp", &serv_struct, NULL))
  816.         request->port = 22;
  817.       else
  818.         request->port = ntohs (serv_struct.s_port);
  819.     }
  821.   if (use_sftp_subsys)
  822.     {
  823.       oldstr = tempstr;
  824.       tempstr = g_strconcat (oldstr, " ", request->hostname, " -s sftp", NULL);
  825.       g_free (oldstr);
  826.       args[i++] = request->hostname;
  827.       args[i++] = "-s";
  828.       args[i++] = "sftp";
  829.       args[i] = NULL;
  830.     }
  831.   else
  832.     {
  833.       oldstr = tempstr;
  834.       tempstr = g_strconcat (oldstr, " ", request->hostname, " "", execname, 
  835.                              """, NULL);
  836.       g_free (oldstr);
  837.       args[i++] = request->hostname;
  838.       args[i++] = execname;
  839.       args[i] = NULL;
  840.     }
  842.   request->logging_function (gftp_logging_misc, request->user_data, 
  843.                              _("Running program %sn"), tempstr);
  844.   g_free (tempstr);
  845.   return (args);
  846. }
  848. #define SSH_LOGIN_BUFSIZE 200
  849. #define SSH_ERROR_BADPASS -1
  850. #define SSH_ERROR_QUESTION -2
  851. #define SSH_WARNING  -3
  853. char *
  854. ssh_start_login_sequence (gftp_request * request, int fd)
  855. {
  856.   char *tempstr, *pwstr, *tmppos;
  857.   size_t rem, len, diff, lastdiff, key_pos;
  858.   int wrotepw, ok;
  859.   ssize_t rd;
  861.   rem = len = SSH_LOGIN_BUFSIZE;
  862.   tempstr = g_malloc0 (len + 1);
  863.   key_pos = diff = lastdiff = 0;
  864.   wrotepw = 0;
  865.   ok = 1;
  867.   if (gftp_set_sockblocking (request, fd, 1) == -1)
  868.     return (NULL);
  870.   pwstr = g_strconcat (request->password, "n", NULL);
  872.   errno = 0;
  873.   while (1)
  874.     {
  875.       if ((rd = gftp_read (request, tempstr + diff, rem - 1, fd)) <= 0)
  876.         {
  877.           ok = 0;
  878.           break;
  879.         }
  880.       rem -= rd;
  881.       diff += rd;
  882.       tempstr[diff] = ''; 
  884.       if (diff > 11 && strcmp (tempstr + diff - 10, "password: ") == 0)
  885.         {
  886.           if (wrotepw)
  887.             {
  888.               ok = SSH_ERROR_BADPASS;
  889.               break;
  890.             }
  892.           if (strstr (tempstr, "WARNING") != NULL ||
  893.               strstr (tempstr, _("WARNING")) != NULL)
  894.             {
  895.               ok = SSH_WARNING;
  896.               break;
  897.             }
  898.               
  899.           wrotepw = 1;
  900.           if (gftp_write (request, pwstr, strlen (pwstr), fd) < 0)
  901.             {
  902.               ok = 0;
  903.               break;
  904.             }
  905.         }
  906.       else if (diff > 2 && strcmp (tempstr + diff - 2, ": ") == 0 &&
  907.                ((tmppos = strstr (tempstr + key_pos, "Enter passphrase for RSA key")) != NULL ||
  908.                 ((tmppos = strstr (tempstr + key_pos, "Enter passphrase for key '")) != NULL)))
  909.         {
  910.           key_pos = diff;
  911.           if (wrotepw)
  912.             {
  913.               ok = SSH_ERROR_BADPASS;
  914.               break;
  915.             }
  917.           if (strstr (tempstr, "WARNING") != NULL ||
  918.               strstr (tempstr, _("WARNING")) != NULL)
  919.             {
  920.               ok = SSH_WARNING;
  921.               break;
  922.             }
  924.           wrotepw = 1;
  925.           if (gftp_write (request, pwstr, strlen (pwstr), fd) < 0)
  926.             {
  927.               ok = 0;
  928.               break;
  929.             }
  930.         }
  931.       else if (diff > 10 && strcmp (tempstr + diff - 10, "(yes/no)? ") == 0)
  932.         {
  933.           ok = SSH_ERROR_QUESTION;
  934.           break;
  935.         }
  936.       else if (diff >= 5 && strcmp (tempstr + diff - 5, "xsftp") == 0)
  937.         break;
  938.       else if (rem <= 1)
  939.         {
  940.           request->logging_function (gftp_logging_recv, request->user_data,
  941.                                      "%s", tempstr + lastdiff);
  942.           len += SSH_LOGIN_BUFSIZE;
  943.           rem += SSH_LOGIN_BUFSIZE;
  944.           lastdiff = diff;
  945.           tempstr = g_realloc (tempstr, len);
  946.           continue;
  947.         }
  948.     }
  950.   g_free (pwstr);
  952.   if (*(tempstr + lastdiff) != '')
  953.     request->logging_function (gftp_logging_recv, request->user_data,
  954.                                "%sn", tempstr + lastdiff);
  956.   if (ok <= 0)
  957.     {
  958.       if (ok == SSH_ERROR_BADPASS)
  959.         request->logging_function (gftp_logging_error, request->user_data,
  960.                                _("Error: An incorrect password was enteredn"));
  961.       else if (ok == SSH_ERROR_QUESTION)
  962.         request->logging_function (gftp_logging_error, request->user_data,
  963.                                _("Please connect to this host with the command line SSH utility and answer this question appropriately.n"));
  964.       else if (ok == SSH_WARNING)
  965.         request->logging_function (gftp_logging_error, request->user_data,
  966.                                    _("Please correct the above warning to connect to this host.n"));
  968.       g_free (tempstr);
  969.       return (NULL);
  970.     }
  971.  
  972.   return (tempstr);
  973. }
  976. #ifdef G_HAVE_GINT64
  978. gint64
  979. hton64 (gint64 val)
  980. {
  981.   gint64 num;
  982.   char *pos;
  984.   num = 0;
  985.   pos = (char *) &num;
  986.   pos[0] = (val >> 56) & 0xff;
  987.   pos[1] = (val >> 48) & 0xff;
  988.   pos[2] = (val >> 40) & 0xff;
  989.   pos[3] = (val >> 32) & 0xff;
  990.   pos[4] = (val >> 24) & 0xff;
  991.   pos[5] = (val >> 16) & 0xff;
  992.   pos[6] = (val >> 8) & 0xff;
  993.   pos[7] = val & 0xff;
  994.   return (num);
  995. }
  997. #endif
  1000. static gint
  1001. gftp_file_sort_function_as (gconstpointer a, gconstpointer b)
  1002. {
  1003.   const gftp_file * f1, * f2;
  1005.   f1 = a;
  1006.   f2 = b;
  1007.   return (strcmp (f1->file, f2->file));
  1008. }
  1011. static gint
  1012. gftp_file_sort_function_ds (gconstpointer a, gconstpointer b)
  1013. {
  1014.   const gftp_file * f1, * f2;
  1015.   gint ret;
  1017.   f1 = a;
  1018.   f2 = b;
  1019.   ret = strcmp (f1->file, f2->file);
  1020.   if (ret < 0)
  1021.     ret = 1;
  1022.   else if (ret > 0)
  1023.     ret = -1;
  1024.   return (ret);
  1025. }
  1028. static gint
  1029. gftp_user_sort_function_as (gconstpointer a, gconstpointer b)
  1030. {
  1031.   const gftp_file * f1, * f2;
  1033.   f1 = a;
  1034.   f2 = b;
  1035.   return (strcmp (f1->user, f2->user));
  1036. }
  1039. static gint
  1040. gftp_user_sort_function_ds (gconstpointer a, gconstpointer b)
  1041. {
  1042.   const gftp_file * f1, * f2;
  1043.   gint ret;
  1045.   f1 = a;
  1046.   f2 = b;
  1047.   ret = strcmp (f1->user, f2->user);
  1048.   if (ret < 0)
  1049.     ret = 1;
  1050.   else if (ret > 0)
  1051.     ret = -1;
  1052.   return (ret);
  1053. }
  1056. static gint
  1057. gftp_group_sort_function_as (gconstpointer a, gconstpointer b)
  1058. {
  1059.   const gftp_file * f1, * f2;
  1061.   f1 = a;
  1062.   f2 = b;
  1063.   return (strcmp (f1->group, f2->group));
  1064. }
  1067. static gint
  1068. gftp_group_sort_function_ds (gconstpointer a, gconstpointer b)
  1069. {
  1070.   const gftp_file * f1, * f2;
  1071.   gint ret;
  1073.   f1 = a;
  1074.   f2 = b;
  1075.   ret = strcmp (f1->group, f2->group);
  1076.   if (ret < 0)
  1077.     ret = 1;
  1078.   else if (ret > 0)
  1079.     ret = -1;
  1080.   return (ret);
  1081. }
  1084. static gint
  1085. gftp_attribs_sort_function_as (gconstpointer a, gconstpointer b)
  1086. {
  1087.   const gftp_file * f1, * f2;
  1089.   f1 = a;
  1090.   f2 = b;
  1091.   return (strcmp (f1->attribs, f2->attribs));
  1092. }
  1095. static gint
  1096. gftp_attribs_sort_function_ds (gconstpointer a, gconstpointer b)
  1097. {
  1098.   const gftp_file * f1, * f2;
  1099.   gint ret;
  1101.   f1 = a;
  1102.   f2 = b;
  1103.   ret = strcmp (f1->attribs, f2->attribs);
  1104.   if (ret < 0)
  1105.     ret = 1;
  1106.   else if (ret > 0)
  1107.     ret = -1;
  1108.   return (ret);
  1109. }
  1112. static gint
  1113. gftp_size_sort_function_as (gconstpointer a, gconstpointer b)
  1114. {
  1115.   const gftp_file * f1, * f2;
  1117.   f1 = a;
  1118.   f2 = b;
  1119.   if (f1->size < f2->size)
  1120.     return (-1);
  1121.   else if (f1->size == f2->size)
  1122.     return (0);
  1123.   else
  1124.     return (1);
  1125. }
  1128. static gint
  1129. gftp_size_sort_function_ds (gconstpointer a, gconstpointer b)
  1130. {
  1131.   const gftp_file * f1, * f2;
  1133.   f1 = a;
  1134.   f2 = b;
  1135.   if (f1->size < f2->size)
  1136.     return (1);
  1137.   else if (f1->size == f2->size)
  1138.     return (0);
  1139.   else
  1140.     return (-1);
  1141. }
  1144. static gint
  1145. gftp_datetime_sort_function_as (gconstpointer a, gconstpointer b)
  1146. {
  1147.   const gftp_file * f1, * f2;
  1149.   f1 = a;
  1150.   f2 = b;
  1151.   if (f1->datetime < f2->datetime)
  1152.     return (-1);
  1153.   else if (f1->datetime == f2->datetime)
  1154.     return (0);
  1155.   else
  1156.     return (1);
  1157. }
  1160. static gint
  1161. gftp_datetime_sort_function_ds (gconstpointer a, gconstpointer b)
  1162. {
  1163.   const gftp_file * f1, * f2;
  1165.   f1 = a;
  1166.   f2 = b;
  1167.   if (f1->datetime < f2->datetime)
  1168.     return (1);
  1169.   else if (f1->datetime == f2->datetime)
  1170.     return (0);
  1171.   else
  1172.     return (-1);
  1173. }
  1176. GList *
  1177. gftp_sort_filelist (GList * filelist, int column, int asds)
  1178. {
  1179.   GList * files, * dirs, * dotdot, * tempitem, * insitem;
  1180.   GCompareFunc sortfunc;
  1181.   gftp_file * tempfle;
  1183.   files = dirs = dotdot = NULL;
  1185.   if (column == GFTP_SORT_COL_FILE)
  1186.     sortfunc = asds ?  gftp_file_sort_function_as : gftp_file_sort_function_ds;
  1187.   else if (column == GFTP_SORT_COL_SIZE)
  1188.     sortfunc = asds ?  gftp_size_sort_function_as : gftp_size_sort_function_ds;
  1189.   else if (column == GFTP_SORT_COL_USER)
  1190.     sortfunc = asds ?  gftp_user_sort_function_as : gftp_user_sort_function_ds;
  1191.   else if (column == GFTP_SORT_COL_GROUP)
  1192.     sortfunc = asds ?
  1193.                 gftp_group_sort_function_as : gftp_group_sort_function_ds;
  1194.   else if (column == GFTP_SORT_COL_DATETIME)
  1195.     sortfunc = asds ?
  1196.                 gftp_datetime_sort_function_as : gftp_datetime_sort_function_ds;  else /* GFTP_SORT_COL_ATTRIBS */
  1197.     sortfunc = asds ? 
  1198.                 gftp_attribs_sort_function_as : gftp_attribs_sort_function_ds;
  1200.   for (tempitem = filelist; tempitem != NULL; )
  1201.     {
  1202.       tempfle = tempitem->data;
  1203.       insitem = tempitem;
  1204.       tempitem = tempitem->next;
  1205.       insitem->next = NULL;
  1207.       if (dotdot == NULL && strcmp (tempfle->file, "..") == 0)
  1208.         dotdot = insitem;
  1209.       else if (sort_dirs_first && tempfle->isdir)
  1210.         {
  1211.           insitem->next = dirs;
  1212.           dirs = insitem;
  1213.         }
  1214.       else
  1215.         {
  1216.           insitem->next = files;
  1217.           files = insitem;
  1218.         }
  1219.     }
  1221.   if (dirs != NULL)
  1222.     dirs = g_list_sort (dirs, sortfunc);
  1223.   if (files != NULL)
  1224.     files = g_list_sort (files, sortfunc);
  1226.   filelist = dotdot;
  1228.   if (filelist == NULL)
  1229.     filelist = dirs;
  1230.   else
  1231.     filelist = g_list_concat (filelist, dirs);
  1233.   if (filelist == NULL)
  1234.     filelist = files;
  1235.   else
  1236.     filelist = g_list_concat (filelist, files);
  1238.   /* I haven't check this, but I'm pretty sure some older versions of glib
  1239.      had a bug that the prev pointer wasn't being sent to NULL */
  1240.   filelist->prev = NULL;
  1241.   return (filelist);
  1242. }