#include <rtranspgdrive.h>

Inheritance diagram for RTransportGDrive:

Collaboration diagram for RTransportGDrive:

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

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)

	RTransportGDrive (const char host, StatusReporter statusReporter=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 ()

	~RTransportGDrive ()

Protected Attributes
SWBuf	host

SWBuf	p

bool	passive

StatusReporter *	statusReporter

bool	term

long	timeoutMillis

SWBuf	u

bool	unverifiedPeerAllowed

Detailed Description

Definition at line 32 of file rtranspgdrive.h.

Constructor & Destructor Documentation

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

Definition at line 93 of file rtranspgdrive.cpp.

                                                                        : RemoteTransport(host, sr) {
     // session open
 }

RTransportGDrive::~RTransportGDrive ( )

Definition at line 98 of file rtranspgdrive.cpp.

                                     {
     // session cleanup
 }

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 > RemoteTransport::getDirList ( const char * dirURL )

virtualinherited

Reimplemented in CURLHTTPTransport.

Definition at line 92 of file remotetrans.cpp.

                                                                       {
 
 SWLOGD("RemoteTransport::getDirList(%s)", dirURL);
     vector<struct DirEntry> dirList;
     
     SWBuf dirBuf;
     if (!getURL("", dirURL, &dirBuf)) {
         char *start = dirBuf.getRawData();
         char *end = start;
         while (start < (dirBuf.getRawData()+dirBuf.size())) {
             struct ftpparse item;
             bool looking = true;
             for (end = start; *end; end++) {
                 if (looking) {
                     if ((*end == 10) || (*end == 13)) {
                         *end = 0;
                         looking = false;
                     }
                 }
                 else if ((*end != 10) && (*end != 13))
                     break;
             }
 SWLOGD("getDirList: parsing item %s(%d)\n", start, end-start);
             int status = ftpparse(&item, start, (int)(end - start));
             // in ftpparse.h, there is a warning that name is not necessarily null terminated
             SWBuf name;
             name.append(item.name, item.namelen);
 SWLOGD("getDirList: got item %s\n", name.c_str());
             if (status && name != "." && name != "..") {
                 struct DirEntry i;
                 i.name = name;
                 i.size = item.size;
                 i.isDirectory = (item.flagtrycwd == 1);
                 dirList.push_back(i);
             }
             start = end;
         }
     }
     else {
         SWLog::getSystemLog()->logWarning("getDirList: 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 RTransportGDrive::getURL	(	const char *	destPath,
		const char *	sourceURL,
		SWBuf *	destBuf = `0`
	)

virtual

Reimplemented from RemoteTransport.

Definition at line 106 of file rtranspgdrive.cpp.

                                                                                          {
     signed char retVal = 0;
     struct FtpFile ftpfile = {destPath, 0, destBuf};
 #if 0
     
     if (session) {
 
         CURLcode res;
 
         struct MyProgressData pd;
         pd.sr = statusReporter;
         pd.term = &term;
 
         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_fwrite);
         if (!passive)
             curl_easy_setopt(session, CURLOPT_FTPPORT, "-");
         curl_easy_setopt(session, CURLOPT_NOPROGRESS, 0);
         curl_easy_setopt(session, CURLOPT_PROGRESSDATA, &pd);
         curl_easy_setopt(session, CURLOPT_PROGRESSFUNCTION, my_fprogress);
         curl_easy_setopt(session, CURLOPT_DEBUGFUNCTION, my_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);
         curl_easy_setopt(session, CURLOPT_CONNECTTIMEOUT, 45);
         
         /* 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");
 
         // it seems CURL tries to use this option data later for some reason, so we unset here
         curl_easy_setopt(session, CURLOPT_PROGRESSDATA, (void*)NULL);
 
         if(CURLE_OK != res) {
             retVal = -1;
         }
     }
 #endif
 
     if (ftpfile.stream)
         fclose(ftpfile.stream); /* 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 RTransportGDrive::putURL	(	const char *	destURL,
		const char *	sourcePath,
		SWBuf *	sourceBuf = `0`
	)

virtual

Reimplemented from RemoteTransport.

Definition at line 103 of file rtranspgdrive.cpp.

                                                                                            {
     return RemoteTransport::putURL(destURL, sourcePath, sourceBuf);
 }