/*

 * lftp - file transfer program

 *

 * Copyright (c) 1996-2016 by Alexander V. Lukyanov (lav@yars.free.net)

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 3 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program.  If not, see <http://www.gnu.org/licenses/>.

 */

#include <config.h>

#include "trio.h"

#include <unistd.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <fcntl.h>

#include <errno.h>

#include <stdarg.h>

#include <time.h>

#include <fnmatch.h>

#include <locale.h>

#include <assert.h>

#include "Http.h"

#include "ResMgr.h"

#include "log.h"

#include "url.h"

#include "HttpAuth.h"

#include "HttpDir.h"

#include "misc.h"

#include "buffer_ssl.h"

#include "buffer_zlib.h"

#include "ascii_ctype.h"

#if !HAVE_DECL_STRPTIME

CDECL char *strptime(const char *buf, const char *format, struct tm *tm);

#endif

#define super NetAccess

#define max_buf 0x10000

#define HTTP_DEFAULT_PORT	 "80"

#define HTTP_DEFAULT_PROXY_PORT	 "3128"

#define HTTPS_DEFAULT_PORT	 "443"

enum {

   H_Continue=100,

   H_Switching_Protocols=101,

   H_Processing=102,

   H_Ok=200,

   H_Created=201,

   H_Accepted=202,

   H_Non_Authoritative_Information=203,

   H_No_Content=204,

   H_Reset_Content=205,

   H_Partial_Content=206,

   H_Multi_Status=207,

   H_Moved_Permanently=301,

   H_Found=302,

   H_See_Other=303,

   H_Not_Modified=304,

   H_Use_Proxy=305,

   H_Temporary_Redirect=307,

   H_Bad_Request=400,

   H_Unauthorized=401,

   H_Payment_Required=402,

   H_Forbidden=403,

   H_Not_Found=404,

   H_Method_Not_Allowed=405,

   H_Not_Acceptable=406,

   H_Proxy_Authentication_Required=407,

   H_Request_Timeout=408,

   H_Conflict=409,

   H_Gone=410,

   H_Length_Required=411,

   H_Precondition_Failed=412,

   H_Request_Entity_Too_Large=413,

   H_Request_URI_Too_Long=414,

   H_Unsupported_Media_Type=415,

   H_Requested_Range_Not_Satisfiable=416,

   H_Expectation_Failed=417,

   H_Unprocessable_Entity=422,

   H_Locked=423,

   H_Failed_Dependency=424,

   H_Too_Many_Requests=429,

   H_Internal_Server_Error=500,

   H_Not_Implemented=501,

   H_Bad_Gateway=502,

   H_Service_Unavailable=503,

   H_Gateway_Timeout=504,

   H_HTTP_Version_Not_Supported=505,

   H_Insufficient_Storage=507,

};

/* Some status code validation macros: */

#define H_2XX(x)        (((x) >= 200) && ((x) <= 299))

#define H_5XX(x)        (((x) >= 500) && ((x) <= 599))

#define H_PARTIAL(x)    ((x) == H_Partial_Content)

#define H_REDIRECTED(x) (((x) == H_Moved_Permanently) || ((x) == H_Found) || ((x) == H_See_Other) || ((x) == H_Temporary_Redirect))

#define H_EMPTY(x)	(((x) == H_No_Content) || ((x) == H_Reset_Content))

#define H_CONTINUE(x)	((x) == H_Continue || (x) == H_Processing)

#define H_REQUESTED_RANGE_NOT_SATISFIABLE(x) ((x) == H_Requested_Range_Not_Satisfiable)

#define H_TRANSIENT(x)	((x)==H_Request_Timeout || (x)==H_Bad_Gateway || (x)==H_Service_Unavailable || (x)==H_Gateway_Timeout)

#define H_UNSUPPORTED(x) ((x)==H_Bad_Request || (x)==H_Not_Implemented)

#define H_AUTH_REQ(x)	((x)==H_Unauthorized || (x)==H_Proxy_Authentication_Required)

#ifndef EINPROGRESS

#define EINPROGRESS -1

#endif

enum { CHUNK_SIZE_UNKNOWN=-1 };

Http::Connection::Connection(int s,const char *c)

   : closure(c), sock(s)

{

}

Http::Connection::~Connection()

{

   close(sock);

   /* make sure we free buffers before ssl */

   recv_buf=0;

   send_buf=0;

}

void Http::Connection::MakeBuffers()

