rhodes 2.0.3 → 2.1.0

data/platform/shared/net/CURLNetRequest.cpp

@@ -18,7 +18,7 @@ namespace net
 {
 curl_slist *set_curl_options(bool trace, CURL *curl, const char *method, const String& strUrl, const String& strBody,
                              IRhoSession* pSession, Hashtable<String,String>* pHeaders, bool sslVerifyPeer);
-CURLMcode do_curl_perform(CURLM *curlm, CURL *curl);
+CURLcode do_curl_perform(CURLM *curlm, CURL *curl);
 	
 IMPLEMENT_LOGCLASS(CURLNetRequest, "Net");
 
@@ -79,22 +79,6 @@ public:
     }
 };
 
-CURLNetRequest::CURLNetRequest()
-{
-    m_bTraceCalls = rho_conf_getBool("net_trace");
-    m_sslVerifyPeer = true;
-    // Init curl
-    curlm = curl_multi_init();
-    curl = curl_easy_init();
-    curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, &errbuf);
-}
-
-CURLNetRequest::~CURLNetRequest()
-{
-    curl_easy_cleanup(curl);
-    curl_multi_cleanup(curlm);
-}
-
 INetResponse *CURLNetRequest::makeResponse(String strBody, int nErrorCode)
 {
     std::auto_ptr<CURLNetResponseImpl> resp(new CURLNetResponseImpl(strBody, nErrorCode));
@@ -103,71 +87,148 @@ INetResponse *CURLNetRequest::makeResponse(String strBody, int nErrorCode)
     return resp.release();
 }
 
-static size_t curlBodyFileCallback(void *ptr, size_t size, size_t nmemb, void *opaque)
+static size_t curlHeaderCallback(void *ptr, size_t size, size_t nmemb, void *opaque)
 {
-    common::CRhoFile *pFile = (common::CRhoFile*)opaque;
+    Hashtable<String,String>* pHeaders = (Hashtable<String,String>*)opaque;
     size_t nBytes = size*nmemb;
-    RAWTRACE1("Received %d bytes (blob)", nBytes);
-    return pFile->write(ptr, nBytes);
+    String strHeader((const char *)ptr, nBytes);
+    RAWTRACE1("Received header: %s", strHeader.c_str());
+    
+    int nSep = strHeader.find(':');
+    if (nSep > 0 )
+    {		
+        String strName = String_trim(strHeader.substr(0, nSep));
+        String lName;
+        std::transform(strName.begin(), strName.end(), std::back_inserter(lName), &::tolower);
+        
+        String strValue = String_trim(strHeader.substr(nSep+1, strHeader.length() - (nSep+3) ));
+        
+        pHeaders->put(lName, strValue);
+    }
+    
+    return nBytes;
 }
 
 static size_t curlBodyStringCallback(void *ptr, size_t size, size_t nmemb, void *opaque)
 {
     String *pStr = (String *)opaque;
     size_t nBytes = size*nmemb;
-    RAWTRACE1("Received %d bytes (string)", nBytes);
+    RAWTRACE1("Received %d bytes", nBytes);
     pStr->append((const char *)ptr, nBytes);
     return nBytes;
 }
 
 INetResponse* CURLNetRequest::pullData(const String& strUrl, IRhoSession* oSession )
 {
+    RAWLOG_INFO1("GET url: %s", strUrl.c_str());
     return doRequest("GET", strUrl, String(), oSession, null );
 }
 
 INetResponse* CURLNetRequest::pushData(const String& strUrl, const String& strBody, IRhoSession* oSession)
 {
+    RAWLOG_INFO1("POST url: %s", strUrl.c_str());
     return doRequest("POST", strUrl, strBody, oSession, null );
 }
 
 INetResponse* CURLNetRequest::pullCookies(const String& strUrl, const String& strBody, IRhoSession* oSession)
 {
+    RAWLOG_INFO1("POST url: %s (requesting cookies)", strUrl.c_str());
     INetResponse* pResp = doRequest("POST", strUrl, strBody, oSession, null );
     if ( pResp->isOK() )
         ((CURLNetResponseImpl*)pResp)->setCharData(pResp->getCookies());
 
     return pResp;
 }
