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

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

Ftp客户端

开发平台：

Visual C++

rfc2068.c：源码内容
  1. /*****************************************************************************/
  2. /*  rfc2068.c - General purpose routines for the HTTP protocol               */
  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: rfc2068.c,v 1.10 2002/11/23 13:45:04 masneyb Exp $";
  23. typedef struct rfc2068_params_tag
  24. {
  25.   unsigned long read_bytes,
  26.                 max_bytes;
  27.   int chunked_transfer : 1;
  28. } rfc2068_params;
  31. static char *
  32. base64_encode (char *str)
  33. {
  35. /* The standard to Base64 encoding can be found in RFC2045 */
  37.   char *newstr, *newpos, *fillpos, *pos;
  38.   unsigned char table[64], encode[3];
  39.   int i, num;
  41.   for (i = 0; i < 26; i++)
  42.     {
  43.       table[i] = 'A' + i;
  44.       table[i + 26] = 'a' + i;
  45.     }
  47.   for (i = 0; i < 10; i++)
  48.     table[i + 52] = '0' + i;
  50.   table[62] = '+';
  51.   table[63] = '-';
  53.   num = strlen (str) / 3;
  54.   if (strlen (str) % 3 > 0)
  55.     num++;
  56.   newstr = g_malloc (num * 4 + 1);
  57.   newstr[num * 4] = '';
  58.   newpos = newstr;
  60.   pos = str;
  61.   while (*pos != '')
  62.     {
  63.       memset (encode, 0, sizeof (encode));
  64.       for (i = 0; i < 3 && *pos != ''; i++)
  65. encode[i] = *pos++;
  67.       fillpos = newpos;
  68.       *newpos++ = table[encode[0] >> 2];
  69.       *newpos++ = table[(encode[0] & 3) << 4 | encode[1] >> 4];
  70.       *newpos++ = table[(encode[1] & 0xF) << 2 | encode[2] >> 6];
  71.       *newpos++ = table[encode[2] & 0x3F];
  72.       while (i < 3)
  73. fillpos[++i] = '=';
  74.     }
  75.   return (newstr);
  76. }
  79. static off_t 
  80. rfc2068_read_response (gftp_request * request)
  81. {
  82.   gftp_getline_buffer * rbuf;
  83.   rfc2068_params * params;
  84.   char tempstr[255];
  86.   params = request->protocol_data;
  87.   params->max_bytes = 0;
  89.   rbuf = NULL;
  90.   if (gftp_get_line (request, &rbuf, tempstr, sizeof (tempstr), 
  91.                      request->sockfd) < 0)
  92.     return (-1);
  94.   if (request->last_ftp_response)
  95.     g_free (request->last_ftp_response);
  96.   request->last_ftp_response = g_malloc (strlen (tempstr) + 1);
  97.   strcpy (request->last_ftp_response, tempstr);
  99.   request->logging_function (gftp_logging_recv, request->user_data, "%s",
  100.                              tempstr);
  102.   params->chunked_transfer = 0;
  103.   while (1) 
  104.     {
  105.       /* Read rest of proxy header */
  106.       if (gftp_get_line (request, &rbuf, tempstr, sizeof (tempstr), 
  107.                          request->sockfd) < 0)
  108. return (-1);
  110.       if (*tempstr == 'r' || *tempstr == 'n')
  111.         break;
  113.       request->logging_function (gftp_logging_recv, request->user_data, "%s",
  114.                                  tempstr);
  116.       if (strncmp (tempstr, "Content-Length:", 15) == 0)
  117. params->max_bytes = strtol (tempstr + 16, NULL, 10);
  118.       if (strncmp (tempstr, "Transfer-Encoding: chunked", 26) == 0)
  119.         params->chunked_transfer = 1;
  120.     }
  122.   return (params->max_bytes);
  123. }
  126. static off_t 
  127. rfc2068_send_command (gftp_request * request, const char *command,
  128.                       const char *extrahdr)
  129. {
  130.   char *tempstr, *str;
  131.   ssize_t ret;
  133.   g_return_val_if_fail (request != NULL, -2);
  134.   g_return_val_if_fail (request->protonum == GFTP_HTTP_NUM, -2);
  135.   g_return_val_if_fail (command != NULL, -2);
  137.   tempstr = g_strdup_printf ("%sUser-Agent: %snHost: %sn", command,
  138.                              version, request->hostname);
  140.   request->logging_function (gftp_logging_send, request->user_data,
  141.                              "%s", tempstr);
  143.   ret = gftp_write (request, tempstr, strlen (tempstr), request->sockfd);
  144.   g_free (tempstr);
  146.   if (ret < 0)
  147.     return (-1);
  149.   if (request->use_proxy && request->proxy_username != NULL &&
  150.       *request->proxy_username != '')
  151.     {
  152.       tempstr = g_strconcat (request->proxy_username, ":", 
  153.                              request->proxy_password, NULL);
  154.       str = base64_encode (tempstr);
  155.       g_free (tempstr);
  157.       request->logging_function (gftp_logging_send, request->user_data,
  158.                                  "Proxy-authorization: Basic xxxx:xxxxn");
  159.       ret = gftp_writefmt (request, request->sockfd, 
  160.                            "Proxy-authorization: Basic %sn", str);
  161.       g_free (str);
  162.       if (ret < 0)
  163. return (-2);
  164.     }
  166.   if (request->username != NULL && *request->username != '')
  167.     {
  168.       tempstr = g_strconcat (request->username, ":", request->password, NULL);
  169.       str = base64_encode (tempstr);
  170.       g_free (tempstr);
  172.       request->logging_function (gftp_logging_send, request->user_data,
  173.                                  "Authorization: Basic xxxxn");
  174.       ret = gftp_writefmt (request, request->sockfd, 
  175.                            "Authorization: Basic %sn", str);
  176.       g_free (str);
  177.       if (ret < 0)
  178. return (-2);
  179.     }
  181.   if (extrahdr)
  182.     {
  183.       request->logging_function (gftp_logging_send, request->user_data, "%s",
  184.                                  extrahdr);
  185.       if (gftp_write (request, extrahdr, strlen (extrahdr), request->sockfd) < 0)
  186.         return (-1);
  187.     }
  189.   if (gftp_write (request, "n", 1, request->sockfd) < 0)
  190.     return (-1);
  192.   return (rfc2068_read_response (request));
  193. }
  196. static int
  197. rfc2068_connect (gftp_request * request)
  198. {
  199.   char *service;
  201.   g_return_val_if_fail (request != NULL, -2);
  202.   g_return_val_if_fail (request->protonum == GFTP_HTTP_NUM, -2);
  203.   g_return_val_if_fail (request->hostname != NULL, -2);
  205.   if (request->sockfd > 0)
  206.     return (0);
  208.   service = request->use_proxy && request->proxy_config != NULL && 
  209.             *request->proxy_config != '' ? request->proxy_config : "http";
  210.   if ((request->sockfd = gftp_connect_server (request, service)) < 0)
  211.     return (-1);
  213.   if (request->directory && *request->directory == '')
  214.     {
  215.       g_free (request->directory);
  216.       request->directory = NULL;
  217.     }
  219.   if (!request->directory)
  220.     {
  221.       request->directory = g_malloc (2);
  222.       strcpy (request->directory, "/");
  223.     }
  225.   return (0);
  226. }
  229. static void
  230. rfc2068_disconnect (gftp_request * request)
  231. {
  232.   g_return_if_fail (request != NULL);
  233.   g_return_if_fail (request->protonum == GFTP_HTTP_NUM);
  235.   if (request->sockfd > 0)
  236.     {
  237.       request->logging_function (gftp_logging_misc, request->user_data,
  238.  _("Disconnecting from site %sn"),
  239.  request->hostname);
  241.       if (close (request->sockfd) < 0)
  242.         request->logging_function (gftp_logging_error, request->user_data,
  243.                                    _("Error closing file descriptor: %sn"),
  244.                                    g_strerror (errno));
  246.       request->sockfd = -1;
  247.     }
  248. }
  251. static off_t
  252. rfc2068_get_file (gftp_request * request, const char *filename, int fd,
  253.                   off_t startsize)
  254. {
  255.   char *tempstr, *extrahdr, *pos, *proto;
  256.   int restarted;
  257.   off_t size;
  259.   g_return_val_if_fail (request != NULL, -2);
  260.   g_return_val_if_fail (request->protonum == GFTP_HTTP_NUM, -2);
  261.   g_return_val_if_fail (filename != NULL, -2);
  263.   if (fd > 0)
  264.     request->sockfd = fd;
  266.   if (request->sockfd < 0 && rfc2068_connect (request) != 0)
  267.     return (-2);
  269.   if (request->proxy_config != NULL && *request->proxy_config != '')
  270.     proto = request->proxy_config;
  271.   else
  272.     proto = "http";
  274.   if (request->username == NULL || *request->username == '')
  275.     tempstr = g_strconcat ("GET ", proto, "://", 
  276.                      request->hostname, "/", filename, 
  277.                      use_http11 ? " HTTP/1.1n" : " HTTP/1.0n", NULL);
  278.   else 
  279.     tempstr = g_strconcat ("GET ", proto, "://", 
  280.                      request->username, "@", request->hostname, "/", filename, 
  281.                      use_http11 ? " HTTP/1.1n" : " HTTP/1.0n", NULL);
  283.   if ((pos = strstr (tempstr, "://")) != NULL)
  284.     remove_double_slashes (pos + 3);
  285.   else
  286.     remove_double_slashes (tempstr);
  288.   if (!use_http11 || startsize == 0)
  289.     extrahdr = NULL;
  290.   else
  291.     {
  292. #if defined (_LARGEFILE_SOURCE)
  293.       extrahdr = g_strdup_printf ("Range: bytes=%lld-n", startsize);
  294.       request->logging_function (gftp_logging_misc, request->user_data,
  295.                               _("Starting the file transfer at offset %lldn"),
  296.                               startsize);
  297. #else
  298.       extrahdr = g_strdup_printf ("Range: bytes=%ld-n", startsize);
  299.       request->logging_function (gftp_logging_misc, request->user_data,
  300.        _("Starting the file transfer at offset %ldn"), 
  301.                                startsize);
  302. #endif
  303.     }
  305.   size = rfc2068_send_command (request, tempstr, extrahdr);
  306.   g_free (tempstr);
  307.   if (extrahdr)
  308.     g_free (extrahdr);
  309.   if (size < 0)
  310.     return (-1);
  312.   restarted = 0;
  313.   if (strlen (request->last_ftp_response) > 9 
  314.       && strncmp (request->last_ftp_response + 9, "206", 3) == 0)
  315.     restarted = 1;
  316.   else if (strlen (request->last_ftp_response) < 9 ||
  317.            strncmp (request->last_ftp_response + 9, "200", 3) != 0)
  318.     {
  319.       request->logging_function (gftp_logging_error, request->user_data,
  320.          _("Cannot retrieve file %sn"), filename);
  321.       return (-2);
  322.     }
  324.   return (restarted ? size + startsize : size);
  325. }
  328. static ssize_t
  329. rfc2068_get_next_file_chunk (gftp_request * request, char *buf, size_t size)
  330. {
  331.   rfc2068_params * params;
  332.   size_t len;
  334.   g_return_val_if_fail (request != NULL, -2);
  335.   g_return_val_if_fail (request->protonum == GFTP_HTTP_NUM, -2);
  337.   params = request->protocol_data;
  338.   if (params->max_bytes == params->read_bytes)
  339.     return (0);
  341.   if (params->max_bytes > 0 && 
  342.       size + params->read_bytes > params->max_bytes)
  343.     size = params->max_bytes - params->read_bytes;
  345.   if ((len = gftp_read (request, buf, size, request->sockfd)) < 0)
  346.     return (-2);
  348.   return (len);
  349. }
  352. static int
  353. rfc2068_end_transfer (gftp_request * request)
  354. {
  355.   rfc2068_params * params;
  357.   g_return_val_if_fail (request != NULL, -2);
  358.   g_return_val_if_fail (request->protonum == GFTP_HTTP_NUM, -2);
  360.   if (request->sockfd < 0)
  361.     return (-2);
  363.   if (close (request->sockfd) < 0)
  364.     request->logging_function (gftp_logging_error, request->user_data,
  365.                                _("Error closing file descriptor: %sn"),
  366.                                g_strerror (errno));
  367.   request->sockfd = -1;
  369.   params = request->protocol_data;
  370.   params->max_bytes = 0;
  372.   request->logging_function (gftp_logging_misc, request->user_data,
  373.                              _("Finished retrieving datan"));
  374.   return (0);
  375. }
  378. static int
  379. rfc2068_list_files (gftp_request * request)
  380. {
  381.   char *tempstr, *pos, *proto;
  382.   rfc2068_params *params;
  383.   off_t ret;
  385.   g_return_val_if_fail (request != NULL, -2);
  386.   g_return_val_if_fail (request->protonum == GFTP_HTTP_NUM, -2);
  388.   params = request->protocol_data;
  389.   if (request->sockfd < 0 && rfc2068_connect (request) != 0)
  390.     return (-2);
  392.   if (request->proxy_config != NULL && *request->proxy_config != '')
  393.     proto = request->proxy_config;
  394.   else
  395.     proto = "http";
  397.   if (request->username == NULL || *request->username == '')
  398.     tempstr = g_strconcat ("GET ", proto, "://", 
  399.                            request->hostname, "/", request->directory, 
  400.                            use_http11 ? "/ HTTP/1.1n" : "/ HTTP/1.0n", NULL);
  401.   else
  402.     tempstr = g_strconcat ("GET ", proto, "://", request->username, "@", 
  403.                            request->hostname, "/", request->directory, 
  404.                            use_http11 ? "/ HTTP/1.1n" : "/ HTTP/1.0n", NULL);
  406.   if ((pos = strstr (tempstr, "://")) != NULL)
  407.     remove_double_slashes (pos + 3);
  408.   else
  409.     remove_double_slashes (tempstr);
  411.   ret = rfc2068_send_command (request, tempstr, NULL);
  412.   g_free (tempstr);
  413.   if (ret < 0)
  414.     return (-1);
  416.   params->read_bytes = 0;
  417.   if (strlen (request->last_ftp_response) > 9 &&
  418.       strncmp (request->last_ftp_response + 9, "200", 3) == 0)
  419.     {
  420.       request->logging_function (gftp_logging_misc, request->user_data,
  421.                                  _("Retrieving directory listing...n"));
  422.       return (0);
  423.     }
  424.   
  425.   return (-2);
  426. }
  429. static off_t 
  430. rfc2068_get_file_size (gftp_request * request, const char *filename)
  431. {
  432.   char *tempstr, *pos, *proto;
  433.   off_t size;
  435.   g_return_val_if_fail (request != NULL, -2);
  436.   g_return_val_if_fail (request->protonum == GFTP_HTTP_NUM, -2);
  437.   g_return_val_if_fail (filename != NULL, -2);
  439.   if (request->sockfd < 0 && rfc2068_connect (request) != 0)
  440.     return (-2);
  442.   if (request->proxy_config != NULL && *request->proxy_config != '')
  443.     proto = request->proxy_config;
  444.   else
  445.     proto = "http";
  447.   if (request->username == NULL || *request->username == '')
  448.     tempstr = g_strconcat ("HEAD ", proto, request->hostname, "/", filename, 
  449.                            use_http11 ? " HTTP/1.1n" : " HTTP/1.0n", NULL);
  450.   else
  451.     tempstr = g_strconcat ("HEAD ", proto, request->username, "@", 
  452.                            request->hostname, "/", filename, 
  453.                            use_http11 ? " HTTP/1.1n" : " HTTP/1.0n", NULL);
  455.   if ((pos = strstr (tempstr, "://")) != NULL)
  456.     remove_double_slashes (pos + 3);
  457.   else
  458.     remove_double_slashes (tempstr);
  460.   size = rfc2068_send_command (request, tempstr, NULL);
  461.   g_free (tempstr);
  462.   if (size < 0)
  463.     return (-2);
  465.   return (size);
  466. }
  469. static int
  470. parse_html_line (char *tempstr, gftp_file * fle)
  471. {
  472.   char months[13][3] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug",
  473.                         "Sep", "Oct", "Nov", "Dec"};
  474.   char *stpos, *pos, month[4];
  475.   struct tm t;
  476.   long units;
  477.   int i;
  479.   memset (fle, 0, sizeof (*fle));
  481.   if ((pos = strstr (tempstr, "<A HREF=")) == NULL && 
  482.       (pos = strstr (tempstr, "<a href=")) == NULL)
  483.     return (0);
  485.   /* Find the filename */
  486.   while (*pos != '"' && *pos != '')
  487.     pos++;
  488.   if (*pos == '')
  489.     return (0);
  490.   pos++;
  492.   for (stpos = pos; *pos != '"' && *pos != ''; pos++);
  493.   if (*pos == '')
  494.     return (0);
  495.   *pos = '';
  497.   /* Copy file attributes. Just about the only thing we can get is whether it
  498.      is a directory or not */
  499.   fle->attribs = g_malloc (11);
  500.   strcpy (fle->attribs, "----------");
  501.   if (*(pos - 1) == '/')
  502.     {
  503.       *(pos - 1) = '';
  504.       *fle->attribs = 'd';
  505.       fle->isdir = 1;
  506.     }
  508.   /* Copy filename */
  509.   if (strchr (stpos, '/') != NULL || strncmp (stpos, "mailto:", 7) == 0 ||
  510.       *stpos == '' || *stpos == '?')
  511.     return (0);
  513.   fle->file = g_malloc (strlen (stpos) + 1);
  514.   strcpy (fle->file, stpos);
  516.   if (*(pos - 1) == '')
  517.     *(pos - 1) = '/';
  518.   *pos = '"';
  519.   pos++;
  521.   /* Skip whitespace and html tags after file and before date */
  522.   stpos = pos;
  523.   if ((pos = strstr (stpos, "</A>")) == NULL &&
  524.       (pos = strstr (stpos, "</a>")) == NULL)
  525.     return (0);
  527.   pos += 4;
  529.   while (*pos == ' ' || *pos == '.' || *pos == '<')
  530.     {
  531.       if (*pos == '<')
  532. {
  533.   if (strncmp (pos, "<A ", 3) == 0 || strncmp (pos, "<a ", 3) == 0)
  534.     {
  535.       stpos = pos;
  536.       if ((pos = strstr (stpos, "</A>")) == NULL 
  537.                    && (pos = strstr (stpos, "</a>")) == NULL)
  538. return (0);
  539.       pos += 4;
  540.     }
  541.   else
  542.     {
  543.       while (*pos != '>' && *pos != '')
  544. pos++;
  545.       if (*pos == '')
  546. return (0);
  547.     }
  548. }
  549.       pos++;
  550.     }
  552.   /* Now get the date */
  553.   memset (&t, 0, sizeof (t));
  554.   memset (month, 0, sizeof (month));
  555.   if (strchr (pos, ':') != NULL)
  556.     {
  557.       if (*pos == '[')
  558. pos++;
  559.       sscanf (pos, "%02d-%3s-%04d %02d:%02d", &t.tm_mday, month, &t.tm_year,
  560.       &t.tm_hour, &t.tm_min);
  561.       while (*pos != ' ' && *pos != '')
  562. pos++;
  563.       if (*pos == '')
  564. return (1);
  566.       while (*pos == ' ')
  567. pos++;
  569.       while (*pos != ' ' && *pos != '')
  570. pos++;
  571.       if (*pos == '')
  572. return (1);
  574.       t.tm_year -= 1900;
  575.     }
  576.   else
  577.     {
  578.       pos++;
  579.       strncpy (month, pos, 3);
  580.       for (i=0; i<3 && *pos != ''; i++)
  581.         pos++;
  582.       if (*pos == '')
  583. return (1);
  585.       while (*pos == ' ')
  586. pos++;
  588.       t.tm_mday = strtol (pos, NULL, 10);
  589.       while (*pos != ' ' && *pos != '')
  590. pos++;
  591.       if (*pos == '')
  592. return (1);
  594.       while (*pos == ' ')
  595. pos++;
  597.       t.tm_year = strtol (pos, NULL, 10) - 1900;
  598.       while (*pos != ' ' && *pos != '')
  599. pos++;
  600.       if (*pos == '')
  601. return (1);
  602.     }
  604.   for (i=0; i<12; i++)
  605.     {
  606.       if (strncmp (month, months[i], 3) == 0)
  607.         {
  608.           t.tm_mon = i;
  609.           break;
  610.         }
  611.     }
  613.   fle->datetime = mktime (&t);
  615.   while (*pos == ' ' || *pos == ']')
  616.     pos++;
  618.   /* Get the size */
  619.   /* This gets confusing on lines like "... 1.1M RedHat RPM package" */
  620.   /* We need to avoid finding the 'k' in package */
  621.  
  622.   stpos = strchr (pos, 'k');
  623.   if (stpos == NULL || !isdigit (*(stpos - 1)))
  624.      stpos = strchr (pos, 'M');
  625.   if (stpos == NULL || !isdigit (*(stpos - 1)))
  626.      return (1); /* Return successfully
  627.    since we got the file */
  628.   if (*stpos == 'k')
  629.     units = 1024;
  630.   else
  631.     units = 1048576;
  633.   fle->size = 0;
  635.   while (*(stpos - 1) != ' ' && *(stpos - 1) != 't' && stpos > tempstr) 
  636.     {
  637.       stpos--;
  638.       if ((*stpos == '.') && isdigit (*(stpos + 1)) ) 
  639.         {  /* found decimal point */
  640.           fle->size = units * strtol (stpos + 1, NULL, 10);
  641.           fle->size /= 10;
  642.         }
  643.     }
  645.   fle->size += units * strtol (stpos, NULL, 10);
  646.   return (1);
  647. }
  650. static int
  651. rfc2068_get_next_file (gftp_request * request, gftp_file * fle, int fd)
  652. {
  653.   gftp_getline_buffer * rbuf;
  654.   rfc2068_params * params;
  655.   char tempstr[255];
  656.   size_t len;
  658.   g_return_val_if_fail (request != NULL, -2);
  659.   g_return_val_if_fail (request->protonum == GFTP_HTTP_NUM, -2);
  660.   g_return_val_if_fail (fle != NULL, -2);
  662.   params = request->protocol_data;
  663.   if (request->last_dir_entry)
  664.     {
  665.       g_free (request->last_dir_entry);
  666.       request->last_dir_entry = NULL;
  667.     }
  669.   rbuf = NULL;
  670.   while (1)
  671.     {
  672.       if (gftp_get_line (request, &rbuf, tempstr, sizeof (tempstr), fd) < 0)
  673.         return (-2);
  675.       tempstr[sizeof (tempstr) - 1] = '';
  676.       params->read_bytes += strlen (tempstr);
  678.       if (params->chunked_transfer && strcmp (tempstr, "0rn") == 0)
  679.         {
  680.           while ((len = gftp_get_line (request, &rbuf, tempstr, 
  681.                                        sizeof (tempstr), fd)) > 0)
  682.             {
  683.               if (strcmp (tempstr, "rn") == 0)
  684.                 break;
  685.             }
  686.   gftp_file_destroy (fle);
  688.           if (len < 0)
  689.             return (-1);
  691.           return (0);
  692.         }
  694.       if (parse_html_line (tempstr, fle) == 0 || fle->file == NULL)
  695. gftp_file_destroy (fle);
  696.       else
  697. break;
  699.       if (params->max_bytes != 0 && params->read_bytes == params->max_bytes)
  700. break;
  701.     }
  703.   if (fle->file == NULL)
  704.     {
  705.       gftp_file_destroy (fle);
  706.       return (-2);
  707.     }
  709.   len = strlen (tempstr);
  710.   if (!request->cached)
  711.     {
  712.       request->last_dir_entry = g_strdup_printf ("%sn", tempstr);
  713.       request->last_dir_entry_len = len + 1;
  714.     }
  715.   return (len);
  716. }
  719. static int
  720. rfc2068_chdir (gftp_request * request, const char *directory)
  721. {
  722.   g_return_val_if_fail (request != NULL, -2);
  723.   g_return_val_if_fail (request->protonum == GFTP_HTTP_NUM, -2);
  724.   g_return_val_if_fail (directory != NULL, -2);
  726.   if (request->directory != directory)
  727.     {
  728.       if (request->directory)
  729.         g_free (request->directory);
  730.       request->directory = g_malloc (strlen (directory) + 1);
  731.       strcpy (request->directory, directory);
  732.     }
  733.   return (0);
  734. }
  737. static void
  738. rfc2068_set_config_options (gftp_request * request)
  739. {
  740.   gftp_set_proxy_hostname (request, http_proxy_host);
  741.   gftp_set_proxy_port (request, http_proxy_port);
  742.   gftp_set_proxy_username (request, http_proxy_username);
  743.   gftp_set_proxy_password (request, http_proxy_password);
  746.   if (request->proxy_config == NULL)
  747.     {
  748.       request->proxy_config = g_malloc (5);
  749.       strcpy (request->proxy_config, "http");
  750.     }
  751. }
  754. void
  755. rfc2068_init (gftp_request * request)
  756. {
  757.   g_return_if_fail (request != NULL);
  759.   request->protonum = GFTP_HTTP_NUM;
  760.   request->init = rfc2068_init;
  761.   request->destroy = NULL;
  762.   request->connect = rfc2068_connect;
  763.   request->disconnect = rfc2068_disconnect;
  764.   request->get_file = rfc2068_get_file;
  765.   request->put_file = NULL;
  766.   request->transfer_file = NULL;
  767.   request->get_next_file_chunk = rfc2068_get_next_file_chunk;
  768.   request->put_next_file_chunk = NULL;
  769.   request->end_transfer = rfc2068_end_transfer;
  770.   request->abort_transfer = rfc2068_end_transfer; /* NOTE: uses end_transfer */
  771.   request->list_files = rfc2068_list_files;
  772.   request->get_next_file = rfc2068_get_next_file;
  773.   request->set_data_type = NULL;
  774.   request->get_file_size = rfc2068_get_file_size;
  775.   request->chdir = rfc2068_chdir;
  776.   request->rmdir = NULL;
  777.   request->rmfile = NULL;
  778.   request->mkdir = NULL;
  779.   request->rename = NULL;
  780.   request->chmod = NULL;
  781.   request->site = NULL;
  782.   request->parse_url = NULL;
  783.   request->swap_socks = NULL;
  784.   request->set_config_options = rfc2068_set_config_options;
  785.   request->url_prefix = "http";
  786.   request->protocol_name = "HTTP";
  787.   request->need_hostport = 1;
  788.   request->need_userpass = 0;
  789.   request->use_cache = 1;
  790.   request->use_threads = 1;
  791.   request->always_connected = 0;
  792.   request->protocol_data = g_malloc0 (sizeof (rfc2068_params));
  793.   gftp_set_config_options (request);
  794. }