1 /*
2 * Copyright (c) 2025-2026 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 #include "urspconfig.h"
16 #include "cellular_data_client.h"
17 #include "hwnetworkslicemanager.h"
18 #include "networkslicemanager.h"
19 #include <parameters.h>
20 namespace OHOS {
21 namespace NetManagerStandard {
22 static std::string DEFAULT_NETSLICE_CONFIG_DIR = "/system/profile/";
23 static std::string URSP_FILENAME1 = "UrspConfig1.xml";
24 static std::string URSP_FILENAME2 = "UrspConfig2.xml";
25 const std::string COMMA_SEPARATOR = ",";
26 const std::string PORT_RANGE_SEPARATOR = "-";
27 const std::string TAG_UEPOLICY = "uePolicy";
28 const std::string TAG_PRECONFIGURSP = "preConfigUrsp";
29 const std::string TAG_TRAFFICDESCRIPTOR = "trafficDescriptor";
30 const std::string TAG_ROUTESELECTIONDESCRIPTOR = "routeSelectionDescriptor";
31 const std::string TAG_ROUTESELECTIONDESCRIPTORCONTENTS = "routeSelectionDescriptorContents";
32 const std::string ATTR_PLMN = "plmn";
33 const std::string ATTR_URSPPRECEDENCE = "precedence";
34 const std::string ATTR_TRAFFICDESCRIPTORTYPE = "trafficDescriptorComponentTypeIdentifier";
35 const std::string ATTR_TRAFFICDESCRIPTORVALUE = "trafficDescriptorComponentValue";
36 const std::string ATTR_ROUTEPRECEDENCE = "precedenceValueOfRouteSelectionDescriptor";
37 const std::string ATTR_RSDTYPE = "routeSelectionDescriptorComponentTypeIdentifier";
38 const std::string ATTR_RSDVALUE = "routeSelectionDescriptorComponentValue";
39 const std::string NETWORKSLICE_WHITELIST = "networkslice_whitelist";
40 constexpr int URSPFILE_ID2 = 2;
41 constexpr int MODEM_ID = 0;
42 constexpr int BASE_16 = 16;
43 constexpr int DECODE_FAIL_UNKNOWN_IDENTIFIER = 1;
44 constexpr int DECODE_SUCCESS = 0;
45 constexpr int DECODE_FAIL_OTHER = -1;
46 constexpr int PREFERRED_ACCESS_TYPE_NON_3GPP = 0x10;
47 constexpr int FIRSTBYTE = 1;
48 constexpr int SECONDBYTE = 2;
49 constexpr int THIRDBYTE = 3;
50 /**
51 * traffic descriptor component
52 */
53 constexpr int TRAFFIC_DESCRIPTOR_COMPONENT_MATCH_ALL = 0x01;
54 constexpr int TRAFFIC_DESCRIPTOR_COMPONENT_OS_ID_OS_APP_ID = 0x08;
55 constexpr int TRAFFIC_DESCRIPTOR_COMPONENT_IPV4_ADDR = 0x10;
56 constexpr int TRAFFIC_DESCRIPTOR_COMPONENT_IPV6_ADDR = 0x21;
57 constexpr int TRAFFIC_DESCRIPTOR_COMPONENT_PROTOCOL_ID = 0x30;
58 constexpr int TRAFFIC_DESCRIPTOR_COMPONENT_SINGLE_REMOTE_PORT = 0x50;
59 constexpr int TRAFFIC_DESCRIPTOR_COMPONENT_REMOTE_PORT_RANGE = 0x51;
60 constexpr int TRAFFIC_DESCRIPTOR_COMPONENT_DNN = 0x88;
61 constexpr int TRAFFIC_DESCRIPTOR_COMPONENT_CONNECTION_CAPABILITY = 0x90;
62 constexpr int TRAFFIC_DESCRIPTOR_COMPONENT_FQDN = 0x91;
63 constexpr int TRAFFIC_DESCRIPTOR_COMPONENT_OS_APP_ID = 0xA0;
64
65 /**
66 * route selection descriptor
67 */
68 constexpr int ROUTE_SELECTION_DESCRIPTOR_COMPONENT_SSC_MODE_TYPE = 1;
69 constexpr int ROUTE_SELECTION_DESCRIPTOR_COMPONENT_SNSSAI = 2;
70 constexpr int ROUTE_SELECTION_DESCRIPTOR_COMPONENT_DNN = 4;
71 constexpr int ROUTE_SELECTION_DESCRIPTOR_COMPONENT_PDU_SESSION_TYPE = 8;
72 constexpr int ROUTE_SELECTION_DESCRIPTOR_COMPONENT_PREFERRED_ACCESS_TYPE = 16;
73 constexpr int ROUTE_SELECTION_DESCRIPTOR_COMPONENT_NON_3GPP_OFFLOAD = 32;
74 /**
75 * protocol pdu session type value
76 */
77 constexpr int PROTOCOL_PDU_SESSION_TYPE_IPV4 = 1;
78 constexpr int PROTOCOL_PDU_SESSION_TYPE_IPV6 = 2;
79 constexpr int PROTOCOL_PDU_SESSION_TYPE_IPV4V6 = 3;
80 constexpr int PROTOCOL_PDU_SESSION_TYPE_UNSTRUCTURED = 4;
81 constexpr int PROTOCOL_PDU_SESSION_TYPE_ETHERNET = 5;
82 constexpr int PROTOCOL_PDU_SESSION_TYPE_RESERVED = 7;
83
84 /**
85 * HAL pdu session type value
86 */
87
88 constexpr int HAL_PDU_SESSION_TYPE_IP = 0;
89 constexpr int HAL_PDU_SESSION_TYPE_IPV6 = 1;
90 constexpr int HAL_PDU_SESSION_TYPE_IPV4V6 = 2;
91 constexpr int HAL_PDU_SESSION_TYPE_NON_IP = 4;
92 constexpr int HAL_PDU_SESSION_TYPE_UNSTRUCTURED = 5;
93
94 constexpr int32_t CONNECTION_CAPABILITY_TYPE_IMS = 1;
95 constexpr int RSD_MAX_DNN_NUM = 2;
96 constexpr int RSD_MAX_NSSAI_NUM = 3;
97 constexpr int RSD_MAX_LIST_NUM = 3;
98 constexpr int INVALID_VALUE = 0;
99 constexpr int RSD_MAX_DNN_LEN = 99;
100 constexpr short IMSA_VERSION = 1;
101
GetInstance()102 UrspConfig& UrspConfig::GetInstance()
103 {
104 static UrspConfig instance;
105 return instance;
106 }
107
UrspConfig()108 UrspConfig::UrspConfig()
109 {
110 NETMGR_EXT_LOG_I("init UrspConfig start");
111 ParseConfig();
112 }
113
ParseConfig()114 void UrspConfig::ParseConfig()
115 {
116 NETMGR_EXT_LOG_I("UrspConfig::ParseConfig ");
117 int urspid = system::GetIntParameter("persist.sys.choose_ursp", 1);
118 std::string urspName = URSP_FILENAME1;
119 if (urspid == URSPFILE_ID2) {
120 urspName = URSP_FILENAME2;
121 }
122 std::string path = DEFAULT_NETSLICE_CONFIG_DIR + urspName;
123 if (path.empty()) {
124 NETMGR_EXT_LOG_E("config file path is empty!");
125 return;
126 }
127 xmlDocPtr doc = xmlReadFile(path.c_str(), NULL, XML_PARSE_NOERROR | XML_PARSE_NOWARNING);
128 if (doc == NULL) {
129 NETMGR_EXT_LOG_E("exception parse config file:[%{public}s]! ", path.c_str());
130 return;
131 }
132 xmlNodePtr curNode = xmlDocGetRootElement(doc);
133 if (curNode == NULL) {
134 NETMGR_EXT_LOG_E("No root element found in config file!");
135 xmlFreeDoc(doc);
136 return;
137 }
138 ParseAllUePolicy(doc);
139 xmlFreeDoc(doc);
140 }
141
ParseAllUePolicy(xmlDocPtr doc)142 void UrspConfig::ParseAllUePolicy(xmlDocPtr doc)
143 {
144 NETMGR_EXT_LOG_I("UrspConfig::ParseAllUePolicy");
145 xmlNodePtr curNode = xmlDocGetRootElement(doc);
146 if (curNode == NULL) {
147 NETMGR_EXT_LOG_E("No root element found in config file!");
148 return;
149 }
150 std::string curName = std::string(reinterpret_cast<const char*>(curNode->name));
151 NETMGR_EXT_LOG_I("UrspConfig::ParseAllUePolicy::curName:%{public}s ", curName.c_str());
152 xmlNodePtr child = curNode->children;
153 while (child != NULL) {
154 if (child->type == XML_TEXT_NODE || child->type == XML_COMMENT_NODE) {
155 std::string childName(reinterpret_cast<const char*>(child->name));
156 NETMGR_EXT_LOG_I("continue childName:%{public}s ", childName.c_str());
157 child = child->next;
158 continue;
159 }
160 std::string childName(reinterpret_cast<const char*>(child->name));
161 NETMGR_EXT_LOG_I("UrspConfig::ParseAllUePolicy::childName:%{public}s ", childName.c_str());
162 if (child->type == XML_ELEMENT_NODE && childName.compare(TAG_UEPOLICY.c_str()) == 0) {
163 ParseUePolicy(child);
164 }
165 child = child->next;
166 }
167 SaveTrafficDescriptorWhiteListToDb();
168 DumpPreConfigUrspMap();
169 }
170
ParseUePolicy(xmlNodePtr curNode)171 void UrspConfig::ParseUePolicy(xmlNodePtr curNode)
172 {
173 NETMGR_EXT_LOG_I("UrspConfig::ParseUePolicy");
174 std::vector<UrspRule> urspRules;
175 xmlChar *plmnstr = xmlGetProp(curNode, reinterpret_cast<const xmlChar *>(ATTR_PLMN.c_str()));
176 std::string plmnStr;
177 if (plmnstr != nullptr) {
178 plmnStr = std::string(reinterpret_cast<const char *>(plmnstr));
179 NETMGR_EXT_LOG_I("UrspConfig::ParseUePolicy::plmnStr = %{public}s", plmnStr.c_str());
180 xmlFree(plmnstr);
181 }
182 xmlNodePtr child = curNode->children;
183 while (child != NULL) {
184 if (child->type == XML_TEXT_NODE || child->type == XML_COMMENT_NODE) {
185 child = child->next;
186 continue;
187 }
188 std::string childName(reinterpret_cast<const char*>(child->name));
189 if (child->type == XML_ELEMENT_NODE && childName.compare(TAG_PRECONFIGURSP.c_str()) == 0) {
190 NETMGR_EXT_LOG_I("UrspConfig::ParseUePolicy::childName:%{public}s ", childName.c_str());
191 UrspRule urspRule = ParsePreConfigUrsp(child);
192 urspRules.push_back(urspRule);
193 }
194 child = child->next;
195 }
196 SndPreImsRsdList();
197 UrspRuleSort(urspRules);
198 mPreConfigUrspMap[plmnStr] = urspRules;
199 }
200
ParsePreConfigUrsp(xmlNodePtr node)201 UrspRule UrspConfig::ParsePreConfigUrsp(xmlNodePtr node)
202 {
203 NETMGR_EXT_LOG_I("UrspConfig::ParsePreConfigUrsp ");
204 UrspRule urspRule;
205 xmlChar *urspprecedence = xmlGetProp(node, reinterpret_cast<const xmlChar *>(ATTR_URSPPRECEDENCE.c_str()));
206 if (urspprecedence != nullptr) {
207 urspRule.urspPrecedence = atoi(reinterpret_cast<char *>(urspprecedence));
208 NETMGR_EXT_LOG_I("UrspConfig::ParsePreConfigUrsp::urspPrecedence = %{public}d", urspRule.urspPrecedence);
209 xmlFree(urspprecedence);
210 }
211 xmlNodePtr child = node->children;
212 while (child != NULL) {
213 if (child->type == XML_TEXT_NODE || child->type == XML_COMMENT_NODE) {
214 child = child->next;
215 continue;
216 }
217 std::string childName(reinterpret_cast<const char*>(child->name));
218 NETMGR_EXT_LOG_I("UrspConfig::ParsePreConfigUrsp::childName = %{public}s", childName.c_str());
219 if (child->type == XML_ELEMENT_NODE && childName.compare(TAG_TRAFFICDESCRIPTOR.c_str()) == 0) {
220 ParseTrafficDescriptor(child, urspRule.trafficDescriptor);
221 } else if (child->type == XML_ELEMENT_NODE && childName.compare(TAG_ROUTESELECTIONDESCRIPTOR.c_str()) == 0) {
222 ParseRouteSelectionDescriptor(child, urspRule.routeSelectionDescriptors);
223 }
224 child = child->next;
225 }
226 if (mIsTrafficDescriptorIncludeIms) {
227 NETMGR_EXT_LOG_I("UrspConfig::ParsePreConfigUrsp IncludeIms");
228 mImsRsdsMap[urspRule.urspPrecedence] = urspRule.routeSelectionDescriptors;
229 mIsTrafficDescriptorIncludeIms = false;
230 }
231 return urspRule;
232 }
233
ParseTrafficDescriptor(xmlNodePtr node,TrafficDescriptor & trafficDescriptor)234 void UrspConfig::ParseTrafficDescriptor(xmlNodePtr node, TrafficDescriptor &trafficDescriptor)
235 {
236 xmlChar *attrvalue = xmlGetProp(node, reinterpret_cast<const xmlChar *>(ATTR_TRAFFICDESCRIPTORTYPE.c_str()));
237 std::string attrValue;
238 if (attrvalue != nullptr) {
239 attrValue = std::string(reinterpret_cast<char *>(attrvalue));
240 xmlFree(attrvalue);
241 }
242 int trafficDescriptorType = std::stoi(attrValue);
243 xmlChar *AttrtrafficDescriptorvalue = nullptr;
244 switch (trafficDescriptorType) {
245 case TRAFFIC_DESCRIPTOR_COMPONENT_MATCH_ALL:
246 trafficDescriptor.isMatchAll = true;
247 break;
248 case TRAFFIC_DESCRIPTOR_COMPONENT_OS_ID_OS_APP_ID:
249 ParseOsAppId(node, trafficDescriptor);
250 break;
251 case TRAFFIC_DESCRIPTOR_COMPONENT_IPV4_ADDR:
252 ParseIpv4Addr(node, trafficDescriptor);
253 break;
254 case TRAFFIC_DESCRIPTOR_COMPONENT_IPV6_ADDR:
255 ParseIpv6Addr(node, trafficDescriptor);
256 break;
257 case TRAFFIC_DESCRIPTOR_COMPONENT_PROTOCOL_ID:
258 case TRAFFIC_DESCRIPTOR_COMPONENT_SINGLE_REMOTE_PORT:
259 case TRAFFIC_DESCRIPTOR_COMPONENT_REMOTE_PORT_RANGE:
260 case TRAFFIC_DESCRIPTOR_COMPONENT_DNN:
261 case TRAFFIC_DESCRIPTOR_COMPONENT_FQDN:
262 case TRAFFIC_DESCRIPTOR_COMPONENT_CONNECTION_CAPABILITY:
263 ParseTrafficDescriptorEx(node, trafficDescriptor, attrValue);
264 break;
265 default:
266 break;
267 }
268 if (AttrtrafficDescriptorvalue != nullptr) {
269 xmlFree(AttrtrafficDescriptorvalue);
270 }
271 }
272
ParseTrafficDescriptorEx(xmlNodePtr node,TrafficDescriptor & trafficDescriptor,std::string attrValue)273 void UrspConfig::ParseTrafficDescriptorEx(xmlNodePtr node, TrafficDescriptor &trafficDescriptor, std::string attrValue)
274 {
275 std::string trafficDescriptorValue;
276 int trafficDescriptorType = std::stoi(attrValue);
277 xmlChar *AttrtrafficDescriptorvalue = nullptr;
278 switch (trafficDescriptorType) {
279 case TRAFFIC_DESCRIPTOR_COMPONENT_PROTOCOL_ID:
280 AttrtrafficDescriptorvalue = xmlGetProp(node,
281 reinterpret_cast<const xmlChar *>(ATTR_TRAFFICDESCRIPTORVALUE.c_str()));
282 trafficDescriptorValue = (std::string)reinterpret_cast<char *>(AttrtrafficDescriptorvalue);
283 trafficDescriptor.protocolIds.push_back(std::stoi(trafficDescriptorValue));
284 break;
285 case TRAFFIC_DESCRIPTOR_COMPONENT_SINGLE_REMOTE_PORT:
286 AttrtrafficDescriptorvalue = xmlGetProp(node,
287 reinterpret_cast<const xmlChar *>(ATTR_TRAFFICDESCRIPTORVALUE.c_str()));
288 trafficDescriptorValue = (std::string)reinterpret_cast<char *>(AttrtrafficDescriptorvalue);
289 trafficDescriptor.singleRemotePorts.push_back(std::stoi(trafficDescriptorValue));
290 break;
291 case TRAFFIC_DESCRIPTOR_COMPONENT_REMOTE_PORT_RANGE:
292 ParseRemotePortRange(node, trafficDescriptor);
293 break;
294 case TRAFFIC_DESCRIPTOR_COMPONENT_DNN:
295 AttrtrafficDescriptorvalue = xmlGetProp(node,
296 reinterpret_cast<const xmlChar *>(ATTR_TRAFFICDESCRIPTORVALUE.c_str()));
297 trafficDescriptorValue = (std::string)reinterpret_cast<char *>(AttrtrafficDescriptorvalue);
298 if (trafficDescriptorValue == "ims" || trafficDescriptorValue == "IMS") {
299 mIsTrafficDescriptorIncludeIms = true;
300 }
301 trafficDescriptor.dnns.push_back(trafficDescriptorValue);
302 break;
303 case TRAFFIC_DESCRIPTOR_COMPONENT_FQDN:
304 AttrtrafficDescriptorvalue = xmlGetProp(node,
305 reinterpret_cast<const xmlChar *>(ATTR_TRAFFICDESCRIPTORVALUE.c_str()));
306 trafficDescriptorValue = (std::string)reinterpret_cast<char *>(AttrtrafficDescriptorvalue);
307 trafficDescriptor.fqdns.push_back(trafficDescriptorValue);
308 break;
309 case TRAFFIC_DESCRIPTOR_COMPONENT_CONNECTION_CAPABILITY:
310 ParseConnectionCapabilities(node, trafficDescriptor);
311 break;
312 }
313 }
314
ParseRouteSelectionDescriptor(xmlNodePtr node,std::vector<RouteSelectionDescriptor> & routeSelectionDescriptors)315 void UrspConfig::ParseRouteSelectionDescriptor(xmlNodePtr node,
316 std::vector<RouteSelectionDescriptor> &routeSelectionDescriptors)
317 {
318 NETMGR_EXT_LOG_I("UrspConfig::ParseRouteSelectionDescriptor ");
319 xmlChar *attrvalue = xmlGetProp(node, reinterpret_cast<const xmlChar *>(ATTR_ROUTEPRECEDENCE.c_str()));
320 std::string attrValue;
321 if (attrvalue != nullptr) {
322 attrValue = std::string(reinterpret_cast<char *>(attrvalue));
323 xmlFree(attrvalue);
324 }
325 NETMGR_EXT_LOG_I("routeSelectionDescriptorPrecedence::%{public}s", attrValue.c_str());
326 int Precedence = std::stoi(attrValue);
327 RouteSelectionDescriptor routeSelectionDescriptor;
328 routeSelectionDescriptor.routePrecedence = Precedence;
329 xmlNodePtr child = node->children;
330 while (child != NULL) {
331 if (child->type == XML_TEXT_NODE || child->type == XML_COMMENT_NODE) {
332 child = child->next;
333 continue;
334 }
335 std::string childName(reinterpret_cast<const char*>(child->name));
336 if (child->type == XML_ELEMENT_NODE &&
337 childName.compare(TAG_ROUTESELECTIONDESCRIPTORCONTENTS.c_str()) == 0) {
338 ParseRouteRule(child, routeSelectionDescriptor);
339 }
340 child = child->next;
341 }
342 routeSelectionDescriptors.push_back(routeSelectionDescriptor);
343 }
344
ParseRouteRule(xmlNodePtr node,RouteSelectionDescriptor & routeSelectionDescriptor)345 void UrspConfig::ParseRouteRule(xmlNodePtr node, RouteSelectionDescriptor &routeSelectionDescriptor)
346 {
347 std::string routeRuleValue;
348 Snssai snssai;
349 xmlChar *attrvalue = xmlGetProp(node,
350 reinterpret_cast<const xmlChar *>(ATTR_RSDTYPE.c_str()));
351 std::string attrValue;
352 if (attrvalue != nullptr) {
353 attrValue = std::string(reinterpret_cast<char *>(attrvalue));
354 xmlFree(attrvalue);
355 }
356 int routeRuleType = std::stoi(attrValue);
357 NETMGR_EXT_LOG_I("ParseRouteRule routeRuleType = %{public}d", routeRuleType);
358 xmlChar *AttrrouteRulevalue = nullptr;
359 switch (routeRuleType) {
360 case ROUTE_SELECTION_DESCRIPTOR_COMPONENT_SSC_MODE_TYPE:
361 AttrrouteRulevalue = xmlGetProp(node, reinterpret_cast<const xmlChar *>(ATTR_RSDVALUE.c_str()));
362 routeRuleValue = (std::string)reinterpret_cast<char *>(AttrrouteRulevalue);
363 routeSelectionDescriptor.sscMode = static_cast<int>(std::stoi(routeRuleValue));
364 break;
365 case ROUTE_SELECTION_DESCRIPTOR_COMPONENT_SNSSAI:
366 AttrrouteRulevalue = xmlGetProp(node, reinterpret_cast<const xmlChar *>(ATTR_RSDVALUE.c_str()));
367 routeRuleValue = (std::string)reinterpret_cast<char *>(AttrrouteRulevalue);
368 snssai.setSnssai(routeRuleValue);
369 if (sAllowedNssaiConfig_->ParseSnssai(snssai) == false) {
370 NETMGR_EXT_LOG_E("parseSNssai(sNssai) is false");
371 break;
372 }
373 routeSelectionDescriptor.snssais.push_back(snssai);
374 break;
375 case ROUTE_SELECTION_DESCRIPTOR_COMPONENT_DNN:
376 AttrrouteRulevalue = xmlGetProp(node,
377 reinterpret_cast<const xmlChar *>(ATTR_RSDVALUE.c_str()));
378 routeRuleValue = (std::string)reinterpret_cast<char *>(AttrrouteRulevalue);
379 routeSelectionDescriptor.dnns.push_back(routeRuleValue);
380 break;
381 case ROUTE_SELECTION_DESCRIPTOR_COMPONENT_PDU_SESSION_TYPE:
382 AttrrouteRulevalue = xmlGetProp(node, reinterpret_cast<const xmlChar *>(ATTR_RSDVALUE.c_str()));
383 routeRuleValue = (std::string)reinterpret_cast<char *>(AttrrouteRulevalue);
384 routeSelectionDescriptor.pduSessionType = static_cast<int>(std::stoi(routeRuleValue));
385 break;
386 case ROUTE_SELECTION_DESCRIPTOR_COMPONENT_PREFERRED_ACCESS_TYPE:
387 case ROUTE_SELECTION_DESCRIPTOR_COMPONENT_NON_3GPP_OFFLOAD:
388 break;
389 default:
390 break;
391 }
392 if (AttrrouteRulevalue != nullptr) {
393 xmlFree(AttrrouteRulevalue);
394 }
395 }
396
ParseOsAppId(xmlNodePtr node,TrafficDescriptor & trafficDescriptor)397 bool UrspConfig::ParseOsAppId(xmlNodePtr node, TrafficDescriptor& trafficDescriptor)
398 {
399 xmlChar *trafficDescriptorvalue = xmlGetProp(node,
400 reinterpret_cast<const xmlChar *>(ATTR_TRAFFICDESCRIPTORVALUE.c_str()));
401 std::string trafficDescriptorValue = (std::string)reinterpret_cast<char *>(trafficDescriptorvalue);
402 xmlFree(trafficDescriptorvalue);
403 std::vector<std::string> values;
404 values = Split(trafficDescriptorValue, COMMA_SEPARATOR);
405 OsAppId osAppId;
406 osAppId.setOsId(values[0]);
407 osAppId.setAppId(values[1]);
408 trafficDescriptor.osAppIds.push_back(osAppId);
409 return true;
410 }
411
ParseIpv4Addr(xmlNodePtr node,TrafficDescriptor & trafficDescriptor)412 bool UrspConfig::ParseIpv4Addr(xmlNodePtr node, TrafficDescriptor& trafficDescriptor)
413 {
414 xmlChar *trafficDescriptorvalue = xmlGetProp(node,
415 reinterpret_cast<const xmlChar *>(ATTR_TRAFFICDESCRIPTORVALUE.c_str()));
416 std::string trafficDescriptorValue = (std::string)reinterpret_cast<char *>(trafficDescriptorvalue);
417 xmlFree(trafficDescriptorvalue);
418 std::vector<std::string> values;
419 values = Split(trafficDescriptorValue, COMMA_SEPARATOR);
420 uint32_t ipv4Address = 0;
421 uint32_t ipv4Mask = 0;
422 Ipv4Addr ipv4Addr;
423 ipv4Address = inet_addr(values[0].c_str());
424 if (ipv4Address == INADDR_NONE) {
425 return false;
426 }
427 ipv4Mask = inet_addr(values[1].c_str());
428 if (ipv4Mask == INADDR_NONE) {
429 return false;
430 }
431 ipv4Addr.setIpv4Addr(ipv4Address);
432 ipv4Addr.setIpv4Mask(ipv4Mask);
433 trafficDescriptor.ipv4Addrs.push_back(ipv4Addr);
434 return true;
435 }
436
ParseIpv6Addr(xmlNodePtr node,TrafficDescriptor & trafficDescriptor)437 bool UrspConfig::ParseIpv6Addr(xmlNodePtr node, TrafficDescriptor& trafficDescriptor)
438 {
439 xmlChar *trafficDescriptorvalue = xmlGetProp(node,
440 reinterpret_cast<const xmlChar *>(ATTR_TRAFFICDESCRIPTORVALUE.c_str()));
441 std::string trafficDescriptorValue = (std::string)reinterpret_cast<char *>(trafficDescriptorvalue);
442 xmlFree(trafficDescriptorvalue);
443 std::vector<std::string> values;
444 values = Split(trafficDescriptorValue, COMMA_SEPARATOR);
445 struct in6_addr ipv6;
446 int prefixLen = 0;
447 Ipv6Addr ipv6Addr;
448 if (inet_pton(AF_INET6, values[0].c_str(), &ipv6) == 0) {
449 return false;
450 }
451
452 prefixLen = std::stoi(values[1]);
453 ipv6Addr.setIpv6Addr(*reinterpret_cast<std::array<uint8_t, BASE_16>*>(ipv6.s6_addr));
454 ipv6Addr.setIpv6PrefixLen(prefixLen);
455 trafficDescriptor.ipv6Addrs.push_back(ipv6Addr);
456 return true;
457 }
458
ParseRemotePortRange(xmlNodePtr node,TrafficDescriptor & trafficDescriptor)459 bool UrspConfig::ParseRemotePortRange(xmlNodePtr node, TrafficDescriptor& trafficDescriptor)
460 {
461 xmlChar *trafficDescriptorvalue = xmlGetProp(node,
462 reinterpret_cast<const xmlChar *>(ATTR_TRAFFICDESCRIPTORVALUE.c_str()));
463 std::string trafficDescriptorValue = (std::string)reinterpret_cast<char *>(trafficDescriptorvalue);
464 xmlFree(trafficDescriptorvalue);
465 std::vector<std::string> values;
466 values = Split(trafficDescriptorValue, COMMA_SEPARATOR);
467 RemotePortRange portRang;
468 portRang.setPortRangeLowLimit(std::stoi(values[0]));
469 portRang.setPortRangeHighLimit(std::stoi(values[1]));
470
471 trafficDescriptor.remotePortRanges.push_back(portRang);
472 return true;
473 }
474
ParseConnectionCapabilities(xmlNodePtr node,TrafficDescriptor & trafficDescriptor)475 bool UrspConfig::ParseConnectionCapabilities(xmlNodePtr node, TrafficDescriptor& trafficDescriptor)
476 {
477 xmlChar *trafficDescriptorvalue = xmlGetProp(node,
478 reinterpret_cast<const xmlChar *>(ATTR_TRAFFICDESCRIPTORVALUE.c_str()));
479 std::string trafficDescriptorValue = (std::string)reinterpret_cast<char *>(trafficDescriptorvalue);
480 xmlFree(trafficDescriptorvalue);
481 int connectionCapabilityType = std::stoi(trafficDescriptorValue);
482 if ((connectionCapabilityType & CONNECTION_CAPABILITY_TYPE_IMS) != 0) {
483 mIsTrafficDescriptorIncludeIms = true;
484 }
485 trafficDescriptor.connectionCapabilities.push_back(connectionCapabilityType);
486 return true;
487 }
488
489
setUrspRules(const std::string & plmn,std::vector<UrspRule> & urspRules)490 void UrspConfig::setUrspRules(const std::string& plmn, std::vector<UrspRule>& urspRules)
491 {
492 UrspRuleSort(urspRules);
493 mUePolicyMap[plmn] = urspRules;
494 }
495
ClearUrspRules()496 void UrspConfig::ClearUrspRules()
497 {
498 mUePolicyMap.clear();
499 }
500
SetUrspVersion(int urspVersion)501 void UrspConfig::SetUrspVersion(int urspVersion)
502 {
503 mUrspVersion = urspVersion;
504 }
505
UrspRuleSort(std::vector<UrspRule> & urspRules)506 void UrspConfig::UrspRuleSort(std::vector<UrspRule>& urspRules)
507 {
508 for (auto& urspRule : urspRules) {
509 std::sort(urspRule.routeSelectionDescriptors.begin(),
510 urspRule.routeSelectionDescriptors.end(), [](const auto& r1, const auto& r2) {
511 return r1.routePrecedence < r2.routePrecedence;
512 });
513 }
514 // Order ursp rules based on urspPrecedence
515 std::sort(urspRules.begin(), urspRules.end(), [](const auto& r1, const auto& r2) {
516 return r1.urspPrecedence < r2.urspPrecedence;
517 });
518 }
519
SaveTrafficDescriptorWhiteListToDb()520 void UrspConfig::SaveTrafficDescriptorWhiteListToDb()
521 {
522 NETMGR_EXT_LOG_I("SaveTrafficDescriptorWhiteList ");
523 std::shared_ptr<TrafficDescriptorWhiteList> whiteList = std::make_shared<TrafficDescriptorWhiteList>();
524 std::vector<UrspRule> urspRules;
525 std::unordered_map<std::string, std::vector<UrspRule>> uePolicyMap =
526 mUePolicyMap.empty() ? mPreConfigUrspMap : mUePolicyMap;
527 for (const auto& entry : uePolicyMap) {
528 urspRules = entry.second;
529 FillTrafficDescriptorWhiteList(whiteList, urspRules);
530 }
531
532 if (whiteList != nullptr) {
533 DelayedSingleton<HwNetworkSliceManager>::GetInstance()->GetTrafficDescriptorWhiteList(*whiteList);
534 }
535 }
536
FillTrafficDescriptorWhiteList(std::shared_ptr<TrafficDescriptorWhiteList> & whiteList,const std::vector<UrspRule> & urspRules)537 void UrspConfig::FillTrafficDescriptorWhiteList(std::shared_ptr<TrafficDescriptorWhiteList>& whiteList,
538 const std::vector<UrspRule>& urspRules)
539 {
540 NETMGR_EXT_LOG_I("FillTrafficDescriptorWhiteList ");
541 for (const auto& urspRule : urspRules) {
542 const TrafficDescriptor& trafficDescriptor = urspRule.trafficDescriptor;
543
544 for (auto& osAppId : trafficDescriptor.osAppIds) {
545 std::string osAppIdStr = osAppId.getOsId() + "#" + osAppId.getAppId();
546 if (!whiteList->osAppIds.empty() && whiteList->osAppIds.find(osAppIdStr) != std::string::npos) {
547 continue;
548 }
549 if (!whiteList->osAppIds.empty()) {
550 whiteList->osAppIds += COMMA_SEPARATOR;
551 }
552 whiteList->osAppIds += osAppIdStr;
553 }
554
555 for (const auto& dnn : trafficDescriptor.dnns) {
556 if (!whiteList->dnns.empty() && whiteList->dnns.find(dnn) != std::string::npos) {
557 continue;
558 }
559 if (!whiteList->dnns.empty()) {
560 whiteList->dnns += COMMA_SEPARATOR;
561 }
562 whiteList->dnns += dnn;
563 }
564
565 for (const auto& fqdn : trafficDescriptor.fqdns) {
566 if (!whiteList->fqdns.empty() && whiteList->fqdns.find(fqdn) != std::string::npos) {
567 continue;
568 }
569 if (!whiteList->fqdns.empty()) {
570 whiteList->fqdns += COMMA_SEPARATOR;
571 }
572 whiteList->fqdns += fqdn;
573 }
574
575 for (const auto& connectionCapability : trafficDescriptor.connectionCapabilities) {
576 if (!whiteList->cct.empty() && whiteList->cct.find(connectionCapability) != std::string::npos) {
577 continue;
578 }
579 if (!whiteList->cct.empty()) {
580 whiteList->cct += COMMA_SEPARATOR;
581 }
582 whiteList->cct += std::to_string(connectionCapability);
583 }
584 }
585 }
586
DecodeUrspRules(int inputLen,int & startIndex,std::vector<uint8_t> buffer,std::vector<UrspRule> & urspRules)587 bool UrspConfig::DecodeUrspRules(int inputLen, int& startIndex,
588 std::vector<uint8_t> buffer, std::vector<UrspRule>& urspRules)
589 {
590 int startIndex_tmp = startIndex;
591 SetUrspVersion(NetworkSliceCommConfig::URSP_VERSION_1520);
592 if (DecodeUrspByVersion(inputLen, startIndex, buffer, urspRules, NetworkSliceCommConfig::URSP_VERSION_1520)) {
593 NETMGR_EXT_LOG_I("decodeUrspRules, success urspVersion is 1520");
594 sSuccUrspVersion = NetworkSliceCommConfig::URSP_VERSION_1520;
595 return true;
596 }
597 SetUrspVersion(NetworkSliceCommConfig::URSP_VERSION_1510);
598 if (DecodeUrspByVersion(inputLen, startIndex_tmp, buffer, urspRules, NetworkSliceCommConfig::URSP_VERSION_1510)) {
599 NETMGR_EXT_LOG_I("decodeUrspRules, success urspVersion is 1510");
600 sSuccUrspVersion = NetworkSliceCommConfig::URSP_VERSION_1510;
601 return true;
602 }
603 NETMGR_EXT_LOG_E("decodeUrspRules(inputLen, buffer, urspRules) is false");
604 return false;
605 }
606
GetSuccUrspVersion()607 short UrspConfig::GetSuccUrspVersion()
608 {
609 return sSuccUrspVersion;
610 }
611
DecodeUrspByVersion(int inputLen,int & startIndex,std::vector<uint8_t> buffer,std::vector<UrspRule> & urspRules,short version)612 bool UrspConfig::DecodeUrspByVersion(int inputLen, int& startIndex,
613 std::vector<uint8_t> buffer, std::vector<UrspRule>& urspRules, short version)
614 {
615 int subLen;
616 int len = inputLen;
617 NETMGR_EXT_LOG_I("version[%{public}d]:startIndex:%{public}d", version, startIndex);
618 while (len > 0) {
619 subLen = GetSubLenByversion(startIndex, buffer, version);
620 if (subLen == DECODE_FAIL_OTHER) {
621 return false;
622 }
623 len = len - GetLenBytesByversion(version) - subLen;
624 if (((int(buffer.size()) - startIndex) < subLen) || (len < 0)) {
625 NETMGR_EXT_LOG_E("(buffer.remaining()[%{public}d] < subLen[%{public}d]) || (len[%{public}d] < 0)",
626 (int(buffer.size()) - startIndex), subLen, len);
627 return false;
628 }
629
630 if (!DecodeUrspRule(subLen, startIndex, buffer, urspRules, version)) {
631 urspRules.clear();
632 ResetImsRsdsMap();
633 NETMGR_EXT_LOG_E("decodeUrspRule(subLen, buffer, urspRules, verision) is false");
634 return false;
635 }
636 }
637 return true;
638 }
639
ResetImsRsdsMap()640 void UrspConfig::ResetImsRsdsMap()
641 {
642 mIsTrafficDescriptorIncludeIms = false;
643 mImsRsdsMap.clear();
644 }
645
GetSubLenByversion(int & startIndex,std::vector<uint8_t> buffer,short version)646 int UrspConfig::GetSubLenByversion(int& startIndex, std::vector<uint8_t> buffer, short version)
647 {
648 int subLen;
649 if (version == NetworkSliceCommConfig::URSP_VERSION_1510) {
650 if ((int(buffer.size()) - startIndex) < NetworkSliceCommConfig::LEN_BYTE) {
651 NETMGR_EXT_LOG_E("buffer.remaining() < NetworkSliceCommConfig::LEN_BYTE");
652 return DECODE_FAIL_OTHER;
653 }
654 subLen = ConvertUnsignedShort2Int(buffer[startIndex++]);
655 } else if (version == NetworkSliceCommConfig::URSP_VERSION_1520) {
656 if ((int(buffer.size()) - startIndex) < NetworkSliceCommConfig::LEN_SHORT) {
657 NETMGR_EXT_LOG_E("buffer.remaining() < NetworkSliceCommConfig::LEN_BYTE");
658 return DECODE_FAIL_OTHER;
659 }
660 short subLen_short = GetShort(startIndex, buffer);
661 subLen = ConvertUnsignedShort2Int(subLen_short);
662 } else {
663 NETMGR_EXT_LOG_E("Ursp version invalid");
664 return DECODE_FAIL_OTHER;
665 }
666 return subLen;
667 }
668
GetLenBytesByversion(short version)669 int UrspConfig::GetLenBytesByversion(short version)
670 {
671 if (version == NetworkSliceCommConfig::URSP_VERSION_1510) {
672 return NetworkSliceCommConfig::LEN_BYTE;
673 } else {
674 return NetworkSliceCommConfig::LEN_SHORT;
675 }
676 }
677
DecodeUrspRule(int inputLen,int & startIndex,std::vector<uint8_t> buffer,std::vector<UrspRule> & urspRules,short version)678 bool UrspConfig::DecodeUrspRule(int inputLen, int& startIndex,
679 std::vector<uint8_t> buffer, std::vector<UrspRule>& urspRules, short version)
680 {
681 NETMGR_EXT_LOG_I("DecodeUrspRule");
682 if ((int(buffer.size()) - startIndex) < NetworkSliceCommConfig::LEN_THREE_BYTE) {
683 /* LEN_THREE_BYTE = Precedence + Length of traffic descriptor */
684 NETMGR_EXT_LOG_E("buffer.remaining()[%{public}d] < NetworkSliceCommConfig::LEN_THREE_BYTE",
685 (int(buffer.size()) - startIndex));
686 return false;
687 }
688 UrspRule urspRule;
689 /* Precedence value of URSP rule */
690 urspRule.urspPrecedence = ConvertUnsignedShort2Int(buffer[startIndex++]);
691 return DecodeUrspRuleExtra(inputLen, startIndex, buffer, urspRule, urspRules, version);
692 }
693
DecodeUrspRuleExtra(int inputLen,int & startIndex,std::vector<uint8_t> buffer,UrspRule & urspRule,std::vector<UrspRule> & urspRules,short version)694 bool UrspConfig::DecodeUrspRuleExtra(int inputLen, int& startIndex, std::vector<uint8_t> buffer,
695 UrspRule& urspRule, std::vector<UrspRule>& urspRules, short version)
696 {
697 int trafficDescriptorLen = ConvertUnsignedShort2Int(GetShort(startIndex, buffer));
698 int len = inputLen;
699 if (((int(buffer.size()) - startIndex) < trafficDescriptorLen)
700 || (len < (NetworkSliceCommConfig::LEN_THREE_BYTE + trafficDescriptorLen))) {
701 NETMGR_EXT_LOG_E("buffer.remaining() < trafficDescriptorLen");
702 return false;
703 }
704 len = len - NetworkSliceCommConfig::LEN_THREE_BYTE - trafficDescriptorLen;
705 int ret = DecodeTrafficDescriptor(trafficDescriptorLen, startIndex, buffer, urspRule.trafficDescriptor);
706 if (ret == DECODE_FAIL_OTHER) {
707 return false;
708 }
709 if (ret == DECODE_FAIL_UNKNOWN_IDENTIFIER) {
710 if ((int(buffer.size()) - startIndex) < len) {
711 NETMGR_EXT_LOG_E("buffer.remaining() < len");
712 return false;
713 }
714 std::vector<uint8_t> dsts =std::vector<uint8_t>(len);
715 std::copy(buffer.begin() + startIndex, buffer.begin() + startIndex + len, dsts.begin());
716 return true;
717 }
718 if ((int(buffer.size()) - startIndex) < NetworkSliceCommConfig::LEN_SHORT) {
719 NETMGR_EXT_LOG_E("buffer.remaining() < NetworkSliceCommConfig::LEN_SHORT");
720 return false;
721 }
722 int routeRuleListLen = ConvertUnsignedShort2Int(GetShort(startIndex, buffer));
723 if (((int(buffer.size()) - startIndex) < routeRuleListLen)
724 || (len != NetworkSliceCommConfig::LEN_SHORT + routeRuleListLen)) {
725 NETMGR_EXT_LOG_E("buffer.remaining[%{public}d] < routeRuleListLen[%{public}d]",
726 (int(buffer.size()) - startIndex), routeRuleListLen);
727 return false;
728 }
729 ret = DecodeRouteRuleList(routeRuleListLen, startIndex, buffer, urspRule, version);
730 if (ret == DECODE_FAIL_OTHER) {
731 return false;
732 }
733 if (ret == DECODE_FAIL_UNKNOWN_IDENTIFIER) {
734 return true;
735 }
736 if (mIsTrafficDescriptorIncludeIms) {
737 NETMGR_EXT_LOG_I("UrspConfig::DecodeUrspRuleExtra IncludeIms");
738 mImsRsdsMap[urspRule.urspPrecedence] = urspRule.routeSelectionDescriptors;
739 mIsTrafficDescriptorIncludeIms = false;
740 }
741 urspRules.push_back(urspRule);
742 return true;
743 }
744
DecodeTrafficDescriptor(int inputLen,int & startIndex,std::vector<uint8_t> buffer,TrafficDescriptor & trafficDescriptor)745 int UrspConfig::DecodeTrafficDescriptor(int inputLen, int& startIndex,
746 std::vector<uint8_t> buffer, TrafficDescriptor& trafficDescriptor)
747 {
748 NETMGR_EXT_LOG_I("DecodeTrafficDescriptor");
749 int len = inputLen;
750 int initBufferRemaining = (int(buffer.size()) - startIndex);
751 while (initBufferRemaining - (int(buffer.size()) - startIndex) < len) {
752 /* Traffic descriptor component type identifier */
753 if ((int(buffer.size()) - startIndex) < NetworkSliceCommConfig::LEN_BYTE) {
754 NETMGR_EXT_LOG_E("buffer.remaining() < Traffic descriptor component type identifier Len");
755 return DECODE_FAIL_OTHER;
756 }
757 int type = static_cast<int>(buffer[startIndex++]);
758 int ret = DECODE_SUCCESS;
759 switch (type) {
760 case TRAFFIC_DESCRIPTOR_COMPONENT_MATCH_ALL:
761 /* Match-all type */
762 trafficDescriptor.isMatchAll = true;
763 break;
764 case TRAFFIC_DESCRIPTOR_COMPONENT_OS_ID_OS_APP_ID:
765 /* OS Id + OS App Id type */
766 ret = DecodeOsIdOsAppId(startIndex, buffer, trafficDescriptor, false);
767 break;
768 case TRAFFIC_DESCRIPTOR_COMPONENT_IPV4_ADDR:
769 /* IPv4 remote address type */
770 ret = DecodeIpv4Addr(startIndex, buffer, trafficDescriptor);
771 break;
772 case TRAFFIC_DESCRIPTOR_COMPONENT_IPV6_ADDR:
773 /* IPv6 remote address/prefix length type */
774 ret = DecodeIpv6Addr(startIndex, buffer, trafficDescriptor);
775 break;
776 case TRAFFIC_DESCRIPTOR_COMPONENT_PROTOCOL_ID:
777 /* Protocol identifier/next header type */
778 ret = DecodeProtocolId(startIndex, buffer, trafficDescriptor);
779 break;
780 default:
781 ret = DecodeTrafficDescriptorExtra(inputLen, startIndex, type,
782 buffer, trafficDescriptor, initBufferRemaining);
783 break;
784 }
785 if (ret != DECODE_SUCCESS) {
786 return ret;
787 }
788 }
789 return DECODE_SUCCESS;
790 }
791
DecodeRouteRuleList(int inputLen,int & startIndex,std::vector<uint8_t> buffer,UrspRule & urspRule,short version)792 int UrspConfig::DecodeRouteRuleList(int inputLen, int& startIndex,
793 std::vector<uint8_t> buffer, UrspRule& urspRule, short version)
794 {
795 NETMGR_EXT_LOG_I("DecodeRouteRuleList");
796 int subLen;
797 int len = inputLen;
798 while (len > 0) {
799 subLen = GetSubLenByversion(startIndex, buffer, version);
800 if (subLen == DECODE_FAIL_OTHER) {
801 return DECODE_FAIL_OTHER;
802 }
803 len = len - GetLenBytesByversion(version) - subLen;
804 if ((int(buffer.size()) - startIndex) < subLen || (len < 0)) {
805 NETMGR_EXT_LOG_E("(buffer.remaining([%{public}d]) < subLen[%{public}d]) || (len[%{public}d] < 0)",
806 (int(buffer.size()) - startIndex), subLen, len);
807 return DECODE_FAIL_OTHER;
808 }
809 if ((int(buffer.size()) - startIndex) < NetworkSliceCommConfig::LEN_THREE_BYTE) {
810 /* LEN_THREE_BYTE = Precedence + Length of route selection descriptor contents */
811 NETMGR_EXT_LOG_E("buffer.remaining() < NetworkSliceCommConfig::LEN_THREE_BYTE");
812 return DECODE_FAIL_OTHER;
813 }
814 RouteSelectionDescriptor routeRule;
815 /* Precedence value of route selection descriptor */
816 routeRule.routePrecedence = buffer[startIndex++];
817 /* Length of route selection descriptor contents */
818 int routeRuleLen = ConvertUnsignedShort2Int(GetShort(startIndex, buffer));
819 if (((int(buffer.size()) - startIndex) < routeRuleLen)
820 || (subLen != NetworkSliceCommConfig::LEN_THREE_BYTE + routeRuleLen)) {
821 NETMGR_EXT_LOG_E("buffer.remaining([%{public}d]) < routeRuleLen[%{public}d], subLen[%{public}d])",
822 (int(buffer.size()) - startIndex), routeRuleLen, subLen);
823 return DECODE_FAIL_OTHER;
824 }
825 int ret = DecodeRouteRule(startIndex, routeRuleLen, buffer, routeRule);
826 if (ret == DECODE_FAIL_OTHER) {
827 return DECODE_FAIL_OTHER;
828 }
829 if (ret == DECODE_FAIL_UNKNOWN_IDENTIFIER) {
830 continue;
831 }
832 urspRule.routeSelectionDescriptors.push_back(routeRule);
833 }
834 if (urspRule.routeSelectionDescriptors.empty()) {
835 return DECODE_FAIL_UNKNOWN_IDENTIFIER;
836 }
837 return DECODE_SUCCESS;
838 }
839
DecodeTrafficDescriptorExtra(int inputLen,int & startIndex,int type,std::vector<uint8_t> buffer,TrafficDescriptor & trafficDescriptor,int initBufferRemaining)840 int UrspConfig::DecodeTrafficDescriptorExtra(int inputLen, int& startIndex, int type,
841 std::vector<uint8_t> buffer, TrafficDescriptor& trafficDescriptor, int initBufferRemaining)
842 {
843 int ret = DECODE_SUCCESS;
844 int len = inputLen;
845 switch (type) {
846 case TRAFFIC_DESCRIPTOR_COMPONENT_SINGLE_REMOTE_PORT:
847 /* Single remote port type */
848 ret = DecodeSingleRemotePort(startIndex, buffer, trafficDescriptor);
849 return ret;
850 case TRAFFIC_DESCRIPTOR_COMPONENT_REMOTE_PORT_RANGE:
851 /* Remote port range type */
852 ret = DecodeRemotePortRange(startIndex, buffer, trafficDescriptor);
853 return ret;
854 case TRAFFIC_DESCRIPTOR_COMPONENT_DNN:
855 /* DNN type */
856 ret = DecodeTrafficDescriptorDnn(startIndex, buffer, trafficDescriptor);
857 return ret;
858 case TRAFFIC_DESCRIPTOR_COMPONENT_FQDN:
859 /* Destination FQDN */
860 ret = DecodeFqdn(startIndex, buffer, trafficDescriptor);
861 if (ret == DECODE_FAIL_UNKNOWN_IDENTIFIER) {
862 int sublen = len - (initBufferRemaining - (int(buffer.size()) - startIndex));
863 std::vector<uint8_t> dsts = std::vector<uint8_t>(sublen);
864 for (int i = 0; i < sublen; ++i) {
865 dsts[i] = buffer[startIndex];
866 startIndex++;
867 }
868 }
869 return ret;
870 case TRAFFIC_DESCRIPTOR_COMPONENT_CONNECTION_CAPABILITY:
871 /* Connection capability type */
872 ret = DecodeConnectionCapabilities(startIndex, buffer, trafficDescriptor);
873 return ret;
874 case TRAFFIC_DESCRIPTOR_COMPONENT_OS_APP_ID:
875 /* OS App Id type */
876 ret = DecodeOsIdOsAppId(startIndex, buffer, trafficDescriptor, true);
877 return ret;
878 default:
879 NETMGR_EXT_LOG_E("decodeTrafficDescriptor failed, invalid Traffic descriptor component type identifier");
880 int sublen = len - (initBufferRemaining - (int(buffer.size()) - startIndex));
881 std::vector<uint8_t> dsts = std::vector<uint8_t>(sublen);
882 for (int i = 0; i < sublen; ++i) {
883 dsts[i] = buffer[startIndex];
884 startIndex++;
885 }
886 return ret;
887 }
888 }
889
DecodeRouteRule(int & startIndex,int inputLen,std::vector<uint8_t> buffer,RouteSelectionDescriptor & routeRule)890 int UrspConfig::DecodeRouteRule(int& startIndex, int inputLen,
891 std::vector<uint8_t> buffer, RouteSelectionDescriptor& routeRule)
892 {
893 int len = inputLen;
894 int initBufferRemaining = (int(buffer.size()) - startIndex);
895 while (initBufferRemaining - (int(buffer.size()) - startIndex) < len) {
896 if ((int(buffer.size()) - startIndex) < NetworkSliceCommConfig::LEN_BYTE) { /* Rsd component type identifier */
897 NETMGR_EXT_LOG_E("buffer.remaining() < Route selection descriptor component type identifier len");
898 return DECODE_FAIL_OTHER;
899 }
900 int type = static_cast<int>(buffer[startIndex++]);
901 int ret = DECODE_SUCCESS;
902 switch (type) {
903 case ROUTE_SELECTION_DESCRIPTOR_COMPONENT_SSC_MODE_TYPE:
904 ret = DecodeSscMode(startIndex, buffer, routeRule);
905 break;
906 case ROUTE_SELECTION_DESCRIPTOR_COMPONENT_SNSSAI:
907 ret = DecodeSnssai(startIndex, buffer, routeRule);
908 break;
909 case ROUTE_SELECTION_DESCRIPTOR_COMPONENT_DNN:
910 ret = DecodeDnn(startIndex, buffer, routeRule);
911 break;
912 case ROUTE_SELECTION_DESCRIPTOR_COMPONENT_PDU_SESSION_TYPE:
913 ret = DecodePduSessionType(startIndex, buffer, routeRule);
914 break;
915 case ROUTE_SELECTION_DESCRIPTOR_COMPONENT_PREFERRED_ACCESS_TYPE:
916 ret = DecodePreferredAccessType(startIndex, buffer, routeRule);
917 if (ret == DECODE_FAIL_UNKNOWN_IDENTIFIER) {
918 int sublen = len - (initBufferRemaining - (int(buffer.size()) - startIndex));
919 std::vector<uint8_t> dsts = std::vector<uint8_t>(sublen);
920 std::copy(buffer.begin() + startIndex, buffer.begin() + startIndex + sublen, dsts.begin());
921 startIndex += sublen;
922 }
923 break;
924 case ROUTE_SELECTION_DESCRIPTOR_COMPONENT_NON_3GPP_OFFLOAD:
925 break;
926 default:
927 int sublen = len - (initBufferRemaining - (int(buffer.size()) - startIndex));
928 std::vector<uint8_t> dsts = std::vector<uint8_t>(sublen);
929 for (int i = 0; i < sublen; ++i) {
930 dsts[i] = buffer[startIndex];
931 startIndex++;
932 }
933 ret = DECODE_FAIL_UNKNOWN_IDENTIFIER;
934 break;
935 }
936 if (ret != DECODE_SUCCESS) {
937 return ret;
938 }
939 }
940 return DECODE_SUCCESS;
941 }
942
DecodeOsIdOsAppId(int & startIndex,std::vector<uint8_t> buffer,TrafficDescriptor & trafficDescriptor,bool isAppIdOnly)943 int UrspConfig::DecodeOsIdOsAppId(int& startIndex, std::vector<uint8_t> buffer,
944 TrafficDescriptor& trafficDescriptor, bool isAppIdOnly)
945 {
946 if ((!isAppIdOnly) && ((int(buffer.size()) - startIndex) < (NetworkSliceCommConfig::LEN_SIXTEEN_BYTE
947 + NetworkSliceCommConfig::LEN_BYTE))) {
948 NETMGR_EXT_LOG_E("buffer.remaining() < osId Len");
949 return DECODE_FAIL_OTHER;
950 }
951 std::string osId = "";
952 if (!isAppIdOnly) {
953 for (int i = 0; i < NetworkSliceCommConfig::LEN_SIXTEEN_BYTE; i++) {
954 osId += ByteToHexStr(buffer[startIndex++]);
955 }
956 }
957 OsAppId osAppId;
958 osAppId.setOsId(osId);
959 uint8_t stringLen = buffer[startIndex++];
960 if ((int(buffer.size()) - startIndex) < stringLen) {
961 NETMGR_EXT_LOG_E("buffer.remaining() < appId Len");
962 return DECODE_FAIL_OTHER;
963 }
964 std::string stringBuffer = "";
965 for (int i = 0; i < stringLen; i++) {
966 stringBuffer += static_cast<char>(buffer[startIndex++]);
967 }
968 NETMGR_EXT_LOG_I("DecodeOsId:%{public}s, OsAppId:%{public}s", osId.c_str(), stringBuffer.c_str());
969 osAppId.setAppId(stringBuffer);
970 trafficDescriptor.osAppIds.push_back(osAppId);
971 return DECODE_SUCCESS;
972 }
973
DecodeIpv4Addr(int & startIndex,std::vector<uint8_t> buffer,TrafficDescriptor & trafficDescriptor)974 int UrspConfig::DecodeIpv4Addr(int& startIndex, std::vector<uint8_t> buffer, TrafficDescriptor& trafficDescriptor)
975 {
976 std::vector<uint8_t> ipv4(NetworkSliceCommConfig::LEN_INT, 0);
977 if ((int(buffer.size()) - startIndex) < NetworkSliceCommConfig::LEN_EIGHT_BYTE) {
978 NETMGR_EXT_LOG_E("buffer.remaining() < Ipv4Addr Len");
979 return DECODE_FAIL_OTHER;
980 }
981 for (int i = 0; i < NetworkSliceCommConfig::LEN_INT; i++) {
982 ipv4[i] = buffer[startIndex++];
983 }
984 Ipv4Addr ipv4Addr;
985 ipv4Addr.setIpv4Addr(vectorToUint32(ipv4));
986 for (int i = 0; i < NetworkSliceCommConfig::LEN_INT; i++) {
987 ipv4[i] = buffer[startIndex++];
988 }
989 ipv4Addr.setIpv4Mask(vectorToUint32(ipv4));
990 trafficDescriptor.ipv4Addrs.push_back(ipv4Addr);
991 return DECODE_SUCCESS;
992 }
993
DecodeIpv6Addr(int & startIndex,std::vector<uint8_t> buffer,TrafficDescriptor & trafficDescriptor)994 int UrspConfig::DecodeIpv6Addr(int& startIndex, std::vector<uint8_t> buffer, TrafficDescriptor& trafficDescriptor)
995 {
996 std::vector<uint8_t> ipv6(NetworkSliceCommConfig::LEN_SIXTEEN_BYTE, 0);
997 if ((int(buffer.size()) - startIndex) <
998 NetworkSliceCommConfig::LEN_SIXTEEN_BYTE + NetworkSliceCommConfig::LEN_BYTE) {
999 NETMGR_EXT_LOG_E("buffer.remaining() < Ipv6Addr Len");
1000 return DECODE_FAIL_OTHER;
1001 }
1002 for (int i = 0; i < NetworkSliceCommConfig::LEN_SIXTEEN_BYTE; i++) {
1003 ipv6[i] = buffer[startIndex++];
1004 }
1005 Ipv6Addr ipv6Addr;
1006 ipv6Addr.setIpv6Addr(vectorToIPv6Array(ipv6));
1007 ipv6Addr.setIpv6PrefixLen(static_cast<int>(buffer[startIndex++]));
1008 trafficDescriptor.ipv6Addrs.push_back(ipv6Addr);
1009 return DECODE_SUCCESS;
1010 }
1011
DecodeProtocolId(int & startIndex,std::vector<uint8_t> buffer,TrafficDescriptor & trafficDescriptor)1012 int UrspConfig::DecodeProtocolId(int& startIndex, std::vector<uint8_t> buffer, TrafficDescriptor& trafficDescriptor)
1013 {
1014 if ((int(buffer.size()) - startIndex) < NetworkSliceCommConfig::LEN_BYTE) {
1015 NETMGR_EXT_LOG_E("buffer.remaining() < Protocol identifier/next header type Len");
1016 return DECODE_FAIL_OTHER;
1017 }
1018 trafficDescriptor.protocolIds.push_back(static_cast<int>(buffer[startIndex++]));
1019 return DECODE_SUCCESS;
1020 }
1021
DecodeSingleRemotePort(int & startIndex,std::vector<uint8_t> buffer,TrafficDescriptor & trafficDescriptor)1022 int UrspConfig::DecodeSingleRemotePort(int& startIndex, std::vector<uint8_t> buffer,
1023 TrafficDescriptor& trafficDescriptor)
1024 {
1025 if ((int(buffer.size()) - startIndex) < NetworkSliceCommConfig::LEN_SHORT) {
1026 NETMGR_EXT_LOG_E("buffer.remaining() < Single remote port type Len");
1027 return DECODE_FAIL_OTHER;
1028 }
1029 trafficDescriptor.singleRemotePorts.push_back(ConvertUnsignedShort2Int(GetShort(startIndex, buffer)));
1030 return DECODE_SUCCESS;
1031 }
1032
DecodeRemotePortRange(int & startIndex,std::vector<uint8_t> buffer,TrafficDescriptor & trafficDescriptor)1033 int UrspConfig::DecodeRemotePortRange(int& startIndex,
1034 std::vector<uint8_t> buffer, TrafficDescriptor& trafficDescriptor)
1035 {
1036 if ((int(buffer.size()) - startIndex) < NetworkSliceCommConfig::LEN_INT) {
1037 NETMGR_EXT_LOG_E("buffer.remaining() < Remote port range type Len");
1038 return DECODE_FAIL_OTHER;
1039 }
1040 RemotePortRange portRang;
1041 portRang.setPortRangeLowLimit(ConvertUnsignedShort2Int(GetShort(startIndex, buffer)));
1042 portRang.setPortRangeHighLimit(ConvertUnsignedShort2Int(GetShort(startIndex, buffer)));
1043 trafficDescriptor.remotePortRanges.push_back(portRang);
1044 return DECODE_SUCCESS;
1045 }
1046
DecodeTrafficDescriptorDnn(int & startIndex,std::vector<uint8_t> buffer,TrafficDescriptor & trafficDescriptor)1047 int UrspConfig::DecodeTrafficDescriptorDnn(int& startIndex, std::vector<uint8_t> buffer,
1048 TrafficDescriptor& trafficDescriptor)
1049 {
1050 if ((int(buffer.size()) - startIndex) < NetworkSliceCommConfig::LEN_BYTE) {
1051 NETMGR_EXT_LOG_E("buffer.remaining() < LEN_BYTE for dnn type");
1052 return DECODE_FAIL_OTHER;
1053 }
1054 uint8_t stringLen = buffer[startIndex++];
1055 if ((int(buffer.size()) - startIndex) < stringLen) {
1056 NETMGR_EXT_LOG_E("buffer.remaining()[%{public}d] < dnn Len[%{public}d]",
1057 (int(buffer.size()) - startIndex), stringLen);
1058 return DECODE_FAIL_OTHER;
1059 }
1060 std::string stringBuffer = DecodeSubDnns(startIndex, buffer, stringLen);
1061 if (stringBuffer == "") {
1062 return DECODE_FAIL_OTHER;
1063 }
1064 std::string dnn = stringBuffer;
1065 trafficDescriptor.dnns.push_back(dnn);
1066 if ("ims" == dnn || "IMS" == dnn) {
1067 mIsTrafficDescriptorIncludeIms = true;
1068 }
1069 return DECODE_SUCCESS;
1070 }
1071
DecodeFqdn(int & startIndex,std::vector<uint8_t> buffer,TrafficDescriptor & trafficDescriptor)1072 int UrspConfig::DecodeFqdn(int& startIndex, std::vector<uint8_t> buffer, TrafficDescriptor& trafficDescriptor)
1073 {
1074 if (mUrspVersion == NetworkSliceCommConfig::URSP_VERSION_1510) {
1075 NETMGR_EXT_LOG_E("mUrspVersion = 1510 but Traffic descriptor is FQDN");
1076 return DECODE_FAIL_UNKNOWN_IDENTIFIER;
1077 }
1078 if ((int(buffer.size()) - startIndex) < NetworkSliceCommConfig::LEN_BYTE) {
1079 NETMGR_EXT_LOG_E("buffer.remaining() < LEN_BYTE for fqdn type");
1080 return DECODE_FAIL_OTHER;
1081 }
1082 uint8_t stringLen = buffer[startIndex++];
1083 if ((int(buffer.size()) - startIndex) < stringLen) {
1084 NETMGR_EXT_LOG_E("buffer.remaining() < fqdn Len");
1085 return DECODE_FAIL_OTHER;
1086 }
1087 std::string stringBuffer = DecodeSubDnns(startIndex, buffer, stringLen);
1088 if (stringBuffer == "") {
1089 return DECODE_FAIL_OTHER;
1090 }
1091 trafficDescriptor.fqdns.push_back(stringBuffer);
1092 return DECODE_SUCCESS;
1093 }
1094
DecodeSubDnns(int & startIndex,std::vector<uint8_t> buffer,uint8_t stringLen)1095 std::string UrspConfig::DecodeSubDnns(int& startIndex, std::vector<uint8_t> buffer, uint8_t stringLen)
1096 {
1097 std::string stringBuffer = "";
1098 int cnt = 0;
1099 for (int i = 0; i < (int)stringLen; i++) {
1100 if (cnt == 0) {
1101 cnt = buffer[startIndex++];
1102 if (cnt > stringLen - i - 1) {
1103 NETMGR_EXT_LOG_E("buffer remaining [%{public}d] < sub dnn len [%{public}d]", (stringLen - i), cnt);
1104 return "";
1105 }
1106 if (i > 0) {
1107 stringBuffer += ".";
1108 }
1109 } else {
1110 stringBuffer += static_cast<char>(buffer[startIndex++]);
1111 cnt--;
1112 }
1113 }
1114 if (cnt > 0) {
1115 NETMGR_EXT_LOG_E("can not get full sub dnn [%{public}d]", cnt);
1116 return "";
1117 }
1118 return stringBuffer;
1119 }
1120
DecodeConnectionCapabilities(int & startIndex,std::vector<uint8_t> buffer,TrafficDescriptor & trafficDescriptor)1121 int UrspConfig::DecodeConnectionCapabilities(int& startIndex, std::vector<uint8_t> buffer,
1122 TrafficDescriptor& trafficDescriptor)
1123 {
1124 if ((int(buffer.size()) - startIndex) < NetworkSliceCommConfig::LEN_BYTE) {
1125 NETMGR_EXT_LOG_E("buffer.remaining() < LEN_BYTE for Connection capabilities type");
1126 return DECODE_FAIL_OTHER;
1127 }
1128 uint8_t stringLen = buffer[startIndex++];
1129 if ((int(buffer.size()) - startIndex) < stringLen) {
1130 NETMGR_EXT_LOG_E("buffer.remaining() < Connection capabilities type len");
1131 return DECODE_FAIL_OTHER;
1132 }
1133 for (int i = 0; i < stringLen; i++) {
1134 int connCapability = static_cast<int>(buffer[startIndex++]);
1135 trafficDescriptor.connectionCapabilities.push_back(connCapability);
1136 if ((connCapability & CONNECTION_CAPABILITY_TYPE_IMS) != 0) {
1137 mIsTrafficDescriptorIncludeIms = true;
1138 }
1139 }
1140 return DECODE_SUCCESS;
1141 }
1142
DecodeSscMode(int & startIndex,std::vector<uint8_t> buffer,RouteSelectionDescriptor & routeRule)1143 int UrspConfig::DecodeSscMode(int& startIndex, std::vector<uint8_t> buffer, RouteSelectionDescriptor &routeRule)
1144 {
1145 if ((int(buffer.size()) - startIndex) < NetworkSliceCommConfig::LEN_BYTE) {
1146 NETMGR_EXT_LOG_E("buffer.remaining() < SSC mode type len");
1147 return DECODE_FAIL_OTHER;
1148 }
1149 /*
1150 * The bits 8 through 4 of the octet shall be spare,
1151 * and the bits 3 through 1 shall be encoded as the value part of the SSC mode
1152 */
1153 routeRule.sscMode = buffer[startIndex++] & 0x07;
1154 NETMGR_EXT_LOG_I("SSC mode:%{public}d", routeRule.sscMode);
1155 return DECODE_SUCCESS;
1156 }
1157
DecodeSnssai(int & startIndex,std::vector<uint8_t> buffer,RouteSelectionDescriptor & routeRule)1158 int UrspConfig::DecodeSnssai(int& startIndex, std::vector<uint8_t> buffer, RouteSelectionDescriptor &routeRule)
1159 {
1160 if ((int(buffer.size()) - startIndex) < NetworkSliceCommConfig::LEN_BYTE) {
1161 NETMGR_EXT_LOG_E("buffer.remaining() < LEN_BYTE for S-NSSAI type");
1162 return DECODE_FAIL_OTHER;
1163 }
1164 uint8_t subLen = buffer[startIndex++];
1165 if ((int(buffer.size()) - startIndex) < subLen) {
1166 NETMGR_EXT_LOG_E("buffer.remaining() < S-NSSAI type len");
1167 return DECODE_FAIL_OTHER;
1168 }
1169 Snssai snssai;
1170 if (!sAllowedNssaiConfig_->DecodeSnssai(startIndex, subLen, buffer, snssai)) {
1171 NETMGR_EXT_LOG_E("AllowedNssaiConfig.decodeSNssai(subLen, buffer, sNssai) is false");
1172 return DECODE_FAIL_OTHER;
1173 }
1174 routeRule.snssais.push_back(snssai);
1175 return DECODE_SUCCESS;
1176 }
1177
DecodeDnn(int & startIndex,std::vector<uint8_t> buffer,RouteSelectionDescriptor & routeRule)1178 int UrspConfig::DecodeDnn(int& startIndex, std::vector<uint8_t> buffer, RouteSelectionDescriptor &routeRule)
1179 {
1180 if ((int(buffer.size()) - startIndex) < NetworkSliceCommConfig::LEN_BYTE) {
1181 NETMGR_EXT_LOG_E("buffer.remaining() < LEN_BYTE for dnn type");
1182 return DECODE_FAIL_OTHER;
1183 }
1184 uint8_t stringLen = buffer[startIndex++];
1185 if ((int(buffer.size()) - startIndex) < stringLen) {
1186 NETMGR_EXT_LOG_E("buffer.remaining()[%{public}d] < dnn Len[%{public}d]",
1187 (int(buffer.size()) - startIndex), stringLen);
1188 return DECODE_FAIL_OTHER;
1189 }
1190 std::string stringBuffer = DecodeSubDnns(startIndex, buffer, stringLen);
1191 if (stringBuffer == "") {
1192 return DECODE_FAIL_OTHER;
1193 }
1194 std::string dnn = stringBuffer;
1195 NETMGR_EXT_LOG_I("DNN:%{public}s", dnn.c_str());
1196 routeRule.dnns.push_back(dnn);
1197 return DECODE_SUCCESS;
1198 }
1199
DecodePduSessionType(int & startIndex,std::vector<uint8_t> buffer,RouteSelectionDescriptor & routeRule)1200 int UrspConfig::DecodePduSessionType(int& startIndex, std::vector<uint8_t> buffer, RouteSelectionDescriptor &routeRule)
1201 {
1202 if ((int(buffer.size()) - startIndex) < NetworkSliceCommConfig::LEN_BYTE) {
1203 NETMGR_EXT_LOG_E("buffer.remaining() < Preferred access type len");
1204 return DECODE_FAIL_OTHER;
1205 }
1206 /*
1207 * The bits 8 through 4 of the octet shall be spare,
1208 * and the bits 3 through 1 shall be encoded as the value part of the PDU session type
1209 */
1210 routeRule.pduSessionType = TransferPduSessionTypeToHal(buffer[startIndex++] & 0x07);
1211 NETMGR_EXT_LOG_I("decodePduSessionType pduSessionType = %{public}d", routeRule.pduSessionType);
1212 return DECODE_SUCCESS;
1213 }
1214
TransferPduSessionTypeToHal(int pduSessionType)1215 int UrspConfig::TransferPduSessionTypeToHal(int pduSessionType)
1216 {
1217 NETMGR_EXT_LOG_I("transferPduSessionTypeToHal pduSessionType = %{public}d", pduSessionType);
1218 switch (pduSessionType) {
1219 case PROTOCOL_PDU_SESSION_TYPE_IPV4:
1220 return HAL_PDU_SESSION_TYPE_IP;
1221 case PROTOCOL_PDU_SESSION_TYPE_IPV6:
1222 return HAL_PDU_SESSION_TYPE_IPV6;
1223 case PROTOCOL_PDU_SESSION_TYPE_IPV4V6:
1224 return HAL_PDU_SESSION_TYPE_IPV4V6;
1225 case PROTOCOL_PDU_SESSION_TYPE_UNSTRUCTURED:
1226 return HAL_PDU_SESSION_TYPE_UNSTRUCTURED;
1227 case PROTOCOL_PDU_SESSION_TYPE_ETHERNET:
1228 return HAL_PDU_SESSION_TYPE_NON_IP;
1229 case PROTOCOL_PDU_SESSION_TYPE_RESERVED:
1230 return HAL_PDU_SESSION_TYPE_IPV4V6;
1231 default:
1232 return HAL_PDU_SESSION_TYPE_IPV4V6;
1233 }
1234 }
1235
DecodePreferredAccessType(int & startIndex,std::vector<uint8_t> buffer,RouteSelectionDescriptor & routeRule)1236 int UrspConfig::DecodePreferredAccessType(int& startIndex, std::vector<uint8_t> buffer,
1237 RouteSelectionDescriptor &routeRule)
1238 {
1239 if ((int(buffer.size()) - startIndex) < NetworkSliceCommConfig::LEN_BYTE) {
1240 NETMGR_EXT_LOG_E("buffer.remaining() < PDU session type len");
1241 return DECODE_FAIL_OTHER;
1242 }
1243 if (buffer[startIndex++] == PREFERRED_ACCESS_TYPE_NON_3GPP) {
1244 return DECODE_FAIL_UNKNOWN_IDENTIFIER;
1245 }
1246 return DECODE_SUCCESS;
1247 }
1248
SndPreImsRsdList()1249 void UrspConfig::SndPreImsRsdList()
1250 {
1251 std::vector<uint8_t> rsdBytes = GetImsRsdList();
1252 if (!rsdBytes.empty()) {
1253 NETMGR_EXT_LOG_I("UrspConfig::SndPreImsRsdList");
1254 Telephony::CellularDataClient::GetInstance().SendImsRsdList(MODEM_ID, rsdBytes);
1255 }
1256 }
1257
GetImsRsdList()1258 std::vector<uint8_t> UrspConfig::GetImsRsdList()
1259 {
1260 if (mImsRsdsMap.empty()) {
1261 return std::vector<uint8_t>();
1262 }
1263 std::vector<uint8_t> rsdBytes = ConvertRsdList2BufferArray(mImsRsdsMap);
1264 ResetImsRsdsMap();
1265 return rsdBytes;
1266 }
1267
SortRsdsMap(std::unordered_map<int,std::vector<RouteSelectionDescriptor>> rsdsMap)1268 std::vector<RouteSelectionDescriptor> UrspConfig::SortRsdsMap(
1269 std::unordered_map<int, std::vector<RouteSelectionDescriptor>> rsdsMap)
1270 {
1271 std::vector<int> keyList;
1272 for (auto& it: rsdsMap) {
1273 keyList.push_back(it.first);
1274 }
1275 std::sort(keyList.begin(), keyList.end(), [](int a, int b) { return a > b;});
1276
1277 std::vector<RouteSelectionDescriptor> rsdList;
1278 for (int& key : keyList) {
1279 std::vector<RouteSelectionDescriptor> outOfOrderList = rsdsMap[key];
1280 std::sort(outOfOrderList.begin(), outOfOrderList.end(), [](auto& r1, auto& r2) {
1281 return r1.routePrecedence < r2.routePrecedence;
1282 });
1283 rsdList.insert(rsdList.end(), outOfOrderList.begin(), outOfOrderList.end());
1284 }
1285 return rsdList;
1286 }
1287
ConvertRsdList2BufferArray(std::unordered_map<int,std::vector<RouteSelectionDescriptor>> rsdsMap)1288 std::vector<uint8_t> UrspConfig::ConvertRsdList2BufferArray(
1289 std::unordered_map<int, std::vector<RouteSelectionDescriptor>> rsdsMap)
1290 {
1291 std::vector<RouteSelectionDescriptor> rsdList = SortRsdsMap(rsdsMap);
1292 for (size_t i = 0; i < rsdList.size(); ++i) {
1293 if (sAllowedNssaiConfig_ == nullptr) {
1294 break;
1295 }
1296 if (rsdList[i].snssais.size() == 0) {
1297 ++i;
1298 continue;
1299 }
1300 if (sAllowedNssaiConfig_->FindSnssaiInAllowedNssai(rsdList[i].snssais) != "") {
1301 ++i;
1302 continue;
1303 } else {
1304 rsdList.erase(rsdList.begin() + i);
1305 }
1306 }
1307 if (rsdList.size() == 0) {
1308 return NotifyImsaDelRsdInfo();
1309 }
1310 while (rsdList.size() > RSD_MAX_LIST_NUM) {
1311 rsdList.erase(rsdList.begin() + RSD_MAX_LIST_NUM);
1312 }
1313 int dataLen = CalculateRsdListLen();
1314 int rsdNum = rsdList.size();
1315 NETMGR_EXT_LOG_I("convertRsdList2Buffer rsdNum = %{public}d, dataLen = %{public}d", rsdNum, dataLen);
1316 std::vector<uint8_t> rsdBytes;
1317 if (dataLen == INVALID_VALUE) {
1318 NETMGR_EXT_LOG_E("dataLen of rsdList is 0 ");
1319 return rsdBytes;
1320 }
1321
1322 /* put version */
1323 PutShort(rsdBytes, IMSA_VERSION);
1324 /* put length */
1325 PutShort(rsdBytes, static_cast<short>(dataLen));
1326 /* put rsdNum */
1327 PutInt(rsdBytes, rsdNum);
1328 /* put rsdInfo */
1329 PutRsdListInfo(rsdBytes, rsdList);
1330 return rsdBytes;
1331 }
1332
PutRsdListInfo(std::vector<uint8_t> & buffer,std::vector<RouteSelectionDescriptor> rsdList)1333 void UrspConfig::PutRsdListInfo(std::vector<uint8_t>& buffer, std::vector<RouteSelectionDescriptor> rsdList)
1334 {
1335 int rsdNum = (int)rsdList.size();
1336 int emptyRsdNum = RSD_MAX_LIST_NUM - rsdNum;
1337 for (RouteSelectionDescriptor rsd : rsdList) {
1338 /* put routePrecedence and 3B reserve */
1339 buffer.push_back(ConvertInt2UnsignedByte(rsd.routePrecedence));
1340 buffer.push_back(0);
1341 buffer.push_back(0);
1342 buffer.push_back(0);
1343
1344 /* put isExistSscMode */
1345 if (rsd.sscMode == 0) {
1346 buffer.push_back(0);
1347 } else {
1348 buffer.push_back(1);
1349 }
1350 /* put sscMode */
1351 buffer.push_back(rsd.sscMode);
1352 /* put pduSessionType */
1353 buffer.push_back(ConvertInt2UnsignedByte(ConvertPduTypeFromHal2Imsa(rsd.pduSessionType)));
1354 /* put 2B(reserve) */
1355 buffer.push_back(0);
1356 buffer.push_back(0);
1357 /* put dnnsInfo */
1358 PutDnnsInfo(buffer, rsd);
1359 /* put nssaisInfo */
1360 PutNssaisInfo(buffer, rsd);
1361 /* put 4B reserve */
1362 buffer.push_back(0);
1363 buffer.push_back(0);
1364 buffer.push_back(0);
1365 buffer.push_back(0);
1366 }
1367 if (emptyRsdNum > 0) {
1368 int rsdLen = CalculateRsdLen();
1369 int nullLen = rsdLen * emptyRsdNum;
1370 PutInvalidValue(buffer, nullLen);
1371 }
1372 }
1373
PutDnnsInfo(std::vector<uint8_t> & buffer,RouteSelectionDescriptor rsd)1374 void UrspConfig::PutDnnsInfo(std::vector<uint8_t>& buffer, RouteSelectionDescriptor rsd)
1375 {
1376 while (rsd.dnns.size() > RSD_MAX_DNN_NUM) {
1377 rsd.dnns.erase(rsd.dnns.begin() + RSD_MAX_DNN_NUM);
1378 }
1379 int dnnNum = rsd.dnns.size();
1380 int emptyNum = RSD_MAX_DNN_NUM - dnnNum;
1381
1382 /* put dnnNum */
1383 PutInt(buffer, dnnNum);
1384
1385 /* put dnns */
1386 for (std::string dnn : rsd.dnns) {
1387 std::vector<uint8_t> dnnBytes = ConvertstringTouInt8Vector(dnn);
1388 int dnnLen = dnnBytes.size();
1389 int nullNum = RSD_MAX_DNN_LEN - dnnLen;
1390
1391 /* put dnnLen */
1392 buffer.push_back(ConvertInt2UnsignedByte(dnnLen));
1393
1394 /* put dnnValue */
1395 buffer.insert(buffer.end(), dnnBytes.begin(), dnnBytes.end());
1396
1397 if (nullNum > 0) {
1398 PutInvalidValue(buffer, nullNum);
1399 }
1400 }
1401
1402 if (emptyNum > 0) {
1403 int nullNum = emptyNum * (RSD_MAX_DNN_LEN + NetworkSliceCommConfig::LEN_BYTE);
1404 PutInvalidValue(buffer, nullNum);
1405 }
1406 }
1407
PutNssaisInfo(std::vector<uint8_t> & buffer,RouteSelectionDescriptor rsd)1408 void UrspConfig::PutNssaisInfo(std::vector<uint8_t>& buffer, RouteSelectionDescriptor rsd)
1409 {
1410 for (int i = 0; i < (int)rsd.snssais.size();) {
1411 if (sAllowedNssaiConfig_ == nullptr) {
1412 break;
1413 }
1414 if (sAllowedNssaiConfig_->isSnssaiInAllowedNssai(rsd.snssais[i]) != "") {
1415 i++;
1416 continue;
1417 } else {
1418 rsd.snssais.erase(rsd.snssais.begin() + i);
1419 }
1420 }
1421 while (rsd.snssais.size() > RSD_MAX_NSSAI_NUM) {
1422 rsd.snssais.erase(rsd.snssais.begin() + RSD_MAX_NSSAI_NUM);
1423 }
1424 int snssaiNum = (int)rsd.snssais.size();
1425 int emptyNum = RSD_MAX_NSSAI_NUM - snssaiNum;
1426 /* put snssaiNum */
1427 PutInt(buffer, snssaiNum);
1428 /* put nssaiInfo */
1429 for (Snssai snssai : rsd.snssais) {
1430 /* put bitOption */
1431 int bitOpt = 0;
1432 if (snssai.getSd() != 0) {
1433 bitOpt = SetBitOpt(bitOpt, FIRSTBYTE);
1434 }
1435 if (snssai.getMappedSst() != 0) {
1436 bitOpt = SetBitOpt(bitOpt, SECONDBYTE);
1437 }
1438 if (snssai.getMappedSd() != 0) {
1439 bitOpt = SetBitOpt(bitOpt, THIRDBYTE);
1440 }
1441
1442 PutInt(buffer, bitOpt);
1443 /* put sst */
1444 buffer.push_back(snssai.getSst());
1445
1446 /* put mappedSst */
1447 buffer.push_back(snssai.getMappedSst());
1448
1449 /* put 2B reserve */
1450 buffer.push_back(0);
1451 buffer.push_back(0);
1452
1453 /* put sd */
1454 PutInt(buffer, snssai.getSd());
1455
1456 /* put mappedSd */
1457 PutInt(buffer, snssai.getMappedSd());
1458 }
1459
1460 if (emptyNum > 0) {
1461 /* 4B(bitOption) + 1B(sst) + 1B(mappedSst) + 2B(reserve) + 4B(sd) + 4B(mappedSd) */
1462 int snssaiLen = (4 + 1 + 1 + 2 + 4 + 4) * NetworkSliceCommConfig::LEN_BYTE;
1463 int nullNum = emptyNum * snssaiLen;
1464 PutInvalidValue(buffer, nullNum);
1465 }
1466 }
1467
SetBitOpt(int num,int position)1468 int UrspConfig::SetBitOpt(int num, int position)
1469 {
1470 int temp = 1;
1471 temp <<= position - 1;
1472 num = num | temp;
1473 return num;
1474 }
1475
1476
ConvertPduTypeFromHal2Imsa(int halPduType)1477 int UrspConfig::ConvertPduTypeFromHal2Imsa(int halPduType)
1478 {
1479 return (halPduType + 1);
1480 }
1481
NotifyImsaDelRsdInfo()1482 std::vector<uint8_t> UrspConfig::NotifyImsaDelRsdInfo()
1483 {
1484 std::vector<uint8_t> buffer;
1485 /* put version */
1486 PutShort(buffer, IMSA_VERSION);
1487 /* put length */
1488 PutShort(buffer, 0);
1489 return buffer;
1490 }
1491
PutInvalidValue(std::vector<uint8_t> & buffer,int num)1492 void UrspConfig::PutInvalidValue(std::vector<uint8_t>& buffer, int num)
1493 {
1494 for (int i = 0; i < num; i++) {
1495 buffer.push_back(0);
1496 }
1497 }
1498
CalculateRsdListLen()1499 short UrspConfig::CalculateRsdListLen()
1500 {
1501 short dataLen = 0;
1502 /* 4B RsdNum */
1503 dataLen += NetworkSliceCommConfig::LEN_INT;
1504 dataLen += CalculateRsdLen() * RSD_MAX_LIST_NUM;
1505 return dataLen;
1506 }
1507
CalculateRsdLen()1508 short UrspConfig::CalculateRsdLen()
1509 {
1510 short dataLen = 0;
1511 /* 4B = 1B(routePrecedence) + 3B(reserve) */
1512 dataLen += 4 * NetworkSliceCommConfig::LEN_BYTE;
1513
1514 /* 4B = 1B(isExist) + 1B(sscMode) + 2B(reserve) */
1515 dataLen += 4 * NetworkSliceCommConfig::LEN_BYTE;
1516
1517 /* 4B = 1B(isExist) + 1B(pduType) + 2B(reserve) */
1518 dataLen += 4 * NetworkSliceCommConfig::LEN_BYTE;
1519
1520 /* 4B(dnnNum) */
1521 dataLen += 4 * NetworkSliceCommConfig::LEN_BYTE;
1522 dataLen += (RSD_MAX_DNN_LEN + NetworkSliceCommConfig::LEN_BYTE) * RSD_MAX_DNN_NUM;
1523
1524 /* 4B(nssaiNum) */
1525 dataLen += 4 * NetworkSliceCommConfig::LEN_BYTE;
1526
1527 /* 4B(bitOption) + 1B(sst) + 1B(mappedSst) + 2B(reserve) + 4B(sd) + 4B(mappedSd) */
1528 short snssaiLen = (4 + 1 + 1 + 2 + 4 + 4) * NetworkSliceCommConfig::LEN_BYTE;
1529 dataLen += snssaiLen * RSD_MAX_NSSAI_NUM;
1530
1531 /* 4B(reserve) */
1532 dataLen += 4 * NetworkSliceCommConfig::LEN_BYTE;
1533 return dataLen;
1534 }
1535
SliceNetworkSelection(SelectedRouteDescriptor & routeRule,std::string plmn,AppDescriptor appDescriptor)1536 bool UrspConfig::SliceNetworkSelection(
1537 SelectedRouteDescriptor& routeRule, std::string plmn, AppDescriptor appDescriptor)
1538 {
1539 NETMGR_EXT_LOG_I("SliceNetworkSelection");
1540 std::unordered_map<std::string, std::vector<UrspRule>> uePolicyMap =
1541 mUePolicyMap.empty() ? mPreConfigUrspMap : mUePolicyMap;
1542 std::vector<UrspRule> urspRules = uePolicyMap.begin()->second;
1543 UrspRule urspRule;
1544 for (size_t i = 0; i < urspRules.size(); i++) {
1545 urspRule = urspRules[i];
1546 if (!isTrafficDescriptorMatch(urspRule.trafficDescriptor, appDescriptor)) {
1547 NETMGR_EXT_LOG_I("!isTrafficDescriptorMatch");
1548 continue;
1549 }
1550 if (!FindAvailableRouteRule(urspRule.routeSelectionDescriptors, routeRule)) {
1551 NETMGR_EXT_LOG_I("Not FindAvailableRouteRule");
1552 continue;
1553 }
1554 routeRule.setUrspPrecedence(static_cast<uint8_t>(urspRule.urspPrecedence));
1555 FillTrafficDescriptor(urspRule.trafficDescriptor, appDescriptor, routeRule);
1556 return true;
1557 }
1558 return false;
1559 }
1560
FindAvailableRouteRule(const std::vector<RouteSelectionDescriptor> & routeSelectionDescriptors,SelectedRouteDescriptor & routeRule)1561 bool UrspConfig::FindAvailableRouteRule(
1562 const std::vector<RouteSelectionDescriptor>& routeSelectionDescriptors, SelectedRouteDescriptor& routeRule)
1563 {
1564 NETMGR_EXT_LOG_I("FindAvailableRouteRule size = %{public}d", (int)routeSelectionDescriptors.size());
1565 for (size_t i = 0; i < routeSelectionDescriptors.size(); i++) {
1566 routeRule.setPduSessionType(routeSelectionDescriptors[i].pduSessionType);
1567 routeRule.setSscMode(routeSelectionDescriptors[i].sscMode);
1568 if (DelayedSingleton<NetworkSliceManager>::GetInstance()->isRouteRuleInForbiddenList(routeRule)) {
1569 NETMGR_EXT_LOG_I("isRouteRuleInForbiddenList");
1570 continue;
1571 }
1572 if (!routeSelectionDescriptors[i].snssais.empty() && !routeSelectionDescriptors[i].dnns.empty()) {
1573 if (!FindAvailableSnssaiAndDnn(routeSelectionDescriptors[i], routeRule)) {
1574 continue;
1575 }
1576 }
1577 if (!routeSelectionDescriptors[i].snssais.empty() && routeSelectionDescriptors[i].dnns.empty()) {
1578 if (!FindAvailableSnssai(routeSelectionDescriptors[i], routeRule)) {
1579 continue;
1580 }
1581 }
1582 if (routeSelectionDescriptors[i].snssais.empty() && !routeSelectionDescriptors[i].dnns.empty()) {
1583 if (!FindAvailableDnn(routeSelectionDescriptors[i], routeRule)) {
1584 continue;
1585 }
1586 }
1587 return true;
1588 }
1589 return false;
1590 }
1591
FindAvailableSnssaiAndDnn(const RouteSelectionDescriptor & routeSelectionDescriptor,SelectedRouteDescriptor & routeRule)1592 bool UrspConfig::FindAvailableSnssaiAndDnn(const RouteSelectionDescriptor& routeSelectionDescriptor,
1593 SelectedRouteDescriptor& routeRule)
1594 {
1595 NETMGR_EXT_LOG_I("FindAvailableSnssaiAndDnn");
1596 for (size_t i = 0; i < routeSelectionDescriptor.snssais.size(); i++) {
1597 if (sAllowedNssaiConfig_ == nullptr) {
1598 continue;
1599 }
1600 Snssai snssai = routeSelectionDescriptor.snssais[i];
1601 std::string stringSnssai = sAllowedNssaiConfig_->isSnssaiInAllowedNssai(snssai);
1602 NETMGR_EXT_LOG_I("FindAvailableSnssaiAndDnn stringSnssai = %{public}s", stringSnssai.c_str());
1603 if (stringSnssai.empty()) {
1604 continue;
1605 }
1606 routeRule.setSnssai(stringSnssai);
1607 for (size_t j = 0; j < routeSelectionDescriptor.dnns.size(); j++) {
1608 std::string dnn = routeSelectionDescriptor.dnns[j];
1609 routeRule.setDnn(dnn);
1610 NETMGR_EXT_LOG_I("FindAvailableDnn:%{public}s", dnn.c_str());
1611 if (DelayedSingleton<NetworkSliceManager>::GetInstance()->isRouteRuleInForbiddenList(routeRule)) {
1612 continue;
1613 }
1614 return true;
1615 }
1616 }
1617 return false;
1618 }
1619
FindAvailableSnssai(const RouteSelectionDescriptor & routeSelectionDescriptor,SelectedRouteDescriptor & routeRule)1620 bool UrspConfig::FindAvailableSnssai(const RouteSelectionDescriptor& routeSelectionDescriptor,
1621 SelectedRouteDescriptor& routeRule)
1622 {
1623 for (size_t i = 0; i < routeSelectionDescriptor.snssais.size(); i++) {
1624 if (sAllowedNssaiConfig_ == nullptr) {
1625 continue;
1626 }
1627 Snssai snssai = routeSelectionDescriptor.snssais[i];
1628 NETMGR_EXT_LOG_I("FindAvailableSnssai snssai = %{public}s", snssai.getSnssai().c_str());
1629 std::string stringSnssai = sAllowedNssaiConfig_->isSnssaiInAllowedNssai(snssai);
1630 if (stringSnssai.empty()) {
1631 continue;
1632 }
1633 routeRule.setSnssai(stringSnssai);
1634 if (DelayedSingleton<NetworkSliceManager>::GetInstance()->isRouteRuleInForbiddenList(routeRule)) {
1635 continue;
1636 }
1637 return true;
1638 }
1639 return false;
1640 }
1641
FindAvailableDnn(const RouteSelectionDescriptor & routeSelectionDescriptor,SelectedRouteDescriptor & routeRule)1642 bool UrspConfig::FindAvailableDnn(const RouteSelectionDescriptor& routeSelectionDescriptor,
1643 SelectedRouteDescriptor& routeRule)
1644 {
1645 for (size_t j = 0; j < routeSelectionDescriptor.dnns.size(); j++) {
1646 const auto& dnn = routeSelectionDescriptor.dnns[j];
1647 routeRule.setDnn(dnn);
1648 if (DelayedSingleton<NetworkSliceManager>::GetInstance()->isRouteRuleInForbiddenList(routeRule)) {
1649 continue;
1650 }
1651 return true;
1652 }
1653 return false;
1654 }
1655 /**
1656 * judge if has available ursp rule
1657 *
1658 * @return true: has available ursp rule false: do not have available ursp rule
1659 */
hasAvailableUrspRule()1660 bool UrspConfig::hasAvailableUrspRule()
1661 {
1662 return (!mUePolicyMap.empty() || !mPreConfigUrspMap.empty());
1663 }
1664
FillTrafficDescriptor(TrafficDescriptor urspTrafficDescriptor,AppDescriptor appDescriptor,SelectedRouteDescriptor & routeRule)1665 void UrspConfig::FillTrafficDescriptor(TrafficDescriptor urspTrafficDescriptor,
1666 AppDescriptor appDescriptor, SelectedRouteDescriptor& routeRule)
1667 {
1668 NETMGR_EXT_LOG_I("FillTrafficDescriptor");
1669 uint8_t routeBitmap = 0;
1670
1671 if (urspTrafficDescriptor.isMatchAll) {
1672 routeBitmap = static_cast<uint8_t>(routeBitmap | 0x01);
1673 routeRule.setRouteBitmap(routeBitmap);
1674 return;
1675 }
1676 if (!urspTrafficDescriptor.osAppIds.empty()) {
1677 FillOsAppIds(urspTrafficDescriptor, routeRule);
1678 }
1679 if (!urspTrafficDescriptor.ipv4Addrs.empty()) {
1680 FillIpv4Addrs(urspTrafficDescriptor, routeRule);
1681 }
1682 if (!urspTrafficDescriptor.ipv6Addrs.empty()) {
1683 FillIpv6Addrs(urspTrafficDescriptor, routeRule);
1684 }
1685 if (!urspTrafficDescriptor.protocolIds.empty()) {
1686 FillProtocolIds(urspTrafficDescriptor, routeRule);
1687 }
1688 if (!urspTrafficDescriptor.dnns.empty()) {
1689 routeBitmap = static_cast<uint8_t>(routeBitmap | 0x02);
1690 routeRule.setDnn(appDescriptor.getDnn());
1691 }
1692 if (!urspTrafficDescriptor.fqdns.empty()) {
1693 routeBitmap = static_cast<uint8_t>(routeBitmap | 0x04);
1694 }
1695 if (!urspTrafficDescriptor.connectionCapabilities.empty()) {
1696 routeBitmap = static_cast<uint8_t>(routeBitmap | 0x08);
1697 }
1698 routeRule.setRouteBitmap(routeBitmap);
1699 NETMGR_EXT_LOG_I("fillTrafficDescriptor routeBitmap = %{public}d", static_cast<int>(routeBitmap));
1700 FillRemotePorts(urspTrafficDescriptor, routeRule);
1701 }
1702
FillOsAppIds(TrafficDescriptor urspTrafficDescriptor,SelectedRouteDescriptor & routeRule)1703 void UrspConfig::FillOsAppIds(TrafficDescriptor urspTrafficDescriptor,
1704 SelectedRouteDescriptor& routeRule)
1705 {
1706 std::string osAppIdsStr;
1707 for (size_t i = 0; i < urspTrafficDescriptor.osAppIds.size(); ++i) {
1708 std::string combinedOsAppId = urspTrafficDescriptor.osAppIds[i].getOsId()
1709 + "#" + urspTrafficDescriptor.osAppIds[i].getAppId();
1710 osAppIdsStr += combinedOsAppId;
1711 if (i < urspTrafficDescriptor.osAppIds.size() - 1) {
1712 osAppIdsStr += COMMA_SEPARATOR;
1713 }
1714 }
1715 routeRule.setAppIds(osAppIdsStr);
1716 }
1717
FillIpv4Addrs(TrafficDescriptor urspTrafficDescriptor,SelectedRouteDescriptor & routeRule)1718 void UrspConfig::FillIpv4Addrs(TrafficDescriptor urspTrafficDescriptor,
1719 SelectedRouteDescriptor& routeRule)
1720 {
1721 uint8_t ipv4Num = static_cast<uint8_t>(urspTrafficDescriptor.ipv4Addrs.size());
1722 std::vector<uint8_t> ipv4AddrAndMask(ipv4Num *
1723 (NetworkSliceCommConfig::LEN_INT + NetworkSliceCommConfig::LEN_INT, 0));
1724 size_t index = 0;
1725 for (const auto& ipv4Addr : urspTrafficDescriptor.ipv4Addrs) {
1726 uint32_t ipv4AddrValues = ipv4Addr.getIpv4Addr();
1727 uint32_t ipv4MaskValues = ipv4Addr.getIpv4Mask();
1728 std::vector<uint8_t> ipv4AddrValue_vec = uInt32ToVector(ipv4AddrValues);
1729 std::vector<uint8_t> ipv4MaskValues_vec = uInt32ToVector(ipv4MaskValues);
1730 for (size_t j = 0; j < NetworkSliceCommConfig::LEN_INT; ++j) {
1731 ipv4AddrAndMask[index++] = ipv4AddrValue_vec[j];
1732 }
1733 for (size_t j = 0; j < NetworkSliceCommConfig::LEN_INT; ++j) {
1734 ipv4AddrAndMask[index++] = ipv4MaskValues_vec[j];
1735 }
1736 }
1737 routeRule.setIpv4Num(ipv4Num);
1738 routeRule.setIpv4AddrAndMask(ipv4AddrAndMask);
1739 }
1740
FillIpv6Addrs(TrafficDescriptor urspTrafficDescriptor,SelectedRouteDescriptor & routeRule)1741 void UrspConfig::FillIpv6Addrs(TrafficDescriptor urspTrafficDescriptor,
1742 SelectedRouteDescriptor& routeRule)
1743 {
1744 size_t ipv6Num = urspTrafficDescriptor.ipv6Addrs.size();
1745 size_t index = 0;
1746 std::vector<uint8_t> ipv6AddrAndPrefix((NetworkSliceCommConfig::LEN_SIXTEEN_BYTE +
1747 NetworkSliceCommConfig::LEN_BYTE) * ipv6Num, 0);
1748 for (size_t i = 0; i < ipv6Num; i++) {
1749 Ipv6Addr ipv6Addr = urspTrafficDescriptor.ipv6Addrs[i];
1750 std::array<uint8_t, NetworkSliceCommConfig::LEN_IPV6ADDR> ipv6AddrValues_arry = ipv6Addr.getIpv6Addr();
1751 for (size_t j = 0; j < NetworkSliceCommConfig::LEN_SIXTEEN_BYTE; ++j) {
1752 ipv6AddrAndPrefix[index++] = ipv6AddrValues_arry[j];
1753 }
1754 int ipv6PrefixLen = ipv6Addr.getIpv6PrefixLen();
1755 ipv6AddrAndPrefix[index++] = ipv6PrefixLen;
1756 }
1757 routeRule.setIpv6Num(ipv6Num);
1758 routeRule.setIpv6AddrAndPrefix(ipv6AddrAndPrefix);
1759 }
1760
FillProtocolIds(TrafficDescriptor urspTrafficDescriptor,SelectedRouteDescriptor & routeRule)1761 void UrspConfig::FillProtocolIds(TrafficDescriptor urspTrafficDescriptor,
1762 SelectedRouteDescriptor& routeRule)
1763 {
1764 std::string protocolIds = ConvertIntListToString(urspTrafficDescriptor.protocolIds);
1765 routeRule.setProtocolIds(protocolIds);
1766 }
1767
FillRemotePorts(TrafficDescriptor urspTrafficDescriptor,SelectedRouteDescriptor & routeRule)1768 void UrspConfig::FillRemotePorts(TrafficDescriptor urspTrafficDescriptor,
1769 SelectedRouteDescriptor& routeRule)
1770 {
1771 std::string remotePorts = ConvertIntListToString(urspTrafficDescriptor.singleRemotePorts);
1772 if (!urspTrafficDescriptor.remotePortRanges.empty()) {
1773 if (!remotePorts.empty()) {
1774 remotePorts += COMMA_SEPARATOR;
1775 }
1776 RemotePortRange remotePortRange;
1777 for (size_t i = 0; i < urspTrafficDescriptor.remotePortRanges.size(); i++) {
1778 remotePortRange = urspTrafficDescriptor.remotePortRanges[i];
1779 remotePorts += std::to_string(remotePortRange.getPortRangeLowLimit())
1780 + PORT_RANGE_SEPARATOR + std::to_string(remotePortRange.getPortRangeHighLimit());
1781 if (i < urspTrafficDescriptor.remotePortRanges.size() - 1) {
1782 remotePorts += COMMA_SEPARATOR;
1783 }
1784 }
1785 }
1786 routeRule.setRemotePorts(remotePorts);
1787 }
1788
isTrafficDescriptorMatch(TrafficDescriptor urspTrafficDescriptor,AppDescriptor appDescriptor)1789 bool UrspConfig::isTrafficDescriptorMatch(TrafficDescriptor urspTrafficDescriptor,
1790 AppDescriptor appDescriptor)
1791 {
1792 if (urspTrafficDescriptor.isMatchAll) {
1793 NETMGR_EXT_LOG_I("urspTrafficDescriptor.isMatchAll == true");
1794 return true;
1795 }
1796 if (!isOsAppIdMatch(urspTrafficDescriptor, appDescriptor)) {
1797 return false;
1798 }
1799 if (!isIpv4AddrMatch(urspTrafficDescriptor, appDescriptor)) {
1800 return false;
1801 }
1802 if (!isIpv6AddrMatch(urspTrafficDescriptor, appDescriptor)) {
1803 return false;
1804 }
1805 if (!urspTrafficDescriptor.protocolIds.empty()
1806 && std::find(urspTrafficDescriptor.protocolIds.begin(), urspTrafficDescriptor.protocolIds.end(),
1807 appDescriptor.getProtocolId()) == urspTrafficDescriptor.protocolIds.end()) {
1808 NETMGR_EXT_LOG_I("protocolId not match: %{public}d", appDescriptor.getProtocolId());
1809 return false;
1810 }
1811 if (!urspTrafficDescriptor.dnns.empty()
1812 && std::find(urspTrafficDescriptor.dnns.begin(), urspTrafficDescriptor.dnns.end(),
1813 appDescriptor.getDnn()) == urspTrafficDescriptor.dnns.end()) {
1814 return false;
1815 }
1816 if (!urspTrafficDescriptor.fqdns.empty()
1817 && std::find(urspTrafficDescriptor.fqdns.begin(), urspTrafficDescriptor.fqdns.end(),
1818 appDescriptor.getFqdn()) == urspTrafficDescriptor.fqdns.end()) {
1819 NETMGR_EXT_LOG_I("fqdn not match: %{public}s", appDescriptor.getFqdn().c_str());
1820 return false;
1821 }
1822 if (!urspTrafficDescriptor.connectionCapabilities.empty()
1823 && std::find(urspTrafficDescriptor.connectionCapabilities.begin(),
1824 urspTrafficDescriptor.connectionCapabilities.end(),
1825 appDescriptor.getConnectionCapability()) == urspTrafficDescriptor.connectionCapabilities.end()) {
1826 NETMGR_EXT_LOG_I("connectionCapabilities not match: %{public}d", appDescriptor.getConnectionCapability());
1827 return false;
1828 }
1829
1830 if (!isRemotePortMatch(urspTrafficDescriptor, appDescriptor)) {
1831 return false;
1832 }
1833 return true;
1834 }
1835
isIpThreeTuplesInWhiteList(std::string plmn,AppDescriptor appDescriptor)1836 bool UrspConfig::isIpThreeTuplesInWhiteList(std::string plmn, AppDescriptor appDescriptor)
1837 {
1838 std::unordered_map<std::string, std::vector<UrspRule>> uePolicyMap =
1839 mUePolicyMap.empty() ? mPreConfigUrspMap : mUePolicyMap;
1840 if (uePolicyMap.find(plmn) == uePolicyMap.end()) {
1841 NETMGR_EXT_LOG_I("cannot find plmn in sliceNetworkSelection");
1842 return false;
1843 }
1844 std::vector<UrspRule> urspRules = uePolicyMap[plmn];
1845 for (size_t i = 0; i < urspRules.size(); ++i) {
1846 UrspRule urspRule = urspRules[i];
1847 if (isIpThreeTuplesInTrafficDescriptor(urspRule.trafficDescriptor, appDescriptor)) {
1848 return true;
1849 }
1850 }
1851 return false;
1852 }
1853
isIpThreeTuplesInTrafficDescriptor(TrafficDescriptor urspTrafficDescriptor,AppDescriptor appDescriptor)1854 bool UrspConfig::isIpThreeTuplesInTrafficDescriptor(TrafficDescriptor urspTrafficDescriptor,
1855 AppDescriptor appDescriptor)
1856 {
1857 if (urspTrafficDescriptor.ipv4Addrs.empty()
1858 && urspTrafficDescriptor.ipv6Addrs.empty()
1859 && urspTrafficDescriptor.protocolIds.empty()
1860 && urspTrafficDescriptor.singleRemotePorts.empty()
1861 && urspTrafficDescriptor.remotePortRanges.empty()) {
1862 return false;
1863 }
1864 if (!isIpv4AddrMatch(urspTrafficDescriptor, appDescriptor)) {
1865 return false;
1866 }
1867 if (!isIpv6AddrMatch(urspTrafficDescriptor, appDescriptor)) {
1868 return false;
1869 }
1870 if (!urspTrafficDescriptor.protocolIds.empty()
1871 && std::find(urspTrafficDescriptor.protocolIds.begin(), urspTrafficDescriptor.protocolIds.end(),
1872 appDescriptor.getProtocolId()) == urspTrafficDescriptor.protocolIds.end()) {
1873 NETMGR_EXT_LOG_I("protocolId not in white list: %{public}d", appDescriptor.getProtocolId());
1874 return false;
1875 }
1876 if (!isRemotePortMatch(urspTrafficDescriptor, appDescriptor)) {
1877 return false;
1878 }
1879 NETMGR_EXT_LOG_I("is IpThreeTuples In TrafficDescriptor");
1880 return true;
1881 }
1882
isOsAppIdMatch(TrafficDescriptor urspTrafficDescriptor,AppDescriptor appDescriptor)1883 bool UrspConfig::isOsAppIdMatch(TrafficDescriptor urspTrafficDescriptor, AppDescriptor appDescriptor)
1884 {
1885 if (!urspTrafficDescriptor.osAppIds.empty()) {
1886 size_t i;
1887 for (i = 0; i < urspTrafficDescriptor.osAppIds.size(); i++) {
1888 OsAppId osAppId = urspTrafficDescriptor.osAppIds[i];
1889 if (osAppId.getAppId() == appDescriptor.getOsAppId().getAppId()) {
1890 break;
1891 }
1892 }
1893 if (i == urspTrafficDescriptor.osAppIds.size()) {
1894 NETMGR_EXT_LOG_I("appId not match: %{public}s", appDescriptor.getOsAppId().getAppId().c_str());
1895 return false;
1896 }
1897 NETMGR_EXT_LOG_I("appId match: %{public}s", appDescriptor.getOsAppId().getAppId().c_str());
1898 }
1899 return true;
1900 }
1901
isRemotePortMatch(TrafficDescriptor urspTrafficDescriptor,AppDescriptor appDescriptor)1902 bool UrspConfig::isRemotePortMatch(TrafficDescriptor urspTrafficDescriptor, AppDescriptor appDescriptor)
1903 {
1904 if (!urspTrafficDescriptor.singleRemotePorts.empty()
1905 && std::find(urspTrafficDescriptor.singleRemotePorts.begin(), urspTrafficDescriptor.singleRemotePorts.end(),
1906 appDescriptor.getRemotePort()) != urspTrafficDescriptor.singleRemotePorts.end()) {
1907 return true;
1908 }
1909
1910 if (!urspTrafficDescriptor.remotePortRanges.empty()) {
1911 RemotePortRange remotePortRange;
1912 size_t i;
1913 for (i = 0; i < urspTrafficDescriptor.remotePortRanges.size(); i++) {
1914 remotePortRange = urspTrafficDescriptor.remotePortRanges[i];
1915 if ((appDescriptor.getRemotePort() >= remotePortRange.getPortRangeLowLimit())
1916 && (appDescriptor.getRemotePort() <= remotePortRange.getPortRangeHighLimit())) {
1917 break;
1918 }
1919 }
1920 if (i == urspTrafficDescriptor.remotePortRanges.size()) {
1921 return false;
1922 }
1923 }
1924 return true;
1925 }
1926
isIpv4AddrMatch(TrafficDescriptor urspTrafficDescriptor,AppDescriptor appDescriptor)1927 bool UrspConfig::isIpv4AddrMatch(TrafficDescriptor urspTrafficDescriptor, AppDescriptor appDescriptor)
1928 {
1929 if (urspTrafficDescriptor.ipv4Addrs.empty()) {
1930 return true;
1931 }
1932 size_t i;
1933 bool ipv4match = false;
1934 for (i = 0; i < urspTrafficDescriptor.ipv4Addrs.size(); ++i) {
1935 Ipv4Addr ipv4Addr = urspTrafficDescriptor.ipv4Addrs[i];
1936 uint32_t ipv4AddrValues = ipv4Addr.getIpv4Addr();
1937 uint32_t ipv4MaskValues = ipv4Addr.getIpv4Mask();
1938 uint32_t appAddrValues = appDescriptor.getIpv4Addr();
1939 if ((appAddrValues & ipv4MaskValues) != (ipv4AddrValues & ipv4MaskValues)) {
1940 NETMGR_EXT_LOG_I("ipv4Addr not match");
1941 continue;
1942 }
1943 ipv4match = true;
1944 }
1945 if (ipv4match == false) {
1946 NETMGR_EXT_LOG_I("ipv4Addr not match");
1947 return false;
1948 }
1949 return true;
1950 }
1951
isIpv6AddrMatch(TrafficDescriptor urspTrafficDescriptor,AppDescriptor appDescriptor)1952 bool UrspConfig::isIpv6AddrMatch(TrafficDescriptor urspTrafficDescriptor, AppDescriptor appDescriptor)
1953 {
1954 if (urspTrafficDescriptor.ipv6Addrs.empty()) {
1955 return true;
1956 }
1957 size_t i;
1958 bool ipv6match = false;
1959 for (i = 0; i < urspTrafficDescriptor.ipv6Addrs.size(); ++i) {
1960 Ipv6Addr ipv6Addr = urspTrafficDescriptor.ipv6Addrs[i];
1961 std::string ipv6AddrValues = transIpv6AddrToStr(ipv6Addr.getIpv6Addr());
1962 std::string appAddrValues = transIpv6AddrToStr(appDescriptor.getIpv6Addr());
1963 if (ipv6AddrValues != appAddrValues) {
1964 NETMGR_EXT_LOG_I("ipv6Addr not match");
1965 continue;
1966 }
1967 ipv6match = true;
1968 }
1969 if (ipv6match == false) {
1970 NETMGR_EXT_LOG_I("ipv6Addr not match");
1971 return false;
1972 }
1973 return true;
1974 }
1975
GetMatchAllUrspRule(const std::string & plmn)1976 SelectedRouteDescriptor UrspConfig::GetMatchAllUrspRule(const std::string& plmn)
1977 {
1978 NETMGR_EXT_LOG_I("GetMatchAllUrspRule");
1979 std::unordered_map<std::string, std::vector<UrspRule>> uePolicyMap;
1980 if (mUePolicyMap.empty()) {
1981 uePolicyMap = mPreConfigUrspMap;
1982 } else {
1983 uePolicyMap = mUePolicyMap;
1984 }
1985 SelectedRouteDescriptor routeRule;
1986 if (uePolicyMap.find(plmn) == uePolicyMap.end()) {
1987 NETMGR_EXT_LOG_I("GetMatchAllUrspRule not find plmn");
1988 return routeRule;
1989 }
1990 std::vector<UrspRule> urspRules = uePolicyMap[plmn];
1991 if (urspRules.empty()) {
1992 NETMGR_EXT_LOG_I("GetMatchAllUrspRule urspRules is empty");
1993 return routeRule;
1994 }
1995 uint8_t routeBitmap = 0; /* bit 1: is matchAll, bit3: hasUrsp */
1996 routeBitmap = ConvertInt2UnsignedByte(routeBitmap | 0x08);
1997 UrspRule urspRule = urspRules.back();
1998 if (!urspRule.trafficDescriptor.isMatchAll) {
1999 routeRule.setRouteBitmap(routeBitmap);
2000 NETMGR_EXT_LOG_I("TD is not MatchAll, routeBitmap = %{public}d", routeBitmap);
2001 return routeRule;
2002 }
2003 for (int j = 0; j < (int)urspRule.routeSelectionDescriptors.size(); ++j) {
2004 if (!urspRule.routeSelectionDescriptors[j].snssais.empty()) {
2005 if (sAllowedNssaiConfig_ == nullptr) {
2006 continue;
2007 }
2008 std::vector<Snssai> snssais = urspRule.routeSelectionDescriptors[j].snssais;
2009 std::string snssai = sAllowedNssaiConfig_->FindSnssaiInAllowedNssai(snssais);
2010 if (snssai.empty()) {
2011 continue;
2012 }
2013 routeRule.setSnssai(snssai);
2014 }
2015 routeRule.setPduSessionType(urspRule.routeSelectionDescriptors[j].pduSessionType);
2016 routeRule.setSscMode(urspRule.routeSelectionDescriptors[j].sscMode);
2017 if (!urspRule.routeSelectionDescriptors[j].dnns.empty()) {
2018 routeRule.setDnn(urspRule.routeSelectionDescriptors[j].dnns[0]);
2019 }
2020 routeRule.setUrspPrecedence((uint8_t) urspRule.urspPrecedence);
2021 routeBitmap = ConvertInt2UnsignedByte(routeBitmap | 0x01);
2022 routeRule.setRouteBitmap(routeBitmap);
2023 return routeRule;
2024 }
2025 return routeRule;
2026 }
2027
DumpUePolicyMap()2028 void UrspConfig::DumpUePolicyMap()
2029 {
2030 NETMGR_EXT_LOG_I("dump UrspConfig.mUePolicyMap begin");
2031 for (const auto& entry : mUePolicyMap) {
2032 NETMGR_EXT_LOG_I("plmn = %{public}s", entry.first.c_str());
2033 const auto& urspRules = entry.second;
2034 NETMGR_EXT_LOG_I("dump UrspConfig: urspRules.size = %{public}d", (int)urspRules.size());
2035 for (size_t i = 0; i < urspRules.size(); ++i) {
2036 const auto& urspRule = urspRules[i];
2037 NETMGR_EXT_LOG_I("urspPrecedence = %{public}d", urspRule.urspPrecedence);
2038 DumptrafficDescriptor(urspRule.trafficDescriptor);
2039 DumpRouteSelectionDescriptors(urspRule.routeSelectionDescriptors);
2040 }
2041 }
2042 NETMGR_EXT_LOG_I("dump end");
2043 }
2044
DumpPreConfigUrspMap()2045 void UrspConfig::DumpPreConfigUrspMap()
2046 {
2047 NETMGR_EXT_LOG_I("dump UrspConfig.mPreConfigUrspMap begin");
2048 for (const auto& entry : mPreConfigUrspMap) {
2049 NETMGR_EXT_LOG_I("plmn = %{public}s", entry.first.c_str());
2050 const auto& urspRules = entry.second;
2051 NETMGR_EXT_LOG_I("dump UrspConfig: urspRules.size = %{public}d", (int)urspRules.size());
2052 for (size_t i = 0; i < urspRules.size(); ++i) {
2053 const auto& urspRule = urspRules[i];
2054 NETMGR_EXT_LOG_I("urspPrecedence = %{public}d", urspRule.urspPrecedence);
2055 DumptrafficDescriptor(urspRule.trafficDescriptor);
2056 DumpRouteSelectionDescriptors(urspRule.routeSelectionDescriptors);
2057 }
2058 }
2059 NETMGR_EXT_LOG_I("dump end");
2060 }
2061
DumptrafficDescriptor(const TrafficDescriptor & trafficDescriptor)2062 void UrspConfig::DumptrafficDescriptor(const TrafficDescriptor& trafficDescriptor)
2063 {
2064 NETMGR_EXT_LOG_I("dump trafficDescriptor");
2065 size_t i;
2066
2067 NETMGR_EXT_LOG_I("trafficDescriptor.isMatchAll = %{public}s", trafficDescriptor.isMatchAll ? "true":"false");
2068 for (i = 0; i < trafficDescriptor.osAppIds.size(); ++i) {
2069 NETMGR_EXT_LOG_I("osAppIds.OsId = %{public}s, osAppIds.AppId = %{public}s",
2070 trafficDescriptor.osAppIds[i].getOsId().c_str(), trafficDescriptor.osAppIds[i].getAppId().c_str());
2071 }
2072 for (i = 0; i < trafficDescriptor.ipv4Addrs.size(); ++i) {
2073 NETMGR_EXT_LOG_I("ipv4Addrs.mIpv4Addr = %{public}d, ipv4Addrs.mIpv4Mask = %{public}d",
2074 trafficDescriptor.ipv4Addrs[i].getIpv4Addr(), trafficDescriptor.ipv4Addrs[i].getIpv4Mask());
2075 }
2076 for (i = 0; i < trafficDescriptor.ipv6Addrs.size(); ++i) {
2077 std::string ipv6addr = transIpv6AddrToStr(trafficDescriptor.ipv6Addrs[i].getIpv6Addr());
2078 NETMGR_EXT_LOG_I("ipv6Addrs.mIpv6Addr = %{public}s, ipv6Addrs.mIpv6Prefix = %{public}d",
2079 ipv6addr.c_str(), trafficDescriptor.ipv6Addrs[i].getIpv6PrefixLen());
2080 }
2081 for (i = 0; i < trafficDescriptor.protocolIds.size(); ++i) {
2082 NETMGR_EXT_LOG_I("protocolId = %{public}d", trafficDescriptor.protocolIds[i]);
2083 }
2084 for (i = 0; i < trafficDescriptor.singleRemotePorts.size(); ++i) {
2085 NETMGR_EXT_LOG_I("singleRemotePorts = %{public}d", trafficDescriptor.singleRemotePorts[i]);
2086 }
2087 for (i = 0; i < trafficDescriptor.remotePortRanges.size(); ++i) {
2088 NETMGR_EXT_LOG_I("portRangeLowLimit = %{public}d, portRangeHighLimit = %{public}d",
2089 trafficDescriptor.remotePortRanges[i].getPortRangeLowLimit(),
2090 trafficDescriptor.remotePortRanges[i].getPortRangeHighLimit());
2091 }
2092 for (i = 0; i < trafficDescriptor.dnns.size(); ++i) {
2093 NETMGR_EXT_LOG_I("trafficDescriptor.dnn = %{public}s", trafficDescriptor.dnns[i].c_str());
2094 }
2095 for (i = 0; i < trafficDescriptor.fqdns.size(); ++i) {
2096 NETMGR_EXT_LOG_I("trafficDescriptor.fqdn = %{public}s", trafficDescriptor.fqdns[i].c_str());
2097 }
2098 for (i = 0; i < trafficDescriptor.connectionCapabilities.size(); ++i) {
2099 NETMGR_EXT_LOG_I("trafficDescriptor.connectionCapabilities = %{public}d",
2100 trafficDescriptor.connectionCapabilities[i]);
2101 }
2102 }
2103
DumpRouteSelectionDescriptors(const std::vector<RouteSelectionDescriptor> & routeSelectionDescriptors)2104 void UrspConfig::DumpRouteSelectionDescriptors(const std::vector<RouteSelectionDescriptor>& routeSelectionDescriptors)
2105 {
2106 NETMGR_EXT_LOG_I("dump routeSelectionDescriptors,size = %{public}d", (int)routeSelectionDescriptors.size());
2107 size_t i;
2108 size_t j;
2109 for (i = 0; i < routeSelectionDescriptors.size(); ++i) {
2110 NETMGR_EXT_LOG_I("routeSelectionDescriptor.routePrecedence = %{public}d",
2111 routeSelectionDescriptors[i].routePrecedence);
2112 NETMGR_EXT_LOG_I("routeSelectionDescriptor.sscMode = %{public}d", routeSelectionDescriptors[i].sscMode);
2113 NETMGR_EXT_LOG_I("routeSelectionDescriptor.pduSessionType = %{public}d",
2114 routeSelectionDescriptors[i].pduSessionType);
2115 for (j = 0; j < routeSelectionDescriptors[i].snssais.size(); ++j) {
2116 NETMGR_EXT_LOG_I("routeSelectionDescriptor.sNssai.mSNssaiLen = %{public}d",
2117 routeSelectionDescriptors[i].snssais[j].getSnssaiLen());
2118 NETMGR_EXT_LOG_I("routeSelectionDescriptor.sNssai.mSst = %{public}d",
2119 routeSelectionDescriptors[i].snssais[j].getSst());
2120 NETMGR_EXT_LOG_I("routeSelectionDescriptor.sNssai.mSd = %{public}d",
2121 routeSelectionDescriptors[i].snssais[j].getSd());
2122 NETMGR_EXT_LOG_I("routeSelectionDescriptor.sNssai.mMappedSst = %{public}d",
2123 routeSelectionDescriptors[i].snssais[j].getMappedSst());
2124 NETMGR_EXT_LOG_I("routeSelectionDescriptor.sNssai.mMappedSd = %{public}d",
2125 routeSelectionDescriptors[i].snssais[j].getMappedSd());
2126 }
2127 for (j = 0; j < routeSelectionDescriptors[i].dnns.size(); ++j) {
2128 NETMGR_EXT_LOG_I("routeSelectionDescriptor.dnn = %{public}s", routeSelectionDescriptors[i].dnns[j].c_str());
2129 }
2130 }
2131 }
2132
2133 } // namespace NetManagerStandard
2134 } // namespace OHOS
2135