File: afcutils.cpp

package info (click to toggle)
kio-extras 4%3A25.04.2-1
  • links: PTS, VCS
  • area: main
  • in suites: sid, trixie
  • size: 31,928 kB
  • sloc: cpp: 28,852; ansic: 3,084; perl: 1,048; xml: 116; sh: 92; python: 28; makefile: 9
file content (149 lines) | stat: -rw-r--r-- 5,988 bytes parent folder | download
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
/*
 * 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));
    }
}