#include <curlhttpt.h>

Inheritance diagram for CURLHTTPTransport:

Collaboration diagram for CURLHTTPTransport:

Public Member Functions
int	copyDirectory (const char urlPrefix, const char dir, const char dest, const char suffix)

	CURLHTTPTransport (const char host, StatusReporter statusReporter=0)

virtual std::vector< struct DirEntry >	getDirList (const char *dirURL)

long	getTimeoutMillis ()

virtual char	getURL (const char destPath, const char sourceURL, SWBuf *destBuf=0)

bool	isPassive ()

bool	isUnverifiedPeerAllowed ()

virtual char	putURL (const char destURL, const char sourcePath, SWBuf *sourceBuf=0)

void	setPassive (bool passive)

void	setPasswd (const char *passwd)

void	setTimeoutMillis (long timeoutMillis)

void	setUnverifiedPeerAllowed (bool val)

void	setUser (const char *user)

void	terminate ()

	~CURLHTTPTransport ()

Protected Attributes
SWBuf	host

SWBuf	p

bool	passive

StatusReporter *	statusReporter

bool	term

long	timeoutMillis

SWBuf	u

bool	unverifiedPeerAllowed

Private Attributes
CURL *	session

Detailed Description

Definition at line 34 of file curlhttpt.h.

Constructor & Destructor Documentation

CURLHTTPTransport::CURLHTTPTransport	(	const char *	host,
		StatusReporter *	statusReporter = `0`
	)

Definition at line 105 of file curlhttpt.cpp.

                                                                          : RemoteTransport(host, sr) {
     session = (CURL *)curl_easy_init();
 }

CURLHTTPTransport::~CURLHTTPTransport ( )

Definition at line 110 of file curlhttpt.cpp.

                                       {
     curl_easy_cleanup(session);
 }

Member Function Documentation

int RemoteTransport::copyDirectory	(	const char *	urlPrefix,
		const char *	dir,
		const char *	dest,
		const char *	suffix
	)

inherited

network copy recursively a remote directly

Returns: error status 0: OK; -1: operation error, -2: connection error; -3: user requested termination

Definition at line 140 of file remotetrans.cpp.

                                                                                                                {
 SWLOGD("RemoteTransport::copyDirectory");
     int retVal = 0;
 
     SWBuf url = SWBuf(urlPrefix) + SWBuf(dir);
     removeTrailingSlash(url);
     url += '/';
     
 SWLOGD("NetTransport: getting dir %s\n", url.c_str());
     vector<struct DirEntry> dirList = getDirList(url.c_str());
 
     if (!dirList.size()) {
         SWLog::getSystemLog()->logWarning("NetTransport: failed to read dir %s\n", url.c_str());
         return -1;
     }
 
     // append files in sub directories and calculate total download size
     unsigned int i = 0;
     long totalBytes = 0;
     for (;;) {
         if (i == dirList.size())
             break;
 
         struct DirEntry &e = dirList.at(i);
 
         if (e.isDirectory) {
             SWBuf name(e.name); // &e will be invalidated after first insertion
             vector<struct DirEntry> sd = getDirList((url + name + '/').c_str());
             for (unsigned int ii = 0; ii < sd.size(); ii++) {
                 sd[ii].name = name + '/' + sd[ii].name;
                 dirList.push_back(sd[ii]);
             }
             dirList.erase(dirList.begin() + i);
         }
         else {
             totalBytes += e.size;
             i++;
         }
     }
 
     long completedBytes = 0;
     for (i = 0; i < dirList.size(); i++) {
         struct DirEntry &dirEntry = dirList[i];
         SWBuf buffer = (SWBuf)dest;
         removeTrailingSlash(buffer);
         buffer += "/";
         buffer += dirEntry.name;
         if (!strcmp(&buffer.c_str()[buffer.length()-strlen(suffix)], suffix)) {
             SWBuf buffer2 = "Downloading (";
             buffer2.appendFormatted("%d", i+1);
             buffer2 += " of ";
             buffer2.appendFormatted("%d", dirList.size());
             buffer2 += "): ";
             buffer2 += dirEntry.name;
             if (statusReporter)
                 statusReporter->preStatus(totalBytes, completedBytes, buffer2.c_str());
             FileMgr::createParent(buffer.c_str());  // make sure parent directory exists
             SWTRY {
                 SWBuf url = (SWBuf)urlPrefix + (SWBuf)dir;
                 removeTrailingSlash(url);
                 url += "/";
                 url += dirEntry.name;
                 retVal = getURL(buffer.c_str(), url.c_str());
                 if (retVal) {
                     SWLog::getSystemLog()->logWarning("copyDirectory: failed to get file %s\n", url.c_str());
                     return retVal;
                 }
                 completedBytes += dirEntry.size;
             }
             SWCATCH (...) {}
             if (term) {
                 retVal = -3;
                 break;
             }
         }
     }
     return retVal;
 }

