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

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

Ftp客户端

开发平台：

Visual C++

rfc959.c：源码内容
  1. /*****************************************************************************/
  2. /*  rfc959.c - General purpose routines for the FTP protocol (RFC 959)       */
  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. static const char cvsid[] = "$Id: rfc959.c,v 1.12 2002/11/23 13:45:04 masneyb Exp $";
  23. typedef struct rfc959_params_tag
  24. {
  25.   gftp_getline_buffer * sockfd_rbuf,
  26.                       * datafd_rbuf;
  27. } rfc959_parms;
  30. static int
  31. rfc959_read_response (gftp_request * request)
  32. {
  33.   char tempstr[255], code[4];
  34.   rfc959_parms * parms;
  35.   ssize_t num_read;
  37.   g_return_val_if_fail (request != NULL, -2);
  38.   g_return_val_if_fail (request->protonum == GFTP_FTP_NUM, -2);
  39.   g_return_val_if_fail (request->sockfd > 0, -2);
  41.   *code = '';
  42.   if (request->last_ftp_response)
  43.     {
  44.       g_free (request->last_ftp_response);
  45.       request->last_ftp_response = NULL;
  46.     }
  48.   parms = request->protocol_data;
  50.   do
  51.     {
  52.       if ((num_read = gftp_get_line (request, &parms->sockfd_rbuf, tempstr, 
  53.                                      sizeof (tempstr), request->sockfd)) <= 0)
  54. break;
  56.       if (isdigit ((int) *tempstr) && isdigit ((int) *(tempstr + 1))
  57.   && isdigit ((int) *(tempstr + 2)))
  58. {
  59.   strncpy (code, tempstr, 3);
  60.   code[3] = ' ';
  61. }
  62.       request->logging_function (gftp_logging_recv, request->user_data,
  63.  "%sn", tempstr);
  64.     }
  65.   while (strncmp (code, tempstr, 4) != 0);
  67.   if (num_read < 0)
  68.     return (-1);
  70.   request->last_ftp_response = g_malloc (strlen (tempstr) + 1);
  71.   strcpy (request->last_ftp_response, tempstr);
  73.   if (request->last_ftp_response[0] == '4' &&
  74.       request->last_ftp_response[1] == '2')
  75.     gftp_disconnect (request);
  77.   return (*request->last_ftp_response);
  78. }
  81. static int
  82. rfc959_send_command (gftp_request * request, const char *command)
  83. {
  84.   g_return_val_if_fail (request != NULL, -2);
  85.   g_return_val_if_fail (request->protonum == GFTP_FTP_NUM, -2);
  86.   g_return_val_if_fail (command != NULL, -2);
  87.   g_return_val_if_fail (request->sockfd > 0, -2);
  89.   if (strncmp (command, "PASS", 4) == 0)
  90.     {
  91.       request->logging_function (gftp_logging_send, request->user_data, 
  92.                                  "PASS xxxxn");
  93.     }
  94.   else if (strncmp (command, "ACCT", 4) == 0)
  95.     {
  96.       request->logging_function (gftp_logging_send, request->user_data, 
  97.                                  "ACCT xxxxn");
  98.     }
  99.   else
  100.     {
  101.       request->logging_function (gftp_logging_send, request->user_data, "%s",
  102.                                  command);
  103.     }
  105.   if (gftp_write (request, command, strlen (command), 
  106.                    request->sockfd) < 0)
  107.     return (-1);
  109.   return (rfc959_read_response (request));
  110. }
  113. static char *
  114. parse_ftp_proxy_string (gftp_request * request)
  115. {
  116.   char *startpos, *endpos, *oldstr, *newstr, *newval, *tempport;
  118.   g_return_val_if_fail (request != NULL, NULL);
  119.   g_return_val_if_fail (request->protonum == GFTP_FTP_NUM, NULL);
  121.   newstr = g_malloc (1);
  122.   *newstr = '';
  123.   startpos = endpos = request->proxy_config;
  124.   while (*endpos != '')
  125.     {
  126.       tempport = NULL;
  127.       if (*endpos == '%' && tolower ((int) *(endpos + 1)) == 'p')
  128. {
  129.   switch (tolower ((int) *(endpos + 2)))
  130.     {
  131.     case 'u':
  132.       newval = request->proxy_username;
  133.       break;
  134.     case 'p':
  135.       newval = request->proxy_password;
  136.       break;
  137.     case 'h':
  138.       newval = request->proxy_hostname;
  139.       break;
  140.     case 'o':
  141.       tempport = g_strdup_printf ("%d", request->proxy_port);
  142.       newval = tempport;
  143.       break;
  144.     case 'a':
  145.       newval = request->proxy_account;
  146.       break;
  147.     default:
  148.       endpos++;
  149.       continue;
  150.     }
  151. }
  152.       else if (*endpos == '%' && tolower ((int) *(endpos + 1)) == 'h')
  153. {
  154.   switch (tolower ((int) *(endpos + 2)))
  155.     {
  156.     case 'u':
  157.       newval = request->username;
  158.       break;
  159.     case 'p':
  160.       newval = request->password;
  161.       break;
  162.     case 'h':
  163.       newval = request->hostname;
  164.       break;
  165.     case 'o':
  166.       tempport = g_strdup_printf ("%d", request->port);
  167.       newval = tempport;
  168.       break;
  169.     case 'a':
  170.       newval = request->account;
  171.       break;
  172.     default:
  173.       endpos++;
  174.       continue;
  175.     }
  176. }
  177.       else if (*endpos == '%' && tolower ((int) *(endpos + 1)) == 'n')
  178. {
  179.   *endpos = '';
  180.   oldstr = newstr;
  181.   newstr = g_strconcat (oldstr, startpos, "rn", NULL);
  182.   g_free (oldstr);
  183.   endpos += 2;
  184.   startpos = endpos;
  185.   continue;
  186. }
  187.       else
  188. {
  189.   endpos++;
  190.   continue;
  191. }
  193.       *endpos = '';
  194.       oldstr = newstr;
  195.       if (!newval)
  196. newstr = g_strconcat (oldstr, startpos, NULL);
  197.       else
  198. newstr = g_strconcat (oldstr, startpos, newval, NULL);
  199.       if (tempport)
  200. {
  201.   g_free (tempport);
  202.   tempport = NULL;
  203. }
  204.       g_free (oldstr);
  205.       endpos += 3;
  206.       startpos = endpos;
  207.     }
  208.   return (newstr);
  209. }
  212. static int
  213. rfc959_getcwd (gftp_request * request)
  214. {
  215.   char *pos, *dir;
  216.   int ret;
  218.   ret = rfc959_send_command (request, "PWDrn");
  219.   if (ret < 0)
  220.     return (-1);
  221.   else if (ret != '2')
  222.     {
  223.       request->logging_function (gftp_logging_error, request->user_data,
  224.  _("Received invalid response to PWD command: '%s'n"),
  225.                                  request->last_ftp_response);
  226.       gftp_disconnect (request);
  227.       return (-2);
  228.     }
  230.   if ((pos = strchr (request->last_ftp_response, '"')) == NULL)
  231.     {
  232.       request->logging_function (gftp_logging_error, request->user_data,
  233.  _("Received invalid response to PWD command: '%s'n"),
  234.                                  request->last_ftp_response);
  235.       gftp_disconnect (request);
  236.       return (-2);
  237.     }
  239.   dir = pos + 1;
  241.   if ((pos = strchr (dir, '"')) == NULL)
  242.     {
  243.       request->logging_function (gftp_logging_error, request->user_data,
  244.  _("Received invalid response to PWD command: '%s'n"),
  245.                                  request->last_ftp_response);
  246.       gftp_disconnect (request);
  247.       return (-2);
  248.     }
  250.   *pos = '';
  252.   if (request->directory)
  253.     g_free (request->directory);
  255.   request->directory = g_malloc (strlen (dir) + 1);
  256.   strcpy (request->directory, dir);
  257.   return (0);
  258. }
  261. static int
  262. rfc959_chdir (gftp_request * request, const char *directory)
  263. {
  264.   char ret, *tempstr;
  266.   g_return_val_if_fail (request != NULL, -2);
  267.   g_return_val_if_fail (request->protonum == GFTP_FTP_NUM, -2);
  268.   g_return_val_if_fail (directory != NULL, -2);
  270.   if (strcmp (directory, "..") == 0)
  271.     ret = rfc959_send_command (request, "CDUPrn");
  272.   else
  273.     {
  274.       tempstr = g_strconcat ("CWD ", directory, "rn", NULL);
  275.       ret = rfc959_send_command (request, tempstr);
  276.       g_free (tempstr);
  277.     }
  279.   if (ret != '2')
  280.     return (-2);
  282.   if (directory != request->directory)
  283.     {
  284.       if (rfc959_getcwd (request) < 0)
  285.         return (-1);
  286.     }
  288.   return (0);
  289. }
  292. static int
  293. rfc959_connect (gftp_request * request)
  294. {
  295.   char tempchar, *startpos, *endpos, *tempstr;
  296.   int ret, resp;
  298.   g_return_val_if_fail (request != NULL, -2);
  299.   g_return_val_if_fail (request->protonum == GFTP_FTP_NUM, -2);
  300.   g_return_val_if_fail (request->hostname != NULL, -2);
  302.   if (request->sockfd > 0)
  303.     return (0);
  305.   if (request->username == NULL || *request->username == '')
  306.     {
  307.       gftp_set_username (request, "anonymous");
  308.       gftp_set_password (request, emailaddr);
  309.     }
  310.   else if (strcasecmp (request->username, "anonymous") == 0)
  311.     gftp_set_password (request, emailaddr);
  312.     
  313.   if ((request->sockfd = gftp_connect_server (request, "ftp")) < 0)
  314.     return (-1);
  316.   /* Get the banner */
  317.   if (rfc959_read_response (request) != '2')
  318.     {
  319.       gftp_disconnect (request);
  320.       return (-2);
  321.     }
  323.   /* Login the proxy server if available */
  324.   if (request->use_proxy)
  325.     {
  326.       resp = '3';
  327.       startpos = endpos = tempstr = parse_ftp_proxy_string (request);
  328.       while ((resp == '3' || resp == '2') && *startpos != '')
  329. {
  330.   if (*endpos == 'n' || *endpos == '')
  331.     {
  332.       tempchar = *(endpos + 1);
  333.       if (*endpos != '')
  334. *(endpos + 1) = '';
  335.       if ((resp = rfc959_send_command (request, startpos)) < 0)
  336.                 return (-2);
  337.       if (*endpos != '')
  338. *(endpos + 1) = tempchar;
  339.       else
  340. break;
  341.       startpos = endpos + 1;
  342.     }
  343.   endpos++;
  344. }
  345.       g_free (tempstr);
  346.     }
  347.   else
  348.     {
  349.       tempstr = g_strconcat ("USER ", request->username, "rn", NULL);
  350.       resp = rfc959_send_command (request, tempstr);
  351.       g_free (tempstr);
  352.       if (resp < 0)
  353.         return (-2);
  354.       if (resp == '3')
  355. {
  356.   tempstr = g_strconcat ("PASS ", request->password, "rn", NULL);
  357.   resp = rfc959_send_command (request, tempstr);
  358.   g_free (tempstr);
  359.           if (resp < 0)
  360.             return (-2);
  361.         }
  362.       if (resp == '3' && request->account)
  363. {
  364.   tempstr = g_strconcat ("ACCT ", request->account, "rn", NULL);
  365.   resp = rfc959_send_command (request, tempstr);
  366.   g_free (tempstr);
  367.           if (resp < 0)
  368.             return (-2);
  369. }
  370.     }
  372.   if (resp != '2')
  373.     {
  374.       gftp_disconnect (request);
  375.       return (-2);
  376.     }
  378.   if (request->data_type == GFTP_TYPE_BINARY)
  379.     tempstr = "TYPE Irn";
  380.   else
  381.     tempstr = "TYPE Arn";
  383.   if (rfc959_send_command (request, tempstr) < 0)
  384.     return (-2);
  386.   ret = -1;
  387.   if (request->directory != NULL && *request->directory != '')
  388.     {
  389.       ret = rfc959_chdir (request, request->directory);
  390.       if (request->sockfd < 0)
  391.         return (-2);
  392.     }
  394.   if (ret != 0)
  395.     {
  396.       if (rfc959_getcwd (request) < 0)
  397.         return (-1);
  398.     }
  400.   if (request->sockfd < 0)
  401.     return (-2);
  403.   return (0);
  404. }
  407. static void
  408. rfc959_disconnect (gftp_request * request)
  409. {
  410.   g_return_if_fail (request != NULL);
  411.   g_return_if_fail (request->protonum == GFTP_FTP_NUM);
  413.   if (request->sockfd > 0)
  414.     {
  415.       request->logging_function (gftp_logging_misc, request->user_data,
  416.  _("Disconnecting from site %sn"),
  417.  request->hostname);
  418.       close (request->sockfd);
  419.       request->sockfd = -1;
  420.       if (request->datafd > 0)
  421. {
  422.   close (request->datafd);
  423.   request->datafd = -1;
  424. }
  425.     }
  426. }
  429. static int
  430. rfc959_data_connection_new (gftp_request * request)
  431. {
  432.   char *pos, *pos1, resp, *command;
  433.   struct sockaddr_in data_addr;
  434.   size_t data_addr_len;
  435.   unsigned int temp[6];
  436.   unsigned char ad[6];
  437.   int i;
  439.   g_return_val_if_fail (request != NULL, -2);
  440.   g_return_val_if_fail (request->protonum == GFTP_FTP_NUM, -2);
  441.   g_return_val_if_fail (request->sockfd > 0, -2);
  443.   if ((request->datafd = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
  444.     {
  445.       request->logging_function (gftp_logging_error, request->user_data,
  446.  _("Failed to create a socket: %sn"),
  447.  g_strerror (errno));
  448.       gftp_disconnect (request);
  449.       return (-1);
  450.     }
  452.   data_addr_len = sizeof (data_addr);
  453.   memset (&data_addr, 0, data_addr_len);
  454.   data_addr.sin_family = AF_INET;
  456.   if (request->transfer_type == gftp_transfer_passive)
  457.     {
  458.       if ((resp = rfc959_send_command (request, "PASVrn")) != '2')
  459. {
  460.           if (request->sockfd < 0)
  461.             return (-2);
  463.   request->transfer_type = gftp_transfer_active;
  464.   return (rfc959_data_connection_new (request));
  465. }
  467.       pos = request->last_ftp_response + 4;
  468.       while (!isdigit ((int) *pos) && *pos != '')
  469.         pos++;
  471.       if (*pos == '')
  472.         {
  473.           request->logging_function (gftp_logging_error, request->user_data,
  474.                       _("Cannot find an IP address in PASV response '%s'n"),
  475.                       request->last_ftp_response);
  476.           gftp_disconnect (request);
  477.           return (-2);
  478.         }
  480.       if (sscanf (pos, "%u,%u,%u,%u,%u,%u", &temp[0], &temp[1], &temp[2],
  481.                   &temp[3], &temp[4], &temp[5]) != 6)
  482.         {
  483.           request->logging_function (gftp_logging_error, request->user_data,
  484.                       _("Cannot find an IP address in PASV response '%s'n"),
  485.                       request->last_ftp_response);
  486.           gftp_disconnect (request);
  487.           return (-2);
  488.         }
  490.       for (i = 0; i < 6; i++)
  491.         ad[i] = (unsigned char) (temp[i] & 0xff);
  493.       memcpy (&data_addr.sin_addr, &ad[0], 4);
  494.       memcpy (&data_addr.sin_port, &ad[4], 2);
  495.       if (connect (request->datafd, (struct sockaddr *) &data_addr, 
  496.                    data_addr_len) == -1)
  497.         {
  498.           request->logging_function (gftp_logging_error, request->user_data,
  499.                                     _("Cannot create a data connection: %sn"),
  500.                                     g_strerror (errno));
  501.           gftp_disconnect (request);
  502.           return (-1);
  503. }
  504.     }
  505.   else
  506.     {
  507.       if (getsockname (request->sockfd, (struct sockaddr *) &data_addr,
  508.                        &data_addr_len) == -1)
  509.         {
  510.   request->logging_function (gftp_logging_error, request->user_data,
  511.      _("Cannot get socket name: %sn"),
  512.      g_strerror (errno));
  513.           gftp_disconnect (request);
  514.   return (-1);
  515.         }
  517.       data_addr.sin_port = 0;
  518.       if (bind (request->datafd, (struct sockaddr *) &data_addr, 
  519.                 data_addr_len) == -1)
  520. {
  521.   request->logging_function (gftp_logging_error, request->user_data,
  522.      _("Cannot bind a port: %sn"),
  523.      g_strerror (errno));
  524.           gftp_disconnect (request);
  525.   return (-1);
  526. }
  528.       if (getsockname (request->datafd, (struct sockaddr *) &data_addr, 
  529.                        &data_addr_len) == -1)
  530.         {
  531.   request->logging_function (gftp_logging_error, request->user_data,
  532.      _("Cannot get socket name: %sn"),
  533.      g_strerror (errno));
  534.           gftp_disconnect (request);
  535.   return (-1);
  536.         }
  538.       if (listen (request->datafd, 1) == -1)
  539. {
  540.   request->logging_function (gftp_logging_error, request->user_data,
  541.      _("Cannot listen on port %d: %sn"),
  542.      ntohs (data_addr.sin_port),
  543.      g_strerror (errno));
  544.           gftp_disconnect (request);
  545.   return (-1);
  546. }
  548.       pos = (char *) &data_addr.sin_addr;
  549.       pos1 = (char *) &data_addr.sin_port;
  550.       command = g_strdup_printf ("PORT %u,%u,%u,%u,%u,%urn",
  551.  pos[0] & 0xff, pos[1] & 0xff, pos[2] & 0xff,
  552.  pos[3] & 0xff, pos1[0] & 0xff,
  553.  pos1[1] & 0xff);
  554.       resp = rfc959_send_command (request, command);
  555.       g_free (command);
  556.       if (resp != '2')
  557. {
  558.           gftp_disconnect (request);
  559.   return (-2);
  560. }
  561.     }
  563.   return (0);
  564. }
  567. static int
  568. rfc959_accept_active_connection (gftp_request * request)
  569. {
  570.   struct sockaddr_in cli_addr;
  571.   size_t cli_addr_len;
  572.   int infd;
  574.   g_return_val_if_fail (request != NULL, -2);
  575.   g_return_val_if_fail (request->protonum == GFTP_FTP_NUM, -2);
  576.   g_return_val_if_fail (request->datafd > 0, -2);
  577.   g_return_val_if_fail (request->transfer_type == gftp_transfer_active, -2);
  579.   cli_addr_len = sizeof (cli_addr);
  581.   if (gftp_set_sockblocking (request, request->datafd, 0) == -1)
  582.     return (-1);
  584.   if ((infd = accept (request->datafd, (struct sockaddr *) &cli_addr,
  585.        &cli_addr_len)) == -1)
  586.     {
  587.       request->logging_function (gftp_logging_error, request->user_data,
  588.                                 _("Cannot accept connection from server: %sn"),
  589.                                 g_strerror (errno));
  590.       gftp_disconnect (request);
  591.       return (-1);
  592.     }
  594.   close (request->datafd);
  596.   request->datafd = infd;
  597.   if (gftp_set_sockblocking (request, request->datafd, 1) == -1)
  598.     return (-1);
  600.   return (0);
  601. }
  604. static off_t
  605. rfc959_get_file (gftp_request * request, const char *filename, int fd,
  606.                  off_t startsize)
  607. {
  608.   char *command, *tempstr, resp;
  609.   int ret;
  611.   g_return_val_if_fail (request != NULL, -2);
  612.   g_return_val_if_fail (request->protonum == GFTP_FTP_NUM, -2);
  613.   g_return_val_if_fail (filename != NULL, -2);
  614.   g_return_val_if_fail (request->sockfd > 0, -2);
  616.   if (fd > 0)
  617.     request->datafd = fd;
  619.   if (request->datafd < 0 && 
  620.       (ret = rfc959_data_connection_new (request)) < 0)
  621.     return (ret);
  623.   if (gftp_set_sockblocking (request, request->datafd, 1) == -1)
  624.     return (-1);
  626.   if (startsize > 0)
  627.     {
  628. #if defined (_LARGEFILE_SOURCE)
  629.       command = g_strdup_printf ("REST %lldrn", startsize); 
  630. #else
  631.       command = g_strdup_printf ("REST %ldrn", startsize); 
  632. #endif
  633.       resp = rfc959_send_command (request, command);
  634.       g_free (command);
  636.       if (resp != '3')
  637.         {
  638.           close (request->datafd);
  639.           request->datafd = -1;
  640.   return (-2);
  641.         }
  642.     }
  644.   tempstr = g_strconcat ("RETR ", filename, "rn", NULL);
  645.   ret = rfc959_send_command (request, tempstr);
  646.   g_free (tempstr);
  648.   if (ret != '1')
  649.     {
  650.       close (request->datafd);
  651.       request->datafd = -1;
  652.       return (-2);
  653.     }
  655.   if (request->transfer_type == gftp_transfer_active &&
  656.       (ret = rfc959_accept_active_connection (request)) < 0)
  657.     return (ret);
  659.   if ((tempstr = strrchr (request->last_ftp_response, '(')) == NULL)
  660.     {
  661.       tempstr = request->last_ftp_response + 4;
  662.       while (!isdigit ((int) *tempstr) && *tempstr != '')
  663. tempstr++;
  664.     }
  665.   else
  666.     tempstr++;
  668.   return (strtol (tempstr, NULL, 10) + startsize);
  669. }
  672. static int
  673. rfc959_put_file (gftp_request * request, const char *filename, int fd,
  674.                  off_t startsize, off_t totalsize)
  675. {
  676.   char *command, *tempstr, resp;
  677.   int ret;
  679.   g_return_val_if_fail (request != NULL, -2);
  680.   g_return_val_if_fail (request->protonum == GFTP_FTP_NUM, -2);
  681.   g_return_val_if_fail (filename != NULL, -2);
  682.   g_return_val_if_fail (request->sockfd > 0, -2);
  684.   if (fd > 0)
  685.     fd = request->datafd;
  687.   if (request->datafd < 0 && 
  688.       (ret = rfc959_data_connection_new (request)) < 0)
  689.     return (ret);
  691.   if (gftp_set_sockblocking (request, request->datafd, 1) == -1)
  692.     return (-1);
  694.   if (startsize > 0)
  695.     {
  696. #if defined (_LARGEFILE_SOURCE)
  697.       command = g_strdup_printf ("REST %lldrn", startsize); 
  698. #else
  699.       command = g_strdup_printf ("REST %ldrn", startsize); 
  700. #endif
  701.       resp = rfc959_send_command (request, command);
  702.       g_free (command);
  703.       if (resp != '3')
  704.         {
  705.           close (request->datafd);
  706.           request->datafd = -1;
  707.   return (-2);
  708.         }
  709.     }
  711.   tempstr = g_strconcat ("STOR ", filename, "rn", NULL);
  712.   ret = rfc959_send_command (request, tempstr);
  713.   g_free (tempstr);
  714.   if (ret != '1')
  715.     {
  716.       close (request->datafd);
  717.       request->datafd = -1;
  718.       return (-2);
  719.     }
  721.   if (request->transfer_type == gftp_transfer_active && 
  722.       (ret = rfc959_accept_active_connection (request)) < 0)
  723.     return (ret);
  725.   return (0);
  726. }
  729. static long 
  730. rfc959_transfer_file (gftp_request *fromreq, const char *fromfile, 
  731.                       off_t fromsize, gftp_request *toreq, 
  732.                       const char *tofile, off_t tosize)
  733. {
  734.   char *tempstr, *pos, *endpos;
  736.   g_return_val_if_fail (fromreq != NULL, -2);
  737.   g_return_val_if_fail (fromfile != NULL, -2);
  738.   g_return_val_if_fail (toreq != NULL, -2);
  739.   g_return_val_if_fail (tofile != NULL, -2);
  740.   g_return_val_if_fail (fromreq->sockfd > 0, -2);
  741.   g_return_val_if_fail (toreq->sockfd > 0, -2);
  743.   fromreq->transfer_type = gftp_transfer_passive;
  744.   toreq->transfer_type = gftp_transfer_active;
  746.   if (rfc959_send_command (fromreq, "PASVrn") != '2')
  747.     return (-2);
  749.   pos = fromreq->last_ftp_response + 4;
  750.   while (!isdigit ((int) *pos) && *pos != '') 
  751.     pos++;
  752.   if (*pos == '') 
  753.     return (-2);
  755.   endpos = pos;
  756.   while (*endpos != ')' && *endpos != '') 
  757.     endpos++;
  758.   if (*endpos == ')') 
  759.     *endpos = '';
  761.   tempstr = g_strconcat ("PORT ", pos, "rn", NULL);
  762.   if (rfc959_send_command (toreq, tempstr) != '2')
  763.      {
  764.        g_free (tempstr);
  765.        return (-2);
  766.      }
  767.   g_free (tempstr);
  769.   tempstr = g_strconcat ("RETR ", fromfile, "rn", NULL);
  770.   if (gftp_write (fromreq, tempstr, strlen (tempstr), 
  771.                    fromreq->sockfd) < 0)
  772.     {
  773.       g_free (tempstr);
  774.       return (-2);
  775.     }
  776.   g_free (tempstr);
  778.   tempstr = g_strconcat ("STOR ", tofile, "rn", NULL);
  779.   if (gftp_write (toreq, tempstr, strlen (tempstr), toreq->sockfd) < 0)
  780.     {
  781.       g_free (tempstr);
  782.       return (-2);
  783.     }
  784.   g_free (tempstr);
  786.   if (rfc959_read_response (fromreq) < 0)
  787.     return (-2);
  788.   if (rfc959_read_response (toreq) < 0)
  789.     return (-2);
  791.   return (0);
  792. }
  795. static int
  796. rfc959_end_transfer (gftp_request * request)
  797. {
  798.   g_return_val_if_fail (request != NULL, -2);
  799.   g_return_val_if_fail (request->protonum == GFTP_FTP_NUM, -2);
  800.   g_return_val_if_fail (request->sockfd > 0, -2);
  802.   if (request->datafd > 0)
  803.     {
  804.       close (request->datafd);
  805.       request->datafd = -1;
  806.     }
  807.   return (rfc959_read_response (request) == '2' ? 0 : -2);
  808. }
  811. static int
  812. rfc959_abort_transfer (gftp_request * request)
  813. {
  814.   int ret;
  816.   g_return_val_if_fail (request != NULL, -2);
  817.   g_return_val_if_fail (request->protonum == GFTP_FTP_NUM, -2);
  818.   g_return_val_if_fail (request->sockfd > 0, -2);
  820.   if (request->datafd > 0)
  821.     {
  822.       close (request->datafd);
  823.       request->datafd = -1;
  824.     }
  826.   /* We need to read two lines of output. The first one is acknowleging
  827.      the transfer and the second line acknowleges the ABOR command */
  828.   if (rfc959_send_command (request, "ABORrn") < 0)
  829.     return (-2);
  831.   if (request->sockfd > 0)
  832.     {
  833.       if ((ret = rfc959_read_response (request)) < 0)
  834.         gftp_disconnect (request);
  835.     }
  836.   
  837.   return (0);
  838. }
  841. static int
  842. rfc959_list_files (gftp_request * request)
  843. {
  844.   char *tempstr, parms[3];
  845.   int ret;
  847.   g_return_val_if_fail (request != NULL, -2);
  848.   g_return_val_if_fail (request->protonum == GFTP_FTP_NUM, -2);
  849.   g_return_val_if_fail (request->sockfd > 0, -2);
  851.   if ((ret = rfc959_data_connection_new (request)) < 0)
  852.     return (ret);
  854.   *parms = '';
  855.   strcat (parms, show_hidden_files ? "a" : "");
  856.   strcat (parms, resolve_symlinks ? "L" : "");
  857.   tempstr = g_strconcat ("LIST", *parms != '' ? " -" : "", parms, "rn", 
  858.                          NULL); 
  860.   ret = rfc959_send_command (request, tempstr);
  861.   g_free (tempstr);
  863.   if (ret != '1')
  864.     return (-2);
  866.   ret = 0;
  867.   if (request->transfer_type == gftp_transfer_active)
  868.     ret = rfc959_accept_active_connection (request);
  870.   return (ret);
  871. }
  874. int
  875. rfc959_get_next_file (gftp_request * request, gftp_file * fle, int fd)
  876. {
  877.   rfc959_parms * parms;
  878.   char tempstr[255];
  879.   ssize_t len;
  881.   g_return_val_if_fail (request != NULL, -2);
  882.   g_return_val_if_fail (request->protonum == GFTP_FTP_NUM, -2);
  883.   g_return_val_if_fail (fle != NULL, -2);
  884.   g_return_val_if_fail (fd > 0, -2);
  886.   if (request->last_dir_entry)
  887.     {
  888.       g_free (request->last_dir_entry);
  889.       request->last_dir_entry = NULL;
  890.     }
  892.   parms = request->protocol_data;
  894.   do
  895.     {
  896.       if ((len = gftp_get_line (request, &parms->datafd_rbuf,
  897.                                 tempstr, sizeof (tempstr), fd)) <= 0)
  898. {
  899.           gftp_file_destroy (fle);
  900.   return ((int) len);
  901. } 
  903.       if (gftp_parse_ls (tempstr, fle) != 0)
  904. {
  905.   if (strncmp (tempstr, "total", strlen ("total")) != 0 &&
  906.       strncmp (tempstr, _("total"), strlen (_("total"))) != 0)
  907.     request->logging_function (gftp_logging_error, request->user_data,
  908.        _("Warning: Cannot parse listing %sn"),
  909.        tempstr);
  910.   gftp_file_destroy (fle);
  911.   continue;
  912. }
  913.       else
  914. break;
  915.     }
  916.   while (1);
  918.   len = strlen (tempstr);
  919.   if (!request->cached)
  920.     {
  921.       request->last_dir_entry = g_strdup_printf ("%sn", tempstr);
  922.       request->last_dir_entry_len = len + 1;
  923.     }
  924.   return (len);
  925. }
  928. static int
  929. rfc959_set_data_type (gftp_request * request, int data_type)
  930. {
  931.   char *tempstr;
  933.   g_return_val_if_fail (request != NULL, -2);
  934.   g_return_val_if_fail (request->protonum == GFTP_FTP_NUM, -2);
  936.   if (request->sockfd > 0 && request->data_type != data_type)
  937.     {
  938.       if (data_type == GFTP_TYPE_BINARY)
  939. tempstr = "TYPE Irn";
  940.       else
  941. tempstr = "TYPE Arn";
  943.       if (rfc959_send_command (request, tempstr) != '2')
  944. return (-2);
  945.     }
  946.   request->data_type = data_type;
  947.   return (0);
  948. }
  951. static off_t
  952. rfc959_get_file_size (gftp_request * request, const char *filename)
  953. {
  954.   char *tempstr;
  955.   int ret;
  957.   g_return_val_if_fail (request != NULL, 0);
  958.   g_return_val_if_fail (request->protonum == GFTP_FTP_NUM, -2);
  959.   g_return_val_if_fail (filename != NULL, 0);
  960.   g_return_val_if_fail (request->sockfd > 0, 0);
  962.   tempstr = g_strconcat ("SIZE ", filename, "rn", NULL);
  963.   ret = rfc959_send_command (request, tempstr);
  964.   g_free (tempstr);
  965.   if (ret < 0)
  966.     return (-2);
  968.   if (*request->last_ftp_response != '2')
  969.     return (0);
  970.   return (strtol (request->last_ftp_response + 4, NULL, 10));
  971. }
  974. static int
  975. rfc959_rmdir (gftp_request * request, const char *directory)
  976. {
  977.   char *tempstr, ret;
  979.   g_return_val_if_fail (request != NULL, -2);
  980.   g_return_val_if_fail (request->protonum == GFTP_FTP_NUM, -2);
  981.   g_return_val_if_fail (directory != NULL, -2);
  982.   g_return_val_if_fail (request->sockfd > 0, -2);
  984.   tempstr = g_strconcat ("RMD ", directory, "rn", NULL);
  985.   ret = rfc959_send_command (request, tempstr);
  986.   g_free (tempstr);
  987.   return (ret == '2' ? 0 : -2);
  988. }
  991. static int
  992. rfc959_rmfile (gftp_request * request, const char *file)
  993. {
  994.   char *tempstr, ret;
  996.   g_return_val_if_fail (request != NULL, -2);
  997.   g_return_val_if_fail (request->protonum == GFTP_FTP_NUM, -2);
  998.   g_return_val_if_fail (file != NULL, -2);
  999.   g_return_val_if_fail (request->sockfd > 0, -2);
  1001.   tempstr = g_strconcat ("DELE ", file, "rn", NULL);
  1002.   ret = rfc959_send_command (request, tempstr);
  1003.   g_free (tempstr);
  1004.   return (ret == '2' ? 0 : -2);
  1005. }
  1008. static int
  1009. rfc959_mkdir (gftp_request * request, const char *directory)
  1010. {
  1011.   char *tempstr, ret;
  1013.   g_return_val_if_fail (request != NULL, -2);
  1014.   g_return_val_if_fail (request->protonum == GFTP_FTP_NUM, -2);
  1015.   g_return_val_if_fail (directory != NULL, -2);
  1016.   g_return_val_if_fail (request->sockfd > 0, -2);
  1018.   tempstr = g_strconcat ("MKD ", directory, "rn", NULL);
  1019.   ret = rfc959_send_command (request, tempstr);
  1020.   g_free (tempstr);
  1021.   return (ret == '2' ? 0 : -2);
  1022. }
  1025. static int
  1026. rfc959_rename (gftp_request * request, const char *oldname,
  1027.        const char *newname)
  1028. {
  1029.   char *tempstr, ret;
  1031.   g_return_val_if_fail (request != NULL, -2);
  1032.   g_return_val_if_fail (request->protonum == GFTP_FTP_NUM, -2);
  1033.   g_return_val_if_fail (oldname != NULL, -2);
  1034.   g_return_val_if_fail (newname != NULL, -2);
  1035.   g_return_val_if_fail (request->sockfd > 0, -2);
  1037.   tempstr = g_strconcat ("RNFR ", oldname, "rn", NULL);
  1038.   ret = rfc959_send_command (request, tempstr);
  1039.   g_free (tempstr);
  1040.   if (ret != '3')
  1041.     return (-2);
  1043.   tempstr = g_strconcat ("RNTO ", newname, "rn", NULL);
  1044.   ret = rfc959_send_command (request, tempstr);
  1045.   g_free (tempstr);
  1046.   return (ret == '2' ? 0 : -2);
  1047. }
  1050. static int
  1051. rfc959_chmod (gftp_request * request, const char *file, int mode)
  1052. {
  1053.   char *tempstr, ret;
  1055.   g_return_val_if_fail (request != NULL, -2);
  1056.   g_return_val_if_fail (request->protonum == GFTP_FTP_NUM, -2);
  1057.   g_return_val_if_fail (file != NULL, -2);
  1058.   g_return_val_if_fail (request->sockfd > 0, -2);
  1060.   tempstr = g_malloc (strlen (file) + (mode / 10) + 16);
  1061.   sprintf (tempstr, "SITE CHMOD %d %srn", mode, file);
  1062.   ret = rfc959_send_command (request, tempstr);
  1063.   g_free (tempstr);
  1064.   return (ret == '2' ? 0 : -2);
  1065. }
  1068. static int
  1069. rfc959_site (gftp_request * request, const char *command)
  1070. {
  1071.   char *tempstr, ret;
  1073.   g_return_val_if_fail (request != NULL, -2);
  1074.   g_return_val_if_fail (request->protonum == GFTP_FTP_NUM, -2);
  1075.   g_return_val_if_fail (command != NULL, -2);
  1076.   g_return_val_if_fail (request->sockfd > 0, -2);
  1078.   tempstr = g_strconcat ("SITE ", command, "rn", NULL);
  1079.   ret = rfc959_send_command (request, tempstr);
  1080.   g_free (tempstr);
  1081.   return (request->sockfd > 0 ? ret : -2);
  1082. }
  1085. static void
  1086. rfc959_set_config_options (gftp_request * request)
  1087. {
  1088.   request->transfer_type = passive_transfer ? gftp_transfer_passive : gftp_transfer_active;
  1090.   if (strcmp (proxy_config, "http") != 0)
  1091.     {
  1092.       gftp_set_proxy_hostname (request, firewall_host);
  1093.       gftp_set_proxy_port (request, firewall_port);
  1094.       gftp_set_proxy_username (request, firewall_username);
  1095.       gftp_set_proxy_password (request, firewall_password);
  1096.       gftp_set_proxy_account (request, firewall_account);
  1097.       gftp_set_proxy_config (request, proxy_config);
  1098.     }
  1099.   else
  1100.     {
  1101.       gftp_set_proxy_hostname (request, http_proxy_host);
  1102.       gftp_set_proxy_port (request, http_proxy_port);
  1103.       gftp_set_proxy_username (request, http_proxy_username);
  1104.       gftp_set_proxy_password (request, http_proxy_password);
  1107.       if (request->proxy_config == NULL)
  1108.         {
  1109.           gftp_protocols[GFTP_HTTP_NUM].init (request);
  1110.           request->proxy_config = g_strdup ("ftp");
  1111.         }
  1112.     }
  1113. }
  1116. void
  1117. rfc959_init (gftp_request * request)
  1118. {
  1119.   g_return_if_fail (request != NULL);
  1121.   request->protonum = GFTP_FTP_NUM;
  1122.   request->init = rfc959_init;
  1123.   request->destroy = NULL; 
  1124.   request->connect = rfc959_connect;
  1125.   request->disconnect = rfc959_disconnect;
  1126.   request->get_file = rfc959_get_file;
  1127.   request->put_file = rfc959_put_file;
  1128.   request->transfer_file = rfc959_transfer_file;
  1129.   request->get_next_file_chunk = NULL;
  1130.   request->put_next_file_chunk = NULL;
  1131.   request->end_transfer = rfc959_end_transfer;
  1132.   request->abort_transfer = rfc959_abort_transfer;
  1133.   request->list_files = rfc959_list_files;
  1134.   request->get_next_file = rfc959_get_next_file;
  1135.   request->set_data_type = rfc959_set_data_type;
  1136.   request->get_file_size = rfc959_get_file_size;
  1137.   request->chdir = rfc959_chdir;
  1138.   request->rmdir = rfc959_rmdir;
  1139.   request->rmfile = rfc959_rmfile;
  1140.   request->mkdir = rfc959_mkdir;
  1141.   request->rename = rfc959_rename;
  1142.   request->chmod = rfc959_chmod;
  1143.   request->set_file_time = NULL;
  1144.   request->site = rfc959_site;
  1145.   request->parse_url = NULL;
  1146.   request->swap_socks = NULL;
  1147.   request->set_config_options = rfc959_set_config_options;
  1148.   request->url_prefix = "ftp";
  1149.   request->protocol_name = "FTP";
  1150.   request->need_hostport = 1;
  1151.   request->need_userpass = 1;
  1152.   request->use_cache = 1;
  1153.   request->use_threads = 1;
  1154.   request->always_connected = 0;
  1155.   request->protocol_data = g_malloc0 (sizeof (rfc959_parms));
  1156.   gftp_set_config_options (request);
  1157. }