dhcpd-pools  3.0
ISC dhcpd lease usage analyser
inet.h
Go to the documentation of this file.
1 /* DO NOT EDIT! GENERATED AUTOMATICALLY! */
2 /* A GNU-like <arpa/inet.h>.
3 
4  Copyright (C) 2005-2006, 2008-2017 Free Software Foundation, Inc.
5 
6  This program is free software; you can redistribute it and/or modify
7  it under the terms of the GNU General Public License as published by
8  the Free Software Foundation; either version 3, or (at your option)
9  any later version.
10 
11  This program is distributed in the hope that it will be useful,
12  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14  GNU General Public License for more details.
15 
16  You should have received a copy of the GNU General Public License
17  along with this program; if not, see <https://www.gnu.org/licenses/>. */
18 
19 #ifndef _GL_ARPA_INET_H
20 
21 #if __GNUC__ >= 3
22 #pragma GCC system_header
23 #endif
24 
25 
26 #if 1
27 # include <features.h> /* for __GLIBC__ */
28 #endif
29 
30 /* Gnulib's sys/socket.h is responsible for defining socklen_t (used below) and
31  for pulling in winsock2.h etc. under MinGW.
32  But avoid namespace pollution on glibc systems. */
33 #ifndef __GLIBC__
34 # include <sys/socket.h>
35 #endif
36 
37 /* On NonStop Kernel, inet_ntop and inet_pton are declared in <netdb.h>.
38  But avoid namespace pollution on glibc systems. */
39 #if defined __TANDEM && !defined __GLIBC__
40 # include <netdb.h>
41 #endif
42 
43 #if 1
44 
45 /* The include_next requires a split double-inclusion guard. */
46 # include_next <arpa/inet.h>
47 
48 #endif
49 
50 #ifndef _GL_ARPA_INET_H
51 #define _GL_ARPA_INET_H
52 
53 /* The definitions of _GL_FUNCDECL_RPL etc. are copied here. */
54 /* C++ compatible function declaration macros.
55  Copyright (C) 2010-2017 Free Software Foundation, Inc.
56 
57  This program is free software: you can redistribute it and/or modify it
58  under the terms of the GNU General Public License as published
59  by the Free Software Foundation; either version 3 of the License, or
60  (at your option) any later version.
61 
62  This program is distributed in the hope that it will be useful,
63  but WITHOUT ANY WARRANTY; without even the implied warranty of
64  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
65  General Public License for more details.
66 
67  You should have received a copy of the GNU General Public License
68  along with this program. If not, see <https://www.gnu.org/licenses/>. */
69 
70 #ifndef _GL_CXXDEFS_H
71 #define _GL_CXXDEFS_H
72 
73 /* Begin/end the GNULIB_NAMESPACE namespace. */
74 #if defined __cplusplus && defined GNULIB_NAMESPACE
75 # define _GL_BEGIN_NAMESPACE namespace GNULIB_NAMESPACE {
76 # define _GL_END_NAMESPACE }
77 #else
78 # define _GL_BEGIN_NAMESPACE
79 # define _GL_END_NAMESPACE
80 #endif
81 
82 /* The three most frequent use cases of these macros are:
83 
84  * For providing a substitute for a function that is missing on some
85  platforms, but is declared and works fine on the platforms on which
86  it exists:
87 
88  #if @GNULIB_FOO@
89  # if !@HAVE_FOO@
90  _GL_FUNCDECL_SYS (foo, ...);
91  # endif
92  _GL_CXXALIAS_SYS (foo, ...);
93  _GL_CXXALIASWARN (foo);
94  #elif defined GNULIB_POSIXCHECK
95  ...
96  #endif
97 
98  * For providing a replacement for a function that exists on all platforms,
99  but is broken/insufficient and needs to be replaced on some platforms:
100 
101  #if @GNULIB_FOO@
102  # if @REPLACE_FOO@
103  # if !(defined __cplusplus && defined GNULIB_NAMESPACE)
104  # undef foo
105  # define foo rpl_foo
106  # endif
107  _GL_FUNCDECL_RPL (foo, ...);
108  _GL_CXXALIAS_RPL (foo, ...);
109  # else
110  _GL_CXXALIAS_SYS (foo, ...);
111  # endif
112  _GL_CXXALIASWARN (foo);
113  #elif defined GNULIB_POSIXCHECK
114  ...
115  #endif
116 
117  * For providing a replacement for a function that exists on some platforms
118  but is broken/insufficient and needs to be replaced on some of them and
119  is additionally either missing or undeclared on some other platforms:
120 
121  #if @GNULIB_FOO@
122  # if @REPLACE_FOO@
123  # if !(defined __cplusplus && defined GNULIB_NAMESPACE)
124  # undef foo
125  # define foo rpl_foo
126  # endif
127  _GL_FUNCDECL_RPL (foo, ...);
128  _GL_CXXALIAS_RPL (foo, ...);
129  # else
130  # if !@HAVE_FOO@ or if !@HAVE_DECL_FOO@
131  _GL_FUNCDECL_SYS (foo, ...);
132  # endif
133  _GL_CXXALIAS_SYS (foo, ...);
134  # endif
135  _GL_CXXALIASWARN (foo);
136  #elif defined GNULIB_POSIXCHECK
137  ...
138  #endif
139 */
140 
141 /* _GL_EXTERN_C declaration;
142  performs the declaration with C linkage. */
143 #if defined __cplusplus
144 # define _GL_EXTERN_C extern "C"
145 #else
146 # define _GL_EXTERN_C extern
147 #endif
148 
149 /* _GL_FUNCDECL_RPL (func, rettype, parameters_and_attributes);
150  declares a replacement function, named rpl_func, with the given prototype,
151  consisting of return type, parameters, and attributes.
152  Example:
153  _GL_FUNCDECL_RPL (open, int, (const char *filename, int flags, ...)
154  _GL_ARG_NONNULL ((1)));
155  */
156 #define _GL_FUNCDECL_RPL(func,rettype,parameters_and_attributes) \
157  _GL_FUNCDECL_RPL_1 (rpl_##func, rettype, parameters_and_attributes)
158 #define _GL_FUNCDECL_RPL_1(rpl_func,rettype,parameters_and_attributes) \
159  _GL_EXTERN_C rettype rpl_func parameters_and_attributes
160 
161 /* _GL_FUNCDECL_SYS (func, rettype, parameters_and_attributes);
162  declares the system function, named func, with the given prototype,
163  consisting of return type, parameters, and attributes.
164  Example:
165  _GL_FUNCDECL_SYS (open, int, (const char *filename, int flags, ...)
166  _GL_ARG_NONNULL ((1)));
167  */
168 #define _GL_FUNCDECL_SYS(func,rettype,parameters_and_attributes) \
169  _GL_EXTERN_C rettype func parameters_and_attributes
170 
171 /* _GL_CXXALIAS_RPL (func, rettype, parameters);
172  declares a C++ alias called GNULIB_NAMESPACE::func
173  that redirects to rpl_func, if GNULIB_NAMESPACE is defined.
174  Example:
175  _GL_CXXALIAS_RPL (open, int, (const char *filename, int flags, ...));
176 
177  Wrapping rpl_func in an object with an inline conversion operator
178  avoids a reference to rpl_func unless GNULIB_NAMESPACE::func is
179  actually used in the program. */
180 #define _GL_CXXALIAS_RPL(func,rettype,parameters) \
181  _GL_CXXALIAS_RPL_1 (func, rpl_##func, rettype, parameters)
182 #if defined __cplusplus && defined GNULIB_NAMESPACE
183 # define _GL_CXXALIAS_RPL_1(func,rpl_func,rettype,parameters) \
184  namespace GNULIB_NAMESPACE \
185  { \
186  static const struct _gl_ ## func ## _wrapper \
187  { \
188  typedef rettype (*type) parameters; \
189  \
190  inline operator type () const \
191  { \
192  return ::rpl_func; \
193  } \
194  } func = {}; \
195  } \
196  _GL_EXTERN_C int _gl_cxxalias_dummy
197 #else
198 # define _GL_CXXALIAS_RPL_1(func,rpl_func,rettype,parameters) \
199  _GL_EXTERN_C int _gl_cxxalias_dummy
200 #endif
201 
202 /* _GL_CXXALIAS_RPL_CAST_1 (func, rpl_func, rettype, parameters);
203  is like _GL_CXXALIAS_RPL_1 (func, rpl_func, rettype, parameters);
204  except that the C function rpl_func may have a slightly different
205  declaration. A cast is used to silence the "invalid conversion" error
206  that would otherwise occur. */
207 #if defined __cplusplus && defined GNULIB_NAMESPACE
208 # define _GL_CXXALIAS_RPL_CAST_1(func,rpl_func,rettype,parameters) \
209  namespace GNULIB_NAMESPACE \
210  { \
211  static const struct _gl_ ## func ## _wrapper \
212  { \
213  typedef rettype (*type) parameters; \
214  \
215  inline operator type () const \
216  { \
217  return reinterpret_cast<type>(::rpl_func); \
218  } \
219  } func = {}; \
220  } \
221  _GL_EXTERN_C int _gl_cxxalias_dummy
222 #else
223 # define _GL_CXXALIAS_RPL_CAST_1(func,rpl_func,rettype,parameters) \
224  _GL_EXTERN_C int _gl_cxxalias_dummy
225 #endif
226 
227 /* _GL_CXXALIAS_SYS (func, rettype, parameters);
228  declares a C++ alias called GNULIB_NAMESPACE::func
229  that redirects to the system provided function func, if GNULIB_NAMESPACE
230  is defined.
231  Example:
232  _GL_CXXALIAS_SYS (open, int, (const char *filename, int flags, ...));
233 
234  Wrapping func in an object with an inline conversion operator
235  avoids a reference to func unless GNULIB_NAMESPACE::func is
236  actually used in the program. */
237 #if defined __cplusplus && defined GNULIB_NAMESPACE
238 # define _GL_CXXALIAS_SYS(func,rettype,parameters) \
239  namespace GNULIB_NAMESPACE \
240  { \
241  static const struct _gl_ ## func ## _wrapper \
242  { \
243  typedef rettype (*type) parameters; \
244  \
245  inline operator type () const \
246  { \
247  return ::func; \
248  } \
249  } func = {}; \
250  } \
251  _GL_EXTERN_C int _gl_cxxalias_dummy
252 #else
253 # define _GL_CXXALIAS_SYS(func,rettype,parameters) \
254  _GL_EXTERN_C int _gl_cxxalias_dummy
255 #endif
256 
257 /* _GL_CXXALIAS_SYS_CAST (func, rettype, parameters);
258  is like _GL_CXXALIAS_SYS (func, rettype, parameters);
259  except that the C function func may have a slightly different declaration.
260  A cast is used to silence the "invalid conversion" error that would
261  otherwise occur. */
262 #if defined __cplusplus && defined GNULIB_NAMESPACE
263 # define _GL_CXXALIAS_SYS_CAST(func,rettype,parameters) \
264  namespace GNULIB_NAMESPACE \
265  { \
266  static const struct _gl_ ## func ## _wrapper \
267  { \
268  typedef rettype (*type) parameters; \
269  \
270  inline operator type () const \
271  { \
272  return reinterpret_cast<type>(::func); \
273  } \
274  } func = {}; \
275  } \
276  _GL_EXTERN_C int _gl_cxxalias_dummy
277 #else
278 # define _GL_CXXALIAS_SYS_CAST(func,rettype,parameters) \
279  _GL_EXTERN_C int _gl_cxxalias_dummy
280 #endif
281 
282 /* _GL_CXXALIAS_SYS_CAST2 (func, rettype, parameters, rettype2, parameters2);
283  is like _GL_CXXALIAS_SYS (func, rettype, parameters);
284  except that the C function is picked among a set of overloaded functions,
285  namely the one with rettype2 and parameters2. Two consecutive casts
286  are used to silence the "cannot find a match" and "invalid conversion"
287  errors that would otherwise occur. */
288 #if defined __cplusplus && defined GNULIB_NAMESPACE
289  /* The outer cast must be a reinterpret_cast.
290  The inner cast: When the function is defined as a set of overloaded
291  functions, it works as a static_cast<>, choosing the designated variant.
292  When the function is defined as a single variant, it works as a
293  reinterpret_cast<>. The parenthesized cast syntax works both ways. */
294 # define _GL_CXXALIAS_SYS_CAST2(func,rettype,parameters,rettype2,parameters2) \
295  namespace GNULIB_NAMESPACE \
296  { \
297  static const struct _gl_ ## func ## _wrapper \
298  { \
299  typedef rettype (*type) parameters; \
300  \
301  inline operator type () const \
302  { \
303  return reinterpret_cast<type>((rettype2 (*) parameters2)(::func)); \
304  } \
305  } func = {}; \
306  } \
307  _GL_EXTERN_C int _gl_cxxalias_dummy
308 #else
309 # define _GL_CXXALIAS_SYS_CAST2(func,rettype,parameters,rettype2,parameters2) \
310  _GL_EXTERN_C int _gl_cxxalias_dummy
311 #endif
312 
313 /* _GL_CXXALIASWARN (func);
314  causes a warning to be emitted when ::func is used but not when
315  GNULIB_NAMESPACE::func is used. func must be defined without overloaded
316  variants. */
317 #if defined __cplusplus && defined GNULIB_NAMESPACE
318 # define _GL_CXXALIASWARN(func) \
319  _GL_CXXALIASWARN_1 (func, GNULIB_NAMESPACE)
320 # define _GL_CXXALIASWARN_1(func,namespace) \
321  _GL_CXXALIASWARN_2 (func, namespace)
322 /* To work around GCC bug <https://gcc.gnu.org/bugzilla/show_bug.cgi?id=43881>,
323  we enable the warning only when not optimizing. */
324 # if !__OPTIMIZE__
325 # define _GL_CXXALIASWARN_2(func,namespace) \
326  _GL_WARN_ON_USE (func, \
327  "The symbol ::" #func " refers to the system function. " \
328  "Use " #namespace "::" #func " instead.")
329 # elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING
330 # define _GL_CXXALIASWARN_2(func,namespace) \
331  extern __typeof__ (func) func
332 # else
333 # define _GL_CXXALIASWARN_2(func,namespace) \
334  _GL_EXTERN_C int _gl_cxxalias_dummy
335 # endif
336 #else
337 # define _GL_CXXALIASWARN(func) \
338  _GL_EXTERN_C int _gl_cxxalias_dummy
339 #endif
340 
341 /* _GL_CXXALIASWARN1 (func, rettype, parameters_and_attributes);
342  causes a warning to be emitted when the given overloaded variant of ::func
343  is used but not when GNULIB_NAMESPACE::func is used. */
344 #if defined __cplusplus && defined GNULIB_NAMESPACE
345 # define _GL_CXXALIASWARN1(func,rettype,parameters_and_attributes) \
346  _GL_CXXALIASWARN1_1 (func, rettype, parameters_and_attributes, \
347  GNULIB_NAMESPACE)
348 # define _GL_CXXALIASWARN1_1(func,rettype,parameters_and_attributes,namespace) \
349  _GL_CXXALIASWARN1_2 (func, rettype, parameters_and_attributes, namespace)
350 /* To work around GCC bug <https://gcc.gnu.org/bugzilla/show_bug.cgi?id=43881>,
351  we enable the warning only when not optimizing. */
352 # if !__OPTIMIZE__
353 # define _GL_CXXALIASWARN1_2(func,rettype,parameters_and_attributes,namespace) \
354  _GL_WARN_ON_USE_CXX (func, rettype, parameters_and_attributes, \
355  "The symbol ::" #func " refers to the system function. " \
356  "Use " #namespace "::" #func " instead.")
357 # elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING
358 # define _GL_CXXALIASWARN1_2(func,rettype,parameters_and_attributes,namespace) \
359  extern __typeof__ (func) func
360 # else
361 # define _GL_CXXALIASWARN1_2(func,rettype,parameters_and_attributes,namespace) \
362  _GL_EXTERN_C int _gl_cxxalias_dummy
363 # endif
364 #else
365 # define _GL_CXXALIASWARN1(func,rettype,parameters_and_attributes) \
366  _GL_EXTERN_C int _gl_cxxalias_dummy
367 #endif
368 
369 #endif /* _GL_CXXDEFS_H */
370 
371 /* The definition of _GL_ARG_NONNULL is copied here. */
372 /* A C macro for declaring that specific arguments must not be NULL.
373  Copyright (C) 2009-2017 Free Software Foundation, Inc.
374 
375  This program is free software: you can redistribute it and/or modify it
376  under the terms of the GNU General Public License as published
377  by the Free Software Foundation; either version 3 of the License, or
378  (at your option) any later version.
379 
380  This program is distributed in the hope that it will be useful,
381  but WITHOUT ANY WARRANTY; without even the implied warranty of
382  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
383  General Public License for more details.
384 
385  You should have received a copy of the GNU General Public License
386  along with this program. If not, see <https://www.gnu.org/licenses/>. */
387 
388 /* _GL_ARG_NONNULL((n,...,m)) tells the compiler and static analyzer tools
389  that the values passed as arguments n, ..., m must be non-NULL pointers.
390  n = 1 stands for the first argument, n = 2 for the second argument etc. */
391 #ifndef _GL_ARG_NONNULL
392 # if (__GNUC__ == 3 && __GNUC_MINOR__ >= 3) || __GNUC__ > 3
393 # define _GL_ARG_NONNULL(params) __attribute__ ((__nonnull__ params))
394 # else
395 # define _GL_ARG_NONNULL(params)
396 # endif
397 #endif
398 
399 /* The definition of _GL_WARN_ON_USE is copied here. */
400 /* A C macro for emitting warnings if a function is used.
401  Copyright (C) 2010-2017 Free Software Foundation, Inc.
402 
403  This program is free software: you can redistribute it and/or modify it
404  under the terms of the GNU General Public License as published
405  by the Free Software Foundation; either version 3 of the License, or
406  (at your option) any later version.
407 
408  This program is distributed in the hope that it will be useful,
409  but WITHOUT ANY WARRANTY; without even the implied warranty of
410  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
411  General Public License for more details.
412 
413  You should have received a copy of the GNU General Public License
414  along with this program. If not, see <https://www.gnu.org/licenses/>. */
415 
416 /* _GL_WARN_ON_USE (function, "literal string") issues a declaration
417  for FUNCTION which will then trigger a compiler warning containing
418  the text of "literal string" anywhere that function is called, if
419  supported by the compiler. If the compiler does not support this
420  feature, the macro expands to an unused extern declaration.
421 
422  This macro is useful for marking a function as a potential
423  portability trap, with the intent that "literal string" include
424  instructions on the replacement function that should be used
425  instead. However, one of the reasons that a function is a
426  portability trap is if it has the wrong signature. Declaring
427  FUNCTION with a different signature in C is a compilation error, so
428  this macro must use the same type as any existing declaration so
429  that programs that avoid the problematic FUNCTION do not fail to
430  compile merely because they included a header that poisoned the
431  function. But this implies that _GL_WARN_ON_USE is only safe to
432  use if FUNCTION is known to already have a declaration. Use of
433  this macro implies that there must not be any other macro hiding
434  the declaration of FUNCTION; but undefining FUNCTION first is part
435  of the poisoning process anyway (although for symbols that are
436  provided only via a macro, the result is a compilation error rather
437  than a warning containing "literal string"). Also note that in
438  C++, it is only safe to use if FUNCTION has no overloads.
439 
440  For an example, it is possible to poison 'getline' by:
441  - adding a call to gl_WARN_ON_USE_PREPARE([[#include <stdio.h>]],
442  [getline]) in configure.ac, which potentially defines
443  HAVE_RAW_DECL_GETLINE
444  - adding this code to a header that wraps the system <stdio.h>:
445  #undef getline
446  #if HAVE_RAW_DECL_GETLINE
447  _GL_WARN_ON_USE (getline, "getline is required by POSIX 2008, but"
448  "not universally present; use the gnulib module getline");
449  #endif
450 
451  It is not possible to directly poison global variables. But it is
452  possible to write a wrapper accessor function, and poison that
453  (less common usage, like &environ, will cause a compilation error
454  rather than issue the nice warning, but the end result of informing
455  the developer about their portability problem is still achieved):
456  #if HAVE_RAW_DECL_ENVIRON
457  static char ***rpl_environ (void) { return &environ; }
458  _GL_WARN_ON_USE (rpl_environ, "environ is not always properly declared");
459  # undef environ
460  # define environ (*rpl_environ ())
461  #endif
462  */
463 #ifndef _GL_WARN_ON_USE
464 
465 # if 4 < __GNUC__ || (__GNUC__ == 4 && 3 <= __GNUC_MINOR__)
466 /* A compiler attribute is available in gcc versions 4.3.0 and later. */
467 # define _GL_WARN_ON_USE(function, message) \
468 extern __typeof__ (function) function __attribute__ ((__warning__ (message)))
469 # elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING
470 /* Verify the existence of the function. */
471 # define _GL_WARN_ON_USE(function, message) \
472 extern __typeof__ (function) function
473 # else /* Unsupported. */
474 # define _GL_WARN_ON_USE(function, message) \
475 _GL_WARN_EXTERN_C int _gl_warn_on_use
476 # endif
477 #endif
478 
479 /* _GL_WARN_ON_USE_CXX (function, rettype, parameters_and_attributes, "string")
480  is like _GL_WARN_ON_USE (function, "string"), except that the function is
481  declared with the given prototype, consisting of return type, parameters,
482  and attributes.
483  This variant is useful for overloaded functions in C++. _GL_WARN_ON_USE does
484  not work in this case. */
485 #ifndef _GL_WARN_ON_USE_CXX
486 # if 4 < __GNUC__ || (__GNUC__ == 4 && 3 <= __GNUC_MINOR__)
487 # define _GL_WARN_ON_USE_CXX(function,rettype,parameters_and_attributes,msg) \
488 extern rettype function parameters_and_attributes \
489  __attribute__ ((__warning__ (msg)))
490 # elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING
491 /* Verify the existence of the function. */
492 # define _GL_WARN_ON_USE_CXX(function,rettype,parameters_and_attributes,msg) \
493 extern rettype function parameters_and_attributes
494 # else /* Unsupported. */
495 # define _GL_WARN_ON_USE_CXX(function,rettype,parameters_and_attributes,msg) \
496 _GL_WARN_EXTERN_C int _gl_warn_on_use
497 # endif
498 #endif
499 
500 /* _GL_WARN_EXTERN_C declaration;
501  performs the declaration with C linkage. */
502 #ifndef _GL_WARN_EXTERN_C
503 # if defined __cplusplus
504 # define _GL_WARN_EXTERN_C extern "C"
505 # else
506 # define _GL_WARN_EXTERN_C extern
507 # endif
508 #endif
509 
510 
511 #if 0
512 /* Converts an internet address from internal format to a printable,
513  presentable format.
514  AF is an internet address family, such as AF_INET or AF_INET6.
515  SRC points to a 'struct in_addr' (for AF_INET) or 'struct in6_addr'
516  (for AF_INET6).
517  DST points to a buffer having room for CNT bytes.
518  The printable representation of the address (in numeric form, not
519  surrounded by [...], no reverse DNS is done) is placed in DST, and
520  DST is returned. If an error occurs, the return value is NULL and
521  errno is set. If CNT bytes are not sufficient to hold the result,
522  the return value is NULL and errno is set to ENOSPC. A good value
523  for CNT is 46.
524 
525  For more details, see the POSIX:2001 specification
526  <http://www.opengroup.org/susv3xsh/inet_ntop.html>. */
527 # if 0
528 # if !(defined __cplusplus && defined GNULIB_NAMESPACE)
529 # undef inet_ntop
530 # define inet_ntop rpl_inet_ntop
531 # endif
532 _GL_FUNCDECL_RPL (inet_ntop, const char *,
533  (int af, const void *restrict src,
534  char *restrict dst, socklen_t cnt)
535  _GL_ARG_NONNULL ((2, 3)));
536 _GL_CXXALIAS_RPL (inet_ntop, const char *,
537  (int af, const void *restrict src,
538  char *restrict dst, socklen_t cnt));
539 # else
540 # if !1
541 _GL_FUNCDECL_SYS (inet_ntop, const char *,
542  (int af, const void *restrict src,
543  char *restrict dst, socklen_t cnt)
544  _GL_ARG_NONNULL ((2, 3)));
545 # endif
546 /* Need to cast, because on NonStop Kernel, the fourth parameter is
547  size_t cnt. */
548 _GL_CXXALIAS_SYS_CAST (inet_ntop, const char *,
549  (int af, const void *restrict src,
550  char *restrict dst, socklen_t cnt));
551 # endif
552 _GL_CXXALIASWARN (inet_ntop);
553 #elif defined GNULIB_POSIXCHECK
554 # undef inet_ntop
555 # if HAVE_RAW_DECL_INET_NTOP
556 _GL_WARN_ON_USE (inet_ntop, "inet_ntop is unportable - "
557  "use gnulib module inet_ntop for portability");
558 # endif
559 #endif
560 
561 #if 1
562 # if 0
563 # if !(defined __cplusplus && defined GNULIB_NAMESPACE)
564 # undef inet_pton
565 # define inet_pton rpl_inet_pton
566 # endif
568  (int af, const char *restrict src, void *restrict dst)
569  _GL_ARG_NONNULL ((2, 3)));
571  (int af, const char *restrict src, void *restrict dst));
572 # else
573 # if !1
575  (int af, const char *restrict src, void *restrict dst)
576  _GL_ARG_NONNULL ((2, 3)));
577 # endif
579  (int af, const char *restrict src, void *restrict dst));
580 # endif
582 #elif defined GNULIB_POSIXCHECK
583 # undef inet_pton
584 # if HAVE_RAW_DECL_INET_PTON
585 _GL_WARN_ON_USE (inet_pton, "inet_pton is unportable - "
586  "use gnulib module inet_pton for portability");
587 # endif
588 #endif
589 
590 
591 #endif /* _GL_ARPA_INET_H */
592 #endif /* _GL_ARPA_INET_H */
int inet_pton(int af, const char *restrict src, void *restrict dst)
Definition: inet_pton.c:82
#define _GL_CXXALIAS_SYS_CAST(func, rettype, parameters)
Definition: inet.h:278
#define _GL_FUNCDECL_SYS(func, rettype, parameters_and_attributes)
Definition: inet.h:168
#define _GL_ARG_NONNULL(params)
Definition: inet.h:395
#define _GL_CXXALIAS_RPL(func, rettype, parameters)
Definition: inet.h:180
#define _GL_CXXALIASWARN(func)
Definition: inet.h:337
#define _GL_CXXALIAS_SYS(func, rettype, parameters)
Definition: inet.h:253
#define _GL_FUNCDECL_RPL(func, rettype, parameters_and_attributes)
Definition: inet.h:156
#define restrict
Definition: config.h:1858
#define _GL_WARN_ON_USE(function, message)
Definition: inet.h:474