Differential D23579 Diff 64989 src/ioslaves/ftp/ftp.cpp

Changeset View

Standalone View

src/ioslaves/ftp/ftp.cpp

1	/* This file is part of the KDE libraries	1		/* This file is part of the KDE libraries
2	Copyright (C) 2000-2006 David Faure <faure@kde.org>	2		Copyright (C) 2000-2006 David Faure <faure@kde.org>
		3		Copyright (C) 2019 Harald Sitter <sitter@kde.org>
3		4
4	This library is free software; you can redistribute it and/or	5		This library is free software; you can redistribute it and/or
5	modify it under the terms of the GNU Library General Public	6		modify it under the terms of the GNU Library General Public
6	License as published by the Free Software Foundation; either	7		License as published by the Free Software Foundation; either
7	version 2 of the License, or (at your option) any later version.	8		version 2 of the License, or (at your option) any later version.
8		9
9	This library is distributed in the hope that it will be useful,	10		This library is distributed in the hope that it will be useful,
10	but WITHOUT ANY WARRANTY; without even the implied warranty of	11		but WITHOUT ANY WARRANTY; without even the implied warranty of
▲ Show 20 Lines • Show All 154 Lines • ▼ Show 20 Line(s)		155	while (len > 0) {
165	case ENOSPC: return ERR_DISK_FULL;	166		case ENOSPC: return ERR_DISK_FULL;
166	default: return ERR_CANNOT_WRITE;	167		default: return ERR_CANNOT_WRITE;
167	}	168		}
168	}	169		}
169	return 0;	170		return 0;
170	}	171		}
171	}	172		}
172		173
173	const KIO::filesize_t Ftp::UnknownSize = (KIO::filesize_t) - 1;	174		const KIO::filesize_t FtpInternal::UnknownSize = (KIO::filesize_t) - 1;
174		175
175	using namespace KIO;	176		using namespace KIO;
176		177
177	extern "C" Q_DECL_EXPORT int kdemain(int argc, char **argv)	178		extern "C" Q_DECL_EXPORT int kdemain(int argc, char **argv)
178	{	179		{
179	QCoreApplication app(argc, argv);	180		QCoreApplication app(argc, argv);
180	app.setApplicationName(QStringLiteral("kio_ftp"));	181		app.setApplicationName(QStringLiteral("kio_ftp"));
181		182
182	qCDebug(KIO_FTP) << "Starting";	183		qCDebug(KIO_FTP) << "Starting";
183		184
184	if (argc != 4) {	185		if (argc != 4) {
185	fprintf(stderr, "Usage: kio_ftp protocol domain-socket1 domain-socket2\n");	186		fprintf(stderr, "Usage: kio_ftp protocol domain-socket1 domain-socket2\n");
186	exit(-1);	187		exit(-1);
187	}	188		}
188		189
189	Ftp slave(argv[2], argv[3]);	190		Ftp slave(argv[2], argv[3]);
190	slave.dispatchLoop();	191		slave.dispatchLoop();
191		192
192	qCDebug(KIO_FTP) << "Done";	193		qCDebug(KIO_FTP) << "Done";
193	return 0;	194		return 0;
194	}	195		}
195		196
196	//===============================================================================	197		//===============================================================================
197	// Ftp	198		// FtpInternal
198	//===============================================================================	199		//===============================================================================
199		200
200	Ftp::Ftp(const QByteArray &pool, const QByteArray &app)
201	: SlaveBase(QByteArrayLiteral("ftp"), pool, app)
202	{
203	// init the socket data
204	m_data = m_control = nullptr;
205	m_server = nullptr;
206	ftpCloseControlConnection();
207
208	// init other members
209	m_port = 0;
210	m_socketProxyAuth = nullptr;
211	}
212
213	Ftp::~Ftp()
214	{
215	qCDebug(KIO_FTP);
216	closeConnection();
217	}
218
219	/**	201		/**
220	* This closes a data connection opened by ftpOpenDataConnection().	202		* This closes a data connection opened by ftpOpenDataConnection().
221	*/	203		*/
222	void Ftp::ftpCloseDataConnection()	204		void FtpInternal::ftpCloseDataConnection()
223	{	205		{
224	delete m_data;	206		delete m_data;
225	m_data = nullptr;	207		m_data = nullptr;
226	delete m_server;	208		delete m_server;
227	m_server = nullptr;	209		m_server = nullptr;
228	}	210		}
229		211
230	/**	212		/**
231	* This closes a control connection opened by ftpOpenControlConnection() and reinits the	213		* This closes a control connection opened by ftpOpenControlConnection() and reinits the
232	* related states. This method gets called from the constructor with m_control = nullptr.	214		* related states. This method gets called from the constructor with m_control = nullptr.
233	*/	215		*/
234	void Ftp::ftpCloseControlConnection()	216		void FtpInternal::ftpCloseControlConnection()
235	{	217		{
236	m_extControl = 0;	218		m_extControl = 0;
237	delete m_control;	219		delete m_control;
238	m_control = nullptr;	220		m_control = nullptr;
239	m_cDataMode = 0;	221		m_cDataMode = 0;
240	m_bLoggedOn = false; // logon needs control connection	222		m_bLoggedOn = false; // logon needs control connection
241	m_bTextMode = false;	223		m_bTextMode = false;
242	m_bBusy = false;	224		m_bBusy = false;
243	}	225		}
244		226
245	/**	227		/**
246	* Returns the last response from the server (iOffset >= 0) -or- reads a new response	228		* Returns the last response from the server (iOffset >= 0) -or- reads a new response
247	* (iOffset < 0). The result is returned (with iOffset chars skipped for iOffset > 0).	229		* (iOffset < 0). The result is returned (with iOffset chars skipped for iOffset > 0).
248	*/	230		*/
249	const char *Ftp::ftpResponse(int iOffset)	231		const char *FtpInternal::ftpResponse(int iOffset)
250	{	232		{
251	Q_ASSERT(m_control); // must have control connection socket	233		Q_ASSERT(m_control); // must have control connection socket
252	const char *pTxt = m_lastControlLine.data();	234		const char *pTxt = m_lastControlLine.data();
253		235
254	// read the next line ...	236		// read the next line ...
255	if (iOffset < 0) {	237		if (iOffset < 0) {
256	int iMore = 0;	238		int iMore = 0;
257	m_iRespCode = 0;	239		m_iRespCode = 0;
Show All 37 Lines
295		277
296	// return text with offset ...	278		// return text with offset ...
297	while (iOffset-- > 0 && pTxt[0]) {	279		while (iOffset-- > 0 && pTxt[0]) {
298	pTxt++;	280		pTxt++;
299	}	281		}
300	return pTxt;	282		return pTxt;
301	}	283		}
302		284
303	void Ftp::closeConnection()	285		void FtpInternal::closeConnection()
304	{	286		{
305	if (m_control \|\| m_data)	287		if (m_control \|\| m_data)
306	qCDebug(KIO_FTP) << "m_bLoggedOn=" << m_bLoggedOn << " m_bBusy=" << m_bBusy;	288		qCDebug(KIO_FTP) << "m_bLoggedOn=" << m_bLoggedOn << " m_bBusy=" << m_bBusy;
307		289
308	if (m_bBusy) { // ftpCloseCommand not called	290		if (m_bBusy) { // ftpCloseCommand not called
309	qCWarning(KIO_FTP) << "Abandoned data stream";	291		qCWarning(KIO_FTP) << "Abandoned data stream";
310	ftpCloseDataConnection();	292		ftpCloseDataConnection();
311	}	293		}
312		294
313	if (m_bLoggedOn) { // send quit	295		if (m_bLoggedOn) { // send quit
314	if (!ftpSendCmd(QByteArrayLiteral("quit"), 0) \|\| (m_iRespType != 2)) {	296		const auto result = ftpSendCmd(QByteArrayLiteral("quit"), 0);
		297		if (!result.success \|\| (m_iRespType != 2)) {
315	qCWarning(KIO_FTP) << "QUIT returned error: " << m_iRespCode;	298		qCWarning(KIO_FTP) << "QUIT returned error: " << m_iRespCode;
316	}	299		}
317	}	300		}
318		301
319	// close the data and control connections ...	302		// close the data and control connections ...
320	ftpCloseDataConnection();	303		ftpCloseDataConnection();
321	ftpCloseControlConnection();	304		ftpCloseControlConnection();
322	}	305		}
323		306
324	void Ftp::setHost(const QString &_host, quint16 _port, const QString &_user,	307		FtpInternal::FtpInternal(Ftp *qptr)
		308		: QObject()
		309		, q(qptr)
		310		{
		311		ftpCloseControlConnection();
		312		}
		313
		314		FtpInternal::~FtpInternal()
		315		{
		316		qCDebug(KIO_FTP);
		317		closeConnection();
		318		}
		319
		320		void FtpInternal::setHost(const QString &_host, quint16 _port, const QString &_user,
325	const QString &_pass)	321		const QString &_pass)
326	{	322		{
327	qCDebug(KIO_FTP) << _host << "port=" << _port << "user=" << _user;	323		qCDebug(KIO_FTP) << _host << "port=" << _port << "user=" << _user;
328		324
329	m_proxyURL.clear();	325		m_proxyURL.clear();
330	m_proxyUrls = config()->readEntry("ProxyUrls", QStringList());	326		m_proxyUrls = config()->readEntry("ProxyUrls", QStringList());
331	qCDebug(KIO_FTP) << "proxy urls:" << m_proxyUrls;	327		qCDebug(KIO_FTP) << "proxy urls:" << m_proxyUrls;
332		328
333	if (m_host != _host \|\| m_port != _port \|\|	329		if (m_host != _host \|\| m_port != _port \|\|
334	m_user != _user \|\| m_pass != _pass) {	330		m_user != _user \|\| m_pass != _pass) {
335	closeConnection();	331		closeConnection();
336	}	332		}
337		333
338	m_host = _host;	334		m_host = _host;
339	m_port = _port;	335		m_port = _port;
340	m_user = _user;	336		m_user = _user;
341	m_pass = _pass;	337		m_pass = _pass;
342	}	338		}
343		339
344	void Ftp::openConnection()	340		Result FtpInternal::openConnection()
345	{	341		{
346	ftpOpenConnection(loginExplicit);	342		return ftpOpenConnection(LoginMode::Explicit);
347	}	343		}
348		344
349	bool Ftp::ftpOpenConnection(LoginMode loginMode)	345		Result FtpInternal::ftpOpenConnection(LoginMode loginMode)
350	{	346		{
351	// check for implicit login if we are already logged on ...	347		// check for implicit login if we are already logged on ...
352	if (loginMode == loginImplicit && m_bLoggedOn) {	348		if (loginMode == LoginMode::Implicit && m_bLoggedOn) {
353	Q_ASSERT(m_control); // must have control connection socket	349		Q_ASSERT(m_control); // must have control connection socket
354	return true;	350		return Result::pass();
355	}	351		}
356		352
357	qCDebug(KIO_FTP) << "host=" << m_host << ", port=" << m_port << ", user=" << m_user << "password= [password hidden]";	353		qCDebug(KIO_FTP) << "host=" << m_host << ", port=" << m_port << ", user=" << m_user << "password= [password hidden]";
358		354
359	infoMessage(i18n("Opening connection to host %1", m_host));	355		infoMessage(i18n("Opening connection to host %1", m_host));
360		356
361	if (m_host.isEmpty()) {	357		if (m_host.isEmpty()) {
362	error(ERR_UNKNOWN_HOST, QString());	358		return Result::fail(ERR_UNKNOWN_HOST);
363	return false;
364	}	359		}
365		360
366	Q_ASSERT(!m_bLoggedOn);	361		Q_ASSERT(!m_bLoggedOn);
367		362
368	m_initialPath.clear();	363		m_initialPath.clear();
369	m_currentPath.clear();	364		m_currentPath.clear();
370		365
371	if (!ftpOpenControlConnection()) {	366		const Result result = ftpOpenControlConnection();
372	return false; // error emitted by ftpOpenControlConnection	367		if (!result.success) {
		368		return result;
373	}	369		}
374	infoMessage(i18n("Connected to host %1", m_host));	370		infoMessage(i18n("Connected to host %1", m_host));
375		371
376	bool userNameChanged = false;	372		bool userNameChanged = false;
377	if (loginMode != loginDefered) {	373		if (loginMode != LoginMode::Defered) {
378	m_bLoggedOn = ftpLogin(&userNameChanged);	374		const Result result = ftpLogin(&userNameChanged);
		375		m_bLoggedOn = result.success;
379	if (!m_bLoggedOn) {	376		if (!m_bLoggedOn) {
380	return false; // error emitted by ftpLogin	377		return result;
381	}	378		}
382	}	379		}
383		380
384	m_bTextMode = config()->readEntry("textmode", false);	381		m_bTextMode = config()->readEntry("textmode", false);
385	connected();	382		connected();
386		383
387	// Redirected due to credential change...	384		// Redirected due to credential change...
388	if (userNameChanged && m_bLoggedOn) {	385		if (userNameChanged && m_bLoggedOn) {
Show All 10 Lines		395	if (m_port > 0 && m_port != DEFAULT_FTP_PORT) {
399	realURL.setPort(m_port);	396		realURL.setPort(m_port);
400	}	397		}
401	if (m_initialPath.isEmpty()) {	398		if (m_initialPath.isEmpty()) {
402	m_initialPath = QStringLiteral("/");	399		m_initialPath = QStringLiteral("/");
403	}	400		}
404	realURL.setPath(m_initialPath);	401		realURL.setPath(m_initialPath);
405	qCDebug(KIO_FTP) << "User name changed! Redirecting to" << realURL;	402		qCDebug(KIO_FTP) << "User name changed! Redirecting to" << realURL;
406	redirection(realURL);	403		redirection(realURL);
407	finished();	404		return Result::fail();
408	return false;
409	}	405		}
410		406
411	return true;	407		return Result::pass();
412	}	408		}
413		409
414	/**	410		/**
415	* Called by @ref openConnection. It opens the control connection to the ftp server.	411		* Called by @ref openConnection. It opens the control connection to the ftp server.
416	*	412		*
417	* @return true on success.	413		* @return true on success.
418	*/	414		*/
419	bool Ftp::ftpOpenControlConnection()	415		Result FtpInternal::ftpOpenControlConnection()
420	{	416		{
421	if (m_proxyUrls.isEmpty()) {	417		if (m_proxyUrls.isEmpty()) {
422	return ftpOpenControlConnection(m_host, m_port);	418		return ftpOpenControlConnection(m_host, m_port);
423	}	419		}
424		420
425	int errorCode = 0;	421		int errorCode = 0;
426	QString errorMessage;	422		QString errorMessage;
427		423
428	Q_FOREACH (const QString &proxyUrl, m_proxyUrls) {	424		Q_FOREACH (const QString &proxyUrl, m_proxyUrls) {
429	const QUrl url(proxyUrl);	425		const QUrl url(proxyUrl);
430	const QString scheme(url.scheme());	426		const QString scheme(url.scheme());
431		427
432	if (!supportedProxyScheme(scheme)) {	428		if (!supportedProxyScheme(scheme)) {
433	// TODO: Need a new error code to indicate unsupported URL scheme.	429		// TODO: Need a new error code to indicate unsupported URL scheme.
434	errorCode = ERR_CANNOT_CONNECT;	430		errorCode = ERR_CANNOT_CONNECT;
435	errorMessage = url.toString();	431		errorMessage = url.toString();
436	continue;	432		continue;
437	}	433		}
438		434
439	if (scheme == QLatin1String("socks")) {	435		if (scheme == QLatin1String("socks")) {
440	qCDebug(KIO_FTP) << "Connecting to SOCKS proxy @" << url;	436		qCDebug(KIO_FTP) << "Connecting to SOCKS proxy @" << url;
441	const int proxyPort = url.port();	437		const int proxyPort = url.port();
442	QNetworkProxy proxy(QNetworkProxy::Socks5Proxy, url.host(), (proxyPort == -1 ? 0 : proxyPort));	438		QNetworkProxy proxy(QNetworkProxy::Socks5Proxy, url.host(), (proxyPort == -1 ? 0 : proxyPort));
443	QNetworkProxy::setApplicationProxy(proxy);	439		QNetworkProxy::setApplicationProxy(proxy);
444	if (ftpOpenControlConnection(m_host, m_port)) {	440		const Result result = ftpOpenControlConnection(m_host, m_port);
445	return true;	441		if (result.success) {
		442		return Result::pass();
446	}	443		}
447	QNetworkProxy::setApplicationProxy(QNetworkProxy::NoProxy);	444		QNetworkProxy::setApplicationProxy(QNetworkProxy::NoProxy);
448	} else {	445		} else {
449	if (ftpOpenControlConnection(url.host(), url.port())) {	446		const Result result = ftpOpenControlConnection(url.host(), url.port());
		447		if (result.success) {
450	m_proxyURL = url;	448		m_proxyURL = url;
451	return true;	449		return Result::pass();
452	}
453	}	450		}
454	}	451		}
455
456	if (errorCode) {
457	error(errorCode, errorMessage);
458	}	452		}
459		453
460	return false;	454		return Result::fail(errorCode, errorMessage);
461	}	455		}
462		456
463	bool Ftp::ftpOpenControlConnection(const QString &host, int port)	457		Result FtpInternal::ftpOpenControlConnection(const QString &host, int port)
464	{	458		{
465	// implicitly close, then try to open a new connection ...	459		// implicitly close, then try to open a new connection ...
466	closeConnection();	460		closeConnection();
467	QString sErrorMsg;	461		QString sErrorMsg;
468		462
469	// now connect to the server and read the login message ...	463		// now connect to the server and read the login message ...
470	if (port == 0) {	464		if (port == 0) {
471	port = 21; // default FTP port	465		port = 21; // default FTP port
472	}	466		}
473	m_control = synchronousConnectToHost(host, port);	467		m_control = synchronousConnectToHost(host, port);
474	connect(m_control, &QAbstractSocket::proxyAuthenticationRequired,	468		connect(m_control, &QAbstractSocket::proxyAuthenticationRequired,
475	this, &Ftp::proxyAuthentication);	469		this, &FtpInternal::proxyAuthentication);
476	int iErrorCode = m_control->state() == QAbstractSocket::ConnectedState ? 0 : ERR_CANNOT_CONNECT;	470		int iErrorCode = m_control->state() == QAbstractSocket::ConnectedState ? 0 : ERR_CANNOT_CONNECT;
477		471
478	// on connect success try to read the server message...	472		// on connect success try to read the server message...
479	if (iErrorCode == 0) {	473		if (iErrorCode == 0) {
480	const char *psz = ftpResponse(-1);	474		const char *psz = ftpResponse(-1);
481	if (m_iRespType != 2) {	475		if (m_iRespType != 2) {
482	// login not successful, do we have an message text?	476		// login not successful, do we have an message text?
483	if (psz[0]) {	477		if (psz[0]) {
484	sErrorMsg = i18n("%1 (Error %2)", host, remoteEncoding()->decode(psz).trimmed());	478		sErrorMsg = i18n("%1 (Error %2)", host, remoteEncoding()->decode(psz).trimmed());
485	}	479		}
486	iErrorCode = ERR_CANNOT_CONNECT;	480		iErrorCode = ERR_CANNOT_CONNECT;
487	}	481		}
488	} else {	482		} else {
489	if (m_control->error() == QAbstractSocket::HostNotFoundError) {	483		if (m_control->error() == QAbstractSocket::HostNotFoundError) {
490	iErrorCode = ERR_UNKNOWN_HOST;	484		iErrorCode = ERR_UNKNOWN_HOST;
491	}	485		}
492		486
493	sErrorMsg = QStringLiteral("%1: %2").arg(host, m_control->errorString());	487		sErrorMsg = QStringLiteral("%1: %2").arg(host, m_control->errorString());
494	}	488		}
495		489
496	// if there was a problem - report it ...	490		// if there was a problem - report it ...
497	if (iErrorCode == 0) { // OK, return success	491		if (iErrorCode == 0) { // OK, return success
498	return true;	492		return Result::pass();
499	}	493		}
500	closeConnection(); // clean-up on error	494		closeConnection(); // clean-up on error
501	error(iErrorCode, sErrorMsg);	495		return Result::fail(iErrorCode, sErrorMsg);
502	return false;
503	}	496		}
504		497
505	/**	498		/**
506	* Called by @ref openConnection. It logs us in.	499		* Called by @ref openConnection. It logs us in.
507	* @ref m_initialPath is set to the current working directory	500		* @ref m_initialPath is set to the current working directory
508	* if logging on was successful.	501		* if logging on was successful.
509	*	502		*
510	* @return true on success.	503		* @return true on success.
511	*/	504		*/
512	bool Ftp::ftpLogin(bool *userChanged)	505		Result FtpInternal::ftpLogin(bool *userChanged)
513	{	506		{
514	infoMessage(i18n("Sending login information"));	507		infoMessage(i18n("Sending login information"));
515		508
516	Q_ASSERT(!m_bLoggedOn);	509		Q_ASSERT(!m_bLoggedOn);
517		510
518	QString user(m_user);	511		QString user(m_user);
519	QString pass(m_pass);	512		QString pass(m_pass);
520		513
▲ Show 20 Lines • Show All 61 Lines • ▼ Show 20 Line(s)		574	info.prompt = i18n("You need to supply a username and a password "
582	"to access this site.");	575		"to access this site.");
583	info.commentLabel = i18n("Site:");	576		info.commentLabel = i18n("Site:");
584	info.comment = i18n("<b>%1</b>", m_host);	577		info.comment = i18n("<b>%1</b>", m_host);
585	info.keepPassword = true; // Prompt the user for persistence as well.	578		info.keepPassword = true; // Prompt the user for persistence as well.
586	info.setModified(false); // Default the modified flag since we reuse authinfo.	579		info.setModified(false); // Default the modified flag since we reuse authinfo.
587		580
588	const bool disablePassDlg = config()->readEntry("DisablePassDlg", false);	581		const bool disablePassDlg = config()->readEntry("DisablePassDlg", false);
589	if (disablePassDlg) {	582		if (disablePassDlg) {
590	error(ERR_USER_CANCELED, m_host);	583		return Result::fail(ERR_USER_CANCELED, m_host);
591	return false;
592	}	584		}
593	const int errorCode = openPasswordDialogV2(info, errorMsg);	585		const int errorCode = openPasswordDialogV2(info, errorMsg);
594	if (errorCode) {	586		if (errorCode) {
595	error(errorCode, QString());	587		return Result::fail(errorCode);
596	return false;
597	} else {	588		} else {
598	// User can decide go anonymous using checkbox	589		// User can decide go anonymous using checkbox
599	if (info.getExtraField(QStringLiteral("anonymous")).toBool()) {	590		if (info.getExtraField(QStringLiteral("anonymous")).toBool()) {
600	user = QStringLiteral(FTP_LOGIN);	591		user = QStringLiteral(FTP_LOGIN);
601	pass = QStringLiteral(FTP_PASSWD);	592		pass = QStringLiteral(FTP_PASSWD);
602	} else {	593		} else {
603	user = info.username;	594		user = info.username;
604	pass = info.password;	595		pass = info.password;
605	}	596		}
606	promptForRetry = true;	597		promptForRetry = true;
607	}	598		}
608	}	599		}
609		600
610	tempbuf = "USER " + user.toLatin1();	601		tempbuf = "USER " + user.toLatin1();
611	if (m_proxyURL.isValid()) {	602		if (m_proxyURL.isValid()) {
612	tempbuf += '@' + m_host.toLatin1();	603		tempbuf += '@' + m_host.toLatin1();
613	if (m_port > 0 && m_port != DEFAULT_FTP_PORT) {	604		if (m_port > 0 && m_port != DEFAULT_FTP_PORT) {
614	tempbuf += ':' + QByteArray::number(m_port);	605		tempbuf += ':' + QByteArray::number(m_port);
615	}	606		}
616	}	607		}
617		608
618	qCDebug(KIO_FTP) << "Sending Login name: " << tempbuf;	609		qCDebug(KIO_FTP) << "Sending Login name: " << tempbuf;
619		610
620	bool loggedIn = (ftpSendCmd(tempbuf) && (m_iRespCode == 230));	611		auto result = ftpSendCmd(tempbuf);
		612		bool loggedIn = (result.success && (m_iRespCode == 230));