{

   send_buf=new IOBufferFDStream(

      new FDStream(sock,"<output-socket>"),IOBuffer::PUT);

   recv_buf=new IOBufferFDStream(

      new FDStream(sock,"<input-socket>"),IOBuffer::GET);

}

void Http::Init()

{

   state=DISCONNECTED;

   tunnel_state=NO_TUNNEL;

   body_size=-1;

   bytes_received=0;

   status_code=0;

   status_consumed=0;

   proto_version=0x10;

   sent_eot=false;

   last_method=0;

   default_cwd="/";

   keep_alive=false;

   keep_alive_max=-1;

   array_send=0;

   chunked=false;

   chunked_trailer=false;

   chunk_size=CHUNK_SIZE_UNKNOWN;

   chunk_pos=0;

   request_pos=0;

   no_ranges=false;

   seen_ranges_bytes=false;

   entity_date_set=false;

   sending_proppatch=false;

   no_cache_this=false;

   no_cache=false;

   auth_sent[0]=auth_sent[1]=0;

   auth_scheme[0]=auth_scheme[1]=HttpAuth::NONE;

   use_propfind_now=true;

   retry_after=0;

   hftp=false;

   https=false;

   use_head=true;

   user_agent=0;

   special=HTTP_NONE;

}

Http::Http() : super()

{

   Init();

   Reconfig();

}

Http::Http(const Http *f) : super(f)

{

   Init();

   Reconfig();

}

Http::~Http()

{

   Close();

   Disconnect();

}

void Http::MoveConnectionHere(Http *o)

{

   conn=o->conn.borrow();

   conn->ResumeInternal();

   rate_limit=o->rate_limit.borrow();

   last_method=o->last_method; o->last_method=0;

   last_uri.move_here(o->last_uri);

   last_url.move_here(o->last_url);

   timeout_timer.Reset(o->timeout_timer);

   state=CONNECTED;

   tunnel_state=o->tunnel_state;

   o->Disconnect();

   ResumeInternal();

}

void Http::DisconnectLL()

{

   Enter(this);

   rate_limit=0;

   if(conn)

   {

      LogNote(7,_("Closing HTTP connection"));

      conn=0;

   }

   if(!Error() && !H_AUTH_REQ(status_code))

      auth_sent[0]=auth_sent[1]=0;

   if(state!=DONE && (real_pos>0 || special==HTTP_POST)

   && !Error() && !H_AUTH_REQ(status_code)) {

      if(last_method && !strcmp(last_method,"POST"))

	 SetError(FATAL,_("POST method failed"));

      else if(ModeIs(STORE))

	 SetError(STORE_FAILED,0);

   }

   if(ModeIs(STORE) && H_AUTH_REQ(status_code))

      pos=real_pos=request_pos; // resend all the data again

   last_method=0;

   last_uri.unset();

   last_url.unset();

   ResetRequestData();

   state=DISCONNECTED;

   Leave(this);

}

void Http::ResetRequestData()

{

   body_size=-1;

   bytes_received=0;

   real_pos=no_ranges?0:-1;

   status.set(0);

   status_consumed=0;

   line.set(0);

   sent_eot=false;

   keep_alive=false;

   keep_alive_max=-1;

   array_send=fileset_for_info?fileset_for_info->curr_index():0;

   chunked=false;

   chunked_trailer=false;

   chunk_size=CHUNK_SIZE_UNKNOWN;

   chunk_pos=0;

   request_pos=0;

   propfind=0;

   inflate=0;

   seen_ranges_bytes=false;

   entity_date_set=false;

}

void Http::Close()

{

   if(mode==CLOSED)

      return;

   if(conn && conn->recv_buf)

      conn->recv_buf->Roll();	// try to read any remaining data

   if(conn && keep_alive && (keep_alive_max>0 || keep_alive_max==-1)

   && !ModeIs(STORE) && !conn->recv_buf->Eof() && (state==RECEIVING_BODY || state==DONE))

   {

      conn->recv_buf->Resume();

      conn->recv_buf->Roll();

      if(xstrcmp(last_method,"HEAD"))

      {

	 // check if all data are in buffer

	 if(!chunked)	// chunked is a bit complex, so don't handle it

	 {

	    bytes_received+=conn->recv_buf->Size();

	    conn->recv_buf->Skip(conn->recv_buf->Size());

	 }

	 if(!(body_size>=0 && bytes_received==body_size))

	    goto disconnect;

      }

      // can reuse the connection.

      state=CONNECTED;

      ResetRequestData();

      rate_limit=0;

   }

   else

   {

   disconnect:

      Disconnect();

      DontSleep();

   }

   array_send=0;

   no_cache_this=false;

   auth_sent[0]=auth_sent[1]=0;

   auth_scheme[0]=auth_scheme[1]=HttpAuth::NONE;

   no_ranges=!QueryBool("use-range",hostname);

   use_propfind_now=QueryBool("use-propfind",hostname);

   special=HTTP_NONE;

   special_data.set(0);

   sending_proppatch=false;

   super::Close();

}

