1 /*
2 Copyright (C) 2015-2021, Dirk Krause
3 SPDX-License-Identifier: BSD-3-Clause
4 */
5
6 /*
7 WARNING: This file was generated by the dkct program (see
8 http://dktools.sourceforge.net/ for details).
9 Changes you make here will be lost if dkct is run again!
10 You should modify the original source and run dkct on it.
11 Original source: dk4sock03.ctr
12 */
13
14 /** @file dk4sock03.c The dk4sock03 module.
15 */
16
17
18 #include "dk4conf.h"
19 #include <libdk4sock/dk4sock.h>
20 #include <libdk4base/dk4mem.h>
21 #include <libdk4base/dk4str8.h>
22 #include <libdk4base/dk4strd.h>
23 #include <libdk4maio8d/dk4mao8d.h>
24 #include <libdk4maio8h/dk4mao8h.h>
25 #include <libdk4c/dk4rec23.h>
26
27 #include <libdk4base/dk4unused.h>
28
29 #if DK4_HAVE_ASSERT_H
30 #ifndef ASSERT_H_INCLUDED
31 #include <assert.h>
32 #define ASSERT_H_INCLUDED 1
33 #endif
34 #endif
35
36
37
38
39
40
41 /** Constant texts used by the module, not localized.
42 */
43 static const char * const dk4socket_c8_kw[] = {
44 /* 0 */
45 "@",
46
47 /* 1 */
48 ".",
49
50 /* 2 */
51 ":",
52
53 NULL
54
55 };
56
57
58
59 int
dk4socket_c8_inet_ntop(char * dptr,size_t dsz,int afam,const void * src,dk4_er_t * erp)60 dk4socket_c8_inet_ntop(
61 char *dptr,
62 size_t dsz,
63 int afam,
64 const void *src,
65 dk4_er_t *erp
66 )
67 {
68 #if DK4_HAVE_INET_NTOP
69 #if DK4_ON_WINDOWS
70 /* +++++ +inet_ntop +Windows */
71 #if DK4_HAVE_STRUCT_SOCKADDR_IN6
72 struct in6_addr in6; /* IPv6 host address */
73 #endif
74 struct in_addr in4; /* IPv4 host address */
75 int back = DK4_SOCKET_RESULT_FAILED;
76 #if DK4_USE_ASSERT
77 assert(NULL != dptr);
78 assert(0 < dsz);
79 #endif
80 if ((NULL != dptr) && (0 < dsz)) { *dptr = '\0'; }
81 if ((NULL != dptr) && (NULL != src) && (0 < dsz)) {
82 dk4socket_error_reset();
83 switch (afam) {
84 case AF_INET : {
85 DK4_MEMCPY(&in4, src, sizeof(in4));
86 if (NULL != inet_ntop(afam, (void *)(&in4), dptr, dsz)) {
87 back = DK4_SOCKET_RESULT_SUCCESS;
88 } else {
89 dk4socket_error_report(erp, DK4_E_SOCKET_INET_NTOP);
90 }
91 } break;
92 #if DK4_HAVE_STRUCT_SOCKADDR_IN6
93 case AF_INET6 : {
94 DK4_MEMCPY(&in6, src, sizeof(in6));
95 if (NULL != inet_ntop(afam, (void *)(&in6), dptr, dsz)) {
96 back = DK4_SOCKET_RESULT_SUCCESS;
97 } else {
98 dk4socket_error_report(erp, DK4_E_SOCKET_INET_NTOP);
99 }
100 } break;
101 #endif
102 default : {
103 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
104 } break;
105 }
106 } else {
107 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
108 }
109 return back;
110 /* ----- +inet_ntop +Windows */
111 #else
112 /* +++++ +inet_ntop -Windows */
113 int back = DK4_SOCKET_RESULT_FAILED;
114 #if DK4_USE_ASSERT
115 assert(NULL != dptr);
116 assert(0 < dsz);
117 #endif
118 if ((NULL != dptr) && (0 < dsz)) { *dptr = '\0'; }
119 if ((NULL != dptr) && (NULL != src) && (0 < dsz)) {
120 if (NULL != inet_ntop(afam, src, dptr, (socklen_t)dsz)) {
121 back = DK4_SOCKET_RESULT_SUCCESS;
122 } else {
123 dk4socket_error_report(erp, DK4_E_SOCKET_INET_NTOP);
124 }
125 } else {
126 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
127 }
128 return back;
129 /* ----- +inet_ntop -Windows */
130 #endif
131 #else
132 /* +++++ -inet_ntop */
133 char buf[16*sizeof(dk4_um_t)];
134 const struct in_addr *inp4;
135 #if DK4_HAVE_STRUCT_SOCKADDR_IN6
136 const struct in6_addr *inp6;
137 #endif
138 unsigned long ul;
139 unsigned long u1;
140 int back = DK4_SOCKET_RESULT_FAILED;
141 #if DK4_HAVE_STRUCT_SOCKADDR_IN6
142 int i;
143 #endif
144 int res;
145 #if DK4_HAVE_STRUCT_SOCKADDR_IN6
146 unsigned short us;
147 #endif
148 #if DK4_USE_ASSERT
149 assert(NULL != dptr);
150 assert(0 < dsz);
151 #endif
152 if ((NULL != dptr) && (0 < dsz)) { *dptr = '\0'; }
153 if ((NULL != dptr) && (NULL != src) && (0 < dsz)) {
154 switch (afam) {
155 case AF_INET : {
156 inp4 = (const struct in_addr *)src;
157 ul = inp4->s_addr;
158 ul = dk4socket_htonl(ul);
159 u1 = ((ul >> 24) & 0x000000FFUL);
160 res = dk4ma_write_c8_decimal_unsigned(
161 buf, sizeof(buf), (dk4_um_t)u1, 0, erp
162 );
163 if (0 != res) {
164 if (0 != dk4str8_cpy_s(dptr, dsz, buf, erp)) {
165 u1 = ((ul >> 16) & 0x000000FFUL);
166 res = dk4ma_write_c8_decimal_unsigned(
167 buf, sizeof(buf), (dk4_um_t)u1, 0, erp
168 );
169 if (0 != res) {
170 if (0 != dk4str8_cat_s(dptr, dsz, dk4socket_c8_kw[1], erp)) {
171 if (0 != dk4str8_cat_s(dptr, dsz, buf, erp)) {
172 u1 = ((ul >> 8) & 0x000000FFUL);
173 res = dk4ma_write_c8_decimal_unsigned(
174 buf, sizeof(buf), (dk4_um_t)u1, 0, erp
175 );
176 if (0 != res) {
177 if (0 != dk4str8_cat_s(dptr,dsz,dk4socket_c8_kw[1],erp)) {
178 if (0 != dk4str8_cat_s(dptr, dsz, buf, erp)) {
179 u1 = (ul & 0x000000FFUL);
180 res = dk4ma_write_c8_decimal_unsigned(
181 buf, sizeof(buf), (dk4_um_t)u1, 0, erp
182 );
183 if (0 != res) {
184 if (
185 0 != dk4str8_cat_s(dptr,dsz,dk4socket_c8_kw[1],erp)
186 )
187 {
188 if (0 != dk4str8_cat_s(dptr, dsz, buf, erp)) {
189 back = DK4_SOCKET_RESULT_SUCCESS;
190 }
191 }
192 }
193 }
194 }
195 }
196 }
197 }
198 }
199 }
200 }
201 } break;
202 #if DK4_HAVE_STRUCT_SOCKADDR_IN6
203 case AF_INET6 : {
204 inp6 = (const struct in6_addr *)src;
205 back = DK4_SOCKET_RESULT_SUCCESS;
206 for (i = 0; i < 8; i++) {
207 #if DK4_ON_WINDOWS
208 us = inp6->u.Word[i];
209 #else
210 us = inp6->s6_addr16[i];
211 #endif
212 us = dk4socket_htons(us);
213 res = dk4ma_write_c8_hex_unsigned(
214 buf, sizeof(buf), (dk4_um_t)us, 0, erp
215 );
216 if (0 != res) {
217 if (0 == i) {
218 if (0 == dk4str8_cpy_s(dptr, dsz, buf, erp)) {
219 back = DK4_SOCKET_RESULT_FAILED;
220 i = 8;
221 }
222 } else {
223 if (0 != dk4str8_cat_s(dptr, dsz, dk4socket_c8_kw[2], erp)) {
224 if (0 != dk4str8_cat_s(dptr, dsz, buf, erp)) {
225 back = DK4_SOCKET_RESULT_FAILED;
226 i = 8;
227 }
228 } else {
229 back = DK4_SOCKET_RESULT_FAILED;
230 i = 8;
231 }
232 }
233 } else {
234 back = DK4_SOCKET_RESULT_FAILED;
235 i = 8;
236 }
237 }
238 } break;
239 #endif
240 default : {
241 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
242 } break;
243 }
244 } else {
245 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
246 }
247 return back;
248 /* ----- -inet_ntop */
249 #endif
250 }
251
252
253
254 int
dk4socket_c8_addr_port_to_text(char * dptr,size_t dsz,int DK4_ARG_UNUSED (afam),const struct sockaddr * saptr,size_t sasz,dk4_er_t * erp)255 dk4socket_c8_addr_port_to_text(
256 char *dptr,
257 size_t dsz,
258 #if DK4_HAVE_GETNAMEINFO
259 int DK4_ARG_UNUSED(afam),
260 #else
261 int afam,
262 #endif
263 const struct sockaddr *saptr,
264 size_t sasz,
265 dk4_er_t *erp
266 )
267 {
268 #if DK4_HAVE_GETNAMEINFO
269 /* +++++ +getnameinfo */
270 char hbuf[64]; /* Buffer for host address */
271 char pbuf[64]; /* Buffer for port number */
272 int res; /* Operation result */
273 int back = DK4_SOCKET_RESULT_FAILED;
274
275 DK4_UNUSED_ARG(afam)
276 #if DK4_USE_ASSERT
277 assert(NULL != dptr);
278 assert(NULL != saptr);
279 assert(0 < dsz);
280 assert(0 < sasz);
281 #endif
282 if ((NULL != dptr) && (0 < dsz)) { *dptr = '\0'; }
283 if ((NULL != dptr) && (NULL != saptr) && (0 < dsz) && (0 < sasz)) {
284 res = NI_NUMERICHOST | NI_NUMERICSERV;
285 dk4socket_error_reset();
286 #if DK4_HAVE_SOCKLEN_T
287 res = getnameinfo(
288 saptr, (socklen_t)sasz, hbuf, sizeof(hbuf), pbuf, sizeof(pbuf), res
289 );
290 #else
291 res = getnameinfo(saptr, sasz, hbuf, sizeof(hbuf), pbuf, sizeof(pbuf), res);
292 #endif
293 if (0 == res) {
294 if (0 != dk4str8_cpy_s(dptr, dsz, pbuf, erp)) {
295 if (0 != dk4str8_cat_s(dptr, dsz, dk4socket_c8_kw[0], erp)) {
296 if (0 != dk4str8_cat_s(dptr, dsz, hbuf, erp)) {
297 back = DK4_SOCKET_RESULT_SUCCESS;
298 } else {
299 }
300 } else {
301 }
302 } else {
303 }
304 } else {
305 dk4error_set_idetails(erp, DK4_E_SOCKET_GETADDRINFO, res);
306 }
307 } else {
308 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
309 }
310 return back;
311 /* ----- +getnameinfo */
312 #else
313 /* +++++ -getnameinfo */
314 char hbuf[64]; /* Host address buffer */
315 char pbuf[64]; /* Port name buffer */
316 struct sockaddr_in *psoin4; /* IPv4 address */
317 #if DK4_HAVE_STRUCT_SOCKADDR_IN6
318 struct sockaddr_in6 *psoin6; /* IPv6 address */
319 #endif
320 int back = DK4_SOCKET_RESULT_FAILED;
321 int hpah = 0;
322 int res;
323 unsigned short us;
324
325 #if DK4_USE_ASSERT
326 assert(NULL != dptr);
327 assert(NULL != saptr);
328 assert(0 < dsz);
329 assert(0 < sasz);
330 #endif
331 if ((NULL != dptr) && (0 < dsz)) { *dptr = '\0'; }
332 if ((NULL != dptr) && (NULL != saptr) && (0 < dsz) && (0 < sasz)) {
333 switch (afam) {
334 case AF_INET : {
335 psoin4 = (struct sockaddr_in *)saptr;
336 us = psoin4->sin_port;
337 us = dk4socket_ntohs(us);
338 res = dk4ma_write_c8_decimal_unsigned(
339 pbuf, sizeof(pbuf), (dk4_um_t)us, 0, erp
340 );
341 if (0 != res) {
342 res = dk4socket_c8_inet_ntop(
343 hbuf, sizeof(hbuf), AF_INET, &(psoin4->sin_addr), erp
344 );
345 if (DK4_SOCKET_RESULT_SUCCESS == res) {
346 hpah = 1;
347 }
348 }
349 } break;
350 #if DK4_HAVE_STRUCT_SOCKADDR_IN6
351 case AF_INET6 : {
352 psoin6 = (struct sockaddr_in6 *)saptr;
353 us = psoin6->sin6_port;
354 us = dk4socket_ntohs(us);
355 res = dk4ma_write_c8_decimal_unsigned(
356 pbuf, sizeof(pbuf), (dk4_um_t)us, 0, erp
357 );
358 if (0 != res) {
359 res = dk4socket_c8_inet_ntop(
360 hbuf, sizeof(hbuf), AF_INET6, &(psoin6->sin6_addr), erp
361 );
362 if (DK4_SOCKET_RESULT_SUCCESS == res) {
363 hpah = 1;
364 }
365 }
366 } break;
367 #endif
368 default : {
369 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
370 } break;
371 }
372 if (0 != hpah) {
373 if (0 != dk4str8_cpy_s(dptr, dsz, pbuf, erp)) {
374 if (0 != dk4str8_cat_s(dptr, dsz, dk4socket_c8_kw[0], erp)) {
375 if (0 != dk4str8_cat_s(dptr, dsz, hbuf, erp)) {
376 back = DK4_SOCKET_RESULT_SUCCESS;
377 }
378 }
379 }
380 }
381 } else {
382 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
383 }
384 return back;
385 /* ----- -getnameinfo */
386 #endif
387 }
388
389
390
391 int
dk4socket_c8_sockaddr_to_text(char * dptr,size_t dsz,const dk4_sockaddr_storage_t * saptr,dk4_er_t * erp)392 dk4socket_c8_sockaddr_to_text(
393 char *dptr,
394 size_t dsz,
395 const dk4_sockaddr_storage_t *saptr,
396 dk4_er_t *erp
397 )
398 {
399 const struct sockaddr *soa;
400 int back = DK4_SOCKET_RESULT_FAILED;
401
402 #if DK4_USE_ASSERT
403 assert(NULL != dptr);
404 assert(NULL != saptr);
405 assert(0 < dsz);
406 #endif
407 if ((NULL != dptr) && (NULL != saptr) && (0 < dsz)) {
408 soa = (const struct sockaddr *)saptr;
409 switch (soa->sa_family) {
410 case AF_INET : {
411 back = dk4socket_c8_addr_port_to_text(
412 dptr, dsz, AF_INET, soa, sizeof(struct sockaddr_in), erp
413 );
414 } break;
415 #if DK4_HAVE_STRUCT_SOCKADDR_IN6
416 case AF_INET6 : {
417 back = dk4socket_c8_addr_port_to_text(
418 dptr, dsz, AF_INET6, soa, sizeof(struct sockaddr_in6), erp
419 );
420 } break;
421 #endif
422 default : {
423 dk4error_set_simple_error_code(erp, DK4_E_SYNTAX);
424 } break;
425 }
426 } else {
427 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
428 }
429 return back;
430 }
431
432