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_client_proxy.h"
17 
18 #include <unistd.h>
19 #include "softbus_client_info_manager.h"
20 #include "softbus_def.h"
21 #include "softbus_errcode.h"
22 #include "softbus_trans_def.h"
23 #include "trans_client_proxy_standard.h"
24 #include "trans_log.h"
25 
26 using namespace OHOS;
27 
GetClientProxy(const char * pkgName,int32_t pid)28 static sptr<TransClientProxy> GetClientProxy(const char *pkgName, int32_t pid)
29 {
30     if (pkgName == nullptr) {
31         TRANS_LOGE(TRANS_CTRL, "pkgName is null");
32         return nullptr;
33     }
34     sptr<IRemoteObject> clientObject = SoftbusClientInfoManager::GetInstance().GetSoftbusClientProxy(pkgName, pid);
35     sptr<TransClientProxy> clientProxy = new (std::nothrow) TransClientProxy(clientObject);
36     return clientProxy;
37 }
38 
InformPermissionChange(int32_t state,const char * pkgName,int32_t pid)39 int32_t InformPermissionChange(int32_t state, const char *pkgName, int32_t pid)
40 {
41     if (pkgName == nullptr) {
42         TRANS_LOGE(TRANS_CTRL, "pkgName is null");
43         return SOFTBUS_INVALID_PKGNAME;
44     }
45     sptr<TransClientProxy> clientProxy = GetClientProxy(pkgName, pid);
46     if (clientProxy == nullptr) {
47         TRANS_LOGE(TRANS_CTRL, "softbus client proxy is nullptr!");
48         return SOFTBUS_TRANS_GET_CLIENT_PROXY_NULL;
49     }
50     return clientProxy->OnClientPermissonChange(pkgName, state);
51 }
52 
ClientIpcOnChannelOpened(const char * pkgName,const char * sessionName,const ChannelInfo * channel,int32_t pid)53 int32_t ClientIpcOnChannelOpened(const char *pkgName, const char *sessionName,
54     const ChannelInfo *channel, int32_t pid)
55 {
56     if (pid == getpid()) {
57         ISessionListener object;
58         if (SoftbusClientInfoManager::GetInstance().GetSoftbusInnerObject(pkgName, &object) != SOFTBUS_OK) {
59             return SOFTBUS_NOT_FIND;
60         }
61         return object.OnSessionOpened(channel->channelId, SOFTBUS_OK);
62     }
63     sptr<TransClientProxy> clientProxy = GetClientProxy(pkgName, pid);
64     if (clientProxy == nullptr) {
65         TRANS_LOGE(TRANS_CTRL, "softbus client proxy is nullptr!");
66         return SOFTBUS_TRANS_GET_CLIENT_PROXY_NULL;
67     }
68     return clientProxy->OnChannelOpened(sessionName, channel);
69 }
70 
ClientIpcOnChannelBind(ChannelMsg * data)71 int32_t ClientIpcOnChannelBind(ChannelMsg *data)
72 {
73     if (data == nullptr) {
74         TRANS_LOGE(TRANS_CTRL, "ClientIpcOnChannelBind data is nullptr!");
75         return SOFTBUS_INVALID_PARAM;
76     }
77     if (data->msgPid == getpid()) {
78         return SOFTBUS_OK;
79     }
80     sptr<TransClientProxy> clientProxy = GetClientProxy(data->msgPkgName, data->msgPid);
81     if (clientProxy == nullptr) {
82         TRANS_LOGE(TRANS_CTRL, "softbus client proxy is nullptr, msgPkgName=%{public}s, msgPid=%{public}d",
83             data->msgPkgName, data->msgPid);
84         return SOFTBUS_TRANS_GET_CLIENT_PROXY_NULL;
85     }
86     return clientProxy->OnChannelBind(data->msgChannelId, data->msgChannelType);
87 }
88 
ClientIpcOnChannelOpenFailed(ChannelMsg * data,int32_t errCode)89 int32_t ClientIpcOnChannelOpenFailed(ChannelMsg *data, int32_t errCode)
90 {
91     if (data == nullptr) {
92         TRANS_LOGE(TRANS_CTRL, "ClientIpcOnChannelOpenFailed data is nullptr!");
93         return SOFTBUS_INVALID_PARAM;
94     }
95     if (data->msgPid == getpid()) {
96         ISessionListener object;
97         if (SoftbusClientInfoManager::GetInstance().GetSoftbusInnerObject(data->msgPkgName, &object) != SOFTBUS_OK) {
98             return SOFTBUS_NOT_FIND;
99         }
100         return object.OnSessionOpened(data->msgChannelId, errCode);
101     }
102     sptr<TransClientProxy> clientProxy = GetClientProxy(data->msgPkgName, data->msgPid);
103     if (clientProxy == nullptr) {
104         TRANS_LOGE(TRANS_CTRL, "softbus client proxy is nullptr!");
105         return SOFTBUS_TRANS_GET_CLIENT_PROXY_NULL;
106     }
107     clientProxy->OnChannelOpenFailed(data->msgChannelId, data->msgChannelType, errCode);
108     return SOFTBUS_OK;
109 }
110 
ClientIpcOnChannelLinkDown(ChannelMsg * data,const char * networkId,const char * peerIp,int32_t routeType)111 int32_t ClientIpcOnChannelLinkDown(ChannelMsg *data, const char *networkId, const char *peerIp, int32_t routeType)
112 {
113     if (data == nullptr || networkId == nullptr) {
114         TRANS_LOGE(TRANS_CTRL, "ClientIpcOnChannelLinkDown data or networkId is nullptr!");
115         return SOFTBUS_INVALID_PARAM;
116     }
117     (void)peerIp;
118     sptr<TransClientProxy> clientProxy = GetClientProxy(data->msgPkgName, data->msgPid);
119     if (clientProxy == nullptr) {
120         TRANS_LOGE(TRANS_CTRL, "softbus client proxy is nullptr!");
121         return SOFTBUS_TRANS_GET_CLIENT_PROXY_NULL;
122     }
123     clientProxy->OnChannelLinkDown(networkId, routeType);
124     return SOFTBUS_OK;
125 }
126 
ClientIpcOnChannelClosed(ChannelMsg * data)127 int32_t ClientIpcOnChannelClosed(ChannelMsg *data)
128 {
129     if (data == nullptr) {
130         TRANS_LOGE(TRANS_CTRL, "ClientIpcOnChannelClosed data is nullptr!");
131         return SOFTBUS_TRANS_GET_CLIENT_PROXY_NULL;
132     }
133     if (data->msgPid == getpid()) {
134         ISessionListener object;
135         if (SoftbusClientInfoManager::GetInstance().GetSoftbusInnerObject(data->msgPkgName, &object) != SOFTBUS_OK) {
136             return SOFTBUS_NOT_FIND;
137         }
138         object.OnSessionClosed(data->msgChannelId);
139         return SOFTBUS_OK;
140     }
141     sptr<TransClientProxy> clientProxy = GetClientProxy(data->msgPkgName, data->msgPid);
142     if (clientProxy == nullptr) {
143         TRANS_LOGE(TRANS_CTRL, "softbus client proxy is nullptr!");
144         return SOFTBUS_TRANS_GET_CLIENT_PROXY_NULL;
145     }
146     int32_t ret = clientProxy->OnChannelClosed(data->msgChannelId, data->msgChannelType, data->msgMessageType);
147     if (ret != SOFTBUS_OK) {
148         TRANS_LOGE(TRANS_CTRL, "OnChannelClosed failed, ret=%{public}d", ret);
149         return ret;
150     }
151     return SOFTBUS_OK;
152 }
153 
ClientIpcSetChannelInfo(const char * pkgName,const char * sessionName,int32_t sessionId,const TransInfo * transInfo,int32_t pid)154 int32_t ClientIpcSetChannelInfo(
155     const char *pkgName, const char *sessionName, int32_t sessionId, const TransInfo *transInfo, int32_t pid)
156 {
157     if (pkgName == nullptr || sessionName == nullptr || transInfo == nullptr) {
158         TRANS_LOGE(TRANS_CTRL, "Invalid param");
159         return SOFTBUS_INVALID_PARAM;
160     }
161     sptr<TransClientProxy> clientProxy = GetClientProxy(pkgName, pid);
162     if (clientProxy == nullptr) {
163         TRANS_LOGE(TRANS_CTRL, "Softbus client proxy is nullptr!, pkgName=%{public}s pid=%{public}d", pkgName, pid);
164         return SOFTBUS_TRANS_GET_CLIENT_PROXY_NULL;
165     }
166     int32_t ret = clientProxy->SetChannelInfo(sessionName, sessionId, transInfo->channelId, transInfo->channelType);
167     if (ret != SOFTBUS_OK) {
168         TRANS_LOGE(TRANS_CTRL, "SetChannelInfo failed, ret=%{public}d", ret);
169         return ret;
170     }
171     return SOFTBUS_OK;
172 }
173 
ClientIpcOnChannelMsgReceived(ChannelMsg * data,TransReceiveData * receiveData)174 int32_t ClientIpcOnChannelMsgReceived(ChannelMsg *data, TransReceiveData *receiveData)
175 {
176     if (data == nullptr || receiveData == nullptr) {
177         TRANS_LOGE(TRANS_CTRL, "ClientIpcOnChannelMsgReceived data or receiveData is nullptr!");
178         return SOFTBUS_INVALID_PARAM;
179     }
180     if (data->msgPid == getpid()) {
181         ISessionListener object;
182         if (SoftbusClientInfoManager::GetInstance().GetSoftbusInnerObject(data->msgPkgName, &object) != SOFTBUS_OK) {
183             return SOFTBUS_NOT_FIND;
184         }
185         object.OnBytesReceived(data->msgChannelId, receiveData->data, receiveData->dataLen);
186         return SOFTBUS_OK;
187     }
188     sptr<TransClientProxy> clientProxy = GetClientProxy(data->msgPkgName, data->msgPid);
189     if (clientProxy == nullptr) {
190         TRANS_LOGE(TRANS_CTRL, "softbus client proxy is nullptr!");
191         return SOFTBUS_TRANS_GET_CLIENT_PROXY_NULL;
192     }
193     clientProxy->OnChannelMsgReceived(data->msgChannelId, data->msgChannelType,
194         receiveData->data, receiveData->dataLen, receiveData->dataType);
195     return SOFTBUS_OK;
196 }
197 
ClientIpcOnChannelQosEvent(const char * pkgName,const QosParam * param)198 int32_t ClientIpcOnChannelQosEvent(const char *pkgName, const QosParam *param)
199 {
200     sptr<TransClientProxy> clientProxy = GetClientProxy(pkgName, param->pid);
201     if (clientProxy == nullptr) {
202         TRANS_LOGE(TRANS_CTRL, "softbus client proxy is nullptr!");
203         return SOFTBUS_TRANS_GET_CLIENT_PROXY_NULL;
204     }
205     clientProxy->OnChannelQosEvent(param->channelId, param->channelType, param->eventId,
206         param->tvCount, param->tvList);
207     return SOFTBUS_OK;
208 }
209 
ClientIpcOnTransLimitChange(const char * pkgName,int32_t pid,int32_t channelId,uint8_t tos)210 int32_t ClientIpcOnTransLimitChange(const char *pkgName, int32_t pid, int32_t channelId, uint8_t tos)
211 {
212     if (pkgName == nullptr) {
213         TRANS_LOGE(TRANS_SDK, "invalid param.");
214         return SOFTBUS_INVALID_PARAM;
215     }
216     sptr<TransClientProxy> clientProxy = GetClientProxy(pkgName, pid);
217     if (clientProxy == nullptr) {
218         TRANS_LOGE(TRANS_SDK, "softbus client proxy is nullptr!");
219         return SOFTBUS_TRANS_GET_CLIENT_PROXY_NULL;
220     }
221 
222     return clientProxy->OnClientTransLimitChange(channelId, tos);
223 }
224 
CheckServiceIsRegistered(const char * pkgName,int32_t pid)225 int32_t CheckServiceIsRegistered(const char *pkgName, int32_t pid)
226 {
227     if (pkgName == nullptr) {
228         TRANS_LOGE(TRANS_SDK, "invalid param. ");
229         return SOFTBUS_INVALID_PARAM;
230     }
231     sptr<IRemoteObject> clientObject = SoftbusClientInfoManager::GetInstance().GetSoftbusClientProxy(pkgName, pid);
232     if (clientObject == nullptr) {
233         char *anonymizePkgName = nullptr;
234         Anonymize(pkgName, &anonymizePkgName);
235         TRANS_LOGE(TRANS_SDK, "softbus client proxy is nullptr! pkgname=%{public}s, pid=%{public}d",
236             AnonymizeWrapper(anonymizePkgName), pid);
237         AnonymizeFree(anonymizePkgName);
238         return SOFTBUS_TRANS_GET_CLIENT_PROXY_NULL;
239     }
240     return SOFTBUS_OK;
241 }
242 
ClientIpcChannelOnQos(ChannelMsg * data,QoSEvent event,const QosTV * qos,uint32_t count)243 int32_t ClientIpcChannelOnQos(ChannelMsg *data, QoSEvent event, const QosTV *qos, uint32_t count)
244 {
245     if (data == nullptr || data->msgPkgName == nullptr || qos == nullptr || count == 0 || count >= QOS_TYPE_BUTT) {
246         TRANS_LOGE(TRANS_SDK, "invalid param.");
247         return SOFTBUS_INVALID_PARAM;
248     }
249     sptr<TransClientProxy> clientProxy = GetClientProxy(data->msgPkgName, data->msgPid);
250     if (clientProxy == nullptr) {
251         TRANS_LOGE(TRANS_SDK, "softbus client proxy is nullptr!");
252         return SOFTBUS_TRANS_GET_CLIENT_PROXY_NULL;
253     }
254 
255     return clientProxy->OnClientChannelOnQos(data->msgChannelId, data->msgChannelType, event, qos, count);
256 }