: transfer(t)

{

reset(std::move(p));

{

fa = std::move(p);

// transfer has no slot or slot has no fa: timer is enabled

transfer->bt.enable(!!p);

: fa(ctransfer->client->fsaccess->newfileaccess(), ctransfer)

, retrybt(ctransfer->client->rng, ctransfer->client->transferSlotsBackoff)

{

starttime = 0;

lastprogressreport = 0;

progressreported = 0;

speed = meanSpeed = 0;

progresscontiguous = 0;

lastdata = Waiter::ds;

errorcount = 0;

lasterror = API_OK;

failure = false;

retrying = false;

fileattrsmutable = 0;

connections = 0;

asyncIO = NULL;

pendingcmd = NULL;

transfer = ctransfer;

transfer->slot = this;

transfer->state = TRANSFERSTATE_ACTIVE;

slots_it = transfer->client->tslots.end();

maxRequestSize = MAX_REQ_SIZE;

#if defined(_WIN32) && !defined(WINDOWS_PHONE)

MEMORYSTATUSEX statex;

memset(&statex, 0, sizeof (statex));

statex.dwLength = sizeof (statex);

if (GlobalMemoryStatusEx(&statex))

{

LOG_debug << "RAM stats. Free physical: " << statex.ullAvailPhys << " Free virtual: " << statex.ullAvailVirtual;

if (statex.ullAvailPhys < 1073741824 // 1024 MB

|| statex.ullAvailVirtual < 1073741824)

{

if (statex.ullAvailPhys < 536870912 // 512 MB

|| statex.ullAvailVirtual < 536870912)

{

if (statex.ullAvailPhys < 268435456 // 256 MB

|| statex.ullAvailVirtual < 268435456)

{

maxRequestSize = 2097152; // 2 MB

}

else

{

maxRequestSize = 4194304; // 4 MB

}

}

else

{

maxRequestSize = 8388608; // 8 MB

}

}

else

{

maxRequestSize = 16777216; // 16 MB

}

}

else

{

LOG_warn << "Error getting RAM usage info";

}

#endif

{

// delay creating these until we know if it's raid or non-raid

if (!(connections || reqs.size() || asyncIO))

{

if (transferbuf.tempUrlVector().empty())

{

return false; // too soon, we don't know raid / non-raid yet

}

connections = transferbuf.isRaid() ? RAIDPARTS : (transfer->size > 131072 ? transfer->client->connections[transfer->type] : 1);

LOG_debug << "Populating transfer slot with " << connections << " connections, max request size of " << maxRequestSize << " bytes";

reqs.resize(connections);

mReqSpeeds.resize(connections);

asyncIO = new AsyncIOContext*[connections]();

}

return true;

{

if (!memcmp(req->posturl.c_str(), "http:", 5))

{

size_t portendindex = req->posturl.find("/", 8);

size_t portstartindex = req->posturl.find(":", 8);

if (portendindex != string::npos)

{

if (portstartindex == string::npos)

{

LOG_debug << "Enabling alternative port for chunk";

req->posturl.insert(portendindex, ":8080");

}

else

{

LOG_debug << "Disabling alternative port for chunk";

req->posturl.erase(portstartindex, portendindex - portstartindex);

}

}

}

{

for (int i = connections; i--;)

{

if (reqs[i])

{

reqs[i]->disconnect();

}

}

{

if (transfer->progresscompleted == transfer->size)

{

if (transfer->progresscompleted)

{

transfer->currentmetamac = macsmac(&transfer->chunkmacs);

transfer->hascurrentmetamac = true;

}

// verify meta MAC

if (!transfer->progresscompleted

|| (transfer->currentmetamac == transfer->metamac))

{

client->transfercacheadd(transfer, &committer);

if (transfer->progresscompleted != progressreported)

{

progressreported = transfer->progresscompleted;

lastdata = Waiter::ds;

progress();

}

transfer->complete(committer);

}

else

{

client->sendevent(99431, "MAC verification failed", 0);

transfer->chunkmacs.clear();

transfer->failed(API_EKEY, committer);

}

return true;

}

return false;

{

if (transfer->type == GET && transferbuf.isRaid())

{

// quick early check - if we were getting data but haven't for a while

// then switch channels before we time out entirely (at the halfway-to-timeout mark)

if ((Waiter::ds - reqs[connectionNum]->lastdata) > (XFERTIMEOUT / 2))

{

LOG_warn << "Raid connection " << connectionNum << " has not received data for " << (XFERTIMEOUT / 2) << " deciseconds";

incrementErrors = true;

return true;

}

if (!transferbuf.isUnusedRaidConection(connectionNum) // connection in use

&& mReqSpeeds[connectionNum].requestElapsedDs() > 50 // enough elapsed time to be considered

&& mRaidChannelSwapsForSlowness < 2) // no more than 2 swaps due to slown connections

{

m_off_t averageOtherRate = 0;

unsigned otherCount = 0;

for (unsigned j = RAIDPARTS; j--; )

{

if (j != connectionNum && !transferbuf.isUnusedRaidConection(j))

{

if (transferbuf.isRaidConnectionProgressBlocked(j) // this one can't continue because it would get too far ahead

|| (reqs[j] && reqs[j]->status == REQ_DONE)) // this one reached end of file

{

++otherCount;

averageOtherRate += mReqSpeeds[j].lastRequestSpeed();

}

else

{

return false;

}

}

}

averageOtherRate /= otherCount ? otherCount : 1;

m_off_t thisRate = mReqSpeeds[connectionNum].lastRequestSpeed();

if (thisRate < averageOtherRate / 2 // this is less than half of avg of other connections

&& averageOtherRate > 50 * 1024 // avg is more than 50KB/s

&& thisRate < 1024 * 1024) // this is less than 1MB/s

{

LOG_warn << "Raid connection " << connectionNum

<< " is much slower than its peers, with speed " << thisRate

<< " while they are managing " << averageOtherRate;

mRaidChannelSwapsForSlowness += 1;

incrementErrors = false;

return true;

}

}

}

return false;

{

CodeCounter::ScopeTimer pbt(client->performanceStats.transferslotDoio);

if (!fa || (transfer->size && transfer->progresscompleted == transfer->size)

|| (transfer->type == PUT && transfer->ultoken))

{

if (transfer->type == GET || transfer->ultoken)

{

if (fa && transfer->type == GET)

{

LOG_debug << "Verifying cached download";

transfer->currentmetamac = macsmac(&transfer->chunkmacs);

transfer->hascurrentmetamac = true;

// verify meta MAC

if (transfer->currentmetamac == transfer->metamac)

{

return transfer->complete(committer);

}

else

{

client->sendevent(99432, "MAC verification failed for cached download", 0);

transfer->chunkmacs.clear();

return transfer->failed(API_EKEY, committer);

}

}

// this is a pending completion, retry every 200 ms by default

retrybt.backoff(2);

retrying = true;

return transfer->complete(committer);

}

else

{

client->sendevent(99410, "No upload token available", 0);

return transfer->failed(API_EINTERNAL, committer);

}

}

retrying = false;

retrybt.reset(); // in case we don't delete the slot, and in case retrybt.next=1

transfer->state = TRANSFERSTATE_ACTIVE;

if (!createconnectionsonce()) // don't use connections, reqs, or asyncIO before this point.

{

return;

}

dstime backoff = 0;

m_off_t p = 0;

if (errorcount > 4)

{

LOG_warn << "Failed transfer: too many errors";

return transfer->failed(lasterror, committer);

}

// main loop over connections

for (int i = connections; i--; )

{

if (reqs[i])

{

unsigned slowestStartConnection;

if (transfer->type == GET && reqs[i]->contentlength == reqs[i]->size && transferbuf.detectSlowestRaidConnection(i, slowestStartConnection))

{

LOG_debug << "Connection " << slowestStartConnection << " is the slowest to reply, using the other 5.";

reqs[slowestStartConnection].reset();

transferbuf.resetPart(slowestStartConnection);

i = connections;

continue;

}

if (reqs[i]->status == REQ_FAILURE && reqs[i]->httpstatus == 200 && transfer->type == GET && transferbuf.isRaid()) // the request started out successfully, hence status==200 in the reply headers

{

// check if we got some data and the failure occured partway through the part chunk. If so, best not to waste it, convert to success case with less data

HttpReqDL *downloadRequest = static_cast<HttpReqDL*>(reqs[i].get());

LOG_debug << "Connection " << i << " received " << downloadRequest->bufpos << " before failing, processing data.";

if (downloadRequest->contentlength == downloadRequest->size && downloadRequest->bufpos >= RAIDSECTOR)

{

downloadRequest->bufpos -= downloadRequest->bufpos % RAIDSECTOR; // always on a raidline boundary

downloadRequest->size = unsigned(downloadRequest->bufpos);

transferbuf.transferPos(i) = downloadRequest->bufpos;

downloadRequest->status = REQ_SUCCESS;

}

}

switch (static_cast<reqstatus_t>(reqs[i]->status))

{

case REQ_INFLIGHT:

{

m_off_t delta = mReqSpeeds[i].requestProgressed(reqs[i]->transferred(client));

mTransferSpeed.calculateSpeed(delta);

p += reqs[i]->transferred(client);

assert(reqs[i]->lastdata != NEVER);

bool incrementErrors = false;

if (transfer->type == GET && transferbuf.isRaid()

&& testForSlowRaidConnection(i, incrementErrors))

{

// switch to 5 channel raid to avoid the slow/delayed connection. (or if already switched, try a different 5). If we already tried too many times then let the usual timeout occur

if (tryRaidRecoveryFromHttpGetError(i, incrementErrors))

{

LOG_warn << "Connection " << i << " is slow or stalled, trying the other 5 cloudraid connections";

reqs[i]->disconnect();

reqs[i]->status = REQ_READY;

}

}

if (EVER(reqs[i]->lastdata) && reqs[i]->lastdata > lastdata)

{

// prevent overall timeout if all channels are busy with big chunks for a while

lastdata = reqs[i]->lastdata;

}

break;

}

case REQ_SUCCESS:

{

m_off_t delta = mReqSpeeds[i].requestProgressed(reqs[i]->size);

mTransferSpeed.calculateSpeed(delta);

if (client->orderdownloadedchunks && transfer->type == GET && !transferbuf.isRaid() && transfer->progresscompleted != static_cast<HttpReqDL*>(reqs[i].get())->dlpos)

{

// postponing unsorted chunk

p += reqs[i]->size;

break;

}

lastdata = Waiter::ds;

transfer->lastaccesstime = m_time();

if (!transferbuf.isRaid())

{

LOG_debug << "Transfer request finished (" << transfer->type << ") Position: " << transferbuf.transferPos(i) << " (" << transfer->pos << ") Size: " << reqs[i]->size

<< " Completed: " << (transfer->progresscompleted + reqs[i]->size) << " of " << transfer->size << " speed " << mReqSpeeds[i].lastRequestSpeed();

}

else

{

LOG_debug << "Transfer request finished (" << transfer->type << ") " << " on connection " << i << " part pos: " << transferbuf.transferPos(i) << " of part size " << transferbuf.raidPartSize(i, transfer->size)

<< " Overall Completed: " << (transfer->progresscompleted) << " of " << transfer->size << " speed " << mReqSpeeds[i].lastRequestSpeed();

}

if (transfer->type == PUT)

{

// completed put transfers are signalled through the

// return of the upload token

if (reqs[i]->in.size())

{

if (reqs[i]->in.size() == NewNode::UPLOADTOKENLEN)

{

LOG_debug << "Upload token received";

if (!transfer->ultoken)

{

transfer->ultoken = new byte[NewNode::UPLOADTOKENLEN]();

}

bool tokenOK = true;

if (reqs[i]->in.data()[NewNode::UPLOADTOKENLEN - 1] == 1)

{

LOG_debug << "New style upload token";

memcpy(transfer->ultoken, reqs[i]->in.data(), NewNode::UPLOADTOKENLEN);

}

else

{

LOG_debug << "Old style upload token: " << reqs[i]->in;

tokenOK = (Base64::atob(reqs[i]->in.data(), transfer->ultoken, NewNode::UPLOADTOKENLEN)

== NewNode::OLDUPLOADTOKENLEN);

}

if (tokenOK)

{

errorcount = 0;

transfer->failcount = 0;

transfer->chunkmacs.finishedUploadChunks(static_cast<HttpReqUL*>(reqs[i].get())->mChunkmacs);

updatecontiguousprogress();

transfer->progresscompleted += reqs[i]->size;

memcpy(transfer->filekey, transfer->transferkey.data(), sizeof transfer->transferkey);

((int64_t*)transfer->filekey)[2] = transfer->ctriv;

((int64_t*)transfer->filekey)[3] = macsmac(&transfer->chunkmacs);

SymmCipher::xorblock(transfer->filekey + SymmCipher::KEYLENGTH, transfer->filekey);

client->transfercacheadd(transfer, &committer);

if (transfer->progresscompleted != progressreported)

{

progressreported = transfer->progresscompleted;

lastdata = Waiter::ds;

progress();

}

return transfer->complete(committer);

}

else

{

delete [] transfer->ultoken;

transfer->ultoken = NULL;

}

}

LOG_debug << "Error uploading chunk: " << reqs[i]->in;

error e = (error)atoi(reqs[i]->in.c_str());

if (e == API_EKEY)

{

client->sendevent(99429, "Integrity check failed in upload", 0);

lasterror = e;

errorcount++;

reqs[i]->status = REQ_PREPARED;

break;

}

if (e == DAEMON_EFAILED || (reqs[i]->contenttype.find("text/html") != string::npos

&& !memcmp(reqs[i]->posturl.c_str(), "http:", 5)))

{

client->usehttps = true;

client->app->notify_change_to_https();

if (e == DAEMON_EFAILED)

{

// megad returning -4 should result in restarting the transfer

client->sendevent(99440, "Retry requested by storage server", 0);

}

else

{

LOG_warn << "Invalid Content-Type detected during upload: " << reqs[i]->contenttype;

}

client->sendevent(99436, "Automatic change to HTTPS", 0);

return transfer->failed(API_EAGAIN, committer);

}

// fail with returned error

return transfer->failed(e, committer);

}

transfer->chunkmacs.finishedUploadChunks(static_cast<HttpReqUL*>(reqs[i].get())->mChunkmacs);

transfer->progresscompleted += reqs[i]->size;

updatecontiguousprogress();

if (transfer->progresscompleted == transfer->size)

{

client->sendevent(99409, "No upload token received", 0);

return transfer->failed(API_EINTERNAL, committer);

}

errorcount = 0;

transfer->failcount = 0;

client->transfercacheadd(transfer, &committer);

reqs[i]->status = REQ_READY;

}

else // GET

{

HttpReqDL *downloadRequest = static_cast<HttpReqDL*>(reqs[i].get());

if (reqs[i]->size == reqs[i]->bufpos || downloadRequest->buffer_released) // downloadRequest->buffer_released being true indicates we're retrying this asyncIO

{

if (!downloadRequest->buffer_released)

{

transferbuf.submitBuffer(i, new TransferBufferManager::FilePiece(downloadRequest->dlpos, downloadRequest->release_buf())); // resets size & bufpos. finalize() is taken care of in the transferbuf

downloadRequest->buffer_released = true;

}

auto outputPiece = transferbuf.getAsyncOutputBufferPointer(i);

if (outputPiece)

{

mRaidChannelSwapsForSlowness = 0;

bool parallelNeeded = outputPiece->finalize(false, transfer->size, transfer->ctriv, transfer->transfercipher(), &transfer->chunkmacs);

if (parallelNeeded)

{

// do full chunk (and chunk-remainder) decryption on a thread for throughput and to minimize mutex lock times.

auto req = reqs[i]; // shared_ptr for shutdown safety

auto transferkey = transfer->transferkey;

auto ctriv = transfer->ctriv;

auto filesize = transfer->size;

req->status = REQ_DECRYPTING;

client->mAsyncQueue.push([req, outputPiece, transferkey, ctriv, filesize](SymmCipher& sc)

{

sc.setkey(transferkey.data());

outputPiece->finalize(true, filesize, ctriv, &sc, nullptr);

req->status = REQ_DECRYPTED;

}, false); // not discardable: if we downloaded the data, don't waste it - decrypt and write as much as we can to file

}

else

{

reqs[i]->status = REQ_DECRYPTED;

}

}

else if (transferbuf.isRaid())

{

reqs[i]->status = REQ_READY; // this connection has retrieved a part of the file, but we don't have enough to combine yet for full file output. This connection can start fetching the next piece of that part.

}

else

{

assert(false); // non-raid, if the request succeeded then we must have a piece to write to file.

}

}

else

{

if (reqs[i]->contenttype.find("text/html") != string::npos

&& !memcmp(reqs[i]->posturl.c_str(), "http:", 5))

{

LOG_warn << "Invalid Content-Type detected during download: " << reqs[i]->contenttype;

client->usehttps = true;

client->app->notify_change_to_https();

client->sendevent(99436, "Automatic change to HTTPS", 0);

return transfer->failed(API_EAGAIN, committer);

}

client->sendevent(99430, "Invalid chunk size", 0);

LOG_warn << "Invalid chunk size: " << reqs[i]->size << " - " << reqs[i]->bufpos;

lasterror = API_EREAD;

errorcount++;

reqs[i]->status = REQ_PREPARED;

break;

}

}

break;

}

case REQ_DECRYPTED:

{

// this must return the same piece we just decrypted, since we have not asked the transferbuf to discard it yet.

auto outputPiece = transferbuf.getAsyncOutputBufferPointer(i);

if (fa->asyncavailable())

{

if (asyncIO[i])

{

LOG_warn << "Retrying failed async write";

delete asyncIO[i];

asyncIO[i] = NULL;

}

p += outputPiece->buf.datalen();

LOG_debug << "Writing data asynchronously at " << outputPiece->pos << " to " << (outputPiece->pos + outputPiece->buf.datalen());

asyncIO[i] = fa->asyncfwrite(outputPiece->buf.datastart(), static_cast<unsigned>(outputPiece->buf.datalen()), outputPiece->pos);

reqs[i]->status = REQ_ASYNCIO;

}

else

{

if (fa->fwrite(outputPiece->buf.datastart(), static_cast<unsigned>(outputPiece->buf.datalen()), outputPiece->pos))

{

LOG_verbose << "Sync write succeeded";

transferbuf.bufferWriteCompleted(i, true);

errorcount = 0;

transfer->failcount = 0;

updatecontiguousprogress();

}

else

{

LOG_err << "Error saving finished chunk";

if (!fa->retry)

{

transferbuf.bufferWriteCompleted(i, false); // discard failed data so we don't retry on slot deletion

return transfer->failed(API_EWRITE, committer);

}

lasterror = API_EWRITE;

backoff = 2;

break;

}

if (checkTransferFinished(committer, client))

{

return;

}

client->transfercacheadd(transfer, &committer);

reqs[i]->status = REQ_READY;

}

}

break;

case REQ_ASYNCIO:

if (asyncIO[i]->finished)

{

LOG_verbose << "Processing finished async fs operation";

if (!asyncIO[i]->failed)

{

if (transfer->type == PUT)

{

LOG_verbose << "Async read succeeded";

m_off_t npos = asyncIO[i]->pos + asyncIO[i]->len;

string finaltempurl = transferbuf.tempURL(i);

if (client->usealtupport && !memcmp(finaltempurl.c_str(), "http:", 5))

{

size_t index = finaltempurl.find("/", 8);

if(index != string::npos && finaltempurl.find(":", 8) == string::npos)

{

finaltempurl.insert(index, ":8080");

}

}

auto pos = asyncIO[i]->pos;

auto req = reqs[i]; // shared_ptr so no object is deleted out from under the worker

auto transferkey = transfer->transferkey;

auto ctriv = transfer->ctriv;

req->pos = pos;

req->status = REQ_ENCRYPTING;

client->mAsyncQueue.push([req, transferkey, ctriv, finaltempurl, pos, npos](SymmCipher& sc)

{

sc.setkey(transferkey.data());

req->prepare(finaltempurl.c_str(), &sc, ctriv, pos, npos);

req->status = REQ_PREPARED;

}, true); // discardable - if the transfer or client are being destroyed, we won't be sending that data.

}

else

{

LOG_verbose << "Async write succeeded";

transferbuf.bufferWriteCompleted(i, true);

errorcount = 0;

transfer->failcount = 0;

updatecontiguousprogress();

if (checkTransferFinished(committer, client))

{

return;

}

client->transfercacheadd(transfer, &committer);

reqs[i]->status = REQ_READY;

if (client->orderdownloadedchunks && !transferbuf.isRaid())

{

// Check connections again looking for postponed chunks

delete asyncIO[i];

asyncIO[i] = NULL;

i = connections;

continue;

}

}

delete asyncIO[i];

asyncIO[i] = NULL;

}

else

{

LOG_warn << "Async operation failed: " << asyncIO[i]->retry;

if (!asyncIO[i]->retry)

{

transferbuf.bufferWriteCompleted(i, false); // discard failed data so we don't retry on slot deletion

delete asyncIO[i];

asyncIO[i] = NULL;

return transfer->failed(transfer->type == PUT ? API_EREAD : API_EWRITE, committer);

}

// retry shortly

if (transfer->type == PUT)

{

lasterror = API_EREAD;

reqs[i]->status = REQ_READY;

}

else

{

lasterror = API_EWRITE;

reqs[i]->status = REQ_SUCCESS;

}

backoff = 2;

}

}

else if (transfer->type == GET)

{

p += asyncIO[i]->len;

}

break;

case REQ_FAILURE:

LOG_warn << "Failed chunk. HTTP status: " << reqs[i]->httpstatus << " on channel " << i;

if (reqs[i]->httpstatus && reqs[i]->contenttype.find("text/html") != string::npos

&& !memcmp(reqs[i]->posturl.c_str(), "http:", 5))

{

LOG_warn << "Invalid Content-Type detected on failed chunk: " << reqs[i]->contenttype;

client->usehttps = true;

client->app->notify_change_to_https();

client->sendevent(99436, "Automatic change to HTTPS", 0);

return transfer->failed(API_EAGAIN, committer);

}

if (reqs[i]->httpstatus == 509)

{

if (reqs[i]->timeleft < 0)

{

client->sendevent(99408, "Overquota without timeleft", 0);

}

LOG_warn << "Bandwidth overquota from storage server";

if (reqs[i]->timeleft > 0)

{

backoff = dstime(reqs[i]->timeleft * 10);

}

else

{

// default retry intervals

backoff = MegaClient::DEFAULT_BW_OVERQUOTA_BACKOFF_SECS * 10;

}

return transfer->failed(API_EOVERQUOTA, committer, backoff);

}

else if (reqs[i]->httpstatus == 429)

{

// too many requests - back off a bit (may be added serverside at some point. Added here 202020623)

backoff = 5;

reqs[i]->status = REQ_PREPARED;

}

else if (reqs[i]->httpstatus == 503 && !transferbuf.isRaid())

{

// for non-raid, if a file gets a 503 then back off as it may become available shortly

backoff = 50;

reqs[i]->status = REQ_PREPARED;

}

else if (reqs[i]->httpstatus == 403 || reqs[i]->httpstatus == 404 || (reqs[i]->httpstatus == 503 && transferbuf.isRaid()))

{

// - 404 means "malformed or expired URL" - can be immediately fixed by getting a fresh one from the API

// - 503 means "the API gave you good information, but I don't have the file" - cannot be fixed (at least not immediately) by getting a fresh URL

// for raid parts and 503, it's appropriate to try another raid source

if (!tryRaidRecoveryFromHttpGetError(i, true))

{

return transfer->failed(API_EAGAIN, committer);

}

}

else if (reqs[i]->httpstatus == 0 && tryRaidRecoveryFromHttpGetError(i, true))

{

// status 0 indicates network error or timeout; no headers recevied.

// tryRaidRecoveryFromHttpGetError has switched to loading a different part instead of this one.

}

else

{

if (!failure)

{

failure = true;

bool changeport = false;

if (transfer->type == GET && client->autodownport && !memcmp(transferbuf.tempURL(i).c_str(), "http:", 5))

{

LOG_debug << "Automatically changing download port";

client->usealtdownport = !client->usealtdownport;

changeport = true;

}

else if (transfer->type == PUT && client->autoupport && !memcmp(transferbuf.tempURL(i).c_str(), "http:", 5))

{

LOG_debug << "Automatically changing upload port";

client->usealtupport = !client->usealtupport;

changeport = true;

}