void Http::Send(const xstring& str)

{

   if(str.length()==0)

      return;

   LogSend(5,str);

   conn->send_buf->Put(str);

}

void Http::Send(const char *format,...)

{

   va_list va;

   va_start(va,format);

   xstring& str=xstring::vformat(format,va);

   va_end(va);

   Send(str);

}

void Http::Send(const HttpHeader *hdr)

{

   Send("%s: %s\r\n",hdr->GetName(),hdr->GetValue());

}

void Http::AppendHostEncoded(xstring& buf,const char *host)

{

   if(is_ipv6_address(host))

      buf.append('[').append(host).append(']');

   else

      buf.append_url_encoded(host,URL_HOST_UNSAFE);

}

void Http::SendMethod(const char *method,const char *efile)

{

   xstring& stripped_hostname=xstring::get_tmp(hostname);

   stripped_hostname.truncate_at('%');

   xstring ehost;

   AppendHostEncoded(ehost,xidna_to_ascii(stripped_hostname));

   if(portname) {

      ehost.append(':');

      ehost.append(url::encode(portname,URL_PORT_UNSAFE));

   }

   if(!use_head && !strcmp(method,"HEAD"))

      method="GET";

   last_method=method;

   if(file_url)

   {

      efile=file_url;

      if(!proxy)

	 efile+=url::path_index(efile);

      else if(!strncmp(efile,"hftp://",7))

	 efile++;

   }

   if(hftp && mode!=LONG_LIST && mode!=CHANGE_DIR && mode!=MAKE_DIR

   && mode!=REMOVE && mode!=REMOVE_DIR

   && (strlen(efile)<7 || strncmp(efile+strlen(efile)-7,";type=",6))

   && QueryBool("use-type",hostname))

   {

      efile=xstring::format("%s;type=%c",efile,ascii?'a':'i');

   }

   /*

      Handle the case when the user has not given us

      get http://foobar.org (note the absense of the trailing /

      It fixes segfault with a certain webserver which I've

      seen ... (Geoffrey Lee <glee@gnupilgrims.org>).

   */

   if(*efile=='\0')

      efile="/";

   last_uri.set(efile+(proxy?url::path_index(efile):0));

   if(last_uri.length()==0)

      last_uri.set("/");

   if(proxy)

      last_url.set(efile);

   Send("%s %s HTTP/1.1\r\n",method,efile);

   Send("Host: %s\r\n",ehost.get());

   if(user_agent && user_agent[0])

      Send("User-Agent: %s\r\n",user_agent);

   if(!hftp)

   {

      const char *content_type=0;

      if(!strcmp(method,"PUT"))

	 content_type=Query("put-content-type",hostname);

      else if(!strcmp(method,"POST"))

	 content_type=Query("post-content-type",hostname);

      if(content_type && content_type[0])

	 Send("Content-Type: %s\r\n",content_type);

      const char *accept=Query("accept",hostname);

      if(accept && accept[0])

	 Send("Accept: %s\r\n",accept);

      accept=Query("accept-language",hostname);

      if(accept && accept[0])

	 Send("Accept-Language: %s\r\n",accept);

      accept=Query("accept-charset",hostname);

      if(accept && accept[0])

	 Send("Accept-Charset: %s\r\n",accept);

      accept=Query("accept-encoding",hostname);

      if(accept && accept[0])

	 Send("Accept-Encoding: %s\r\n",accept);

      const char *referer=Query("referer",hostname);

      const char *slash="";

      if(!xstrcmp(referer,"."))

      {

	 referer=GetConnectURL(NO_USER+NO_PASSWORD);

	 if(last_char(referer)!='/' && !cwd.is_file)

	    slash="/";

      }

      if(referer && referer[0])

	 Send("Referer: %s%s\r\n",referer,slash);

      xstring cookie;

      MakeCookie(cookie,hostname,efile+(proxy?url::path_index(efile):0));

      if(cookie.length()>0)

	 Send("Cookie: %s\r\n",cookie.get());

   }

}

