Merge remote-tracking branch 'upstream/debian/jessie' into debian/sid

[apt.git] / methods / https.cc

diff --git a/methods/https.cc b/methods/https.cc
index 2a562434b42dab471ae732be2e045a607a6b1957..81060122cd2d486171e4700b27bd9f47b9304e51 100644 (file)
--- a/methods/https.cc
+++ b/methods/https.cc
@@ -3,7 +3,7 @@
 // $Id: http.cc,v 1.59 2004/05/08 19:42:35 mdz Exp $
 /* ######################################################################
 
 // $Id: http.cc,v 1.59 2004/05/08 19:42:35 mdz Exp $
 /* ######################################################################
 

-   HTTPS Acquire Method - This is the HTTPS aquire method for APT.
+   HTTPS Acquire Method - This is the HTTPS acquire method for APT.

    
    It uses libcurl
 
    
    It uses libcurl
 


@@ -18,20 +18,21 @@
 #include <apt-pkg/hashes.h>
 #include <apt-pkg/netrc.h>
 #include <apt-pkg/configuration.h>
 #include <apt-pkg/hashes.h>
 #include <apt-pkg/netrc.h>
 #include <apt-pkg/configuration.h>

+#include <apt-pkg/macros.h>
+#include <apt-pkg/strutl.h>
+#include <apt-pkg/proxy.h>

 
 #include <sys/stat.h>
 #include <sys/time.h>
 
 #include <sys/stat.h>
 #include <sys/time.h>

-#include <utime.h>

 #include <unistd.h>
 #include <unistd.h>

-#include <signal.h>

 #include <stdio.h>
 #include <stdio.h>

-#include <errno.h>
-#include <string.h>

 #include <iostream>
 #include <sstream>
 #include <iostream>
 #include <sstream>

+#include <ctype.h>
+#include <stdlib.h>

 
 

-#include "config.h"

 #include "https.h"
 #include "https.h"

+

 #include <apti18n.h>
                                                                        /*}}}*/
 using namespace std;
 #include <apti18n.h>
                                                                        /*}}}*/
 using namespace std;


@@ -54,16 +55,21 @@ HttpsMethod::parse_header(void *buffer, size_t size, size_t nmemb, void *userp)
    {
       if (me->Server->Result != 416 && me->Server->StartPos != 0)
         ;
    {
       if (me->Server->Result != 416 && me->Server->StartPos != 0)
         ;

-      else if (me->Server->Result == 416 && me->Server->Size == me->File->FileSize())
+      else if (me->Server->Result == 416 && me->Server->TotalFileSize == me->File->FileSize())

       {
          me->Server->Result = 200;
       {
          me->Server->Result = 200;

-        me->Server->StartPos = me->Server->Size;
+        me->Server->StartPos = me->Server->TotalFileSize;
+        // the actual size is not important for https as curl will deal with it
+        // by itself and e.g. doesn't bother us with transport-encoding…
+        me->Server->JunkSize = std::numeric_limits<unsigned long long>::max();

       }
       else
         me->Server->StartPos = 0;
 
       me->File->Truncate(me->Server->StartPos);
       me->File->Seek(me->Server->StartPos);
       }
       else
         me->Server->StartPos = 0;
 
       me->File->Truncate(me->Server->StartPos);
       me->File->Seek(me->Server->StartPos);

+
+      me->Res.Size = me->Server->Size;

    }
    else if (me->Server->HeaderLine(line) == false)
       return 0;
    }
    else if (me->Server->HeaderLine(line) == false)
       return 0;


