1 /*
2 * Copyright (c) 2022 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 <arpa/inet.h>
17 #include <netdb.h>
18 #include <stdlib.h>
19 #include <sys/socket.h>
20 #include "functionalext.h"
21 #define HTTP_PORT 80
22 #define TCPMUX_PORT 1
23 #define FIDO_PORT 60179
24 #define NOT_EXIST_PORT 62000
25 #define NOT_EXIST_PORT_STR "62000"
26
27 const int INFO_RESULT = 0;
28 const int FAMILY_NOTSUPPORTED = -6;
29
30 /**
31 * @tc.name : getnameinfo_0100
32 * @tc.desc : Each parameter is valid and can resolve the IP address of the host name(hint.ai_flags =AI_ALL).
33 * @tc.level : Level 0
34 */
getnameinfo_0100()35 void getnameinfo_0100()
36 {
37 int ret;
38 char host[NI_MAXHOST];
39 char server[NI_MAXSERV];
40 struct sockaddr_in sa;
41 memset(&sa, 0, sizeof(sa));
42 sa.sin_family = AF_INET;
43 inet_pton(AF_INET, "127.0.0.1", &sa.sin_addr.s_addr);
44 ret = getnameinfo((const struct sockaddr *)(&sa), sizeof(sa), host, sizeof(host), server, sizeof(server), 0);
45 EXPECT_EQ("getnameinfo_0100", ret, INFO_RESULT);
46 EXPECT_NE("getnameinfo_0100", strlen(host), 0);
47 EXPECT_NE("getnameinfo_0100", strlen(server), 0);
48 }
49
50 /**
51 * @tc.name : getnameinfo_0200
52 * @tc.desc : Each parameter is valid and can resolve the IP address of the host name(hint.ai_flags =AI_ALL).
53 * @tc.level : Level 0
54 */
getnameinfo_0200()55 void getnameinfo_0200()
56 {
57 int ret = -1;
58 int num = -1;
59 int res = -1;
60 struct addrinfo *result, hint;
61 hint.ai_flags = AI_NUMERICHOST;
62 hint.ai_family = AF_INET6;
63 char buf[] = "fe80::bed5:4695:6cac:bef8";
64 ret = getaddrinfo(buf, NULL, &hint, &result);
65 char host[NI_MAXHOST];
66 char server[NI_MAXSERV];
67 if (ret == 0) {
68 res = getnameinfo(result->ai_addr, result->ai_addrlen, host, sizeof(host), server, sizeof(server), 0);
69 }
70 EXPECT_EQ("getnameinfo_0200", res, INFO_RESULT);
71 EXPECT_NE("getnameinfo_0200", strlen(host), 0);
72 EXPECT_NE("getnameinfo_0200", strlen(server), 0);
73 freeaddrinfo(result);
74 result = NULL;
75 }
76
77 /**
78 * @tc.name : getnameinfo_0300
79 * @tc.desc : Each parameter is valid and can resolve the IP address of the host name(hint.ai_flags =AI_ALL).
80 * @tc.level : Level 1
81 */
getnameinfo_0300()82 void getnameinfo_0300()
83 {
84 int ret;
85 char host[NI_MAXHOST];
86 char server[NI_MAXSERV];
87 struct sockaddr_in sa;
88 memset(&sa, 0, sizeof(sa));
89 sa.sin_family = AF_INET;
90 inet_pton(AF_INET, "127.0.0.1", &sa.sin_addr.s_addr);
91 ret = getnameinfo((const struct sockaddr *)(&sa), sizeof(sa), 0, 0, server, sizeof(server), 0);
92 EXPECT_EQ("getnameinfo_0300", ret, INFO_RESULT);
93 EXPECT_NE("getnameinfo_0300", strlen(server), 0);
94 }
95
96 /**
97 * @tc.name : getnameinfo_0400
98 * @tc.desc : Each parameter is valid and can resolve the IP address of the host name(hint.ai_flags =AI_ALL).
99 * @tc.level : Level 1
100 */
getnameinfo_0400()101 void getnameinfo_0400()
102 {
103 int ret;
104 char host[NI_MAXHOST];
105 char server[NI_MAXSERV];
106 struct sockaddr_in sa;
107 memset(&sa, 0, sizeof(sa));
108 sa.sin_family = AF_INET;
109 inet_pton(AF_INET, "127.0.0.1", &sa.sin_addr.s_addr);
110 ret = getnameinfo((const struct sockaddr *)(&sa), sizeof(sa), host, sizeof(host), 0, 0, 0);
111 EXPECT_EQ("getnameinfo_0400", ret, INFO_RESULT);
112 EXPECT_NE("getnameinfo_0400", strlen(host), 0);
113 }
114 /**
115 * @tc.name : getnameinfo_0500
116 * @tc.desc : Each parameter is valid and can resolve the IP address of the host name(hint.ai_flags =AI_ALL).
117 * @tc.level : Level 2
118 */
getnameinfo_0500()119 void getnameinfo_0500()
120 {
121 int ret;
122 char host[NI_MAXHOST];
123 char server[NI_MAXSERV];
124 struct sockaddr_in sa;
125 memset(&sa, 0, sizeof(sa));
126 sa.sin_family = AF_INET;
127 inet_pton(AF_INET, "127.0.0.1", &sa.sin_addr.s_addr);
128 ret = getnameinfo((const struct sockaddr *)(&sa), 4, host, sizeof(host), server, sizeof(server), 0);
129 EXPECT_EQ("getnameinfo_0500", ret, FAMILY_NOTSUPPORTED);
130 }
131
132 /**
133 * @tc.name : getnameinfo_0600
134 * @tc.desc : Each parameter is valid and can resolve the IP address of the host name(hint.ai_flags =AI_ALL).
135 * @tc.level : Level 2
136 */
getnameinfo_0600()137 void getnameinfo_0600()
138 {
139 int ret = -1;
140 int num = -1;
141 int res = -1;
142 struct addrinfo *result, hint;
143 hint.ai_flags = AI_NUMERICHOST;
144 hint.ai_family = AF_INET6;
145 char buf[] = "fe80::bed5:4695:6cac:bef8";
146 ret = getaddrinfo(buf, NULL, &hint, &result);
147 char host[NI_MAXHOST];
148 char server[NI_MAXSERV];
149 if (ret == 0) {
150 res = getnameinfo(result->ai_addr, 4, host, sizeof(host), server, sizeof(server), 0);
151 }
152 EXPECT_EQ("getnameinfo_0600", res, FAMILY_NOTSUPPORTED);
153 freeaddrinfo(result);
154 result = NULL;
155 }
156
157 /**
158 * @tc.name : getnameinfo_0700
159 * @tc.desc : Each parameter is valid, sa->sa_family is AF_LOCAL, the information of the host cannot be obtained.
160 * @tc.level : Level 2
161 */
getnameinfo_0700()162 void getnameinfo_0700()
163 {
164 int ret;
165 char host[NI_MAXHOST];
166 char server[NI_MAXSERV];
167 struct sockaddr_in sa;
168 memset(&sa, 0, sizeof(sa));
169 sa.sin_family = AF_LOCAL;
170 ret = getnameinfo((const struct sockaddr *)(&sa), sizeof(sa), host, sizeof(host), server, sizeof(server), 0);
171 EXPECT_EQ("getnameinfo_0700", ret, FAMILY_NOTSUPPORTED);
172 }
173
getnameinfo_0900()174 void getnameinfo_0900()
175 {
176 int ret;
177 char *ptr = "127.0.0.1";
178 char hostname[128] = {0};
179 char servername[128] = {0};
180 struct sockaddr_in addrDst;
181
182 memset(&addrDst, 0, sizeof(addrDst));
183 addrDst.sin_family = AF_INET;
184 addrDst.sin_addr.s_addr = inet_addr(ptr);
185 addrDst.sin_port = htons(HTTP_PORT);
186
187 ret = getnameinfo((struct sockaddr *)&addrDst, sizeof(addrDst), hostname, sizeof(hostname),
188 servername, sizeof(servername), 0);
189 EXPECT_EQ("getnameinfo_0900", ret, 0);
190 EXPECT_STREQ("getnameinfo_0900 hostname", hostname, "localhost");
191 EXPECT_STREQ("getnameinfo_0900 hostname", servername, "http");
192 }
193
getnameinfo_1000()194 void getnameinfo_1000()
195 {
196 int ret;
197 char *ptr = "127.0.0.1";
198 char hostname[128] = {0};
199 char servername[128] = {0};
200 struct sockaddr_in addrDst;
201
202 memset(&addrDst, 0, sizeof(addrDst));
203 addrDst.sin_family = AF_INET;
204 addrDst.sin_addr.s_addr = inet_addr(ptr);
205 addrDst.sin_port = htons(TCPMUX_PORT);
206
207 ret = getnameinfo((struct sockaddr *)&addrDst, sizeof(addrDst), hostname, sizeof(hostname),
208 servername, sizeof(servername), 0);
209 EXPECT_EQ("getnameinfo_1000", ret, 0);
210 EXPECT_STREQ("getnameinfo_1000 hostname", hostname, "localhost");
211 EXPECT_STREQ("getnameinfo_1000 hostname", servername, "tcpmux");
212 }
213
214
getnameinfo_1100()215 void getnameinfo_1100()
216 {
217 int ret;
218 char *ptr = "127.0.0.1";
219 char hostname[128] = {0};
220 char servername[128] = {0};
221 struct sockaddr_in addrDst;
222
223 memset(&addrDst, 0, sizeof(addrDst));
224 addrDst.sin_family = AF_INET;
225 addrDst.sin_addr.s_addr = inet_addr(ptr);
226 addrDst.sin_port = htons(FIDO_PORT);
227
228 ret = getnameinfo((struct sockaddr *)&addrDst, sizeof(addrDst), hostname, sizeof(hostname),
229 servername, sizeof(servername), 0);
230 EXPECT_EQ("getnameinfo_1100", ret, 0);
231 EXPECT_STREQ("getnameinfo_1100 hostname", hostname, "localhost");
232 EXPECT_STREQ("getnameinfo_1100 hostname", servername, "fido");
233 }
234
getnameinfo_1200()235 void getnameinfo_1200()
236 {
237 int ret;
238 char *ptr = "127.0.0.1";
239 char hostname[128] = {0};
240 char servername[128] = {0};
241 struct sockaddr_in addrDst;
242
243 memset(&addrDst, 0, sizeof(addrDst));
244 addrDst.sin_family = AF_INET;
245 addrDst.sin_addr.s_addr = inet_addr(ptr);
246 addrDst.sin_port = htons(NOT_EXIST_PORT);
247
248 ret = getnameinfo((struct sockaddr *)&addrDst, sizeof(addrDst), hostname, sizeof(hostname),
249 servername, sizeof(servername), 0);
250 EXPECT_EQ("getnameinfo_1200", ret, 0);
251 EXPECT_STREQ("getnameinfo_1200 hostname", hostname, "localhost");
252 EXPECT_STREQ("getnameinfo_1200 hostname", servername, NOT_EXIST_PORT_STR);
253 }
254
main(int argc,char * argv[])255 int main(int argc, char *argv[])
256 {
257 getnameinfo_0100();
258 getnameinfo_0200();
259 getnameinfo_0300();
260 getnameinfo_0400();
261 getnameinfo_0500();
262 getnameinfo_0600();
263 getnameinfo_0700();
264 getnameinfo_0900();
265 getnameinfo_1000();
266 getnameinfo_1100();
267 getnameinfo_1200();
268 return t_status;
269 }
270