File indexing completed on 2024-04-28 08:49:46

 /*
  * SPDX-FileCopyrightText: 2022 Kai Uwe Broulik <kde@broulik.de>
  * SPDX-License-Identifier: GPL-2.0-or-later
  */
 
 #include "afcutils.h"
 
 #include "afc_debug.h"
 
 #include <KLocalizedString>
 
 using namespace KIO;
 
 WorkerResult AfcUtils::Result::from(const afc_error_t afcError, const QString &errorText)
 {
     switch (afcError) {
     case AFC_E_SUCCESS:
     case AFC_E_END_OF_DATA:
         return WorkerResult::pass();
 
     case AFC_E_UNKNOWN_ERROR:
         return WorkerResult::fail(ERR_UNKNOWN, errorText);
 
     case AFC_E_NO_RESOURCES:
     case AFC_E_NO_MEM:
         return WorkerResult::fail(ERR_OUT_OF_MEMORY, errorText);
 
     case AFC_E_READ_ERROR:
         return WorkerResult::fail(ERR_CANNOT_READ, errorText);
     case AFC_E_WRITE_ERROR:
         return WorkerResult::fail(ERR_CANNOT_WRITE, errorText);
     case AFC_E_OBJECT_NOT_FOUND:
         return WorkerResult::fail(ERR_DOES_NOT_EXIST, errorText);
     case AFC_E_OBJECT_IS_DIR:
         return WorkerResult::fail(ERR_IS_DIRECTORY, errorText);
     case AFC_E_PERM_DENIED:
         return WorkerResult::fail(ERR_ACCESS_DENIED, errorText);
     case AFC_E_SERVICE_NOT_CONNECTED:
         return WorkerResult::fail(ERR_CONNECTION_BROKEN, errorText);
     case AFC_E_OP_TIMEOUT:
         return WorkerResult::fail(ERR_SERVER_TIMEOUT, errorText);
     case AFC_E_OP_NOT_SUPPORTED:
         return WorkerResult::fail(ERR_UNSUPPORTED_ACTION, errorText);
     case AFC_E_OBJECT_EXISTS:
         return WorkerResult::fail(ERR_FILE_ALREADY_EXIST, errorText);
     case AFC_E_NO_SPACE_LEFT:
         return WorkerResult::fail(ERR_DISK_FULL, errorText);
     case AFC_E_IO_ERROR:
         return WorkerResult::fail(ERR_CONNECTION_BROKEN, errorText);
     case AFC_E_INTERNAL_ERROR:
         return WorkerResult::fail(ERR_INTERNAL_SERVER, errorText);
     case AFC_E_DIR_NOT_EMPTY:
         return WorkerResult::fail(ERR_CANNOT_RMDIR, errorText);
     case AFC_E_MUX_ERROR:
         return WorkerResult::fail(ERR_CANNOT_CONNECT, errorText);
         //    case AFC_E_NOT_ENOUGH_DATA:
         //        return WorkerResult::fail(ERR_UNKNOWN_INTERRUPT, errorText);
     default:
         qCWarning(KIO_AFC_LOG) << "Unhandled afc_error_t" << afcError;
         return WorkerResult::fail(ERR_INTERNAL, i18n("Unhandled AFC error code '%1'", afcError));
     }
 }
 
 WorkerResult AfcUtils::Result::from(const house_arrest_error_t houseArrestError, const QString &errorText)
 {
     switch (houseArrestError) {
     case HOUSE_ARREST_E_SUCCESS:
         return WorkerResult::pass();
     case HOUSE_ARREST_E_CONN_FAILED:
         return WorkerResult::fail(ERR_CANNOT_CONNECT, errorText);
     default:
         qCWarning(KIO_AFC_LOG) << "Unhandled house_arrest_error_t" << houseArrestError;
         return WorkerResult::fail(ERR_INTERNAL, i18n("Unhandled housearrest error code '%1'", houseArrestError));
     }
 }
 
 WorkerResult AfcUtils::Result::from(const instproxy_error_t instProxyError, const QString &errorText)
 {
     switch (instProxyError) {
     case INSTPROXY_E_SUCCESS:
         return WorkerResult::pass();
     case INSTPROXY_E_CONN_FAILED:
         return WorkerResult::fail(ERR_CANNOT_CONNECT, errorText);
     case INSTPROXY_E_RECEIVE_TIMEOUT:
         return WorkerResult::fail(ERR_SERVER_TIMEOUT, errorText);
     // We don't actually manage any apps (yet?), so most error codes don't apply to us
     default:
         qCWarning(KIO_AFC_LOG) << "Unhandled instproxy_error_t" << instProxyError;
         return WorkerResult::fail(ERR_INTERNAL, i18n("Unhandled instproxy error code '%1'", instProxyError));
     }
 }
 
 WorkerResult AfcUtils::Result::from(const lockdownd_error_t lockdownError, const QString &errorText)
 {
     switch (lockdownError) {
     case LOCKDOWN_E_SUCCESS:
         return WorkerResult::pass();
     case LOCKDOWN_E_RECEIVE_TIMEOUT:
         return WorkerResult::fail(ERR_SERVER_TIMEOUT, errorText);
     case LOCKDOWN_E_MUX_ERROR:
         return WorkerResult::fail(ERR_CANNOT_CONNECT, errorText);
     case LOCKDOWN_E_PASSWORD_PROTECTED: {
         QString text = errorText;
         if (text.isEmpty()) {
             text = i18n("The device is locked. Please enter the passcode on the device and try again.");
         }
         return WorkerResult::fail(ERR_WORKER_DEFINED, text);
     }
     case LOCKDOWN_E_USER_DENIED_PAIRING: {
         QString text = errorText;
         if (text.isEmpty()) {
             text = i18n("You have denied this computer access to the device.");
         }
         return WorkerResult::fail(ERR_WORKER_DEFINED, text);
     }
     case LOCKDOWN_E_PAIRING_DIALOG_RESPONSE_PENDING: {
         QString text = errorText;
         if (text.isEmpty()) {
             text = i18n("You need to allow this computer to access the device. Please accept the prompt on the device and try again.");
         }
         return WorkerResult::fail(ERR_WORKER_DEFINED, text);
     }
     // lockdownd_client_new_with_handshake returns this when pairing failed rather than any of the errors above
     case LOCKDOWN_E_INVALID_HOST_ID: {
         QString text = errorText;
         if (text.isEmpty()) {
             text = i18n("Cannot access the device. Make sure it is unlocked and allows this computer to access it.");
         }
         return WorkerResult::fail(ERR_WORKER_DEFINED, text);
     }
     // TODO LOCKDOWN_E_SESSION_INACTIVE
     default:
         qCWarning(KIO_AFC_LOG) << "Unhandled lockdownd_error_t" << lockdownError;
         return WorkerResult::fail(ERR_INTERNAL, i18n("Unhandled lockdownd code '%1'", lockdownError));
     }
 }
 
 WorkerResult AfcUtils::Result::from(const sbservices_error_t springBoardError, const QString &errorText)
 {
     switch (springBoardError) {
     case SBSERVICES_E_SUCCESS:
         return WorkerResult::pass();
     case SBSERVICES_E_CONN_FAILED:
         return WorkerResult::fail(ERR_CANNOT_CONNECT, errorText);
     default:
         qCWarning(KIO_AFC_LOG) << "Unhandled sbservices_error_t" << springBoardError;
         return WorkerResult::fail(ERR_INTERNAL, i18n("Unhandled sbservices code '%1'", springBoardError));
     }
 }