Differential D23579 Diff 66747 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		(void) ftpSendCmd(QByteArrayLiteral("site dirstyle"));
675	// Check if it was already in Unix style	670		// Check if it was already in Unix style
676	// Patch from Keith Refson <Keith.Refson@earth.ox.ac.uk>	671		// Patch from Keith Refson <Keith.Refson@earth.ox.ac.uk>
			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…
677	if (!qstrncmp(ftpResponse(0), "200 MSDOS-like directory output is on", 37))	672		if (!qstrncmp(ftpResponse(0), "200 MSDOS-like directory output is on", 37))
678	//It was in Unix style already!	673		//It was in Unix style already!
679	{	674		{
680	ftpSendCmd(QByteArrayLiteral("site dirstyle"));	675		(void) ftpSendCmd(QByteArrayLiteral("site dirstyle"));
681	}	676		}
682	// windows won't support chmod before KDE konquers their desktop...	677		// windows won't support chmod before KDE konquers their desktop...
683	m_extControl \|= chmodUnknown;	678		m_extControl \|= chmodUnknown;
684	}	679		}
685	} else {	680		} else {
686	qCWarning(KIO_FTP) << "SYST failed";	681		qCWarning(KIO_FTP) << "SYST failed";
687	}	682		}
688		683
689	if (config()->readEntry("EnableAutoLoginMacro", false)) {	684		if (config()->readEntry("EnableAutoLoginMacro", false)) {
690	ftpAutoLoginMacro();	685		ftpAutoLoginMacro();
691	}	686		}
692		687
693	// Get the current working directory	688		// Get the current working directory
694	qCDebug(KIO_FTP) << "Searching for pwd";	689		qCDebug(KIO_FTP) << "Searching for pwd";
695	if (!ftpSendCmd(QByteArrayLiteral("PWD")) \|\| (m_iRespType != 2)) {	690		result = ftpSendCmd(QByteArrayLiteral("PWD"));
		691		if (!result.success \|\| (m_iRespType != 2)) {
			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…
696	qCDebug(KIO_FTP) << "Couldn't issue pwd command";	692		qCDebug(KIO_FTP) << "Couldn't issue pwd command";
697	error(ERR_CANNOT_LOGIN, i18n("Could not login to %1.", m_host)); // or anything better ?	693		return Result::fail(ERR_CANNOT_LOGIN, i18n("Could not login to %1.", m_host)); // or anything better ?
698	return false;
699	}	694		}
700		695
701	QString sTmp = remoteEncoding()->decode(ftpResponse(3));	696		QString sTmp = remoteEncoding()->decode(ftpResponse(3));
702	const int iBeg = sTmp.indexOf(QLatin1Char('"'));	697		const int iBeg = sTmp.indexOf(QLatin1Char('"'));
703	const int iEnd = sTmp.lastIndexOf(QLatin1Char('"'));	698		const int iEnd = sTmp.lastIndexOf(QLatin1Char('"'));
704	if (iBeg > 0 && iBeg < iEnd) {	699		if (iBeg > 0 && iBeg < iEnd) {
705	m_initialPath = sTmp.mid(iBeg + 1, iEnd - iBeg - 1);	700		m_initialPath = sTmp.mid(iBeg + 1, iEnd - iBeg - 1);
706	if (m_initialPath[0] != QLatin1Char('/')) {	701		if (m_initialPath[0] != QLatin1Char('/')) {
707	m_initialPath.prepend(QLatin1Char('/'));	702		m_initialPath.prepend(QLatin1Char('/'));
708	}	703		}
709	qCDebug(KIO_FTP) << "Initial path set to: " << m_initialPath;	704		qCDebug(KIO_FTP) << "Initial path set to: " << m_initialPath;
710	m_currentPath = m_initialPath;	705		m_currentPath = m_initialPath;
711	}	706		}
712	return true;	707
		708		return Result::pass();
