1 /*
2  * Copyright (c) 2022-2024 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "ext_extension_stub.h"
17 
18 #include <cstdint>
19 #include <sstream>
20 
21 #include "b_error/b_error.h"
22 #include "b_error/b_excep_utils.h"
23 #include "filemgmt_libhilog.h"
24 
25 namespace OHOS::FileManagement::Backup {
26 using namespace std;
27 
ExtExtensionStub()28 ExtExtensionStub::ExtExtensionStub()
29 {
30     opToInterfaceMap_[static_cast<uint32_t>(IExtensionInterfaceCode::CMD_GET_FILE_HANDLE)] =
31         &ExtExtensionStub::CmdGetFileHandle;
32     opToInterfaceMap_[static_cast<uint32_t>(IExtensionInterfaceCode::CMD_HANDLE_CLAER)] =
33         &ExtExtensionStub::CmdHandleClear;
34     opToInterfaceMap_[static_cast<uint32_t>(IExtensionInterfaceCode::CMD_HANDLE_BACKUP)] =
35         &ExtExtensionStub::CmdHandleBackup;
36     opToInterfaceMap_[static_cast<uint32_t>(IExtensionInterfaceCode::CMD_PUBLISH_FILE)] =
37         &ExtExtensionStub::CmdPublishFile;
38     opToInterfaceMap_[static_cast<uint32_t>(IExtensionInterfaceCode::CMD_HANDLE_RESTORE)] =
39         &ExtExtensionStub::CmdHandleRestore;
40     opToInterfaceMap_[static_cast<uint32_t>(IExtensionInterfaceCode::CMD_GET_INCREMENTAL_FILE_HANDLE)] =
41         &ExtExtensionStub::CmdGetIncrementalFileHandle;
42     opToInterfaceMap_[static_cast<uint32_t>(IExtensionInterfaceCode::CMD_PUBLISH_INCREMENTAL_FILE)] =
43         &ExtExtensionStub::CmdPublishIncrementalFile;
44     opToInterfaceMap_[static_cast<uint32_t>(IExtensionInterfaceCode::CMD_HANDLE_INCREMENTAL_BACKUP)] =
45         &ExtExtensionStub::CmdHandleIncrementalBackup;
46     opToInterfaceMap_[static_cast<uint32_t>(IExtensionInterfaceCode::CMD_GET_INCREMENTAL_BACKUP_FILE_HANDLE)] =
47         &ExtExtensionStub::CmdGetIncrementalBackupFileHandle;
48     opToInterfaceMap_[static_cast<uint32_t>(IExtensionInterfaceCode::CMD_GET_BACKUP_INFO)] =
49         &ExtExtensionStub::CmdGetBackupInfo;
50     opToInterfaceMap_[static_cast<uint32_t>(IExtensionInterfaceCode::CMD_INCREMENTAL_ON_BACKUP)] =
51         &ExtExtensionStub::CmdIncrementalOnBackup;
52     opToInterfaceMap_[static_cast<uint32_t>(IExtensionInterfaceCode::CMD_UPDATE_FD_SENDRATE)] =
53         &ExtExtensionStub::CmdUpdateFdSendRate;
54     opToInterfaceMap_[static_cast<uint32_t>(IExtensionInterfaceCode::CMD_HANDLE_USER_0_BACKUP)] =
55         &ExtExtensionStub::CmdHandleUser0Backup;
56 }
57 
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)58 int32_t ExtExtensionStub::OnRemoteRequest(uint32_t code,
59                                           MessageParcel &data,
60                                           MessageParcel &reply,
61                                           MessageOption &option)
62 {
63     const std::u16string descriptor = ExtExtensionStub::GetDescriptor();
64     const std::u16string remoteDescriptor = data.ReadInterfaceToken();
65     if (descriptor != remoteDescriptor) {
66         return BError(BError::Codes::EXT_INVAL_ARG, "Invalid remote descriptor");
67     }
68 
69     HILOGI("Begin to call procedure indexed %{public}u", code);
70     auto interfaceIndex = opToInterfaceMap_.find(code);
71     if (interfaceIndex == opToInterfaceMap_.end() || !interfaceIndex->second) {
72         HILOGE("Cannot response request %{public}d : unknown procedure", code);
73         return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
74     }
75 
76     return BExcepUltils::ExceptionCatcherLocked(
77         [&]() { return ErrCode((this->*(interfaceIndex->second))(data, reply)); });
78 }
79 
CmdGetFileHandle(MessageParcel & data,MessageParcel & reply)80 ErrCode ExtExtensionStub::CmdGetFileHandle(MessageParcel &data, MessageParcel &reply)
81 {
82     string fileName;
83     if (!data.ReadString(fileName)) {
84         return BError(BError::Codes::EXT_INVAL_ARG, "Failed to receive fileName").GetCode();
85     }
86 
87     int32_t errCode = ERR_OK;
88     UniqueFd fd = GetFileHandle(fileName, errCode);
89     bool fdFlag = fd < 0 ? false : true;
90     reply.WriteBool(fdFlag);
91     reply.WriteInt32(errCode);
92     if (fdFlag == true && !reply.WriteFileDescriptor(fd)) {
93         return BError(BError::Codes::EXT_BROKEN_IPC, "Failed to send out the file").GetCode();
94     }
95     return BError(BError::Codes::OK);
96 }
97 
CmdHandleClear(MessageParcel & data,MessageParcel & reply)98 ErrCode ExtExtensionStub::CmdHandleClear(MessageParcel &data, MessageParcel &reply)
99 {
100     ErrCode res = HandleClear();
101     if (!reply.WriteInt32(res)) {
102         stringstream ss;
103         ss << "Failed to send the result " << res;
104         return BError(BError::Codes::EXT_BROKEN_IPC, ss.str()).GetCode();
105     }
106     return BError(BError::Codes::OK);
107 }
108 
CmdHandleBackup(MessageParcel & data,MessageParcel & reply)109 ErrCode ExtExtensionStub::CmdHandleBackup(MessageParcel &data, MessageParcel &reply)
110 {
111     bool isClearData = true;
112     isClearData = data.ReadBool();
113     ErrCode res = HandleBackup(isClearData);
114     if (!reply.WriteInt32(res)) {
115         stringstream ss;
116         ss << "Failed to send the result " << res;
117         return BError(BError::Codes::EXT_BROKEN_IPC, ss.str()).GetCode();
118     }
119     return BError(BError::Codes::OK);
120 }
121 
CmdPublishFile(MessageParcel & data,MessageParcel & reply)122 ErrCode ExtExtensionStub::CmdPublishFile(MessageParcel &data, MessageParcel &reply)
123 {
124     string fileName;
125     if (!data.ReadString(fileName)) {
126         return BError(BError::Codes::EXT_INVAL_ARG, "Failed to receive fileName");
127     }
128 
129     ErrCode res = PublishFile(fileName);
130     if (!reply.WriteInt32(res)) {
131         stringstream ss;
132         ss << "Failed to send the result " << res;
133         return BError(BError::Codes::EXT_BROKEN_IPC, ss.str()).GetCode();
134     }
135     return BError(BError::Codes::OK);
136 }
137 
CmdHandleRestore(MessageParcel & data,MessageParcel & reply)138 ErrCode ExtExtensionStub::CmdHandleRestore(MessageParcel &data, MessageParcel &reply)
139 {
140     bool isClearData = true;
141     isClearData = data.ReadBool();
142     ErrCode res = HandleRestore(isClearData);
143     if (!reply.WriteInt32(res)) {
144         stringstream ss;
145         ss << "Failed to send the result " << res;
146         return BError(BError::Codes::EXT_BROKEN_IPC, ss.str()).GetCode();
147     }
148     return BError(BError::Codes::OK);
149 }
150 
CmdGetIncrementalFileHandle(MessageParcel & data,MessageParcel & reply)151 ErrCode ExtExtensionStub::CmdGetIncrementalFileHandle(MessageParcel &data, MessageParcel &reply)
152 {
153     string fileName;
154     if (!data.ReadString(fileName)) {
155         return BError(BError::Codes::EXT_INVAL_ARG, "Failed to receive fileName").GetCode();
156     }
157 
158     ErrCode res = GetIncrementalFileHandle(fileName);
159     if (!reply.WriteInt32(res)) {
160         return BError(BError::Codes::EXT_BROKEN_IPC, "Failed to send out the file").GetCode();
161     }
162     return BError(BError::Codes::OK);
163 }
164 
CmdPublishIncrementalFile(MessageParcel & data,MessageParcel & reply)165 ErrCode ExtExtensionStub::CmdPublishIncrementalFile(MessageParcel &data, MessageParcel &reply)
166 {
167     string fileName;
168     if (!data.ReadString(fileName)) {
169         return BError(BError::Codes::EXT_INVAL_ARG, "Failed to receive fileName");
170     }
171 
172     ErrCode res = PublishIncrementalFile(fileName);
173     if (!reply.WriteInt32(res)) {
174         stringstream ss;
175         ss << "Failed to send the result " << res;
176         return BError(BError::Codes::EXT_BROKEN_IPC, ss.str()).GetCode();
177     }
178     return BError(BError::Codes::OK);
179 }
180 
CmdHandleIncrementalBackup(MessageParcel & data,MessageParcel & reply)181 ErrCode ExtExtensionStub::CmdHandleIncrementalBackup(MessageParcel &data, MessageParcel &reply)
182 {
183     UniqueFd incrementalFd(data.ReadFileDescriptor());
184     UniqueFd manifestFd(data.ReadFileDescriptor());
185     ErrCode res = HandleIncrementalBackup(move(incrementalFd), move(manifestFd));
186     if (!reply.WriteInt32(res)) {
187         stringstream ss;
188         ss << "Failed to send the result " << res;
189         return BError(BError::Codes::EXT_BROKEN_IPC, ss.str()).GetCode();
190     }
191     return BError(BError::Codes::OK);
192 }
193 
CmdIncrementalOnBackup(MessageParcel & data,MessageParcel & reply)194 ErrCode ExtExtensionStub::CmdIncrementalOnBackup(MessageParcel &data, MessageParcel &reply)
195 {
196     bool isClearData = true;
197     isClearData = data.ReadBool();
198     ErrCode res = IncrementalOnBackup(isClearData);
199     if (!reply.WriteInt32(res)) {
200         stringstream ss;
201         ss << "Failed to send the result " << res;
202         return BError(BError::Codes::EXT_BROKEN_IPC, ss.str()).GetCode();
203     }
204     return BError(BError::Codes::OK);
205 }
206 
CmdGetIncrementalBackupFileHandle(MessageParcel & data,MessageParcel & reply)207 ErrCode ExtExtensionStub::CmdGetIncrementalBackupFileHandle(MessageParcel &data, MessageParcel &reply)
208 {
209     auto [incrementalFd, manifestFd] = GetIncrementalBackupFileHandle();
210     if (!reply.WriteFileDescriptor(incrementalFd)) {
211         return BError(BError::Codes::EXT_BROKEN_IPC, "Failed to send out the file").GetCode();
212     }
213     if (!reply.WriteFileDescriptor(manifestFd)) {
214         return BError(BError::Codes::EXT_BROKEN_IPC, "Failed to send out the file").GetCode();
215     }
216     return BError(BError::Codes::OK);
217 }
218 
CmdGetBackupInfo(MessageParcel & data,MessageParcel & reply)219 ErrCode ExtExtensionStub::CmdGetBackupInfo(MessageParcel &data, MessageParcel &reply)
220 {
221     HILOGI("CmdGetBackupInfo Begin");
222     std::string result;
223     int ret = GetBackupInfo(result);
224     if (!reply.WriteInt32(ret)) {
225         return BError(BError::Codes::EXT_BROKEN_IPC, "Failed to send out the ret").GetCode();
226     }
227     if (!reply.WriteString(result)) {
228         return BError(BError::Codes::EXT_BROKEN_IPC, "Failed to send out the result").GetCode();
229     }
230     return BError(BError::Codes::OK);
231 }
232 
CmdUpdateFdSendRate(MessageParcel & data,MessageParcel & reply)233 ErrCode ExtExtensionStub::CmdUpdateFdSendRate(MessageParcel &data, MessageParcel &reply)
234 {
235     HILOGD("CmdUpdateFdSendRate Begin");
236     std::string bundleName;
237     if (!data.ReadString(bundleName)) {
238         return BError(BError::Codes::EXT_INVAL_ARG, "Failed to receive bundleName").GetCode();
239     }
240     int32_t sendRate;
241     if (!data.ReadInt32(sendRate)) {
242         return BError(BError::Codes::EXT_INVAL_ARG, "Failed to receive sendRate").GetCode();
243     }
244     int ret = UpdateFdSendRate(bundleName, sendRate);
245     if (!reply.WriteInt32(ret)) {
246         return BError(BError::Codes::EXT_BROKEN_IPC, "Failed to send out the ret").GetCode();
247     }
248     return BError(BError::Codes::OK);
249 }
250 
CmdHandleUser0Backup(MessageParcel & data,MessageParcel & reply)251 ErrCode ExtExtensionStub::CmdHandleUser0Backup(MessageParcel &data, MessageParcel &reply)
252 {
253     HILOGD("CmdHandleUser0Backup Begin");
254     int ret = User0OnBackup();
255     if (!reply.WriteInt32(ret)) {
256         return BError(BError::Codes::EXT_BROKEN_IPC, "Failed to send out the ret").GetCode();
257     }
258     return BError(BError::Codes::OK);
259 }
260 } // namespace OHOS::FileManagement::Backup