-	
-INetResponse* CURLNetRequest::doRequest( const char* method, const String& strUrl, const String& strBody, IRhoSession* oSession, Hashtable<String,String>* pHeaders )
+
+INetResponse* CURLNetRequest::doRequest(const char *method, const String& strUrl,
+                                        const String& strBody, IRhoSession *oSession,
+                                        Hashtable<String,String>* pHeaders)
+{
+    return doPull(method, strUrl, strBody, null, oSession, pHeaders);
+}
+
+INetResponse* CURLNetRequest::doPull(const char* method, const String& strUrl,
+                                     const String& strBody, common::CRhoFile *oFile,
+                                     IRhoSession* oSession, Hashtable<String,String>* pHeaders )
 {
-    //TODO: doRequest - pHeaders
-    m_bCancel = false;
     int nRespCode = -1;
     String strRespBody;
-
-    RAWLOG_INFO1("Request url: %s", strUrl.c_str());
+    long nStartFrom = 0;
+    if (oFile)
+        nStartFrom = oFile->size();
 
     rho_net_impl_network_indicator(1);
 
-    curl_slist *hdrs = set_curl_options(method, strUrl, strBody, oSession, pHeaders);
-    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &strRespBody);
-    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, &curlBodyStringCallback);
+    Hashtable<String,String> h;
+    if (pHeaders)
+        h = *pHeaders;
+    
+    for (int nAttempts = 0; nAttempts < 10; ++nAttempts) {
+        String strRespChunk;
+        
+        curl_slist *hdrs = m_curl.set_options(method, strUrl, strBody, oSession, &h);
+        CURL *curl = m_curl.curl();
+        if (pHeaders) {
+            curl_easy_setopt(curl, CURLOPT_HEADERDATA, pHeaders);
+            curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, &curlHeaderCallback);
+        }
+        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &strRespChunk);
+        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, &curlBodyStringCallback);
+        if (nStartFrom > 0)
+            curl_easy_setopt(curl, CURLOPT_RESUME_FROM, nStartFrom);
 
-    CURLMcode err = do_curl_perform(curlm, curl);
-    curl_slist_free_all(hdrs);
+        CURLcode err = m_curl.perform();
+        curl_slist_free_all(hdrs);
+        
+        long statusCode = 0;
+        if (curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &statusCode) != 0)
+            statusCode = 500;
+        if (statusCode == 206) {
+            if (oFile)
+                oFile->write(strRespChunk.c_str(), strRespChunk.size());
+            else
+                strRespBody.append(strRespChunk.c_str(), strRespChunk.size());
+            // Clear counter of attempts because 206 response does not considered to be failed attempt
+            nAttempts = 0;
+        }
+        else {
+            if (oFile) {
+                oFile->movePosToStart();
+                oFile->write(strRespChunk.c_str(), strRespChunk.size());
+            }
+            else
+                strRespBody = strRespChunk;
+        }
+        
+        if (err == CURLE_OPERATION_TIMEDOUT && strRespChunk.size() > 0) {
+            RAWTRACE("Connection was closed by timeout, but we have part of data received; try to restore connection");
+            nStartFrom = oFile ? oFile->size() : strRespBody.size();
+            continue;
+        }
+        
+        nRespCode = getResponseCode(err, strRespBody, oSession);
+        break;
+    }
 
     rho_net_impl_network_indicator(0);
 
-    nRespCode = getResponseCode(err, strRespBody, oSession);
-    if (nRespCode == 200)
+    return makeResponse(strRespBody, nRespCode);
+}
+
+INetResponse* CURLNetRequest::pullFile(const String& strUrl, const String& strFilePath, IRhoSession* oSession, Hashtable<String,String>* pHeaders)
+{
+    int nRespCode = -1;
+    
+    RAWLOG_INFO2("Pull file. Url: %s; File: %s", strUrl.c_str(), strFilePath.c_str());
+    
+    common::CRhoFile oFile;
+    if ( !oFile.open(strFilePath.c_str(),common::CRhoFile::OpenForWrite) ) 
     {
-        RAWTRACE("RESPONSE-----");
-        RAWTRACE(strRespBody.c_str());
-        RAWTRACE("END RESPONSE-----");
+        RAWLOG_ERROR1("pullFile: cannot create file: %s", strFilePath.c_str());
+        return new CURLNetResponseImpl("", nRespCode);
     }
-
-    return makeResponse(strRespBody, nRespCode);
+    
+    return doPull("GET", strUrl, String(), &oFile, oSession, pHeaders);
 }
 
 INetResponse* CURLNetRequest::pushMultipartData(const String& strUrl, VectorPtr<CMultipartItem*>& arItems, IRhoSession* oSession, Hashtable<String,String>* pHeaders)