vector< struct DirEntry > CURLHTTPTransport::getDirList ( const char * dirURL )

virtual

Reimplemented from RemoteTransport.

Definition at line 215 of file curlhttpt.cpp.

                                                                         {
     
     vector<struct DirEntry> dirList;
     
     SWBuf dirBuf;
     const char *pBuf;
     char *pBufRes;
     SWBuf possibleName;
     double fSize;
     int possibleNameLength = 0;
     
     if (!getURL("", dirURL, &dirBuf)) {
         pBuf = strstr(dirBuf, "<a href=\"");//Find the next link to a possible file name.
         while (pBuf != NULL) {
             pBuf += 9;//move to the start of the actual name.
             pBufRes = (char *)strchr(pBuf, '\"');//Find the end of the possible file name
             if (!pBufRes)
                 break;
             possibleNameLength = (int)(pBufRes - pBuf);
             possibleName.setFormatted("%.*s", possibleNameLength, pBuf);
             if (isalnum(possibleName[0])) {
 SWLOGD("getDirListHTTP: Found a file: %s", possibleName.c_str());
                 pBuf = pBufRes;
                 pBufRes = (char *)findSizeStart(pBuf);
                 fSize = 0;
                 if(pBufRes != NULL) {
                     pBuf = pBufRes;
                     fSize = strtod(pBuf, &pBufRes);
                     if (pBufRes[0] == 'K')
                         fSize *= 1024;
                     else if (pBufRes[0] == 'M')
                         fSize *= 1048576;
                     pBuf = pBufRes;
                 }
                 struct DirEntry i;
                 i.name = possibleName;
                 i.size = (long unsigned int)fSize;
                 i.isDirectory = possibleName.endsWith("/");
                 dirList.push_back(i);
             } else {
                 pBuf += possibleNameLength;
             }
             pBuf++;
             pBuf = strstr(pBuf, "<a href=\"");//Find the next link to a possible file name.
         }
     }
     else
     {
         SWLog::getSystemLog()->logWarning("FTPURLGetDir: failed to get dir %s\n", dirURL);
     }
     return dirList;
 }

long RemoteTransport::getTimeoutMillis ( )

inlineinherited

Definition at line 94 of file remotetrans.h.

94 { return timeoutMillis; }

RemoteTransport::timeoutMillis

long timeoutMillis

Definition: remotetrans.h:61

char CURLHTTPTransport::getURL	(	const char *	destPath,
		const char *	sourceURL,
		SWBuf *	destBuf = `0`
	)

virtual

Reimplemented from RemoteTransport.

