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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 浏览器 > 查看源码
ftp.c
资源名称：wwwoffle-2.5e.tgz　[点击查看]
上传用户：seven77cht
上传日期：2007-01-04
资源大小：486k
文件大小：24k
源码类别：

浏览器

开发平台：

Unix_Linux

ftp.c：源码内容
  1. /***************************************
  2.   $Header: /home/amb/wwwoffle/RCS/ftp.c 1.37 2000/03/20 18:47:14 amb Exp $
  4.   WWWOFFLE - World Wide Web Offline Explorer - Version 2.5e.
  5.   Functions for getting URLs using FTP.
  6.   ******************/ /******************
  7.   Written by Andrew M. Bishop
  9.   This file Copyright 1997,98,99,2000 Andrew M. Bishop
  10.   It may be distributed under the GNU Public License, version 2, or
  11.   any higher version.  See section COPYING of the GNU Public license
  12.   for conditions under which this file may be redistributed.
  13.   ***************************************/
  16. #include <stdio.h>
  17. #include <stdlib.h>
  18. #include <string.h>
  19. #include <ctype.h>
  21. #include <sys/time.h>
  22. #include <unistd.h>
  23. #include <fcntl.h>
  24. #include <time.h>
  26. #include "wwwoffle.h"
  27. #include "misc.h"
  28. #include "config.h"
  29. #include "errors.h"
  30. #include "sockets.h"
  31. #include "proto.h"
  34. /*+ Set this to 1 to see the full dialog with the FTP server. +*/
  35. #define DEBUG_FTP 0
  37. /*+ Set to the name of the proxy if there is one. +*/
  38. static char *proxy=NULL;
  40. /*+ The file descriptor of the socket +*/
  41. static int server_ctrl=-1,      /*+ for the control connection to the server. +*/
  42.            server_data=-1;      /*+ for the data connection to the server. +*/
  44. /*+ A buffer to contain the reply +*/
  45. static char *bufferhead=NULL,   /*+ head. +*/
  46.             *buffer=NULL,       /*+ body. +*/
  47.             *buffertail=NULL;   /*+ tail. +*/
  49. /*+ The number of characters in the buffer +*/
  50. static int nbufferhead=0,       /*+ in total for the head . +*/
  51.            nreadhead=0,         /*+ that have been read from the head. +*/
  52.            nbuffer=0,           /*+ in total for the body part. +*/
  53.            nread=0,             /*+ that have been read for the body. +*/
  54.            nbuffertail=0,       /*+ in total for the tail . +*/
  55.            nreadtail=0;         /*+ that have been read from the tail. +*/
  57. static char *htmlise_dir_entry(char *line);
  60. /*++++++++++++++++++++++++++++++++++++++
  61.   Open a connection to get a URL using FTP.
  63.   char *FTP_Open Returns NULL on success, a useful message on error.
  65.   URL *Url The URL to open.
  66.   ++++++++++++++++++++++++++++++++++++++*/
  68. char *FTP_Open(URL *Url)
  69. {
  70.  char *msg=NULL;
  71.  char *colon;
  72.  char *server_host=NULL;
  73.  int server_port=Protocols[Protocol_FTP].defport;
  75.  /* Sort out the host. */
  77.  proxy=WhichProxy(Url->proto,Url->host);
  78.  if(IsLocalNetHost(Url->host))
  79.     proxy=NULL;
  81.  if(proxy)
  82.    {
  83.     server_host=(char*)malloc(strlen(proxy)+1);
  84.     strcpy(server_host,proxy);
  85.    }
  86.  else
  87.    {
  88.     server_host=(char*)malloc(strlen(Url->host)+1);
  89.     strcpy(server_host,Url->host);
  90.    }
  92.  if((colon=strchr(server_host,':')))
  93.    {
  94.     *colon++=0;
  95.     if(*colon)
  96.        server_port=atoi(colon);
  97.    }
  99.  /* Open the connection. */
  101.  server_ctrl=OpenClientSocket(server_host,server_port,ConnectTimeout);
  102.  init_buffer(server_ctrl);
  104.  if(server_ctrl==-1)
  105.     msg=PrintMessage(Warning,"Cannot open the FTP control connection to %s port %d; [%!s].",server_host,server_port);
  107.  free(server_host);
  109.  return(msg);
  110. }
  113. /*++++++++++++++++++++++++++++++++++++++
  114.   Write to the server to request the URL.
  116.   char *FTP_Request Returns NULL on success, a useful message on error.
  118.   URL *Url The URL to get.
  120.   Header *request_head The head of the HTTP request for the URL.
  122.   Body *request_body The body of the HTTP request for the URL.
  123.   ++++++++++++++++++++++++++++++++++++++*/
  125. char *FTP_Request(URL *Url,Header *request_head,Body *request_body)
  126. {
  127.  char *msg=NULL,*str=NULL;
  128.  char *path,*file=NULL;
  129.  char *host,*mimetype=NULL;
  130.  char *msg_reply=NULL;
  131.  char *timestamp,sizebuf[32];
  132.  int i,l,port_l,port_h;
  133.  struct tm modtime;
  134.  time_t mtime;
  135.  char *user,*pass;
  137.  /* Initial setting up. */
  139.  sizebuf[0]=0;
  140.  time(&mtime);
  141.  modtime=*gmtime(&mtime);
  143.  /* Take a simple route if it is proxied. */
  145.  if(proxy)
  146.    {
  147.     char *head;
  149.     MakeRequestAuthorised(proxy,request_head);
  151.     head=HeaderString(request_head);
  153.     PrintMessage(ExtraDebug,"Outgoing Request Head (to proxy)n%s",head);
  155.     if(write_string(server_ctrl,head)==-1)
  156.        msg=PrintMessage(Warning,"Failed to write to remote FTP proxy [%!s].");
  157.     if(request_body && write_data(server_ctrl,request_body->content,request_body->length)==-1)
  158.        msg=PrintMessage(Warning,"Failed to write to remote FTP proxy [%!s].");
  160.     free(head);
  162.     return(msg);
  163.    }
  165.  /* Else Sort out the path. */
  167.  path=URLDecode(Url->path,0);
  168.  if(path[strlen(path)-1]=='/')
  169.    {
  170.     path[strlen(path)-1]=0;
  171.     file=NULL;
  172.    }
  173.  else
  174.     for(i=strlen(path)-1;i>=0;i--)
  175.        if(path[i]=='/')
  176.          {
  177.           path[i]=0;
  178.           file=&path[i+1];
  179.           break;
  180.          }
  182.  if(Url->user)
  183.    {
  184.     user=Url->user;
  185.     pass=Url->pass;
  186.    }
  187.  else
  188.     WhatFTPUserPass(Url->host,&user,&pass);
  190.  /* send all the RFC959 commands. */
  192.  server_data=-1;
  194.  do
  195.    {
  196.     str=read_line_or_timeout(server_ctrl,str,SocketTimeout);
  197.     PrintMessage(ExtraDebug,"FTP: connected; got: %s",str);
  199.     if(!file && !*path && str && isdigit(str[0]) && isdigit(str[1]) && isdigit(str[2]) && str[3]=='-')
  200.       {
  201.        if(msg_reply)
  202.          {
  203.           msg_reply=(char*)realloc((void*)msg_reply,strlen(msg_reply)+strlen(str));
  204.           strcat(msg_reply,str+4);
  205.          }
  206.        else
  207.          {
  208.           msg_reply=(char*)malloc(strlen(str));
  209.           strcpy(msg_reply,str+4);
  210.          }
  211.       }
  212.    }
  213.  while(str && (!isdigit(str[0]) || !isdigit(str[1]) || !isdigit(str[2]) || str[3]!=' '));
  215.  if(!str || atoi(str)!=220)
  216.    {
  217.     if(str)
  218.       {
  219.        char *p=str+strlen(str)-1;
  220.        while(*p=='n' || *p=='r') *p--=0;
  221.        msg=PrintMessage(Warning,"Got '%s' message when connected to FTP server.",str);
  222.       }
  223.     else
  224.        msg=PrintMessage(Warning,"No reply from FTP server when connected; timed out?");
  225.     return(msg);
  226.    }
  228.  /* Login */
  230.  if(write_formatted(server_ctrl,"USER %srn",user)==-1)
  231.    {
  232.     msg=PrintMessage(Warning,"Failed to write 'USER' command to remote FTP host [%!s].");
  233.     return(msg);
  234.    }
  236.  do
  237.    {
  238.     str=read_line_or_timeout(server_ctrl,str,SocketTimeout);
  239.     PrintMessage(ExtraDebug,"FTP: sent 'USER %s'; got: %s",user,str);
  240.    }
  241.  while(str && (!isdigit(str[0]) || !isdigit(str[1]) || !isdigit(str[2]) || str[3]!=' '));
  243.  if(!str || (atoi(str)!=230 && atoi(str)!=331))
  244.    {
  245.     if(str)
  246.       {
  247.        char *p=str+strlen(str)-1;
  248.        while(*p=='n' || *p=='r') *p--=0;
  249.        msg=PrintMessage(Warning,"Got '%s' message after sending 'USER' command to FTP server.",str);
  250.       }
  251.     else
  252.        msg=PrintMessage(Warning,"No reply from FTP server to 'USER' command; timed out?");
  253.     return(msg);
  254.    }
  256.  if(atoi(str)==331)
  257.    {
  258.     if(write_formatted(server_ctrl,"PASS %srn",pass)==-1)
  259.       {
  260.        msg=PrintMessage(Warning,"Failed to write 'PASS' command to remote FTP host [%!s].");
  261.        return(msg);
  262.       }
  264.     do
  265.       {
  266.        str=read_line_or_timeout(server_ctrl,str,SocketTimeout);
  267.        PrintMessage(ExtraDebug,"FTP: sent 'PASS %s'; got: %s",pass,str);
  269.        if(!file && !*path && str && isdigit(str[0]) && isdigit(str[1]) && isdigit(str[2]) && str[3]=='-')
  270.          {
  271.           if(msg_reply)
  272.             {
  273.              msg_reply=(char*)realloc((void*)msg_reply,strlen(msg_reply)+strlen(str));
  274.              strcat(msg_reply,str+4);
  275.             }
  276.           else
  277.             {
  278.              msg_reply=(char*)malloc(strlen(str));
  279.              strcpy(msg_reply,str+4);
  280.             }
  281.          }
  282.       }
  283.     while(str && (!isdigit(str[0]) || !isdigit(str[1]) || !isdigit(str[2]) || str[3]!=' '));
  285.     if(!str || (atoi(str)!=202 && atoi(str)!=230))
  286.       {
  287.        if(str)
  288.          {
  289.           char *p=str+strlen(str)-1;
  290.           while(*p=='n' || *p=='r') *p--=0;
  291.           msg=PrintMessage(Warning,"Got '%s' message after sending 'PASS' command to FTP server.",str);
  292.          }
  293.        else
  294.           msg=PrintMessage(Warning,"No reply from FTP server to 'PASS' command; timed out?");
  295.        return(msg);
  296.       }
  297.    }
  299.  /* Change directory */
  301.  if(write_formatted(server_ctrl,"CWD %srn",*path?path:"/")==-1)
  302.    {
  303.     msg=PrintMessage(Warning,"Failed to write 'CWD' command to remote FTP host [%!s].");
  304.     return(msg);
  305.    }
  307.  do
  308.    {
  309.     str=read_line_or_timeout(server_ctrl,str,SocketTimeout);
  310.     PrintMessage(ExtraDebug,"FTP: sent 'CWD %s' got: %s",*path?path:"/",str);
  312.     if(!file && str && isdigit(str[0]) && isdigit(str[1]) && isdigit(str[2]) && str[3]=='-')
  313.       {
  314.        if(msg_reply)
  315.          {
  316.           msg_reply=(char*)realloc((void*)msg_reply,strlen(msg_reply)+strlen(str));
  317.           strcat(msg_reply,str+4);
  318.          }
  319.        else
  320.          {
  321.           msg_reply=(char*)malloc(strlen(str));
  322.           strcpy(msg_reply,str+4);
  323.          }
  324.       }
  325.    }
  326.  while(str && (!isdigit(str[0]) || !isdigit(str[1]) || !isdigit(str[2]) || str[3]!=' '));
  328.  if(!str || atoi(str)!=250)
  329.    {
  330.     if(str)
  331.       {
  332.        char *p=str+strlen(str)-1;
  333.        while(*p=='n' || *p=='r') *p--=0;
  334.        msg=PrintMessage(Warning,"Got '%s' message after sending 'CWD' command to FTP server.",str);
  335.       }
  336.     else
  337.        msg=PrintMessage(Warning,"No reply from FTP server to 'CWD' command; timed out?");
  338.     return(msg);
  339.    }
  341.  /* Change directory again to see if file is a dir. */
  343.  if(file)
  344.    {
  345.     if(write_formatted(server_ctrl,"CWD %srn",file)==-1)
  346.       {
  347.        msg=PrintMessage(Warning,"Failed to write 'CWD' command to remote FTP host [%!s].");
  348.        return(msg);
  349.       }
  351.     do
  352.       {
  353.        str=read_line_or_timeout(server_ctrl,str,SocketTimeout);
  354.        PrintMessage(ExtraDebug,"FTP: sent 'CWD %s' got: %s",file,str);
  355.       }
  356.     while(str && (!isdigit(str[0]) || !isdigit(str[1]) || !isdigit(str[2]) || str[3]!=' '));
  358.     if(!str || (atoi(str)!=250 && atoi(str)!=501 && atoi(str)!=530 && atoi(str)!=550))
  359.       {
  360.        if(str)
  361.          {
  362.           char *p=str+strlen(str)-1;
  363.           while(*p=='n' || *p=='r') *p--=0;
  364.           msg=PrintMessage(Warning,"Got '%s' message after sending 'CWD' command to FTP server.",str);
  365.          }
  366.        else
  367.           msg=PrintMessage(Warning,"No reply from FTP server to 'CWD' command; timed out?");
  368.        return(msg);
  369.       }
  371.     if(atoi(str)==250)
  372.       {
  373.        char *loc=(char*)malloc(strlen(Url->link)+2);
  375.        strcpy(loc,Url->link);
  376.        strcat(loc,"/");
  378.        bufferhead=HTMLMessageHead(-1,302,"Is a directory",
  379.                                   "Location",loc,
  380.                                   NULL);
  382.        buffer=HTMLMessageBody(-1,"FTPDirRedirect",
  383.                               "url",Url->link,
  384.                               NULL);
  386.        free(loc);
  388.        goto near_end;
  389.       }
  390.    }
  392.  /* Set mode to binary or ASCII */
  394.  if(write_formatted(server_ctrl,"TYPE %crn",file?'I':'A')==-1)
  395.    {
  396.     msg=PrintMessage(Warning,"Failed to write 'TYPE' command to remote FTP host [%!s].");
  397.     return(msg);
  398.    }
  400.  do
  401.    {
  402.     str=read_line_or_timeout(server_ctrl,str,SocketTimeout);
  403.     PrintMessage(ExtraDebug,"FTP: sent 'TYPE %c'; got: %s",file?'I':'A',str);
  404.    }
  405.  while(str && (!isdigit(str[0]) || !isdigit(str[1]) || !isdigit(str[2]) || str[3]!=' '));
  407.  if(!str || atoi(str)!=200)
  408.    {
  409.     if(str)
  410.       {
  411.        char *p=str+strlen(str)-1;
  412.        while(*p=='n' || *p=='r') *p--=0;
  413.        msg=PrintMessage(Warning,"Got '%s' message after sending 'TYPE' command to FTP server.",str);
  414.       }
  415.     else
  416.        msg=PrintMessage(Warning,"No reply from FTP server to 'TYPE' command; timed out?");
  417.     return(msg);
  418.    }
  420.  if(!strcmp(request_head->method,"GET"))
  421.    {
  422.     /* Try and get the size and modification time. */
  424.     if(file)
  425.       {
  426.        if(write_formatted(server_ctrl,"SIZE %srn",file)==-1)
  427.          {
  428.           msg=PrintMessage(Warning,"Failed to write 'SIZE' command to remote FTP host [%!s].");
  429.           return(msg);
  430.          }
  432.        do
  433.          {
  434.           str=read_line_or_timeout(server_ctrl,str,SocketTimeout);
  435.           PrintMessage(ExtraDebug,"FTP: sent 'SIZE %s'; got: %s",file,str);
  436.          }
  437.        while(str && (!isdigit(str[0]) || !isdigit(str[1]) || !isdigit(str[2]) || str[3]!=' '));
  439.        if (atoi(str) == 213)
  440.           if (str[4])
  441.              sprintf(sizebuf, "%ld", (long)atoi(str+4));
  443.        if(write_formatted(server_ctrl,"MDTM %srn",file)==-1)
  444.          {
  445.           msg=PrintMessage(Warning,"Failed to write 'MDTM' command to remote FTP host [%!s].");
  446.           return(msg);
  447.          }
  449.        do
  450.          {
  451.           str=read_line_or_timeout(server_ctrl,str,SocketTimeout);
  452.           PrintMessage(ExtraDebug,"FTP: sent 'MDTM %s'; got: %s",file,str);
  453.          }
  454.        while(str && (!isdigit(str[0]) || !isdigit(str[1]) || !isdigit(str[2]) || str[3]!=' '));
  456.        if (atoi(str) == 213)
  457.          {
  458.           int year, mon, mday, hour, min, sec;
  460.           if (sscanf(str, "%*d %4d%2d%2d%2d%2d%2d", &year, &mon, &mday, &hour, &min, &sec) == 6)
  461.             {
  462.              memset(&modtime, 0, sizeof(modtime));
  463.              modtime.tm_year = year - 1900;
  464.              modtime.tm_mon = mon - 1;
  465.              modtime.tm_mday = mday;
  466.              modtime.tm_hour = hour;
  467.              modtime.tm_min = min;
  468.              modtime.tm_sec = sec;
  469.             }
  470.          }
  471.       }
  472.    }
  474.  /* Create the data connection. */
  476.  if(write_string(server_ctrl,"PASVrn")==-1)
  477.    {
  478.     msg=PrintMessage(Warning,"Failed to write 'PASV' command to remote FTP host [%!s].");
  479.     return(msg);
  480.    }
  482.  do
  483.    {
  484.     str=read_line_or_timeout(server_ctrl,str,SocketTimeout);
  485.     PrintMessage(ExtraDebug,"FTP: sent 'PASV'; got: %s",str);
  486.    }
  487.  while(str && (!isdigit(str[0]) || !isdigit(str[1]) || !isdigit(str[2]) || str[3]!=' '));
  489.  if(!str || atoi(str)!=227)
  490.    {
  491.     if(str)
  492.       {
  493.        char *p=str+strlen(str)-1;
  494.        while(*p=='n' || *p=='r') *p--=0;
  495.        msg=PrintMessage(Warning,"Got '%s' message after sending 'PASV' command",str);
  496.       }
  497.     else
  498.        msg=PrintMessage(Warning,"No reply from FTP server to 'PASV' command; timed out?");
  499.     return(msg);
  500.    }
  502.  if((host=strchr(str,',')))
  503.    {
  504.     while(isdigit(*--host));
  505.     host++;
  506.    }
  508.  if(!host || sscanf(host,"%*d,%*d,%*d,%*d%n,%d,%d",&l,&port_h,&port_l)!=2)
  509.    {
  510.     char *p=str+strlen(str)-1;
  511.     while(*p=='n' || *p=='r') *p--=0;
  512.     msg=PrintMessage(Warning,"Got '%s' message after sending 'PASV' command, cannot parse.",str);
  513.     return(msg);
  514.    }
  516.  host[l]=0;
  517.  for(;l>0;l--)
  518.     if(host[l]==',')
  519.        host[l]='.';
  521.  server_data=OpenClientSocket(host,port_l+256*port_h,ConnectTimeout);
  522.  init_buffer(server_data);
  524.  if(server_data==-1)
  525.    {
  526.     msg=PrintMessage(Warning,"Cannot open the FTP data connection [%!s].");
  527.     return(msg);
  528.    }
  530.  /* Make the request */
  532.  if(!strcmp(request_head->method,"GET"))
  533.    {
  534.     if(file)
  535.       {
  536.        if(write_formatted(server_ctrl,"RETR %srn",file)==-1)
  537.          {
  538.           msg=PrintMessage(Warning,"Failed to write 'RETR' command to remote FTP host [%!s].");
  539.           return(msg);
  540.          }
  542.        do
  543.          {
  544.           str=read_line_or_timeout(server_ctrl,str,SocketTimeout);
  545.           PrintMessage(ExtraDebug,"FTP: sent 'RETR %s'; got: %s",file,str);
  546.          }
  547.        while(str && (!isdigit(str[0]) || !isdigit(str[1]) || !isdigit(str[2]) || str[3]!=' '));
  549.        mimetype=WhatMIMEType(file);
  550.       }
  551.     else
  552.       {
  553.        if(write_string(server_ctrl,"LIST -arn")==-1)
  554.          {
  555.           msg=PrintMessage(Warning,"Failed to write 'LIST -a' command to remote FTP host [%!s].");
  556.           return(msg);
  557.          }
  559.        do
  560.          {
  561.           str=read_line_or_timeout(server_ctrl,str,SocketTimeout);
  562.           PrintMessage(ExtraDebug,"FTP: sent 'LIST -a'; got: %s",str);
  563.          }
  564.        while(str && (!isdigit(str[0]) || !isdigit(str[1]) || !isdigit(str[2]) || str[3]!=' '));
  566.        mimetype="text/html";
  567.       }
  569.     if(str && (atoi(str)==150 || atoi(str)==125))
  570.       {
  571.        char *p=str;
  572.        while(*p!='r' && *p!='n')
  573.           p++;
  574.        *p=0;
  575.       }
  576.     else
  577.       {
  578.        if(str)
  579.          {
  580.           char *p=str+strlen(str)-1;
  581.           while(*p=='n' || *p=='r') *p--=0;
  582.           msg=PrintMessage(Warning,"Got '%s' message after sending '%s' command to FTP server.",str,file?"RETR":"LIST -a");
  583.          }
  584.        else
  585.           msg=PrintMessage(Warning,"No reply from FTP server to '%s' command; timed out?",file?"RETR":"LIST -a");
  586.        return(msg);
  587.       }
  588.    }
  589.  else if(file) /* PUT */
  590.    {
  591.     if(file)
  592.       {
  593.        if(write_formatted(server_ctrl,"STOR %srn",file)==-1)
  594.          {
  595.           msg=PrintMessage(Warning,"Failed to write 'STOR' command to remote FTP host [%!s].");
  596.           return(msg);
  597.          }
  599.        do
  600.          {
  601.           str=read_line_or_timeout(server_ctrl,str,SocketTimeout);
  602.           PrintMessage(ExtraDebug,"FTP: sent 'STOR %s'; got: %s",file,str);
  603.          }
  604.        while(str && (!isdigit(str[0]) || !isdigit(str[1]) || !isdigit(str[2]) || str[3]!=' '));
  606.        mimetype="text/html";
  607.       }
  608.     else
  609.       {
  610.        msg=PrintMessage(Warning,"Cannot use the PUT method on a directory name");
  611.        return(msg);
  612.       }
  614.     if(str && (atoi(str)==150 || atoi(str)==125))
  615.       {
  616.        char *p=str;
  617.        while(*p!='r' && *p!='n')
  618.           p++;
  619.        *p=0;
  620.       }
  621.     else
  622.       {
  623.        if(str)
  624.          {
  625.           char *p=str+strlen(str)-1;
  626.           while(*p=='n' || *p=='r') *p--=0;
  627.           msg=PrintMessage(Warning,"Got '%s' message after sending 'STOR' command to FTP server.",str);
  628.          }
  629.        else
  630.           msg=PrintMessage(Warning,"No reply from FTP server to 'STOR' command; timed out?");
  631.        return(msg);
  632.       }
  634.     write_data(server_data,request_body->content,request_body->length);
  635.    }
  637.  /* Prepare the HTTP header. */
  639.  if(!strcmp(request_head->method,"GET"))
  640.    {
  641.     mtime=mktime(&modtime);
  642.     if(mtime!=-1)
  643.        timestamp=RFC822Date(mtime,1);
  644.     else
  645.        timestamp=RFC822Date(time(NULL),1);
  646.  
  647.     if(*sizebuf)
  648.        bufferhead=HTMLMessageHead(-1,200,str+4,
  649.                                   "Content-Type",mimetype,
  650.                                   "Last-Modified",timestamp,
  651.                                   "Content-Length",sizebuf,
  652.                                   NULL);
  653.     else
  654.        bufferhead=HTMLMessageHead(-1,200,str+4,
  655.                                   "Content-Type",mimetype,
  656.                                   "Last-Modified",timestamp,
  657.                                   NULL);
  658.    }
  659.  else
  660.    {
  661.     bufferhead=HTMLMessageHead(-1,200,str+4,
  662.                                "Content-Type",mimetype,
  663.                                NULL);
  664.    }
  666.  buffer=NULL;
  667.  buffertail=NULL;
  669.  if(!strcmp(request_head->method,"GET"))
  670.    {
  671.     if(!file)
  672.       {
  673.        if(msg_reply)
  674.          {
  675.           char *old_msg_reply=msg_reply;
  676.           msg_reply=HTMLString(msg_reply);
  677.           free(old_msg_reply);
  678.          }
  680.        buffer=HTMLMessageBody(-1,"FTPDir-Head",
  681.                               "url",URLDecode(Url->name,0),
  682.                               "message",msg_reply,
  683.                               NULL);
  685.        buffertail=HTMLMessageBody(-1,"FTPDir-Tail",
  686.                                   NULL);
  687.       }
  688.    }
  689.  else
  690.    {
  691.     buffer=HTMLMessageBody(-1,"FTPPut",
  692.                            "url",URLDecode(Url->name,0),
  693.                            NULL);
  695.    }
  697. near_end:
  699.  if(msg_reply)
  700.     free(msg_reply);
  702.  nbufferhead=strlen(bufferhead); nreadhead=0;
  703.  nbuffer=buffer?strlen(buffer):0; nread=0;
  704.  nbuffertail=buffertail?strlen(buffertail):0; nreadtail=0;
  706.  free(str);
  707.  free(path);
  709.  return(msg);
  710. }
  713. /*++++++++++++++++++++++++++++++++++++++
  714.   Read a line from the header of the reply for the URL.
  716.   char *FTP_ReadHead Returns the next line of data, NULL on EOF.
  718.   char *line The previous line read.
  719.   ++++++++++++++++++++++++++++++++++++++*/
  721. char *FTP_ReadHead(char *line)
  722. {
  723.  char *l=line;
  724.  int m;
  726.  /* Take a simple route if it is proxied. */
  728.  if(proxy)
  729.     return(read_line_or_timeout(server_ctrl,line,SocketTimeout));
  730.  
  731.  /* Else send the header. */
  733.  if(nreadhead==nbufferhead)
  734.     return(NULL);
  736.  for(m=nreadhead;m<nbufferhead;m++)
  737.     if(bufferhead[m]=='n')
  738.        break;
  740.  m++;
  741.  l=(char*)realloc((void*)l,m-nreadhead+1);
  742.  strncpy(l,&bufferhead[nreadhead],m-nreadhead);
  743.  l[m-nreadhead]=0;
  745.  nreadhead=m;
  747.  return(l);
  748. }
  751. /*++++++++++++++++++++++++++++++++++++++
  752.   Read bytes from the body of the reply for the URL.
  754.   int FTP_ReadBody Returns the number of bytes read on success, -1 on error.
  756.   char *s A string to fill in with the information.
  758.   int n The number of bytes to read.
  759.   ++++++++++++++++++++++++++++++++++++++*/
  761. int FTP_ReadBody(char *s,int n)
  762. {
  763.  int m=0;
  765.  /* Take a simple route if it is proxied. */
  767.  if(proxy)
  768.     return(read_data_or_timeout(server_ctrl,s,n,SocketTimeout));
  769.  
  770.  /* Else send the data then the tail. */
  772.  if(server_data==-1)            /* Redirection */
  773.    {
  774.     for(;nread<nbuffer && m<n;nread++,m++)
  775.        s[m]=buffer[nread];
  777.     for(;nreadtail<nbuffertail && m<n;nreadtail++,m++)
  778.        s[m]=buffertail[nreadtail];
  779.    }
  780.  else if(!buffer && !buffertail) /* File not dir entry. */
  781.     m=read_data_or_timeout(server_data,s,n,SocketTimeout);
  782.  else if(buffer && buffertail)  /* Middle of dir entry */
  783.    {
  784.     for(;nread<nbuffer && m<n;nread++,m++)
  785.        s[m]=buffer[nread];
  787.     if(nread==nbuffer)
  788.       {
  789.        buffer=htmlise_dir_entry(buffer);
  790.        if(buffer)
  791.           nbuffer=strlen(buffer),nread=0;
  792.       }
  794.     if(!buffer)
  795.        for(;nreadtail<nbuffertail && m<n;nreadtail++,m++)
  796.           s[m]=buffertail[nreadtail];
  797.    }
  798.  else if(!buffer && buffertail) /* End of dir entry. */
  799.    {
  800.     for(;nreadtail<nbuffertail && m<n;nreadtail++,m++)
  801.        s[m]=buffertail[nreadtail];
  802.    }
  803.  else /* if(buffer && !buffertail) */ /* Done a PUT */
  804.    {
  805.     for(;nread<nbuffer && m<n;nread++,m++)
  806.        s[m]=buffer[nread];
  807.    }
  809.  return(m);
  810. }
  813. /*++++++++++++++++++++++++++++++++++++++
  814.   Close a connection opened using FTP.
  816.   int FTP_Close Return 0 on success, -1 on error.
  817.   ++++++++++++++++++++++++++++++++++++++*/
  819. int FTP_Close(void)
  820. {
  821.  int err=0;
  822.  char *str=NULL;
  824.  /* Take a simple route if it is proxied. */
  826.  if(proxy)
  827.     return(CloseSocket(server_ctrl));
  829.  /* Else say goodbye and close all of the sockets, */
  831.  if(server_data!=-1)
  832.     CloseSocket(server_data);
  834.  write_string(server_ctrl,"QUITrn");
  836.  do
  837.    {
  838.     str=read_line_or_timeout(server_ctrl,str,SocketTimeout);
  839.     PrintMessage(ExtraDebug,"FTP: sent 'QUIT'; got: %s",str);
  840.    }
  841.  while(str && (!isdigit(str[0]) || !isdigit(str[1]) || !isdigit(str[2]) || str[3]!=' '));
  843.  err=CloseSocket(server_ctrl);
  845.  if(bufferhead)
  846.     free(bufferhead);
  848.  if(buffer)
  849.     free(buffer);
  851.  if(buffertail)
  852.     free(buffertail);
  854.  return(err);
  855. }
  858. /*++++++++++++++++++++++++++++++++++++++
  859.   Convert a line from the ftp server dir listing into a pretty listing.
  861.   char *htmlise_dir_entry Returns the next line.
  863.   char *line The previous line.
  864.   ++++++++++++++++++++++++++++++++++++++*/
  866. static char *htmlise_dir_entry(char *line)
  867. {
  868.  int i,isdir=0,islink=0;
  869.  char *q,*p[16],*l,*file=NULL,*link=NULL;
  871.  l=read_line_or_timeout(server_data,line,SocketTimeout);
  873.  if(!l)
  874.     return(l);
  876.  for(q=l,i=0;*q && i<16;i++)
  877.    {
  878.     while(*q==' ' || *q=='t')
  879.        q++;
  880.     if(*q=='n' || *q=='r')
  881.        break;
  882.     if(*q)
  883.        p[i]=q;
  884.     while(*q && *q!=' ' && *q!='t' && *q!='r' && *q!='n')
  885.        q++;
  886.    }
  888.  if((*p[0]=='-' || *p[0]=='d' || *p[0]=='l') && i>=8) /* A UNIX 'ls -l' listing. */
  889.    {
  890.     if(i==8)
  891.       {file=p[7]; link=file;}
  892.     else if(i==10 && (*p[8]=='-' && *(p[8]+1)=='>'))
  893.       {file=p[7]; link=p[9];}
  894.     else if(i==9)
  895.       {file=p[8]; link=file;}
  896.     else if(i==11 && (*p[9]=='-' && *(p[9]+1)=='>'))
  897.       {file=p[8]; link=p[10];}
  899.     if(*p[0]=='d')
  900.        isdir=1;
  902.     if(*p[0]=='l')
  903.        islink=1;
  904.    }
  906.  if(file)
  907.    {
  908.     char *endf,endfc,*endl,endlc,*ll,*fileurlenc,*linkurlenc;
  910.     endf=file;
  911.     while(*endf && *endf!=' ' && *endf!='t' && *endf!='r' && *endf!='n')
  912.        endf++;
  913.     endfc=*endf;
  915.     endl=link;
  916.     while(*endl && *endl!=' ' && *endl!='t' && *endl!='r' && *endl!='n')
  917.        endl++;
  918.     endlc=*endl;
  920.     *endf=0;
  921.     fileurlenc=URLEncode(file);
  922.     *endf=endfc;
  924.     *endl=0;
  925.     linkurlenc=URLEncode(link);
  926.     *endl=endlc;
  928.     ll=(char*)malloc(strlen(l)+strlen(fileurlenc)+strlen(linkurlenc)+40);
  930.     strncpy(ll,l,file-l);
  931.     strcpy(ll+(file-l),"<a href="");
  932.     strcat(ll,"./");
  933.     strcat(ll,fileurlenc);
  934.     if(isdir && *(endl-1)!='/')
  935.        strcat(ll,"/");
  936.     strcat(ll,"">");
  937.     *endf=0;
  938.     strcat(ll,file);
  939.     *endf=endfc;
  940.     strcat(ll,"</a>");
  942.     if(islink)
  943.       {
  944.        strncat(ll,endf,link-endf);
  945.        strcat(ll,"<a href="");
  946.        if(strncmp(linkurlenc,"../",3) && strncmp(linkurlenc,"./",2) && strncmp(linkurlenc,"/",1))
  947.           strcat(ll,"./");
  948.        strcat(ll,linkurlenc);
  949.        strcat(ll,"">");
  950.        *endl=0;
  951.        strcat(ll,link);
  952.        *endl=endlc;
  953.        strcat(ll,"</a>");
  955.        strcat(ll,endl);
  956.       }
  957.     else
  958.       {
  959.        strcat(ll,endf);
  960.       }
  962.     free(fileurlenc);
  963.     free(linkurlenc);
  964.     if(l)
  965.        free(l);
  966.     l=ll;
  967.    }
  969.  return(l);
  970. }