621	bool needPass = (m_iRespCode == 331);	613		bool needPass = (m_iRespCode == 331);
622	// Prompt user for login info if we do not	614		// Prompt user for login info if we do not
623	// get back a "230" or "331".	615		// get back a "230" or "331".
624	if (!loggedIn && !needPass) {	616		if (!loggedIn && !needPass) {
625	lastServerResponse = QString::fromUtf8(ftpResponse(0));	617		lastServerResponse = QString::fromUtf8(ftpResponse(0));
626	qCDebug(KIO_FTP) << "Login failed: " << lastServerResponse;	618		qCDebug(KIO_FTP) << "Login failed: " << lastServerResponse;
627	++failedAuth;	619		++failedAuth;
628	continue; // Well we failed, prompt the user please!!	620		continue; // Well we failed, prompt the user please!!
629	}	621		}
630		622
631	if (needPass) {	623		if (needPass) {
632	tempbuf = "PASS " + pass.toLatin1();	624		tempbuf = "PASS " + pass.toLatin1();
633	qCDebug(KIO_FTP) << "Sending Login password: " << "[protected]";	625		qCDebug(KIO_FTP) << "Sending Login password: " << "[protected]";
634	loggedIn = (ftpSendCmd(tempbuf) && (m_iRespCode == 230));	626		result = ftpSendCmd(tempbuf);
		627		loggedIn = (result.success && (m_iRespCode == 230));
635	}	628		}
636		629
637	if (loggedIn) {	630		if (loggedIn) {
638	// Make sure the user name changed flag is properly set.	631		// Make sure the user name changed flag is properly set.
639	if (userChanged) {	632		if (userChanged) {
640	*userChanged = (!m_user.isEmpty() && (m_user != user));	633		*userChanged = (!m_user.isEmpty() && (m_user != user));
641	}	634		}
642		635
Show All 10 Lines		645	if (info.keepPassword) {
653	cacheAuthentication(info);	646		cacheAuthentication(info);
654	}	647		}
655	}	648		}
656	failedAuth = -1;	649		failedAuth = -1;
657	} else {	650		} else {
658	// some servers don't let you login anymore	651		// some servers don't let you login anymore
659	// if you fail login once, so restart the connection here	652		// if you fail login once, so restart the connection here
660	lastServerResponse = QString::fromUtf8(ftpResponse(0));	653		lastServerResponse = QString::fromUtf8(ftpResponse(0));
661	if (!ftpOpenControlConnection()) {	654		const Result result = ftpOpenControlConnection();
662	return false;	655		if (!result.success) {
		656		return result;
663	}	657		}
664	}	658		}
665	} while (++failedAuth);	659		} while (++failedAuth);
666		660
667	qCDebug(KIO_FTP) << "Login OK";	661		qCDebug(KIO_FTP) << "Login OK";
668	infoMessage(i18n("Login OK"));	662		infoMessage(i18n("Login OK"));
669		663
670	// Okay, we're logged in. If this is IIS 4, switch dir listing style to Unix:	664		// Okay, we're logged in. If this is IIS 4, switch dir listing style to Unix:
671	// Thanks to jk@soegaard.net (Jens Kristian Sgaard) for this hint	665		// Thanks to jk@soegaard.net (Jens Kristian Sgaard) for this hint
672	if (ftpSendCmd(QByteArrayLiteral("SYST")) && (m_iRespType == 2)) {	666		auto result = ftpSendCmd(QByteArrayLiteral("SYST"));
		667		if (result.success && (m_iRespType == 2)) {
673	if (!qstrncmp(ftpResponse(0), "215 Windows_NT", 14)) { // should do for any version	668		if (!qstrncmp(ftpResponse(0), "215 Windows_NT", 14)) { // should do for any version
674	ftpSendCmd(QByteArrayLiteral("site dirstyle"));	669		result = ftpSendCmd(QByteArrayLiteral("site dirstyle"));
		670		if (!result.success) {
		671		return result;
			dfaureUnsubmitted Done I don't think we want to return on failure here. If the server doesn't support this command, we might as well try proceeding. That's why the old code actually ignored errors here. dfaure: I don't think we want to return on failure here. If the server doesn't support this command, we…
		672		}
675	// Check if it was already in Unix style	673		// Check if it was already in Unix style
676	// Patch from Keith Refson <Keith.Refson@earth.ox.ac.uk>	674		// Patch from Keith Refson <Keith.Refson@earth.ox.ac.uk>
677	if (!qstrncmp(ftpResponse(0), "200 MSDOS-like directory output is on", 37))	675		if (!qstrncmp(ftpResponse(0), "200 MSDOS-like directory output is on", 37))
678	//It was in Unix style already!	676		//It was in Unix style already!
679	{	677		{
680	ftpSendCmd(QByteArrayLiteral("site dirstyle"));	678		result = ftpSendCmd(QByteArrayLiteral("site dirstyle"));
		679		if (!result.success) {
		680		return result;
		681		}
681	}	682		}
682	// windows won't support chmod before KDE konquers their desktop...	683		// windows won't support chmod before KDE konquers their desktop...
683	m_extControl \|= chmodUnknown;	684		m_extControl \|= chmodUnknown;
684	}	685		}
685	} else {	686		} else {
686	qCWarning(KIO_FTP) << "SYST failed";	687		qCWarning(KIO_FTP) << "SYST failed";
687	}	688		}
688		689
689	if (config()->readEntry("EnableAutoLoginMacro", false)) {	690		if (config()->readEntry("EnableAutoLoginMacro", false)) {
690	ftpAutoLoginMacro();	691		ftpAutoLoginMacro();
691	}	692		}
692		693
693	// Get the current working directory	694		// Get the current working directory
694	qCDebug(KIO_FTP) << "Searching for pwd";	695		qCDebug(KIO_FTP) << "Searching for pwd";
695	if (!ftpSendCmd(QByteArrayLiteral("PWD")) \|\| (m_iRespType != 2)) {	696		result = ftpSendCmd(QByteArrayLiteral("PWD"));
			dfaureUnsubmitted Done The reuse of the `result` var irks me a bit. const vars rock :-) Would it be a bad idea to make Result implicitly convertible to bool, so you can keep doing this inside the if? `if (!ftpSendCmd(QByteArrayLiteral("PWD")) \|\| (m_iRespType != 2)) {` would still work fine then. This would simplify all cases where we test for failures, but ignore the actual error message on failure (because we'll provide a more high-level one, like here). In other cases, we indeed need a result var. dfaure: The reuse of the `result` var irks me a bit. const vars rock :-) Would it be a bad idea to…
			sitterAuthorUnsubmitted Done I know what you mean, I originally started out with consts but moved away because it was getting fairly repetitive and in the end the constness offers little, the objects are fairly "ephemeral" much like errno. The result handling is indeed very "wordy", but I think there is value to be had in the expressiveness there: A Result is not really a binary affair. Yes it is failure or success, but if it is a failure the developer must make a conscious choice to not use the context information of. If Result was implicitly usable as a bool we'd not force this conscious choice, opening us up for mistakes further down the line when everyone has forgotten if ftpSendCmd needs/deserves result handling... or worse yet, looking at old code it won't be obvious if the author ignored the result context by accident or intentionally. So, I would stay away from treating a Result like a bool. To get to the heart of the issue though: I actually think ftpSendCmd probably shouldn't even return a Result but rather a bool. Probably 99% of all callers entirely ignore the Result context and treat it as a bool, which seems like a strong indication that the return type is unnecessarily complex. Should I go ahead with making it bool? sitter: I know what you mean, I originally started out with consts but moved away because it was…
			dfaureUnsubmitted Done Forcing to use a local variable isn't forcing to test the error code, though. So I'm not convinced by this argument. But yes, let's go for your suggestion, ftpSendCmd should return a bool, good compromise. The only error codes it currently returns are "unsupported action" (unlikely case of programmer error) and "cannot login". So false obviously means "cannot login" anyway. Not sure all callers of ftpSendCmd realized this, though :) dfaure: Forcing to use a local variable isn't forcing to test the error code, though. So I'm not…
		697		if (!result.success \|\| (m_iRespType != 2)) {
696	qCDebug(KIO_FTP) << "Couldn't issue pwd command";	698		qCDebug(KIO_FTP) << "Couldn't issue pwd command";
697	error(ERR_CANNOT_LOGIN, i18n("Could not login to %1.", m_host)); // or anything better ?	699		return Result::fail(ERR_CANNOT_LOGIN, i18n("Could not login to %1.", m_host)); // or anything better ?
698	return false;
699	}	700		}
700		701
701	QString sTmp = remoteEncoding()->decode(ftpResponse(3));	702		QString sTmp = remoteEncoding()->decode(ftpResponse(3));
702	const int iBeg = sTmp.indexOf(QLatin1Char('"'));	703		const int iBeg = sTmp.indexOf(QLatin1Char('"'));
703	const int iEnd = sTmp.lastIndexOf(QLatin1Char('"'));	704		const int iEnd = sTmp.lastIndexOf(QLatin1Char('"'));
704	if (iBeg > 0 && iBeg < iEnd) {	705		if (iBeg > 0 && iBeg < iEnd) {
705	m_initialPath = sTmp.mid(iBeg + 1, iEnd - iBeg - 1);	706		m_initialPath = sTmp.mid(iBeg + 1, iEnd - iBeg - 1);
706	if (m_initialPath[0] != QLatin1Char('/')) {	707		if (m_initialPath[0] != QLatin1Char('/')) {
707	m_initialPath.prepend(QLatin1Char('/'));	708		m_initialPath.prepend(QLatin1Char('/'));
708	}	709		}
709	qCDebug(KIO_FTP) << "Initial path set to: " << m_initialPath;	710		qCDebug(KIO_FTP) << "Initial path set to: " << m_initialPath;
710	m_currentPath = m_initialPath;	711		m_currentPath = m_initialPath;
711	}	712		}
712	return true;	713
		714		return Result::pass();