713	}	709		}
714		710
715	void Ftp::ftpAutoLoginMacro()	711		void FtpInternal::ftpAutoLoginMacro()
716	{	712		{
717	QString macro = metaData(QStringLiteral("autoLoginMacro"));	713		QString macro = metaData(QStringLiteral("autoLoginMacro"));
718		714
719	if (macro.isEmpty()) {	715		if (macro.isEmpty()) {
720	return;	716		return;
721	}	717		}
722		718
723	const QStringList list = macro.split(QLatin1Char('\n'), QString::SkipEmptyParts);	719		const QStringList list = macro.split(QLatin1Char('\n'), QString::SkipEmptyParts);
724		720
725	for (QStringList::const_iterator it = list.begin(); it != list.end(); ++it) {	721		for (QStringList::const_iterator it = list.begin(); it != list.end(); ++it) {
726	if ((*it).startsWith(QLatin1String("init"))) {	722		if ((*it).startsWith(QLatin1String("init"))) {
727	const QStringList list2 = macro.split(QLatin1Char('\\'), QString::SkipEmptyParts);	723		const QStringList list2 = macro.split(QLatin1Char('\\'), QString::SkipEmptyParts);
728	it = list2.begin();	724		it = list2.begin();
729	++it; // ignore the macro name	725		++it; // ignore the macro name
730		726
731	for (; it != list2.end(); ++it) {	727		for (; it != list2.end(); ++it) {
732	// TODO: Add support for arbitrary commands	728		// TODO: Add support for arbitrary commands
733	// besides simply changing directory!!	729		// besides simply changing directory!!
734	if ((*it).startsWith(QLatin1String("cwd"))) {	730		if ((*it).startsWith(QLatin1String("cwd"))) {
735	(void)ftpFolder((*it).mid(4), false);	731		(void) ftpFolder((*it).mid(4));
736	}	732		}
737	}	733		}
738		734
739	break;	735		break;
740	}	736		}
741	}	737		}
742	}	738		}
743		739
744	/**	740		/**
745	* ftpSendCmd - send a command (@p cmd) and read response	741		* ftpSendCmd - send a command (@p cmd) and read response
746	*	742		*
747	* @param maxretries number of time it should retry. Since it recursively	743		* @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	744		* calls itself if it can't read the answer (this happens especially after
749	* timeouts), we need to limit the recursiveness ;-)	745		* timeouts), we need to limit the recursiveness ;-)
750	*	746		*
751	* return true if any response received, false on error	747		* return true if any response received, false on error
752	*/	748		*/
753	bool Ftp::ftpSendCmd(const QByteArray &cmd, int maxretries)	749		Result FtpInternal::ftpSendCmd(const QByteArray &cmd, int maxretries)
754	{	750		{
755	Q_ASSERT(m_control); // must have control connection socket	751		Q_ASSERT(m_control); // must have control connection socket
756		752
757	if (cmd.indexOf('\r') != -1 \|\| cmd.indexOf('\n') != -1) {	753		if (cmd.indexOf('\r') != -1 \|\| cmd.indexOf('\n') != -1) {
758	qCWarning(KIO_FTP) << "Invalid command received (contains CR or LF):"	754		qCWarning(KIO_FTP) << "Invalid command received (contains CR or LF):"
759	<< cmd.data();	755		<< cmd.data();
760	error(ERR_UNSUPPORTED_ACTION, m_host);	756		return Result::fail(ERR_UNSUPPORTED_ACTION, m_host);
761	return false;
762	}	757		}
763		758
764	// Don't print out the password...	759		// Don't print out the password...
765	bool isPassCmd = (cmd.left(4).toLower() == "pass");	760		bool isPassCmd = (cmd.left(4).toLower() == "pass");
766	#if 0	761		#if 0
767	if (!isPassCmd) {	762		if (!isPassCmd) {
768	qDebug() << "send> " << cmd.data();	763		qDebug() << "send> " << cmd.data();
769	} else {	764		} else {
Show All 21 Lines		785	if ((m_iRespType <= 0) \|\| (m_iRespCode == 421)) {
791	// We have not yet logged on...	786		// We have not yet logged on...
792	if (!m_bLoggedOn) {	787		if (!m_bLoggedOn) {
793	// The command was sent from the ftpLogin function, i.e. we are actually	788		// 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	789		// 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	790		// return false and let the user decide whether (s)he wants to start from
796	// the beginning...	791		// the beginning...
797	if (maxretries > 0 && !isPassCmd) {	792		if (maxretries > 0 && !isPassCmd) {
798	closeConnection();	793		closeConnection();
799	if (ftpOpenConnection(loginDefered)) {	794		const auto result = ftpOpenConnection(LoginMode::Defered);
		795		#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?
		796		if (result.success) {
800	ftpSendCmd(cmd, maxretries - 1);	797		ftpSendCmd(cmd, maxretries - 1);
801	}	798		}
802	}	799		}
803		800
804	return false;	801		return Result::fail();
805	} else {	802		} else {
806	if (maxretries < 1) {	803		if (maxretries < 1) {
807	return false;	804		return Result::fail();
808	} else {	805		} else {
809	qCDebug(KIO_FTP) << "Was not able to communicate with " << m_host	806		qCDebug(KIO_FTP) << "Was not able to communicate with " << m_host
810	<< "Attempting to re-establish connection.";	807		<< "Attempting to re-establish connection.";
811		808
812	closeConnection(); // Close the old connection...	809		closeConnection(); // Close the old connection...
813	openConnection(); // Attempt to re-establish a new connection...	810		const Result openResult = openConnection(); // Attempt to re-establish a new connection...
814		811
815	if (!m_bLoggedOn) {	812		if (!openResult.success) {
816	if (m_control) { // if openConnection succeeded ...	813		if (m_control) { // if openConnection succeeded ...
817	qCDebug(KIO_FTP) << "Login failure, aborting";	814		qCDebug(KIO_FTP) << "Login failure, aborting";
818	error(ERR_CANNOT_LOGIN, m_host);
819	closeConnection();	815		closeConnection();
		816		return Result::fail(ERR_CANNOT_LOGIN, m_host);
820	}	817		}
821	return false;	818		return openResult;
			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	}	819		}
823		820
824	qCDebug(KIO_FTP) << "Logged back in, re-issuing command";	821		qCDebug(KIO_FTP) << "Logged back in, re-issuing command";
825		822
826	// If we were able to login, resend the command...	823		// If we were able to login, resend the command...
827	if (maxretries) {	824		if (maxretries) {
828	maxretries--;	825		maxretries--;
829	}	826		}
830		827
831	return ftpSendCmd(cmd, maxretries);	828		return ftpSendCmd(cmd, maxretries);
832	}	829		}
833	}	830		}
834	}	831		}
835		832
836	return true;	833		return Result::pass();
837	}	834		}
838		835
839	/*	836		/*
840	* ftpOpenPASVDataConnection - set up data connection, using PASV mode	837		* ftpOpenPASVDataConnection - set up data connection, using PASV mode
841	*	838		*
842	* return 0 if successful, ERR_INTERNAL otherwise	839		* return 0 if successful, ERR_INTERNAL otherwise
843	* doesn't set error message, since non-pasv mode will always be tried if	840		* doesn't set error message, since non-pasv mode will always be tried if
844	* this one fails	841		* this one fails
845	*/	842		*/
846	int Ftp::ftpOpenPASVDataConnection()	843		int FtpInternal::ftpOpenPASVDataConnection()
847	{	844		{
848	Q_ASSERT(m_control); // must have control connection socket	845		Q_ASSERT(m_control); // must have control connection socket
849	Q_ASSERT(!m_data); // ... but no data connection	846		Q_ASSERT(!m_data); // ... but no data connection
850		847
851	// Check that we can do PASV	848		// Check that we can do PASV
852	QHostAddress address = m_control->peerAddress();	849		QHostAddress address = m_control->peerAddress();
853	if (address.protocol() != QAbstractSocket::IPv4Protocol && !isSocksProxy()) {	850		if (address.protocol() != QAbstractSocket::IPv4Protocol && !isSocksProxy()) {
854	return ERR_INTERNAL; // no PASV for non-PF_INET connections	851		return ERR_INTERNAL; // no PASV for non-PF_INET connections
855	}	852		}
856		853
857	if (m_extControl & pasvUnknown) {	854		if (m_extControl & pasvUnknown) {
858	return ERR_INTERNAL; // already tried and got "unknown command"	855		return ERR_INTERNAL; // already tried and got "unknown command"
859	}	856		}
860		857
861	m_bPasv = true;	858		m_bPasv = true;
862		859
863	/* Let's PASsiVe*/	860		/* Let's PASsiVe*/
864	if (!ftpSendCmd(QByteArrayLiteral("PASV")) \|\| (m_iRespType != 2)) {	861		const auto result = ftpSendCmd(QByteArrayLiteral("PASV"));
		862		if (!result.success \|\| (m_iRespType != 2)) {
865	qCDebug(KIO_FTP) << "PASV attempt failed";	863		qCDebug(KIO_FTP) << "PASV attempt failed";
866	// unknown command?	864		// unknown command?
867	if (m_iRespType == 5) {	865		if (m_iRespType == 5) {
868	qCDebug(KIO_FTP) << "disabling use of PASV";	866		qCDebug(KIO_FTP) << "disabling use of PASV";
869	m_extControl \|= pasvUnknown;	867		m_extControl \|= pasvUnknown;
870	}	868		}
871	return ERR_INTERNAL;	869		return ERR_INTERNAL;
872	}	870		}
Show All 22 Lines
895	m_data = synchronousConnectToHost(host, port);	893		m_data = synchronousConnectToHost(host, port);
896		894
897	return m_data->state() == QAbstractSocket::ConnectedState ? 0 : ERR_INTERNAL;	895		return m_data->state() == QAbstractSocket::ConnectedState ? 0 : ERR_INTERNAL;
898	}	896		}
899		897
900	/*	898		/*
901	* ftpOpenEPSVDataConnection - opens a data connection via EPSV	899		* ftpOpenEPSVDataConnection - opens a data connection via EPSV
902	*/	900		*/
903	int Ftp::ftpOpenEPSVDataConnection()	901		int FtpInternal::ftpOpenEPSVDataConnection()
904	{	902		{
905	Q_ASSERT(m_control); // must have control connection socket	903		Q_ASSERT(m_control); // must have control connection socket
906	Q_ASSERT(!m_data); // ... but no data connection	904		Q_ASSERT(!m_data); // ... but no data connection
907		905
908	QHostAddress address = m_control->peerAddress();	906		QHostAddress address = m_control->peerAddress();
909	int portnum;	907		int portnum;
910		908
911	if (m_extControl & epsvUnknown) {	909		if (m_extControl & epsvUnknown) {
912	return ERR_INTERNAL;	910		return ERR_INTERNAL;
913	}	911		}
914		912
915	m_bPasv = true;	913		m_bPasv = true;
916	if (!ftpSendCmd(QByteArrayLiteral("EPSV")) \|\| (m_iRespType != 2)) {	914		const auto result = ftpSendCmd(QByteArrayLiteral("EPSV"));
		915		if (!result.success \|\| (m_iRespType != 2)) {
917	// unknown command?	916		// unknown command?
918	if (m_iRespType == 5) {	917		if (m_iRespType == 5) {
919	qCDebug(KIO_FTP) << "disabling use of EPSV";	918		qCDebug(KIO_FTP) << "disabling use of EPSV";
920	m_extControl \|= epsvUnknown;	919		m_extControl \|= epsvUnknown;
921	}	920		}
922	return ERR_INTERNAL;	921		return ERR_INTERNAL;
923	}	922		}
924		923
925	const char *start = strchr(ftpResponse(3), '\|');	924		const char *start = strchr(ftpResponse(3), '\|');
926	if (!start \|\| sscanf(start, "\|\|\|%d\|", &portnum) != 1) {	925		if (!start \|\| sscanf(start, "\|\|\|%d\|", &portnum) != 1) {
927	return ERR_INTERNAL;	926		return ERR_INTERNAL;
928	}	927		}
		928		Q_ASSERT(portnum > 0);
929		929
930	const QString host = (isSocksProxy() ? m_host : address.toString());	930		const QString host = (isSocksProxy() ? m_host : address.toString());
931	m_data = synchronousConnectToHost(host, portnum);	931		m_data = synchronousConnectToHost(host, static_cast<quint16>(portnum));
932	return m_data->isOpen() ? 0 : ERR_INTERNAL;	932		return m_data->isOpen() ? 0 : ERR_INTERNAL;
933	}	933		}
934		934
935	/*	935		/*
936	* ftpOpenDataConnection - set up data connection	936		* ftpOpenDataConnection - set up data connection
937	*	937		*
938	* The routine calls several ftpOpenXxxxConnection() helpers to find	938		* The routine calls several ftpOpenXxxxConnection() helpers to find
939	* the best connection mode. If a helper cannot connect if returns	939		* the best connection mode. If a helper cannot connect if returns
940	* ERR_INTERNAL - so this is not really an error! All other error	940		* 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	941		* codes are treated as fatal, e.g. they are passed back to the caller
942	* who is responsible for calling error(). ftpOpenPortDataConnection	942		* who is responsible for calling error(). ftpOpenPortDataConnection
943	* can be called as last try and it does never return ERR_INTERNAL.	943		* can be called as last try and it does never return ERR_INTERNAL.
944	*	944		*
945	* @return 0 if successful, err code otherwise	945		* @return 0 if successful, err code otherwise
946	*/	946		*/
947	int Ftp::ftpOpenDataConnection()	947		int FtpInternal::ftpOpenDataConnection()
948	{	948		{
949	// make sure that we are logged on and have no data connection...	949		// make sure that we are logged on and have no data connection...
950	Q_ASSERT(m_bLoggedOn);	950		Q_ASSERT(m_bLoggedOn);
951	ftpCloseDataConnection();	951		ftpCloseDataConnection();
952		952
953	int iErrCode = 0;	953		int iErrCode = 0;
954	int iErrCodePASV = 0; // Remember error code from PASV	954		int iErrCodePASV = 0; // Remember error code from PASV
955		955
Show All 33 Lines
989	}	989		}
990		990
991	/*	991		/*
992	* ftpOpenPortDataConnection - set up data connection	992		* ftpOpenPortDataConnection - set up data connection
993	*	993		*
994	* @return 0 if successful, err code otherwise (but never ERR_INTERNAL	994		* @return 0 if successful, err code otherwise (but never ERR_INTERNAL
995	* because this is the last connection mode that is tried)	995		* because this is the last connection mode that is tried)
996	*/	996		*/
997	int Ftp::ftpOpenPortDataConnection()	997		int FtpInternal::ftpOpenPortDataConnection()
998	{	998		{
999	Q_ASSERT(m_control); // must have control connection socket	999		Q_ASSERT(m_control); // must have control connection socket
1000	Q_ASSERT(!m_data); // ... but no data connection	1000		Q_ASSERT(!m_data); // ... but no data connection
1001		1001
1002	m_bPasv = false;	1002		m_bPasv = false;
1003	if (m_extControl & eprtUnknown) {	1003		if (m_extControl & eprtUnknown) {
1004	return ERR_INTERNAL;	1004		return ERR_INTERNAL;
1005	}	1005		}
Show All 22 Lines		1022	if (localAddress.protocol() == QAbstractSocket::IPv4Protocol) {
1028	data.port = m_server->serverPort();	1028		data.port = m_server->serverPort();
1029		1029
1030	unsigned char pData = reinterpret_cast<unsigned char >(&data);	1030		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]);	1031		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) {	1032		} else if (localAddress.protocol() == QAbstractSocket::IPv6Protocol) {
1033	command = QStringLiteral("EPRT \|2\|%2\|%3\|").arg(localAddress.toString()).arg(m_server->serverPort());	1033		command = QStringLiteral("EPRT \|2\|%2\|%3\|").arg(localAddress.toString()).arg(m_server->serverPort());
1034	}	1034		}
1035		1035
1036	if (ftpSendCmd(command.toLatin1()) && (m_iRespType == 2)) {	1036		const auto result = ftpSendCmd(command.toLatin1());
		1037		if (result.success && (m_iRespType == 2)) {
1037	return 0;	1038		return 0;
1038	}	1039		}
1039		1040
1040	delete m_server;	1041		delete m_server;
1041	m_server = nullptr;	1042		m_server = nullptr;
1042	return ERR_INTERNAL;	1043		return ERR_INTERNAL;
1043	}	1044		}
1044		1045
1045	bool Ftp::ftpOpenCommand(const char *_command, const QString &_path, char _mode,	1046		Result FtpInternal::ftpOpenCommand(const char *_command, const QString &_path, char _mode,
1046	int errorcode, KIO::fileoffset_t _offset)	1047		int errorcode, KIO::fileoffset_t _offset)
1047	{	1048		{
1048	int errCode = 0;	1049		int errCode = 0;
1049	if (!ftpDataMode(ftpModeFromPath(_path, _mode))) {	1050		if (!ftpDataMode(ftpModeFromPath(_path, _mode))) {
1050	errCode = ERR_CANNOT_CONNECT;	1051		errCode = ERR_CANNOT_CONNECT;
1051	} else {	1052		} else {
1052	errCode = ftpOpenDataConnection();	1053		errCode = ftpOpenDataConnection();
1053	}	1054		}
1054		1055
1055	if (errCode != 0) {	1056		if (errCode != 0) {
1056	error(errCode, m_host);	1057		return Result::fail(errCode, m_host);
1057	return false;
1058	}	1058		}
1059		1059
1060	if (_offset > 0) {	1060		if (_offset > 0) {
1061	// send rest command if offset > 0, this applies to retr and stor commands	1061		// send rest command if offset > 0, this applies to retr and stor commands
1062	char buf[100];	1062		char buf[100];
1063	sprintf(buf, "rest %lld", _offset);	1063		sprintf(buf, "rest %lld", _offset);
1064	if (!ftpSendCmd(buf)) {	1064		const auto result = ftpSendCmd(buf);
1065	return false;	1065		if (!result.success) {
		1066		return result;
1066	}	1067		}
1067	if (m_iRespType != 3) {	1068		if (m_iRespType != 3) {
1068	error(ERR_CANNOT_RESUME, _path); // should never happen	1069		return Result::fail(ERR_CANNOT_RESUME, _path); // should never happen
1069	return false;
1070	}	1070		}
1071	}	1071		}
1072		1072
1073	QByteArray tmp = _command;	1073		QByteArray tmp = _command;
1074	QString errormessage;	1074		QString errormessage;
1075		1075
1076	if (!_path.isEmpty()) {	1076		if (!_path.isEmpty()) {
1077	tmp += ' ' + remoteEncoding()->encode(ftpCleanPath(_path));	1077		tmp += ' ' + remoteEncoding()->encode(ftpCleanPath(_path));
1078	}	1078		}
1079		1079
1080	if (!ftpSendCmd(tmp) \|\| (m_iRespType != 1)) {	1080		const auto result = ftpSendCmd(tmp);
		1081		if (!result.success \|\| (m_iRespType != 1)) {
1081	if (_offset > 0 && qstrcmp(_command, "retr") == 0 && (m_iRespType == 4)) {	1082		if (_offset > 0 && qstrcmp(_command, "retr") == 0 && (m_iRespType == 4)) {
1082	errorcode = ERR_CANNOT_RESUME;	1083		errorcode = ERR_CANNOT_RESUME;
1083	}	1084		}
1084	// The error code here depends on the command	1085		// The error code here depends on the command
1085	errormessage = _path + i18n("\nThe server said: \"%1\"", QString::fromUtf8(ftpResponse(0)).trimmed());	1086		errormessage = _path + i18n("\nThe server said: \"%1\"", QString::fromUtf8(ftpResponse(0)).trimmed());
1086	}	1087		}
1087		1088
1088	else {	1089		else {
1089	// Only now we know for sure that we can resume	1090		// Only now we know for sure that we can resume
1090	if (_offset > 0 && qstrcmp(_command, "retr") == 0) {	1091		if (_offset > 0 && qstrcmp(_command, "retr") == 0) {
1091	canResume();	1092		canResume();
1092	}	1093		}
1093		1094
1094	if (m_server && !m_data) {	1095		if (m_server && !m_data) {
1095	qCDebug(KIO_FTP) << "waiting for connection from remote.";	1096		qCDebug(KIO_FTP) << "waiting for connection from remote.";
1096	m_server->waitForNewConnection(connectTimeout() * 1000);	1097		m_server->waitForNewConnection(connectTimeout() * 1000);
1097	m_data = m_server->nextPendingConnection();	1098		m_data = m_server->nextPendingConnection();
1098	}	1099		}
1099		1100
1100	if (m_data) {	1101		if (m_data) {
1101	qCDebug(KIO_FTP) << "connected with remote.";	1102		qCDebug(KIO_FTP) << "connected with remote.";
1102	m_bBusy = true; // cleared in ftpCloseCommand	1103		m_bBusy = true; // cleared in ftpCloseCommand
1103	return true;	1104		return Result::pass();
1104	}	1105		}
1105		1106
1106	qCDebug(KIO_FTP) << "no connection received from remote.";	1107		qCDebug(KIO_FTP) << "no connection received from remote.";
1107	errorcode = ERR_CANNOT_ACCEPT;	1108		errorcode = ERR_CANNOT_ACCEPT;
1108	errormessage = m_host;	1109		errormessage = m_host;
1109	return false;
1110	}	1110		}
			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…
1111		1111
1112	if (errorcode != KJob::NoError) {	1112		if (errorcode != KJob::NoError) {
1113	error(errorcode, errormessage);	1113		return Result::fail(errorcode, errormessage);
1114	}	1114		}
1115	return false;	1115		return Result::fail();
1116	}	1116		}
1117		1117
1118	bool Ftp::ftpCloseCommand()	1118		bool FtpInternal::ftpCloseCommand()
1119	{	1119		{
1120	// first close data sockets (if opened), then read response that	1120		// first close data sockets (if opened), then read response that
1121	// we got for whatever was used in ftpOpenCommand ( should be 226 )	1121		// we got for whatever was used in ftpOpenCommand ( should be 226 )
1122	ftpCloseDataConnection();	1122		ftpCloseDataConnection();
1123		1123
1124	if (!m_bBusy) {	1124		if (!m_bBusy) {
1125	return true;	1125		return true;
1126	}	1126		}
1127		1127
1128	qCDebug(KIO_FTP) << "ftpCloseCommand: reading command result";	1128		qCDebug(KIO_FTP) << "ftpCloseCommand: reading command result";
1129	m_bBusy = false;	1129		m_bBusy = false;
1130		1130
1131	if (!ftpResponse(-1) \|\| (m_iRespType != 2)) {	1131		if (!ftpResponse(-1) \|\| (m_iRespType != 2)) {
1132	qCDebug(KIO_FTP) << "ftpCloseCommand: no transfer complete message";	1132		qCDebug(KIO_FTP) << "ftpCloseCommand: no transfer complete message";
1133	return false;	1133		return false;
1134	}	1134		}
1135	return true;	1135		return true;
1136	}	1136		}
1137		1137
1138	void Ftp::mkdir(const QUrl &url, int permissions)	1138		Result FtpInternal::mkdir(const QUrl &url, int permissions)
1139	{	1139		{
1140	if (!ftpOpenConnection(loginImplicit)) {	1140		auto result = ftpOpenConnection(LoginMode::Implicit);
1141	return;	1141		if (!result.success) {
		1142		return result;
1142	}	1143		}
1143		1144
1144	const QByteArray encodedPath(remoteEncoding()->encode(url));	1145		const QByteArray encodedPath(remoteEncoding()->encode(url));
1145	const QString path = QString::fromLatin1(encodedPath.constData(), encodedPath.size());	1146		const QString path = QString::fromLatin1(encodedPath.constData(), encodedPath.size());
1146		1147
1147	if (!ftpSendCmd((QByteArrayLiteral("mkd ") + encodedPath)) \|\| (m_iRespType != 2)) {	1148		result = ftpSendCmd((QByteArrayLiteral("mkd ") + encodedPath));
		1149		if (!result.success \|\| (m_iRespType != 2)) {
1148	QString currentPath(m_currentPath);	1150		QString currentPath(m_currentPath);
1149		1151
1150	// Check whether or not mkdir failed because	1152		// Check whether or not mkdir failed because
1151	// the directory already exists...	1153		// the directory already exists...
1152	if (ftpFolder(path, false)) {	1154		if (ftpFolder(path)) {
1153	error(ERR_DIR_ALREADY_EXIST, path);	1155		const QString failedPath = path;
1154	// Change the directory back to what it was...	1156		// Change the directory back to what it was...
1155	(void) ftpFolder(currentPath, false);	1157		(void) ftpFolder(currentPath);
1156	return;	1158		return Result::fail(ERR_DIR_ALREADY_EXIST, failedPath);
1157	}	1159		}
1158		1160
1159	error(ERR_CANNOT_MKDIR, path);	1161		return Result::fail(ERR_CANNOT_MKDIR, path);
1160	return;
1161	}	1162		}
1162		1163
1163	if (permissions != -1) {	1164		if (permissions != -1) {
1164	// chmod the dir we just created, ignoring errors.	1165		// chmod the dir we just created, ignoring errors.
1165	(void) ftpChmod(path, permissions);	1166		(void) ftpChmod(path, permissions);
1166	}	1167		}
1167		1168
1168	finished();	1169		return Result::pass();
1169	}	1170		}
1170		1171
1171	void Ftp::rename(const QUrl &src, const QUrl &dst, KIO::JobFlags flags)	1172		Result FtpInternal::rename(const QUrl &src, const QUrl &dst, KIO::JobFlags flags)
1172	{	1173		{
1173	if (!ftpOpenConnection(loginImplicit)) {	1174		const auto result = ftpOpenConnection(LoginMode::Implicit);
1174	return;	1175		if (!result.success) {
		1176		return result;
1175	}	1177		}
1176		1178
1177	// The actual functionality is in ftpRename because put needs it	1179		// The actual functionality is in ftpRename because put needs it
1178	if (ftpRename(src.path(), dst.path(), flags)) {	1180		return ftpRename(src.path(), dst.path(), flags);
1179	finished();
1180	}
1181	}	1181		}
1182		1182
1183	bool Ftp::ftpRename(const QString &src, const QString &dst, KIO::JobFlags jobFlags)	1183		Result FtpInternal::ftpRename(const QString &src, const QString &dst, KIO::JobFlags jobFlags)
1184	{	1184		{
1185	Q_ASSERT(m_bLoggedOn);	1185		Q_ASSERT(m_bLoggedOn);
1186		1186
1187	// Must check if dst already exists, RNFR+RNTO overwrites by default (#127793).	1187		// Must check if dst already exists, RNFR+RNTO overwrites by default (#127793).
1188	if (!(jobFlags & KIO::Overwrite)) {	1188		if (!(jobFlags & KIO::Overwrite)) {
1189	if (ftpFileExists(dst)) {	1189		if (ftpFileExists(dst)) {
1190	error(ERR_FILE_ALREADY_EXIST, dst);	1190		return Result::fail(ERR_FILE_ALREADY_EXIST, dst);
1191	return false;
1192	}	1191		}
1193	}	1192		}
1194		1193
1195	if (ftpFolder(dst, false)) {	1194		if (ftpFolder(dst)) {
1196	error(ERR_DIR_ALREADY_EXIST, dst);	1195		return Result::fail(ERR_DIR_ALREADY_EXIST, dst);
1197	return false;
1198	}	1196		}
1199		1197
1200	// CD into parent folder	1198		// CD into parent folder
1201	const int pos = src.lastIndexOf(QLatin1Char('/'));	1199		const int pos = src.lastIndexOf(QLatin1Char('/'));
1202	if (pos >= 0) {	1200		if (pos >= 0) {
1203	if (!ftpFolder(src.left(pos + 1), false)) {	1201		if (!ftpFolder(src.left(pos + 1))) {
1204	return false;	1202		return Result::fail(ERR_CANNOT_ENTER_DIRECTORY, src);
			dfaureUnsubmitted Done `ERR_CANNOT_ENTER_DIRECTORY, src` dfaure: `ERR_CANNOT_ENTER_DIRECTORY, src`
1205	}	1203		}
1206	}	1204		}
1207		1205
1208	const QByteArray from_cmd = "RNFR " + remoteEncoding()->encode(src.mid(pos + 1));	1206		const QByteArray from_cmd = "RNFR " + remoteEncoding()->encode(src.mid(pos + 1));
1209	if (!ftpSendCmd(from_cmd) \|\| (m_iRespType != 3)) {	1207		auto result = ftpSendCmd(from_cmd);
1210	error(ERR_CANNOT_RENAME, src);	1208		if (!result.success \|\| (m_iRespType != 3)) {
1211	return false;	1209		return Result::fail(ERR_CANNOT_RENAME, src);
1212	}	1210		}
1213		1211
1214	const QByteArray to_cmd = "RNTO " + remoteEncoding()->encode(dst);	1212		const QByteArray to_cmd = "RNTO " + remoteEncoding()->encode(dst);
1215	if (!ftpSendCmd(to_cmd) \|\| (m_iRespType != 2)) {	1213		result = ftpSendCmd(to_cmd);
1216	error(ERR_CANNOT_RENAME, src);	1214		if (!result.success \|\| (m_iRespType != 2)) {
1217	return false;	1215		return Result::fail(ERR_CANNOT_RENAME, src);
1218	}	1216		}
1219		1217
1220	return true;	1218		return Result::pass();
1221	}	1219		}
1222		1220
1223	void Ftp::del(const QUrl &url, bool isfile)	1221		Result FtpInternal::del(const QUrl &url, bool isfile)
1224	{	1222		{
1225	if (!ftpOpenConnection(loginImplicit)) {	1223		auto result = ftpOpenConnection(LoginMode::Implicit);
1226	return;	1224		if (!result.success) {
		1225		return result;
1227	}	1226		}
1228		1227
1229	// When deleting a directory, we must exit from it first	1228		// When deleting a directory, we must exit from it first
1230	// The last command probably went into it (to stat it)	1229		// The last command probably went into it (to stat it)
1231	if (!isfile) {	1230		if (!isfile) {
1232	ftpFolder(remoteEncoding()->directory(url), false); // ignore errors	1231		(void) ftpFolder(remoteEncoding()->directory(url)); // ignore errors
1233	}	1232		}
1234		1233
1235	const QByteArray cmd = (isfile ? "DELE " : "RMD ") + remoteEncoding()->encode(url);	1234		const QByteArray cmd = (isfile ? "DELE " : "RMD ") + remoteEncoding()->encode(url);
1236		1235
1237	if (!ftpSendCmd(cmd) \|\| (m_iRespType != 2)) {	1236		result = ftpSendCmd(cmd);
1238	error(ERR_CANNOT_DELETE, url.path());	1237		if (!result.success \|\| (m_iRespType != 2)) {
1239	} else {	1238		return Result::fail(ERR_CANNOT_DELETE, url.path());
1240	finished();
1241	}	1239		}
		1240
		1241		return Result::pass();
1242	}	1242		}
1243		1243
1244	bool Ftp::ftpChmod(const QString &path, int permissions)	1244		bool FtpInternal::ftpChmod(const QString &path, int permissions)
1245	{	1245		{
1246	Q_ASSERT(m_bLoggedOn);	1246		Q_ASSERT(m_bLoggedOn);
1247		1247
1248	if (m_extControl & chmodUnknown) { // previous errors?	1248		if (m_extControl & chmodUnknown) { // previous errors?
1249	return false;	1249		return false;
1250	}	1250		}
1251		1251
1252	// we need to do bit AND 777 to get permissions, in case	1252		// we need to do bit AND 777 to get permissions, in case
1253	// we were sent a full mode (unlikely)	1253		// we were sent a full mode (unlikely)
1254	const QByteArray cmd = "SITE CHMOD " + QByteArray::number(permissions & 0777/octal/, 8 /octal/) + ' ' + remoteEncoding()->encode(path);	1254		const QByteArray cmd = "SITE CHMOD " + QByteArray::number(permissions & 0777/octal/, 8 /octal/) + ' ' + remoteEncoding()->encode(path);
1255		1255
1256	ftpSendCmd(cmd);	1256		auto result = ftpSendCmd(cmd);
		1257		if (result.success) {
		1258		qCDebug(KIO_FTP) << "ftpChmod: Failed to issue chmod" << result.errorString;
		1259		return false;
		1260		}
		1261
1257	if (m_iRespType == 2) {	1262		if (m_iRespType == 2) {
1258	return true;	1263		return true;
1259	}	1264		}
1260		1265
1261	if (m_iRespCode == 500) {	1266		if (m_iRespCode == 500) {
1262	m_extControl \|= chmodUnknown;	1267		m_extControl \|= chmodUnknown;
1263	qCDebug(KIO_FTP) << "ftpChmod: CHMOD not supported - disabling";	1268		qCDebug(KIO_FTP) << "ftpChmod: CHMOD not supported - disabling";
1264	}	1269		}
1265	return false;	1270		return false;
1266	}	1271		}
1267		1272
1268	void Ftp::chmod(const QUrl &url, int permissions)	1273		Result FtpInternal::chmod(const QUrl &url, int permissions)
1269	{	1274		{
1270	if (!ftpOpenConnection(loginImplicit)) {	1275		const auto result = ftpOpenConnection(LoginMode::Implicit);
1271	return;	1276		if (!result.success) {
		1277		return result;
1272	}	1278		}
1273		1279
1274	if (!ftpChmod(url.path(), permissions)) {	1280		if (!ftpChmod(url.path(), permissions)) {
1275	error(ERR_CANNOT_CHMOD, url.path());	1281		return Result::fail(ERR_CANNOT_CHMOD, url.path());
1276	} else {
1277	finished();
1278	}	1282		}
		1283
		1284		return Result::pass();
1279	}	1285		}
1280		1286
1281	void Ftp::ftpCreateUDSEntry(const QString &filename, const FtpEntry &ftpEnt, UDSEntry &entry, bool isDir)	1287		void FtpInternal::ftpCreateUDSEntry(const QString &filename, const FtpEntry &ftpEnt, UDSEntry &entry, bool isDir)
1282	{	1288		{
1283	Q_ASSERT(entry.count() == 0); // by contract :-)	1289		Q_ASSERT(entry.count() == 0); // by contract :-)
1284		1290
1285	entry.fastInsert(KIO::UDSEntry::UDS_NAME, filename);	1291		entry.fastInsert(KIO::UDSEntry::UDS_NAME, filename);
1286	entry.fastInsert(KIO::UDSEntry::UDS_SIZE, ftpEnt.size);	1292		entry.fastInsert(KIO::UDSEntry::UDS_SIZE, ftpEnt.size);
1287	entry.fastInsert(KIO::UDSEntry::UDS_MODIFICATION_TIME, ftpEnt.date.toSecsSinceEpoch());	1293		entry.fastInsert(KIO::UDSEntry::UDS_MODIFICATION_TIME, ftpEnt.date.toSecsSinceEpoch());
1288	entry.fastInsert(KIO::UDSEntry::UDS_ACCESS, ftpEnt.access);	1294		entry.fastInsert(KIO::UDSEntry::UDS_ACCESS, ftpEnt.access);
1289	entry.fastInsert(KIO::UDSEntry::UDS_USER, ftpEnt.owner);	1295		entry.fastInsert(KIO::UDSEntry::UDS_USER, ftpEnt.owner);
Show All 17 Lines		1300	if (!ftpEnt.link.isEmpty()) {
1307	}	1313		}
1308	}	1314		}
1309		1315
1310	entry.fastInsert(KIO::UDSEntry::UDS_FILE_TYPE, isDir ? S_IFDIR : ftpEnt.type);	1316		entry.fastInsert(KIO::UDSEntry::UDS_FILE_TYPE, isDir ? S_IFDIR : ftpEnt.type);
1311	// entry.insert KIO::UDSEntry::UDS_ACCESS_TIME,buff.st_atime);	1317		// entry.insert KIO::UDSEntry::UDS_ACCESS_TIME,buff.st_atime);
1312	// entry.insert KIO::UDSEntry::UDS_CREATION_TIME,buff.st_ctime);	1318		// entry.insert KIO::UDSEntry::UDS_CREATION_TIME,buff.st_ctime);
1313	}	1319		}
1314		1320
1315	void Ftp::ftpShortStatAnswer(const QString &filename, bool isDir)	1321		void FtpInternal::ftpShortStatAnswer(const QString &filename, bool isDir)
1316	{	1322		{
1317	UDSEntry entry;	1323		UDSEntry entry;
1318		1324
1319	entry.fastInsert(KIO::UDSEntry::UDS_NAME, filename);	1325		entry.fastInsert(KIO::UDSEntry::UDS_NAME, filename);
1320	entry.fastInsert(KIO::UDSEntry::UDS_FILE_TYPE, isDir ? S_IFDIR : S_IFREG);	1326		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);	1327		entry.fastInsert(KIO::UDSEntry::UDS_ACCESS, S_IRUSR \| S_IXUSR \| S_IRGRP \| S_IXGRP \| S_IROTH \| S_IXOTH);
1322	if (isDir) {	1328		if (isDir) {
1323	entry.fastInsert(KIO::UDSEntry::UDS_MIME_TYPE, QStringLiteral("inode/directory"));	1329		entry.fastInsert(KIO::UDSEntry::UDS_MIME_TYPE, QStringLiteral("inode/directory"));
1324	}	1330		}
1325	// No details about size, ownership, group, etc.	1331		// No details about size, ownership, group, etc.
1326		1332
1327	statEntry(entry);	1333		statEntry(entry);
1328	finished();
1329	}	1334		}
1330		1335
1331	void Ftp::ftpStatAnswerNotFound(const QString &path, const QString &filename)	1336		Result FtpInternal::ftpStatAnswerNotFound(const QString &path, const QString &filename)
1332	{	1337		{
1333	// Only do the 'hack' below if we want to download an existing file (i.e. when looking at the "source")	1338		// 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"	1339		// When e.g. uploading a file, we still need stat() to return "not found"
1335	// when the file doesn't exist.	1340		// when the file doesn't exist.
1336	QString statSide = metaData(QStringLiteral("statSide"));	1341		QString statSide = metaData(QStringLiteral("statSide"));
1337	qCDebug(KIO_FTP) << "statSide=" << statSide;	1342		qCDebug(KIO_FTP) << "statSide=" << statSide;
1338	if (statSide == QLatin1String("source")) {	1343		if (statSide == QLatin1String("source")) {
1339	qCDebug(KIO_FTP) << "Not found, but assuming found, because some servers don't allow listing";	1344		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	1345		// 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...	1346		// But "retr <blah>" works. So lie in stat(), to get going...
1342	//	1347		//
1343	// There's also the case of ftp://ftp2.3ddownloads.com/90380/linuxgames/loki/patches/ut/ut-patch-436.run	1348		// 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.	1349		// where listing permissions are denied, but downloading is still possible.
1345	ftpShortStatAnswer(filename, false /file, not dir/);	1350		ftpShortStatAnswer(filename, false /file, not dir/);
1346		1351
1347	return;	1352		return Result::pass();
1348	}	1353		}
1349		1354
1350	error(ERR_DOES_NOT_EXIST, path);	1355		return Result::fail(ERR_DOES_NOT_EXIST, path);
1351	}	1356		}
1352		1357
1353	void Ftp::stat(const QUrl &url)	1358		Result FtpInternal::stat(const QUrl &url)
1354	{	1359		{
1355	qCDebug(KIO_FTP) << "path=" << url.path();	1360		qCDebug(KIO_FTP) << "path=" << url.path();
1356	if (!ftpOpenConnection(loginImplicit)) {	1361		auto result = ftpOpenConnection(LoginMode::Implicit);
1357	return;	1362		if (!result.success) {
		1363		return result;
1358	}	1364		}
1359		1365
1360	const QString path = ftpCleanPath(QDir::cleanPath(url.path()));	1366		const QString path = ftpCleanPath(QDir::cleanPath(url.path()));
1361	qCDebug(KIO_FTP) << "cleaned path=" << path;	1367		qCDebug(KIO_FTP) << "cleaned path=" << path;
1362		1368
1363	// We can't stat root, but we know it's a dir.	1369		// We can't stat root, but we know it's a dir.
1364	if (path.isEmpty() \|\| path == QLatin1String("/")) {	1370		if (path.isEmpty() \|\| path == QLatin1String("/")) {
1365	UDSEntry entry;	1371		UDSEntry entry;
1366	//entry.insert( KIO::UDSEntry::UDS_NAME, UDSField( QString() ) );	1372		//entry.insert( KIO::UDSEntry::UDS_NAME, UDSField( QString() ) );
1367	entry.fastInsert(KIO::UDSEntry::UDS_NAME, QStringLiteral("."));	1373		entry.fastInsert(KIO::UDSEntry::UDS_NAME, QStringLiteral("."));
1368	entry.fastInsert(KIO::UDSEntry::UDS_FILE_TYPE, S_IFDIR);	1374		entry.fastInsert(KIO::UDSEntry::UDS_FILE_TYPE, S_IFDIR);
1369	entry.fastInsert(KIO::UDSEntry::UDS_MIME_TYPE, QStringLiteral("inode/directory"));	1375		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);	1376		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"));	1377		entry.fastInsert(KIO::UDSEntry::UDS_USER, QStringLiteral("root"));
1372	entry.fastInsert(KIO::UDSEntry::UDS_GROUP, QStringLiteral("root"));	1378		entry.fastInsert(KIO::UDSEntry::UDS_GROUP, QStringLiteral("root"));
1373	// no size	1379		// no size
1374		1380
1375	statEntry(entry);	1381		statEntry(entry);
1376	finished();	1382		return Result::pass();
1377	return;
1378	}	1383		}
1379		1384
1380	QUrl tempurl(url);	1385		QUrl tempurl(url);
1381	tempurl.setPath(path); // take the clean one	1386		tempurl.setPath(path); // take the clean one
1382	QString listarg; // = tempurl.directory(QUrl::ObeyTrailingSlash);	1387		QString listarg; // = tempurl.directory(QUrl::ObeyTrailingSlash);
1383	QString parentDir;	1388		QString parentDir;
1384	QString filename = tempurl.fileName();	1389		QString filename = tempurl.fileName();
1385	Q_ASSERT(!filename.isEmpty());	1390		Q_ASSERT(!filename.isEmpty());
1386	QString search = filename;	1391		QString search = filename;
1387		1392
1388	// Try cwd into it, if it works it's a dir (and then we'll list the parent directory to get more info)	1393		// 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)	1394		// if it doesn't work, it's a file (and then we'll use dir filename)
1390	bool isDir = ftpFolder(path, false);	1395		bool isDir = ftpFolder(path);
1391		1396
1392	// if we're only interested in "file or directory", we should stop here	1397		// if we're only interested in "file or directory", we should stop here
1393	QString sDetails = metaData(QStringLiteral("details"));	1398		QString sDetails = metaData(QStringLiteral("details"));
1394	int details = sDetails.isEmpty() ? 2 : sDetails.toInt();	1399		int details = sDetails.isEmpty() ? 2 : sDetails.toInt();
1395	qCDebug(KIO_FTP) << "details=" << details;	1400		qCDebug(KIO_FTP) << "details=" << details;
1396	if (details == 0) {	1401		if (details == 0) {
1397	if (!isDir && !ftpFileExists(path)) { // ok, not a dir -> is it a file ?	1402		if (!isDir && !ftpFileExists(path)) { // ok, not a dir -> is it a file ?
1398	// no -> it doesn't exist at all	1403		// no -> it doesn't exist at all
1399	ftpStatAnswerNotFound(path, filename);	1404		return ftpStatAnswerNotFound(path, filename);
1400	return;
1401	}	1405		}
1402	ftpShortStatAnswer(filename, isDir); // successfully found a dir or a file -> done	1406		ftpShortStatAnswer(filename, isDir);
1403	return;	1407		return Result::pass(); // successfully found a dir or a file -> done
1404	}	1408		}
1405		1409
1406	if (!isDir) {	1410		if (!isDir) {
1407	// It is a file or it doesn't exist, try going to parent directory	1411		// It is a file or it doesn't exist, try going to parent directory
1408	parentDir = tempurl.adjusted(QUrl::RemoveFilename).path();	1412		parentDir = tempurl.adjusted(QUrl::RemoveFilename).path();
1409	// With files we can do "LIST <filename>" to avoid listing the whole dir	1413		// With files we can do "LIST <filename>" to avoid listing the whole dir
1410	listarg = filename;	1414		listarg = filename;
1411	} else {	1415		} else {
1412	// --- New implementation:	1416		// --- New implementation:
1413	// Don't list the parent dir. Too slow, might not show it, etc.	1417		// Don't list the parent dir. Too slow, might not show it, etc.
1414	// Just return that it's a dir.	1418		// Just return that it's a dir.
1415	UDSEntry entry;	1419		UDSEntry entry;
1416	entry.fastInsert(KIO::UDSEntry::UDS_NAME, filename);	1420		entry.fastInsert(KIO::UDSEntry::UDS_NAME, filename);
1417	entry.fastInsert(KIO::UDSEntry::UDS_FILE_TYPE, S_IFDIR);	1421		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);	1422		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.	1423		// No clue about size, ownership, group, etc.
1420		1424
1421	statEntry(entry);	1425		statEntry(entry);
1422	finished();	1426		return Result::pass();
1423	return;
1424	}	1427		}
1425		1428
1426	// Now cwd the parent dir, to prepare for listing	1429		// Now cwd the parent dir, to prepare for listing
1427	if (!ftpFolder(parentDir, true)) {	1430		if (!ftpFolder(parentDir)) {
1428	return;	1431		return Result::fail(ERR_CANNOT_ENTER_DIRECTORY, parentDir);
1429	}	1432		}
1430		1433
1431	if (!ftpOpenCommand("list", listarg, 'I', ERR_DOES_NOT_EXIST)) {	1434		result = ftpOpenCommand("list", listarg, 'I', ERR_DOES_NOT_EXIST);
		1435		if (!result.success) {
1432	qCritical() << "COULD NOT LIST";	1436		qCritical() << "COULD NOT LIST";
1433	return;	1437		return result;
1434	}	1438		}
1435	qCDebug(KIO_FTP) << "Starting of list was ok";	1439		qCDebug(KIO_FTP) << "Starting of list was ok";
1436		1440
1437	Q_ASSERT(!search.isEmpty() && search != QLatin1String("/"));	1441		Q_ASSERT(!search.isEmpty() && search != QLatin1String("/"));
1438		1442
1439	bool bFound = false;	1443		bool bFound = false;
1440	QUrl linkURL;	1444		QUrl linkURL;
1441	FtpEntry ftpEnt;	1445		FtpEntry ftpEnt;
Show All 18 Lines		1461	for (int i = 0, count = ftpValidateEntList.count(); i < count; ++i) {
1460	if (maybeEmitStatEntry(ftpEnt, search, filename, isDir)) {	1464		if (maybeEmitStatEntry(ftpEnt, search, filename, isDir)) {
1461	break;	1465		break;
1462	}	1466		}
1463	}	1467		}
1464		1468
1465	ftpCloseCommand(); // closes the data connection only	1469		ftpCloseCommand(); // closes the data connection only
1466		1470
1467	if (!bFound) {	1471		if (!bFound) {
1468	ftpStatAnswerNotFound(path, filename);	1472		return ftpStatAnswerNotFound(path, filename);
1469	return;
1470	}	1473		}
1471		1474
1472	if (!linkURL.isEmpty()) {	1475		if (!linkURL.isEmpty()) {
1473	if (linkURL == url \|\| linkURL == tempurl) {	1476		if (linkURL == url \|\| linkURL == tempurl) {
1474	error(ERR_CYCLIC_LINK, linkURL.toString());	1477		return Result::fail(ERR_CYCLIC_LINK, linkURL.toString());
1475	return;
1476	}	1478		}
1477	Ftp::stat(linkURL);	1479		return FtpInternal::stat(linkURL);
			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;
1479	}	1480		}
1480		1481
1481	qCDebug(KIO_FTP) << "stat : finished successfully";	1482		qCDebug(KIO_FTP) << "stat : finished successfully";;
1482	finished();	1483		return Result::pass();
1483	}	1484		}
1484		1485
1485	bool Ftp::maybeEmitStatEntry(FtpEntry &ftpEnt, const QString &search, const QString &filename, bool isDir)	1486		bool FtpInternal::maybeEmitStatEntry(FtpEntry &ftpEnt, const QString &search, const QString &filename, bool isDir)
1486	{	1487		{
1487	if ((search == ftpEnt.name \|\| filename == ftpEnt.name) && !filename.isEmpty()) {	1488		if ((search == ftpEnt.name \|\| filename == ftpEnt.name) && !filename.isEmpty()) {
1488	UDSEntry entry;	1489		UDSEntry entry;
1489	ftpCreateUDSEntry(filename, ftpEnt, entry, isDir);	1490		ftpCreateUDSEntry(filename, ftpEnt, entry, isDir);
1490	statEntry(entry);	1491		statEntry(entry);
1491	return true;	1492		return true;
1492	}	1493		}
1493		1494
1494	return false;	1495		return false;
1495	}	1496		}
1496		1497
1497	void Ftp::listDir(const QUrl &url)	1498		Result FtpInternal::listDir(const QUrl &url)
1498	{	1499		{
1499	qCDebug(KIO_FTP) << url;	1500		qCDebug(KIO_FTP) << url;
1500	if (!ftpOpenConnection(loginImplicit)) {	1501		auto result = ftpOpenConnection(LoginMode::Implicit);
1501	return;	1502		if (!result.success) {
		1503		return result;
1502	}	1504		}
1503		1505
1504	// No path specified ?	1506		// No path specified ?
1505	QString path = url.path();	1507		QString path = url.path();
1506	if (path.isEmpty()) {	1508		if (path.isEmpty()) {
1507	QUrl realURL;	1509		QUrl realURL;
1508	realURL.setScheme(QStringLiteral("ftp"));	1510		realURL.setScheme(QStringLiteral("ftp"));
1509	realURL.setUserName(m_user);	1511		realURL.setUserName(m_user);
1510	realURL.setPassword(m_pass);	1512		realURL.setPassword(m_pass);
1511	realURL.setHost(m_host);	1513		realURL.setHost(m_host);
1512	if (m_port > 0 && m_port != DEFAULT_FTP_PORT) {	1514		if (m_port > 0 && m_port != DEFAULT_FTP_PORT) {
1513	realURL.setPort(m_port);	1515		realURL.setPort(m_port);
1514	}	1516		}
1515	if (m_initialPath.isEmpty()) {	1517		if (m_initialPath.isEmpty()) {
1516	m_initialPath = QStringLiteral("/");	1518		m_initialPath = QStringLiteral("/");
1517	}	1519		}
1518	realURL.setPath(m_initialPath);	1520		realURL.setPath(m_initialPath);
1519	qCDebug(KIO_FTP) << "REDIRECTION to " << realURL;	1521		qCDebug(KIO_FTP) << "REDIRECTION to " << realURL;
1520	redirection(realURL);	1522		redirection(realURL);
1521	finished();	1523		return Result::pass();
1522	return;
1523	}	1524		}
1524		1525
1525	qCDebug(KIO_FTP) << "hunting for path" << path;	1526		qCDebug(KIO_FTP) << "hunting for path" << path;
1526		1527
1527	if (!ftpOpenDir(path)) {	1528		result = ftpOpenDir(path);
		1529		if (!result.success) {
1528	if (ftpFileExists(path)) {	1530		if (ftpFileExists(path)) {
1529	error(ERR_IS_FILE, path);	1531		return Result::fail(ERR_IS_FILE, path);
1530	} else {	1532		}
1531	// not sure which to emit	1533		// not sure which to emit
1532	//error( ERR_DOES_NOT_EXIST, path );	1534		//error( ERR_DOES_NOT_EXIST, path );
1533	error(ERR_CANNOT_ENTER_DIRECTORY, path);	1535		return Result::fail(ERR_CANNOT_ENTER_DIRECTORY, path);
1534	}
1535	return;
1536	}	1536		}
1537		1537
1538	UDSEntry entry;	1538		UDSEntry entry;
1539	FtpEntry ftpEnt;	1539		FtpEntry ftpEnt;
1540	QList<FtpEntry> ftpValidateEntList;	1540		QList<FtpEntry> ftpValidateEntList;
1541	while (ftpReadDir(ftpEnt)) {	1541		while (ftpReadDir(ftpEnt)) {
1542	qCDebug(KIO_FTP) << ftpEnt.name;	1542		qCDebug(KIO_FTP) << ftpEnt.name;
1543	//Q_ASSERT( !ftpEnt.name.isEmpty() );	1543		//Q_ASSERT( !ftpEnt.name.isEmpty() );
Show All 17 Lines		1560	for (int i = 0, count = ftpValidateEntList.count(); i < count; ++i) {
1561	FtpEntry &ftpEnt = ftpValidateEntList[i];	1561		FtpEntry &ftpEnt = ftpValidateEntList[i];
1562	fixupEntryName(&ftpEnt);	1562		fixupEntryName(&ftpEnt);
1563	ftpCreateUDSEntry(ftpEnt.name, ftpEnt, entry, false);	1563		ftpCreateUDSEntry(ftpEnt.name, ftpEnt, entry, false);
1564	listEntry(entry);	1564		listEntry(entry);
1565	entry.clear();	1565		entry.clear();
1566	}	1566		}
1567		1567
1568	ftpCloseCommand(); // closes the data connection only	1568		ftpCloseCommand(); // closes the data connection only
1569	finished();	1569		return Result::pass();
1570	}	1570		}
1571		1571
1572	void Ftp::slave_status()	1572		void FtpInternal::slave_status()
1573	{	1573		{
1574	qCDebug(KIO_FTP) << "Got slave_status host = " << (!m_host.toLatin1().isEmpty() ? m_host.toLatin1() : "[None]") << " [" << (m_bLoggedOn ? "Connected" : "Not connected") << "]";	1574		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);	1575		slaveStatus(m_host, m_bLoggedOn);
1576	}	1576		}
1577		1577
1578	bool Ftp::ftpOpenDir(const QString &path)	1578		Result FtpInternal::ftpOpenDir(const QString &path)
1579	{	1579		{
1580	//QString path( _url.path(QUrl::RemoveTrailingSlash) );	1580		//QString path( _url.path(QUrl::RemoveTrailingSlash) );
1581		1581
1582	// We try to change to this directory first to see whether it really is a directory.	1582		// We try to change to this directory first to see whether it really is a directory.
1583	// (And also to follow symlinks)	1583		// (And also to follow symlinks)
1584	QString tmp = path.isEmpty() ? QStringLiteral("/") : path;	1584		QString tmp = path.isEmpty() ? QStringLiteral("/") : path;
1585		1585
1586	// We get '550', whether it's a file or doesn't exist...	1586		// We get '550', whether it's a file or doesn't exist...
1587	if (!ftpFolder(tmp, false)) {	1587		if (!ftpFolder(tmp)) {
1588	return false;	1588		return Result::fail();
1589	}	1589		}
1590		1590
1591	// Don't use the path in the list command:	1591		// Don't use the path in the list command:
1592	// We changed into this directory anyway - so it's enough just to send "list".	1592		// 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.	1593		// 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...	1594		// 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.	1595		// 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)	1596		// 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	1597		// Pass KJob::NoError first because we don't want to emit error before we
1598	// have tried all commands.	1598		// have tried all commands.
1599	if (!ftpOpenCommand("list -la", QString(), 'I', KJob::NoError)) {	1599		auto result = ftpOpenCommand("list -la", QString(), 'I', KJob::NoError);
1600	if (!ftpOpenCommand("list", QString(), 'I', KJob::NoError)) {	1600		if (!result.success) {
		1601		result = ftpOpenCommand("list", QString(), 'I', KJob::NoError);
		1602		}
		1603		if (!result.success) {
1601	// Servers running with Turkish locale having problems converting 'i' letter to upper case.	1604		// Servers running with Turkish locale having problems converting 'i' letter to upper case.
1602	// So we send correct upper case command as last resort.	1605		// 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)) {	1606		result = ftpOpenCommand("LIST -la", QString(), 'I', ERR_CANNOT_ENTER_DIRECTORY);
1604	qCWarning(KIO_FTP) << "Can't open for listing";
1605	return false;
1606	}
1607	}	1607		}
		1608
		1609		if (!result.success) {
		1610		qCWarning(KIO_FTP) << "Can't open for listing";
		1611		return result;
1608	}	1612		}
		1613
1609	qCDebug(KIO_FTP) << "Starting of list was ok";	1614		qCDebug(KIO_FTP) << "Starting of list was ok";
1610	return true;	1615		return Result::pass();
1611	}	1616		}
1612		1617
1613	bool Ftp::ftpReadDir(FtpEntry &de)	1618		bool FtpInternal::ftpReadDir(FtpEntry &de)
1614	{	1619		{
1615	Q_ASSERT(m_data);	1620		Q_ASSERT(m_data);
1616		1621
1617	// get a line from the data connection ...	1622		// get a line from the data connection ...
1618	while (true) {	1623		while (true) {
1619	while (!m_data->canReadLine() && m_data->waitForReadyRead((readTimeout() * 1000))) {}	1624		while (!m_data->canReadLine() && m_data->waitForReadyRead((readTimeout() * 1000))) {}
1620	QByteArray data = m_data->readLine();	1625		QByteArray data = m_data->readLine();
1621	if (data.size() == 0) {	1626		if (data.size() == 0) {
▲ Show 20 Lines • Show All 223 Lines • ▼ Show 20 Line(s)
1845	} // line invalid, loop to get another line	1850		} // line invalid, loop to get another line
1846	return false;	1851		return false;
1847	}	1852		}
1848		1853
1849	//===============================================================================	1854		//===============================================================================
1850	// public: get download file from server	1855		// public: get download file from server
1851	// helper: ftpGet called from get() and copy()	1856		// helper: ftpGet called from get() and copy()
1852	//===============================================================================	1857		//===============================================================================
1853	void Ftp::get(const QUrl &url)	1858		Result FtpInternal::get(const QUrl &url)
1854	{	1859		{
1855	qCDebug(KIO_FTP) << url;	1860		qCDebug(KIO_FTP) << url;
1856		1861		const Result result = ftpGet(-1, QString(), url, 0);
1857	int iError = 0;
1858	const StatusCode cs = ftpGet(iError, -1, url, 0);
1859	ftpCloseCommand(); // must close command!	1862		ftpCloseCommand(); // must close command!
1860		1863		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	}	1864		}
1870		1865
1871	Ftp::StatusCode Ftp::ftpGet(int &iError, int iCopyFile, const QUrl &url, KIO::fileoffset_t llOffset)	1866		Result FtpInternal::ftpGet(int iCopyFile, const QString &sCopyFile, const QUrl &url, KIO::fileoffset_t llOffset)
1872	{	1867		{
1873	// Calls error() by itself!	1868		auto result = ftpOpenConnection(LoginMode::Implicit);
1874	if (!ftpOpenConnection(loginImplicit)) {	1869		if (!result.success) {
1875	return statusServerError;	1870		return result;
			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…
1876	}	1871		}
1877		1872
1878	// Try to find the size of the file (and check that it exists at	1873		// 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"	1874		// 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	1875		// 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	1876		// directory, return an error; otherwise simply try to retrieve
1882	// the request...	1877		// the request...
1883	if (!ftpSize(url.path(), '?') && (m_iRespCode == 550) &&	1878		if (!ftpSize(url.path(), '?') && (m_iRespCode == 550) &&
1884	ftpFolder(url.path(), false)) {	1879		ftpFolder(url.path())) {
1885	// Ok it's a dir in fact	1880		// Ok it's a dir in fact
1886	qCDebug(KIO_FTP) << "it is a directory in fact";	1881		qCDebug(KIO_FTP) << "it is a directory in fact";
1887	iError = ERR_IS_DIRECTORY;	1882		return Result::fail(ERR_IS_DIRECTORY);
1888	return statusServerError;
1889	}	1883		}
1890		1884
1891	QString resumeOffset = metaData(QStringLiteral("range-start"));	1885		QString resumeOffset = metaData(QStringLiteral("range-start"));
1892	if (resumeOffset.isEmpty()) {	1886		if (resumeOffset.isEmpty()) {
1893	resumeOffset = metaData(QStringLiteral("resume")); // old name	1887		resumeOffset = metaData(QStringLiteral("resume")); // old name
1894	}	1888		}
1895	if (!resumeOffset.isEmpty()) {	1889		if (!resumeOffset.isEmpty()) {
1896	llOffset = resumeOffset.toLongLong();	1890		llOffset = resumeOffset.toLongLong();
1897	qCDebug(KIO_FTP) << "got offset from metadata : " << llOffset;	1891		qCDebug(KIO_FTP) << "got offset from metadata : " << llOffset;
1898	}	1892		}
1899		1893
1900	if (!ftpOpenCommand("retr", url.path(), '?', ERR_CANNOT_OPEN_FOR_READING, llOffset)) {	1894		result = ftpOpenCommand("retr", url.path(), '?', ERR_CANNOT_OPEN_FOR_READING, llOffset);
		1895		if (!result.success) {
1901	qCWarning(KIO_FTP) << "Can't open for reading";	1896		qCWarning(KIO_FTP) << "Can't open for reading";
1902	return statusServerError;	1897		return result;
			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?
1903	}	1898		}
1904		1899
1905	// Read the size from the response string	1900		// Read the size from the response string
1906	if (m_size == UnknownSize) {	1901		if (m_size == UnknownSize) {
1907	const char *psz = strrchr(ftpResponse(4), '(');	1902		const char *psz = strrchr(ftpResponse(4), '(');
1908	if (psz) {	1903		if (psz) {
1909	m_size = charToLongLong(psz + 1);	1904		m_size = charToLongLong(psz + 1);
1910	}	1905		}
1911	if (!m_size) {	1906		if (!m_size) {
1912	m_size = UnknownSize;	1907		m_size = UnknownSize;
1913	}	1908		}
1914	}	1909		}
1915		1910
1916	// Send the mime-type...	1911		// Send the mime-type...
1917	if (iCopyFile == -1) {	1912		if (iCopyFile == -1) {
1918	StatusCode status = ftpSendMimeType(iError, url);	1913		const auto result = ftpSendMimeType(url);
1919	if (status != statusSuccess) {	1914		if (!result.success) {
1920	return status;	1915		return result;
1921	}	1916		}
1922	}	1917		}
1923		1918
1924	KIO::filesize_t bytesLeft = 0;	1919		KIO::filesize_t bytesLeft = 0;
1925	if (m_size != UnknownSize) {	1920		if (m_size != UnknownSize) {
1926	bytesLeft = m_size - llOffset;	1921		bytesLeft = m_size - llOffset;
1927	totalSize(m_size); // emit the total size...	1922		totalSize(m_size); // emit the total size...
1928	}	1923		}
Show All 24 Lines		1936	while (m_size == UnknownSize \|\| bytesLeft > 0) {
1953	}	1948		}
1954	int n = m_data->read(buffer + iBufferCur, iBlockSize);	1949		int n = m_data->read(buffer + iBufferCur, iBlockSize);
1955	if (n <= 0) {	1950		if (n <= 0) {
1956	// this is how we detect EOF in case of unknown size	1951		// this is how we detect EOF in case of unknown size
1957	if (m_size == UnknownSize && n == 0) {	1952		if (m_size == UnknownSize && n == 0) {
1958	break;	1953		break;
1959	}	1954		}
1960	// unexpected eof. Happens when the daemon gets killed.	1955		// unexpected eof. Happens when the daemon gets killed.
1961	iError = ERR_CANNOT_READ;	1956		return Result::fail(ERR_CANNOT_READ);
1962	return statusServerError;
1963	}	1957		}
1964	processed_size += n;	1958		processed_size += n;
1965		1959
1966	// collect very small data chunks in buffer before processing ...	1960		// collect very small data chunks in buffer before processing ...
1967	if (m_size != UnknownSize) {	1961		if (m_size != UnknownSize) {
1968	bytesLeft -= n;	1962		bytesLeft -= n;
1969	iBufferCur += n;	1963		iBufferCur += n;
1970	if (iBufferCur < minimumMimeSize && bytesLeft > 0) {	1964		if (iBufferCur < minimumMimeSize && bytesLeft > 0) {
1971	processedSize(processed_size);	1965		processedSize(processed_size);
1972	continue;	1966		continue;
1973	}	1967		}
1974	n = iBufferCur;	1968		n = iBufferCur;
1975	iBufferCur = 0;	1969		iBufferCur = 0;
1976	}	1970		}
1977		1971
1978	// write output file or pass to data pump ...	1972		// write output file or pass to data pump ...
		1973		int writeError = 0;
1979	if (iCopyFile == -1) {	1974		if (iCopyFile == -1) {
1980	array = QByteArray::fromRawData(buffer, n);	1975		array = QByteArray::fromRawData(buffer, n);
1981	data(array);	1976		data(array);
1982	array.clear();	1977		array.clear();
1983	} else if ((iError = WriteToFile(iCopyFile, buffer, n)) != 0) {	1978		} else if ((writeError = WriteToFile(iCopyFile, buffer, n)) != 0) {
1984	return statusClientError; // client side error	1979		return Result::fail(writeError, sCopyFile);
			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…
1985	}	1980		}
1986	processedSize(processed_size);	1981
		1982		Q_ASSERT(processed_size >= 0);
		1983		processedSize(static_cast<KIO::filesize_t>(processed_size));
1987	}	1984		}
1988		1985
1989	qCDebug(KIO_FTP) << "done";	1986		qCDebug(KIO_FTP) << "done";
1990	if (iCopyFile == -1) { // must signal EOF to data pump ...	1987		if (iCopyFile == -1) { // must signal EOF to data pump ...
1991	data(array); // array is empty and must be empty!	1988		data(array); // array is empty and must be empty!
1992	}	1989		}
1993		1990
1994	processedSize(m_size == UnknownSize ? processed_size : m_size);	1991		processedSize(m_size == UnknownSize ? processed_size : m_size);
1995	return statusSuccess;	1992		return Result::pass();
1996	}	1993		}
1997		1994
1998	#if 0	1995		#if 0
1999	void Ftp::mimetype(const QUrl &url)	1996		void FtpInternal::mimetype(const QUrl &url)
2000	{	1997		{
2001	if (!ftpOpenConnection(loginImplicit)) {	1998		if (!ftpOpenConnection(loginImplicit)) {
2002	return;	1999		return;
2003	}	2000		}
2004		2001
2005	if (!ftpOpenCommand("retr", url.path(), 'I', ERR_CANNOT_OPEN_FOR_READING, 0)) {	2002		if (!ftpOpenCommand("retr", url.path(), 'I', ERR_CANNOT_OPEN_FOR_READING, 0)) {
2006	qCWarning(KIO_FTP) << "Can't open for reading";	2003		qCWarning(KIO_FTP) << "Can't open for reading";
2007	return;	2004		return;
2008	}	2005		}
2009	char buffer[ 2048 ];	2006		char buffer[ 2048 ];
2010	QByteArray array;	2007		QByteArray array;
2011	// Get one chunk of data only and send it, KIO::Job will determine the	2008		// Get one chunk of data only and send it, KIO::Job will determine the
2012	// mimetype from it using KMimeMagic	2009		// mimetype from it using KMimeMagic
2013	int n = m_data->read(buffer, 2048);	2010		int n = m_data->read(buffer, 2048);
2014	array.setRawData(buffer, n);	2011		array.setRawData(buffer, n);
2015	data(array);	2012		data(array);
2016	array.resetRawData(buffer, n);	2013		array.resetRawData(buffer, n);
2017		2014
2018	qCDebug(KIO_FTP) << "aborting";	2015		qCDebug(KIO_FTP) << "aborting";
2019	ftpAbortTransfer();	2016		ftpAbortTransfer();
2020		2017
2021	qCDebug(KIO_FTP) << "finished";	2018		qCDebug(KIO_FTP) << "finished";
2022	finished();	2019		finished(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";	2020		qCDebug(KIO_FTP) << "after finished";
2024	}	2021		}
2025		2022
2026	void Ftp::ftpAbortTransfer()	2023		void FtpInternal::ftpAbortTransfer()
2027	{	2024		{
2028	// RFC 959, page 34-35	2025		// RFC 959, page 34-35
2029	// IAC (interpret as command) = 255 ; IP (interrupt process) = 254	2026		// IAC (interpret as command) = 255 ; IP (interrupt process) = 254
2030	// DM = 242 (data mark)	2027		// DM = 242 (data mark)
2031	char msg[4];	2028		char msg[4];
2032	// 1. User system inserts the Telnet "Interrupt Process" (IP) signal	2029		// 1. User system inserts the Telnet "Interrupt Process" (IP) signal
2033	// in the Telnet stream.	2030		// in the Telnet stream.
2034	msg[0] = (char) 255; //IAC	2031		msg[0] = (char) 255; //IAC
Show All 24 Lines
2059	closeSockets();	2056		closeSockets();
2060	}	2057		}
2061	#endif	2058		#endif
2062		2059
2063	//===============================================================================	2060		//===============================================================================
2064	// public: put upload file to server	2061		// public: put upload file to server
2065	// helper: ftpPut called from put() and copy()	2062		// helper: ftpPut called from put() and copy()
2066	//===============================================================================	2063		//===============================================================================
2067	void Ftp::put(const QUrl &url, int permissions, KIO::JobFlags flags)	2064		Result FtpInternal::put(const QUrl &url, int permissions, KIO::JobFlags flags)
2068	{	2065		{
2069	qCDebug(KIO_FTP) << url;	2066		qCDebug(KIO_FTP) << url;
2070		2067		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!	2068		ftpCloseCommand(); // must close command!
2074		2069		return result;
2075	if (cs == statusSuccess) {
2076	finished();
2077	return;
2078	}	2070		}
2079		2071
2080	if (iError) { // can have only server side errs	2072		Result FtpInternal::ftpPut(int iCopyFile, const QUrl &dest_url,
2081	error(iError, url.path());
2082	}
2083	}
2084
2085	Ftp::StatusCode Ftp::ftpPut(int &iError, int iCopyFile, const QUrl &dest_url,
2086	int permissions, KIO::JobFlags flags)	2073		int permissions, KIO::JobFlags flags)
			dfaureUnsubmitted Done outdated warning? dfaure: outdated warning?