void Http::SendBasicAuth(const char *tag,const char *auth)

{

   if(!auth || !*auth)

      return;

   int auth_len=strlen(auth);

   char *buf64=string_alloca(base64_length(auth_len)+1);

   base64_encode(auth,buf64,auth_len);

   Send("%s: Basic %s\r\n",tag,buf64);

}

void Http::SendBasicAuth(const char *tag,const char *user,const char *pass)

{

   /* Basic scheme */

   SendBasicAuth(tag,xstring::cat(user,":",pass,NULL));

}

void Http::SendAuth(HttpAuth::target_t target,const char *user,const char *uri)

{

   auth_scheme[target]=HttpAuth::NONE;

   if(!user)

      return;

   HttpAuth *auth=HttpAuth::Get(target,GetFileURL(file,NO_USER),user);

   if(auth && auth->Update(last_method,uri)) {

      auth_sent[target]++;

      Send(auth->GetHeader());

   }

}

void Http::SendProxyAuth()

{

   SendAuth(HttpAuth::PROXY,proxy_user,last_url);

}

void Http::SendAuth()

{

   if(hftp && !auth_scheme[HttpAuth::WWW] && user && pass && QueryBool("use-authorization",proxy)) {

      SendBasicAuth("Authorization",user,pass);

      return;

   }

   SendAuth(HttpAuth::WWW,user?user:auth_user,last_uri);

}

void Http::SendCacheControl()

{

   const char *cc_setting=Query("cache-control",hostname);

   const char *cc_no_cache=(no_cache || no_cache_this)?"no-cache":0;

   if(!*cc_setting)

      cc_setting=0;

   if(!cc_setting && !cc_no_cache)

      return;

   int cc_no_cache_len=xstrlen(cc_no_cache);

   if(cc_no_cache && cc_setting)

   {

      const char *pos=strstr(cc_setting,cc_no_cache);

      if(pos && (pos==cc_setting || pos[-1]==' ')

	     && (pos[cc_no_cache_len]==0 || pos[cc_no_cache_len]==' '))

	 cc_no_cache=0, cc_no_cache_len=0;

   }

   xstring& cc=xstring::join(",",2,cc_no_cache,cc_setting);

   if(*cc)

      Send("Cache-Control: %s\r\n",cc.get());

}

bool Http::ModeSupported()

{

   switch((open_mode)mode)

   {

   case CLOSED:

   case QUOTE_CMD:

   case LIST:

   case CHANGE_MODE:

   case LINK:

   case SYMLINK:

      return false;

   case CONNECT_VERIFY:

   case RETRIEVE:

   case STORE:

   case MAKE_DIR:

   case CHANGE_DIR:

   case ARRAY_INFO:

   case REMOVE_DIR:

   case REMOVE:

   case LONG_LIST:

   case RENAME:

      return true;

   case MP_LIST:

#if USE_EXPAT

      return QueryBool("use-propfind",hostname);

#else

      // without XML parser it is meaningless to retrieve XML file info.

      return false;

#endif

   }

   abort(); // should not happen

}

void Http::DirFile(xstring& path,const xstring& ecwd,const xstring& efile) const

{

   const int base=path.length();

   if(efile[0]=='/') {

      path.append(efile);

   } else if(efile[0]=='~' || ecwd.length()==0 || (ecwd.eq("~") && !hftp)) {

      path.append('/');

      path.append(efile);

   } else {

      size_t min_len=path.length()+1;

      if(ecwd[0]!='/')

	 path.append('/');

      path.append(ecwd);

      if(ecwd.last_char()!='/' && efile.length()>0)

	 path.append('/');

      // reduce . and .. at beginning of efile:

      //  * get the minimum path length (so that we don't remove ~user)

      //  * skip .; handle .. using basename_ptr to chomp the path.

      if(path[min_len]=='~') {

	 while(path[min_len] && path[min_len]!='/')

	    ++min_len;

	 if(path[min_len]=='/')

	    ++min_len;

      }

      const char *e=efile;

      while(e[0]=='.') {

	 if(e[1]=='/' || e[1]==0)

	    ++e;

	 else if(e[1]=='.' && (e[2]=='/' || e[2]==0)) {

	    if(path.length()<=min_len)

	       break;

	    const char *bn=basename_ptr(path+min_len);

	    path.truncate(bn-path);

	    e+=2;

	 } else

	    break;

	 if(*e=='/')

	    ++e;

      }

      path.append(e);

   }

   // remove "/~" or "/~/"

   if(path[base+1]=='~' && path[base+2]==0)

      path.truncate(base+1);

   else if(path[base+1]=='~' && path[base+2]=='/')

      path.set_substr(base,2,"");

}

