1 /*
2 * Copyright (C) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "dhcp_common_utils.h"
17 #include <arpa/inet.h>
18 #include <netinet/if_ether.h>
19 #include <regex>
20 #include "securec.h"
21 #include "dhcp_logger.h"
22
23 namespace OHOS {
24 namespace DHCP {
25 DEFINE_DHCPLOG_DHCP_LABEL("DhcpCommonUtils");
26
27 constexpr int32_t GATEWAY_MAC_LENTH = 18;
28 constexpr int32_t MAC_INDEX_0 = 0;
29 constexpr int32_t MAC_INDEX_1 = 1;
30 constexpr int32_t MAC_INDEX_2 = 2;
31 constexpr int32_t MAC_INDEX_3 = 3;
32 constexpr int32_t MAC_INDEX_4 = 4;
33 constexpr int32_t MAC_INDEX_5 = 5;
34
Ipv4Anonymize(const std::string str)35 std::string Ipv4Anonymize(const std::string str)
36 {
37 std::string strTemp = str;
38 std::string::size_type begin = strTemp.find_last_of('.');
39 while (begin < strTemp.length()) {
40 if (strTemp[begin] != '.') {
41 strTemp[begin] = '*';
42 }
43 begin++;
44 }
45 return strTemp;
46 }
47
UintIp4ToStr(uint32_t uIp, bool bHost)48 char *UintIp4ToStr(uint32_t uIp, bool bHost)
49 {
50 char bufIp4[INET_ADDRSTRLEN] = {0};
51 struct in_addr addr4;
52 if (bHost) {
53 addr4.s_addr = htonl(uIp);
54 } else {
55 addr4.s_addr = uIp;
56 }
57 const char *p = inet_ntop(AF_INET, &addr4, bufIp4, INET_ADDRSTRLEN);
58 if (p == nullptr) {
59 DHCP_LOGE("UintIp4ToStr inet_ntop p == nullptr!");
60 return nullptr;
61 }
62 char *strIp = static_cast<char *>(malloc(INET_ADDRSTRLEN));
63 if (strIp == nullptr) {
64 DHCP_LOGE("UintIp4ToStr strIp malloc failed!");
65 return nullptr;
66 }
67 if (strncpy_s(strIp, INET_ADDRSTRLEN, bufIp4, strlen(bufIp4)) != EOK) {
68 DHCP_LOGE("UintIp4ToStr strIp strncpy_s failed!");
69 free(strIp);
70 strIp = nullptr;
71 return nullptr;
72 }
73 return strIp;
74 }
75
IntIpv4ToAnonymizeStr(uint32_t ip)76 std::string IntIpv4ToAnonymizeStr(uint32_t ip)
77 {
78 std::string strTemp = "";
79 char *pIp = UintIp4ToStr(ip, false);
80 if (pIp != nullptr) {
81 strTemp = Ipv4Anonymize(pIp);
82 free(pIp);
83 pIp = nullptr;
84 }
85 return strTemp;
86 }
87
MacArray2Str(uint8_t *macArray, int32_t len)88 std::string MacArray2Str(uint8_t *macArray, int32_t len)
89 {
90 if ((macArray == nullptr) || (len != ETH_ALEN)) {
91 DHCP_LOGE("MacArray2Str arg is invalid!");
92 return "";
93 }
94
95 char gwMacAddr[GATEWAY_MAC_LENTH] = {0};
96 if (sprintf_s(gwMacAddr, sizeof(gwMacAddr), "%02x:%02x:%02x:%02x:%02x:%02x", macArray[MAC_INDEX_0],
97 macArray[MAC_INDEX_1], macArray[MAC_INDEX_2], macArray[MAC_INDEX_3], macArray[MAC_INDEX_4],
98 macArray[MAC_INDEX_5]) < 0) {
99 DHCP_LOGE("MacArray2Str sprintf_s err");
100 return "";
101 }
102 std::string ret = gwMacAddr;
103 return ret;
104 }
105
CheckDataLegal(std::string &data, int base)106 int CheckDataLegal(std::string &data, int base)
107 {
108 std::regex pattern("\\d+");
109 if (!std::regex_search(data, pattern)) {
110 return 0;
111 }
112 errno = 0;
113 char *endptr = nullptr;
114 long int num = std::strtol(data.c_str(), &endptr, base);
115 if (errno == ERANGE) {
116 DHCP_LOGE("CheckDataLegal errno == ERANGE, data:%{private}s", data.c_str());
117 return 0;
118 }
119 return static_cast<int>(num);
120 }
121
CheckDataToUint(std::string &data, int base)122 unsigned int CheckDataToUint(std::string &data, int base)
123 {
124 std::regex pattern("\\d+");
125 std::regex patternTmp("-\\d+");
126 if (!std::regex_search(data, pattern) || std::regex_search(data, patternTmp)) {
127 DHCP_LOGE("CheckDataToUint regex unsigned int value fail, data:%{private}s", data.c_str());
128 return 0;
129 }
130 errno = 0;
131 char *endptr = nullptr;
132 unsigned long int num = std::strtoul(data.c_str(), &endptr, base);
133 if (errno == ERANGE) {
134 DHCP_LOGE("CheckDataToUint errno == ERANGE, data:%{private}s", data.c_str());
135 return 0;
136 }
137 return static_cast<unsigned int>(num);
138 }
139
CheckDataTolonglong(std::string &data, int base)140 long long CheckDataTolonglong(std::string &data, int base)
141 {
142 std::regex pattern("\\d+");
143 if (!std::regex_search(data, pattern)) {
144 return 0;
145 }
146 errno = 0;
147 char *endptr = nullptr;
148 long long int num = std::strtoll(data.c_str(), &endptr, base);
149 if (errno == ERANGE) {
150 DHCP_LOGE("CheckDataTolonglong errno == ERANGE, data:%{private}s", data.c_str());
151 return 0;
152 }
153 return num;
154 }
155
GetElapsedSecondsSinceBoot()156 int64_t GetElapsedSecondsSinceBoot()
157 {
158 struct timespec times = {0, 0};
159 clock_gettime(CLOCK_BOOTTIME, ×);
160 return static_cast<int64_t>(times.tv_sec);
161 }
162 }
163 }
164