Definition at line 115 of file curlhttpt.cpp.

                                                                                           {
     signed char retVal = 0;
     struct FtpFile ftpfile = {destPath, 0, destBuf};
 
     CURLcode res;
 
     if (session) {
         curl_easy_setopt(session, CURLOPT_URL, sourceURL);
 
         SWBuf credentials = u + ":" + p;
         curl_easy_setopt(session, CURLOPT_USERPWD, credentials.c_str());
         curl_easy_setopt(session, CURLOPT_WRITEFUNCTION, my_httpfwrite);
         if (!passive)
             curl_easy_setopt(session, CURLOPT_FTPPORT, "-");
         curl_easy_setopt(session, CURLOPT_NOPROGRESS, 0);
         curl_easy_setopt(session, CURLOPT_FAILONERROR, 1);
         curl_easy_setopt(session, CURLOPT_PROGRESSDATA, statusReporter);
         curl_easy_setopt(session, CURLOPT_PROGRESSFUNCTION, my_httpfprogress);
         curl_easy_setopt(session, CURLOPT_DEBUGFUNCTION, myhttp_trace);
         /* Set a pointer to our struct to pass to the callback */
         curl_easy_setopt(session, CURLOPT_FILE, &ftpfile);
 
         /* Switch on full protocol/debug output */
         curl_easy_setopt(session, CURLOPT_VERBOSE, true);
 #ifndef OLDCURL
         curl_easy_setopt(session, CURLOPT_CONNECTTIMEOUT_MS, timeoutMillis);
         curl_easy_setopt(session, CURLOPT_TIMEOUT_MS, timeoutMillis);
 #else
         curl_easy_setopt(session, CURLOPT_CONNECTTIMEOUT, timeoutMillis/1000);
         curl_easy_setopt(session, CURLOPT_TIMEOUT, timeoutMillis/1000);
 #endif
 
         /* Disable checking host certificate */
         if (isUnverifiedPeerAllowed()) {
             curl_easy_setopt(session, CURLOPT_SSL_VERIFYPEER, false);
         }
 
         /* FTP connection settings */
 
 #if (LIBCURL_VERSION_MAJOR > 7) || \
    ((LIBCURL_VERSION_MAJOR == 7) && (LIBCURL_VERSION_MINOR > 10)) || \
    ((LIBCURL_VERSION_MAJOR == 7) && (LIBCURL_VERSION_MINOR == 10) && (LIBCURL_VERSION_PATCH >= 5))
 #      define EPRT_AVAILABLE 1
 #endif
 
 #ifdef EPRT_AVAILABLE
         curl_easy_setopt(session, CURLOPT_FTP_USE_EPRT, 0);
 SWLOGD("***** using CURLOPT_FTP_USE_EPRT\n");
 #endif
 
 
 SWLOGD("***** About to perform curl easy action. \n");
 SWLOGD("***** destPath: %s \n", destPath);
 SWLOGD("***** sourceURL: %s \n", sourceURL);
         res = curl_easy_perform(session);
 SWLOGD("***** Finished performing curl easy action. \n");
 
         if(CURLE_OK != res) {
             if (CURLE_OPERATION_TIMEDOUT == res
 #ifdef CURLE_FTP_ACCEPT_TIMEOUT
                 || CURLE_FTP_ACCEPT_TIMEOUT == res
 #endif
                ) {
                 retVal = -2;
             }
             else {
                 retVal = -1;
             }
         }
     }
 
     if (ftpfile.fd > 0)
         FileMgr::closeFile(ftpfile.fd); /* close the local file */
 
     return retVal;
 }

bool RemoteTransport::isPassive ( )

inlineinherited

Definition at line 95 of file remotetrans.h.

95 { return passive; }

RemoteTransport::passive

bool passive

Definition: remotetrans.h:60

bool RemoteTransport::isUnverifiedPeerAllowed ( )

inlineinherited

Definition at line 99 of file remotetrans.h.

99 { return unverifiedPeerAllowed; }

RemoteTransport::unverifiedPeerAllowed

bool unverifiedPeerAllowed

Definition: remotetrans.h:63

char RemoteTransport::putURL	(	const char *	destURL,
		const char *	sourcePath,
		SWBuf *	sourceBuf = `0`
	)

virtualinherited

Reimplemented in RTransportGDrive.

Definition at line 85 of file remotetrans.cpp.

                                                                                           {
     SWLog::getSystemLog()->logWarning("RemoteTransport::putURL called but unsupported");
     char retVal = -1;
     return retVal;
 }