1 /*
2 * Copyright (c) 2021 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_udp_stream_interface.h"
17
18 #include <map>
19 #include <mutex>
20 #include <string>
21 #include <sys/types.h>
22
23 #include "securec.h"
24 #include "softbus_adapter_crypto.h"
25 #include "softbus_errcode.h"
26 #include "softbus_log.h"
27 #include "stream_adaptor.h"
28 #include "stream_adaptor_listener.h"
29 #include "stream_common.h"
30
31 using namespace OHOS;
32
33 namespace {
34 std::map<int, std::shared_ptr<StreamAdaptor>> g_adaptorMap;
35 std::mutex g_mutex;
36 }
37
SendVtpStream(int32_t channelId,const StreamData * indata,const StreamData * ext,const StreamFrameInfo * param)38 int32_t SendVtpStream(int32_t channelId, const StreamData *indata, const StreamData *ext, const StreamFrameInfo *param)
39 {
40 if (indata == nullptr || indata->buf == nullptr || param == nullptr) {
41 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "invalid argument!");
42 return SOFTBUS_ERR;
43 }
44 std::shared_ptr<StreamAdaptor> adaptor = nullptr;
45 {
46 std::lock_guard<std::mutex> lock(g_mutex);
47 auto it = g_adaptorMap.find(channelId);
48 if (it == g_adaptorMap.end()) {
49 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "adaptor not existed!");
50 return SOFTBUS_ERR;
51 }
52 adaptor = it->second;
53 }
54
55 std::unique_ptr<IStream> stream = nullptr;
56 if (adaptor->GetStreamType() == RAW_STREAM) {
57 ssize_t dataLen = indata->bufLen + adaptor->GetEncryptOverhead();
58 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_DBG,
59 "bufLen = %zd, GetEncryptOverhead() = %zd", indata->bufLen, adaptor->GetEncryptOverhead());
60 std::unique_ptr<char[]> data = std::make_unique<char[]>(dataLen);
61 ssize_t encLen = adaptor->Encrypt(indata->buf, indata->bufLen, data.get(), dataLen, adaptor->GetSessionKey());
62 if (encLen != dataLen) {
63 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR,
64 "encrypted failed, dataLen = %zd, encryptLen = %zd", dataLen, encLen);
65 return SOFTBUS_ERR;
66 }
67
68 stream = IStream::MakeRawStream(data.get(), dataLen, {}, Communication::SoftBus::Scene::SOFTBUS_SCENE);
69 } else if (adaptor->GetStreamType() == COMMON_VIDEO_STREAM || adaptor->GetStreamType() == COMMON_AUDIO_STREAM) {
70 Communication::SoftBus::StreamData data = {
71 .buffer = std::make_unique<char[]>(indata->bufLen),
72 .bufLen = indata->bufLen,
73 .extBuffer = std::make_unique<char[]>(ext->bufLen),
74 .extLen = ext->bufLen,
75 };
76
77 int ret = memcpy_s(data.buffer.get(), data.bufLen, indata->buf, indata->bufLen);
78 if (ret != SOFTBUS_OK) {
79 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "Failed to memcpy data!, %d", ret);
80 return SOFTBUS_ERR;
81 }
82 ret = memcpy_s(data.extBuffer.get(), data.extLen, ext->buf, ext->bufLen);
83 if (ret != SOFTBUS_OK) {
84 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "Failed to memcpy ext!, %d", ret);
85 return SOFTBUS_ERR;
86 }
87 stream = IStream::MakeCommonStream(data, {});
88 } else {
89 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "Do not support");
90 }
91
92 if (stream == nullptr) {
93 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "make stream failed, stream is nullptr");
94 return SOFTBUS_ERR;
95 }
96 return adaptor->GetStreamManager()->Send(std::move(stream)) ? SOFTBUS_OK : SOFTBUS_ERR;
97 }
98
StartVtpStreamChannelServer(int32_t channelId,const VtpStreamOpenParam * param,const IStreamListener * callback)99 int32_t StartVtpStreamChannelServer(int32_t channelId, const VtpStreamOpenParam *param, const IStreamListener *callback)
100 {
101 if (channelId < 0 || param == nullptr || param->pkgName == nullptr || callback == nullptr) {
102 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "StartVtpStreamChannelServer invalid channelId or pkgName");
103 return SOFTBUS_ERR;
104 }
105 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "cId=%d Start Channel Server.", channelId);
106 int32_t ret = SOFTBUS_ERR;
107 auto it = g_adaptorMap.find(channelId);
108 if (it != g_adaptorMap.end()) {
109 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_WARN, "adaptor already existed!");
110 return SOFTBUS_ERR;
111 }
112
113 {
114 std::lock_guard<std::mutex> lock(g_mutex);
115 it = g_adaptorMap.find(channelId);
116 if (it == g_adaptorMap.end()) {
117 std::string pkgStr(param->pkgName);
118 it = g_adaptorMap.emplace(std::pair<int, std::shared_ptr<StreamAdaptor>>(channelId,
119 std::make_shared<StreamAdaptor>(pkgStr))).first;
120 } else {
121 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_WARN, "adaptor already existed!");
122 return SOFTBUS_ERR;
123 }
124 }
125
126 auto newAdaptor = it->second;
127 newAdaptor->InitAdaptor(channelId, param, true, callback);
128
129 Communication::SoftBus::IpAndPort ipPort;
130 ipPort.ip = param->myIp;
131 ipPort.port = 0;
132 ret = newAdaptor->GetStreamManager()->CreateStreamServerChannel(ipPort,
133 Communication::SoftBus::VTP, param->type, param->sessionKey);
134 if (ret > 0) {
135 newAdaptor->SetAliveState(true);
136 } else {
137 CloseVtpStreamChannel(channelId, param->pkgName);
138 }
139
140 return ret;
141 }
142
StartVtpStreamChannelClient(int32_t channelId,const VtpStreamOpenParam * param,const IStreamListener * callback)143 int32_t StartVtpStreamChannelClient(int32_t channelId, const VtpStreamOpenParam *param, const IStreamListener *callback)
144 {
145 if (channelId < 0 || param == nullptr || param->pkgName == nullptr || callback == nullptr) {
146 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "invalid channelId or pkgName");
147 return SOFTBUS_ERR;
148 }
149
150 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "StartChannelClient cId=%d.", channelId);
151 auto it = g_adaptorMap.find(channelId);
152 if (it != g_adaptorMap.end()) {
153 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_WARN, "adaptor already existed!");
154 return SOFTBUS_ERR;
155 }
156
157 {
158 std::lock_guard<std::mutex> lock(g_mutex);
159 it = g_adaptorMap.find(channelId);
160 if (it == g_adaptorMap.end()) {
161 std::string pkgStr(param->pkgName);
162 it = g_adaptorMap.emplace(std::pair<int, std::shared_ptr<StreamAdaptor>>(channelId,
163 std::make_shared<StreamAdaptor>(pkgStr))).first;
164 } else {
165 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_WARN, "adaptor already existed!");
166 return SOFTBUS_ERR;
167 }
168 }
169
170 auto newAdaptor = it->second;
171 newAdaptor->InitAdaptor(channelId, param, false, callback);
172
173 Communication::SoftBus::IpAndPort ipPort;
174 ipPort.ip = param->myIp;
175 ipPort.port = 0;
176
177 Communication::SoftBus::IpAndPort peerIpPort;
178 peerIpPort.ip = param->peerIp;
179 peerIpPort.port = param->peerPort;
180
181 int32_t ret = newAdaptor->GetStreamManager()->CreateStreamClientChannel(ipPort, peerIpPort,
182 Communication::SoftBus::VTP, param->type, param->sessionKey);
183 if (ret > 0) {
184 newAdaptor->SetAliveState(true);
185 } else {
186 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "CreateStreamClientChannel failed, ret:%d", ret);
187 CloseVtpStreamChannel(channelId, param->pkgName);
188 }
189
190 return ret;
191 }
192
CloseVtpStreamChannel(int32_t channelId,const char * pkgName)193 int32_t CloseVtpStreamChannel(int32_t channelId, const char *pkgName)
194 {
195 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "close stream channelid=%d", channelId);
196 std::shared_ptr<StreamAdaptor> adaptor = nullptr;
197
198 if (channelId < 0 || pkgName == nullptr) {
199 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "invalid channelId or pkgName");
200 return SOFTBUS_ERR;
201 }
202
203 {
204 std::lock_guard<std::mutex> lock(g_mutex);
205 auto it = g_adaptorMap.find(channelId);
206 if (it == g_adaptorMap.end()) {
207 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "adaptor not existed!");
208 return SOFTBUS_ERR;
209 }
210 adaptor = it->second;
211 g_adaptorMap.erase(it);
212 }
213
214 bool alive = adaptor->GetAliveState();
215 if (!alive) {
216 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "VtpStreamChannel already closed");
217 return SOFTBUS_ERR;
218 }
219
220 adaptor->ReleaseAdaptor();
221
222 return SOFTBUS_OK;
223 }
224
225