@@ -177,7 +238,8 @@ INetResponse* CURLNetRequest::pushMultipartData(const String& strUrl, VectorPtr<
     
     rho_net_impl_network_indicator(1);
     
-    curl_slist *hdrs = set_curl_options("POST", strUrl, String(), oSession, pHeaders);
+    curl_slist *hdrs = m_curl.set_options("POST", strUrl, String(), oSession, pHeaders);
+    CURL *curl = m_curl.curl();
     curl_easy_setopt(curl, CURLOPT_WRITEDATA, &strRespBody);
     curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, &curlBodyStringCallback);
 	
@@ -229,7 +291,7 @@ INetResponse* CURLNetRequest::pushMultipartData(const String& strUrl, VectorPtr<
         
     curl_easy_setopt(curl, CURLOPT_HTTPPOST, post);
     
-    CURLMcode err = do_curl_perform(curlm, curl);
+    CURLcode err = m_curl.perform();
 	
     curl_slist_free_all(hdrs);
     curl_formfree(post);
@@ -253,7 +315,6 @@ INetResponse* CURLNetRequest::pushMultipartData(const String& strUrl, CMultipart
 
 INetResponse* CURLNetRequest::pushFile(const String& strUrl, const String& strFilePath, IRhoSession* oSession, Hashtable<String,String>* pHeaders)
 {
-    m_bCancel = false;
     int nRespCode = -1;
     String strRespBody;
 	
@@ -268,7 +329,8 @@ INetResponse* CURLNetRequest::pushFile(const String& strUrl, const String& strFi
 	
     rho_net_impl_network_indicator(1);
 	
-    curl_slist *hdrs = set_curl_options("POST", strUrl, String(), oSession, pHeaders);
+    curl_slist *hdrs = m_curl.set_options("POST", strUrl, String(), oSession, pHeaders);
+    CURL *curl = m_curl.curl();
     curl_easy_setopt(curl, CURLOPT_WRITEDATA, &strRespBody);
     curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, &curlBodyStringCallback);
 	
@@ -281,7 +343,7 @@ INetResponse* CURLNetRequest::pushFile(const String& strUrl, const String& strFi
                  CURLFORM_END);
     curl_easy_setopt(curl, CURLOPT_HTTPPOST, post);
     
-    CURLMcode err = do_curl_perform(curlm, curl);
+    CURLcode err = m_curl.perform();
 	
     curl_slist_free_all(hdrs);
     curl_formfree(post);
@@ -291,57 +353,31 @@ INetResponse* CURLNetRequest::pushFile(const String& strUrl, const String& strFi
     nRespCode = getResponseCode(err, strRespBody, oSession);
     return makeResponse(strRespBody, nRespCode);
 }
-	
-INetResponse* CURLNetRequest::pullFile(const String& strUrl, const String& strFilePath, IRhoSession* oSession, Hashtable<String,String>* pHeaders)
-{
-    m_bCancel = false;
-    int nRespCode = -1;
-    String strRespBody;
-	
-    RAWLOG_INFO2("Pull file. Url: %s; File: %s", strUrl.c_str(), strFilePath.c_str());
-	
-    common::CRhoFile oFile;
-    if ( !oFile.open(strFilePath.c_str(),common::CRhoFile::OpenForWrite) ) 
-    {
-        RAWLOG_ERROR1("pullFile: cannot create file: %s", strFilePath.c_str());
-        return new CURLNetResponseImpl(strRespBody,nRespCode);
-    }
 
-    rho_net_impl_network_indicator(1);
-    
-	curl_slist *hdrs = set_curl_options("GET", strUrl, String(), oSession, pHeaders);
-	curl_easy_setopt(curl, CURLOPT_WRITEDATA, &oFile);
-	curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, &curlBodyFileCallback);
-	
-	CURLMcode err = do_curl_perform(curlm, curl);
-	curl_slist_free_all(hdrs);
-	
-    rho_net_impl_network_indicator(0);
-	
-	nRespCode = getResponseCode(err, strRespBody, oSession );
-    return makeResponse(strRespBody, nRespCode);
-}
-	
-int CURLNetRequest::getResponseCode(CURLMcode err, const String& strRespBody, IRhoSession* oSession )	
+int CURLNetRequest::getResponseCode(CURLcode err, const String& strRespBody, IRhoSession* oSession )	
 {    
-	if (err != CURLM_OK) {
-		RAWLOG_ERROR1("Error when calling curl_multi_perform: %d", err);
-		return -1;
-	}
+    if (err != CURLE_OK)
+        return -1;
 	
     long statusCode = 0;
+    CURL *curl = m_curl.curl();
     if (curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &statusCode) != 0)
         statusCode = 500;
     
-    if (statusCode != 200) {
+    if (statusCode >= 400) {
         RAWLOG_ERROR2("Request failed. HTTP Code: %d returned. HTTP Response: %s",
                       (int)statusCode, strRespBody.c_str());
         if (statusCode == 401)
             if (oSession)
                 oSession->logout();
     }
-	
-	return (int)statusCode;
+    else {
+        RAWTRACE1("RESPONSE----- (%d bytes)", strRespBody.size());
+        RAWTRACE(strRespBody.c_str());
+        RAWTRACE("END RESPONSE-----");
+    }
+
+    return (int)statusCode;
 }
 
 String CURLNetRequest::resolveUrl(const String& strUrl)
@@ -351,15 +387,14 @@ String CURLNetRequest::resolveUrl(const String& strUrl)
 
 void CURLNetRequest::cancel()
 {
-    m_bCancel = true;
-	curl_multi_remove_handle(curlm, curl);
+    m_curl.cancel();
 }
 
 String CURLNetRequest::makeCookies()
 {
 	String cookies;
 	curl_slist *rcookies = NULL;
-	if (curl_easy_getinfo(curl, CURLINFO_COOKIELIST, &rcookies) != 0) {
+	if (curl_easy_getinfo(m_curl.curl(), CURLINFO_COOKIELIST, &rcookies) != 0) {
         // No cookies
         RAWTRACE("No cookies");
         return cookies;
@@ -430,7 +465,9 @@ static int curl_trace(CURL *curl, curl_infotype type, char *data, size_t size, v
         case CURLINFO_DATA_OUT:     text = "=> Send data"; break;
         case CURLINFO_SSL_DATA_IN:  text = "<= Recv SSL data"; break;
         case CURLINFO_SSL_DATA_OUT: text = "=> Send SSL data"; break;
-        default: return 0;
+        default:
+            RAWLOG_INFO1("!! Unknown type of curl trace: %d", (int)type);
+            return 0;
     }
     
     String strData(data, size);
@@ -438,61 +475,40 @@ static int curl_trace(CURL *curl, curl_infotype type, char *data, size_t size, v
     return 0;
 }
 
-static size_t curlHeaderCallback(void *ptr, size_t size, size_t nmemb, void *opaque)
-{
-    Hashtable<String,String>* pHeaders = (Hashtable<String,String>*)opaque;
-    size_t nBytes = size*nmemb;
-    String strHeader((const char *)ptr, nBytes);
-    RAWTRACE1("Received header: %s", strHeader.c_str());
-    
-    int nSep = strHeader.find(':');
-    if (nSep > 0 )
-    {		
-        String strName = String_trim(strHeader.substr(0, nSep));
-        String lName;
-        std::transform(strName.begin(), strName.end(), std::back_inserter(lName), &::tolower);
-
-        String strValue = String_trim(strHeader.substr(nSep+1, strHeader.length() - (nSep+3) ));
-    
-        pHeaders->put(lName, strValue);
-    }
-    
-    return nBytes;
-}
-
-curl_slist *CURLNetRequest::set_curl_options(const char *method, const String& strUrl, const String& strBody,
+curl_slist *CURLNetRequest::CURLHolder::set_options(const char *method, const String& strUrl, const String& strBody,
                              IRhoSession* pSession, Hashtable<String,String>* pHeaders)
 {
-    curl_easy_reset(curl);
+    curl_easy_setopt(m_curl, CURLOPT_BUFFERSIZE, CURL_MAX_WRITE_SIZE-1);
+
     if (strcasecmp(method, "GET") == 0)
-        curl_easy_setopt(curl, CURLOPT_HTTPGET, 1);
+        curl_easy_setopt(m_curl, CURLOPT_HTTPGET, 1);
     else if (strcasecmp(method, "POST") == 0)
-        curl_easy_setopt(curl, CURLOPT_POST, 1);
-    curl_easy_setopt(curl, CURLOPT_URL, strUrl.c_str());
+        curl_easy_setopt(m_curl, CURLOPT_POST, 1);
+    curl_easy_setopt(m_curl, CURLOPT_URL, strUrl.c_str());
     
     // Just to enable cookie parser
-    curl_easy_setopt(curl, CURLOPT_COOKIEFILE, "");
+    curl_easy_setopt(m_curl, CURLOPT_COOKIEFILE, "");
     // It will clear all stored cookies
-    curl_easy_setopt(curl, CURLOPT_COOKIELIST, "ALL");
+    curl_easy_setopt(m_curl, CURLOPT_COOKIELIST, "ALL");
     String session;
     if (pSession)
         session = pSession->getSession();
     
     if (!session.empty()) {
         //RAWTRACE1("Set cookie: %s", session.c_str());
-        curl_easy_setopt(curl, CURLOPT_COOKIE, session.c_str());
+        curl_easy_setopt(m_curl, CURLOPT_COOKIE, session.c_str());
     }
     
-    curl_easy_setopt(curl, CURLOPT_TIMEOUT, 180);
-    curl_easy_setopt(curl, CURLOPT_TCP_NODELAY, 1);
+    //curl_easy_setopt(m_curl, CURLOPT_TIMEOUT, timeout);
+    curl_easy_setopt(m_curl, CURLOPT_TCP_NODELAY, 0); //enable Nagle algorithm
     
-    curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, (long)m_sslVerifyPeer);
+    curl_easy_setopt(m_curl, CURLOPT_SSL_VERIFYPEER, (long)m_sslVerifyPeer);
     
     // Set very large timeout in case of local requests
     // It is required because otherwise requests (especially requests to writing!)
     // could repeated twice or more times
-    if (net::URI::isLocalHost(strUrl))
-        curl_easy_setopt(curl, CURLOPT_TIMEOUT, 10*24*60*60);
+    //if (net::URI::isLocalHost(strUrl))
+        curl_easy_setopt(m_curl, CURLOPT_TIMEOUT, 10*24*60*60);
     
     curl_slist *hdrs = NULL;
     // Disable "Expect: 100-continue"
@@ -501,8 +517,8 @@ curl_slist *CURLNetRequest::set_curl_options(const char *method, const String& s
     hdrs = curl_slist_append(hdrs, "Connection: Keep-Alive");
 
     if (strcasecmp(method, "POST") == 0) {
-        curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, strBody.size());
-        curl_easy_setopt(curl, CURLOPT_POSTFIELDS, strBody.c_str());
+        curl_easy_setopt(m_curl, CURLOPT_POSTFIELDSIZE, strBody.size());
+        curl_easy_setopt(m_curl, CURLOPT_POSTFIELDS, strBody.c_str());
     }
     
     bool hasContentType = false;
@@ -514,13 +530,7 @@ curl_slist *CURLNetRequest::set_curl_options(const char *method, const String& s
                 hasContentType = true;
             String strHeader = it->first + ": " + it->second;
             hdrs = curl_slist_append(hdrs, strHeader.c_str());
-//            curl_easy_setopt(curl, CURLOPT_HTTPHEADER, hdrs);
         }
-        
-        //set header callback
-        curl_easy_setopt(curl, CURLOPT_HEADERDATA, pHeaders);
-        curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, &curlHeaderCallback);
-        
     }
     
     if (!hasContentType && strcasecmp(method, "POST") == 0 && strBody.length() > 0)
@@ -533,47 +543,129 @@ curl_slist *CURLNetRequest::set_curl_options(const char *method, const String& s
         hdrs = curl_slist_append(hdrs, strHeader.c_str());
     }
     
-    curl_easy_setopt(curl, CURLOPT_HTTPHEADER, hdrs);
+    curl_easy_setopt(m_curl, CURLOPT_HTTPHEADER, hdrs);
+
+    // Enable all available encodings (identity, deflate and gzip)
+    curl_easy_setopt(m_curl, CURLOPT_ENCODING, "");
+    curl_easy_setopt(m_curl, CURLOPT_HTTP_CONTENT_DECODING, (long)1);
+    curl_easy_setopt(m_curl, CURLOPT_HTTP_TRANSFER_DECODING, (long)1);
     
     if (m_bTraceCalls) {
-        curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, &curl_trace);
-        curl_easy_setopt(curl, CURLOPT_DEBUGDATA, NULL);
-        curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
+        curl_easy_setopt(m_curl, CURLOPT_DEBUGFUNCTION, &curl_trace);
+        curl_easy_setopt(m_curl, CURLOPT_DEBUGDATA, NULL);
+        curl_easy_setopt(m_curl, CURLOPT_VERBOSE, 1L);
     }
     
     return hdrs;
 }
 
-CURLMcode do_curl_perform(CURLM *curlm, CURL *curl)
+CURLNetRequest::CURLHolder::CURLHolder()
+    :m_active(0)
+{
+    m_bTraceCalls = rho_conf_getBool("net_trace");
+    timeout = rho_conf_getInt("net_timeout");
+    if (timeout == 0)
+        timeout = 30; // 30 seconds by default
+    m_sslVerifyPeer = true;
+    
+    m_curlm = curl_multi_init();
+    m_curl = curl_easy_init();
+    curl_easy_setopt(m_curl, CURLOPT_ERRORBUFFER, &errbuf);
+}
+
+CURLNetRequest::CURLHolder::~CURLHolder()
+{
+    curl_easy_cleanup(m_curl);
+    curl_multi_cleanup(m_curlm);
+}
+    
+void CURLNetRequest::CURLHolder::activate()
 {
-    int running = 0;
-    curl_multi_add_handle(curlm, curl);
-    CURLMcode err;
+    common::CMutexLock guard(m_lock);
+    if (m_active > 0)
+        return;
+    ++m_active;
+    curl_multi_add_handle(m_curlm, m_curl);
+}
+
+void CURLNetRequest::CURLHolder::deactivate()
+{
+    common::CMutexLock guard(m_lock);
+    if (m_active == 0)
+        return;
+    --m_active;
+    curl_multi_remove_handle(m_curlm, m_curl);
+}
+
+CURLcode CURLNetRequest::CURLHolder::perform()
+{
+    activate();
+    
+    int const CHUNK = 1;
+    
+    long noactivity = 0;
+    
+    CURLcode result;
     for(;;) {
-        err = curl_multi_perform(curlm, &running);
+        int running;
+        CURLMcode err = curl_multi_perform(m_curlm, &running);
         if (err == CURLM_CALL_MULTI_PERFORM)
             continue;
-        if (err == CURLM_OK && running > 0) {
-            //RAWTRACE("curl_multi_perform returns OK, but we still have active transfers");
-            fd_set rfd, wfd, efd;
-            int n = 0;
-            FD_ZERO(&rfd);
-            FD_ZERO(&wfd);
-            FD_ZERO(&efd);
-            curl_multi_fdset(curlm, &rfd, &wfd, &efd, &n);
-            if (n < 0) n = 0;
-            timeval tv;
-            tv.tv_sec = 0;
-            tv.tv_usec = 100000;
-            select(n, &rfd, &wfd, &efd, &tv);
-            continue;
+        if (err != CURLM_OK) {
+            RAWLOG_ERROR1("curl_multi_perform error: %d", (int)err);
+        }
+        else {
+            if (running > 0 && noactivity < timeout) {
+                RAWTRACE("we still have active transfers but no data ready at this moment; waiting...");
+                fd_set rfd, wfd, efd;
+                int n = 0;
+                FD_ZERO(&rfd);
+                FD_ZERO(&wfd);
+                FD_ZERO(&efd);
+                err = curl_multi_fdset(m_curlm, &rfd, &wfd, &efd, &n);
+                if (err == CURLM_OK) {
+                    if (n > 0) {
+                        timeval tv;
+                        tv.tv_sec = CHUNK;
+                        tv.tv_usec = 0;
+                        int e = select(n + 1, &rfd, &wfd, &efd, &tv);
+                        if (e < 0) {
+                            RAWLOG_ERROR1("select (on curl handles) error: %d", errno);
+                        }
+                        else {
+                            if (e == 0) {
+                                RAWTRACE("No activity on sockets, check them again");
+                                noactivity += CHUNK;
+                            }
+                            else noactivity = 0;
+                            continue;
+                        }
+                    }
+                }
+                else {
+                    RAWLOG_ERROR1("curl_multi_fdset error: %d", (int)err);
+                }
+
+            }
         }
+        int nmsgs;
+        CURLMsg *msg = curl_multi_info_read(m_curlm, &nmsgs);
+        result = CURLE_OK;
+        if (msg && msg->msg == CURLMSG_DONE)
+            result = msg->data.result;
+        if (result == CURLE_OK && noactivity >= timeout)
+            result = CURLE_OPERATION_TIMEDOUT;
+        if (result == CURLE_OK)
+            RAWTRACE("Operation completed successfully");
+        else
+            RAWLOG_ERROR2("Operation finished with error %d: %s", (int)result, curl_easy_strerror(result));
         break;
     }
-    curl_multi_remove_handle(curlm, curl);
-    return err;
+
+    deactivate();
+    return result;
 }
-	
+
 } // namespace net
 } // namespace rho
 

data/platform/shared/net/CURLNetRequest.h

@@ -5,6 +5,7 @@
 #include "curl/curl.h"
 #include "net/INetRequest.h"
 #include "logging/RhoLog.h"
+#include "common/RhoFile.h"
 
 namespace rho
 {
@@ -14,10 +15,41 @@ namespace net
 class CURLNetRequest : public INetRequest
 {
     DEFINE_LOGCLASS;
+    
+    class CURLHolder
+    {
+    public:
+        CURLHolder();
+        ~CURLHolder();
+        
+        CURL *curl() {return m_curl;}
+        
+        curl_slist *set_options(const char *method, const String& strUrl, const String& strBody,
+                                IRhoSession* pSession, Hashtable<String,String>* pHeaders);
+        CURLcode perform();
+        
+        void cancel() {deactivate();}
+        
+        boolean sslVerifyPeer() {return m_sslVerifyPeer;}
+        void sslVerifyPeer(boolean mode) {m_sslVerifyPeer = mode;}
+        
+    private:
+        void activate();
+        void deactivate();
+        
+    private:
+        CURL *m_curl;
+        CURLM *m_curlm;
+        char *errbuf[CURL_ERROR_SIZE];
+        common::CMutex m_lock;
+        int m_active;
+        
+        boolean m_bTraceCalls;
+        long timeout;
+        boolean m_sslVerifyPeer;
+    };
+    
 public:
-    CURLNetRequest();
-    ~CURLNetRequest();
-
     INetResponse *pullData(const String& strUrl, IRhoSession *oSession);
     INetResponse *pushData(const String& strUrl, const String& strBody, IRhoSession *oSession);
     INetResponse *pushFile(const String& strUrl, const String& strFileName, IRhoSession *oSession, Hashtable<String,String>* pHeaders);
@@ -27,27 +59,21 @@ public:
     INetResponse *pullCookies(const String& strUrl, const String& strBody, IRhoSession *oSession);
     INetResponse* doRequest( const char* method, const String& strUrl, const String& strBody, IRhoSession* oSession, Hashtable<String,String>* pHeaders );
 
-    boolean sslVerifyPeer() {return m_sslVerifyPeer;}
-    void sslVerifyPeer(boolean mode) {m_sslVerifyPeer = mode;}
+    boolean sslVerifyPeer() {return m_curl.sslVerifyPeer();}
+    void sslVerifyPeer(boolean mode) {m_curl.sslVerifyPeer(mode);}
     
     String resolveUrl(const String& strUrl);
 
     void cancel();
-    virtual boolean isCancelled(){return m_bCancel;}
+    virtual boolean isCancelled(){return false;}
 
 private:
-    curl_slist *set_curl_options(const char *method, const String& strUrl, const String& strBody,
-                                 IRhoSession* pSession, Hashtable<String,String>* pHeaders);
-    int getResponseCode(CURLMcode err, const String& strRespBody, IRhoSession* oSession);
+    INetResponse* doPull(const char *method, const String &strUrl, const String &strBody, common::CRhoFile *oFile, IRhoSession *oSession, Hashtable<String,String>* pHeaders);
+    int getResponseCode(CURLcode err, const String& strRespBody, IRhoSession* oSession);
     String makeCookies();
     INetResponse *makeResponse(String strBody, int nErrorCode);
-    
-    boolean m_bCancel;
-    CURLM *curlm;
-    CURL *curl;
-    char *errbuf[CURL_ERROR_SIZE];
-    boolean m_bTraceCalls;
-    boolean m_sslVerifyPeer;
+
+    CURLHolder m_curl;
 };
 
 } // namespace net