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 "client_trans_stream.h"
17
18 #include "client_trans_session_manager.h"
19 #include "client_trans_socket_manager.h"
20 #include "client_trans_udp_stream_interface.h"
21 #include "session.h"
22 #include "softbus_error_code.h"
23 #include "softbus_utils.h"
24 #include "trans_log.h"
25 #include "trans_server_proxy.h"
26
27 static const UdpChannelMgrCb *g_udpChannelMgrCb = NULL;
28
RegisterStreamCb(const UdpChannelMgrCb * streamCb)29 void RegisterStreamCb(const UdpChannelMgrCb *streamCb)
30 {
31 if (streamCb == NULL || streamCb->OnUdpChannelOpened == NULL ||
32 streamCb->OnUdpChannelClosed == NULL || streamCb->OnStreamReceived == NULL) {
33 TRANS_LOGE(TRANS_STREAM, "udp channel callback is invalid");
34 return;
35 }
36
37 g_udpChannelMgrCb = streamCb;
38 }
39
UnregisterStreamCb(void)40 void UnregisterStreamCb(void)
41 {
42 g_udpChannelMgrCb = NULL;
43 }
44
SetStreamChannelStatus(int32_t channelId,int32_t status)45 static void SetStreamChannelStatus(int32_t channelId, int32_t status)
46 {
47 if (g_udpChannelMgrCb == NULL) {
48 TRANS_LOGE(TRANS_STREAM, "udp channel callback is null.");
49 return;
50 }
51
52 switch (status) {
53 case STREAM_CONNECTED:
54 TRANS_LOGI(TRANS_STREAM, "dstream connected. channelId=%{public}d", channelId);
55 break;
56 case STREAM_CLOSED:
57 TRANS_LOGI(TRANS_STREAM, "dstream closed. channelId=%{public}d", channelId);
58 break;
59 case STREAM_INIT:
60 TRANS_LOGI(TRANS_STREAM, "dstream init. channelId=%{public}d", channelId);
61 break;
62 case STREAM_OPENING:
63 TRANS_LOGI(TRANS_STREAM, "dstream opening. channelId=%{public}d", channelId);
64 break;
65 case STREAM_CONNECTING:
66 TRANS_LOGI(TRANS_STREAM, "dstream connecting. channelId=%{public}d", channelId);
67 break;
68 case STREAM_CLOSING:
69 TRANS_LOGI(TRANS_STREAM, "dstream closing. channelId=%{public}d", channelId);
70 break;
71 default:
72 TRANS_LOGE(TRANS_STREAM, "unsupport stream. channelId=%{public}d, status=%{public}d.", channelId, status);
73 break;
74 }
75 }
76
OnStreamReceived(int32_t channelId,const StreamData * data,const StreamData * ext,const StreamFrameInfo * param)77 static void OnStreamReceived(int32_t channelId, const StreamData *data, const StreamData *ext,
78 const StreamFrameInfo *param)
79 {
80 if ((g_udpChannelMgrCb == NULL) || (g_udpChannelMgrCb->OnStreamReceived == NULL)) {
81 TRANS_LOGE(TRANS_STREAM, "udp channel callback on stream received is null.");
82 return;
83 }
84
85 g_udpChannelMgrCb->OnStreamReceived(channelId, data, ext, param);
86 }
87
OnQosEvent(int channelId,int eventId,int tvCount,const QosTv * tvList)88 static void OnQosEvent(int channelId, int eventId, int tvCount, const QosTv *tvList)
89 {
90 if ((g_udpChannelMgrCb == NULL) || (g_udpChannelMgrCb->OnQosEvent == NULL)) {
91 return;
92 }
93 g_udpChannelMgrCb->OnQosEvent(channelId, eventId, tvCount, tvList);
94 }
95
OnFrameStats(int32_t channelId,const StreamSendStats * data)96 static void OnFrameStats(int32_t channelId, const StreamSendStats *data)
97 {
98 int32_t ret = ServerIpcStreamStats(channelId, CHANNEL_TYPE_UDP, data);
99 TRANS_LOGI(TRANS_STREAM, "notify frame stats to server, channelId=%{public}d", channelId);
100 if ((ret != SOFTBUS_OK) && (ret != SOFTBUS_NOT_IMPLEMENT)) {
101 TRANS_LOGE(TRANS_STREAM, "ipc to server fail, ret=%{public}d", ret);
102 return;
103 }
104 }
105
OnRippleStats(int32_t channelId,const TrafficStats * data)106 static void OnRippleStats(int32_t channelId, const TrafficStats *data)
107 {
108 int32_t ret = ServerIpcRippleStats(channelId, CHANNEL_TYPE_UDP, data);
109 TRANS_LOGI(TRANS_STREAM, "notify ripple stats to server, channelId=%{public}d", channelId);
110 if ((ret != SOFTBUS_OK) && (ret != SOFTBUS_NOT_IMPLEMENT)) {
111 TRANS_LOGE(TRANS_STREAM, "ipc to server fail, ret=%{public}d", ret);
112 return;
113 }
114 }
115
116 static IStreamListener g_streamCallcb = {
117 .OnStatusChange = SetStreamChannelStatus,
118 .OnStreamReceived = OnStreamReceived,
119 .OnQosEvent = OnQosEvent,
120 .OnFrameStats = OnFrameStats,
121 .OnRippleStats = OnRippleStats,
122 };
123
GetRawStreamEncryptOptByChannelId(int32_t sessionId,int32_t channelId,bool * isEncryptRawStream)124 static int32_t GetRawStreamEncryptOptByChannelId(int32_t sessionId, int32_t channelId, bool *isEncryptRawStream)
125 {
126 if (g_udpChannelMgrCb == NULL) {
127 TRANS_LOGE(TRANS_STREAM, "udp channel callback is null.");
128 return SOFTBUS_NO_INIT;
129 }
130 if (g_udpChannelMgrCb->OnRawStreamEncryptOptGet == NULL) {
131 TRANS_LOGE(TRANS_STREAM, "OnRawStreamEncryptOptGet of udp channel callback is null.");
132 return SOFTBUS_TRANS_UDP_CHANNEL_CALLBACK_NULL;
133 }
134 return g_udpChannelMgrCb->OnRawStreamEncryptOptGet(sessionId, channelId, isEncryptRawStream);
135 }
136
OnStreamUdpChannelOpened(int32_t channelId,SocketAccessInfo * accessInfo)137 static int32_t OnStreamUdpChannelOpened(int32_t channelId, SocketAccessInfo *accessInfo)
138 {
139 if ((g_udpChannelMgrCb == NULL) || (g_udpChannelMgrCb->OnUdpChannelOpened == NULL)) {
140 TRANS_LOGE(TRANS_STREAM, "udp channel callback on udp channel opened is null channelId=%{public}d", channelId);
141 return SOFTBUS_NO_INIT;
142 }
143
144 int32_t ret = g_udpChannelMgrCb->OnUdpChannelOpened(channelId, accessInfo);
145 if (ret != SOFTBUS_OK) {
146 TRANS_LOGE(TRANS_STREAM, "OnUdpChannelOpened fail, channelId=%{public}d, ret=%{public}d", channelId, ret);
147 return ret;
148 }
149
150 return SOFTBUS_OK;
151 }
152
TransOnstreamChannelOpened(const ChannelInfo * channel,int32_t * streamPort,SocketAccessInfo * accessInfo)153 int32_t TransOnstreamChannelOpened(const ChannelInfo *channel, int32_t *streamPort, SocketAccessInfo *accessInfo)
154 {
155 TRANS_LOGD(TRANS_STREAM, "enter.");
156 if (channel == NULL || streamPort == NULL) {
157 TRANS_LOGW(TRANS_STREAM, "invalid param.");
158 return SOFTBUS_INVALID_PARAM;
159 }
160 StreamType streamType = (StreamType)channel->streamType;
161 if (streamType != RAW_STREAM && streamType != COMMON_VIDEO_STREAM && streamType != COMMON_AUDIO_STREAM) {
162 TRANS_LOGE(TRANS_STREAM, "stream type invalid. type=%{public}d", channel->streamType);
163 return SOFTBUS_INVALID_PARAM;
164 }
165 bool isEncryptedRawStream = false;
166 int32_t ret = GetRawStreamEncryptOptByChannelId(channel->sessionId, channel->channelId, &isEncryptedRawStream);
167 if (ret != SOFTBUS_OK) {
168 TRANS_LOGE(TRANS_STREAM, "failed to get encryption option by channelId=%{public}d", channel->channelId);
169 return ret;
170 }
171 if (channel->isServer) {
172 if (IsSessionExceedLimit()) {
173 *streamPort = 0;
174 return SOFTBUS_TRANS_SESSION_CNT_EXCEEDS_LIMIT;
175 }
176
177 ret = OnStreamUdpChannelOpened(channel->channelId, accessInfo);
178 if (ret != SOFTBUS_OK) {
179 TRANS_LOGE(TRANS_STREAM, "OnUdpChannelOpened fail channelId=%{public}d", channel->channelId);
180 return ret;
181 }
182
183 VtpStreamOpenParam p1 = { "DSOFTBUS_STREAM", channel->myIp,
184 NULL, -1, streamType, (uint8_t*)channel->sessionKey, channel->keyLen, isEncryptedRawStream};
185
186 int32_t port = StartVtpStreamChannelServer(channel->channelId, &p1, &g_streamCallcb);
187 if (port <= 0) {
188 TRANS_LOGE(TRANS_STREAM, "start stream channel as server failed.");
189 return SOFTBUS_TRANS_UDP_START_STREAM_SERVER_FAILED;
190 }
191 *streamPort = port;
192 TRANS_LOGI(TRANS_STREAM, "stream server success, listen port=%{public}d.", port);
193 } else {
194 VtpStreamOpenParam p1 = { "DSOFTBUS_STREAM", channel->myIp, channel->peerIp,
195 channel->peerPort, streamType, (uint8_t *)channel->sessionKey, channel->keyLen, isEncryptedRawStream};
196
197 int32_t ret = StartVtpStreamChannelClient(channel->channelId, &p1, &g_streamCallcb);
198 if (ret <= 0) {
199 TRANS_LOGE(TRANS_STREAM, "start stream channel as client failed. ret=%{public}d", ret);
200 return SOFTBUS_TRANS_UDP_START_STREAM_CLIENT_FAILED;
201 }
202 TRANS_LOGI(TRANS_STREAM, "stream start client success.");
203 return OnStreamUdpChannelOpened(channel->channelId, accessInfo);
204 }
205 return SOFTBUS_OK;
206 }
207
TransSendStream(int32_t channelId,const StreamData * data,const StreamData * ext,const StreamFrameInfo * param)208 int32_t TransSendStream(int32_t channelId, const StreamData *data, const StreamData *ext, const StreamFrameInfo *param)
209 {
210 if (channelId < 0) {
211 TRANS_LOGE(TRANS_STREAM, "param faild");
212 return SOFTBUS_INVALID_PARAM;
213 }
214 return SendVtpStream(channelId, data, ext, param);
215 }
216
TransSetStreamMultiLayer(int32_t channelId,const void * optValue)217 int32_t TransSetStreamMultiLayer(int32_t channelId, const void *optValue)
218 {
219 if (channelId < 0) {
220 TRANS_LOGE(TRANS_STREAM, "param invalid channelId is %{public}d", channelId);
221 return SOFTBUS_INVALID_PARAM;
222 }
223 return SetVtpStreamMultiLayerOpt(channelId, optValue);
224 }
225
TransCloseStreamChannel(int32_t channelId)226 int32_t TransCloseStreamChannel(int32_t channelId)
227 {
228 TRANS_LOGI(TRANS_STREAM, "close stream channel. channelId=%{public}d", channelId);
229 int32_t ret = CloseVtpStreamChannel(channelId, "DSOFTBUS_STREAM");
230 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_STREAM, "close stream channel failed.");
231 return SOFTBUS_OK;
232 }
233