@@ -75,27 +81,26 @@ size_t
 HttpsMethod::write_data(void *buffer, size_t size, size_t nmemb, void *userp)
 {
    HttpsMethod *me = (HttpsMethod *)userp;
 HttpsMethod::write_data(void *buffer, size_t size, size_t nmemb, void *userp)
 {
    HttpsMethod *me = (HttpsMethod *)userp;

+   size_t buffer_size = size * nmemb;
+   // we don't need to count the junk here, just drop anything we get as
+   // we don't always know how long it would be, e.g. in chunked encoding.
+   if (me->Server->JunkSize != 0)
+      return buffer_size;

 
 

-   if(me->File->Write(buffer, size*nmemb) != true)
-      return false;
-
-   return size*nmemb;
-}
-
-int 
-HttpsMethod::progress_callback(void *clientp, double dltotal, double dlnow, 
-                             double ultotal, double ulnow)
-{
-   HttpsMethod *me = (HttpsMethod *)clientp;
-   if(dltotal > 0 && me->Res.Size == 0) {
-      me->Res.Size = (unsigned long long)dltotal;
+   if (me->ReceivedData == false)
+   {

       me->URIStart(me->Res);
       me->URIStart(me->Res);

+      me->ReceivedData = true;

    }
    }

-   return 0;
+
+   if(me->File->Write(buffer, buffer_size) != true)
+      return false;
+
+   return buffer_size;

 }
 
 // HttpsServerState::HttpsServerState - Constructor                    /*{{{*/
 }
 
 // HttpsServerState::HttpsServerState - Constructor                    /*{{{*/

-HttpsServerState::HttpsServerState(URI Srv,HttpsMethod *Owner) : ServerState(Srv, NULL)
+HttpsServerState::HttpsServerState(URI Srv,HttpsMethod * /*Owner*/) : ServerState(Srv, NULL)

 {
    TimeOut = _config->FindI("Acquire::https::Timeout",TimeOut);
    Reset();
 {
    TimeOut = _config->FindI("Acquire::https::Timeout",TimeOut);
    Reset();


@@ -106,6 +111,9 @@ void HttpsMethod::SetupProxy()                                      /*{{{*/
 {
    URI ServerName = Queue->Uri;
 
 {
    URI ServerName = Queue->Uri;
 

+   // Determine the proxy setting
+   AutoDetectProxy(ServerName);
+

    // Curl should never read proxy settings from the environment, as
    // we determine which proxy to use.  Do this for consistency among
    // methods and prevent an environment variable overriding a
    // Curl should never read proxy settings from the environment, as
    // we determine which proxy to use.  Do this for consistency among
    // methods and prevent an environment variable overriding a


@@ -166,6 +174,7 @@ bool HttpsMethod::Fetch(FetchItem *Itm)
    char curl_errorstr[CURL_ERROR_SIZE];
    URI Uri = Itm->Uri;
    string remotehost = Uri.Host;
    char curl_errorstr[CURL_ERROR_SIZE];
    URI Uri = Itm->Uri;
    string remotehost = Uri.Host;

+   ReceivedData = false;

 
    // TODO:
    //       - http::Pipeline-Depth
 
    // TODO:
    //       - http::Pipeline-Depth


@@ -183,10 +192,12 @@ bool HttpsMethod::Fetch(FetchItem *Itm)
    curl_easy_setopt(curl, CURLOPT_WRITEHEADER, this);
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_data);
    curl_easy_setopt(curl, CURLOPT_WRITEDATA, this);
    curl_easy_setopt(curl, CURLOPT_WRITEHEADER, this);
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_data);
    curl_easy_setopt(curl, CURLOPT_WRITEDATA, this);

-   curl_easy_setopt(curl, CURLOPT_PROGRESSFUNCTION, progress_callback);
-   curl_easy_setopt(curl, CURLOPT_PROGRESSDATA, this);
-   curl_easy_setopt(curl, CURLOPT_NOPROGRESS, false);
+   // options
+   curl_easy_setopt(curl, CURLOPT_NOPROGRESS, true);

    curl_easy_setopt(curl, CURLOPT_FILETIME, true);
    curl_easy_setopt(curl, CURLOPT_FILETIME, true);

+   // only allow curl to handle https, not the other stuff it supports
+   curl_easy_setopt(curl, CURLOPT_PROTOCOLS, CURLPROTO_HTTPS);
+   curl_easy_setopt(curl, CURLOPT_REDIR_PROTOCOLS, CURLPROTO_HTTPS);

 
    // SSL parameters are set by default to the common (non mirror-specific) value
    // if available (or a default one) and gets overload by mirror-specific ones.
 
    // SSL parameters are set by default to the common (non mirror-specific) value
    // if available (or a default one) and gets overload by mirror-specific ones.


@@ -305,7 +316,7 @@ bool HttpsMethod::Fetch(FetchItem *Itm)
    curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, curl_errorstr);
 
    // If we ask for uncompressed files servers might respond with content-
    curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, curl_errorstr);
 
    // If we ask for uncompressed files servers might respond with content-