void Http::SendPropfind(const xstring& efile,int depth)

{

   SendMethod("PROPFIND",efile);

   Send("Depth: %d\r\n",depth);

   if(allprop.length()>0)

   {

      Send("Content-Type: text/xml\r\n");

      Send("Content-Length: %d\r\n",int(allprop.length()));

   }

}

void Http::SendPropfindBody()

{

   Send(allprop);

}

const xstring& Http::FormatLastModified(time_t lm)

{

   static const char weekday_names[][4]={

      "Sun","Mon","Tue","Wed","Thu","Fri","Sat"

   };

   const struct tm *t=gmtime(&lm);

   return xstring::format("%s, %2d %s %04d %02d:%02d:%02d GMT",

      weekday_names[t->tm_wday],t->tm_mday,month_names[t->tm_mon],

      t->tm_year+1900,t->tm_hour,t->tm_min,t->tm_sec);

}

void Http::SendProppatch(const xstring& efile)

{

   SendMethod("PROPPATCH",efile);

   xstring prop(

      ""

      "<propertyupdate xmlns=\"DAV:\">"

	 "<set>"

	    "<prop>"

	       "<getlastmodified>");

   prop.append(FormatLastModified(entity_date)).append(

	       "</getlastmodified>"

	    "</prop>"

	 "</set>"

      "</propertyupdate>");

   Send("Content-Type: text/xml\r\n");

   Send("Content-Length: %d\r\n",int(prop.length()));

   Send("\r\n");

   Send(prop);

}

void Http::SendRequest(const char *connection,const char *f)