2087	{	2074		{
2088	if (!ftpOpenConnection(loginImplicit)) {	2075		const auto openResult = ftpOpenConnection(LoginMode::Implicit);
2089	return statusServerError;	2076		if (!openResult.success) {
		2077		return openResult;
2090	}	2078		}
2091		2079
2092	// Don't use mark partial over anonymous FTP.	2080		// Don't use mark partial over anonymous FTP.
2093	// My incoming dir allows put but not rename...	2081		// My incoming dir allows put but not rename...
2094	bool bMarkPartial;	2082		bool bMarkPartial;
2095	if (m_user.isEmpty() \|\| m_user == QLatin1String(FTP_LOGIN)) {	2083		if (m_user.isEmpty() \|\| m_user == QLatin1String(FTP_LOGIN)) {
2096	bMarkPartial = false;	2084		bMarkPartial = false;
2097	} else {	2085		} else {
2098	bMarkPartial = config()->readEntry("MarkPartial", true);	2086		bMarkPartial = config()->readEntry("MarkPartial", true);
2099	}	2087		}
2100		2088
2101	QString dest_orig = dest_url.path();	2089		QString dest_orig = dest_url.path();
2102	const QString dest_part = dest_orig + QLatin1String(".part");	2090		const QString dest_part = dest_orig + QLatin1String(".part");
2103		2091
2104	if (ftpSize(dest_orig, 'I')) {	2092		if (ftpSize(dest_orig, 'I')) {
2105	if (m_size == 0) {	2093		if (m_size == 0) {
2106	// delete files with zero size	2094		// delete files with zero size
2107	const QByteArray cmd = "DELE " + remoteEncoding()->encode(dest_orig);	2095		const QByteArray cmd = "DELE " + remoteEncoding()->encode(dest_orig);
2108	if (!ftpSendCmd(cmd) \|\| (m_iRespType != 2)) {	2096		auto result = ftpSendCmd(cmd);
2109	iError = ERR_CANNOT_DELETE_PARTIAL;	2097		if (!result.success \|\| (m_iRespType != 2)) {
2110	return statusServerError;	2098		return Result::fail(ERR_CANNOT_DELETE_PARTIAL, QString());
2111	}	2099		}
2112	} else if (!(flags & KIO::Overwrite) && !(flags & KIO::Resume)) {	2100		} else if (!(flags & KIO::Overwrite) && !(flags & KIO::Resume)) {
2113	iError = ERR_FILE_ALREADY_EXIST;	2101		return Result::fail(ERR_FILE_ALREADY_EXIST, QString());
2114	return statusServerError;
2115	} else if (bMarkPartial) {	2102		} else if (bMarkPartial) {
2116	// when using mark partial, append .part extension	2103		// when using mark partial, append .part extension
2117	if (!ftpRename(dest_orig, dest_part, KIO::Overwrite)) {	2104		const auto result = ftpRename(dest_orig, dest_part, KIO::Overwrite);
2118	iError = ERR_CANNOT_RENAME_PARTIAL;	2105		if (!result.success) {
2119	return statusServerError;	2106		return Result::fail(ERR_CANNOT_RENAME_PARTIAL, QString());
2120	}	2107		}
2121	}	2108		}
2122	// Don't chmod an existing file	2109		// Don't chmod an existing file
2123	permissions = -1;	2110		permissions = -1;
2124	} else if (bMarkPartial && ftpSize(dest_part, 'I')) {	2111		} else if (bMarkPartial && ftpSize(dest_part, 'I')) {
2125	// file with extension .part exists	2112		// file with extension .part exists
2126	if (m_size == 0) {	2113		if (m_size == 0) {
2127	// delete files with zero size	2114		// delete files with zero size
2128	const QByteArray cmd = "DELE " + remoteEncoding()->encode(dest_part);	2115		const QByteArray cmd = "DELE " + remoteEncoding()->encode(dest_part);
2129	if (!ftpSendCmd(cmd) \|\| (m_iRespType != 2)) {	2116		auto result = ftpSendCmd(cmd);
2130	iError = ERR_CANNOT_DELETE_PARTIAL;	2117		if (!result.success \|\| (m_iRespType != 2)) {
2131	return statusServerError;	2118		return Result::fail(ERR_CANNOT_DELETE_PARTIAL, QString());
2132	}	2119		}
2133	} else if (!(flags & KIO::Overwrite) && !(flags & KIO::Resume)) {	2120		} else if (!(flags & KIO::Overwrite) && !(flags & KIO::Resume)) {
2134	flags \|= canResume(m_size) ? KIO::Resume : KIO::DefaultFlags;	2121		flags \|= canResume(m_size) ? KIO::Resume : KIO::DefaultFlags;
2135	if (!(flags & KIO::Resume)) {	2122		if (!(flags & KIO::Resume)) {
2136	iError = ERR_FILE_ALREADY_EXIST;	2123		return Result::fail(ERR_FILE_ALREADY_EXIST, QString());
2137	return statusServerError;
2138	}	2124		}
2139	}	2125		}
2140	} else {	2126		} else {
2141	m_size = 0;	2127		m_size = 0;
2142	}	2128		}
2143		2129
2144	QString dest;	2130		QString dest;
2145		2131
2146	// if we are using marking of partial downloads -> add .part extension	2132		// if we are using marking of partial downloads -> add .part extension
2147	if (bMarkPartial) {	2133		if (bMarkPartial) {
2148	qCDebug(KIO_FTP) << "Adding .part extension to " << dest_orig;	2134		qCDebug(KIO_FTP) << "Adding .part extension to " << dest_orig;
2149	dest = dest_part;	2135		dest = dest_part;
2150	} else {	2136		} else {
2151	dest = dest_orig;	2137		dest = dest_orig;
2152	}	2138		}
2153		2139
2154	KIO::fileoffset_t offset = 0;	2140		KIO::fileoffset_t offset = 0;
2155		2141
2156	// set the mode according to offset	2142		// set the mode according to offset
2157	if ((flags & KIO::Resume) && m_size > 0) {	2143		if ((flags & KIO::Resume) && m_size > 0) {
2158	offset = m_size;	2144		offset = m_size;
2159	if (iCopyFile != -1) {	2145		if (iCopyFile != -1) {
2160	if (QT_LSEEK(iCopyFile, offset, SEEK_SET) < 0) {	2146		if (QT_LSEEK(iCopyFile, offset, SEEK_SET) < 0) {
2161	iError = ERR_CANNOT_RESUME;	2147		return Result::fail(ERR_CANNOT_RESUME, QString());
2162	return statusClientError;
2163	}	2148		}
2164	}	2149		}
2165	}	2150		}
2166		2151
2167	if (! ftpOpenCommand("stor", dest, '?', ERR_CANNOT_WRITE, offset)) {	2152		const auto storResult = ftpOpenCommand("stor", dest, '?', ERR_CANNOT_WRITE, offset);
2168	return statusServerError;	2153		qDebug() << "!!! storresult" << storResult;
			dfaureUnsubmitted Done remember to remove this dfaure: remember to remove this
		2154		if (!storResult.success) {
		2155		return storResult;
			dfaureUnsubmitted Done because of the useless enum? ;) dfaure: because of the useless enum? ;)
2169	}	2156		}
2170		2157
2171	qCDebug(KIO_FTP) << "ftpPut: starting with offset=" << offset;	2158		qCDebug(KIO_FTP) << "ftpPut: starting with offset=" << offset;
2172	KIO::fileoffset_t processed_size = offset;	2159		KIO::fileoffset_t processed_size = offset;
2173		2160
2174	QByteArray buffer;	2161		QByteArray buffer;
2175	int result;	2162		int result;
2176	int iBlockSize = initialIpcSize;	2163		int iBlockSize = initialIpcSize;
		2164		int writeError = 0;
