1 /*
2  * Copyright (c) 2021-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 "trans_server_stub.h"
17 
18 #include "ipc_skeleton.h"
19 #include "lnn_connection_addr_utils.h"
20 #include "securec.h"
21 #include "softbus_common.h"
22 #include "softbus_conn_interface.h"
23 #include "softbus_errcode.h"
24 #include "softbus_permission.h"
25 #include "softbus_proxychannel_manager.h"
26 #include "softbus_trans_def.h"
27 #include "trans_auth_manager.h"
28 #include "trans_channel_manager.h"
29 #include "trans_log.h"
30 #include "trans_session_manager.h"
31 #include "trans_session_service.h"
32 
ServerCreateSessionServer(IpcIo * req,IpcIo * reply)33 int32_t ServerCreateSessionServer(IpcIo *req, IpcIo *reply)
34 {
35     TRANS_LOGI(TRANS_CTRL, "ipc server pop");
36     if (req == NULL || reply == NULL) {
37         TRANS_LOGW(TRANS_CTRL, "invalid param");
38         return SOFTBUS_INVALID_PARAM;
39     }
40     uint32_t size;
41     const char *pkgName = (const char*)ReadString(req, &size);
42     if (pkgName == NULL) {
43         TRANS_LOGE(TRANS_CTRL, "ServerCreateSessionServer pkgName is null");
44         return SOFTBUS_ERR;
45     }
46     const char *sessionName = (const char *)ReadString(req, &size);
47     if (sessionName == NULL) {
48         TRANS_LOGE(TRANS_CTRL, "sessionName pkgName is null");
49         return SOFTBUS_ERR;
50     }
51     int32_t callingUid = GetCallingUid();
52     int32_t callingPid = GetCallingPid();
53     if (CheckTransPermission(callingUid, callingPid, pkgName, sessionName, ACTION_CREATE) != SOFTBUS_OK) {
54         TRANS_LOGE(TRANS_CTRL, "no permission");
55         WriteInt32(reply, SOFTBUS_PERMISSION_DENIED);
56         return SOFTBUS_PERMISSION_DENIED;
57     }
58     int32_t ret = TransCreateSessionServer(pkgName, sessionName, callingUid, callingPid);
59     (void)WriteInt32(reply, ret);
60     return ret;
61 }
62 
ServerRemoveSessionServer(IpcIo * req,IpcIo * reply)63 int32_t ServerRemoveSessionServer(IpcIo *req, IpcIo *reply)
64 {
65     TRANS_LOGI(TRANS_CTRL, "ipc server pop");
66     if (req == NULL || reply == NULL) {
67         TRANS_LOGW(TRANS_CTRL, "invalid param");
68         return SOFTBUS_INVALID_PARAM;
69     }
70     uint32_t size;
71     const char *pkgName = (const char*)ReadString(req, &size);
72     if (pkgName == NULL) {
73         TRANS_LOGE(TRANS_CTRL, "ServerRemoveSessionServer pkgName is null");
74         return SOFTBUS_ERR;
75     }
76     const char *sessionName = (const char *)ReadString(req, &size);
77     if (sessionName == NULL) {
78         TRANS_LOGE(TRANS_CTRL, "ServerRemoveSessionServer sessionName is null");
79         return SOFTBUS_ERR;
80     }
81     int32_t callingUid = GetCallingUid();
82     int32_t callingPid = GetCallingPid();
83     if (CheckTransPermission(callingUid, callingPid, pkgName, sessionName, ACTION_CREATE) != SOFTBUS_OK) {
84         TRANS_LOGE(TRANS_CTRL, "no permission");
85         WriteInt32(reply, SOFTBUS_PERMISSION_DENIED);
86         return SOFTBUS_PERMISSION_DENIED;
87     }
88     int32_t ret = TransRemoveSessionServer(pkgName, sessionName);
89     WriteInt32(reply, ret);
90     return ret;
91 }
92 
CheckOpenSessionPremission(const char * sessionName,const char * peerSessionName)93 static int32_t CheckOpenSessionPremission(const char *sessionName, const char *peerSessionName)
94 {
95     char pkgName[PKG_NAME_SIZE_MAX] = {0};
96     if (TransGetPkgNameBySessionName(sessionName, pkgName, PKG_NAME_SIZE_MAX) != SOFTBUS_OK) {
97         TRANS_LOGE(TRANS_CTRL, "TransGetPkgNameBySessionName failed");
98         return SOFTBUS_INVALID_PARAM;
99     }
100 
101     int32_t callingUid = GetCallingUid();
102     int32_t callingPid = GetCallingPid();
103     if (CheckTransPermission(callingUid, callingPid, pkgName, sessionName, ACTION_OPEN) != SOFTBUS_OK) {
104         TRANS_LOGE(TRANS_CTRL, "no permission");
105         return SOFTBUS_PERMISSION_DENIED;
106     }
107 
108     if (CheckTransSecLevel(sessionName, peerSessionName) != SOFTBUS_OK) {
109         TRANS_LOGE(TRANS_CTRL, "sec level invalid");
110         return SOFTBUS_PERMISSION_DENIED;
111     }
112     return SOFTBUS_OK;
113 }
114 
ServerReadSessionAttrs(IpcIo * req,SessionAttribute * getAttr)115 static void ServerReadSessionAttrs(IpcIo *req, SessionAttribute *getAttr)
116 {
117     if (getAttr == NULL || req == NULL) {
118         TRANS_LOGE(TRANS_CTRL, "getAttr and req is NULL");
119         return;
120     }
121     LinkType *pGetArr = NULL;
122 
123     if (!ReadInt32(req, &getAttr->dataType)) {
124         TRANS_LOGE(TRANS_CTRL, "read dataType failed");
125         return;
126     }
127 
128     if (!ReadInt32(req, &getAttr->linkTypeNum)) {
129         TRANS_LOGE(TRANS_CTRL, "read linkTypeNum failed");
130         return;
131     }
132 
133     if (getAttr->linkTypeNum > 0) {
134         pGetArr = (LinkType *)ReadBuffer(req, sizeof(LinkType) * getAttr->linkTypeNum);
135     }
136 
137     if (pGetArr != NULL && getAttr->linkTypeNum <= LINK_TYPE_MAX) {
138         (void)memcpy_s(getAttr->linkType, sizeof(LinkType) * LINK_TYPE_MAX,
139                        pGetArr, sizeof(LinkType) * getAttr->linkTypeNum);
140     }
141 
142     if (!ReadInt32(req, &getAttr->attr.streamAttr.streamType)) {
143         TRANS_LOGE(TRANS_CTRL, "read streamType failed");
144         return;
145     }
146 
147     if (!ReadUint16(req, &getAttr->fastTransDataSize)) {
148         TRANS_LOGE(TRANS_CTRL, "read fastTransDataSize failed");
149         return;
150     }
151 
152     if (getAttr->fastTransDataSize != 0) {
153         getAttr->fastTransData = (uint8_t *)ReadRawData(req, getAttr->fastTransDataSize);
154     }
155 }
156 
ReadQosInfo(IpcIo * req,SessionParam * param)157 static bool ReadQosInfo(IpcIo *req, SessionParam *param)
158 {
159     if (req == NULL || param == NULL) {
160         TRANS_LOGE(TRANS_CTRL, "param or req is NULL");
161         return false;
162     }
163 
164     if (!ReadBool(req, &param->isQosLane)) {
165         TRANS_LOGE(TRANS_SDK, "read qos flag failed!");
166         return false;
167     }
168 
169     if (!param->isQosLane) {
170         return true;
171     }
172 
173     if (!ReadUint32(req, &param->qosCount)) {
174         TRANS_LOGE(TRANS_SDK, "read count of qos failed!");
175         return false;
176     }
177 
178     if (param->qosCount == 0) {
179         return true;
180     }
181 
182     if (param->qosCount > QOS_TYPE_BUTT) {
183         TRANS_LOGE(TRANS_SDK, "read invalid qosCount=%{public}" PRIu32, param->qosCount);
184         return false;
185     }
186 
187     const QosTV *qosInfo = (QosTV *)ReadBuffer(req, sizeof(QosTV) * param->qosCount);
188     if (qosInfo == NULL) {
189         COMM_LOGE(COMM_SVC, "failed to read qos data");
190         return false;
191     }
192 
193     if (memcpy_s(param->qos, sizeof(QosTV) * QOS_TYPE_BUTT, qosInfo, sizeof(QosTV) * param->qosCount) != EOK) {
194         COMM_LOGE(COMM_SVC, "failed memcpy qos info");
195         return false;
196     }
197 
198     return true;
199 }
200 
ServerOpenSession(IpcIo * req,IpcIo * reply)201 int32_t ServerOpenSession(IpcIo *req, IpcIo *reply)
202 {
203     TRANS_LOGI(TRANS_CTRL, "ipc server pop");
204     if (req == NULL || reply == NULL) {
205         TRANS_LOGW(TRANS_CTRL, "invalid param");
206         return SOFTBUS_INVALID_PARAM;
207     }
208 
209     int32_t ret;
210     uint32_t size;
211     SessionParam param;
212     SessionAttribute getAttr;
213     (void)memset_s(&param, sizeof(SessionParam), 0, sizeof(SessionParam));
214     (void)memset_s(&getAttr, sizeof(SessionAttribute), 0, sizeof(SessionAttribute));
215     TransSerializer transSerializer;
216     transSerializer.transInfo.channelId = INVALID_CHANNEL_ID;
217     transSerializer.transInfo.channelType = CHANNEL_TYPE_BUTT;
218     param.sessionName = (const char*)ReadString(req, &size);
219     param.peerSessionName = (const char *)ReadString(req, &size);
220     param.peerDeviceId = (const char *)ReadString(req, &size);
221     param.groupId = (const char *)ReadString(req, &size);
222     ReadBool(req, &param.isAsync);
223     ReadInt32(req, &param.sessionId);
224     ServerReadSessionAttrs(req, &getAttr);
225     param.attr = &getAttr;
226     if (!ReadQosInfo(req, &param)) {
227         TRANS_LOGE(TRANS_CTRL, "failed to read qos info");
228         return SOFTBUS_IPC_ERR;
229     }
230 
231     ret = CheckOpenSessionPremission(param.sessionName, param.peerSessionName);
232     if (ret != SOFTBUS_OK) {
233         transSerializer.ret = ret;
234         WriteUint32(reply, sizeof(TransSerializer));
235         bool value = WriteBuffer(reply, (void *)&transSerializer, sizeof(TransSerializer));
236         if (!value) {
237             return SOFTBUS_ERR;
238         }
239         return ret;
240     }
241 
242     ret = TransOpenSession(&param, &(transSerializer.transInfo));
243     transSerializer.ret = ret;
244     WriteUint32(reply, sizeof(TransSerializer));
245     bool value = WriteBuffer(reply, (void *)&transSerializer, sizeof(TransSerializer));
246     if (!value) {
247         return SOFTBUS_ERR;
248     }
249     return ret;
250 }
251 
ServerOpenAuthSession(IpcIo * req,IpcIo * reply)252 int32_t ServerOpenAuthSession(IpcIo *req, IpcIo *reply)
253 {
254     TRANS_LOGD(TRANS_CTRL, "ipc server pop");
255     if (req == NULL || reply == NULL) {
256         TRANS_LOGW(TRANS_CTRL, "invalid param");
257         return SOFTBUS_INVALID_PARAM;
258     }
259     int32_t ret;
260     uint32_t size;
261     ConnectOption connOpt;
262     const char *sessionName = (const char*)ReadString(req, &size);
263     ConnectionAddr *addr = (ConnectionAddr *)ReadRawData(req, sizeof(ConnectionAddr));
264     if (!LnnConvertAddrToOption(addr, &connOpt)) {
265         TRANS_LOGE(TRANS_CTRL, "LnnConvertAddrToOption fail");
266         WriteInt32(reply, SOFTBUS_ERR);
267         return SOFTBUS_ERR;
268     }
269     ret = CheckOpenSessionPremission(sessionName, sessionName);
270     if (ret != SOFTBUS_OK) {
271         WriteInt32(reply, ret);
272         return ret;
273     }
274     ret = TransOpenAuthChannel(sessionName, &connOpt, "");
275     WriteInt32(reply, ret);
276     return ret;
277 }
278 
ServerNotifyAuthSuccess(IpcIo * req,IpcIo * reply)279 int32_t ServerNotifyAuthSuccess(IpcIo *req, IpcIo *reply)
280 {
281     TRANS_LOGI(TRANS_CTRL, "ipc server pop");
282     if (req == NULL || reply == NULL) {
283         TRANS_LOGW(TRANS_CTRL, "invalid param");
284         return SOFTBUS_INVALID_PARAM;
285     }
286     int32_t channelId = 0;
287     int32_t channelType = -1;
288     ReadInt32(req, &channelId);
289     ReadInt32(req, &channelType);
290     int32_t callingUid = GetCallingUid();
291     int32_t callingPid = GetCallingPid();
292     char pkgName[PKG_NAME_SIZE_MAX];
293     char sessionName[SESSION_NAME_SIZE_MAX];
294     if (TransAuthGetNameByChanId(channelId, pkgName, sessionName,
295         PKG_NAME_SIZE_MAX, SESSION_NAME_SIZE_MAX) != SOFTBUS_OK) {
296         TRANS_LOGE(TRANS_CTRL, "get session name fail");
297         WriteInt32(reply, SOFTBUS_TRANS_UDP_INVALID_CHANNEL_ID);
298         return SOFTBUS_TRANS_UDP_INVALID_CHANNEL_ID;
299     }
300     if (CheckTransPermission(callingUid, callingPid, pkgName, sessionName, ACTION_OPEN) != SOFTBUS_OK) {
301         TRANS_LOGE(TRANS_CTRL, "ServerCloseChannel no permission");
302         WriteInt32(reply, SOFTBUS_PERMISSION_DENIED);
303         return SOFTBUS_PERMISSION_DENIED;
304     }
305 
306     int32_t ret = TransNotifyAuthSuccess(channelId, channelType);
307     WriteInt32(reply, ret);
308     return ret;
309 }
310 
ServerCloseChannel(IpcIo * req,IpcIo * reply)311 int32_t ServerCloseChannel(IpcIo *req, IpcIo *reply)
312 {
313     TRANS_LOGI(TRANS_CTRL, "ipc server pop");
314     if (req == NULL || reply == NULL) {
315         TRANS_LOGW(TRANS_CTRL, "invalid param");
316         return SOFTBUS_INVALID_PARAM;
317     }
318 
319     int32_t ret;
320     int32_t channelId = 0;
321     int32_t channelType = 0;
322     const char *sessionName = NULL;
323     uint32_t size;
324     ReadInt32(req, &channelId);
325     ReadInt32(req, &channelType);
326     if (channelType == CHANNEL_TYPE_UNDEFINED) {
327         sessionName = (const char*)ReadString(req, &size);
328         if (sessionName == NULL) {
329             TRANS_LOGE(TRANS_CTRL, "ServerCloseChannel sessionName is null");
330             return SOFTBUS_IPC_ERR;
331         }
332     }
333     ret = TransCloseChannel(sessionName, channelId, channelType);
334 
335     WriteInt32(reply, ret);
336     return ret;
337 }
338 
ServerSendSessionMsg(IpcIo * req,IpcIo * reply)339 int32_t ServerSendSessionMsg(IpcIo *req, IpcIo *reply)
340 {
341     TRANS_LOGI(TRANS_CTRL, "ipc server pop");
342     if (req == NULL || reply == NULL) {
343         TRANS_LOGW(TRANS_CTRL, "invalid param");
344         return SOFTBUS_INVALID_PARAM;
345     }
346     int32_t channelId = 0;
347     int32_t channelType = 0;
348     int32_t msgType = 0;
349     (void)ReadInt32(req, &channelId);
350     (void)ReadInt32(req, &channelType);
351     (void)ReadInt32(req, &msgType);
352     uint32_t size = 0;
353     ReadUint32(req, &size);
354     const void *data = (const void *)ReadBuffer(req, size);
355     int32_t ret = TransSendMsg(channelId, channelType, data, size, msgType);
356     WriteInt32(reply, ret);
357     return ret;
358 }
359 
ServerReleaseResources(IpcIo * req,IpcIo * reply)360 int32_t ServerReleaseResources(IpcIo *req, IpcIo *reply)
361 {
362     TRANS_LOGI(TRANS_CTRL, "ipc server pop");
363     if (req == NULL || reply == NULL) {
364         TRANS_LOGW(TRANS_CTRL, "invalid param");
365         return SOFTBUS_INVALID_PARAM;
366     }
367     int32_t channelId = 0;
368     if (!ReadInt32(req, &channelId)) {
369         TRANS_LOGE(TRANS_CTRL, "failed to read channelId");
370         return SOFTBUS_IPC_ERR;
371     }
372 
373     int32_t ret = TransReleaseUdpResources(channelId);
374     return ret;
375 }
376