{

   xstring efile;

   xstring ecwd;

   bool add_slash=true;

   if(mode==CHANGE_DIR && new_cwd && new_cwd->url)

   {

      const char *efile_c=new_cwd->url+url::path_index(new_cwd->url);

      if(!*efile_c)

	 efile_c="/";

      efile.set(efile_c);

      add_slash=false;

   }

   else

      efile.set(url::encode(f,URL_PATH_UNSAFE));

   if(cwd.url)

      ecwd.set(cwd.url+url::path_index(cwd.url));

   else

   {

      ecwd.set(url::encode(cwd,URL_PATH_UNSAFE));

      if(hftp && ecwd[0]=='/' && ecwd[1]!='~')

      {

	 // root directory in ftp urls needs special encoding. (/%2Fpath)

	 ecwd.set_substr(1,0,"%2F");

      }

   }

   if(cwd.is_file)

   {

      if(efile[0])

	 ecwd.truncate(basename_ptr(ecwd+(!strncmp(ecwd,"/~",2)))-ecwd);

      add_slash=false;

   }

   if(mode==CHANGE_DIR && new_cwd && !new_cwd->url)

      add_slash=!new_cwd->is_file;

   xstring pfile;

   if(proxy && !https)

   {

      const char *proto="http";

      if(hftp)

	 proto="ftp";

      pfile.vset(proto,"://",NULL);

      if(hftp && user && pass)

      {

	 pfile.append(url::encode(user,URL_USER_UNSAFE));

	 if(!QueryBool("use-authorization",proxy))

	 {

	    pfile.append(':');

	    pfile.append(url::encode(pass,URL_PASS_UNSAFE));

	 }

	 pfile.append('@');

      }

      AppendHostEncoded(pfile,hostname);

      if(portname)

      {

	 pfile.append(':');

	 pfile.append(url::encode(portname,URL_PORT_UNSAFE));

      }

   }

   else

   {

      pfile.set("");

   }

   DirFile(pfile,ecwd,efile);

   efile.set(pfile);

   if(pos==0)

      real_pos=0;

   if(ModeIs(STORE))    // can't seek before writing

      real_pos=pos;

#ifdef DEBUG_MP_LIST

   if(mode==RETRIEVE && file[0]==0)

      mode=MP_LIST;

#endif

   switch((open_mode)mode)

   {

   case CLOSED:

   case CONNECT_VERIFY:

      abort(); // cannot happen

   case QUOTE_CMD:

      switch(special)

      {

      case HTTP_POST:

	 entity_size=special_data.length();

	 goto send_post;

      case HTTP_MOVE:

      case HTTP_COPY:

	 SendMethod(special==HTTP_MOVE?"MOVE":"COPY",efile);

	 Send("Destination: %s\r\n",special_data.get());

	 break;

      case HTTP_PROPFIND:

	 SendMethod("PROPFIND",efile);

	 Send("Depth: 1\r\n"); // directory listing required

	 break;

      case HTTP_NONE:

	 abort(); // cannot happen

      }

      break;

   case LIST:

   case CHANGE_MODE:

   case LINK:

   case SYMLINK:

      abort(); // unsupported

   case RETRIEVE:

   retrieve:

      SendMethod("GET",efile);

      if(pos>0 && !no_ranges)

      {

	 if(limit==FILE_END)

	    Send("Range: bytes=%lld-\r\n",(long long)pos);

	 else

	    Send("Range: bytes=%lld-%lld\r\n",(long long)pos,(long long)limit-1);

      }

      break;

   case STORE:

      if(sending_proppatch) {

	 SendProppatch(efile);

	 break;

      }

      if(hftp || strcasecmp(Query("put-method",hostname),"POST"))

	 SendMethod("PUT",efile);

      else

      {

      send_post:

	 SendMethod("POST",efile);

	 pos=0;

      }

      if(entity_size>=0)

	 Send("Content-length: %lld\r\n",(long long)(entity_size-pos));

      if(pos>0 && entity_size<0)

      {

	 request_pos=pos;

	 if(limit==FILE_END)

	    Send("Range: bytes=%lld-\r\n",(long long)pos);

	 else

	    Send("Range: bytes=%lld-%lld\r\n",(long long)pos,(long long)limit-1);

      }

      else if(pos>0)

      {

	 request_pos=pos;

	 Send("Range: bytes=%lld-%lld/%lld\r\n",(long long)pos,

		     (long long)((limit==FILE_END || limit>entity_size ? entity_size : limit)-1),

		     (long long)entity_size);

      }

      if(entity_date!=NO_DATE)

      {

	 Send("Last-Modified: %s\r\n",FormatLastModified(entity_date).get());

	 Send("X-OC-MTime: %ld\r\n",(long)entity_date);	 // for OwnCloud

      }

      break;

   case CHANGE_DIR:

   case LONG_LIST:

   case MP_LIST:

   case MAKE_DIR:

      if(last_char(efile)!='/' && add_slash)

	 efile.append('/');

      if(mode==CHANGE_DIR)

      {

	 if(use_propfind_now)

	    SendPropfind(efile,0);

	 else

	    SendMethod("HEAD",efile);

      }

      else if(mode==LONG_LIST)

	 goto retrieve;

      else if(mode==MAKE_DIR)

      {

	 if(QueryBool("use-mkcol"))

	    SendMethod("MKCOL",efile);

	 else

	 {

	    SendMethod("PUT",efile);

	    Send("Content-Length: 0\r\n");

	 }

	 pos=entity_size=0;

      }

      else if(mode==MP_LIST)

      {

	 SendPropfind(efile,1);

	 pos=0;

      }

      break;

   case(REMOVE):

      SendMethod("DELETE",efile);

      Send("Depth: 0\r\n"); // deny directory removal

      break;

   case(REMOVE_DIR):

      if(efile.last_char()!='/')

	 efile.append('/');

      SendMethod("DELETE",efile);

      break;

   case ARRAY_INFO:

      if(use_propfind_now)

	 SendPropfind(efile,0);

      else

	 SendMethod("HEAD",efile);

      break;

   case RENAME:

      {

	 SendMethod("MOVE",efile);

	 Send("Destination: %s\r\n",GetFileURL(file1).get());

      }

   }

   if(proxy && !https)

      SendProxyAuth();

   SendAuth();

   if(no_cache || no_cache_this)

      Send("Pragma: no-cache\r\n"); // for HTTP/1.0 compatibility

   SendCacheControl();

   if(mode==ARRAY_INFO && !use_head)

      connection="close";

   else if(!ModeIs(STORE))

      connection="keep-alive";

   if(mode!=ARRAY_INFO || connection)

      Send("Connection: %s\r\n",connection?connection:"close");

   Send("\r\n");

   if(special==HTTP_POST)

   {

      if(special_data)

	 Send("%s",special_data.get());

      entity_size=NO_SIZE;

   }

   else if(!xstrcmp(last_method,"PROPFIND"))

      SendPropfindBody();

   keep_alive=false;

   chunked=false;

   chunked_trailer=false;

   chunk_size=CHUNK_SIZE_UNKNOWN;

   chunk_pos=0;

   request_pos=0;

   inflate=0;