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 "service_reverse_stub.h"
17 
18 #include <cstdint>
19 #include <sstream>
20 
21 #include "b_error/b_error.h"
22 #include "filemgmt_libhilog.h"
23 
24 namespace OHOS::FileManagement::Backup {
25 using namespace std;
26 const int INVALID_FD = -1;
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)27 int32_t ServiceReverseStub::OnRemoteRequest(uint32_t code,
28                                             MessageParcel &data,
29                                             MessageParcel &reply,
30                                             MessageOption &option)
31 {
32     const std::u16string descriptor = ServiceReverseStub::GetDescriptor();
33     const std::u16string remoteDescriptor = data.ReadInterfaceToken();
34     if (descriptor != remoteDescriptor) {
35         return BError(BError::Codes::SA_INVAL_ARG, "Invalid remote descriptor");
36     }
37 
38     HILOGD("Begin to call procedure indexed %{public}u", code);
39     auto interfaceIndex = opToInterfaceMap_.find(code);
40     if (interfaceIndex == opToInterfaceMap_.end() || !interfaceIndex->second) {
41         HILOGE("Cannot response request %{public}d : unknown procedure", code);
42         return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
43     }
44     return (this->*(interfaceIndex->second))(data, reply);
45 }
ServiceReverseStubSupplement()46 void ServiceReverseStub::ServiceReverseStubSupplement()
47 {
48     opToInterfaceMap_[static_cast<uint32_t>(IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_RESTORE_ON_FILE_READY)] =
49         &ServiceReverseStub::CmdIncrementalRestoreOnFileReady;
50     opToInterfaceMap_[static_cast<uint32_t>(
51         IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_RESTORE_ON_SUB_TASK_STARTED)] =
52         &ServiceReverseStub::CmdIncrementalRestoreOnBundleStarted;
53     opToInterfaceMap_[static_cast<uint32_t>(
54         IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_RESTORE_ON_RESULT_REPORT)] =
55         &ServiceReverseStub::CmdIncrementalRestoreOnResultReport;
56     opToInterfaceMap_[static_cast<uint32_t>(
57         IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_RESTORE_ON_SUB_TASK_FINISHED)] =
58         &ServiceReverseStub::CmdIncrementalRestoreOnBundleFinished;
59     opToInterfaceMap_[static_cast<uint32_t>(
60         IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_RESTORE_ON_TASK_FINISHED)] =
61         &ServiceReverseStub::CmdIncrementalRestoreOnAllBundlesFinished;
62     opToInterfaceMap_[static_cast<uint32_t>(
63         IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_RESTORE_ON_PROCESS_INFO)] =
64         &ServiceReverseStub::CmdIncrementalRestoreOnProcessInfo;
65 }
66 
ServiceReverseStub()67 ServiceReverseStub::ServiceReverseStub()
68 {
69     opToInterfaceMap_[static_cast<uint32_t>(IServiceReverseInterfaceCode::SERVICER_BACKUP_ON_FILE_READY)] =
70         &ServiceReverseStub::CmdBackupOnFileReady;
71     opToInterfaceMap_[static_cast<uint32_t>(IServiceReverseInterfaceCode::SERVICER_BACKUP_ON_SUB_TASK_STARTED)] =
72         &ServiceReverseStub::CmdBackupOnBundleStarted;
73     opToInterfaceMap_[static_cast<uint32_t>(IServiceReverseInterfaceCode::SERVICER_BACKUP_ON_RESULT_REPORT)] =
74         &ServiceReverseStub::CmdBackupOnResultReport;
75     opToInterfaceMap_[static_cast<uint32_t>(IServiceReverseInterfaceCode::SERVICER_BACKUP_ON_SUB_TASK_FINISHED)] =
76         &ServiceReverseStub::CmdBackupOnBundleFinished;
77     opToInterfaceMap_[static_cast<uint32_t>(IServiceReverseInterfaceCode::SERVICER_BACKUP_ON_TASK_FINISHED)] =
78         &ServiceReverseStub::CmdBackupOnAllBundlesFinished;
79     opToInterfaceMap_[static_cast<uint32_t>(IServiceReverseInterfaceCode::SERVICER_BACKUP_ON_PROCESS_INFO)] =
80         &ServiceReverseStub::CmdBackupOnProcessInfo;
81 
82     opToInterfaceMap_[static_cast<uint32_t>(IServiceReverseInterfaceCode::SERVICER_RESTORE_ON_FILE_READY)] =
83         &ServiceReverseStub::CmdRestoreOnFileReady;
84     opToInterfaceMap_[static_cast<uint32_t>(IServiceReverseInterfaceCode::SERVICER_RESTORE_ON_SUB_TASK_STARTED)] =
85         &ServiceReverseStub::CmdRestoreOnBundleStarted;
86     opToInterfaceMap_[static_cast<uint32_t>(IServiceReverseInterfaceCode::SERVICER_RESTORE_ON_RESULT_REPORT)] =
87         &ServiceReverseStub::CmdRestoreOnResultReport;
88     opToInterfaceMap_[static_cast<uint32_t>(IServiceReverseInterfaceCode::SERVICER_RESTORE_ON_SUB_TASK_FINISHED)] =
89         &ServiceReverseStub::CmdRestoreOnBundleFinished;
90     opToInterfaceMap_[static_cast<uint32_t>(IServiceReverseInterfaceCode::SERVICER_RESTORE_ON_TASK_FINISHED)] =
91         &ServiceReverseStub::CmdRestoreOnAllBundlesFinished;
92     opToInterfaceMap_[static_cast<uint32_t>(IServiceReverseInterfaceCode::SERVICER_RESTORE_ON_PROCESS_INFO)] =
93         &ServiceReverseStub::CmdRestoreOnProcessInfo;
94 
95     opToInterfaceMap_[static_cast<uint32_t>(IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_BACKUP_ON_FILE_READY)] =
96         &ServiceReverseStub::CmdIncrementalBackupOnFileReady;
97     opToInterfaceMap_[static_cast<uint32_t>(
98         IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_BACKUP_ON_SUB_TASK_STARTED)] =
99         &ServiceReverseStub::CmdIncrementalBackupOnBundleStarted;
100     opToInterfaceMap_[static_cast<uint32_t>(IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_BACKUP_ON_RESULT_REPORT)]
101         = &ServiceReverseStub::CmdIncrementalBackupOnResultReport;
102     opToInterfaceMap_[static_cast<uint32_t>(
103         IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_BACKUP_ON_SUB_TASK_FINISHED)] =
104         &ServiceReverseStub::CmdIncrementalBackupOnBundleFinished;
105     opToInterfaceMap_[static_cast<uint32_t>(
106         IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_BACKUP_ON_TASK_FINISHED)] =
107         &ServiceReverseStub::CmdIncrementalBackupOnAllBundlesFinished;
108     opToInterfaceMap_[static_cast<uint32_t>(
109         IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_BACKUP_ON_PROCESS_INFO)] =
110         &ServiceReverseStub::CmdIncrementalBackupOnProcessInfo;
111     ServiceReverseStubSupplement();
112 }
113 
CmdBackupOnFileReady(MessageParcel & data,MessageParcel & reply)114 int32_t ServiceReverseStub::CmdBackupOnFileReady(MessageParcel &data, MessageParcel &reply)
115 {
116     auto bundleName = data.ReadString();
117     auto fileName = data.ReadString();
118     int fd = INVALID_FD;
119     bool fdFlag = data.ReadBool();
120     if (fdFlag == true) {
121         fd = data.ReadFileDescriptor();
122     }
123     int32_t errCode = data.ReadInt32();
124     BackupOnFileReady(bundleName, fileName, fd, errCode);
125     return BError(BError::Codes::OK);
126 }
127 
CmdBackupOnResultReport(MessageParcel & data,MessageParcel & reply)128 int32_t ServiceReverseStub::CmdBackupOnResultReport(MessageParcel &data, MessageParcel &reply)
129 {
130     std::string result = data.ReadString();
131     std::string bundleName = data.ReadString();
132     BackupOnResultReport(result, bundleName);
133     return BError(BError::Codes::OK);
134 }
135 
CmdBackupOnBundleStarted(MessageParcel & data,MessageParcel & reply)136 int32_t ServiceReverseStub::CmdBackupOnBundleStarted(MessageParcel &data, MessageParcel &reply)
137 {
138     int32_t errCode = data.ReadInt32();
139     auto bundleName = data.ReadString();
140     BackupOnBundleStarted(errCode, bundleName);
141     return BError(BError::Codes::OK);
142 }
143 
CmdBackupOnBundleFinished(MessageParcel & data,MessageParcel & reply)144 int32_t ServiceReverseStub::CmdBackupOnBundleFinished(MessageParcel &data, MessageParcel &reply)
145 {
146     int32_t errCode = data.ReadInt32();
147     auto bundleName = data.ReadString();
148     BackupOnBundleFinished(errCode, bundleName);
149     return BError(BError::Codes::OK);
150 }
151 
CmdBackupOnAllBundlesFinished(MessageParcel & data,MessageParcel & reply)152 int32_t ServiceReverseStub::CmdBackupOnAllBundlesFinished(MessageParcel &data, MessageParcel &reply)
153 {
154     int32_t errCode = data.ReadInt32();
155     BackupOnAllBundlesFinished(errCode);
156     return BError(BError::Codes::OK);
157 }
158 
CmdBackupOnProcessInfo(MessageParcel & data,MessageParcel & reply)159 int32_t ServiceReverseStub::CmdBackupOnProcessInfo(MessageParcel &data, MessageParcel &reply)
160 {
161     std::string bundleName = data.ReadString();
162     std::string processInfo = data.ReadString();
163     BackupOnProcessInfo(bundleName, processInfo);
164     return BError(BError::Codes::OK);
165 }
166 
CmdRestoreOnBundleStarted(MessageParcel & data,MessageParcel & reply)167 int32_t ServiceReverseStub::CmdRestoreOnBundleStarted(MessageParcel &data, MessageParcel &reply)
168 {
169     int32_t errCode = data.ReadInt32();
170     auto bundleName = data.ReadString();
171     RestoreOnBundleStarted(errCode, bundleName);
172     return BError(BError::Codes::OK);
173 }
174 
CmdRestoreOnBundleFinished(MessageParcel & data,MessageParcel & reply)175 int32_t ServiceReverseStub::CmdRestoreOnBundleFinished(MessageParcel &data, MessageParcel &reply)
176 {
177     int32_t errCode = data.ReadInt32();
178     auto bundleName = data.ReadString();
179     RestoreOnBundleFinished(errCode, bundleName);
180     return BError(BError::Codes::OK);
181 }
182 
CmdRestoreOnAllBundlesFinished(MessageParcel & data,MessageParcel & reply)183 int32_t ServiceReverseStub::CmdRestoreOnAllBundlesFinished(MessageParcel &data, MessageParcel &reply)
184 {
185     int32_t errCode = data.ReadInt32();
186     RestoreOnAllBundlesFinished(errCode);
187     return BError(BError::Codes::OK);
188 }
189 
CmdRestoreOnFileReady(MessageParcel & data,MessageParcel & reply)190 int32_t ServiceReverseStub::CmdRestoreOnFileReady(MessageParcel &data, MessageParcel &reply)
191 {
192     auto bundleName = data.ReadString();
193     auto fileName = data.ReadString();
194     int fd = INVALID_FD;
195     bool fdFlag = data.ReadBool();
196     if (fdFlag == true) {
197         fd = data.ReadFileDescriptor();
198     }
199     int32_t errCode = data.ReadInt32();
200     RestoreOnFileReady(bundleName, fileName, fd, errCode);
201     return BError(BError::Codes::OK);
202 }
203 
CmdRestoreOnResultReport(MessageParcel & data,MessageParcel & reply)204 int32_t ServiceReverseStub::CmdRestoreOnResultReport(MessageParcel &data, MessageParcel &reply)
205 {
206     std::string result;
207     if (!data.ReadString(result)) {
208         return BError(BError::Codes::EXT_INVAL_ARG, "Failed to read result").GetCode();
209     }
210     std::string bundleName;
211     if (!data.ReadString(bundleName)) {
212         return BError(BError::Codes::EXT_INVAL_ARG, "Failed to read bundleName").GetCode();
213     }
214     ErrCode errCode;
215     if (!data.ReadInt32(errCode)) {
216         return BError(BError::Codes::EXT_INVAL_ARG, "Failed to read errCode").GetCode();
217     }
218     RestoreOnResultReport(result, bundleName, errCode);
219     return BError(BError::Codes::OK);
220 }
221 
CmdRestoreOnProcessInfo(MessageParcel & data,MessageParcel & reply)222 int32_t ServiceReverseStub::CmdRestoreOnProcessInfo(MessageParcel &data, MessageParcel &reply)
223 {
224     std::string bundleName = data.ReadString();
225     std::string processInfo = data.ReadString();
226     RestoreOnProcessInfo(bundleName, processInfo);
227     return BError(BError::Codes::OK);
228 }
229 
CmdIncrementalBackupOnFileReady(MessageParcel & data,MessageParcel & reply)230 int32_t ServiceReverseStub::CmdIncrementalBackupOnFileReady(MessageParcel &data, MessageParcel &reply)
231 {
232     auto bundleName = data.ReadString();
233     auto fileName = data.ReadString();
234     int fd = INVALID_FD;
235     int manifestFd = INVALID_FD;
236     bool fdFlag = data.ReadBool();
237     if (fdFlag == true) {
238         fd = data.ReadFileDescriptor();
239         manifestFd = data.ReadFileDescriptor();
240     }
241     int32_t errCode = data.ReadInt32();
242     IncrementalBackupOnFileReady(bundleName, fileName, fd, manifestFd, errCode);
243     return BError(BError::Codes::OK);
244 }
245 
CmdIncrementalBackupOnBundleStarted(MessageParcel & data,MessageParcel & reply)246 int32_t ServiceReverseStub::CmdIncrementalBackupOnBundleStarted(MessageParcel &data, MessageParcel &reply)
247 {
248     int32_t errCode = data.ReadInt32();
249     auto bundleName = data.ReadString();
250     IncrementalBackupOnBundleStarted(errCode, bundleName);
251     return BError(BError::Codes::OK);
252 }
253 
CmdIncrementalBackupOnResultReport(MessageParcel & data,MessageParcel & reply)254 int32_t ServiceReverseStub::CmdIncrementalBackupOnResultReport(MessageParcel &data, MessageParcel &reply)
255 {
256     std::string result = data.ReadString();
257     std::string bundleName = data.ReadString();
258     IncrementalBackupOnResultReport(result, bundleName);
259     return BError(BError::Codes::OK);
260 }
261 
CmdIncrementalBackupOnBundleFinished(MessageParcel & data,MessageParcel & reply)262 int32_t ServiceReverseStub::CmdIncrementalBackupOnBundleFinished(MessageParcel &data, MessageParcel &reply)
263 {
264     int32_t errCode = data.ReadInt32();
265     auto bundleName = data.ReadString();
266     IncrementalBackupOnBundleFinished(errCode, bundleName);
267     return BError(BError::Codes::OK);
268 }
269 
CmdIncrementalBackupOnAllBundlesFinished(MessageParcel & data,MessageParcel & reply)270 int32_t ServiceReverseStub::CmdIncrementalBackupOnAllBundlesFinished(MessageParcel &data, MessageParcel &reply)
271 {
272     int32_t errCode = data.ReadInt32();
273     IncrementalBackupOnAllBundlesFinished(errCode);
274     return BError(BError::Codes::OK);
275 }
276 
CmdIncrementalBackupOnProcessInfo(MessageParcel & data,MessageParcel & reply)277 int32_t ServiceReverseStub::CmdIncrementalBackupOnProcessInfo(MessageParcel &data, MessageParcel &reply)
278 {
279     std::string bundleName = data.ReadString();
280     std::string processInfo = data.ReadString();
281     IncrementalBackupOnProcessInfo(bundleName, processInfo);
282     return BError(BError::Codes::OK);
283 }
284 
CmdIncrementalRestoreOnBundleStarted(MessageParcel & data,MessageParcel & reply)285 int32_t ServiceReverseStub::CmdIncrementalRestoreOnBundleStarted(MessageParcel &data, MessageParcel &reply)
286 {
287     int32_t errCode = data.ReadInt32();
288     auto bundleName = data.ReadString();
289     IncrementalRestoreOnBundleStarted(errCode, bundleName);
290     return BError(BError::Codes::OK);
291 }
292 
CmdIncrementalRestoreOnBundleFinished(MessageParcel & data,MessageParcel & reply)293 int32_t ServiceReverseStub::CmdIncrementalRestoreOnBundleFinished(MessageParcel &data, MessageParcel &reply)
294 {
295     int32_t errCode = data.ReadInt32();
296     auto bundleName = data.ReadString();
297     IncrementalRestoreOnBundleFinished(errCode, bundleName);
298     return BError(BError::Codes::OK);
299 }
300 
CmdIncrementalRestoreOnAllBundlesFinished(MessageParcel & data,MessageParcel & reply)301 int32_t ServiceReverseStub::CmdIncrementalRestoreOnAllBundlesFinished(MessageParcel &data, MessageParcel &reply)
302 {
303     int32_t errCode = data.ReadInt32();
304     IncrementalRestoreOnAllBundlesFinished(errCode);
305     return BError(BError::Codes::OK);
306 }
307 
CmdIncrementalRestoreOnFileReady(MessageParcel & data,MessageParcel & reply)308 int32_t ServiceReverseStub::CmdIncrementalRestoreOnFileReady(MessageParcel &data, MessageParcel &reply)
309 {
310     auto bundleName = data.ReadString();
311     auto fileName = data.ReadString();
312     int fd = INVALID_FD;
313     int manifestFd = INVALID_FD;
314     bool fdFlag = data.ReadBool();
315     if (fdFlag == true) {
316         fd = data.ReadFileDescriptor();
317         manifestFd = data.ReadFileDescriptor();
318     }
319     int32_t errCode = data.ReadInt32();
320     IncrementalRestoreOnFileReady(bundleName, fileName, fd, manifestFd, errCode);
321     return BError(BError::Codes::OK);
322 }
323 
CmdIncrementalRestoreOnResultReport(MessageParcel & data,MessageParcel & reply)324 int32_t ServiceReverseStub::CmdIncrementalRestoreOnResultReport(MessageParcel &data, MessageParcel &reply)
325 {
326     auto result = data.ReadString();
327     auto bundleName = data.ReadString();
328     ErrCode errCode = data.ReadInt32();
329     IncrementalRestoreOnResultReport(result, bundleName, errCode);
330     return BError(BError::Codes::OK);
331 }
332 
CmdIncrementalRestoreOnProcessInfo(MessageParcel & data,MessageParcel & reply)333 int32_t ServiceReverseStub::CmdIncrementalRestoreOnProcessInfo(MessageParcel &data, MessageParcel &reply)
334 {
335     auto bundleName = data.ReadString();
336     auto processInfo = data.ReadString();
337     IncrementalRestoreOnProcessInfo(bundleName, processInfo);
338     return BError(BError::Codes::OK);
339 }
340 } // namespace OHOS::FileManagement::Backup