2177	// Loop until we got 'dataEnd'	2165		// Loop until we got 'dataEnd'
2178	do {	2166		do {
2179	if (iCopyFile == -1) {	2167		if (iCopyFile == -1) {
2180	dataReq(); // Request for data	2168		dataReq(); // Request for data
2181	result = readData(buffer);	2169		result = readData(buffer);
2182	} else {	2170		} else {
2183	// let the buffer size grow if the file is larger 64kByte ...	2171		// let the buffer size grow if the file is larger 64kByte ...
2184	if (processed_size - offset > 1024 * 64) {	2172		if (processed_size - offset > 1024 * 64) {
2185	iBlockSize = maximumIpcSize;	2173		iBlockSize = maximumIpcSize;
2186	}	2174		}
2187	buffer.resize(iBlockSize);	2175		buffer.resize(iBlockSize);
2188	result = QT_READ(iCopyFile, buffer.data(), buffer.size());	2176		result = QT_READ(iCopyFile, buffer.data(), buffer.size());
2189	if (result < 0) {	2177		if (result < 0) {
2190	iError = ERR_CANNOT_WRITE;	2178		writeError = ERR_CANNOT_READ;
			dfaureUnsubmitted Done yeah, feel free to change it. dfaure: yeah, feel free to change it.
2191	} else {	2179		} else {
2192	buffer.resize(result);	2180		buffer.resize(result);
2193	}	2181		}
2194	}	2182		}
2195		2183
2196	if (result > 0) {	2184		if (result > 0) {
2197	m_data->write(buffer);	2185		m_data->write(buffer);
2198	while (m_data->bytesToWrite() && m_data->waitForBytesWritten()) {}	2186		while (m_data->bytesToWrite() && m_data->waitForBytesWritten()) {}
2199	processed_size += result;	2187		processed_size += result;
2200	processedSize(processed_size);	2188		processedSize(processed_size);
2201	}	2189		}
2202	} while (result > 0);	2190		} while (result > 0);
2203		2191
2204	if (result != 0) { // error	2192		if (result != 0) { // error
2205	ftpCloseCommand(); // don't care about errors	2193		ftpCloseCommand(); // don't care about errors
2206	qCDebug(KIO_FTP) << "Error during 'put'. Aborting.";	2194		qCDebug(KIO_FTP) << "Error during 'put'. Aborting.";
2207	if (bMarkPartial) {	2195		if (bMarkPartial) {
2208	// Remove if smaller than minimum size	2196		// Remove if smaller than minimum size
2209	if (ftpSize(dest, 'I') &&	2197		if (ftpSize(dest, 'I') &&
2210	(processed_size < config()->readEntry("MinimumKeepSize", DEFAULT_MINIMUM_KEEP_SIZE))) {	2198		(processed_size < config()->readEntry("MinimumKeepSize", DEFAULT_MINIMUM_KEEP_SIZE))) {
2211	const QByteArray cmd = "DELE " + remoteEncoding()->encode(dest);	2199		const QByteArray cmd = "DELE " + remoteEncoding()->encode(dest);
2212	(void) ftpSendCmd(cmd);	2200		(void) ftpSendCmd(cmd);
2213	}	2201		}
2214	}	2202		}
2215	return statusServerError;	2203		return Result::fail(writeError, dest_url.toString());
2216	}	2204		}
2217		2205
2218	if (!ftpCloseCommand()) {	2206		if (!ftpCloseCommand()) {
2219	iError = ERR_CANNOT_WRITE;	2207		return Result::fail(ERR_CANNOT_WRITE);
2220	return statusServerError;
2221	}	2208		}
2222		2209
2223	// after full download rename the file back to original name	2210		// after full download rename the file back to original name
2224	if (bMarkPartial) {	2211		if (bMarkPartial) {
2225	qCDebug(KIO_FTP) << "renaming dest (" << dest << ") back to dest_orig (" << dest_orig << ")";	2212		qCDebug(KIO_FTP) << "renaming dest (" << dest << ") back to dest_orig (" << dest_orig << ")";
2226	if (!ftpRename(dest, dest_orig, KIO::Overwrite)) {	2213		const auto result = ftpRename(dest, dest_orig, KIO::Overwrite);
2227	iError = ERR_CANNOT_RENAME_PARTIAL;	2214		if (!result.success) {
2228	return statusServerError;	2215		return Result::fail(ERR_CANNOT_RENAME_PARTIAL);
2229	}	2216		}
2230	}	2217		}
2231		2218
2232	// set final permissions	2219		// set final permissions
2233	if (permissions != -1) {	2220		if (permissions != -1) {
2234	if (m_user == QLatin1String(FTP_LOGIN))	2221		if (m_user == QLatin1String(FTP_LOGIN))
2235	qCDebug(KIO_FTP) << "Trying to chmod over anonymous FTP ???";	2222		qCDebug(KIO_FTP) << "Trying to chmod over anonymous FTP ???";
2236	// chmod the file we just put	2223		// chmod the file we just put
2237	if (! ftpChmod(dest_orig, permissions)) {	2224		if (! ftpChmod(dest_orig, permissions)) {
2238	// To be tested	2225		// To be tested
2239	//if ( m_user != FTP_LOGIN )	2226		//if ( m_user != FTP_LOGIN )
2240	// warning( i18n( "Could not change permissions for\n%1" ).arg( dest_orig ) );	2227		// warning( i18n( "Could not change permissions for\n%1" ).arg( dest_orig ) );
2241	}	2228		}
2242	}	2229		}
2243		2230
2244	return statusSuccess;	2231		return Result::pass();
2245	}	2232		}
2246		2233
2247	/** Use the SIZE command to get the file size.	2234		/** Use the SIZE command to get the file size.
2248	Warning : the size depends on the transfer mode, hence the second arg. */	2235		Warning : the size depends on the transfer mode, hence the second arg. */
2249	bool Ftp::ftpSize(const QString &path, char mode)	2236		bool FtpInternal::ftpSize(const QString &path, char mode)
2250	{	2237		{
2251	m_size = UnknownSize;	2238		m_size = UnknownSize;
2252	if (!ftpDataMode(mode)) {	2239		if (!ftpDataMode(mode)) {
2253	return false;	2240		return false;
2254	}	2241		}
2255		2242
2256	const QByteArray buf = "SIZE " + remoteEncoding()->encode(path);	2243		const QByteArray buf = "SIZE " + remoteEncoding()->encode(path);
2257	if (!ftpSendCmd(buf) \|\| (m_iRespType != 2)) {	2244		auto result = ftpSendCmd(buf);
		2245		if (!result.success \|\| (m_iRespType != 2)) {
2258	return false;	2246		return false;
2259	}	2247		}
2260		2248
2261	// skip leading "213 " (response code)	2249		// skip leading "213 " (response code)
2262	QByteArray psz(ftpResponse(4));	2250		QByteArray psz(ftpResponse(4));
2263	if (psz.isEmpty()) {	2251		if (psz.isEmpty()) {
2264	return false;	2252		return false;
2265	}	2253		}
2266	bool ok = false;	2254		bool ok = false;
2267	m_size = psz.trimmed().toLongLong(&ok);	2255		m_size = psz.trimmed().toLongLong(&ok);
2268	if (!ok) {	2256		if (!ok) {
2269	m_size = UnknownSize;	2257		m_size = UnknownSize;
2270	}	2258		}
2271	return true;	2259		return true;
2272	}	2260		}
2273		2261
2274	bool Ftp::ftpFileExists(const QString &path)	2262		bool FtpInternal::ftpFileExists(const QString &path)
2275	{	2263		{
2276	const QByteArray buf = "SIZE " + remoteEncoding()->encode(path);	2264		const QByteArray buf = "SIZE " + remoteEncoding()->encode(path);
2277	if (!ftpSendCmd(buf) \|\| (m_iRespType != 2)) {	2265		const auto result = ftpSendCmd(buf);
		2266		if (!result.success \|\| (m_iRespType != 2)) {
2278	return false;	2267		return false;
2279	}	2268		}
2280		2269
2281	// skip leading "213 " (response code)	2270		// skip leading "213 " (response code)
2282	const char *psz = ftpResponse(4);	2271		const char *psz = ftpResponse(4);
2283	return psz != nullptr;	2272		return psz != nullptr;
2284	}	2273		}
2285		2274
2286	// Today the differences between ASCII and BINARY are limited to	2275		// Today the differences between ASCII and BINARY are limited to
2287	// CR or CR/LF line terminators. Many servers ignore ASCII (like	2276		// CR or CR/LF line terminators. Many servers ignore ASCII (like
2288	// win2003 -or- vsftp with default config). In the early days of	2277		// win2003 -or- vsftp with default config). In the early days of
2289	// computing, when even text-files had structure, this stuff was	2278		// computing, when even text-files had structure, this stuff was
2290	// more important.	2279		// more important.
2291	// Theoretically "list" could return different results in ASCII	2280		// Theoretically "list" could return different results in ASCII
2292	// and BINARY mode. But again, most servers ignore ASCII here.	2281		// and BINARY mode. But again, most servers ignore ASCII here.
2293	bool Ftp::ftpDataMode(char cMode)	2282		bool FtpInternal::ftpDataMode(char cMode)
2294	{	2283		{
2295	if (cMode == '?') {	2284		if (cMode == '?') {
2296	cMode = m_bTextMode ? 'A' : 'I';	2285		cMode = m_bTextMode ? 'A' : 'I';
2297	} else if (cMode == 'a') {	2286		} else if (cMode == 'a') {
2298	cMode = 'A';	2287		cMode = 'A';
2299	} else if (cMode != 'A') {	2288		} else if (cMode != 'A') {
2300	cMode = 'I';	2289		cMode = 'I';
2301	}	2290		}
2302		2291
2303	qCDebug(KIO_FTP) << "want" << cMode << "has" << m_cDataMode;	2292		qCDebug(KIO_FTP) << "want" << cMode << "has" << m_cDataMode;
2304	if (m_cDataMode == cMode) {	2293		if (m_cDataMode == cMode) {
2305	return true;	2294		return true;
2306	}	2295		}
2307		2296
2308	const QByteArray buf = QByteArrayLiteral("TYPE ") + cMode;	2297		const QByteArray buf = QByteArrayLiteral("TYPE ") + cMode;
2309	if (!ftpSendCmd(buf) \|\| (m_iRespType != 2)) {	2298		const auto result = ftpSendCmd(buf);
		2299		if (!result.success \|\| (m_iRespType != 2)) {
2310	return false;	2300		return false;
2311	}	2301		}
2312	m_cDataMode = cMode;	2302		m_cDataMode = cMode;
2313	return true;	2303		return true;
2314	}	2304		}
2315		2305
2316	bool Ftp::ftpFolder(const QString &path, bool bReportError)	2306		bool FtpInternal::ftpFolder(const QString &path)
2317	{	2307		{
2318	QString newPath = path;	2308		QString newPath = path;
2319	int iLen = newPath.length();	2309		int iLen = newPath.length();
2320	if (iLen > 1 && newPath[iLen - 1] == QLatin1Char('/')) {	2310		if (iLen > 1 && newPath[iLen - 1] == QLatin1Char('/')) {
2321	newPath.chop(1);	2311		newPath.chop(1);
2322	}	2312		}
2323		2313
2324	qCDebug(KIO_FTP) << "want" << newPath << "has" << m_currentPath;	2314		qCDebug(KIO_FTP) << "want" << newPath << "has" << m_currentPath;
2325	if (m_currentPath == newPath) {	2315		if (m_currentPath == newPath) {
2326	return true;	2316		return true;
2327	}	2317		}
2328		2318
2329	const QByteArray tmp = "cwd " + remoteEncoding()->encode(newPath);	2319		const QByteArray tmp = "cwd " + remoteEncoding()->encode(newPath);
2330	if (!ftpSendCmd(tmp)) {	2320		const auto result = ftpSendCmd(tmp);
		2321		if (!result.success) {
2331	return false; // connection failure	2322		return false; // connection failure
2332	}	2323		}
2333	if (m_iRespType != 2) {	2324		if (m_iRespType != 2) {
2334	if (bReportError) {
2335	error(ERR_CANNOT_ENTER_DIRECTORY, path);
2336	}
2337	return false; // not a folder	2325		return false; // not a folder
			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…
2338	}	2326		}
2339	m_currentPath = newPath;	2327		m_currentPath = newPath;
2340	return true;	2328		return true;
2341	}	2329		}
2342		2330
2343	//===============================================================================	2331		//===============================================================================
2344	// public: copy don't use kio data pump if one side is a local file	2332		// public: copy don't use kio data pump if one side is a local file
2345	// helper: ftpCopyPut called from copy() on upload	2333		// helper: ftpCopyPut called from copy() on upload
2346	// helper: ftpCopyGet called from copy() on download	2334		// helper: ftpCopyGet called from copy() on download
2347	//===============================================================================	2335		//===============================================================================
2348	void Ftp::copy(const QUrl &src, const QUrl &dest, int permissions, KIO::JobFlags flags)	2336		Result FtpInternal::copy(const QUrl &src, const QUrl &dest, int permissions, KIO::JobFlags flags)
2349	{	2337		{
2350	int iError = 0;
2351	int iCopyFile = -1;	2338		int iCopyFile = -1;
2352	StatusCode cs = statusSuccess;
2353	bool bSrcLocal = src.isLocalFile();	2339		bool bSrcLocal = src.isLocalFile();
2354	bool bDestLocal = dest.isLocalFile();	2340		bool bDestLocal = dest.isLocalFile();
2355	QString sCopyFile;	2341		QString sCopyFile;
2356		2342
		2343		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	2344		if (bSrcLocal && !bDestLocal) { // File -> Ftp
2358	sCopyFile = src.toLocalFile();	2345		sCopyFile = src.toLocalFile();
2359	qCDebug(KIO_FTP) << "local file" << sCopyFile << "-> ftp" << dest.path();	2346		qCDebug(KIO_FTP) << "local file" << sCopyFile << "-> ftp" << dest.path();
2360	cs = ftpCopyPut(iError, iCopyFile, sCopyFile, dest, permissions, flags);	2347		result = ftpCopyPut(iCopyFile, sCopyFile, dest, permissions, flags);
2361	} else if (!bSrcLocal && bDestLocal) { // Ftp -> File	2348		} else if (!bSrcLocal && bDestLocal) { // Ftp -> File
2362	sCopyFile = dest.toLocalFile();	2349		sCopyFile = dest.toLocalFile();
2363	qCDebug(KIO_FTP) << "ftp" << src.path() << "-> local file" << sCopyFile;	2350		qCDebug(KIO_FTP) << "ftp" << src.path() << "-> local file" << sCopyFile;
2364	cs = ftpCopyGet(iError, iCopyFile, sCopyFile, src, permissions, flags);	2351		result = ftpCopyGet(iCopyFile, sCopyFile, src, permissions, flags);
2365	} else {	2352		} else {
2366	error(ERR_UNSUPPORTED_ACTION, QString());	2353		return Result::fail(ERR_UNSUPPORTED_ACTION, QString());
2367	return;
2368	}	2354		}
2369		2355
2370	// perform clean-ups and report error (if any)	2356		// perform clean-ups and report error (if any)
2371	if (iCopyFile != -1) {	2357		if (iCopyFile != -1) {
2372	QT_CLOSE(iCopyFile);	2358		QT_CLOSE(iCopyFile);
2373	}	2359		}
2374	ftpCloseCommand(); // must close command!	2360		ftpCloseCommand(); // must close command!
2375	if (cs == statusServerError && iError) {	2361
2376	error(iError, sCopyFile);	2362		return result;
2377	} else {
2378	finished();
2379	}
2380	}	2363		}
2381		2364
2382	Ftp::StatusCode Ftp::ftpCopyPut(int &iError, int &iCopyFile, const QString &sCopyFile,	2365		Result FtpInternal::ftpCopyPut(int &iCopyFile, const QString &sCopyFile,
2383	const QUrl &url, int permissions, KIO::JobFlags flags)	2366		const QUrl &url, int permissions, KIO::JobFlags flags)
2384	{	2367		{
2385	// check if source is ok ...	2368		// check if source is ok ...
2386	QFileInfo info(sCopyFile);	2369		QFileInfo info(sCopyFile);
2387	bool bSrcExists = info.exists();	2370		bool bSrcExists = info.exists();
2388	if (bSrcExists) {	2371		if (bSrcExists) {
2389	if (info.isDir()) {	2372		if (info.isDir()) {
2390	iError = ERR_IS_DIRECTORY;	2373		return Result::fail(ERR_IS_DIRECTORY);
2391	return statusClientError;
2392	}	2374		}
2393	} else {	2375		} else {
2394	iError = ERR_DOES_NOT_EXIST;	2376		return Result::fail(ERR_DOES_NOT_EXIST);
2395	return statusClientError;
2396	}	2377		}
2397		2378
2398	iCopyFile = QT_OPEN(QFile::encodeName(sCopyFile).constData(), O_RDONLY);	2379		iCopyFile = QT_OPEN(QFile::encodeName(sCopyFile).constData(), O_RDONLY);
2399	if (iCopyFile == -1) {	2380		if (iCopyFile == -1) {
2400	iError = ERR_CANNOT_OPEN_FOR_READING;	2381		return Result::fail(ERR_CANNOT_OPEN_FOR_READING);
2401	return statusClientError;
2402	}	2382		}
2403		2383
2404	// delegate the real work (iError gets status) ...	2384		// delegate the real work (iError gets status) ...
2405	totalSize(info.size());	2385		totalSize(info.size());
2406	#ifdef ENABLE_CAN_RESUME	2386		#ifdef ENABLE_CAN_RESUME
2407	return ftpPut(iError, iCopyFile, url, permissions, flags & ~KIO::Resume);	2387		return ftpPut(iCopyFile, url, permissions, flags & ~KIO::Resume);
2408	#else	2388		#else
2409	return ftpPut(iError, iCopyFile, url, permissions, flags \| KIO::Resume);	2389		return ftpPut(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	2390		#endif
2411	}	2391		}
2412		2392
2413	Ftp::StatusCode Ftp::ftpCopyGet(int &iError, int &iCopyFile, const QString &sCopyFile,	2393		Result FtpInternal::ftpCopyGet(int &iCopyFile, const QString &sCopyFile,
2414	const QUrl &url, int permissions, KIO::JobFlags flags)	2394		const QUrl &url, int permissions, KIO::JobFlags flags)
2415	{	2395		{
2416	// check if destination is ok ...	2396		// check if destination is ok ...
2417	QFileInfo info(sCopyFile);	2397		QFileInfo info(sCopyFile);
2418	const bool bDestExists = info.exists();	2398		const bool bDestExists = info.exists();
2419	if (bDestExists) {	2399		if (bDestExists) {
2420	if (info.isDir()) {	2400		if (info.isDir()) {
2421	iError = ERR_IS_DIRECTORY;	2401		return Result::fail(ERR_IS_DIRECTORY);
2422	return statusClientError;
2423	}	2402		}
2424	if (!(flags & KIO::Overwrite)) {	2403		if (!(flags & KIO::Overwrite)) {
2425	iError = ERR_FILE_ALREADY_EXIST;	2404		return Result::fail(ERR_FILE_ALREADY_EXIST);
2426	return statusClientError;
2427	}	2405		}
2428	}	2406		}
2429		2407
2430	// do we have a ".part" file?	2408		// do we have a ".part" file?
2431	const QString sPart = sCopyFile + QLatin1String(".part");	2409		const QString sPart = sCopyFile + QLatin1String(".part");
2432	bool bResume = false;	2410		bool bResume = false;
2433	QFileInfo sPartInfo(sPart);	2411		QFileInfo sPartInfo(sPart);
2434	const bool bPartExists = sPartInfo.exists();	2412		const bool bPartExists = sPartInfo.exists();
2435	const bool bMarkPartial = config()->readEntry("MarkPartial", true);	2413		const bool bMarkPartial = config()->readEntry("MarkPartial", true);
2436	const QString dest = bMarkPartial ? sPart : sCopyFile;	2414		const QString dest = bMarkPartial ? sPart : sCopyFile;
2437	if (bMarkPartial && bPartExists && sPartInfo.size() > 0) {	2415		if (bMarkPartial && bPartExists && sPartInfo.size() > 0) {
2438	// must not be a folder! please fix a similar bug in kio_file!!	2416		// must not be a folder! please fix a similar bug in kio_file!!
2439	if (sPartInfo.isDir()) {	2417		if (sPartInfo.isDir()) {
2440	iError = ERR_DIR_ALREADY_EXIST;	2418		return Result::fail(ERR_DIR_ALREADY_EXIST);
2441	return statusClientError; // client side error
2442	}	2419		}
2443	//doesn't work for copy? -> design flaw?	2420		//doesn't work for copy? -> design flaw?
2444	#ifdef ENABLE_CAN_RESUME	2421		#ifdef ENABLE_CAN_RESUME
2445	bResume = canResume(sPartInfo.size());	2422		bResume = canResume(sPartInfo.size());
2446	#else	2423		#else
2447	bResume = true;	2424		bResume = true;
2448	#endif	2425		#endif
2449	}	2426		}
2450		2427
2451	if (bPartExists && !bResume) { // get rid of an unwanted ".part" file	2428		if (bPartExists && !bResume) { // get rid of an unwanted ".part" file
2452	QFile::remove(sPart);	2429		QFile::remove(sPart);
2453	}	2430		}
2454		2431
2455	// WABA: Make sure that we keep writing permissions ourselves,	2432		// WABA: Make sure that we keep writing permissions ourselves,
2456	// otherwise we can be in for a surprise on NFS.	2433		// otherwise we can be in for a surprise on NFS.
2457	mode_t initialMode;	2434		mode_t initialMode;
2458	if (permissions != -1) {	2435		if (permissions >= 0) {
2459	initialMode = permissions \| S_IWUSR;	2436		initialMode = static_cast<mode_t>(permissions \| S_IWUSR);
2460	} else {	2437		} else {
2461	initialMode = 0666;	2438		initialMode = 0666;
2462	}	2439		}
2463		2440
2464	// open the output file ...	2441		// open the output file ...
2465	KIO::fileoffset_t hCopyOffset = 0;	2442		KIO::fileoffset_t hCopyOffset = 0;
2466	if (bResume) {	2443		if (bResume) {
2467	iCopyFile = QT_OPEN(QFile::encodeName(sPart).constData(), O_RDWR); // append if resuming	2444		iCopyFile = QT_OPEN(QFile::encodeName(sPart).constData(), O_RDWR); // append if resuming
2468	hCopyOffset = QT_LSEEK(iCopyFile, 0, SEEK_END);	2445		hCopyOffset = QT_LSEEK(iCopyFile, 0, SEEK_END);
2469	if (hCopyOffset < 0) {	2446		if (hCopyOffset < 0) {
2470	iError = ERR_CANNOT_RESUME;	2447		return Result::fail(ERR_CANNOT_RESUME);
2471	return statusClientError; // client side error
2472	}	2448		}
2473	qCDebug(KIO_FTP) << "resuming at " << hCopyOffset;	2449		qCDebug(KIO_FTP) << "resuming at " << hCopyOffset;
2474	} else {	2450		} else {
2475	iCopyFile = QT_OPEN(QFile::encodeName(dest).constData(), O_CREAT \| O_TRUNC \| O_WRONLY, initialMode);	2451		iCopyFile = QT_OPEN(QFile::encodeName(dest).constData(), O_CREAT \| O_TRUNC \| O_WRONLY, initialMode);
2476	}	2452		}
2477		2453
2478	if (iCopyFile == -1) {	2454		if (iCopyFile == -1) {
2479	qCDebug(KIO_FTP) << "### COULD NOT WRITE " << sCopyFile;	2455		qCDebug(KIO_FTP) << "### COULD NOT WRITE " << sCopyFile;
2480	iError = (errno == EACCES) ? ERR_WRITE_ACCESS_DENIED	2456		const int error = (errno == EACCES) ? ERR_WRITE_ACCESS_DENIED
2481	: ERR_CANNOT_OPEN_FOR_WRITING;	2457		: ERR_CANNOT_OPEN_FOR_WRITING;
2482	return statusClientError;	2458		return Result::fail(error);
2483	}	2459		}
2484		2460
2485	// delegate the real work (iError gets status) ...	2461		// delegate the real work (iError gets status) ...
2486	StatusCode iRes = ftpGet(iError, iCopyFile, url, hCopyOffset);	2462		auto result = ftpGet(iCopyFile, sCopyFile, url, hCopyOffset);
2487	if (QT_CLOSE(iCopyFile) && iRes == statusSuccess) {	2463
2488	iError = ERR_CANNOT_WRITE;	2464		if (QT_CLOSE(iCopyFile) == 0 && !result.success) {
2489	iRes = statusClientError;	2465		// If Closing the file failed but there isn't an error yet, switch
			dfaureUnsubmitted Done s/Closing/closing/ dfaure: s/Closing/closing/
		2466		// into an error!
		2467		result = Result::fail(ERR_CANNOT_WRITE);
2490	}	2468		}
			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
2491	iCopyFile = -1;	2469		iCopyFile = -1;
2492		2470
2493	// handle renaming or deletion of a partial file ...	2471		// handle renaming or deletion of a partial file ...
2494	if (bMarkPartial) {	2472		if (bMarkPartial) {
2495	if (iRes == statusSuccess) {	2473		if (result.success) {
2496	// rename ".part" on success	2474		// rename ".part" on success
2497	if (!QFile::rename(sPart, sCopyFile)) {	2475		if (!QFile::rename(sPart, sCopyFile)) {
2498	// If rename fails, try removing the destination first if it exists.	2476		// If rename fails, try removing the destination first if it exists.
2499	if (!bDestExists \|\| !(QFile::remove(sCopyFile) && QFile::rename(sPart, sCopyFile))) {	2477		if (!bDestExists \|\| !(QFile::remove(sCopyFile) && QFile::rename(sPart, sCopyFile))) {
2500	qCDebug(KIO_FTP) << "cannot rename " << sPart << " to " << sCopyFile;	2478		qCDebug(KIO_FTP) << "cannot rename " << sPart << " to " << sCopyFile;
2501	iError = ERR_CANNOT_RENAME_PARTIAL;	2479		result = Result::fail(ERR_CANNOT_RENAME_PARTIAL);
2502	iRes = statusClientError;
2503	}	2480		}
2504	}	2481		}
2505	} else {	2482		} else {
2506	sPartInfo.refresh();	2483		sPartInfo.refresh();
2507	if (sPartInfo.exists()) { // should a very small ".part" be deleted?	2484		if (sPartInfo.exists()) { // should a very small ".part" be deleted?
2508	int size = config()->readEntry("MinimumKeepSize", DEFAULT_MINIMUM_KEEP_SIZE);	2485		int size = config()->readEntry("MinimumKeepSize", DEFAULT_MINIMUM_KEEP_SIZE);
2509	if (sPartInfo.size() < size) {	2486		if (sPartInfo.size() < size) {
2510	QFile::remove(sPart);	2487		QFile::remove(sPart);
2511	}	2488		}
2512	}	2489		}
2513	}	2490		}
2514	}	2491		}
2515		2492
2516	if (iRes == statusSuccess) {	2493		if (result.success) {
2517	const QString mtimeStr = metaData(QStringLiteral("modified"));	2494		const QString mtimeStr = metaData(QStringLiteral("modified"));
2518	if (!mtimeStr.isEmpty()) {	2495		if (!mtimeStr.isEmpty()) {
2519	QDateTime dt = QDateTime::fromString(mtimeStr, Qt::ISODate);	2496		QDateTime dt = QDateTime::fromString(mtimeStr, Qt::ISODate);
2520	if (dt.isValid()) {	2497		if (dt.isValid()) {
2521	qCDebug(KIO_FTP) << "Updating modified timestamp to" << mtimeStr;	2498		qCDebug(KIO_FTP) << "Updating modified timestamp to" << mtimeStr;
2522	struct utimbuf utbuf;	2499		struct utimbuf utbuf;
2523	info.refresh();	2500		info.refresh();
2524	utbuf.actime = info.lastRead().toSecsSinceEpoch(); // access time, unchanged	2501		utbuf.actime = info.lastRead().toSecsSinceEpoch(); // access time, unchanged
2525	utbuf.modtime = dt.toSecsSinceEpoch(); // modification time	2502		utbuf.modtime = dt.toSecsSinceEpoch(); // modification time
2526	::utime(QFile::encodeName(sCopyFile).constData(), &utbuf);	2503		::utime(QFile::encodeName(sCopyFile).constData(), &utbuf);
2527	}	2504		}
2528	}	2505		}
2529	}	2506		}
2530		2507
2531	return iRes;	2508		return result;
2532	}	2509		}
2533		2510
2534	Ftp::StatusCode Ftp::ftpSendMimeType(int &iError, const QUrl &url)	2511		Result FtpInternal::ftpSendMimeType(const QUrl &url)
2535	{	2512		{
2536	const int totalSize = ((m_size == UnknownSize \|\| m_size > 1024) ? 1024 : m_size);	2513		const int totalSize = ((m_size == UnknownSize \|\| m_size > 1024) ? 1024 : static_cast<int>(m_size));
2537	QByteArray buffer(totalSize, '\0');	2514		QByteArray buffer(totalSize, '\0');
2538		2515
2539	while (true) {	2516		while (true) {
2540	// Wait for content to be available...	2517		// Wait for content to be available...
2541	if (m_data->bytesAvailable() == 0 && !m_data->waitForReadyRead((readTimeout() * 1000))) {	2518		if (m_data->bytesAvailable() == 0 && !m_data->waitForReadyRead((readTimeout() * 1000))) {
2542	iError = ERR_CANNOT_READ;	2519		return Result::fail(ERR_CANNOT_READ, url.toString());
2543	return statusServerError;
2544	}	2520		}
2545		2521
2546	const int bytesRead = m_data->peek(buffer.data(), totalSize);	2522		const qint64 bytesRead = m_data->peek(buffer.data(), totalSize);
2547		2523
2548	// If we got a -1, it must be an error so return an error.	2524		// If we got a -1, it must be an error so return an error.
2549	if (bytesRead == -1) {	2525		if (bytesRead == -1) {
2550	iError = ERR_CANNOT_READ;	2526		return Result::fail(ERR_CANNOT_READ, url.toString());
2551	return statusServerError;
2552	}	2527		}
2553		2528
2554	// If m_size is unknown, peek returns 0 (0 sized file ??), or peek returns size	2529		// If m_size is unknown, peek returns 0 (0 sized file ??), or peek returns size
2555	// equal to the size we want, then break.	2530		// equal to the size we want, then break.
2556	if (bytesRead == 0 \|\| bytesRead == totalSize \|\| m_size == UnknownSize) {	2531		if (bytesRead == 0 \|\| bytesRead == totalSize \|\| m_size == UnknownSize) {
2557	break;	2532		break;
2558	}	2533		}
2559	}	2534		}
2560		2535
2561	if (!buffer.isEmpty()) {	2536		if (!buffer.isEmpty()) {
2562	QMimeDatabase db;	2537		QMimeDatabase db;
2563	QMimeType mime = db.mimeTypeForFileNameAndData(url.path(), buffer);	2538		QMimeType mime = db.mimeTypeForFileNameAndData(url.path(), buffer);
2564	qCDebug(KIO_FTP) << "Emitting mimetype" << mime.name();	2539		qCDebug(KIO_FTP) << "Emitting mimetype" << mime.name();
2565	mimeType(mime.name()); // emit the mime type...	2540		mimeType(mime.name()); // emit the mime type...
2566	}	2541		}
2567		2542
2568	return statusSuccess;	2543		return Result::pass();
2569	}	2544		}
2570		2545
2571	void Ftp::proxyAuthentication(const QNetworkProxy &proxy, QAuthenticator *authenticator)	2546		void FtpInternal::proxyAuthentication(const QNetworkProxy &proxy, QAuthenticator *authenticator)
2572	{	2547		{
2573	Q_UNUSED(proxy);	2548		Q_UNUSED(proxy);
2574	qCDebug(KIO_FTP) << "Authenticator received -- realm:" << authenticator->realm() << "user:" << authenticator->user();	2549		qCDebug(KIO_FTP) << "Authenticator received -- realm:" << authenticator->realm() << "user:" << authenticator->user();
2575		2550
2576	AuthInfo info;	2551		AuthInfo info;
2577	info.url = m_proxyURL;	2552		info.url = m_proxyURL;
2578	info.realmValue = authenticator->realm();	2553		info.realmValue = authenticator->realm();
2579	info.verifyPath = true; //### whatever	2554		info.verifyPath = true; //### whatever
2580	info.username = authenticator->user();	2555		info.username = authenticator->user();
2581		2556
2582	const bool haveCachedCredentials = checkCachedAuthentication(info);	2557		const bool haveCachedCredentials = checkCachedAuthentication(info);
2583		2558
2584	// if m_socketProxyAuth is a valid pointer then authentication has been attempted before,	2559		// if m_socketProxyAuth is a valid pointer then authentication has been attempted before,
2585	// and it was not successful. see below and saveProxyAuthenticationForSocket().	2560		// and it was not successful. see below and saveProxyAuthenticationForSocket().
2586	if (!haveCachedCredentials \|\| m_socketProxyAuth) {	2561		if (!haveCachedCredentials \|\| m_socketProxyAuth) {
2587	// Save authentication info if the connection succeeds. We need to disconnect	2562		// 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!	2563		// 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);	2564		connect(m_control, &QAbstractSocket::connected, this, &FtpInternal::saveProxyAuthentication);
2590	//### fillPromptInfo(&info);	2565		//### fillPromptInfo(&info);
2591	info.prompt = i18n("You need to supply a username and a password for "	2566		info.prompt = i18n("You need to supply a username and a password for "
2592	"the proxy server listed below before you are allowed "	2567		"the proxy server listed below before you are allowed "
2593	"to access any sites.");	2568		"to access any sites.");
2594	info.keepPassword = true;	2569		info.keepPassword = true;
2595	info.commentLabel = i18n("Proxy:");	2570		info.commentLabel = i18n("Proxy:");
2596	info.comment = i18n("<b>%1</b> at <b>%2</b>", info.realmValue, m_proxyURL.host());	2571		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."));	2572		const int errorCode = openPasswordDialogV2(info, i18n("Proxy Authentication Failed."));
2598	if (errorCode) {	2573		if (errorCode) {
2599	qCDebug(KIO_FTP) << "user canceled proxy authentication, or communication error.";	2574		qCDebug(KIO_FTP) << "user canceled proxy authentication, or communication error.";
2600	error(errorCode, m_proxyURL.host());	2575		#pragma message "problem this is a slot so we cant return a result up the call chain maybe do it like errno or something"
		2576		// error(errorCode, m_proxyURL.host());
			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…
2601	return;	2577		return;
2602	}	2578		}
2603	}	2579		}
2604	authenticator->setUser(info.username);	2580		authenticator->setUser(info.username);
2605	authenticator->setPassword(info.password);	2581		authenticator->setPassword(info.password);
2606	authenticator->setOption(QStringLiteral("keepalive"), info.keepPassword);	2582		authenticator->setOption(QStringLiteral("keepalive"), info.keepPassword);
2607		2583
2608	if (m_socketProxyAuth) {	2584		if (m_socketProxyAuth) {
2609	m_socketProxyAuth = authenticator;	2585		m_socketProxyAuth = authenticator;
2610	} else {	2586		} else {
2611	m_socketProxyAuth = new QAuthenticator(*authenticator);	2587		m_socketProxyAuth = new QAuthenticator(*authenticator);
2612	}	2588		}
2613		2589
2614	m_proxyURL.setUserName(info.username);	2590		m_proxyURL.setUserName(info.username);
2615	m_proxyURL.setPassword(info.password);	2591		m_proxyURL.setPassword(info.password);
2616	}	2592		}
2617		2593
2618	void Ftp::saveProxyAuthentication()	2594		void FtpInternal::saveProxyAuthentication()
2619	{	2595		{
2620	qCDebug(KIO_FTP);	2596		qCDebug(KIO_FTP);
2621	disconnect(m_control, &QAbstractSocket::connected, this, &Ftp::saveProxyAuthentication);	2597		disconnect(m_control, &QAbstractSocket::connected, this, &FtpInternal::saveProxyAuthentication);
2622	Q_ASSERT(m_socketProxyAuth);	2598		Q_ASSERT(m_socketProxyAuth);
2623	if (m_socketProxyAuth) {	2599		if (m_socketProxyAuth) {
2624	qCDebug(KIO_FTP) << "-- realm:" << m_socketProxyAuth->realm() << "user:" << m_socketProxyAuth->user();	2600		qCDebug(KIO_FTP) << "-- realm:" << m_socketProxyAuth->realm() << "user:" << m_socketProxyAuth->user();
2625	KIO::AuthInfo a;	2601		KIO::AuthInfo a;
2626	a.verifyPath = true;	2602		a.verifyPath = true;
2627	a.url = m_proxyURL;	2603		a.url = m_proxyURL;
2628	a.realmValue = m_socketProxyAuth->realm();	2604		a.realmValue = m_socketProxyAuth->realm();
2629	a.username = m_socketProxyAuth->user();	2605		a.username = m_socketProxyAuth->user();
2630	a.password = m_socketProxyAuth->password();	2606		a.password = m_socketProxyAuth->password();
2631	a.keepPassword = m_socketProxyAuth->option(QStringLiteral("keepalive")).toBool();	2607		a.keepPassword = m_socketProxyAuth->option(QStringLiteral("keepalive")).toBool();
2632	cacheAuthentication(a);	2608		cacheAuthentication(a);
2633	}	2609		}
2634	delete m_socketProxyAuth;	2610		delete m_socketProxyAuth;
2635	m_socketProxyAuth = nullptr;	2611		m_socketProxyAuth = nullptr;
2636	}	2612		}
2637		2613
2638	void Ftp::fixupEntryName(FtpEntry *e)	2614		void FtpInternal::fixupEntryName(FtpEntry *e)
2639	{	2615		{
2640	Q_ASSERT(e);	2616		Q_ASSERT(e);
2641	if (e->type == S_IFDIR) {	2617		if (e->type == S_IFDIR) {
2642	if (!ftpFolder(e->name, false)) {	2618		if (!ftpFolder(e->name)) {
2643	QString name(e->name.trimmed());	2619		QString name(e->name.trimmed());
2644	if (ftpFolder(name, false)) {	2620		if (ftpFolder(name)) {
2645	e->name = name;	2621		e->name = name;
2646	qCDebug(KIO_FTP) << "fixing up directory name from" << e->name << "to" << name;	2622		qCDebug(KIO_FTP) << "fixing up directory name from" << e->name << "to" << name;
2647	} else {	2623		} else {
2648	int index = 0;	2624		int index = 0;
2649	while (e->name.at(index).isSpace()) {	2625		while (e->name.at(index).isSpace()) {
2650	index++;	2626		index++;
2651	name = e->name.mid(index);	2627		name = e->name.mid(index);
2652	if (ftpFolder(name, false)) {	2628		if (ftpFolder(name)) {
2653	qCDebug(KIO_FTP) << "fixing up directory name from" << e->name << "to" << name;	2629		qCDebug(KIO_FTP) << "fixing up directory name from" << e->name << "to" << name;
2654	e->name = name;	2630		e->name = name;
2655	break;	2631		break;
2656	}	2632		}
2657	}	2633		}
2658	}	2634		}
2659	}	2635		}
2660	} else {	2636		} else {
Show All 13 Lines		2647	if (ftpFileExists(name)) {
2674	break;	2650		break;
2675	}	2651		}
2676	}	2652		}
2677	}	2653		}
2678	}	2654		}
2679	}	2655		}
2680	}	2656		}
2681		2657
2682	QTcpSocket *Ftp::synchronousConnectToHost(const QString &host, quint16 port)	2658		QTcpSocket *FtpInternal::synchronousConnectToHost(const QString &host, quint16 port)
2683	{	2659		{
2684	QTcpSocket *socket = new QSslSocket;	2660		QTcpSocket *socket = new QSslSocket;
2685	socket->connectToHost(host, port);	2661		socket->connectToHost(host, port);
2686	socket->waitForConnected(connectTimeout() * 1000);	2662		socket->waitForConnected(connectTimeout() * 1000);
2687	return socket;	2663		return socket;
2688	}	2664		}
2689		2665
		2666		//===============================================================================
		2667		// Ftp
		2668		//===============================================================================
		2669
		2670		Ftp::Ftp(const QByteArray &pool, const QByteArray &app)
		2671		: SlaveBase(QByteArrayLiteral("ftp"), pool, app)
		2672		, d(new FtpInternal(this))
		2673		{
		2674		}
		2675
		2676		Ftp::~Ftp() = default;
		2677
		2678		void Ftp::setHost(const QString &host, quint16 port, const QString &user, const QString &pass)
		2679		{
		2680		d->setHost(host, port, user, pass);
		2681		}
		2682
		2683		void Ftp::openConnection()
		2684		{
		2685		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 ;)
		2686		}
		2687
		2688		void Ftp::closeConnection()
		2689		{
		2690		d->closeConnection();
		2691		}
		2692
		2693		void Ftp::stat(const QUrl &url)
		2694		{
		2695		finalize(d->stat(url));
		2696		}
		2697
		2698		void Ftp::listDir(const QUrl &url)
		2699		{
		2700		d->listDir(url);
		2701		}
		2702
		2703		void Ftp::mkdir(const QUrl &url, int permissions)
			dfaureUnsubmitted Not Done yeah, looks like wishful thinking.... remove? dfaure: yeah, looks like wishful thinking.... remove?
		2704		{
		2705		finalize(d->mkdir(url, permissions));
		2706		}
		2707
		2708		void Ftp::rename(const QUrl &src, const QUrl &dst, JobFlags flags)
		2709		{
		2710		finalize(d->rename(src, dst, flags));
		2711		}
		2712
		2713		void Ftp::del(const QUrl &url, bool isfile)
		2714		{
		2715		finalize(d->del(url, isfile));
		2716		}
		2717
		2718		void Ftp::chmod(const QUrl &url, int permissions)
		2719		{
		2720		finalize(d->chmod(url, permissions));
		2721		}
		2722
		2723		void Ftp::get(const QUrl &url)
		2724		{
		2725		finalize(d->get(url));
		2726		}
		2727
		2728		void Ftp::put(const QUrl &url, int permissions, JobFlags flags)
		2729		{
		2730		finalize(d->put(url, permissions, flags));
		2731		}
		2732
		2733		void Ftp::slave_status()
		2734		{
		2735		d->slave_status();
		2736		}
		2737
		2738		void Ftp::copy(const QUrl &src, const QUrl &dest, int permissions, JobFlags flags)
		2739		{
		2740		finalize(d->copy(src, dest, permissions, flags));
		2741		}
		2742
		2743		void Ftp::finalize(const Result &result)
		2744		{
		2745		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
		2746		if (!result.success) {
		2747		error(result.error, result.errorString);
		2748		return;
		2749		}
		2750		finished();
		2751		}
		2752
		2753		QDebug operator<<(QDebug dbg, const Result &r)
		2754
		2755		{
		2756		QDebugStateSaver saver(dbg);
		2757		dbg.nospace() << "Result("
		2758		<< "success=" << r.success
		2759		<< ", err=" << r.error
		2760		<< ", str=" << r.errorString
		2761		<< ')';
		2762		return dbg;
		2763		}
		2764
2690	// needed for JSON file embedding	2765		// needed for JSON file embedding
2691	#include "ftp.moc"	2766		#include "ftp.moc"