713	}	715		}
714		716
715	void Ftp::ftpAutoLoginMacro()	717		void FtpInternal::ftpAutoLoginMacro()
716	{	718		{
717	QString macro = metaData(QStringLiteral("autoLoginMacro"));	719		QString macro = metaData(QStringLiteral("autoLoginMacro"));
718		720
719	if (macro.isEmpty()) {	721		if (macro.isEmpty()) {
720	return;	722		return;
721	}	723		}
722		724
723	const QStringList list = macro.split(QLatin1Char('\n'), QString::SkipEmptyParts);	725		const QStringList list = macro.split(QLatin1Char('\n'), QString::SkipEmptyParts);
Show All 21 Lines
745	* ftpSendCmd - send a command (@p cmd) and read response	747		* ftpSendCmd - send a command (@p cmd) and read response
746	*	748		*
747	* @param maxretries number of time it should retry. Since it recursively	749		* @param maxretries number of time it should retry. Since it recursively
748	* calls itself if it can't read the answer (this happens especially after	750		* calls itself if it can't read the answer (this happens especially after
749	* timeouts), we need to limit the recursiveness ;-)	751		* timeouts), we need to limit the recursiveness ;-)
750	*	752		*
751	* return true if any response received, false on error	753		* return true if any response received, false on error
752	*/	754		*/
753	bool Ftp::ftpSendCmd(const QByteArray &cmd, int maxretries)	755		Result FtpInternal::ftpSendCmd(const QByteArray &cmd, int maxretries)
754	{	756		{
755	Q_ASSERT(m_control); // must have control connection socket	757		Q_ASSERT(m_control); // must have control connection socket
756		758
757	if (cmd.indexOf('\r') != -1 \|\| cmd.indexOf('\n') != -1) {	759		if (cmd.indexOf('\r') != -1 \|\| cmd.indexOf('\n') != -1) {
758	qCWarning(KIO_FTP) << "Invalid command received (contains CR or LF):"	760		qCWarning(KIO_FTP) << "Invalid command received (contains CR or LF):"
759	<< cmd.data();	761		<< cmd.data();
760	error(ERR_UNSUPPORTED_ACTION, m_host);	762		return Result::fail(ERR_UNSUPPORTED_ACTION, m_host);
761	return false;
762	}	763		}
763		764
764	// Don't print out the password...	765		// Don't print out the password...
765	bool isPassCmd = (cmd.left(4).toLower() == "pass");	766		bool isPassCmd = (cmd.left(4).toLower() == "pass");
766	#if 0	767		#if 0
767	if (!isPassCmd) {	768		if (!isPassCmd) {
768	qDebug() << "send> " << cmd.data();	769		qDebug() << "send> " << cmd.data();
769	} else {	770		} else {
Show All 21 Lines		791	if ((m_iRespType <= 0) \|\| (m_iRespCode == 421)) {
791	// We have not yet logged on...	792		// We have not yet logged on...
792	if (!m_bLoggedOn) {	793		if (!m_bLoggedOn) {
793	// The command was sent from the ftpLogin function, i.e. we are actually	794		// The command was sent from the ftpLogin function, i.e. we are actually
794	// attempting to login in. NOTE: If we already sent the username, we	795		// attempting to login in. NOTE: If we already sent the username, we
795	// return false and let the user decide whether (s)he wants to start from	796		// return false and let the user decide whether (s)he wants to start from
796	// the beginning...	797		// the beginning...
797	if (maxretries > 0 && !isPassCmd) {	798		if (maxretries > 0 && !isPassCmd) {
798	closeConnection();	799		closeConnection();
799	if (ftpOpenConnection(loginDefered)) {	800		const auto result = ftpOpenConnection(LoginMode::Defered);
		801		#pragma message "we ignore success of the new command its unclear if that is intentional"
			dfaureUnsubmitted Done Oh... it's a recursive call... wow, tricky. Yeah, that means this method returns false even if the nested method managed to login. Very confusing, and probably wrong... dfaure: Oh... it's a recursive call... wow, tricky. Yeah, that means this method returns false even if…
			dfaureUnsubmitted Done How about adding a check for the ret val? dfaure: How about adding a check for the ret val?
		802		if (result.success) {
800	ftpSendCmd(cmd, maxretries - 1);	803		ftpSendCmd(cmd, maxretries - 1);
801	}	804		}
802	}	805		}
803		806
804	return false;	807		return Result::fail();
805	} else {	808		} else {
806	if (maxretries < 1) {	809		if (maxretries < 1) {
807	return false;	810		return Result::fail();
808	} else {	811		} else {
809	qCDebug(KIO_FTP) << "Was not able to communicate with " << m_host	812		qCDebug(KIO_FTP) << "Was not able to communicate with " << m_host
810	<< "Attempting to re-establish connection.";	813		<< "Attempting to re-establish connection.";
811		814
812	closeConnection(); // Close the old connection...	815		closeConnection(); // Close the old connection...
813	openConnection(); // Attempt to re-establish a new connection...	816		const Result openResult = openConnection(); // Attempt to re-establish a new connection...
814		817
815	if (!m_bLoggedOn) {	818		if (!m_bLoggedOn \|\| !openResult.success) {
816	if (m_control) { // if openConnection succeeded ...	819		if (m_control) { // if openConnection succeeded ...
817	qCDebug(KIO_FTP) << "Login failure, aborting";	820		qCDebug(KIO_FTP) << "Login failure, aborting";
818	error(ERR_CANNOT_LOGIN, m_host);	821
819	closeConnection();	822		closeConnection();
		823		return Result::fail(ERR_CANNOT_LOGIN, m_host);
820	}	824		}
821	return false;	825		if (!openResult.success) {
		826		return openResult; // forward
		827		}
		828		return Result::fail(); // else we don't know what went wrong
			dfaureUnsubmitted Done I think this is all quite redundant. openConnection() sets m_bLoggedOn to true if it succeeds, and to false if it fails. So the ret val from openConnection and m_bLoggedOn are the same thing. It makes little sense to test both independently and then even have a third case of failure in this line. It's all the same, I suggest to simplify this. I think this can all be simplified to if (!openResult.success) { if (m_control) { // ... closeConnection(); } return openResult; // or Result::fail(ERR_CANNOT_LOGIN, m_host), if the error code from openResult is no good } dfaure: I think this is all quite redundant. openConnection() sets m_bLoggedOn to true if it succeeds…
822	}	829		}
823		830
824	qCDebug(KIO_FTP) << "Logged back in, re-issuing command";	831		qCDebug(KIO_FTP) << "Logged back in, re-issuing command";
825		832
826	// If we were able to login, resend the command...	833		// If we were able to login, resend the command...
827	if (maxretries) {	834		if (maxretries) {
828	maxretries--;	835		maxretries--;
829	}	836		}
830		837
831	return ftpSendCmd(cmd, maxretries);	838		return ftpSendCmd(cmd, maxretries);
832	}	839		}
833	}	840		}
834	}	841		}
835		842
836	return true;	843		return Result::pass();
837	}	844		}
838		845
839	/*	846		/*
840	* ftpOpenPASVDataConnection - set up data connection, using PASV mode	847		* ftpOpenPASVDataConnection - set up data connection, using PASV mode
841	*	848		*
842	* return 0 if successful, ERR_INTERNAL otherwise	849		* return 0 if successful, ERR_INTERNAL otherwise
843	* doesn't set error message, since non-pasv mode will always be tried if	850		* doesn't set error message, since non-pasv mode will always be tried if
844	* this one fails	851		* this one fails
845	*/	852		*/
846	int Ftp::ftpOpenPASVDataConnection()	853		int FtpInternal::ftpOpenPASVDataConnection()
847	{	854		{
848	Q_ASSERT(m_control); // must have control connection socket	855		Q_ASSERT(m_control); // must have control connection socket
849	Q_ASSERT(!m_data); // ... but no data connection	856		Q_ASSERT(!m_data); // ... but no data connection
850		857
851	// Check that we can do PASV	858		// Check that we can do PASV
852	QHostAddress address = m_control->peerAddress();	859		QHostAddress address = m_control->peerAddress();
853	if (address.protocol() != QAbstractSocket::IPv4Protocol && !isSocksProxy()) {	860		if (address.protocol() != QAbstractSocket::IPv4Protocol && !isSocksProxy()) {
854	return ERR_INTERNAL; // no PASV for non-PF_INET connections	861		return ERR_INTERNAL; // no PASV for non-PF_INET connections
855	}	862		}
856		863
857	if (m_extControl & pasvUnknown) {	864		if (m_extControl & pasvUnknown) {
858	return ERR_INTERNAL; // already tried and got "unknown command"	865		return ERR_INTERNAL; // already tried and got "unknown command"
859	}	866		}
860		867
861	m_bPasv = true;	868		m_bPasv = true;
862		869
863	/* Let's PASsiVe*/	870		/* Let's PASsiVe*/
864	if (!ftpSendCmd(QByteArrayLiteral("PASV")) \|\| (m_iRespType != 2)) {	871		const auto result = ftpSendCmd(QByteArrayLiteral("PASV"));
		872		if (!result.success \|\| (m_iRespType != 2)) {
865	qCDebug(KIO_FTP) << "PASV attempt failed";	873		qCDebug(KIO_FTP) << "PASV attempt failed";
866	// unknown command?	874		// unknown command?
867	if (m_iRespType == 5) {	875		if (m_iRespType == 5) {
868	qCDebug(KIO_FTP) << "disabling use of PASV";	876		qCDebug(KIO_FTP) << "disabling use of PASV";
869	m_extControl \|= pasvUnknown;	877		m_extControl \|= pasvUnknown;
870	}	878		}
871	return ERR_INTERNAL;	879		return ERR_INTERNAL;
872	}	880		}
Show All 22 Lines
895	m_data = synchronousConnectToHost(host, port);	903		m_data = synchronousConnectToHost(host, port);
896		904
897	return m_data->state() == QAbstractSocket::ConnectedState ? 0 : ERR_INTERNAL;	905		return m_data->state() == QAbstractSocket::ConnectedState ? 0 : ERR_INTERNAL;
898	}	906		}
899		907
900	/*	908		/*
901	* ftpOpenEPSVDataConnection - opens a data connection via EPSV	909		* ftpOpenEPSVDataConnection - opens a data connection via EPSV
902	*/	910		*/
903	int Ftp::ftpOpenEPSVDataConnection()	911		int FtpInternal::ftpOpenEPSVDataConnection()
904	{	912		{
905	Q_ASSERT(m_control); // must have control connection socket	913		Q_ASSERT(m_control); // must have control connection socket
906	Q_ASSERT(!m_data); // ... but no data connection	914		Q_ASSERT(!m_data); // ... but no data connection
907		915
908	QHostAddress address = m_control->peerAddress();	916		QHostAddress address = m_control->peerAddress();
909	int portnum;	917		int portnum;
910		918
911	if (m_extControl & epsvUnknown) {	919		if (m_extControl & epsvUnknown) {
912	return ERR_INTERNAL;	920		return ERR_INTERNAL;
913	}	921		}
914		922
915	m_bPasv = true;	923		m_bPasv = true;
916	if (!ftpSendCmd(QByteArrayLiteral("EPSV")) \|\| (m_iRespType != 2)) {	924		const auto result = ftpSendCmd(QByteArrayLiteral("EPSV"));
		925		if (!result.success \|\| (m_iRespType != 2)) {
917	// unknown command?	926		// unknown command?
918	if (m_iRespType == 5) {	927		if (m_iRespType == 5) {
919	qCDebug(KIO_FTP) << "disabling use of EPSV";	928		qCDebug(KIO_FTP) << "disabling use of EPSV";
920	m_extControl \|= epsvUnknown;	929		m_extControl \|= epsvUnknown;
921	}	930		}
922	return ERR_INTERNAL;	931		return ERR_INTERNAL;
923	}	932		}
924		933
925	const char *start = strchr(ftpResponse(3), '\|');	934		const char *start = strchr(ftpResponse(3), '\|');
926	if (!start \|\| sscanf(start, "\|\|\|%d\|", &portnum) != 1) {	935		if (!start \|\| sscanf(start, "\|\|\|%d\|", &portnum) != 1) {
927	return ERR_INTERNAL;	936		return ERR_INTERNAL;
928	}	937		}
		938		Q_ASSERT(portnum > 0);
929		939
930	const QString host = (isSocksProxy() ? m_host : address.toString());	940		const QString host = (isSocksProxy() ? m_host : address.toString());
931	m_data = synchronousConnectToHost(host, portnum);	941		m_data = synchronousConnectToHost(host, static_cast<quint16>(portnum));
932	return m_data->isOpen() ? 0 : ERR_INTERNAL;	942		return m_data->isOpen() ? 0 : ERR_INTERNAL;
933	}	943		}
934		944
935	/*	945		/*
936	* ftpOpenDataConnection - set up data connection	946		* ftpOpenDataConnection - set up data connection
937	*	947		*
938	* The routine calls several ftpOpenXxxxConnection() helpers to find	948		* The routine calls several ftpOpenXxxxConnection() helpers to find
939	* the best connection mode. If a helper cannot connect if returns	949		* the best connection mode. If a helper cannot connect if returns
940	* ERR_INTERNAL - so this is not really an error! All other error	950		* ERR_INTERNAL - so this is not really an error! All other error
941	* codes are treated as fatal, e.g. they are passed back to the caller	951		* codes are treated as fatal, e.g. they are passed back to the caller
942	* who is responsible for calling error(). ftpOpenPortDataConnection	952		* who is responsible for calling error(). ftpOpenPortDataConnection
943	* can be called as last try and it does never return ERR_INTERNAL.	953		* can be called as last try and it does never return ERR_INTERNAL.
944	*	954		*
945	* @return 0 if successful, err code otherwise	955		* @return 0 if successful, err code otherwise
946	*/	956		*/
947	int Ftp::ftpOpenDataConnection()	957		int FtpInternal::ftpOpenDataConnection()
948	{	958		{
949	// make sure that we are logged on and have no data connection...	959		// make sure that we are logged on and have no data connection...
950	Q_ASSERT(m_bLoggedOn);	960		Q_ASSERT(m_bLoggedOn);
951	ftpCloseDataConnection();	961		ftpCloseDataConnection();
952		962
953	int iErrCode = 0;	963		int iErrCode = 0;
954	int iErrCodePASV = 0; // Remember error code from PASV	964		int iErrCodePASV = 0; // Remember error code from PASV
955		965
Show All 33 Lines
989	}	999		}
990		1000
991	/*	1001		/*
992	* ftpOpenPortDataConnection - set up data connection	1002		* ftpOpenPortDataConnection - set up data connection
993	*	1003		*
994	* @return 0 if successful, err code otherwise (but never ERR_INTERNAL	1004		* @return 0 if successful, err code otherwise (but never ERR_INTERNAL
995	* because this is the last connection mode that is tried)	1005		* because this is the last connection mode that is tried)
996	*/	1006		*/
997	int Ftp::ftpOpenPortDataConnection()	1007		int FtpInternal::ftpOpenPortDataConnection()
998	{	1008		{
999	Q_ASSERT(m_control); // must have control connection socket	1009		Q_ASSERT(m_control); // must have control connection socket
1000	Q_ASSERT(!m_data); // ... but no data connection	1010		Q_ASSERT(!m_data); // ... but no data connection
1001		1011
1002	m_bPasv = false;	1012		m_bPasv = false;
1003	if (m_extControl & eprtUnknown) {	1013		if (m_extControl & eprtUnknown) {
1004	return ERR_INTERNAL;	1014		return ERR_INTERNAL;
1005	}	1015		}
Show All 22 Lines		1032	if (localAddress.protocol() == QAbstractSocket::IPv4Protocol) {
1028	data.port = m_server->serverPort();	1038		data.port = m_server->serverPort();
1029		1039
1030	unsigned char pData = reinterpret_cast<unsigned char >(&data);	1040		unsigned char pData = reinterpret_cast<unsigned char >(&data);
1031	command.sprintf("PORT %d,%d,%d,%d,%d,%d", pData[3], pData[2], pData[1], pData[0], pData[5], pData[4]);	1041		command.sprintf("PORT %d,%d,%d,%d,%d,%d", pData[3], pData[2], pData[1], pData[0], pData[5], pData[4]);
1032	} else if (localAddress.protocol() == QAbstractSocket::IPv6Protocol) {	1042		} else if (localAddress.protocol() == QAbstractSocket::IPv6Protocol) {
1033	command = QStringLiteral("EPRT \|2\|%2\|%3\|").arg(localAddress.toString()).arg(m_server->serverPort());	1043		command = QStringLiteral("EPRT \|2\|%2\|%3\|").arg(localAddress.toString()).arg(m_server->serverPort());
1034	}	1044		}
1035		1045
1036	if (ftpSendCmd(command.toLatin1()) && (m_iRespType == 2)) {	1046		const auto result = ftpSendCmd(command.toLatin1());
		1047		if (result.success && (m_iRespType == 2)) {
1037	return 0;	1048		return 0;
1038	}	1049		}
1039		1050
1040	delete m_server;	1051		delete m_server;
1041	m_server = nullptr;	1052		m_server = nullptr;
1042	return ERR_INTERNAL;	1053		return ERR_INTERNAL;
1043	}	1054		}
1044		1055
1045	bool Ftp::ftpOpenCommand(const char *_command, const QString &_path, char _mode,	1056		Result FtpInternal::ftpOpenCommand(const char *_command, const QString &_path, char _mode,
1046	int errorcode, KIO::fileoffset_t _offset)	1057		int errorcode, KIO::fileoffset_t _offset)
1047	{	1058		{
1048	int errCode = 0;	1059		int errCode = 0;
1049	if (!ftpDataMode(ftpModeFromPath(_path, _mode))) {	1060		if (!ftpDataMode(ftpModeFromPath(_path, _mode))) {
1050	errCode = ERR_CANNOT_CONNECT;	1061		errCode = ERR_CANNOT_CONNECT;
1051	} else {	1062		} else {
1052	errCode = ftpOpenDataConnection();	1063		errCode = ftpOpenDataConnection();
1053	}	1064		}
1054		1065
1055	if (errCode != 0) {	1066		if (errCode != 0) {
1056	error(errCode, m_host);	1067		return Result::fail(errCode, m_host);
1057	return false;
1058	}	1068		}
1059		1069
1060	if (_offset > 0) {	1070		if (_offset > 0) {
1061	// send rest command if offset > 0, this applies to retr and stor commands	1071		// send rest command if offset > 0, this applies to retr and stor commands
1062	char buf[100];	1072		char buf[100];
1063	sprintf(buf, "rest %lld", _offset);	1073		sprintf(buf, "rest %lld", _offset);
1064	if (!ftpSendCmd(buf)) {	1074		const auto result = ftpSendCmd(buf);
1065	return false;	1075		if (!result.success) {
		1076		return result;
1066	}	1077		}
1067	if (m_iRespType != 3) {	1078		if (m_iRespType != 3) {
1068	error(ERR_CANNOT_RESUME, _path); // should never happen	1079		return Result::fail(ERR_CANNOT_RESUME, _path); // should never happen
1069	return false;
1070	}	1080		}
1071	}	1081		}
1072		1082
1073	QByteArray tmp = _command;	1083		QByteArray tmp = _command;
1074	QString errormessage;	1084		QString errormessage;
1075		1085
1076	if (!_path.isEmpty()) {	1086		if (!_path.isEmpty()) {
1077	tmp += ' ' + remoteEncoding()->encode(ftpCleanPath(_path));	1087		tmp += ' ' + remoteEncoding()->encode(ftpCleanPath(_path));
1078	}	1088		}
1079		1089
1080	if (!ftpSendCmd(tmp) \|\| (m_iRespType != 1)) {	1090		const auto result = ftpSendCmd(tmp);
		1091		if (!result.success \|\| (m_iRespType != 1)) {
1081	if (_offset > 0 && qstrcmp(_command, "retr") == 0 && (m_iRespType == 4)) {	1092		if (_offset > 0 && qstrcmp(_command, "retr") == 0 && (m_iRespType == 4)) {
1082	errorcode = ERR_CANNOT_RESUME;	1093		errorcode = ERR_CANNOT_RESUME;
1083	}	1094		}
1084	// The error code here depends on the command	1095		// The error code here depends on the command
1085	errormessage = _path + i18n("\nThe server said: \"%1\"", QString::fromUtf8(ftpResponse(0)).trimmed());	1096		errormessage = _path + i18n("\nThe server said: \"%1\"", QString::fromUtf8(ftpResponse(0)).trimmed());
1086	}	1097		}
1087		1098
1088	else {	1099		else {
1089	// Only now we know for sure that we can resume	1100		// Only now we know for sure that we can resume
1090	if (_offset > 0 && qstrcmp(_command, "retr") == 0) {	1101		if (_offset > 0 && qstrcmp(_command, "retr") == 0) {
1091	canResume();	1102		canResume();
1092	}	1103		}
1093		1104
1094	if (m_server && !m_data) {	1105		if (m_server && !m_data) {
1095	qCDebug(KIO_FTP) << "waiting for connection from remote.";	1106		qCDebug(KIO_FTP) << "waiting for connection from remote.";
1096	m_server->waitForNewConnection(connectTimeout() * 1000);	1107		m_server->waitForNewConnection(connectTimeout() * 1000);
1097	m_data = m_server->nextPendingConnection();	1108		m_data = m_server->nextPendingConnection();
1098	}	1109		}
1099		1110
1100	if (m_data) {	1111		if (m_data) {
1101	qCDebug(KIO_FTP) << "connected with remote.";	1112		qCDebug(KIO_FTP) << "connected with remote.";
1102	m_bBusy = true; // cleared in ftpCloseCommand	1113		m_bBusy = true; // cleared in ftpCloseCommand
1103	return true;	1114		return Result::pass();
1104	}	1115		}
1105		1116
1106	qCDebug(KIO_FTP) << "no connection received from remote.";	1117		qCDebug(KIO_FTP) << "no connection received from remote.";
1107	errorcode = ERR_CANNOT_ACCEPT;	1118		errorcode = ERR_CANNOT_ACCEPT;
1108	errormessage = m_host;	1119		errormessage = m_host;
1109	return false;	1120		return Result::fail();
			dfaureUnsubmitted Done why not use errorcode and errormessage here? or in fact just removing that line, so that it goes to the correct `return Result::fail(errorcode...)` below. I believe this was a bug in the orig code, setting two local vars and then returning false is nonsense, the `return false` shouldn't have been there. dfaure: why not use errorcode and errormessage here? or in fact just removing that line, so that it…
1110	}	1121		}
1111		1122
1112	if (errorcode != KJob::NoError) {	1123		if (errorcode != KJob::NoError) {
1113	error(errorcode, errormessage);	1124		return Result::fail(errorcode, errormessage);
1114	}	1125		}
1115	return false;	1126		return Result::fail();
1116	}	1127		}
1117		1128
1118	bool Ftp::ftpCloseCommand()	1129		bool FtpInternal::ftpCloseCommand()
1119	{	1130		{
1120	// first close data sockets (if opened), then read response that	1131		// first close data sockets (if opened), then read response that
1121	// we got for whatever was used in ftpOpenCommand ( should be 226 )	1132		// we got for whatever was used in ftpOpenCommand ( should be 226 )
1122	ftpCloseDataConnection();	1133		ftpCloseDataConnection();
1123		1134
1124	if (!m_bBusy) {	1135		if (!m_bBusy) {
1125	return true;	1136		return true;
1126	}	1137		}
1127		1138
1128	qCDebug(KIO_FTP) << "ftpCloseCommand: reading command result";	1139		qCDebug(KIO_FTP) << "ftpCloseCommand: reading command result";
1129	m_bBusy = false;	1140		m_bBusy = false;
1130		1141
1131	if (!ftpResponse(-1) \|\| (m_iRespType != 2)) {	1142		if (!ftpResponse(-1) \|\| (m_iRespType != 2)) {
1132	qCDebug(KIO_FTP) << "ftpCloseCommand: no transfer complete message";	1143		qCDebug(KIO_FTP) << "ftpCloseCommand: no transfer complete message";
1133	return false;	1144		return false;
1134	}	1145		}
1135	return true;	1146		return true;
1136	}	1147		}
1137		1148
1138	void Ftp::mkdir(const QUrl &url, int permissions)	1149		Result FtpInternal::mkdir(const QUrl &url, int permissions)
1139	{	1150		{
1140	if (!ftpOpenConnection(loginImplicit)) {	1151		auto result = ftpOpenConnection(LoginMode::Implicit);
1141	return;	1152		if (!result.success) {
		1153		return result;
1142	}	1154		}
1143		1155
1144	const QByteArray encodedPath(remoteEncoding()->encode(url));	1156		const QByteArray encodedPath(remoteEncoding()->encode(url));
1145	const QString path = QString::fromLatin1(encodedPath.constData(), encodedPath.size());	1157		const QString path = QString::fromLatin1(encodedPath.constData(), encodedPath.size());
1146		1158
1147	if (!ftpSendCmd((QByteArrayLiteral("mkd ") + encodedPath)) \|\| (m_iRespType != 2)) {	1159		result = ftpSendCmd((QByteArrayLiteral("mkd ") + encodedPath));
		1160		if (!result.success \|\| (m_iRespType != 2)) {
1148	QString currentPath(m_currentPath);	1161		QString currentPath(m_currentPath);
1149		1162
1150	// Check whether or not mkdir failed because	1163		// Check whether or not mkdir failed because
1151	// the directory already exists...	1164		// the directory already exists...
1152	if (ftpFolder(path, false)) {	1165		if (ftpFolder(path, false)) {
1153	error(ERR_DIR_ALREADY_EXIST, path);	1166		const QString failedPath = path;
1154	// Change the directory back to what it was...	1167		// Change the directory back to what it was...
1155	(void) ftpFolder(currentPath, false);	1168		(void) ftpFolder(currentPath, false);
1156	return;	1169		return Result::fail(ERR_DIR_ALREADY_EXIST, failedPath);
1157	}	1170		}
1158		1171
1159	error(ERR_CANNOT_MKDIR, path);	1172		return Result::fail(ERR_CANNOT_MKDIR, path);
1160	return;
1161	}	1173		}
1162		1174
1163	if (permissions != -1) {	1175		if (permissions != -1) {
1164	// chmod the dir we just created, ignoring errors.	1176		// chmod the dir we just created, ignoring errors.
1165	(void) ftpChmod(path, permissions);	1177		(void) ftpChmod(path, permissions);
1166	}	1178		}
1167		1179
1168	finished();	1180		return Result::pass();
1169	}	1181		}
1170		1182
1171	void Ftp::rename(const QUrl &src, const QUrl &dst, KIO::JobFlags flags)	1183		Result FtpInternal::rename(const QUrl &src, const QUrl &dst, KIO::JobFlags flags)
1172	{	1184		{
1173	if (!ftpOpenConnection(loginImplicit)) {	1185		const auto result = ftpOpenConnection(LoginMode::Implicit);
1174	return;	1186		if (!result.success) {
		1187		return result;
1175	}	1188		}
1176		1189
1177	// The actual functionality is in ftpRename because put needs it	1190		// The actual functionality is in ftpRename because put needs it
1178	if (ftpRename(src.path(), dst.path(), flags)) {	1191		return ftpRename(src.path(), dst.path(), flags);
1179	finished();
1180	}
1181	}	1192		}
1182		1193
1183	bool Ftp::ftpRename(const QString &src, const QString &dst, KIO::JobFlags jobFlags)	1194		Result FtpInternal::ftpRename(const QString &src, const QString &dst, KIO::JobFlags jobFlags)
1184	{	1195		{
1185	Q_ASSERT(m_bLoggedOn);	1196		Q_ASSERT(m_bLoggedOn);
1186		1197
1187	// Must check if dst already exists, RNFR+RNTO overwrites by default (#127793).	1198		// Must check if dst already exists, RNFR+RNTO overwrites by default (#127793).
1188	if (!(jobFlags & KIO::Overwrite)) {	1199		if (!(jobFlags & KIO::Overwrite)) {
1189	if (ftpFileExists(dst)) {	1200		if (ftpFileExists(dst)) {
1190	error(ERR_FILE_ALREADY_EXIST, dst);	1201		return Result::fail(ERR_FILE_ALREADY_EXIST, dst);
1191	return false;
1192	}	1202		}
1193	}	1203		}
1194		1204
1195	if (ftpFolder(dst, false)) {	1205		if (ftpFolder(dst, false)) {
1196	error(ERR_DIR_ALREADY_EXIST, dst);	1206		return Result::fail(ERR_DIR_ALREADY_EXIST, dst);
1197	return false;
1198	}	1207		}
1199		1208
1200	// CD into parent folder	1209		// CD into parent folder
1201	const int pos = src.lastIndexOf(QLatin1Char('/'));	1210		const int pos = src.lastIndexOf(QLatin1Char('/'));
1202	if (pos >= 0) {	1211		if (pos >= 0) {
1203	if (!ftpFolder(src.left(pos + 1), false)) {	1212		if (!ftpFolder(src.left(pos + 1), false)) {
1204	return false;	1213		return Result::fail();
			dfaureUnsubmitted Done `ERR_CANNOT_ENTER_DIRECTORY, src` dfaure: `ERR_CANNOT_ENTER_DIRECTORY, src`
1205	}	1214		}
1206	}	1215		}
1207		1216
1208	const QByteArray from_cmd = "RNFR " + remoteEncoding()->encode(src.mid(pos + 1));	1217		const QByteArray from_cmd = "RNFR " + remoteEncoding()->encode(src.mid(pos + 1));
1209	if (!ftpSendCmd(from_cmd) \|\| (m_iRespType != 3)) {	1218		auto result = ftpSendCmd(from_cmd);
1210	error(ERR_CANNOT_RENAME, src);	1219		if (!result.success \|\| (m_iRespType != 3)) {
1211	return false;	1220		return Result::fail(ERR_CANNOT_RENAME, src);
1212	}	1221		}
1213		1222
1214	const QByteArray to_cmd = "RNTO " + remoteEncoding()->encode(dst);	1223		const QByteArray to_cmd = "RNTO " + remoteEncoding()->encode(dst);
1215	if (!ftpSendCmd(to_cmd) \|\| (m_iRespType != 2)) {	1224		result = ftpSendCmd(to_cmd);
1216	error(ERR_CANNOT_RENAME, src);	1225		if (!result.success \|\| (m_iRespType != 2)) {
1217	return false;	1226		return Result::fail(ERR_CANNOT_RENAME, src);
1218	}	1227		}
1219		1228
1220	return true;	1229		return Result::pass();
1221	}	1230		}
1222		1231
1223	void Ftp::del(const QUrl &url, bool isfile)	1232		Result FtpInternal::del(const QUrl &url, bool isfile)
1224	{	1233		{
1225	if (!ftpOpenConnection(loginImplicit)) {	1234		auto result = ftpOpenConnection(LoginMode::Implicit);
1226	return;	1235		if (!result.success) {
		1236		return result;
1227	}	1237		}
1228		1238
1229	// When deleting a directory, we must exit from it first	1239		// When deleting a directory, we must exit from it first
1230	// The last command probably went into it (to stat it)	1240		// The last command probably went into it (to stat it)
1231	if (!isfile) {	1241		if (!isfile) {
1232	ftpFolder(remoteEncoding()->directory(url), false); // ignore errors	1242		(void) ftpFolder(remoteEncoding()->directory(url), false); // ignore errors
1233	}	1243		}
1234		1244
1235	const QByteArray cmd = (isfile ? "DELE " : "RMD ") + remoteEncoding()->encode(url);	1245		const QByteArray cmd = (isfile ? "DELE " : "RMD ") + remoteEncoding()->encode(url);
1236		1246
1237	if (!ftpSendCmd(cmd) \|\| (m_iRespType != 2)) {	1247		result = ftpSendCmd(cmd);
1238	error(ERR_CANNOT_DELETE, url.path());	1248		if (!result.success \|\| (m_iRespType != 2)) {
1239	} else {	1249		return Result::fail(ERR_CANNOT_DELETE, url.path());
1240	finished();
1241	}	1250		}
		1251
		1252		return Result::pass();
1242	}	1253		}
1243		1254
1244	bool Ftp::ftpChmod(const QString &path, int permissions)	1255		bool FtpInternal::ftpChmod(const QString &path, int permissions)
1245	{	1256		{
1246	Q_ASSERT(m_bLoggedOn);	1257		Q_ASSERT(m_bLoggedOn);
1247		1258
1248	if (m_extControl & chmodUnknown) { // previous errors?	1259		if (m_extControl & chmodUnknown) { // previous errors?
1249	return false;	1260		return false;
1250	}	1261		}
1251		1262
1252	// we need to do bit AND 777 to get permissions, in case	1263		// we need to do bit AND 777 to get permissions, in case
1253	// we were sent a full mode (unlikely)	1264		// we were sent a full mode (unlikely)
1254	const QByteArray cmd = "SITE CHMOD " + QByteArray::number(permissions & 0777/octal/, 8 /octal/) + ' ' + remoteEncoding()->encode(path);	1265		const QByteArray cmd = "SITE CHMOD " + QByteArray::number(permissions & 0777/octal/, 8 /octal/) + ' ' + remoteEncoding()->encode(path);
1255		1266
1256	ftpSendCmd(cmd);	1267		auto result = ftpSendCmd(cmd);
		1268		if (result.success) {
		1269		qCDebug(KIO_FTP) << "ftpChmod: Failed to issue chmod" << result.errorString;
		1270		return false;
		1271		}
		1272
1257	if (m_iRespType == 2) {	1273		if (m_iRespType == 2) {
1258	return true;	1274		return true;
1259	}	1275		}
1260		1276
1261	if (m_iRespCode == 500) {	1277		if (m_iRespCode == 500) {
1262	m_extControl \|= chmodUnknown;	1278		m_extControl \|= chmodUnknown;
1263	qCDebug(KIO_FTP) << "ftpChmod: CHMOD not supported - disabling";	1279		qCDebug(KIO_FTP) << "ftpChmod: CHMOD not supported - disabling";
1264	}	1280		}
1265	return false;	1281		return false;
1266	}	1282		}
1267		1283
1268	void Ftp::chmod(const QUrl &url, int permissions)	1284		Result FtpInternal::chmod(const QUrl &url, int permissions)
1269	{	1285		{
1270	if (!ftpOpenConnection(loginImplicit)) {	1286		const auto result = ftpOpenConnection(LoginMode::Implicit);
1271	return;	1287		if (!result.success) {
		1288		return result;
1272	}	1289		}
1273		1290
1274	if (!ftpChmod(url.path(), permissions)) {	1291		if (!ftpChmod(url.path(), permissions)) {
1275	error(ERR_CANNOT_CHMOD, url.path());	1292		return Result::fail(ERR_CANNOT_CHMOD, url.path());
1276	} else {
1277	finished();
1278	}	1293		}
		1294
		1295		return Result::pass();
1279	}	1296		}
1280		1297
1281	void Ftp::ftpCreateUDSEntry(const QString &filename, const FtpEntry &ftpEnt, UDSEntry &entry, bool isDir)	1298		void FtpInternal::ftpCreateUDSEntry(const QString &filename, const FtpEntry &ftpEnt, UDSEntry &entry, bool isDir)
1282	{	1299		{
1283	Q_ASSERT(entry.count() == 0); // by contract :-)	1300		Q_ASSERT(entry.count() == 0); // by contract :-)
1284		1301
1285	entry.fastInsert(KIO::UDSEntry::UDS_NAME, filename);	1302		entry.fastInsert(KIO::UDSEntry::UDS_NAME, filename);
1286	entry.fastInsert(KIO::UDSEntry::UDS_SIZE, ftpEnt.size);	1303		entry.fastInsert(KIO::UDSEntry::UDS_SIZE, ftpEnt.size);
1287	entry.fastInsert(KIO::UDSEntry::UDS_MODIFICATION_TIME, ftpEnt.date.toSecsSinceEpoch());	1304		entry.fastInsert(KIO::UDSEntry::UDS_MODIFICATION_TIME, ftpEnt.date.toSecsSinceEpoch());
1288	entry.fastInsert(KIO::UDSEntry::UDS_ACCESS, ftpEnt.access);	1305		entry.fastInsert(KIO::UDSEntry::UDS_ACCESS, ftpEnt.access);
1289	entry.fastInsert(KIO::UDSEntry::UDS_USER, ftpEnt.owner);	1306		entry.fastInsert(KIO::UDSEntry::UDS_USER, ftpEnt.owner);
Show All 17 Lines		1311	if (!ftpEnt.link.isEmpty()) {
1307	}	1324		}
1308	}	1325		}
1309		1326
1310	entry.fastInsert(KIO::UDSEntry::UDS_FILE_TYPE, isDir ? S_IFDIR : ftpEnt.type);	1327		entry.fastInsert(KIO::UDSEntry::UDS_FILE_TYPE, isDir ? S_IFDIR : ftpEnt.type);
1311	// entry.insert KIO::UDSEntry::UDS_ACCESS_TIME,buff.st_atime);	1328		// entry.insert KIO::UDSEntry::UDS_ACCESS_TIME,buff.st_atime);
1312	// entry.insert KIO::UDSEntry::UDS_CREATION_TIME,buff.st_ctime);	1329		// entry.insert KIO::UDSEntry::UDS_CREATION_TIME,buff.st_ctime);
1313	}	1330		}
1314		1331
1315	void Ftp::ftpShortStatAnswer(const QString &filename, bool isDir)	1332		void FtpInternal::ftpShortStatAnswer(const QString &filename, bool isDir)
1316	{	1333		{
1317	UDSEntry entry;	1334		UDSEntry entry;
1318		1335
1319	entry.fastInsert(KIO::UDSEntry::UDS_NAME, filename);	1336		entry.fastInsert(KIO::UDSEntry::UDS_NAME, filename);
1320	entry.fastInsert(KIO::UDSEntry::UDS_FILE_TYPE, isDir ? S_IFDIR : S_IFREG);	1337		entry.fastInsert(KIO::UDSEntry::UDS_FILE_TYPE, isDir ? S_IFDIR : S_IFREG);
1321	entry.fastInsert(KIO::UDSEntry::UDS_ACCESS, S_IRUSR \| S_IXUSR \| S_IRGRP \| S_IXGRP \| S_IROTH \| S_IXOTH);	1338		entry.fastInsert(KIO::UDSEntry::UDS_ACCESS, S_IRUSR \| S_IXUSR \| S_IRGRP \| S_IXGRP \| S_IROTH \| S_IXOTH);
1322	if (isDir) {	1339		if (isDir) {
1323	entry.fastInsert(KIO::UDSEntry::UDS_MIME_TYPE, QStringLiteral("inode/directory"));	1340		entry.fastInsert(KIO::UDSEntry::UDS_MIME_TYPE, QStringLiteral("inode/directory"));
1324	}	1341		}
1325	// No details about size, ownership, group, etc.	1342		// No details about size, ownership, group, etc.
1326		1343
1327	statEntry(entry);	1344		statEntry(entry);
1328	finished();
1329	}	1345		}
1330		1346
1331	void Ftp::ftpStatAnswerNotFound(const QString &path, const QString &filename)	1347		Result FtpInternal::ftpStatAnswerNotFound(const QString &path, const QString &filename)
1332	{	1348		{
1333	// Only do the 'hack' below if we want to download an existing file (i.e. when looking at the "source")	1349		// Only do the 'hack' below if we want to download an existing file (i.e. when looking at the "source")
1334	// When e.g. uploading a file, we still need stat() to return "not found"	1350		// When e.g. uploading a file, we still need stat() to return "not found"
1335	// when the file doesn't exist.	1351		// when the file doesn't exist.
1336	QString statSide = metaData(QStringLiteral("statSide"));	1352		QString statSide = metaData(QStringLiteral("statSide"));
1337	qCDebug(KIO_FTP) << "statSide=" << statSide;	1353		qCDebug(KIO_FTP) << "statSide=" << statSide;
1338	if (statSide == QLatin1String("source")) {	1354		if (statSide == QLatin1String("source")) {
1339	qCDebug(KIO_FTP) << "Not found, but assuming found, because some servers don't allow listing";	1355		qCDebug(KIO_FTP) << "Not found, but assuming found, because some servers don't allow listing";
1340	// MS Server is incapable of handling "list <blah>" in a case insensitive way	1356		// MS Server is incapable of handling "list <blah>" in a case insensitive way
1341	// But "retr <blah>" works. So lie in stat(), to get going...	1357		// But "retr <blah>" works. So lie in stat(), to get going...
1342	//	1358		//
1343	// There's also the case of ftp://ftp2.3ddownloads.com/90380/linuxgames/loki/patches/ut/ut-patch-436.run	1359		// There's also the case of ftp://ftp2.3ddownloads.com/90380/linuxgames/loki/patches/ut/ut-patch-436.run
1344	// where listing permissions are denied, but downloading is still possible.	1360		// where listing permissions are denied, but downloading is still possible.
1345	ftpShortStatAnswer(filename, false /file, not dir/);	1361		ftpShortStatAnswer(filename, false /file, not dir/);
1346		1362
1347	return;	1363		return Result::pass();
1348	}	1364		}
1349		1365
1350	error(ERR_DOES_NOT_EXIST, path);	1366		return Result::fail(ERR_DOES_NOT_EXIST, path);
1351	}	1367		}
1352		1368
1353	void Ftp::stat(const QUrl &url)	1369		Result FtpInternal::stat(const QUrl &url)
1354	{	1370		{
1355	qCDebug(KIO_FTP) << "path=" << url.path();	1371		qCDebug(KIO_FTP) << "path=" << url.path();
1356	if (!ftpOpenConnection(loginImplicit)) {	1372		auto result = ftpOpenConnection(LoginMode::Implicit);
1357	return;	1373		if (!result.success) {
		1374		return result;
1358	}	1375		}
1359		1376
1360	const QString path = ftpCleanPath(QDir::cleanPath(url.path()));	1377		const QString path = ftpCleanPath(QDir::cleanPath(url.path()));
1361	qCDebug(KIO_FTP) << "cleaned path=" << path;	1378		qCDebug(KIO_FTP) << "cleaned path=" << path;
1362		1379
1363	// We can't stat root, but we know it's a dir.	1380		// We can't stat root, but we know it's a dir.
1364	if (path.isEmpty() \|\| path == QLatin1String("/")) {	1381		if (path.isEmpty() \|\| path == QLatin1String("/")) {
1365	UDSEntry entry;	1382		UDSEntry entry;
1366	//entry.insert( KIO::UDSEntry::UDS_NAME, UDSField( QString() ) );	1383		//entry.insert( KIO::UDSEntry::UDS_NAME, UDSField( QString() ) );
1367	entry.fastInsert(KIO::UDSEntry::UDS_NAME, QStringLiteral("."));	1384		entry.fastInsert(KIO::UDSEntry::UDS_NAME, QStringLiteral("."));
1368	entry.fastInsert(KIO::UDSEntry::UDS_FILE_TYPE, S_IFDIR);	1385		entry.fastInsert(KIO::UDSEntry::UDS_FILE_TYPE, S_IFDIR);
1369	entry.fastInsert(KIO::UDSEntry::UDS_MIME_TYPE, QStringLiteral("inode/directory"));	1386		entry.fastInsert(KIO::UDSEntry::UDS_MIME_TYPE, QStringLiteral("inode/directory"));
1370	entry.fastInsert(KIO::UDSEntry::UDS_ACCESS, S_IRUSR \| S_IXUSR \| S_IRGRP \| S_IXGRP \| S_IROTH \| S_IXOTH);	1387		entry.fastInsert(KIO::UDSEntry::UDS_ACCESS, S_IRUSR \| S_IXUSR \| S_IRGRP \| S_IXGRP \| S_IROTH \| S_IXOTH);
1371	entry.fastInsert(KIO::UDSEntry::UDS_USER, QStringLiteral("root"));	1388		entry.fastInsert(KIO::UDSEntry::UDS_USER, QStringLiteral("root"));
1372	entry.fastInsert(KIO::UDSEntry::UDS_GROUP, QStringLiteral("root"));	1389		entry.fastInsert(KIO::UDSEntry::UDS_GROUP, QStringLiteral("root"));
1373	// no size	1390		// no size
1374		1391
1375	statEntry(entry);	1392		statEntry(entry);
1376	finished();	1393		return Result::pass();
1377	return;
1378	}	1394		}
1379		1395
1380	QUrl tempurl(url);	1396		QUrl tempurl(url);
1381	tempurl.setPath(path); // take the clean one	1397		tempurl.setPath(path); // take the clean one
1382	QString listarg; // = tempurl.directory(QUrl::ObeyTrailingSlash);	1398		QString listarg; // = tempurl.directory(QUrl::ObeyTrailingSlash);
1383	QString parentDir;	1399		QString parentDir;
1384	QString filename = tempurl.fileName();	1400		QString filename = tempurl.fileName();
1385	Q_ASSERT(!filename.isEmpty());	1401		Q_ASSERT(!filename.isEmpty());
1386	QString search = filename;	1402		QString search = filename;
1387		1403
1388	// Try cwd into it, if it works it's a dir (and then we'll list the parent directory to get more info)	1404		// Try cwd into it, if it works it's a dir (and then we'll list the parent directory to get more info)
1389	// if it doesn't work, it's a file (and then we'll use dir filename)	1405		// if it doesn't work, it's a file (and then we'll use dir filename)
1390	bool isDir = ftpFolder(path, false);	1406		bool isDir = ftpFolder(path, false);
1391		1407
1392	// if we're only interested in "file or directory", we should stop here	1408		// if we're only interested in "file or directory", we should stop here
1393	QString sDetails = metaData(QStringLiteral("details"));	1409		QString sDetails = metaData(QStringLiteral("details"));
1394	int details = sDetails.isEmpty() ? 2 : sDetails.toInt();	1410		int details = sDetails.isEmpty() ? 2 : sDetails.toInt();
1395	qCDebug(KIO_FTP) << "details=" << details;	1411		qCDebug(KIO_FTP) << "details=" << details;
1396	if (details == 0) {	1412		if (details == 0) {
1397	if (!isDir && !ftpFileExists(path)) { // ok, not a dir -> is it a file ?	1413		if (!isDir && !ftpFileExists(path)) { // ok, not a dir -> is it a file ?
1398	// no -> it doesn't exist at all	1414		// no -> it doesn't exist at all
1399	ftpStatAnswerNotFound(path, filename);	1415		return ftpStatAnswerNotFound(path, filename);
1400	return;
1401	}	1416		}
1402	ftpShortStatAnswer(filename, isDir); // successfully found a dir or a file -> done	1417		ftpShortStatAnswer(filename, isDir);
1403	return;	1418		return Result::pass(); // successfully found a dir or a file -> done
1404	}	1419		}
1405		1420
1406	if (!isDir) {	1421		if (!isDir) {
1407	// It is a file or it doesn't exist, try going to parent directory	1422		// It is a file or it doesn't exist, try going to parent directory
1408	parentDir = tempurl.adjusted(QUrl::RemoveFilename).path();	1423		parentDir = tempurl.adjusted(QUrl::RemoveFilename).path();
1409	// With files we can do "LIST <filename>" to avoid listing the whole dir	1424		// With files we can do "LIST <filename>" to avoid listing the whole dir
1410	listarg = filename;	1425		listarg = filename;
1411	} else {	1426		} else {
1412	// --- New implementation:	1427		// --- New implementation:
1413	// Don't list the parent dir. Too slow, might not show it, etc.	1428		// Don't list the parent dir. Too slow, might not show it, etc.
1414	// Just return that it's a dir.	1429		// Just return that it's a dir.
1415	UDSEntry entry;	1430		UDSEntry entry;
1416	entry.fastInsert(KIO::UDSEntry::UDS_NAME, filename);	1431		entry.fastInsert(KIO::UDSEntry::UDS_NAME, filename);
1417	entry.fastInsert(KIO::UDSEntry::UDS_FILE_TYPE, S_IFDIR);	1432		entry.fastInsert(KIO::UDSEntry::UDS_FILE_TYPE, S_IFDIR);
1418	entry.fastInsert(KIO::UDSEntry::UDS_ACCESS, S_IRUSR \| S_IXUSR \| S_IRGRP \| S_IXGRP \| S_IROTH \| S_IXOTH);	1433		entry.fastInsert(KIO::UDSEntry::UDS_ACCESS, S_IRUSR \| S_IXUSR \| S_IRGRP \| S_IXGRP \| S_IROTH \| S_IXOTH);
1419	// No clue about size, ownership, group, etc.	1434		// No clue about size, ownership, group, etc.
1420		1435
1421	statEntry(entry);	1436		statEntry(entry);
1422	finished();	1437		return Result::pass();
1423	return;
1424	}	1438		}
1425		1439
1426	// Now cwd the parent dir, to prepare for listing	1440		// Now cwd the parent dir, to prepare for listing
1427	if (!ftpFolder(parentDir, true)) {	1441		if (!ftpFolder(parentDir, true)) {
1428	return;	1442		return Result::fail();
1429	}	1443		}
1430		1444
1431	if (!ftpOpenCommand("list", listarg, 'I', ERR_DOES_NOT_EXIST)) {	1445		result = ftpOpenCommand("list", listarg, 'I', ERR_DOES_NOT_EXIST);
		1446		if (!result.success) {
1432	qCritical() << "COULD NOT LIST";	1447		qCritical() << "COULD NOT LIST";
1433	return;	1448		return result;
1434	}	1449		}
1435	qCDebug(KIO_FTP) << "Starting of list was ok";	1450		qCDebug(KIO_FTP) << "Starting of list was ok";
1436		1451
1437	Q_ASSERT(!search.isEmpty() && search != QLatin1String("/"));	1452		Q_ASSERT(!search.isEmpty() && search != QLatin1String("/"));
1438		1453
1439	bool bFound = false;	1454		bool bFound = false;
1440	QUrl linkURL;	1455		QUrl linkURL;
1441	FtpEntry ftpEnt;	1456		FtpEntry ftpEnt;
Show All 18 Lines		1472	for (int i = 0, count = ftpValidateEntList.count(); i < count; ++i) {
1460	if (maybeEmitStatEntry(ftpEnt, search, filename, isDir)) {	1475		if (maybeEmitStatEntry(ftpEnt, search, filename, isDir)) {
1461	break;	1476		break;
1462	}	1477		}
1463	}	1478		}
1464		1479
1465	ftpCloseCommand(); // closes the data connection only	1480		ftpCloseCommand(); // closes the data connection only
1466		1481
1467	if (!bFound) {	1482		if (!bFound) {
1468	ftpStatAnswerNotFound(path, filename);	1483		return ftpStatAnswerNotFound(path, filename);
1469	return;
1470	}	1484		}
1471		1485
1472	if (!linkURL.isEmpty()) {	1486		if (!linkURL.isEmpty()) {
1473	if (linkURL == url \|\| linkURL == tempurl) {	1487		if (linkURL == url \|\| linkURL == tempurl) {
1474	error(ERR_CYCLIC_LINK, linkURL.toString());	1488		return Result::fail(ERR_CYCLIC_LINK, linkURL.toString());
1475	return;
1476	}	1489		}
1477	Ftp::stat(linkURL);	1490		#pragma message "this used to return nothing and ignored the stat what gives"
			dfaureUnsubmitted Done That's because it was a recursive call, so it left the callee in charge of emitting error/finished. Not doing it here again was actually correct. Now that error codes are returned, your change is correct, you can remove the pragma. dfaure: That's because it was a recursive call, so it left the callee in charge of emitting…
1478	return;	1491		return FtpInternal::stat(linkURL);
1479	}	1492		}
1480		1493
1481	qCDebug(KIO_FTP) << "stat : finished successfully";	1494		qCDebug(KIO_FTP) << "stat : finished successfully";;
1482	finished();	1495		return Result::pass();
1483	}	1496		}
1484		1497
1485	bool Ftp::maybeEmitStatEntry(FtpEntry &ftpEnt, const QString &search, const QString &filename, bool isDir)	1498		bool FtpInternal::maybeEmitStatEntry(FtpEntry &ftpEnt, const QString &search, const QString &filename, bool isDir)
1486	{	1499		{
1487	if ((search == ftpEnt.name \|\| filename == ftpEnt.name) && !filename.isEmpty()) {	1500		if ((search == ftpEnt.name \|\| filename == ftpEnt.name) && !filename.isEmpty()) {
1488	UDSEntry entry;	1501		UDSEntry entry;
1489	ftpCreateUDSEntry(filename, ftpEnt, entry, isDir);	1502		ftpCreateUDSEntry(filename, ftpEnt, entry, isDir);
1490	statEntry(entry);	1503		statEntry(entry);
1491	return true;	1504		return true;
1492	}	1505		}
1493		1506
1494	return false;	1507		return false;
1495	}	1508		}
1496		1509
1497	void Ftp::listDir(const QUrl &url)	1510		Result FtpInternal::listDir(const QUrl &url)
1498	{	1511		{
1499	qCDebug(KIO_FTP) << url;	1512		qCDebug(KIO_FTP) << url;
1500	if (!ftpOpenConnection(loginImplicit)) {	1513		auto result = ftpOpenConnection(LoginMode::Implicit);
1501	return;	1514		if (!result.success) {
		1515		return result;
1502	}	1516		}
1503		1517
1504	// No path specified ?	1518		// No path specified ?
1505	QString path = url.path();	1519		QString path = url.path();
1506	if (path.isEmpty()) {	1520		if (path.isEmpty()) {
1507	QUrl realURL;	1521		QUrl realURL;
1508	realURL.setScheme(QStringLiteral("ftp"));	1522		realURL.setScheme(QStringLiteral("ftp"));
1509	realURL.setUserName(m_user);	1523		realURL.setUserName(m_user);
1510	realURL.setPassword(m_pass);	1524		realURL.setPassword(m_pass);
1511	realURL.setHost(m_host);	1525		realURL.setHost(m_host);
1512	if (m_port > 0 && m_port != DEFAULT_FTP_PORT) {	1526		if (m_port > 0 && m_port != DEFAULT_FTP_PORT) {
1513	realURL.setPort(m_port);	1527		realURL.setPort(m_port);
1514	}	1528		}
1515	if (m_initialPath.isEmpty()) {	1529		if (m_initialPath.isEmpty()) {
1516	m_initialPath = QStringLiteral("/");	1530		m_initialPath = QStringLiteral("/");
1517	}	1531		}
1518	realURL.setPath(m_initialPath);	1532		realURL.setPath(m_initialPath);
1519	qCDebug(KIO_FTP) << "REDIRECTION to " << realURL;	1533		qCDebug(KIO_FTP) << "REDIRECTION to " << realURL;
1520	redirection(realURL);	1534		redirection(realURL);
1521	finished();	1535		return Result::pass();
1522	return;
1523	}	1536		}
1524		1537
1525	qCDebug(KIO_FTP) << "hunting for path" << path;	1538		qCDebug(KIO_FTP) << "hunting for path" << path;
1526		1539
1527	if (!ftpOpenDir(path)) {	1540		result = ftpOpenDir(path);
		1541		if (!result.success) {
1528	if (ftpFileExists(path)) {	1542		if (ftpFileExists(path)) {
1529	error(ERR_IS_FILE, path);	1543		return Result::fail(ERR_IS_FILE, path);
1530	} else {	1544		}
1531	// not sure which to emit	1545		// not sure which to emit
1532	//error( ERR_DOES_NOT_EXIST, path );	1546		//error( ERR_DOES_NOT_EXIST, path );
1533	error(ERR_CANNOT_ENTER_DIRECTORY, path);	1547		return Result::fail(ERR_CANNOT_ENTER_DIRECTORY, path);
1534	}
1535	return;
1536	}	1548		}
1537		1549
1538	UDSEntry entry;	1550		UDSEntry entry;
1539	FtpEntry ftpEnt;	1551		FtpEntry ftpEnt;
1540	QList<FtpEntry> ftpValidateEntList;	1552		QList<FtpEntry> ftpValidateEntList;
1541	while (ftpReadDir(ftpEnt)) {	1553		while (ftpReadDir(ftpEnt)) {
1542	qCDebug(KIO_FTP) << ftpEnt.name;	1554		qCDebug(KIO_FTP) << ftpEnt.name;
1543	//Q_ASSERT( !ftpEnt.name.isEmpty() );	1555		//Q_ASSERT( !ftpEnt.name.isEmpty() );
Show All 17 Lines		1572	for (int i = 0, count = ftpValidateEntList.count(); i < count; ++i) {
1561	FtpEntry &ftpEnt = ftpValidateEntList[i];	1573		FtpEntry &ftpEnt = ftpValidateEntList[i];
1562	fixupEntryName(&ftpEnt);	1574		fixupEntryName(&ftpEnt);
1563	ftpCreateUDSEntry(ftpEnt.name, ftpEnt, entry, false);	1575		ftpCreateUDSEntry(ftpEnt.name, ftpEnt, entry, false);
1564	listEntry(entry);	1576		listEntry(entry);
1565	entry.clear();	1577		entry.clear();
1566	}	1578		}
1567		1579
1568	ftpCloseCommand(); // closes the data connection only	1580		ftpCloseCommand(); // closes the data connection only
1569	finished();	1581		return Result::pass();
1570	}	1582		}
1571		1583
1572	void Ftp::slave_status()	1584		void FtpInternal::slave_status()
1573	{	1585		{
1574	qCDebug(KIO_FTP) << "Got slave_status host = " << (!m_host.toLatin1().isEmpty() ? m_host.toLatin1() : "[None]") << " [" << (m_bLoggedOn ? "Connected" : "Not connected") << "]";	1586		qCDebug(KIO_FTP) << "Got slave_status host = " << (!m_host.toLatin1().isEmpty() ? m_host.toLatin1() : "[None]") << " [" << (m_bLoggedOn ? "Connected" : "Not connected") << "]";
1575	slaveStatus(m_host, m_bLoggedOn);	1587		slaveStatus(m_host, m_bLoggedOn);
1576	}	1588		}
1577		1589
1578	bool Ftp::ftpOpenDir(const QString &path)	1590		Result FtpInternal::ftpOpenDir(const QString &path)
1579	{	1591		{
1580	//QString path( _url.path(QUrl::RemoveTrailingSlash) );	1592		//QString path( _url.path(QUrl::RemoveTrailingSlash) );
1581		1593
1582	// We try to change to this directory first to see whether it really is a directory.	1594		// We try to change to this directory first to see whether it really is a directory.
1583	// (And also to follow symlinks)	1595		// (And also to follow symlinks)
1584	QString tmp = path.isEmpty() ? QStringLiteral("/") : path;	1596		QString tmp = path.isEmpty() ? QStringLiteral("/") : path;
1585		1597
1586	// We get '550', whether it's a file or doesn't exist...	1598		// We get '550', whether it's a file or doesn't exist...
1587	if (!ftpFolder(tmp, false)) {	1599		if (!ftpFolder(tmp, false)) {
1588	return false;	1600		return Result::fail();
1589	}	1601		}
1590		1602
1591	// Don't use the path in the list command:	1603		// Don't use the path in the list command:
1592	// We changed into this directory anyway - so it's enough just to send "list".	1604		// We changed into this directory anyway - so it's enough just to send "list".
1593	// We use '-a' because the application MAY be interested in dot files.	1605		// We use '-a' because the application MAY be interested in dot files.
1594	// The only way to really know would be to have a metadata flag for this...	1606		// The only way to really know would be to have a metadata flag for this...
1595	// Since some windows ftp server seems not to support the -a argument, we use a fallback here.	1607		// Since some windows ftp server seems not to support the -a argument, we use a fallback here.
1596	// In fact we have to use -la otherwise -a removes the default -l (e.g. ftp.trolltech.com)	1608		// In fact we have to use -la otherwise -a removes the default -l (e.g. ftp.trolltech.com)
1597	// Pass KJob::NoError first because we don't want to emit error before we	1609		// Pass KJob::NoError first because we don't want to emit error before we
1598	// have tried all commands.	1610		// have tried all commands.
1599	if (!ftpOpenCommand("list -la", QString(), 'I', KJob::NoError)) {	1611		auto result = ftpOpenCommand("list -la", QString(), 'I', KJob::NoError);
1600	if (!ftpOpenCommand("list", QString(), 'I', KJob::NoError)) {	1612		if (!result.success) {
1601	// Servers running with Turkish locale having problems converting 'i' letter to upper case.	1613		result = ftpOpenCommand("list", QString(), 'I', KJob::NoError);
1602	// So we send correct upper case command as last resort.
	dfaureUnsubmitted Done What happened to those two lines of comments? Can I suggest to keep them? dfaure: What happened to those two lines of comments? Can I suggest to keep them?
	sitterAuthorUnsubmitted Done Oh! Collateral damage from removing the nesting I guess. Comments are back now. sitter: Oh! Collateral damage from removing the nesting I guess. Comments are back now.
1603	if (!ftpOpenCommand("LIST -la", QString(), 'I', ERR_CANNOT_ENTER_DIRECTORY)) {
1604	qCWarning(KIO_FTP) << "Can't open for listing";
1605	return false;
1606	}	1614		}
		1615		if (!result.success) {
		1616		result = ftpOpenCommand("LIST -la", QString(), 'I', ERR_CANNOT_ENTER_DIRECTORY);
1607	}	1617		}
		1618
		1619		if (!result.success) {
		1620		qCWarning(KIO_FTP) << "Can't open for listing";
		1621		return result;
1608	}	1622		}
		1623
1609	qCDebug(KIO_FTP) << "Starting of list was ok";	1624		qCDebug(KIO_FTP) << "Starting of list was ok";
1610	return true;	1625		return Result::pass();
1611	}	1626		}
1612		1627
1613	bool Ftp::ftpReadDir(FtpEntry &de)	1628		bool FtpInternal::ftpReadDir(FtpEntry &de)
1614	{	1629		{
1615	Q_ASSERT(m_data);	1630		Q_ASSERT(m_data);
1616		1631
1617	// get a line from the data connection ...	1632		// get a line from the data connection ...
1618	while (true) {	1633		while (true) {
1619	while (!m_data->canReadLine() && m_data->waitForReadyRead((readTimeout() * 1000))) {}	1634		while (!m_data->canReadLine() && m_data->waitForReadyRead((readTimeout() * 1000))) {}
1620	QByteArray data = m_data->readLine();	1635		QByteArray data = m_data->readLine();
1621	if (data.size() == 0) {	1636		if (data.size() == 0) {
▲ Show 20 Lines • Show All 223 Lines • ▼ Show 20 Line(s)
1845	} // line invalid, loop to get another line	1860		} // line invalid, loop to get another line
1846	return false;	1861		return false;
1847	}	1862		}
1848		1863
1849	//===============================================================================	1864		//===============================================================================
1850	// public: get download file from server	1865		// public: get download file from server
1851	// helper: ftpGet called from get() and copy()	1866		// helper: ftpGet called from get() and copy()
1852	//===============================================================================	1867		//===============================================================================
1853	void Ftp::get(const QUrl &url)	1868		Result FtpInternal::get(const QUrl &url)
1854	{	1869		{
1855	qCDebug(KIO_FTP) << url;	1870		qCDebug(KIO_FTP) << url;
1856		1871		const Result result = ftpGet(-1, url, 0);
1857	int iError = 0;
1858	const StatusCode cs = ftpGet(iError, -1, url, 0);
1859	ftpCloseCommand(); // must close command!	1872		ftpCloseCommand(); // must close command!
1860		1873		return result;
1861	if (cs == statusSuccess) {
1862	finished();
1863	return;
1864	}
1865
1866	if (iError) { // can have only server side errs
1867	error(iError, url.path());
1868	}
1869	}	1874		}
1870		1875
1871	Ftp::StatusCode Ftp::ftpGet(int &iError, int iCopyFile, const QUrl &url, KIO::fileoffset_t llOffset)	1876		Result FtpInternal::ftpGet(int iCopyFile, const QUrl &url, KIO::fileoffset_t llOffset)
1872	{	1877		{
1873	// Calls error() by itself!	1878		auto result = ftpOpenConnection(LoginMode::Implicit);
1874	if (!ftpOpenConnection(loginImplicit)) {	1879		if (!result.success) {
1875	return statusServerError;	1880		#pragma message "was server error here"
			dfaureUnsubmitted Done Wasn't that just a way to propagate the error from the low-level method to this method? Your new mechanism replaces that, no? dfaure: Wasn't that just a way to propagate the error from the low-level method to this method? Your…
			sitterAuthorUnsubmitted Done I could have sworn there was code that differentiated between server and client. I can't find it anymore... maybe it was all a dream, or maybe I saw it in the history. Oh well, down with the useless enum! sitter: I could have sworn there was code that differentiated between server and client. I can't find…
		1881		return result;
1876	}	1882		}
1877		1883
1878	// Try to find the size of the file (and check that it exists at	1884		// Try to find the size of the file (and check that it exists at
1879	// the same time). If we get back a 550, "File does not exist"	1885		// the same time). If we get back a 550, "File does not exist"
1880	// or "not a plain file", check if it is a directory. If it is a	1886		// or "not a plain file", check if it is a directory. If it is a
1881	// directory, return an error; otherwise simply try to retrieve	1887		// directory, return an error; otherwise simply try to retrieve
1882	// the request...	1888		// the request...
1883	if (!ftpSize(url.path(), '?') && (m_iRespCode == 550) &&	1889		if (!ftpSize(url.path(), '?') && (m_iRespCode == 550) &&
1884	ftpFolder(url.path(), false)) {	1890		ftpFolder(url.path(), false)) {
1885	// Ok it's a dir in fact	1891		// Ok it's a dir in fact
1886	qCDebug(KIO_FTP) << "it is a directory in fact";	1892		qCDebug(KIO_FTP) << "it is a directory in fact";
1887	iError = ERR_IS_DIRECTORY;	1893		return Result::fail(ERR_IS_DIRECTORY, StatusCode::ServerError);
1888	return statusServerError;
1889	}	1894		}
1890		1895
1891	QString resumeOffset = metaData(QStringLiteral("range-start"));	1896		QString resumeOffset = metaData(QStringLiteral("range-start"));
1892	if (resumeOffset.isEmpty()) {	1897		if (resumeOffset.isEmpty()) {
1893	resumeOffset = metaData(QStringLiteral("resume")); // old name	1898		resumeOffset = metaData(QStringLiteral("resume")); // old name
1894	}	1899		}
1895	if (!resumeOffset.isEmpty()) {	1900		if (!resumeOffset.isEmpty()) {
1896	llOffset = resumeOffset.toLongLong();	1901		llOffset = resumeOffset.toLongLong();
1897	qCDebug(KIO_FTP) << "got offset from metadata : " << llOffset;	1902		qCDebug(KIO_FTP) << "got offset from metadata : " << llOffset;
1898	}	1903		}
1899		1904
1900	if (!ftpOpenCommand("retr", url.path(), '?', ERR_CANNOT_OPEN_FOR_READING, llOffset)) {	1905		result = ftpOpenCommand("retr", url.path(), '?', ERR_CANNOT_OPEN_FOR_READING, llOffset);
		1906		if (!result.success) {
1901	qCWarning(KIO_FTP) << "Can't open for reading";	1907		qCWarning(KIO_FTP) << "Can't open for reading";
1902	return statusServerError;	1908		#pragma message "was server error here"
			dfaureUnsubmitted Done Same as above: why do we still need this distinction? Is this enum useful? dfaure: Same as above: why do we still need this distinction? Is this enum useful?
		1909		return result;
1903	}	1910		}
1904		1911
1905	// Read the size from the response string	1912		// Read the size from the response string
1906	if (m_size == UnknownSize) {	1913		if (m_size == UnknownSize) {
1907	const char *psz = strrchr(ftpResponse(4), '(');	1914		const char *psz = strrchr(ftpResponse(4), '(');
1908	if (psz) {	1915		if (psz) {
1909	m_size = charToLongLong(psz + 1);	1916		m_size = charToLongLong(psz + 1);
1910	}	1917		}
1911	if (!m_size) {	1918		if (!m_size) {
1912	m_size = UnknownSize;	1919		m_size = UnknownSize;
1913	}	1920		}
1914	}	1921		}
1915		1922
1916	// Send the mime-type...	1923		// Send the mime-type...
1917	if (iCopyFile == -1) {	1924		if (iCopyFile == -1) {
1918	StatusCode status = ftpSendMimeType(iError, url);	1925		const auto result = ftpSendMimeType(url);
1919	if (status != statusSuccess) {	1926		if (!result.success) {
1920	return status;	1927		return result;
1921	}	1928		}
1922	}	1929		}
1923		1930
1924	KIO::filesize_t bytesLeft = 0;	1931		KIO::filesize_t bytesLeft = 0;
1925	if (m_size != UnknownSize) {	1932		if (m_size != UnknownSize) {
1926	bytesLeft = m_size - llOffset;	1933		bytesLeft = m_size - llOffset;
1927	totalSize(m_size); // emit the total size...	1934		totalSize(m_size); // emit the total size...
1928	}	1935		}
Show All 24 Lines		1948	while (m_size == UnknownSize \|\| bytesLeft > 0) {
1953	}	1960		}
1954	int n = m_data->read(buffer + iBufferCur, iBlockSize);	1961		int n = m_data->read(buffer + iBufferCur, iBlockSize);
1955	if (n <= 0) {	1962		if (n <= 0) {
1956	// this is how we detect EOF in case of unknown size	1963		// this is how we detect EOF in case of unknown size
1957	if (m_size == UnknownSize && n == 0) {	1964		if (m_size == UnknownSize && n == 0) {
1958	break;	1965		break;
1959	}	1966		}
1960	// unexpected eof. Happens when the daemon gets killed.	1967		// unexpected eof. Happens when the daemon gets killed.
1961	iError = ERR_CANNOT_READ;	1968		return Result::fail(ERR_CANNOT_READ, StatusCode::ServerError);
1962	return statusServerError;
1963	}	1969		}
1964	processed_size += n;	1970		processed_size += n;
1965		1971
1966	// collect very small data chunks in buffer before processing ...	1972		// collect very small data chunks in buffer before processing ...
1967	if (m_size != UnknownSize) {	1973		if (m_size != UnknownSize) {
1968	bytesLeft -= n;	1974		bytesLeft -= n;
1969	iBufferCur += n;	1975		iBufferCur += n;
1970	if (iBufferCur < minimumMimeSize && bytesLeft > 0) {	1976		if (iBufferCur < minimumMimeSize && bytesLeft > 0) {
1971	processedSize(processed_size);	1977		processedSize(processed_size);
1972	continue;	1978		continue;
1973	}	1979		}
1974	n = iBufferCur;	1980		n = iBufferCur;
1975	iBufferCur = 0;	1981		iBufferCur = 0;
1976	}	1982		}
1977		1983
1978	// write output file or pass to data pump ...	1984		// write output file or pass to data pump ...
		1985		int writeError = 0;
1979	if (iCopyFile == -1) {	1986		if (iCopyFile == -1) {
1980	array = QByteArray::fromRawData(buffer, n);	1987		array = QByteArray::fromRawData(buffer, n);
1981	data(array);	1988		data(array);
1982	array.clear();	1989		array.clear();
1983	} else if ((iError = WriteToFile(iCopyFile, buffer, n)) != 0) {	1990		} else if ((writeError = WriteToFile(iCopyFile, buffer, n)) != 0) {
1984	return statusClientError; // client side error	1991		#pragma message "we cannot construct the final error here because we do not know what the target fiel path is"
			dfaureUnsubmitted Done Yep. Pass sCopyFile as argument, when ftpCopyGet calls ftpGet, just like what happens with iCopyFile. dfaure: Yep. Pass sCopyFile as argument, when ftpCopyGet calls ftpGet, just like what happens with…
		1992		return Result::fail(writeError, QString(), StatusCode::ClientError);
1985	}	1993		}
1986	processedSize(processed_size);	1994
		1995		Q_ASSERT(processed_size >= 0);
		1996		processedSize(static_cast<KIO::filesize_t>(processed_size));
1987	}	1997		}
1988		1998
1989	qCDebug(KIO_FTP) << "done";	1999		qCDebug(KIO_FTP) << "done";
1990	if (iCopyFile == -1) { // must signal EOF to data pump ...	2000		if (iCopyFile == -1) { // must signal EOF to data pump ...
1991	data(array); // array is empty and must be empty!	2001		data(array); // array is empty and must be empty!
1992	}	2002		}
1993		2003
1994	processedSize(m_size == UnknownSize ? processed_size : m_size);	2004		processedSize(m_size == UnknownSize ? processed_size : m_size);
1995	return statusSuccess;	2005		return Result::pass();
1996	}	2006		}
1997		2007
1998	#if 0	2008		#if 0
1999	void Ftp::mimetype(const QUrl &url)	2009		void FtpInternal::mimetype(const QUrl &url)
2000	{	2010		{
2001	if (!ftpOpenConnection(loginImplicit)) {	2011		if (!ftpOpenConnection(loginImplicit)) {
2002	return;	2012		return;
2003	}	2013		}
2004		2014
2005	if (!ftpOpenCommand("retr", url.path(), 'I', ERR_CANNOT_OPEN_FOR_READING, 0)) {	2015		if (!ftpOpenCommand("retr", url.path(), 'I', ERR_CANNOT_OPEN_FOR_READING, 0)) {
2006	qCWarning(KIO_FTP) << "Can't open for reading";	2016		qCWarning(KIO_FTP) << "Can't open for reading";
2007	return;	2017		return;
2008	}	2018		}
2009	char buffer[ 2048 ];	2019		char buffer[ 2048 ];
2010	QByteArray array;	2020		QByteArray array;
2011	// Get one chunk of data only and send it, KIO::Job will determine the	2021		// Get one chunk of data only and send it, KIO::Job will determine the
2012	// mimetype from it using KMimeMagic	2022		// mimetype from it using KMimeMagic
2013	int n = m_data->read(buffer, 2048);	2023		int n = m_data->read(buffer, 2048);
2014	array.setRawData(buffer, n);	2024		array.setRawData(buffer, n);
2015	data(array);	2025		data(array);
2016	array.resetRawData(buffer, n);	2026		array.resetRawData(buffer, n);
2017		2027
2018	qCDebug(KIO_FTP) << "aborting";	2028		qCDebug(KIO_FTP) << "aborting";
2019	ftpAbortTransfer();	2029		ftpAbortTransfer();
2020		2030
2021	qCDebug(KIO_FTP) << "finished";	2031		qCDebug(KIO_FTP) << "finished";
2022	finished();	2032		finished2(Q_FUNC_INFO);
			dfaureUnsubmitted Done ? dfaure: ?
			dfaureUnsubmitted Done `finished(Q_FUNC_INFO)` looks like a local hack? dfaure: `finished(Q_FUNC_INFO)` looks like a local hack?
2023	qCDebug(KIO_FTP) << "after finished";	2033		qCDebug(KIO_FTP) << "after finished";
2024	}	2034		}
2025		2035
2026	void Ftp::ftpAbortTransfer()	2036		void FtpInternal::ftpAbortTransfer()
2027	{	2037		{
2028	// RFC 959, page 34-35	2038		// RFC 959, page 34-35
2029	// IAC (interpret as command) = 255 ; IP (interrupt process) = 254	2039		// IAC (interpret as command) = 255 ; IP (interrupt process) = 254
2030	// DM = 242 (data mark)	2040		// DM = 242 (data mark)
2031	char msg[4];	2041		char msg[4];
2032	// 1. User system inserts the Telnet "Interrupt Process" (IP) signal	2042		// 1. User system inserts the Telnet "Interrupt Process" (IP) signal
2033	// in the Telnet stream.	2043		// in the Telnet stream.
2034	msg[0] = (char) 255; //IAC	2044		msg[0] = (char) 255; //IAC
2035	msg[1] = (char) 254; //IP	2045		msg[1] = (char) 254; //IP
2036	(void) send(sControl, msg, 2, 0);	2046		(void) send(sControl, msg, 2, 0);
2037	// 2. User system sends the Telnet "Sync" signal.	2047		// 2. User system sends the Telnet "Sync" signal.
2038	msg[0] = (char) 255; //IAC	2048		msg[0] = (char) 255; //IAC
2039	msg[1] = (char) 242; //DM	2049		msg[1] = (char) 242; //DM
2040	if (send(sControl, msg, 2, MSG_OOB) != 2)	2050		if (send(sControl, msg, 2, MSG_OOB) != 2)
2041	; // error...	2051		; // error...
2042		2052
2043	// Send ABOR	2053		// Send ABOR
2044	qCDebug(KIO_FTP) << "send ABOR";	2054		qCDebug(KIO_FTP) << "send ABOR";
2045	QCString buf = "ABOR\r\n";	2055		QCString buf = "ABOR\r\n";
2046	if (KSocks::self()->write(sControl, buf.data(), buf.length()) <= 0) {	2056		if (KSocks::self()->write(sControl, buf.data(), buf.length()) <= 0) {
2047	error(ERR_CANNOT_WRITE, QString());	2057		error(ERR_CANNOT_WRITE, QString(), Q_FUNC_INFO);
2048	return;	2058		return;
2049	}	2059		}
2050		2060
2051	//	2061		//
2052	qCDebug(KIO_FTP) << "read resp";	2062		qCDebug(KIO_FTP) << "read resp";
2053	if (readresp() != '2') {	2063		if (readresp() != '2') {
2054	error(ERR_CANNOT_READ, QString());	2064		error(ERR_CANNOT_READ, QString());
2055	return;	2065		return;
2056	}	2066		}
2057		2067
2058	qCDebug(KIO_FTP) << "close sockets";	2068		qCDebug(KIO_FTP) << "close sockets";
2059	closeSockets();	2069		closeSockets();
2060	}	2070		}
2061	#endif	2071		#endif
2062		2072
2063	//===============================================================================	2073		//===============================================================================
2064	// public: put upload file to server	2074		// public: put upload file to server
2065	// helper: ftpPut called from put() and copy()	2075		// helper: ftpPut called from put() and copy()
2066	//===============================================================================	2076		//===============================================================================
2067	void Ftp::put(const QUrl &url, int permissions, KIO::JobFlags flags)	2077		Result FtpInternal::put(const QUrl &url, int permissions, KIO::JobFlags flags)
2068	{	2078		{
2069	qCDebug(KIO_FTP) << url;	2079		qCDebug(KIO_FTP) << url;
2070		2080		const auto result = ftpPut(-1, url, permissions, flags);
2071	int iError = 0; // iError gets status
2072	const StatusCode cs = ftpPut(iError, -1, url, permissions, flags);
2073	ftpCloseCommand(); // must close command!	2081		ftpCloseCommand(); // must close command!
2074		2082		return result;
2075	if (cs == statusSuccess) {
2076	finished();
2077	return;
2078	}	2083		}
2079		2084
2080	if (iError) { // can have only server side errs	2085		#pragma message "ierrror should be moot with results"
			dfaureUnsubmitted Done outdated warning? dfaure: outdated warning?
2081	error(iError, url.path());	2086		Result FtpInternal::ftpPut(int iCopyFile, const QUrl &dest_url,
2082	}
2083	}
2084
2085	Ftp::StatusCode Ftp::ftpPut(int &iError, int iCopyFile, const QUrl &dest_url,
2086	int permissions, KIO::JobFlags flags)	2087		int permissions, KIO::JobFlags flags)
2087	{	2088		{
2088	if (!ftpOpenConnection(loginImplicit)) {	2089		const auto openResult = ftpOpenConnection(LoginMode::Implicit);
2089	return statusServerError;	2090		if (!openResult.success) {
		2091		return openResult;
2090	}	2092		}
2091		2093
2092	// Don't use mark partial over anonymous FTP.	2094		// Don't use mark partial over anonymous FTP.
2093	// My incoming dir allows put but not rename...	2095		// My incoming dir allows put but not rename...
2094	bool bMarkPartial;	2096		bool bMarkPartial;
2095	if (m_user.isEmpty() \|\| m_user == QLatin1String(FTP_LOGIN)) {	2097		if (m_user.isEmpty() \|\| m_user == QLatin1String(FTP_LOGIN)) {
2096	bMarkPartial = false;	2098		bMarkPartial = false;
2097	} else {	2099		} else {
2098	bMarkPartial = config()->readEntry("MarkPartial", true);	2100		bMarkPartial = config()->readEntry("MarkPartial", true);
2099	}	2101		}
2100		2102
2101	QString dest_orig = dest_url.path();	2103		QString dest_orig = dest_url.path();
2102	const QString dest_part = dest_orig + QLatin1String(".part");	2104		const QString dest_part = dest_orig + QLatin1String(".part");
2103		2105
2104	if (ftpSize(dest_orig, 'I')) {	2106		if (ftpSize(dest_orig, 'I')) {
2105	if (m_size == 0) {	2107		if (m_size == 0) {
2106	// delete files with zero size	2108		// delete files with zero size
2107	const QByteArray cmd = "DELE " + remoteEncoding()->encode(dest_orig);	2109		const QByteArray cmd = "DELE " + remoteEncoding()->encode(dest_orig);
2108	if (!ftpSendCmd(cmd) \|\| (m_iRespType != 2)) {	2110		auto result = ftpSendCmd(cmd);
2109	iError = ERR_CANNOT_DELETE_PARTIAL;	2111		if (!result.success \|\| (m_iRespType != 2)) {
2110	return statusServerError;	2112		return Result::fail(ERR_CANNOT_DELETE_PARTIAL, QString(), StatusCode::ServerError);
2111	}	2113		}
2112	} else if (!(flags & KIO::Overwrite) && !(flags & KIO::Resume)) {	2114		} else if (!(flags & KIO::Overwrite) && !(flags & KIO::Resume)) {
2113	iError = ERR_FILE_ALREADY_EXIST;	2115		return Result::fail(ERR_FILE_ALREADY_EXIST, QString(), StatusCode::ServerError);
2114	return statusServerError;
2115	} else if (bMarkPartial) {	2116		} else if (bMarkPartial) {
2116	// when using mark partial, append .part extension	2117		// when using mark partial, append .part extension
2117	if (!ftpRename(dest_orig, dest_part, KIO::Overwrite)) {	2118		const auto result = ftpRename(dest_orig, dest_part, KIO::Overwrite);
2118	iError = ERR_CANNOT_RENAME_PARTIAL;	2119		if (!result.success) {
2119	return statusServerError;	2120		return Result::fail(ERR_CANNOT_RENAME_PARTIAL, QString(), StatusCode::ServerError);
2120	}	2121		}
2121	}	2122		}
2122	// Don't chmod an existing file	2123		// Don't chmod an existing file
2123	permissions = -1;	2124		permissions = -1;
2124	} else if (bMarkPartial && ftpSize(dest_part, 'I')) {	2125		} else if (bMarkPartial && ftpSize(dest_part, 'I')) {
2125	// file with extension .part exists	2126		// file with extension .part exists
2126	if (m_size == 0) {	2127		if (m_size == 0) {
2127	// delete files with zero size	2128		// delete files with zero size
2128	const QByteArray cmd = "DELE " + remoteEncoding()->encode(dest_part);	2129		const QByteArray cmd = "DELE " + remoteEncoding()->encode(dest_part);
2129	if (!ftpSendCmd(cmd) \|\| (m_iRespType != 2)) {	2130		auto result = ftpSendCmd(cmd);
2130	iError = ERR_CANNOT_DELETE_PARTIAL;	2131		if (!result.success \|\| (m_iRespType != 2)) {
2131	return statusServerError;	2132		return Result::fail(ERR_CANNOT_DELETE_PARTIAL, QString(), StatusCode::ServerError);
2132	}	2133		}
2133	} else if (!(flags & KIO::Overwrite) && !(flags & KIO::Resume)) {	2134		} else if (!(flags & KIO::Overwrite) && !(flags & KIO::Resume)) {
2134	flags \|= canResume(m_size) ? KIO::Resume : KIO::DefaultFlags;	2135		flags \|= canResume(m_size) ? KIO::Resume : KIO::DefaultFlags;
2135	if (!(flags & KIO::Resume)) {	2136		if (!(flags & KIO::Resume)) {
2136	iError = ERR_FILE_ALREADY_EXIST;	2137		return Result::fail(ERR_FILE_ALREADY_EXIST, QString(), StatusCode::ServerError);
2137	return statusServerError;
2138	}	2138		}
2139	}	2139		}
2140	} else {	2140		} else {
2141	m_size = 0;	2141		m_size = 0;
2142	}	2142		}
2143		2143
2144	QString dest;	2144		QString dest;
2145		2145
2146	// if we are using marking of partial downloads -> add .part extension	2146		// if we are using marking of partial downloads -> add .part extension
2147	if (bMarkPartial) {	2147		if (bMarkPartial) {
2148	qCDebug(KIO_FTP) << "Adding .part extension to " << dest_orig;	2148		qCDebug(KIO_FTP) << "Adding .part extension to " << dest_orig;
2149	dest = dest_part;	2149		dest = dest_part;
2150	} else {	2150		} else {
2151	dest = dest_orig;	2151		dest = dest_orig;
2152	}	2152		}
2153		2153
2154	KIO::fileoffset_t offset = 0;	2154		KIO::fileoffset_t offset = 0;
2155		2155
2156	// set the mode according to offset	2156		// set the mode according to offset
2157	if ((flags & KIO::Resume) && m_size > 0) {	2157		if ((flags & KIO::Resume) && m_size > 0) {
2158	offset = m_size;	2158		offset = m_size;
2159	if (iCopyFile != -1) {	2159		if (iCopyFile != -1) {
2160	if (QT_LSEEK(iCopyFile, offset, SEEK_SET) < 0) {	2160		if (QT_LSEEK(iCopyFile, offset, SEEK_SET) < 0) {
2161	iError = ERR_CANNOT_RESUME;	2161		return Result::fail(ERR_CANNOT_RESUME, QString(), StatusCode::ServerError);
2162	return statusClientError;
2163	}	2162		}
2164	}	2163		}
2165	}	2164		}
2166		2165
2167	if (! ftpOpenCommand("stor", dest, '?', ERR_CANNOT_WRITE, offset)) {	2166		const auto storResult = ftpOpenCommand("stor", dest, '?', ERR_CANNOT_WRITE, offset);
2168	return statusServerError;	2167		qDebug() << "!!! storresult" << storResult;
			dfaureUnsubmitted Done remember to remove this dfaure: remember to remove this
		2168		if (!storResult.success) {
		2169		#pragma message "re-constructing failure"
			dfaureUnsubmitted Done because of the useless enum? ;) dfaure: because of the useless enum? ;)
		2170		return Result::fail(storResult.error, storResult.errorString, StatusCode::ServerError);
2169	}	2171		}
2170		2172
2171	qCDebug(KIO_FTP) << "ftpPut: starting with offset=" << offset;	2173		qCDebug(KIO_FTP) << "ftpPut: starting with offset=" << offset;
2172	KIO::fileoffset_t processed_size = offset;	2174		KIO::fileoffset_t processed_size = offset;
2173		2175
2174	QByteArray buffer;	2176		QByteArray buffer;
2175	int result;	2177		int result;
2176	int iBlockSize = initialIpcSize;	2178		int iBlockSize = initialIpcSize;
		2179		int writeError = 0;