-   // negotation which lets us end up with compressed files we do not support,
+   // negotiation which lets us end up with compressed files we do not support,

    // see 657029, 657560 and co, so if we have no extension on the request
    // ask for text only. As a sidenote: If there is nothing to negotate servers
    // seem to be nice and ignore it.
    // see 657029, 657560 and co, so if we have no extension on the request
    // ask for text only. As a sidenote: If there is nothing to negotate servers
    // seem to be nice and ignore it.


@@ -320,11 +331,11 @@ bool HttpsMethod::Fetch(FetchItem *Itm)
    // if we have the file send an if-range query with a range header
    if (stat(Itm->DestFile.c_str(),&SBuf) >= 0 && SBuf.st_size > 0)
    {
    // if we have the file send an if-range query with a range header
    if (stat(Itm->DestFile.c_str(),&SBuf) >= 0 && SBuf.st_size > 0)
    {

-      char Buf[1000];
-      sprintf(Buf, "Range: bytes=%li-", (long) SBuf.st_size);
-      headers = curl_slist_append(headers, Buf);
-      sprintf(Buf, "If-Range: %s", TimeRFC1123(SBuf.st_mtime).c_str());
-      headers = curl_slist_append(headers, Buf);
+      std::string Buf;
+      strprintf(Buf, "Range: bytes=%lli-", (long long) SBuf.st_size);
+      headers = curl_slist_append(headers, Buf.c_str());
+      strprintf(Buf, "If-Range: %s", TimeRFC1123(SBuf.st_mtime).c_str());
+      headers = curl_slist_append(headers, Buf.c_str());

    }
    else if(Itm->LastModified > 0)
    {
    }
    else if(Itm->LastModified > 0)
    {


@@ -335,6 +346,7 @@ bool HttpsMethod::Fetch(FetchItem *Itm)
    // go for it - if the file exists, append on it
    File = new FileFd(Itm->DestFile, FileFd::WriteAny);
    Server = new HttpsServerState(Itm->Uri, this);
    // go for it - if the file exists, append on it
    File = new FileFd(Itm->DestFile, FileFd::WriteAny);
    Server = new HttpsServerState(Itm->Uri, this);

+   Res = FetchResult();

 
    // keep apt updated
    Res.Filename = Itm->DestFile;
 
    // keep apt updated
    Res.Filename = Itm->DestFile;


@@ -405,10 +417,11 @@ bool HttpsMethod::Fetch(FetchItem *Itm)
    curl_easy_getinfo(curl, CURLINFO_FILETIME, &Res.LastModified);
    if (Res.LastModified != -1)
    {
    curl_easy_getinfo(curl, CURLINFO_FILETIME, &Res.LastModified);
    if (Res.LastModified != -1)
    {

-      struct utimbuf UBuf;
-      UBuf.actime = Res.LastModified;
-      UBuf.modtime = Res.LastModified;
-      utime(File->Name().c_str(),&UBuf);
+      struct timeval times[2];
+      times[0].tv_sec = Res.LastModified;
+      times[1].tv_sec = Res.LastModified;
+      times[0].tv_usec = times[1].tv_usec = 0;
+      utimes(File->Name().c_str(), times);

    }
    else
       Res.LastModified = resultStat.st_mtime;
    }
    else
       Res.LastModified = resultStat.st_mtime;


@@ -427,7 +440,7 @@ bool HttpsMethod::Fetch(FetchItem *Itm)
    delete File;
 
    return true;
    delete File;
 
    return true;

-};
+}

 
 int main()
 {
 
 int main()
 {