2177	// Loop until we got 'dataEnd'	2180		// Loop until we got 'dataEnd'
2178	do {	2181		do {
2179	if (iCopyFile == -1) {	2182		if (iCopyFile == -1) {
2180	dataReq(); // Request for data	2183		dataReq(); // Request for data
2181	result = readData(buffer);	2184		result = readData(buffer);
2182	} else {	2185		} else {
2183	// let the buffer size grow if the file is larger 64kByte ...	2186		// let the buffer size grow if the file is larger 64kByte ...
2184	if (processed_size - offset > 1024 * 64) {	2187		if (processed_size - offset > 1024 * 64) {
2185	iBlockSize = maximumIpcSize;	2188		iBlockSize = maximumIpcSize;
2186	}	2189		}
2187	buffer.resize(iBlockSize);	2190		buffer.resize(iBlockSize);
2188	result = QT_READ(iCopyFile, buffer.data(), buffer.size());	2191		result = QT_READ(iCopyFile, buffer.data(), buffer.size());
2189	if (result < 0) {	2192		if (result < 0) {
2190	iError = ERR_CANNOT_WRITE;	2193		#pragma message "isnt this cannot read we fail to read the input file here no"
			dfaureUnsubmitted Done yeah, feel free to change it. dfaure: yeah, feel free to change it.
		2194		writeError = ERR_CANNOT_WRITE;
2191	} else {	2195		} else {
2192	buffer.resize(result);	2196		buffer.resize(result);
2193	}	2197		}
2194	}	2198		}
2195		2199
2196	if (result > 0) {	2200		if (result > 0) {
2197	m_data->write(buffer);	2201		m_data->write(buffer);
2198	while (m_data->bytesToWrite() && m_data->waitForBytesWritten()) {}	2202		while (m_data->bytesToWrite() && m_data->waitForBytesWritten()) {}
2199	processed_size += result;	2203		processed_size += result;
2200	processedSize(processed_size);	2204		processedSize(processed_size);
2201	}	2205		}
2202	} while (result > 0);	2206		} while (result > 0);
2203		2207
2204	if (result != 0) { // error	2208		if (result != 0) { // error
2205	ftpCloseCommand(); // don't care about errors	2209		ftpCloseCommand(); // don't care about errors
2206	qCDebug(KIO_FTP) << "Error during 'put'. Aborting.";	2210		qCDebug(KIO_FTP) << "Error during 'put'. Aborting.";
2207	if (bMarkPartial) {	2211		if (bMarkPartial) {
2208	// Remove if smaller than minimum size	2212		// Remove if smaller than minimum size
2209	if (ftpSize(dest, 'I') &&	2213		if (ftpSize(dest, 'I') &&
2210	(processed_size < config()->readEntry("MinimumKeepSize", DEFAULT_MINIMUM_KEEP_SIZE))) {	2214		(processed_size < config()->readEntry("MinimumKeepSize", DEFAULT_MINIMUM_KEEP_SIZE))) {
2211	const QByteArray cmd = "DELE " + remoteEncoding()->encode(dest);	2215		const QByteArray cmd = "DELE " + remoteEncoding()->encode(dest);
2212	(void) ftpSendCmd(cmd);	2216		(void) ftpSendCmd(cmd);
2213	}	2217		}
2214	}	2218		}
2215	return statusServerError;	2219		return Result::fail(writeError, dest_url.toString(), StatusCode::ServerError);
2216	}	2220		}
2217		2221
2218	if (!ftpCloseCommand()) {	2222		if (!ftpCloseCommand()) {
2219	iError = ERR_CANNOT_WRITE;	2223		return Result::fail(ERR_CANNOT_WRITE, StatusCode::ServerError);
2220	return statusServerError;
2221	}	2224		}
2222		2225
2223	// after full download rename the file back to original name	2226		// after full download rename the file back to original name
2224	if (bMarkPartial) {	2227		if (bMarkPartial) {
2225	qCDebug(KIO_FTP) << "renaming dest (" << dest << ") back to dest_orig (" << dest_orig << ")";	2228		qCDebug(KIO_FTP) << "renaming dest (" << dest << ") back to dest_orig (" << dest_orig << ")";
2226	if (!ftpRename(dest, dest_orig, KIO::Overwrite)) {	2229		const auto result = ftpRename(dest, dest_orig, KIO::Overwrite);
2227	iError = ERR_CANNOT_RENAME_PARTIAL;	2230		if (!result.success) {
2228	return statusServerError;	2231		return Result::fail(ERR_CANNOT_RENAME_PARTIAL, StatusCode::ServerError);
2229	}	2232		}
2230	}	2233		}
2231		2234
2232	// set final permissions	2235		// set final permissions
2233	if (permissions != -1) {	2236		if (permissions != -1) {
2234	if (m_user == QLatin1String(FTP_LOGIN))	2237		if (m_user == QLatin1String(FTP_LOGIN))
2235	qCDebug(KIO_FTP) << "Trying to chmod over anonymous FTP ???";	2238		qCDebug(KIO_FTP) << "Trying to chmod over anonymous FTP ???";
2236	// chmod the file we just put	2239		// chmod the file we just put
2237	if (! ftpChmod(dest_orig, permissions)) {	2240		if (! ftpChmod(dest_orig, permissions)) {
2238	// To be tested	2241		// To be tested
2239	//if ( m_user != FTP_LOGIN )	2242		//if ( m_user != FTP_LOGIN )
2240	// warning( i18n( "Could not change permissions for\n%1" ).arg( dest_orig ) );	2243		// warning( i18n( "Could not change permissions for\n%1" ).arg( dest_orig ) );
2241	}	2244		}
2242	}	2245		}
2243		2246
2244	return statusSuccess;	2247		return Result::pass();
2245	}	2248		}
2246		2249
2247	/** Use the SIZE command to get the file size.	2250		/** Use the SIZE command to get the file size.
2248	Warning : the size depends on the transfer mode, hence the second arg. */	2251		Warning : the size depends on the transfer mode, hence the second arg. */
2249	bool Ftp::ftpSize(const QString &path, char mode)	2252		bool FtpInternal::ftpSize(const QString &path, char mode)
2250	{	2253		{
2251	m_size = UnknownSize;	2254		m_size = UnknownSize;
2252	if (!ftpDataMode(mode)) {	2255		if (!ftpDataMode(mode)) {
2253	return false;	2256		return false;
2254	}	2257		}
2255		2258
2256	const QByteArray buf = "SIZE " + remoteEncoding()->encode(path);	2259		const QByteArray buf = "SIZE " + remoteEncoding()->encode(path);
2257	if (!ftpSendCmd(buf) \|\| (m_iRespType != 2)) {	2260		auto result = ftpSendCmd(buf);
		2261		if (!result.success \|\| (m_iRespType != 2)) {
2258	return false;	2262		return false;
2259	}	2263		}
2260		2264
2261	// skip leading "213 " (response code)	2265		// skip leading "213 " (response code)
2262	QByteArray psz(ftpResponse(4));	2266		QByteArray psz(ftpResponse(4));
2263	if (psz.isEmpty()) {	2267		if (psz.isEmpty()) {
2264	return false;	2268		return false;
2265	}	2269		}
2266	bool ok = false;	2270		bool ok = false;
2267	m_size = psz.trimmed().toLongLong(&ok);	2271		m_size = psz.trimmed().toLongLong(&ok);
2268	if (!ok) {	2272		if (!ok) {
2269	m_size = UnknownSize;	2273		m_size = UnknownSize;
2270	}	2274		}
2271	return true;	2275		return true;
2272	}	2276		}
2273		2277
2274	bool Ftp::ftpFileExists(const QString &path)	2278		bool FtpInternal::ftpFileExists(const QString &path)
2275	{	2279		{
2276	const QByteArray buf = "SIZE " + remoteEncoding()->encode(path);	2280		const QByteArray buf = "SIZE " + remoteEncoding()->encode(path);
2277	if (!ftpSendCmd(buf) \|\| (m_iRespType != 2)) {	2281		const auto result = ftpSendCmd(buf);
		2282		if (!result.success \|\| (m_iRespType != 2)) {
2278	return false;	2283		return false;
2279	}	2284		}
2280		2285
2281	// skip leading "213 " (response code)	2286		// skip leading "213 " (response code)
2282	const char *psz = ftpResponse(4);	2287		const char *psz = ftpResponse(4);
2283	return psz != nullptr;	2288		return psz != nullptr;
2284	}	2289		}
2285		2290
2286	// Today the differences between ASCII and BINARY are limited to	2291		// Today the differences between ASCII and BINARY are limited to
2287	// CR or CR/LF line terminators. Many servers ignore ASCII (like	2292		// CR or CR/LF line terminators. Many servers ignore ASCII (like
2288	// win2003 -or- vsftp with default config). In the early days of	2293		// win2003 -or- vsftp with default config). In the early days of
2289	// computing, when even text-files had structure, this stuff was	2294		// computing, when even text-files had structure, this stuff was
2290	// more important.	2295		// more important.
2291	// Theoretically "list" could return different results in ASCII	2296		// Theoretically "list" could return different results in ASCII
2292	// and BINARY mode. But again, most servers ignore ASCII here.	2297		// and BINARY mode. But again, most servers ignore ASCII here.
2293	bool Ftp::ftpDataMode(char cMode)	2298		bool FtpInternal::ftpDataMode(char cMode)
2294	{	2299		{
2295	if (cMode == '?') {	2300		if (cMode == '?') {
2296	cMode = m_bTextMode ? 'A' : 'I';	2301		cMode = m_bTextMode ? 'A' : 'I';
2297	} else if (cMode == 'a') {	2302		} else if (cMode == 'a') {
2298	cMode = 'A';	2303		cMode = 'A';
2299	} else if (cMode != 'A') {	2304		} else if (cMode != 'A') {
2300	cMode = 'I';	2305		cMode = 'I';
2301	}	2306		}
2302		2307
2303	qCDebug(KIO_FTP) << "want" << cMode << "has" << m_cDataMode;	2308		qCDebug(KIO_FTP) << "want" << cMode << "has" << m_cDataMode;
2304	if (m_cDataMode == cMode) {	2309		if (m_cDataMode == cMode) {
2305	return true;	2310		return true;
2306	}	2311		}
2307		2312
2308	const QByteArray buf = QByteArrayLiteral("TYPE ") + cMode;	2313		const QByteArray buf = QByteArrayLiteral("TYPE ") + cMode;
2309	if (!ftpSendCmd(buf) \|\| (m_iRespType != 2)) {	2314		const auto result = ftpSendCmd(buf);
		2315		if (!result.success \|\| (m_iRespType != 2)) {
2310	return false;	2316		return false;
2311	}	2317		}
2312	m_cDataMode = cMode;	2318		m_cDataMode = cMode;
2313	return true;	2319		return true;
2314	}	2320		}
2315		2321
2316	bool Ftp::ftpFolder(const QString &path, bool bReportError)	2322		bool FtpInternal::ftpFolder(const QString &path, bool bReportError)
2317	{	2323		{
2318	QString newPath = path;	2324		QString newPath = path;
2319	int iLen = newPath.length();	2325		int iLen = newPath.length();
2320	if (iLen > 1 && newPath[iLen - 1] == QLatin1Char('/')) {	2326		if (iLen > 1 && newPath[iLen - 1] == QLatin1Char('/')) {
2321	newPath.chop(1);	2327		newPath.chop(1);
2322	}	2328		}
2323		2329
2324	qCDebug(KIO_FTP) << "want" << newPath << "has" << m_currentPath;	2330		qCDebug(KIO_FTP) << "want" << newPath << "has" << m_currentPath;
2325	if (m_currentPath == newPath) {	2331		if (m_currentPath == newPath) {
2326	return true;	2332		return true;
2327	}	2333		}
2328		2334
2329	const QByteArray tmp = "cwd " + remoteEncoding()->encode(newPath);	2335		const QByteArray tmp = "cwd " + remoteEncoding()->encode(newPath);
2330	if (!ftpSendCmd(tmp)) {	2336		const auto result = ftpSendCmd(tmp);
		2337		if (!result.success) {
2331	return false; // connection failure	2338		return false; // connection failure
2332	}	2339		}
2333	if (m_iRespType != 2) {	2340		if (m_iRespType != 2) {
2334	if (bReportError) {	2341		#pragma message "reporterror has been broken not sure what to do with it"
			dfaureUnsubmitted Done Well, that's part of your refactoring. It was used to decide if a method should emit error on failure or just return false. It was part of the big mess that you're cleaning up. Kill bReportError completely. dfaure: Well, that's part of your refactoring. It was used to decide if a method should emit error on…
2335	error(ERR_CANNOT_ENTER_DIRECTORY, path);	2342		// if (bReportError) {
2336	}	2343		// error(ERR_CANNOT_ENTER_DIRECTORY, path);
		2344		// }
2337	return false; // not a folder	2345		return false; // not a folder
2338	}	2346		}
2339	m_currentPath = newPath;	2347		m_currentPath = newPath;
2340	return true;	2348		return true;
2341	}	2349		}
2342		2350
2343	//===============================================================================	2351		//===============================================================================
2344	// public: copy don't use kio data pump if one side is a local file	2352		// public: copy don't use kio data pump if one side is a local file
2345	// helper: ftpCopyPut called from copy() on upload	2353		// helper: ftpCopyPut called from copy() on upload
2346	// helper: ftpCopyGet called from copy() on download	2354		// helper: ftpCopyGet called from copy() on download
2347	//===============================================================================	2355		//===============================================================================
2348	void Ftp::copy(const QUrl &src, const QUrl &dest, int permissions, KIO::JobFlags flags)	2356		Result FtpInternal::copy(const QUrl &src, const QUrl &dest, int permissions, KIO::JobFlags flags)
2349	{	2357		{
2350	int iError = 0;
2351	int iCopyFile = -1;	2358		int iCopyFile = -1;
2352	StatusCode cs = statusSuccess;
2353	bool bSrcLocal = src.isLocalFile();	2359		bool bSrcLocal = src.isLocalFile();
2354	bool bDestLocal = dest.isLocalFile();	2360		bool bDestLocal = dest.isLocalFile();
2355	QString sCopyFile;	2361		QString sCopyFile;
2356		2362
		2363		Result result = Result::pass();
			dfaureUnsubmitted Done optimistic but useless initializations, all code paths set (or ignore) result. dfaure: optimistic but useless initializations, all code paths set (or ignore) result.
			sitterAuthorUnsubmitted Done I do need to declare it though, and by design a Result cannot have a "null" state, so I either need to initialize a failure or pass here. Do you have a better suggestion? sitter: I do need to declare it though, and by design a Result cannot have a "null" state, so I either…
			dfaureUnsubmitted Done Ah ok, never mind then. dfaure: Ah ok, never mind then.
2357	if (bSrcLocal && !bDestLocal) { // File -> Ftp	2364		if (bSrcLocal && !bDestLocal) { // File -> Ftp
2358	sCopyFile = src.toLocalFile();	2365		sCopyFile = src.toLocalFile();
2359	qCDebug(KIO_FTP) << "local file" << sCopyFile << "-> ftp" << dest.path();	2366		qCDebug(KIO_FTP) << "local file" << sCopyFile << "-> ftp" << dest.path();
2360	cs = ftpCopyPut(iError, iCopyFile, sCopyFile, dest, permissions, flags);	2367		result = ftpCopyPut(iCopyFile, sCopyFile, dest, permissions, flags);
2361	} else if (!bSrcLocal && bDestLocal) { // Ftp -> File	2368		} else if (!bSrcLocal && bDestLocal) { // Ftp -> File
2362	sCopyFile = dest.toLocalFile();	2369		sCopyFile = dest.toLocalFile();
2363	qCDebug(KIO_FTP) << "ftp" << src.path() << "-> local file" << sCopyFile;	2370		qCDebug(KIO_FTP) << "ftp" << src.path() << "-> local file" << sCopyFile;
2364	cs = ftpCopyGet(iError, iCopyFile, sCopyFile, src, permissions, flags);	2371		result = ftpCopyGet(iCopyFile, sCopyFile, src, permissions, flags);
2365	} else {	2372		} else {
2366	error(ERR_UNSUPPORTED_ACTION, QString());	2373		return Result::fail(ERR_UNSUPPORTED_ACTION, QString());
2367	return;
2368	}	2374		}
2369		2375
2370	// perform clean-ups and report error (if any)	2376		// perform clean-ups and report error (if any)
2371	if (iCopyFile != -1) {	2377		if (iCopyFile != -1) {
2372	QT_CLOSE(iCopyFile);	2378		QT_CLOSE(iCopyFile);
2373	}	2379		}
2374	ftpCloseCommand(); // must close command!	2380		ftpCloseCommand(); // must close command!
2375	if (cs == statusServerError && iError) {	2381
2376	error(iError, sCopyFile);	2382		return result;
2377	} else {
2378	finished();
2379	}
2380	}	2383		}
2381		2384
2382	Ftp::StatusCode Ftp::ftpCopyPut(int &iError, int &iCopyFile, const QString &sCopyFile,	2385		Result FtpInternal::ftpCopyPut(int &iCopyFile, const QString &sCopyFile,
2383	const QUrl &url, int permissions, KIO::JobFlags flags)	2386		const QUrl &url, int permissions, KIO::JobFlags flags)
2384	{	2387		{
2385	// check if source is ok ...	2388		// check if source is ok ...
2386	QFileInfo info(sCopyFile);	2389		QFileInfo info(sCopyFile);
2387	bool bSrcExists = info.exists();	2390		bool bSrcExists = info.exists();
2388	if (bSrcExists) {	2391		if (bSrcExists) {
2389	if (info.isDir()) {	2392		if (info.isDir()) {
2390	iError = ERR_IS_DIRECTORY;	2393		return Result::fail(ERR_IS_DIRECTORY, StatusCode::ClientError);
2391	return statusClientError;
2392	}	2394		}
2393	} else {	2395		} else {
2394	iError = ERR_DOES_NOT_EXIST;	2396		return Result::fail(ERR_DOES_NOT_EXIST, StatusCode::ClientError);
2395	return statusClientError;
2396	}	2397		}
2397		2398
2398	iCopyFile = QT_OPEN(QFile::encodeName(sCopyFile).constData(), O_RDONLY);	2399		iCopyFile = QT_OPEN(QFile::encodeName(sCopyFile).constData(), O_RDONLY);
2399	if (iCopyFile == -1) {	2400		if (iCopyFile == -1) {
2400	iError = ERR_CANNOT_OPEN_FOR_READING;	2401		return Result::fail(ERR_CANNOT_OPEN_FOR_READING, StatusCode::ClientError);
2401	return statusClientError;
2402	}	2402		}
2403		2403
2404	// delegate the real work (iError gets status) ...	2404		// delegate the real work (iError gets status) ...
2405	totalSize(info.size());	2405		totalSize(info.size());
2406	#ifdef ENABLE_CAN_RESUME	2406		#ifdef ENABLE_CAN_RESUME
2407	return ftpPut(iError, iCopyFile, url, permissions, flags & ~KIO::Resume);	2407		return ftpPut(iCopyFile, url, permissions, flags & ~KIO::Resume);
2408	#else	2408		#else
2409	return ftpPut(iError, iCopyFile, url, permissions, flags \| KIO::Resume);	2409		return ftpPut(iError, iCopyFile, url, permissions, flags \| KIO::Resume);
			dfaureUnsubmitted Done probably needs the same treatment, i.e. removing iError? (ifdef'ed out code) dfaure: probably needs the same treatment, i.e. removing iError? (ifdef'ed out code)
2410	#endif	2410		#endif
2411	}	2411		}
2412		2412
2413	Ftp::StatusCode Ftp::ftpCopyGet(int &iError, int &iCopyFile, const QString &sCopyFile,	2413		Result FtpInternal::ftpCopyGet(int &iCopyFile, const QString &sCopyFile,
2414	const QUrl &url, int permissions, KIO::JobFlags flags)	2414		const QUrl &url, int permissions, KIO::JobFlags flags)
2415	{	2415		{
2416	// check if destination is ok ...	2416		// check if destination is ok ...
2417	QFileInfo info(sCopyFile);	2417		QFileInfo info(sCopyFile);
2418	const bool bDestExists = info.exists();	2418		const bool bDestExists = info.exists();
2419	if (bDestExists) {	2419		if (bDestExists) {
2420	if (info.isDir()) {	2420		if (info.isDir()) {
2421	iError = ERR_IS_DIRECTORY;	2421		return Result::fail(ERR_IS_DIRECTORY, StatusCode::ClientError);
2422	return statusClientError;
2423	}	2422		}
2424	if (!(flags & KIO::Overwrite)) {	2423		if (!(flags & KIO::Overwrite)) {
2425	iError = ERR_FILE_ALREADY_EXIST;	2424		return Result::fail(ERR_FILE_ALREADY_EXIST, StatusCode::ClientError);
2426	return statusClientError;
2427	}	2425		}
2428	}	2426		}
2429		2427
2430	// do we have a ".part" file?	2428		// do we have a ".part" file?
2431	const QString sPart = sCopyFile + QLatin1String(".part");	2429		const QString sPart = sCopyFile + QLatin1String(".part");
2432	bool bResume = false;	2430		bool bResume = false;
2433	QFileInfo sPartInfo(sPart);	2431		QFileInfo sPartInfo(sPart);
2434	const bool bPartExists = sPartInfo.exists();	2432		const bool bPartExists = sPartInfo.exists();
2435	const bool bMarkPartial = config()->readEntry("MarkPartial", true);	2433		const bool bMarkPartial = config()->readEntry("MarkPartial", true);
2436	const QString dest = bMarkPartial ? sPart : sCopyFile;	2434		const QString dest = bMarkPartial ? sPart : sCopyFile;
2437	if (bMarkPartial && bPartExists && sPartInfo.size() > 0) {	2435		if (bMarkPartial && bPartExists && sPartInfo.size() > 0) {
2438	// must not be a folder! please fix a similar bug in kio_file!!	2436		// must not be a folder! please fix a similar bug in kio_file!!
2439	if (sPartInfo.isDir()) {	2437		if (sPartInfo.isDir()) {
2440	iError = ERR_DIR_ALREADY_EXIST;	2438		return Result::fail(ERR_DIR_ALREADY_EXIST, StatusCode::ClientError);
2441	return statusClientError; // client side error
2442	}	2439		}
2443	//doesn't work for copy? -> design flaw?	2440		//doesn't work for copy? -> design flaw?
2444	#ifdef ENABLE_CAN_RESUME	2441		#ifdef ENABLE_CAN_RESUME
2445	bResume = canResume(sPartInfo.size());	2442		bResume = canResume(sPartInfo.size());
2446	#else	2443		#else
2447	bResume = true;	2444		bResume = true;
2448	#endif	2445		#endif
2449	}	2446		}
2450		2447
2451	if (bPartExists && !bResume) { // get rid of an unwanted ".part" file	2448		if (bPartExists && !bResume) { // get rid of an unwanted ".part" file
2452	QFile::remove(sPart);	2449		QFile::remove(sPart);
2453	}	2450		}
2454		2451
2455	// WABA: Make sure that we keep writing permissions ourselves,	2452		// WABA: Make sure that we keep writing permissions ourselves,
2456	// otherwise we can be in for a surprise on NFS.	2453		// otherwise we can be in for a surprise on NFS.
2457	mode_t initialMode;	2454		mode_t initialMode;
2458	if (permissions != -1) {	2455		if (permissions >= 0) {
2459	initialMode = permissions \| S_IWUSR;	2456		initialMode = static_cast<mode_t>(permissions \| S_IWUSR);
2460	} else {	2457		} else {
2461	initialMode = 0666;	2458		initialMode = 0666;
2462	}	2459		}
2463		2460
2464	// open the output file ...	2461		// open the output file ...
2465	KIO::fileoffset_t hCopyOffset = 0;	2462		KIO::fileoffset_t hCopyOffset = 0;
2466	if (bResume) {	2463		if (bResume) {
2467	iCopyFile = QT_OPEN(QFile::encodeName(sPart).constData(), O_RDWR); // append if resuming	2464		iCopyFile = QT_OPEN(QFile::encodeName(sPart).constData(), O_RDWR); // append if resuming
2468	hCopyOffset = QT_LSEEK(iCopyFile, 0, SEEK_END);	2465		hCopyOffset = QT_LSEEK(iCopyFile, 0, SEEK_END);
2469	if (hCopyOffset < 0) {	2466		if (hCopyOffset < 0) {
2470	iError = ERR_CANNOT_RESUME;	2467		return Result::fail(ERR_CANNOT_RESUME, StatusCode::ClientError);
2471	return statusClientError; // client side error
2472	}	2468		}
2473	qCDebug(KIO_FTP) << "resuming at " << hCopyOffset;	2469		qCDebug(KIO_FTP) << "resuming at " << hCopyOffset;
2474	} else {	2470		} else {
2475	iCopyFile = QT_OPEN(QFile::encodeName(dest).constData(), O_CREAT \| O_TRUNC \| O_WRONLY, initialMode);	2471		iCopyFile = QT_OPEN(QFile::encodeName(dest).constData(), O_CREAT \| O_TRUNC \| O_WRONLY, initialMode);
2476	}	2472		}
2477		2473
2478	if (iCopyFile == -1) {	2474		if (iCopyFile == -1) {
2479	qCDebug(KIO_FTP) << "### COULD NOT WRITE " << sCopyFile;	2475		qCDebug(KIO_FTP) << "### COULD NOT WRITE " << sCopyFile;
2480	iError = (errno == EACCES) ? ERR_WRITE_ACCESS_DENIED	2476		const int error = (errno == EACCES) ? ERR_WRITE_ACCESS_DENIED
2481	: ERR_CANNOT_OPEN_FOR_WRITING;	2477		: ERR_CANNOT_OPEN_FOR_WRITING;
2482	return statusClientError;	2478		return Result::fail(error, StatusCode::ClientError);
2483	}	2479		}
2484		2480
2485	// delegate the real work (iError gets status) ...	2481		// delegate the real work (iError gets status) ...
2486	StatusCode iRes = ftpGet(iError, iCopyFile, url, hCopyOffset);	2482		auto result = ftpGet(iCopyFile, url, hCopyOffset);
2487	if (QT_CLOSE(iCopyFile) && iRes == statusSuccess) {	2483
2488	iError = ERR_CANNOT_WRITE;	2484		if (QT_CLOSE(iCopyFile) == 0 && !result.success) {
2489	iRes = statusClientError;	2485		// If Closing the file failed but there isn't an error yet, switch
			dfaureUnsubmitted Done s/Closing/closing/ dfaure: s/Closing/closing/
		2486		// into an error!
		2487		result = Result::fail(ERR_CANNOT_WRITE, StatusCode::ClientError);
		2488		#pragma message "shouldnt we return here"
			dfaureUnsubmitted Done no, we keep going in order to delete the .part file dfaure: no, we keep going in order to delete the .part file
2490	}	2489		}
2491	iCopyFile = -1;	2490		iCopyFile = -1;
2492		2491
2493	// handle renaming or deletion of a partial file ...	2492		// handle renaming or deletion of a partial file ...
2494	if (bMarkPartial) {	2493		if (bMarkPartial) {
2495	if (iRes == statusSuccess) {	2494		if (result.success) {
2496	// rename ".part" on success	2495		// rename ".part" on success
2497	if (!QFile::rename(sPart, sCopyFile)) {	2496		if (!QFile::rename(sPart, sCopyFile)) {
2498	// If rename fails, try removing the destination first if it exists.	2497		// If rename fails, try removing the destination first if it exists.
2499	if (!bDestExists \|\| !(QFile::remove(sCopyFile) && QFile::rename(sPart, sCopyFile))) {	2498		if (!bDestExists \|\| !(QFile::remove(sCopyFile) && QFile::rename(sPart, sCopyFile))) {
2500	qCDebug(KIO_FTP) << "cannot rename " << sPart << " to " << sCopyFile;	2499		qCDebug(KIO_FTP) << "cannot rename " << sPart << " to " << sCopyFile;
2501	iError = ERR_CANNOT_RENAME_PARTIAL;	2500		result = Result::fail(ERR_CANNOT_RENAME_PARTIAL, StatusCode::ClientError);
2502	iRes = statusClientError;
2503	}	2501		}
2504	}	2502		}
2505	} else {	2503		} else {
2506	sPartInfo.refresh();	2504		sPartInfo.refresh();
2507	if (sPartInfo.exists()) { // should a very small ".part" be deleted?	2505		if (sPartInfo.exists()) { // should a very small ".part" be deleted?
2508	int size = config()->readEntry("MinimumKeepSize", DEFAULT_MINIMUM_KEEP_SIZE);	2506		int size = config()->readEntry("MinimumKeepSize", DEFAULT_MINIMUM_KEEP_SIZE);
2509	if (sPartInfo.size() < size) {	2507		if (sPartInfo.size() < size) {
2510	QFile::remove(sPart);	2508		QFile::remove(sPart);
2511	}	2509		}
2512	}	2510		}
2513	}	2511		}
2514	}	2512		}
2515		2513
2516	if (iRes == statusSuccess) {	2514		if (result.success) {
2517	const QString mtimeStr = metaData(QStringLiteral("modified"));	2515		const QString mtimeStr = metaData(QStringLiteral("modified"));
2518	if (!mtimeStr.isEmpty()) {	2516		if (!mtimeStr.isEmpty()) {
2519	QDateTime dt = QDateTime::fromString(mtimeStr, Qt::ISODate);	2517		QDateTime dt = QDateTime::fromString(mtimeStr, Qt::ISODate);
2520	if (dt.isValid()) {	2518		if (dt.isValid()) {
2521	qCDebug(KIO_FTP) << "Updating modified timestamp to" << mtimeStr;	2519		qCDebug(KIO_FTP) << "Updating modified timestamp to" << mtimeStr;
2522	struct utimbuf utbuf;	2520		struct utimbuf utbuf;
2523	info.refresh();	2521		info.refresh();
2524	utbuf.actime = info.lastRead().toSecsSinceEpoch(); // access time, unchanged	2522		utbuf.actime = info.lastRead().toSecsSinceEpoch(); // access time, unchanged
2525	utbuf.modtime = dt.toSecsSinceEpoch(); // modification time	2523		utbuf.modtime = dt.toSecsSinceEpoch(); // modification time
2526	::utime(QFile::encodeName(sCopyFile).constData(), &utbuf);	2524		::utime(QFile::encodeName(sCopyFile).constData(), &utbuf);
2527	}	2525		}
2528	}	2526		}
2529	}	2527		}
2530		2528
2531	return iRes;	2529		return result;
2532	}	2530		}
2533		2531
2534	Ftp::StatusCode Ftp::ftpSendMimeType(int &iError, const QUrl &url)	2532		Result FtpInternal::ftpSendMimeType(const QUrl &url)
2535	{	2533		{
2536	const int totalSize = ((m_size == UnknownSize \|\| m_size > 1024) ? 1024 : m_size);	2534		const int totalSize = ((m_size == UnknownSize \|\| m_size > 1024) ? 1024 : static_cast<int>(m_size));
2537	QByteArray buffer(totalSize, '\0');	2535		QByteArray buffer(totalSize, '\0');
2538		2536
2539	while (true) {	2537		while (true) {
2540	// Wait for content to be available...	2538		// Wait for content to be available...
2541	if (m_data->bytesAvailable() == 0 && !m_data->waitForReadyRead((readTimeout() * 1000))) {	2539		if (m_data->bytesAvailable() == 0 && !m_data->waitForReadyRead((readTimeout() * 1000))) {
2542	iError = ERR_CANNOT_READ;	2540		return Result::fail(ERR_CANNOT_READ, url.toString(), StatusCode::ServerError);
2543	return statusServerError;
2544	}	2541		}
2545		2542
2546	const int bytesRead = m_data->peek(buffer.data(), totalSize);	2543		const qint64 bytesRead = m_data->peek(buffer.data(), totalSize);
2547		2544
2548	// If we got a -1, it must be an error so return an error.	2545		// If we got a -1, it must be an error so return an error.
2549	if (bytesRead == -1) {	2546		if (bytesRead == -1) {
2550	iError = ERR_CANNOT_READ;	2547		return Result::fail(ERR_CANNOT_READ, url.toString(), StatusCode::ServerError);
2551	return statusServerError;
2552	}	2548		}
2553		2549
2554	// If m_size is unknown, peek returns 0 (0 sized file ??), or peek returns size	2550		// If m_size is unknown, peek returns 0 (0 sized file ??), or peek returns size
2555	// equal to the size we want, then break.	2551		// equal to the size we want, then break.
2556	if (bytesRead == 0 \|\| bytesRead == totalSize \|\| m_size == UnknownSize) {	2552		if (bytesRead == 0 \|\| bytesRead == totalSize \|\| m_size == UnknownSize) {
2557	break;	2553		break;
2558	}	2554		}
2559	}	2555		}
2560		2556
2561	if (!buffer.isEmpty()) {	2557		if (!buffer.isEmpty()) {
2562	QMimeDatabase db;	2558		QMimeDatabase db;
2563	QMimeType mime = db.mimeTypeForFileNameAndData(url.path(), buffer);	2559		QMimeType mime = db.mimeTypeForFileNameAndData(url.path(), buffer);
2564	qCDebug(KIO_FTP) << "Emitting mimetype" << mime.name();	2560		qCDebug(KIO_FTP) << "Emitting mimetype" << mime.name();
2565	mimeType(mime.name()); // emit the mime type...	2561		mimeType(mime.name()); // emit the mime type...
2566	}	2562		}
2567		2563
2568	return statusSuccess;	2564		return Result::pass();
2569	}	2565		}
2570		2566
2571	void Ftp::proxyAuthentication(const QNetworkProxy &proxy, QAuthenticator *authenticator)	2567		void FtpInternal::proxyAuthentication(const QNetworkProxy &proxy, QAuthenticator *authenticator)
2572	{	2568		{
2573	Q_UNUSED(proxy);	2569		Q_UNUSED(proxy);
2574	qCDebug(KIO_FTP) << "Authenticator received -- realm:" << authenticator->realm() << "user:" << authenticator->user();	2570		qCDebug(KIO_FTP) << "Authenticator received -- realm:" << authenticator->realm() << "user:" << authenticator->user();
2575		2571
2576	AuthInfo info;	2572		AuthInfo info;
2577	info.url = m_proxyURL;	2573		info.url = m_proxyURL;
2578	info.realmValue = authenticator->realm();	2574		info.realmValue = authenticator->realm();
2579	info.verifyPath = true; //### whatever	2575		info.verifyPath = true; //### whatever
2580	info.username = authenticator->user();	2576		info.username = authenticator->user();
2581		2577
2582	const bool haveCachedCredentials = checkCachedAuthentication(info);	2578		const bool haveCachedCredentials = checkCachedAuthentication(info);
2583		2579
2584	// if m_socketProxyAuth is a valid pointer then authentication has been attempted before,	2580		// if m_socketProxyAuth is a valid pointer then authentication has been attempted before,
2585	// and it was not successful. see below and saveProxyAuthenticationForSocket().	2581		// and it was not successful. see below and saveProxyAuthenticationForSocket().
2586	if (!haveCachedCredentials \|\| m_socketProxyAuth) {	2582		if (!haveCachedCredentials \|\| m_socketProxyAuth) {
2587	// Save authentication info if the connection succeeds. We need to disconnect	2583		// Save authentication info if the connection succeeds. We need to disconnect
2588	// this after saving the auth data (or an error) so we won't save garbage afterwards!	2584		// this after saving the auth data (or an error) so we won't save garbage afterwards!
2589	connect(m_control, &QAbstractSocket::connected, this, &Ftp::saveProxyAuthentication);	2585		connect(m_control, &QAbstractSocket::connected, this, &FtpInternal::saveProxyAuthentication);
2590	//### fillPromptInfo(&info);	2586		//### fillPromptInfo(&info);
2591	info.prompt = i18n("You need to supply a username and a password for "	2587		info.prompt = i18n("You need to supply a username and a password for "
2592	"the proxy server listed below before you are allowed "	2588		"the proxy server listed below before you are allowed "
2593	"to access any sites.");	2589		"to access any sites.");
2594	info.keepPassword = true;	2590		info.keepPassword = true;
2595	info.commentLabel = i18n("Proxy:");	2591		info.commentLabel = i18n("Proxy:");
2596	info.comment = i18n("<b>%1</b> at <b>%2</b>", info.realmValue, m_proxyURL.host());	2592		info.comment = i18n("<b>%1</b> at <b>%2</b>", info.realmValue, m_proxyURL.host());
2597	const int errorCode = openPasswordDialogV2(info, i18n("Proxy Authentication Failed."));	2593		const int errorCode = openPasswordDialogV2(info, i18n("Proxy Authentication Failed."));
2598	if (errorCode) {	2594		if (errorCode) {
2599	qCDebug(KIO_FTP) << "user canceled proxy authentication, or communication error.";	2595		qCDebug(KIO_FTP) << "user canceled proxy authentication, or communication error.";
2600	error(errorCode, m_proxyURL.host());	2596		#pragma message "problem this is a slot so we cant return a result up the call chain maybe do it like errno or something"
			dfaureUnsubmitted Done Yes, clearly. But the question is where to check it. Hmm, how does this method even get called, without an event loop? From `m_control->waitForReadyRead`, maybe? The old code was broken here, it would for sure emit error+error or error+finished, since the main code had no idea that this slot emitted error already. Hmm. Shouldn't we do this connect before the waitForConnected in Ftp::synchronousConnectToHost? If a proxy exists, it will surely act at connection time? And then it becomes easier, the place where to check the errno-like member is just after the call to Ftp::synchronousConnectToHost... dfaure: Yes, clearly. But the question is where to check it. Hmm, how does this method even get called…
			sitterAuthorUnsubmitted Done Since you mention it... where even is the eventloop for any of this? SlaveBase has no event processing, neither does the FTP slave. I get the distinct feeling that the entire auth code never worked, or at least not since kf5. To that end I'd actually be in favor of removing it since no one complained (or I cannot find any bug report anyway). From some limited testing your assessment would be mostly correct though. When trying to waitForConnected there'd be a ProxyAuthenticationRequiredError. Which we can handle somewhat awkwardly by querying the info from the user and then setting a newly "enhanced" proxy QNetworkProxy::setApplicationProxy before creating a new socket I guess. I'm not too excited about fixing proxy auth support no one apparently needs. Originally introduced without review as well: https://git.reviewboard.kde.org/r/102923/ sitter: Since you mention it... where even is the eventloop for any of this? SlaveBase has no event…
			dfaureUnsubmitted Done The (restricted) event loop is within waitFor. It's not a full event loop, but it processes socket events, which in turn leads to that proxy handling. dfaure:* The (restricted) event loop is within waitFor*. It's not a full event loop, but it processes…
		2597		// error(errorCode, m_proxyURL.host());
2601	return;	2598		return;
2602	}	2599		}
2603	}	2600		}
2604	authenticator->setUser(info.username);	2601		authenticator->setUser(info.username);
2605	authenticator->setPassword(info.password);	2602		authenticator->setPassword(info.password);
2606	authenticator->setOption(QStringLiteral("keepalive"), info.keepPassword);	2603		authenticator->setOption(QStringLiteral("keepalive"), info.keepPassword);
2607		2604
2608	if (m_socketProxyAuth) {	2605		if (m_socketProxyAuth) {
2609	m_socketProxyAuth = authenticator;	2606		m_socketProxyAuth = authenticator;
2610	} else {	2607		} else {
2611	m_socketProxyAuth = new QAuthenticator(*authenticator);	2608		m_socketProxyAuth = new QAuthenticator(*authenticator);
2612	}	2609		}
2613		2610
2614	m_proxyURL.setUserName(info.username);	2611		m_proxyURL.setUserName(info.username);
2615	m_proxyURL.setPassword(info.password);	2612		m_proxyURL.setPassword(info.password);
2616	}	2613		}
2617		2614
2618	void Ftp::saveProxyAuthentication()	2615		void FtpInternal::saveProxyAuthentication()
2619	{	2616		{
2620	qCDebug(KIO_FTP);	2617		qCDebug(KIO_FTP);
2621	disconnect(m_control, &QAbstractSocket::connected, this, &Ftp::saveProxyAuthentication);	2618		disconnect(m_control, &QAbstractSocket::connected, this, &FtpInternal::saveProxyAuthentication);
2622	Q_ASSERT(m_socketProxyAuth);	2619		Q_ASSERT(m_socketProxyAuth);
2623	if (m_socketProxyAuth) {	2620		if (m_socketProxyAuth) {
2624	qCDebug(KIO_FTP) << "-- realm:" << m_socketProxyAuth->realm() << "user:" << m_socketProxyAuth->user();	2621		qCDebug(KIO_FTP) << "-- realm:" << m_socketProxyAuth->realm() << "user:" << m_socketProxyAuth->user();
2625	KIO::AuthInfo a;	2622		KIO::AuthInfo a;
2626	a.verifyPath = true;	2623		a.verifyPath = true;
2627	a.url = m_proxyURL;	2624		a.url = m_proxyURL;
2628	a.realmValue = m_socketProxyAuth->realm();	2625		a.realmValue = m_socketProxyAuth->realm();
2629	a.username = m_socketProxyAuth->user();	2626		a.username = m_socketProxyAuth->user();
2630	a.password = m_socketProxyAuth->password();	2627		a.password = m_socketProxyAuth->password();
2631	a.keepPassword = m_socketProxyAuth->option(QStringLiteral("keepalive")).toBool();	2628		a.keepPassword = m_socketProxyAuth->option(QStringLiteral("keepalive")).toBool();
2632	cacheAuthentication(a);	2629		cacheAuthentication(a);
2633	}	2630		}
2634	delete m_socketProxyAuth;	2631		delete m_socketProxyAuth;
2635	m_socketProxyAuth = nullptr;	2632		m_socketProxyAuth = nullptr;
2636	}	2633		}
2637		2634
2638	void Ftp::fixupEntryName(FtpEntry *e)	2635		void FtpInternal::fixupEntryName(FtpEntry *e)
2639	{	2636		{
2640	Q_ASSERT(e);	2637		Q_ASSERT(e);
2641	if (e->type == S_IFDIR) {	2638		if (e->type == S_IFDIR) {
2642	if (!ftpFolder(e->name, false)) {	2639		if (!ftpFolder(e->name, false)) {
2643	QString name(e->name.trimmed());	2640		QString name(e->name.trimmed());
2644	if (ftpFolder(name, false)) {	2641		if (ftpFolder(name, false)) {
2645	e->name = name;	2642		e->name = name;
2646	qCDebug(KIO_FTP) << "fixing up directory name from" << e->name << "to" << name;	2643		qCDebug(KIO_FTP) << "fixing up directory name from" << e->name << "to" << name;
Show All 27 Lines		2668	if (ftpFileExists(name)) {
2674	break;	2671		break;
2675	}	2672		}
2676	}	2673		}
2677	}	2674		}
2678	}	2675		}
2679	}	2676		}
2680	}	2677		}
2681		2678
2682	QTcpSocket *Ftp::synchronousConnectToHost(const QString &host, quint16 port)	2679		QTcpSocket *FtpInternal::synchronousConnectToHost(const QString &host, quint16 port)
2683	{	2680		{
2684	QTcpSocket *socket = new QSslSocket;	2681		QTcpSocket *socket = new QSslSocket;
2685	socket->connectToHost(host, port);	2682		socket->connectToHost(host, port);
2686	socket->waitForConnected(connectTimeout() * 1000);	2683		socket->waitForConnected(connectTimeout() * 1000);
2687	return socket;	2684		return socket;
2688	}	2685		}
2689		2686
		2687		//===============================================================================
		2688		// Ftp
		2689		//===============================================================================
		2690
		2691		Ftp::Ftp(const QByteArray &pool, const QByteArray &app)
		2692		: SlaveBase(QByteArrayLiteral("ftp"), pool, app)
		2693		, d(new FtpInternal(this))
		2694		{
		2695		}
		2696
		2697		Ftp::~Ftp() = default;
		2698
		2699		void Ftp::setHost(const QString &host, quint16 port, const QString &user, const QString &pass)
		2700		{
		2701		d->setHost(host, port, user, pass);
		2702		}
		2703
		2704		void Ftp::openConnection()
		2705		{
		2706		finalize(d->openConnection());
			dfaureUnsubmitted Done This looks wrong. openConnection() should emit connected() or error(), but never finished(). dfaure: This looks wrong. openConnection() should emit connected() or error(), but never finished().
			sitterAuthorUnsubmitted Done You may wish to take a look at D23537 ;) sitter: You may wish to take a look at D23537 ;)
		2707		}
		2708
		2709		void Ftp::closeConnection()
		2710		{
		2711		d->closeConnection();
		2712		}
		2713
		2714		void Ftp::stat(const QUrl &url)
		2715		{
		2716		finalize(d->stat(url));
		2717		}
		2718
		2719		void Ftp::listDir(const QUrl &url)
		2720		{
		2721		d->listDir(url);
		2722		}
		2723
		2724		void Ftp::mkdir(const QUrl &url, int permissions)
			dfaureUnsubmitted Not Done yeah, looks like wishful thinking.... remove? dfaure: yeah, looks like wishful thinking.... remove?
		2725		{
		2726		finalize(d->mkdir(url, permissions));
		2727		}
		2728
		2729		void Ftp::rename(const QUrl &src, const QUrl &dst, JobFlags flags)
		2730		{
		2731		finalize(d->rename(src, dst, flags));
		2732		}
		2733
		2734		void Ftp::del(const QUrl &url, bool isfile)
		2735		{
		2736		finalize(d->del(url, isfile));
		2737		}
		2738
		2739		void Ftp::chmod(const QUrl &url, int permissions)
		2740		{
		2741		finalize(d->chmod(url, permissions));
		2742		}
		2743
		2744		void Ftp::get(const QUrl &url)
		2745		{
		2746		finalize(d->get(url));
		2747		}
		2748
		2749		void Ftp::put(const QUrl &url, int permissions, JobFlags flags)
		2750		{
		2751		finalize(d->put(url, permissions, flags));
		2752		}
		2753
		2754		void Ftp::slave_status()
		2755		{
		2756		d->slave_status();
		2757		}
		2758
		2759		void Ftp::copy(const QUrl &src, const QUrl &dest, int permissions, JobFlags flags)
		2760		{
		2761		finalize(d->copy(src, dest, permissions, flags));
		2762		}
		2763
		2764		void Ftp::finalize(const Result &result)
		2765		{
		2766		qDebug() << result;
			dfaureUnsubmitted Done remember to clean up the qDebug()s before the final version dfaure: remember to clean up the qDebug()s before the final version
		2767		if (!result.success) {
		2768		error(result.error, result.errorString);
		2769		return;
		2770		}
		2771		finished();
		2772		}
		2773
		2774		QDebug operator<<(QDebug dbg, const Result &r)
		2775
		2776		{
		2777		QDebugStateSaver saver(dbg);
		2778		dbg.nospace() << "Result("
		2779		<< "success=" << r.success
		2780		<< ", err=" << r.error
		2781		<< ", str=" << r.errorString
		2782		<< ", code=" << static_cast<int>(r.statusCode)
		2783		<< ')';
		2784		return dbg;
		2785		}
		2786
2690	// needed for JSON file embedding	2787		// needed for JSON file embedding
2691	#include "ftp.moc"	2788		#include "ftp.moc"