1 #***************************************************************************
3 # Project ___| | | | _ \| |
5 # | (__| |_| | _ <| |___
6 # \___|\___/|_| \_\_____|
8 # Copyright (C) 1998 - 2011, Daniel Stenberg, <daniel@haxx.se>, et al.
10 # This software is licensed as described in the file COPYING, which
11 # you should have received as part of this distribution. The terms
12 # are also available at http://curl.haxx.se/docs/copyright.html.
14 # You may opt to use, copy, modify, merge, publish, distribute and/or sell
15 # copies of the Software, and permit persons to whom the Software is
16 # furnished to do so, under the terms of the COPYING file.
18 # This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
19 # KIND, either express or implied.
21 #***************************************************************************
23 # File version for 'aclocal' use. Keep it a single number.
27 dnl CURL_INCLUDES_ARPA_INET
28 dnl -------------------------------------------------
29 dnl Set up variable with list of headers that must be
30 dnl included when arpa/inet.h is to be included.
32 AC_DEFUN([CURL_INCLUDES_ARPA_INET], [
33 curl_includes_arpa_inet="\
35 #ifdef HAVE_SYS_TYPES_H
36 # include <sys/types.h>
38 #ifdef HAVE_SYS_SOCKET_H
39 # include <sys/socket.h>
41 #ifdef HAVE_NETINET_IN_H
42 # include <netinet/in.h>
44 #ifdef HAVE_ARPA_INET_H
45 # include <arpa/inet.h>
49 sys/types.h sys/socket.h netinet/in.h arpa/inet.h,
50 [], [], [$curl_includes_arpa_inet])
54 dnl CURL_INCLUDES_FCNTL
55 dnl -------------------------------------------------
56 dnl Set up variable with list of headers that must be
57 dnl included when fcntl.h is to be included.
59 AC_DEFUN([CURL_INCLUDES_FCNTL], [
60 curl_includes_fcntl="\
62 #ifdef HAVE_SYS_TYPES_H
63 # include <sys/types.h>
73 sys/types.h unistd.h fcntl.h,
74 [], [], [$curl_includes_fcntl])
78 dnl CURL_INCLUDES_IFADDRS
79 dnl -------------------------------------------------
80 dnl Set up variable with list of headers that must be
81 dnl included when ifaddrs.h is to be included.
83 AC_DEFUN([CURL_INCLUDES_IFADDRS], [
84 curl_includes_ifaddrs="\
86 #ifdef HAVE_SYS_TYPES_H
87 # include <sys/types.h>
89 #ifdef HAVE_SYS_SOCKET_H
90 # include <sys/socket.h>
92 #ifdef HAVE_NETINET_IN_H
93 # include <netinet/in.h>
100 sys/types.h sys/socket.h netinet/in.h ifaddrs.h,
101 [], [], [$curl_includes_ifaddrs])
105 dnl CURL_INCLUDES_INTTYPES
106 dnl -------------------------------------------------
107 dnl Set up variable with list of headers that must be
108 dnl included when inttypes.h is to be included.
110 AC_DEFUN([CURL_INCLUDES_INTTYPES], [
111 curl_includes_inttypes="\
113 #ifdef HAVE_SYS_TYPES_H
114 # include <sys/types.h>
119 #ifdef HAVE_INTTYPES_H
120 # include <inttypes.h>
125 ac_cv_header_stdint_h="no"
129 sys/types.h stdint.h inttypes.h,
130 [], [], [$curl_includes_inttypes])
134 dnl CURL_INCLUDES_LIBGEN
135 dnl -------------------------------------------------
136 dnl Set up variable with list of headers that must be
137 dnl included when libgen.h is to be included.
139 AC_DEFUN([CURL_INCLUDES_LIBGEN], [
140 curl_includes_libgen="\
142 #ifdef HAVE_SYS_TYPES_H
143 # include <sys/types.h>
150 sys/types.h libgen.h,
151 [], [], [$curl_includes_libgen])
155 dnl CURL_INCLUDES_NETDB
156 dnl -------------------------------------------------
157 dnl Set up variable with list of headers that must be
158 dnl included when netdb.h is to be included.
160 AC_DEFUN([CURL_INCLUDES_NETDB], [
161 curl_includes_netdb="\
163 #ifdef HAVE_SYS_TYPES_H
164 # include <sys/types.h>
172 [], [], [$curl_includes_netdb])
176 dnl CURL_INCLUDES_POLL
177 dnl -------------------------------------------------
178 dnl Set up variable with list of headers that must be
179 dnl included when poll.h is to be included.
181 AC_DEFUN([CURL_INCLUDES_POLL], [
182 curl_includes_poll="\
184 #ifdef HAVE_SYS_TYPES_H
185 # include <sys/types.h>
190 #ifdef HAVE_SYS_POLL_H
191 # include <sys/poll.h>
195 sys/types.h poll.h sys/poll.h,
196 [], [], [$curl_includes_poll])
200 dnl CURL_INCLUDES_SETJMP
201 dnl -------------------------------------------------
202 dnl Set up variable with list of headers that must be
203 dnl included when setjmp.h is to be included.
205 AC_DEFUN([CURL_INCLUDES_SETJMP], [
206 curl_includes_setjmp="\
208 #ifdef HAVE_SYS_TYPES_H
209 # include <sys/types.h>
216 sys/types.h setjmp.h,
217 [], [], [$curl_includes_setjmp])
221 dnl CURL_INCLUDES_SIGNAL
222 dnl -------------------------------------------------
223 dnl Set up variable with list of headers that must be
224 dnl included when signal.h is to be included.
226 AC_DEFUN([CURL_INCLUDES_SIGNAL], [
227 curl_includes_signal="\
229 #ifdef HAVE_SYS_TYPES_H
230 # include <sys/types.h>
237 sys/types.h signal.h,
238 [], [], [$curl_includes_signal])
242 dnl CURL_INCLUDES_SOCKET
243 dnl -------------------------------------------------
244 dnl Set up variable with list of headers that must be
245 dnl included when socket.h is to be included.
247 AC_DEFUN([CURL_INCLUDES_SOCKET], [
248 curl_includes_socket="\
250 #ifdef HAVE_SYS_TYPES_H
251 # include <sys/types.h>
258 sys/types.h socket.h,
259 [], [], [$curl_includes_socket])
263 dnl CURL_INCLUDES_STDIO
264 dnl -------------------------------------------------
265 dnl Set up variable with list of headers that must be
266 dnl included when stdio.h is to be included.
268 AC_DEFUN([CURL_INCLUDES_STDIO], [
269 curl_includes_stdio="\
271 #ifdef HAVE_SYS_TYPES_H
272 # include <sys/types.h>
280 [], [], [$curl_includes_stdio])
284 dnl CURL_INCLUDES_STDLIB
285 dnl -------------------------------------------------
286 dnl Set up variable with list of headers that must be
287 dnl included when stdlib.h is to be included.
289 AC_DEFUN([CURL_INCLUDES_STDLIB], [
290 curl_includes_stdlib="\
292 #ifdef HAVE_SYS_TYPES_H
293 # include <sys/types.h>
300 sys/types.h stdlib.h,
301 [], [], [$curl_includes_stdlib])
305 dnl CURL_INCLUDES_STRING
306 dnl -------------------------------------------------
307 dnl Set up variable with list of headers that must be
308 dnl included when string(s).h is to be included.
310 AC_DEFUN([CURL_INCLUDES_STRING], [
311 curl_includes_string="\
313 #ifdef HAVE_SYS_TYPES_H
314 # include <sys/types.h>
319 #ifdef HAVE_STRINGS_H
320 # include <strings.h>
324 sys/types.h string.h strings.h,
325 [], [], [$curl_includes_string])
329 dnl CURL_INCLUDES_STROPTS
330 dnl -------------------------------------------------
331 dnl Set up variable with list of headers that must be
332 dnl included when stropts.h is to be included.
334 AC_DEFUN([CURL_INCLUDES_STROPTS], [
335 curl_includes_stropts="\
337 #ifdef HAVE_SYS_TYPES_H
338 # include <sys/types.h>
343 #ifdef HAVE_SYS_SOCKET_H
344 # include <sys/socket.h>
346 #ifdef HAVE_SYS_IOCTL_H
347 # include <sys/ioctl.h>
349 #ifdef HAVE_STROPTS_H
350 # include <stropts.h>
354 sys/types.h unistd.h sys/socket.h sys/ioctl.h stropts.h,
355 [], [], [$curl_includes_stropts])
359 dnl CURL_INCLUDES_SYS_SOCKET
360 dnl -------------------------------------------------
361 dnl Set up variable with list of headers that must be
362 dnl included when sys/socket.h is to be included.
364 AC_DEFUN([CURL_INCLUDES_SYS_SOCKET], [
365 curl_includes_sys_socket="\
367 #ifdef HAVE_SYS_TYPES_H
368 # include <sys/types.h>
370 #ifdef HAVE_SYS_SOCKET_H
371 # include <sys/socket.h>
375 sys/types.h sys/socket.h,
376 [], [], [$curl_includes_sys_socket])
380 dnl CURL_INCLUDES_SYS_TYPES
381 dnl -------------------------------------------------
382 dnl Set up variable with list of headers that must be
383 dnl included when sys/types.h is to be included.
385 AC_DEFUN([CURL_INCLUDES_SYS_TYPES], [
386 curl_includes_sys_types="\
388 #ifdef HAVE_SYS_TYPES_H
389 # include <sys/types.h>
394 [], [], [$curl_includes_sys_types])
398 dnl CURL_INCLUDES_SYS_UIO
399 dnl -------------------------------------------------
400 dnl Set up variable with list of headers that must be
401 dnl included when sys/uio.h is to be included.
403 AC_DEFUN([CURL_INCLUDES_SYS_UIO], [
404 curl_includes_sys_uio="\
406 #ifdef HAVE_SYS_TYPES_H
407 # include <sys/types.h>
409 #ifdef HAVE_SYS_UIO_H
410 # include <sys/uio.h>
414 sys/types.h sys/uio.h,
415 [], [], [$curl_includes_sys_uio])
419 dnl CURL_INCLUDES_SYS_XATTR
420 dnl -------------------------------------------------
421 dnl Set up variable with list of headers that must be
422 dnl included when sys/xattr.h is to be included.
424 AC_DEFUN([CURL_INCLUDES_SYS_XATTR], [
425 curl_includes_sys_xattr="\
427 #ifdef HAVE_SYS_TYPES_H
428 # include <sys/types.h>
430 #ifdef HAVE_SYS_XATTR_H
431 # include <sys/xattr.h>
435 sys/types.h sys/xattr.h,
436 [], [], [$curl_includes_sys_xattr])
439 dnl CURL_INCLUDES_TIME
440 dnl -------------------------------------------------
441 dnl Set up variable with list of headers that must be
442 dnl included when time.h is to be included.
444 AC_DEFUN([CURL_INCLUDES_TIME], [
445 AC_REQUIRE([AC_HEADER_TIME])dnl
446 curl_includes_time="\
448 #ifdef HAVE_SYS_TYPES_H
449 # include <sys/types.h>
451 #ifdef HAVE_SYS_TIME_H
452 # include <sys/time.h>
453 # ifdef TIME_WITH_SYS_TIME
463 sys/types.h sys/time.h time.h,
464 [], [], [$curl_includes_time])
468 dnl CURL_INCLUDES_UNISTD
469 dnl -------------------------------------------------
470 dnl Set up variable with list of headers that must be
471 dnl included when unistd.h is to be included.
473 AC_DEFUN([CURL_INCLUDES_UNISTD], [
474 curl_includes_unistd="\
476 #ifdef HAVE_SYS_TYPES_H
477 # include <sys/types.h>
484 sys/types.h unistd.h,
485 [], [], [$curl_includes_unistd])
489 dnl CURL_INCLUDES_WINSOCK2
490 dnl -------------------------------------------------
491 dnl Set up variable with list of headers that must be
492 dnl included when winsock(2).h is to be included.
494 AC_DEFUN([CURL_INCLUDES_WINSOCK2], [
495 curl_includes_winsock2="\
497 #ifdef HAVE_WINDOWS_H
498 # ifndef WIN32_LEAN_AND_MEAN
499 # define WIN32_LEAN_AND_MEAN
501 # include <windows.h>
502 # ifdef HAVE_WINSOCK2_H
503 # include <winsock2.h>
505 # ifdef HAVE_WINSOCK_H
506 # include <winsock.h>
511 CURL_CHECK_HEADER_WINDOWS
512 CURL_CHECK_HEADER_WINSOCK
513 CURL_CHECK_HEADER_WINSOCK2
517 dnl CURL_INCLUDES_WS2TCPIP
518 dnl -------------------------------------------------
519 dnl Set up variable with list of headers that must be
520 dnl included when ws2tcpip.h is to be included.
522 AC_DEFUN([CURL_INCLUDES_WS2TCPIP], [
523 curl_includes_ws2tcpip="\
525 #ifdef HAVE_WINDOWS_H
526 # ifndef WIN32_LEAN_AND_MEAN
527 # define WIN32_LEAN_AND_MEAN
529 # include <windows.h>
530 # ifdef HAVE_WINSOCK2_H
531 # include <winsock2.h>
532 # ifdef HAVE_WS2TCPIP_H
533 # include <ws2tcpip.h>
538 CURL_CHECK_HEADER_WINDOWS
539 CURL_CHECK_HEADER_WINSOCK2
540 CURL_CHECK_HEADER_WS2TCPIP
544 dnl CURL_PREPROCESS_CALLCONV
545 dnl -------------------------------------------------
546 dnl Set up variable with a preprocessor block which
547 dnl defines function calling convention.
549 AC_DEFUN([CURL_PREPROCESS_CALLCONV], [
550 curl_preprocess_callconv="\
551 /* preprocess start */
552 #ifdef HAVE_WINDOWS_H
553 # define FUNCALLCONV __stdcall
557 /* preprocess end */"
561 dnl CURL_CHECK_FUNC_ALARM
562 dnl -------------------------------------------------
563 dnl Verify if alarm is available, prototyped, and
564 dnl can be compiled. If all of these are true, and
565 dnl usage has not been previously disallowed with
566 dnl shell variable curl_disallow_alarm, then
567 dnl HAVE_ALARM will be defined.
569 AC_DEFUN([CURL_CHECK_FUNC_ALARM], [
570 AC_REQUIRE([CURL_INCLUDES_UNISTD])dnl
572 tst_links_alarm="unknown"
573 tst_proto_alarm="unknown"
574 tst_compi_alarm="unknown"
575 tst_allow_alarm="unknown"
577 AC_MSG_CHECKING([if alarm can be linked])
579 AC_LANG_FUNC_LINK_TRY([alarm])
582 tst_links_alarm="yes"
588 if test "$tst_links_alarm" = "yes"; then
589 AC_MSG_CHECKING([if alarm is prototyped])
590 AC_EGREP_CPP([alarm],[
591 $curl_includes_unistd
594 tst_proto_alarm="yes"
601 if test "$tst_proto_alarm" = "yes"; then
602 AC_MSG_CHECKING([if alarm is compilable])
605 $curl_includes_unistd
612 tst_compi_alarm="yes"
619 if test "$tst_compi_alarm" = "yes"; then
620 AC_MSG_CHECKING([if alarm usage allowed])
621 if test "x$curl_disallow_alarm" != "xyes"; then
623 tst_allow_alarm="yes"
630 AC_MSG_CHECKING([if alarm might be used])
631 if test "$tst_links_alarm" = "yes" &&
632 test "$tst_proto_alarm" = "yes" &&
633 test "$tst_compi_alarm" = "yes" &&
634 test "$tst_allow_alarm" = "yes"; then
636 AC_DEFINE_UNQUOTED(HAVE_ALARM, 1,
637 [Define to 1 if you have the alarm function.])
638 ac_cv_func_alarm="yes"
641 ac_cv_func_alarm="no"
646 dnl CURL_CHECK_FUNC_BASENAME
647 dnl -------------------------------------------------
648 dnl Verify if basename is available, prototyped, and
649 dnl can be compiled. If all of these are true, and
650 dnl usage has not been previously disallowed with
651 dnl shell variable curl_disallow_basename, then
652 dnl HAVE_BASENAME will be defined.
654 AC_DEFUN([CURL_CHECK_FUNC_BASENAME], [
655 AC_REQUIRE([CURL_INCLUDES_STRING])dnl
656 AC_REQUIRE([CURL_INCLUDES_LIBGEN])dnl
657 AC_REQUIRE([CURL_INCLUDES_UNISTD])dnl
659 tst_links_basename="unknown"
660 tst_proto_basename="unknown"
661 tst_compi_basename="unknown"
662 tst_allow_basename="unknown"
664 AC_MSG_CHECKING([if basename can be linked])
666 AC_LANG_FUNC_LINK_TRY([basename])
669 tst_links_basename="yes"
672 tst_links_basename="no"
675 if test "$tst_links_basename" = "yes"; then
676 AC_MSG_CHECKING([if basename is prototyped])
677 AC_EGREP_CPP([basename],[
678 $curl_includes_string
679 $curl_includes_libgen
680 $curl_includes_unistd
683 tst_proto_basename="yes"
686 tst_proto_basename="no"
690 if test "$tst_proto_basename" = "yes"; then
691 AC_MSG_CHECKING([if basename is compilable])
694 $curl_includes_string
695 $curl_includes_libgen
696 $curl_includes_unistd
703 tst_compi_basename="yes"
706 tst_compi_basename="no"
710 if test "$tst_compi_basename" = "yes"; then
711 AC_MSG_CHECKING([if basename usage allowed])
712 if test "x$curl_disallow_basename" != "xyes"; then
714 tst_allow_basename="yes"
717 tst_allow_basename="no"
721 AC_MSG_CHECKING([if basename might be used])
722 if test "$tst_links_basename" = "yes" &&
723 test "$tst_proto_basename" = "yes" &&
724 test "$tst_compi_basename" = "yes" &&
725 test "$tst_allow_basename" = "yes"; then
727 AC_DEFINE_UNQUOTED(HAVE_BASENAME, 1,
728 [Define to 1 if you have the basename function.])
729 ac_cv_func_basename="yes"
732 ac_cv_func_basename="no"
737 dnl CURL_CHECK_FUNC_CLOSESOCKET
738 dnl -------------------------------------------------
739 dnl Verify if closesocket is available, prototyped, and
740 dnl can be compiled. If all of these are true, and
741 dnl usage has not been previously disallowed with
742 dnl shell variable curl_disallow_closesocket, then
743 dnl HAVE_CLOSESOCKET will be defined.
745 AC_DEFUN([CURL_CHECK_FUNC_CLOSESOCKET], [
746 AC_REQUIRE([CURL_INCLUDES_WINSOCK2])dnl
747 AC_REQUIRE([CURL_INCLUDES_SOCKET])dnl
749 tst_links_closesocket="unknown"
750 tst_proto_closesocket="unknown"
751 tst_compi_closesocket="unknown"
752 tst_allow_closesocket="unknown"
754 AC_MSG_CHECKING([if closesocket can be linked])
757 $curl_includes_winsock2
758 $curl_includes_socket
760 if(0 != closesocket(0))
765 tst_links_closesocket="yes"
768 tst_links_closesocket="no"
771 if test "$tst_links_closesocket" = "yes"; then
772 AC_MSG_CHECKING([if closesocket is prototyped])
773 AC_EGREP_CPP([closesocket],[
774 $curl_includes_winsock2
775 $curl_includes_socket
778 tst_proto_closesocket="yes"
781 tst_proto_closesocket="no"
785 if test "$tst_proto_closesocket" = "yes"; then
786 AC_MSG_CHECKING([if closesocket is compilable])
789 $curl_includes_winsock2
790 $curl_includes_socket
792 if(0 != closesocket(0))
797 tst_compi_closesocket="yes"
800 tst_compi_closesocket="no"
804 if test "$tst_compi_closesocket" = "yes"; then
805 AC_MSG_CHECKING([if closesocket usage allowed])
806 if test "x$curl_disallow_closesocket" != "xyes"; then
808 tst_allow_closesocket="yes"
811 tst_allow_closesocket="no"
815 AC_MSG_CHECKING([if closesocket might be used])
816 if test "$tst_links_closesocket" = "yes" &&
817 test "$tst_proto_closesocket" = "yes" &&
818 test "$tst_compi_closesocket" = "yes" &&
819 test "$tst_allow_closesocket" = "yes"; then
821 AC_DEFINE_UNQUOTED(HAVE_CLOSESOCKET, 1,
822 [Define to 1 if you have the closesocket function.])
823 ac_cv_func_closesocket="yes"
826 ac_cv_func_closesocket="no"
831 dnl CURL_CHECK_FUNC_CLOSESOCKET_CAMEL
832 dnl -------------------------------------------------
833 dnl Verify if CloseSocket is available, prototyped, and
834 dnl can be compiled. If all of these are true, and
835 dnl usage has not been previously disallowed with
836 dnl shell variable curl_disallow_closesocket_camel,
837 dnl then HAVE_CLOSESOCKET_CAMEL will be defined.
839 AC_DEFUN([CURL_CHECK_FUNC_CLOSESOCKET_CAMEL], [
840 AC_REQUIRE([CURL_INCLUDES_SYS_SOCKET])dnl
842 tst_links_closesocket_camel="unknown"
843 tst_proto_closesocket_camel="unknown"
844 tst_compi_closesocket_camel="unknown"
845 tst_allow_closesocket_camel="unknown"
847 AC_MSG_CHECKING([if CloseSocket can be linked])
850 $curl_includes_sys_socket
852 if(0 != CloseSocket(0))
857 tst_links_closesocket_camel="yes"
860 tst_links_closesocket_camel="no"
863 if test "$tst_links_closesocket_camel" = "yes"; then
864 AC_MSG_CHECKING([if CloseSocket is prototyped])
865 AC_EGREP_CPP([CloseSocket],[
866 $curl_includes_sys_socket
869 tst_proto_closesocket_camel="yes"
872 tst_proto_closesocket_camel="no"
876 if test "$tst_proto_closesocket_camel" = "yes"; then
877 AC_MSG_CHECKING([if CloseSocket is compilable])
880 $curl_includes_sys_socket
882 if(0 != CloseSocket(0))
887 tst_compi_closesocket_camel="yes"
890 tst_compi_closesocket_camel="no"
894 if test "$tst_compi_closesocket_camel" = "yes"; then
895 AC_MSG_CHECKING([if CloseSocket usage allowed])
896 if test "x$curl_disallow_closesocket_camel" != "xyes"; then
898 tst_allow_closesocket_camel="yes"
901 tst_allow_closesocket_camel="no"
905 AC_MSG_CHECKING([if CloseSocket might be used])
906 if test "$tst_links_closesocket_camel" = "yes" &&
907 test "$tst_proto_closesocket_camel" = "yes" &&
908 test "$tst_compi_closesocket_camel" = "yes" &&
909 test "$tst_allow_closesocket_camel" = "yes"; then
911 AC_DEFINE_UNQUOTED(HAVE_CLOSESOCKET_CAMEL, 1,
912 [Define to 1 if you have the CloseSocket camel case function.])
913 ac_cv_func_closesocket_camel="yes"
916 ac_cv_func_closesocket_camel="no"
921 dnl CURL_CHECK_FUNC_CONNECT
922 dnl -------------------------------------------------
923 dnl Verify if connect is available, prototyped, and
924 dnl can be compiled. If all of these are true, and
925 dnl usage has not been previously disallowed with
926 dnl shell variable curl_disallow_connect, then
927 dnl HAVE_CONNECT will be defined.
929 AC_DEFUN([CURL_CHECK_FUNC_CONNECT], [
930 AC_REQUIRE([CURL_INCLUDES_WINSOCK2])dnl
931 AC_REQUIRE([CURL_INCLUDES_SYS_SOCKET])dnl
932 AC_REQUIRE([CURL_INCLUDES_SOCKET])dnl
934 tst_links_connect="unknown"
935 tst_proto_connect="unknown"
936 tst_compi_connect="unknown"
937 tst_allow_connect="unknown"
939 AC_MSG_CHECKING([if connect can be linked])
942 $curl_includes_winsock2
943 $curl_includes_sys_socket
944 $curl_includes_socket
946 if(0 != connect(0, 0, 0))
951 tst_links_connect="yes"
954 tst_links_connect="no"
957 if test "$tst_links_connect" = "yes"; then
958 AC_MSG_CHECKING([if connect is prototyped])
959 AC_EGREP_CPP([connect],[
960 $curl_includes_winsock2
961 $curl_includes_sys_socket
962 $curl_includes_socket
965 tst_proto_connect="yes"
968 tst_proto_connect="no"
972 if test "$tst_proto_connect" = "yes"; then
973 AC_MSG_CHECKING([if connect is compilable])
976 $curl_includes_winsock2
977 $curl_includes_sys_socket
978 $curl_includes_socket
980 if(0 != connect(0, 0, 0))
985 tst_compi_connect="yes"
988 tst_compi_connect="no"
992 if test "$tst_compi_connect" = "yes"; then
993 AC_MSG_CHECKING([if connect usage allowed])
994 if test "x$curl_disallow_connect" != "xyes"; then
996 tst_allow_connect="yes"
999 tst_allow_connect="no"
1003 AC_MSG_CHECKING([if connect might be used])
1004 if test "$tst_links_connect" = "yes" &&
1005 test "$tst_proto_connect" = "yes" &&
1006 test "$tst_compi_connect" = "yes" &&
1007 test "$tst_allow_connect" = "yes"; then
1008 AC_MSG_RESULT([yes])
1009 AC_DEFINE_UNQUOTED(HAVE_CONNECT, 1,
1010 [Define to 1 if you have the connect function.])
1011 ac_cv_func_connect="yes"
1014 ac_cv_func_connect="no"
1019 dnl CURL_CHECK_FUNC_FCNTL
1020 dnl -------------------------------------------------
1021 dnl Verify if fcntl is available, prototyped, and
1022 dnl can be compiled. If all of these are true, and
1023 dnl usage has not been previously disallowed with
1024 dnl shell variable curl_disallow_fcntl, then
1025 dnl HAVE_FCNTL will be defined.
1027 AC_DEFUN([CURL_CHECK_FUNC_FCNTL], [
1028 AC_REQUIRE([CURL_INCLUDES_FCNTL])dnl
1030 tst_links_fcntl="unknown"
1031 tst_proto_fcntl="unknown"
1032 tst_compi_fcntl="unknown"
1033 tst_allow_fcntl="unknown"
1035 AC_MSG_CHECKING([if fcntl can be linked])
1037 AC_LANG_FUNC_LINK_TRY([fcntl])
1039 AC_MSG_RESULT([yes])
1040 tst_links_fcntl="yes"
1043 tst_links_fcntl="no"
1046 if test "$tst_links_fcntl" = "yes"; then
1047 AC_MSG_CHECKING([if fcntl is prototyped])
1048 AC_EGREP_CPP([fcntl],[
1049 $curl_includes_fcntl
1051 AC_MSG_RESULT([yes])
1052 tst_proto_fcntl="yes"
1055 tst_proto_fcntl="no"
1059 if test "$tst_proto_fcntl" = "yes"; then
1060 AC_MSG_CHECKING([if fcntl is compilable])
1063 $curl_includes_fcntl
1065 if(0 != fcntl(0, 0, 0))
1069 AC_MSG_RESULT([yes])
1070 tst_compi_fcntl="yes"
1073 tst_compi_fcntl="no"
1077 if test "$tst_compi_fcntl" = "yes"; then
1078 AC_MSG_CHECKING([if fcntl usage allowed])
1079 if test "x$curl_disallow_fcntl" != "xyes"; then
1080 AC_MSG_RESULT([yes])
1081 tst_allow_fcntl="yes"
1084 tst_allow_fcntl="no"
1088 AC_MSG_CHECKING([if fcntl might be used])
1089 if test "$tst_links_fcntl" = "yes" &&
1090 test "$tst_proto_fcntl" = "yes" &&
1091 test "$tst_compi_fcntl" = "yes" &&
1092 test "$tst_allow_fcntl" = "yes"; then
1093 AC_MSG_RESULT([yes])
1094 AC_DEFINE_UNQUOTED(HAVE_FCNTL, 1,
1095 [Define to 1 if you have the fcntl function.])
1096 ac_cv_func_fcntl="yes"
1097 CURL_CHECK_FUNC_FCNTL_O_NONBLOCK
1100 ac_cv_func_fcntl="no"
1105 dnl CURL_CHECK_FUNC_FCNTL_O_NONBLOCK
1106 dnl -------------------------------------------------
1107 dnl Verify if fcntl with status flag O_NONBLOCK is
1108 dnl available, can be compiled, and seems to work. If
1109 dnl all of these are true, then HAVE_FCNTL_O_NONBLOCK
1110 dnl will be defined.
1112 AC_DEFUN([CURL_CHECK_FUNC_FCNTL_O_NONBLOCK], [
1114 tst_compi_fcntl_o_nonblock="unknown"
1115 tst_allow_fcntl_o_nonblock="unknown"
1118 sunos4* | aix3* | beos*)
1119 dnl O_NONBLOCK does not work on these platforms
1120 curl_disallow_fcntl_o_nonblock="yes"
1124 if test "$ac_cv_func_fcntl" = "yes"; then
1125 AC_MSG_CHECKING([if fcntl O_NONBLOCK is compilable])
1128 $curl_includes_fcntl
1131 if(0 != fcntl(0, F_SETFL, flags | O_NONBLOCK))
1135 AC_MSG_RESULT([yes])
1136 tst_compi_fcntl_o_nonblock="yes"
1139 tst_compi_fcntl_o_nonblock="no"
1143 if test "$tst_compi_fcntl_o_nonblock" = "yes"; then
1144 AC_MSG_CHECKING([if fcntl O_NONBLOCK usage allowed])
1145 if test "x$curl_disallow_fcntl_o_nonblock" != "xyes"; then
1146 AC_MSG_RESULT([yes])
1147 tst_allow_fcntl_o_nonblock="yes"
1150 tst_allow_fcntl_o_nonblock="no"
1154 AC_MSG_CHECKING([if fcntl O_NONBLOCK might be used])
1155 if test "$tst_compi_fcntl_o_nonblock" = "yes" &&
1156 test "$tst_allow_fcntl_o_nonblock" = "yes"; then
1157 AC_MSG_RESULT([yes])
1158 AC_DEFINE_UNQUOTED(HAVE_FCNTL_O_NONBLOCK, 1,
1159 [Define to 1 if you have a working fcntl O_NONBLOCK function.])
1160 ac_cv_func_fcntl_o_nonblock="yes"
1163 ac_cv_func_fcntl_o_nonblock="no"
1168 dnl CURL_CHECK_FUNC_FDOPEN
1169 dnl -------------------------------------------------
1170 dnl Verify if fdopen is available, prototyped, and
1171 dnl can be compiled. If all of these are true, and
1172 dnl usage has not been previously disallowed with
1173 dnl shell variable curl_disallow_fdopen, then
1174 dnl HAVE_FDOPEN will be defined.
1176 AC_DEFUN([CURL_CHECK_FUNC_FDOPEN], [
1177 AC_REQUIRE([CURL_INCLUDES_STDIO])dnl
1179 tst_links_fdopen="unknown"
1180 tst_proto_fdopen="unknown"
1181 tst_compi_fdopen="unknown"
1182 tst_allow_fdopen="unknown"
1184 AC_MSG_CHECKING([if fdopen can be linked])
1186 AC_LANG_FUNC_LINK_TRY([fdopen])
1188 AC_MSG_RESULT([yes])
1189 tst_links_fdopen="yes"
1192 tst_links_fdopen="no"
1195 if test "$tst_links_fdopen" = "yes"; then
1196 AC_MSG_CHECKING([if fdopen is prototyped])
1197 AC_EGREP_CPP([fdopen],[
1198 $curl_includes_stdio
1200 AC_MSG_RESULT([yes])
1201 tst_proto_fdopen="yes"
1204 tst_proto_fdopen="no"
1208 if test "$tst_proto_fdopen" = "yes"; then
1209 AC_MSG_CHECKING([if fdopen is compilable])
1212 $curl_includes_stdio
1214 if(0 != fdopen(0, 0))
1218 AC_MSG_RESULT([yes])
1219 tst_compi_fdopen="yes"
1222 tst_compi_fdopen="no"
1226 if test "$tst_compi_fdopen" = "yes"; then
1227 AC_MSG_CHECKING([if fdopen usage allowed])
1228 if test "x$curl_disallow_fdopen" != "xyes"; then
1229 AC_MSG_RESULT([yes])
1230 tst_allow_fdopen="yes"
1233 tst_allow_fdopen="no"
1237 AC_MSG_CHECKING([if fdopen might be used])
1238 if test "$tst_links_fdopen" = "yes" &&
1239 test "$tst_proto_fdopen" = "yes" &&
1240 test "$tst_compi_fdopen" = "yes" &&
1241 test "$tst_allow_fdopen" = "yes"; then
1242 AC_MSG_RESULT([yes])
1243 AC_DEFINE_UNQUOTED(HAVE_FDOPEN, 1,
1244 [Define to 1 if you have the fdopen function.])
1245 ac_cv_func_fdopen="yes"
1248 ac_cv_func_fdopen="no"
1253 dnl CURL_CHECK_FUNC_FGETXATTR
1254 dnl -------------------------------------------------
1255 dnl Verify if fgetxattr is available, prototyped, and
1256 dnl can be compiled. If all of these are true, and
1257 dnl usage has not been previously disallowed with
1258 dnl shell variable curl_disallow_fgetxattr, then
1259 dnl HAVE_FGETXATTR will be defined.
1261 AC_DEFUN([CURL_CHECK_FUNC_FGETXATTR], [
1262 AC_REQUIRE([CURL_INCLUDES_SYS_XATTR])dnl
1264 tst_links_fgetxattr="unknown"
1265 tst_proto_fgetxattr="unknown"
1266 tst_compi_fgetxattr="unknown"
1267 tst_allow_fgetxattr="unknown"
1268 tst_nargs_fgetxattr="unknown"
1270 AC_MSG_CHECKING([if fgetxattr can be linked])
1272 AC_LANG_FUNC_LINK_TRY([fgetxattr])
1274 AC_MSG_RESULT([yes])
1275 tst_links_fgetxattr="yes"
1278 tst_links_fgetxattr="no"
1281 if test "$tst_links_fgetxattr" = "yes"; then
1282 AC_MSG_CHECKING([if fgetxattr is prototyped])
1283 AC_EGREP_CPP([fgetxattr],[
1284 $curl_includes_sys_xattr
1286 AC_MSG_RESULT([yes])
1287 tst_proto_fgetxattr="yes"
1290 tst_proto_fgetxattr="no"
1294 if test "$tst_proto_fgetxattr" = "yes"; then
1295 if test "$tst_nargs_fgetxattr" = "unknown"; then
1296 AC_MSG_CHECKING([if fgetxattr takes 4 args.])
1299 $curl_includes_sys_xattr
1301 if(0 != fgetxattr(0, 0, 0, 0))
1305 AC_MSG_RESULT([yes])
1306 tst_compi_fgetxattr="yes"
1307 tst_nargs_fgetxattr="4"
1310 tst_compi_fgetxattr="no"
1313 if test "$tst_nargs_fgetxattr" = "unknown"; then
1314 AC_MSG_CHECKING([if fgetxattr takes 6 args.])
1317 $curl_includes_sys_xattr
1319 if(0 != fgetxattr(0, 0, 0, 0, 0, 0))
1323 AC_MSG_RESULT([yes])
1324 tst_compi_fgetxattr="yes"
1325 tst_nargs_fgetxattr="6"
1328 tst_compi_fgetxattr="no"
1331 AC_MSG_CHECKING([if fgetxattr is compilable])
1332 if test "$tst_compi_fgetxattr" = "yes"; then
1333 AC_MSG_RESULT([yes])
1339 if test "$tst_compi_fgetxattr" = "yes"; then
1340 AC_MSG_CHECKING([if fgetxattr usage allowed])
1341 if test "x$curl_disallow_fgetxattr" != "xyes"; then
1342 AC_MSG_RESULT([yes])
1343 tst_allow_fgetxattr="yes"
1346 tst_allow_fgetxattr="no"
1350 AC_MSG_CHECKING([if fgetxattr might be used])
1351 if test "$tst_links_fgetxattr" = "yes" &&
1352 test "$tst_proto_fgetxattr" = "yes" &&
1353 test "$tst_compi_fgetxattr" = "yes" &&
1354 test "$tst_allow_fgetxattr" = "yes"; then
1355 AC_MSG_RESULT([yes])
1356 AC_DEFINE_UNQUOTED(HAVE_FGETXATTR, 1,
1357 [Define to 1 if you have the fgetxattr function.])
1358 dnl AC_DEFINE_UNQUOTED(FGETXATTR_ARGS, $tst_nargs_fgetxattr,
1359 dnl [Specifies the number of arguments to fgetxattr])
1361 if test "$tst_nargs_fgetxattr" -eq "4"; then
1362 AC_DEFINE(HAVE_FGETXATTR_4, 1, [fgetxattr() takes 4 args])
1363 elif test "$tst_nargs_fgetxattr" -eq "6"; then
1364 AC_DEFINE(HAVE_FGETXATTR_6, 1, [fgetxattr() takes 6 args])
1367 ac_cv_func_fgetxattr="yes"
1370 ac_cv_func_fgetxattr="no"
1375 dnl CURL_CHECK_FUNC_FLISTXATTR
1376 dnl -------------------------------------------------
1377 dnl Verify if flistxattr is available, prototyped, and
1378 dnl can be compiled. If all of these are true, and
1379 dnl usage has not been previously disallowed with
1380 dnl shell variable curl_disallow_flistxattr, then
1381 dnl HAVE_FLISTXATTR will be defined.
1383 AC_DEFUN([CURL_CHECK_FUNC_FLISTXATTR], [
1384 AC_REQUIRE([CURL_INCLUDES_SYS_XATTR])dnl
1386 tst_links_flistxattr="unknown"
1387 tst_proto_flistxattr="unknown"
1388 tst_compi_flistxattr="unknown"
1389 tst_allow_flistxattr="unknown"
1390 tst_nargs_flistxattr="unknown"
1392 AC_MSG_CHECKING([if flistxattr can be linked])
1394 AC_LANG_FUNC_LINK_TRY([flistxattr])
1396 AC_MSG_RESULT([yes])
1397 tst_links_flistxattr="yes"
1400 tst_links_flistxattr="no"
1403 if test "$tst_links_flistxattr" = "yes"; then
1404 AC_MSG_CHECKING([if flistxattr is prototyped])
1405 AC_EGREP_CPP([flistxattr],[
1406 $curl_includes_sys_xattr
1408 AC_MSG_RESULT([yes])
1409 tst_proto_flistxattr="yes"
1412 tst_proto_flistxattr="no"
1416 if test "$tst_proto_flistxattr" = "yes"; then
1417 if test "$tst_nargs_flistxattr" = "unknown"; then
1418 AC_MSG_CHECKING([if flistxattr takes 3 args.])
1421 $curl_includes_sys_xattr
1423 if(0 != flistxattr(0, 0, 0))
1427 AC_MSG_RESULT([yes])
1428 tst_compi_flistxattr="yes"
1429 tst_nargs_flistxattr="3"
1432 tst_compi_flistxattr="no"
1435 if test "$tst_nargs_flistxattr" = "unknown"; then
1436 AC_MSG_CHECKING([if flistxattr takes 4 args.])
1439 $curl_includes_sys_xattr
1441 if(0 != flistxattr(0, 0, 0, 0))
1445 AC_MSG_RESULT([yes])
1446 tst_compi_flistxattr="yes"
1447 tst_nargs_flistxattr="4"
1450 tst_compi_flistxattr="no"
1453 AC_MSG_CHECKING([if flistxattr is compilable])
1454 if test "$tst_compi_flistxattr" = "yes"; then
1455 AC_MSG_RESULT([yes])
1461 if test "$tst_compi_flistxattr" = "yes"; then
1462 AC_MSG_CHECKING([if flistxattr usage allowed])
1463 if test "x$curl_disallow_flistxattr" != "xyes"; then
1464 AC_MSG_RESULT([yes])
1465 tst_allow_flistxattr="yes"
1468 tst_allow_flistxattr="no"
1472 AC_MSG_CHECKING([if flistxattr might be used])
1473 if test "$tst_links_flistxattr" = "yes" &&
1474 test "$tst_proto_flistxattr" = "yes" &&
1475 test "$tst_compi_flistxattr" = "yes" &&
1476 test "$tst_allow_flistxattr" = "yes"; then
1477 AC_MSG_RESULT([yes])
1478 AC_DEFINE_UNQUOTED(HAVE_FLISTXATTR, 1,
1479 [Define to 1 if you have the flistxattr function.])
1480 dnl AC_DEFINE_UNQUOTED(FLISTXATTR_ARGS, $tst_nargs_flistxattr,
1481 dnl [Specifies the number of arguments to flistxattr])
1483 if test "$tst_nargs_flistxattr" -eq "3"; then
1484 AC_DEFINE(HAVE_FLISTXATTR_3, 1, [flistxattr() takes 3 args])
1485 elif test "$tst_nargs_flistxattr" -eq "4"; then
1486 AC_DEFINE(HAVE_FLISTXATTR_4, 1, [flistxattr() takes 4 args])
1489 ac_cv_func_flistxattr="yes"
1492 ac_cv_func_flistxattr="no"
1497 dnl CURL_CHECK_FUNC_FREEADDRINFO
1498 dnl -------------------------------------------------
1499 dnl Verify if freeaddrinfo is available, prototyped,
1500 dnl and can be compiled. If all of these are true,
1501 dnl and usage has not been previously disallowed with
1502 dnl shell variable curl_disallow_freeaddrinfo, then
1503 dnl HAVE_FREEADDRINFO will be defined.
1505 AC_DEFUN([CURL_CHECK_FUNC_FREEADDRINFO], [
1506 AC_REQUIRE([CURL_INCLUDES_WS2TCPIP])dnl
1507 AC_REQUIRE([CURL_INCLUDES_SYS_SOCKET])dnl
1508 AC_REQUIRE([CURL_INCLUDES_NETDB])dnl
1510 tst_links_freeaddrinfo="unknown"
1511 tst_proto_freeaddrinfo="unknown"
1512 tst_compi_freeaddrinfo="unknown"
1513 tst_allow_freeaddrinfo="unknown"
1515 AC_MSG_CHECKING([if freeaddrinfo can be linked])
1518 $curl_includes_ws2tcpip
1519 $curl_includes_sys_socket
1520 $curl_includes_netdb
1525 AC_MSG_RESULT([yes])
1526 tst_links_freeaddrinfo="yes"
1529 tst_links_freeaddrinfo="no"
1532 if test "$tst_links_freeaddrinfo" = "yes"; then
1533 AC_MSG_CHECKING([if freeaddrinfo is prototyped])
1534 AC_EGREP_CPP([freeaddrinfo],[
1535 $curl_includes_ws2tcpip
1536 $curl_includes_sys_socket
1537 $curl_includes_netdb
1539 AC_MSG_RESULT([yes])
1540 tst_proto_freeaddrinfo="yes"
1543 tst_proto_freeaddrinfo="no"
1547 if test "$tst_proto_freeaddrinfo" = "yes"; then
1548 AC_MSG_CHECKING([if freeaddrinfo is compilable])
1551 $curl_includes_ws2tcpip
1552 $curl_includes_sys_socket
1553 $curl_includes_netdb
1558 AC_MSG_RESULT([yes])
1559 tst_compi_freeaddrinfo="yes"
1562 tst_compi_freeaddrinfo="no"
1566 if test "$tst_compi_freeaddrinfo" = "yes"; then
1567 AC_MSG_CHECKING([if freeaddrinfo usage allowed])
1568 if test "x$curl_disallow_freeaddrinfo" != "xyes"; then
1569 AC_MSG_RESULT([yes])
1570 tst_allow_freeaddrinfo="yes"
1573 tst_allow_freeaddrinfo="no"
1577 AC_MSG_CHECKING([if freeaddrinfo might be used])
1578 if test "$tst_links_freeaddrinfo" = "yes" &&
1579 test "$tst_proto_freeaddrinfo" = "yes" &&
1580 test "$tst_compi_freeaddrinfo" = "yes" &&
1581 test "$tst_allow_freeaddrinfo" = "yes"; then
1582 AC_MSG_RESULT([yes])
1583 AC_DEFINE_UNQUOTED(HAVE_FREEADDRINFO, 1,
1584 [Define to 1 if you have the freeaddrinfo function.])
1585 ac_cv_func_freeaddrinfo="yes"
1588 ac_cv_func_freeaddrinfo="no"
1593 dnl CURL_CHECK_FUNC_FREEIFADDRS
1594 dnl -------------------------------------------------
1595 dnl Verify if freeifaddrs is available, prototyped, and
1596 dnl can be compiled. If all of these are true, and
1597 dnl usage has not been previously disallowed with
1598 dnl shell variable curl_disallow_freeifaddrs, then
1599 dnl HAVE_FREEIFADDRS will be defined.
1601 AC_DEFUN([CURL_CHECK_FUNC_FREEIFADDRS], [
1602 AC_REQUIRE([CURL_INCLUDES_IFADDRS])dnl
1604 tst_links_freeifaddrs="unknown"
1605 tst_proto_freeifaddrs="unknown"
1606 tst_compi_freeifaddrs="unknown"
1607 tst_allow_freeifaddrs="unknown"
1609 AC_MSG_CHECKING([if freeifaddrs can be linked])
1611 AC_LANG_FUNC_LINK_TRY([freeifaddrs])
1613 AC_MSG_RESULT([yes])
1614 tst_links_freeifaddrs="yes"
1617 tst_links_freeifaddrs="no"
1620 if test "$tst_links_freeifaddrs" = "yes"; then
1621 AC_MSG_CHECKING([if freeifaddrs is prototyped])
1622 AC_EGREP_CPP([freeifaddrs],[
1623 $curl_includes_ifaddrs
1625 AC_MSG_RESULT([yes])
1626 tst_proto_freeifaddrs="yes"
1629 tst_proto_freeifaddrs="no"
1633 if test "$tst_proto_freeifaddrs" = "yes"; then
1634 AC_MSG_CHECKING([if freeifaddrs is compilable])
1637 $curl_includes_ifaddrs
1642 AC_MSG_RESULT([yes])
1643 tst_compi_freeifaddrs="yes"
1646 tst_compi_freeifaddrs="no"
1650 if test "$tst_compi_freeifaddrs" = "yes"; then
1651 AC_MSG_CHECKING([if freeifaddrs usage allowed])
1652 if test "x$curl_disallow_freeifaddrs" != "xyes"; then
1653 AC_MSG_RESULT([yes])
1654 tst_allow_freeifaddrs="yes"
1657 tst_allow_freeifaddrs="no"
1661 AC_MSG_CHECKING([if freeifaddrs might be used])
1662 if test "$tst_links_freeifaddrs" = "yes" &&
1663 test "$tst_proto_freeifaddrs" = "yes" &&
1664 test "$tst_compi_freeifaddrs" = "yes" &&
1665 test "$tst_allow_freeifaddrs" = "yes"; then
1666 AC_MSG_RESULT([yes])
1667 AC_DEFINE_UNQUOTED(HAVE_FREEIFADDRS, 1,
1668 [Define to 1 if you have the freeifaddrs function.])
1669 ac_cv_func_freeifaddrs="yes"
1672 ac_cv_func_freeifaddrs="no"
1677 dnl CURL_CHECK_FUNC_FREMOVEXATTR
1678 dnl -------------------------------------------------
1679 dnl Verify if fremovexattr is available, prototyped, and
1680 dnl can be compiled. If all of these are true, and
1681 dnl usage has not been previously disallowed with
1682 dnl shell variable curl_disallow_fremovexattr, then
1683 dnl HAVE_FREMOVEXATTR will be defined.
1685 AC_DEFUN([CURL_CHECK_FUNC_FREMOVEXATTR], [
1686 AC_REQUIRE([CURL_INCLUDES_SYS_XATTR])dnl
1688 tst_links_fremovexattr="unknown"
1689 tst_proto_fremovexattr="unknown"
1690 tst_compi_fremovexattr="unknown"
1691 tst_allow_fremovexattr="unknown"
1692 tst_nargs_fremovexattr="unknown"
1694 AC_MSG_CHECKING([if fremovexattr can be linked])
1696 AC_LANG_FUNC_LINK_TRY([fremovexattr])
1698 AC_MSG_RESULT([yes])
1699 tst_links_fremovexattr="yes"
1702 tst_links_fremovexattr="no"
1705 if test "$tst_links_fremovexattr" = "yes"; then
1706 AC_MSG_CHECKING([if fremovexattr is prototyped])
1707 AC_EGREP_CPP([fremovexattr],[
1708 $curl_includes_sys_xattr
1710 AC_MSG_RESULT([yes])
1711 tst_proto_fremovexattr="yes"
1714 tst_proto_fremovexattr="no"
1718 if test "$tst_proto_fremovexattr" = "yes"; then
1719 if test "$tst_nargs_fremovexattr" = "unknown"; then
1720 AC_MSG_CHECKING([if fremovexattr takes 2 args.])
1723 $curl_includes_sys_xattr
1725 if(0 != fremovexattr(0, 0))
1729 AC_MSG_RESULT([yes])
1730 tst_compi_fremovexattr="yes"
1731 tst_nargs_fremovexattr="2"
1734 tst_compi_fremovexattr="no"
1737 if test "$tst_nargs_fremovexattr" = "unknown"; then
1738 AC_MSG_CHECKING([if fremovexattr takes 3 args.])
1741 $curl_includes_sys_xattr
1743 if(0 != fremovexattr(0, 0, 0))
1747 AC_MSG_RESULT([yes])
1748 tst_compi_fremovexattr="yes"
1749 tst_nargs_fremovexattr="3"
1752 tst_compi_fremovexattr="no"
1755 AC_MSG_CHECKING([if fremovexattr is compilable])
1756 if test "$tst_compi_fremovexattr" = "yes"; then
1757 AC_MSG_RESULT([yes])
1763 if test "$tst_compi_fremovexattr" = "yes"; then
1764 AC_MSG_CHECKING([if fremovexattr usage allowed])
1765 if test "x$curl_disallow_fremovexattr" != "xyes"; then
1766 AC_MSG_RESULT([yes])
1767 tst_allow_fremovexattr="yes"
1770 tst_allow_fremovexattr="no"
1774 AC_MSG_CHECKING([if fremovexattr might be used])
1775 if test "$tst_links_fremovexattr" = "yes" &&
1776 test "$tst_proto_fremovexattr" = "yes" &&
1777 test "$tst_compi_fremovexattr" = "yes" &&
1778 test "$tst_allow_fremovexattr" = "yes"; then
1779 AC_MSG_RESULT([yes])
1780 AC_DEFINE_UNQUOTED(HAVE_FREMOVEXATTR, 1,
1781 [Define to 1 if you have the fremovexattr function.])
1782 dnl AC_DEFINE_UNQUOTED(FREMOVEXATTR_ARGS, $tst_nargs_fremovexattr,
1783 dnl [Specifies the number of arguments to fremovexattr])
1785 if test "$tst_nargs_fremovexattr" -eq "2"; then
1786 AC_DEFINE(HAVE_FREMOVEXATTR_2, 1, [fremovexattr() takes 2 args])
1787 elif test "$tst_nargs_fremovexattr" -eq "3"; then
1788 AC_DEFINE(HAVE_FREMOVEXATTR_3, 1, [fremovexattr() takes 3 args])
1791 ac_cv_func_fremovexattr="yes"
1794 ac_cv_func_fremovexattr="no"
1799 dnl CURL_CHECK_FUNC_FSETXATTR
1800 dnl -------------------------------------------------
1801 dnl Verify if fsetxattr is available, prototyped, and
1802 dnl can be compiled. If all of these are true, and
1803 dnl usage has not been previously disallowed with
1804 dnl shell variable curl_disallow_fsetxattr, then
1805 dnl HAVE_FSETXATTR will be defined.
1807 AC_DEFUN([CURL_CHECK_FUNC_FSETXATTR], [
1808 AC_REQUIRE([CURL_INCLUDES_SYS_XATTR])dnl
1810 tst_links_fsetxattr="unknown"
1811 tst_proto_fsetxattr="unknown"
1812 tst_compi_fsetxattr="unknown"
1813 tst_allow_fsetxattr="unknown"
1814 tst_nargs_fsetxattr="unknown"
1816 AC_MSG_CHECKING([if fsetxattr can be linked])
1818 AC_LANG_FUNC_LINK_TRY([fsetxattr])
1820 AC_MSG_RESULT([yes])
1821 tst_links_fsetxattr="yes"
1824 tst_links_fsetxattr="no"
1827 if test "$tst_links_fsetxattr" = "yes"; then
1828 AC_MSG_CHECKING([if fsetxattr is prototyped])
1829 AC_EGREP_CPP([fsetxattr],[
1830 $curl_includes_sys_xattr
1832 AC_MSG_RESULT([yes])
1833 tst_proto_fsetxattr="yes"
1836 tst_proto_fsetxattr="no"
1840 if test "$tst_proto_fsetxattr" = "yes"; then
1841 if test "$tst_nargs_fsetxattr" = "unknown"; then
1842 AC_MSG_CHECKING([if fsetxattr takes 5 args.])
1845 $curl_includes_sys_xattr
1847 if(0 != fsetxattr(0, 0, 0, 0, 0))
1851 AC_MSG_RESULT([yes])
1852 tst_compi_fsetxattr="yes"
1853 tst_nargs_fsetxattr="5"
1856 tst_compi_fsetxattr="no"
1859 if test "$tst_nargs_fsetxattr" = "unknown"; then
1860 AC_MSG_CHECKING([if fsetxattr takes 6 args.])
1863 $curl_includes_sys_xattr
1865 if(0 != fsetxattr(0, 0, 0, 0, 0, 0))
1869 AC_MSG_RESULT([yes])
1870 tst_compi_fsetxattr="yes"
1871 tst_nargs_fsetxattr="6"
1874 tst_compi_fsetxattr="no"
1877 AC_MSG_CHECKING([if fsetxattr is compilable])
1878 if test "$tst_compi_fsetxattr" = "yes"; then
1879 AC_MSG_RESULT([yes])
1885 if test "$tst_compi_fsetxattr" = "yes"; then
1886 AC_MSG_CHECKING([if fsetxattr usage allowed])
1887 if test "x$curl_disallow_fsetxattr" != "xyes"; then
1888 AC_MSG_RESULT([yes])
1889 tst_allow_fsetxattr="yes"
1892 tst_allow_fsetxattr="no"
1896 AC_MSG_CHECKING([if fsetxattr might be used])
1897 if test "$tst_links_fsetxattr" = "yes" &&
1898 test "$tst_proto_fsetxattr" = "yes" &&
1899 test "$tst_compi_fsetxattr" = "yes" &&
1900 test "$tst_allow_fsetxattr" = "yes"; then
1901 AC_MSG_RESULT([yes])
1902 AC_DEFINE_UNQUOTED(HAVE_FSETXATTR, 1,
1903 [Define to 1 if you have the fsetxattr function.])
1904 dnl AC_DEFINE_UNQUOTED(FSETXATTR_ARGS, $tst_nargs_fsetxattr,
1905 dnl [Specifies the number of arguments to fsetxattr])
1907 if test "$tst_nargs_fsetxattr" -eq "5"; then
1908 AC_DEFINE(HAVE_FSETXATTR_5, 1, [fsetxattr() takes 5 args])
1909 elif test "$tst_nargs_fsetxattr" -eq "6"; then
1910 AC_DEFINE(HAVE_FSETXATTR_6, 1, [fsetxattr() takes 6 args])
1913 ac_cv_func_fsetxattr="yes"
1916 ac_cv_func_fsetxattr="no"
1921 dnl CURL_CHECK_FUNC_FTRUNCATE
1922 dnl -------------------------------------------------
1923 dnl Verify if ftruncate is available, prototyped, and
1924 dnl can be compiled. If all of these are true, and
1925 dnl usage has not been previously disallowed with
1926 dnl shell variable curl_disallow_ftruncate, then
1927 dnl HAVE_FTRUNCATE will be defined.
1929 AC_DEFUN([CURL_CHECK_FUNC_FTRUNCATE], [
1930 AC_REQUIRE([CURL_INCLUDES_UNISTD])dnl
1932 tst_links_ftruncate="unknown"
1933 tst_proto_ftruncate="unknown"
1934 tst_compi_ftruncate="unknown"
1935 tst_allow_ftruncate="unknown"
1937 AC_MSG_CHECKING([if ftruncate can be linked])
1939 AC_LANG_FUNC_LINK_TRY([ftruncate])
1941 AC_MSG_RESULT([yes])
1942 tst_links_ftruncate="yes"
1945 tst_links_ftruncate="no"
1948 if test "$tst_links_ftruncate" = "yes"; then
1949 AC_MSG_CHECKING([if ftruncate is prototyped])
1950 AC_EGREP_CPP([ftruncate],[
1951 $curl_includes_unistd
1953 AC_MSG_RESULT([yes])
1954 tst_proto_ftruncate="yes"
1957 tst_proto_ftruncate="no"
1961 if test "$tst_proto_ftruncate" = "yes"; then
1962 AC_MSG_CHECKING([if ftruncate is compilable])
1965 $curl_includes_unistd
1967 if(0 != ftruncate(0, 0))
1971 AC_MSG_RESULT([yes])
1972 tst_compi_ftruncate="yes"
1975 tst_compi_ftruncate="no"
1979 if test "$tst_compi_ftruncate" = "yes"; then
1980 AC_MSG_CHECKING([if ftruncate usage allowed])
1981 if test "x$curl_disallow_ftruncate" != "xyes"; then
1982 AC_MSG_RESULT([yes])
1983 tst_allow_ftruncate="yes"
1986 tst_allow_ftruncate="no"
1990 AC_MSG_CHECKING([if ftruncate might be used])
1991 if test "$tst_links_ftruncate" = "yes" &&
1992 test "$tst_proto_ftruncate" = "yes" &&
1993 test "$tst_compi_ftruncate" = "yes" &&
1994 test "$tst_allow_ftruncate" = "yes"; then
1995 AC_MSG_RESULT([yes])
1996 AC_DEFINE_UNQUOTED(HAVE_FTRUNCATE, 1,
1997 [Define to 1 if you have the ftruncate function.])
1998 ac_cv_func_ftruncate="yes"
2001 ac_cv_func_ftruncate="no"
2006 dnl CURL_CHECK_FUNC_GETADDRINFO
2007 dnl -------------------------------------------------
2008 dnl Verify if getaddrinfo is available, prototyped, can
2009 dnl be compiled and seems to work. If all of these are
2010 dnl true, and usage has not been previously disallowed
2011 dnl with shell variable curl_disallow_getaddrinfo, then
2012 dnl HAVE_GETADDRINFO will be defined. Additionally when
2013 dnl HAVE_GETADDRINFO gets defined this will also attempt
2014 dnl to find out if getaddrinfo happens to be threadsafe,
2015 dnl defining HAVE_GETADDRINFO_THREADSAFE when true.
2017 AC_DEFUN([CURL_CHECK_FUNC_GETADDRINFO], [
2018 AC_REQUIRE([CURL_INCLUDES_WS2TCPIP])dnl
2019 AC_REQUIRE([CURL_INCLUDES_STDLIB])dnl
2020 AC_REQUIRE([CURL_INCLUDES_STRING])dnl
2021 AC_REQUIRE([CURL_INCLUDES_SYS_SOCKET])dnl
2022 AC_REQUIRE([CURL_INCLUDES_NETDB])dnl
2024 tst_links_getaddrinfo="unknown"
2025 tst_proto_getaddrinfo="unknown"
2026 tst_compi_getaddrinfo="unknown"
2027 tst_works_getaddrinfo="unknown"
2028 tst_allow_getaddrinfo="unknown"
2029 tst_tsafe_getaddrinfo="unknown"
2031 AC_MSG_CHECKING([if getaddrinfo can be linked])
2034 $curl_includes_ws2tcpip
2035 $curl_includes_sys_socket
2036 $curl_includes_netdb
2038 if(0 != getaddrinfo(0, 0, 0, 0))
2042 AC_MSG_RESULT([yes])
2043 tst_links_getaddrinfo="yes"
2046 tst_links_getaddrinfo="no"
2049 if test "$tst_links_getaddrinfo" = "yes"; then
2050 AC_MSG_CHECKING([if getaddrinfo is prototyped])
2051 AC_EGREP_CPP([getaddrinfo],[
2052 $curl_includes_ws2tcpip
2053 $curl_includes_sys_socket
2054 $curl_includes_netdb
2056 AC_MSG_RESULT([yes])
2057 tst_proto_getaddrinfo="yes"
2060 tst_proto_getaddrinfo="no"
2064 if test "$tst_proto_getaddrinfo" = "yes"; then
2065 AC_MSG_CHECKING([if getaddrinfo is compilable])
2068 $curl_includes_ws2tcpip
2069 $curl_includes_sys_socket
2070 $curl_includes_netdb
2072 if(0 != getaddrinfo(0, 0, 0, 0))
2076 AC_MSG_RESULT([yes])
2077 tst_compi_getaddrinfo="yes"
2080 tst_compi_getaddrinfo="no"
2084 dnl only do runtime verification when not cross-compiling
2085 if test "x$cross_compiling" != "xyes" &&
2086 test "$tst_compi_getaddrinfo" = "yes"; then
2087 AC_MSG_CHECKING([if getaddrinfo seems to work])
2090 $curl_includes_ws2tcpip
2091 $curl_includes_stdlib
2092 $curl_includes_string
2093 $curl_includes_sys_socket
2094 $curl_includes_netdb
2096 struct addrinfo hints;
2097 struct addrinfo *ai = 0;
2100 memset(&hints, 0, sizeof(hints));
2101 hints.ai_flags = AI_NUMERICHOST;
2102 hints.ai_family = AF_UNSPEC;
2103 hints.ai_socktype = SOCK_STREAM;
2104 error = getaddrinfo("127.0.0.1", 0, &hints, &ai);
2111 AC_MSG_RESULT([yes])
2112 tst_works_getaddrinfo="yes"
2115 tst_works_getaddrinfo="no"
2119 if test "$tst_compi_getaddrinfo" = "yes" &&
2120 test "$tst_works_getaddrinfo" != "no"; then
2121 AC_MSG_CHECKING([if getaddrinfo usage allowed])
2122 if test "x$curl_disallow_getaddrinfo" != "xyes"; then
2123 AC_MSG_RESULT([yes])
2124 tst_allow_getaddrinfo="yes"
2127 tst_allow_getaddrinfo="no"
2131 AC_MSG_CHECKING([if getaddrinfo might be used])
2132 if test "$tst_links_getaddrinfo" = "yes" &&
2133 test "$tst_proto_getaddrinfo" = "yes" &&
2134 test "$tst_compi_getaddrinfo" = "yes" &&
2135 test "$tst_allow_getaddrinfo" = "yes" &&
2136 test "$tst_works_getaddrinfo" != "no"; then
2137 AC_MSG_RESULT([yes])
2138 AC_DEFINE_UNQUOTED(HAVE_GETADDRINFO, 1,
2139 [Define to 1 if you have a working getaddrinfo function.])
2140 ac_cv_func_getaddrinfo="yes"
2143 ac_cv_func_getaddrinfo="no"
2144 ac_cv_func_getaddrinfo_threadsafe="no"
2147 if test "$ac_cv_func_getaddrinfo" = "yes"; then
2148 AC_MSG_CHECKING([if getaddrinfo is threadsafe])
2150 aix[[1234]].* | aix5.[[01]].*)
2151 dnl aix 5.1 and older
2152 tst_tsafe_getaddrinfo="no"
2155 dnl aix 5.2 and newer
2156 tst_tsafe_getaddrinfo="yes"
2159 dnl darwin 5.0 and mac os x 10.1.X and older
2160 tst_tsafe_getaddrinfo="no"
2163 dnl darwin 6.0 and mac os x 10.2.X and newer
2164 tst_tsafe_getaddrinfo="yes"
2166 freebsd[[1234]].* | freebsd5.[[1234]]*)
2167 dnl freebsd 5.4 and older
2168 tst_tsafe_getaddrinfo="no"
2171 dnl freebsd 5.5 and newer
2172 tst_tsafe_getaddrinfo="yes"
2174 hpux[[123456789]].* | hpux10.* | hpux11.0* | hpux11.10*)
2175 dnl hpux 11.10 and older
2176 tst_tsafe_getaddrinfo="no"
2179 dnl hpux 11.11 and newer
2180 tst_tsafe_getaddrinfo="yes"
2183 dnl netbsd 3.X and older
2184 tst_tsafe_getaddrinfo="no"
2187 dnl netbsd 4.X and newer
2188 tst_tsafe_getaddrinfo="yes"
2192 tst_tsafe_getaddrinfo="no"
2195 dnl solaris which have it
2196 tst_tsafe_getaddrinfo="yes"
2199 if test "$tst_tsafe_getaddrinfo" = "unknown"; then
2200 CURL_CHECK_DEF_CC([h_errno], [
2201 $curl_includes_ws2tcpip
2202 $curl_includes_sys_socket
2203 $curl_includes_netdb
2205 if test "$curl_cv_have_def_h_errno" = "no"; then
2206 tst_tsafe_getaddrinfo="no"
2209 if test "$tst_tsafe_getaddrinfo" = "unknown"; then
2210 tst_tsafe_getaddrinfo="yes"
2212 AC_MSG_RESULT([$tst_tsafe_getaddrinfo])
2213 if test "$tst_tsafe_getaddrinfo" = "yes"; then
2214 AC_DEFINE_UNQUOTED(HAVE_GETADDRINFO_THREADSAFE, 1,
2215 [Define to 1 if the getaddrinfo function is threadsafe.])
2216 ac_cv_func_getaddrinfo_threadsafe="yes"
2218 ac_cv_func_getaddrinfo_threadsafe="no"
2224 dnl CURL_CHECK_FUNC_GETHOSTBYADDR
2225 dnl -------------------------------------------------
2226 dnl Verify if gethostbyaddr is available, prototyped,
2227 dnl and can be compiled. If all of these are true,
2228 dnl and usage has not been previously disallowed with
2229 dnl shell variable curl_disallow_gethostbyaddr, then
2230 dnl HAVE_GETHOSTBYADDR will be defined.
2232 AC_DEFUN([CURL_CHECK_FUNC_GETHOSTBYADDR], [
2233 AC_REQUIRE([CURL_INCLUDES_WINSOCK2])dnl
2234 AC_REQUIRE([CURL_INCLUDES_NETDB])dnl
2236 tst_links_gethostbyaddr="unknown"
2237 tst_proto_gethostbyaddr="unknown"
2238 tst_compi_gethostbyaddr="unknown"
2239 tst_allow_gethostbyaddr="unknown"
2241 AC_MSG_CHECKING([if gethostbyaddr can be linked])
2244 $curl_includes_winsock2
2245 $curl_includes_netdb
2247 if(0 != gethostbyaddr(0, 0, 0))
2251 AC_MSG_RESULT([yes])
2252 tst_links_gethostbyaddr="yes"
2255 tst_links_gethostbyaddr="no"
2258 if test "$tst_links_gethostbyaddr" = "yes"; then
2259 AC_MSG_CHECKING([if gethostbyaddr is prototyped])
2260 AC_EGREP_CPP([gethostbyaddr],[
2261 $curl_includes_winsock2
2262 $curl_includes_netdb
2264 AC_MSG_RESULT([yes])
2265 tst_proto_gethostbyaddr="yes"
2268 tst_proto_gethostbyaddr="no"
2272 if test "$tst_proto_gethostbyaddr" = "yes"; then
2273 AC_MSG_CHECKING([if gethostbyaddr is compilable])
2276 $curl_includes_winsock2
2277 $curl_includes_netdb
2279 if(0 != gethostbyaddr(0, 0, 0))
2283 AC_MSG_RESULT([yes])
2284 tst_compi_gethostbyaddr="yes"
2287 tst_compi_gethostbyaddr="no"
2291 if test "$tst_compi_gethostbyaddr" = "yes"; then
2292 AC_MSG_CHECKING([if gethostbyaddr usage allowed])
2293 if test "x$curl_disallow_gethostbyaddr" != "xyes"; then
2294 AC_MSG_RESULT([yes])
2295 tst_allow_gethostbyaddr="yes"
2298 tst_allow_gethostbyaddr="no"
2302 AC_MSG_CHECKING([if gethostbyaddr might be used])
2303 if test "$tst_links_gethostbyaddr" = "yes" &&
2304 test "$tst_proto_gethostbyaddr" = "yes" &&
2305 test "$tst_compi_gethostbyaddr" = "yes" &&
2306 test "$tst_allow_gethostbyaddr" = "yes"; then
2307 AC_MSG_RESULT([yes])
2308 AC_DEFINE_UNQUOTED(HAVE_GETHOSTBYADDR, 1,
2309 [Define to 1 if you have the gethostbyaddr function.])
2310 ac_cv_func_gethostbyaddr="yes"
2313 ac_cv_func_gethostbyaddr="no"
2317 dnl CURL_CHECK_FUNC_GAI_STRERROR
2318 dnl -------------------------------------------------
2319 dnl Verify if gai_strerror is available, prototyped,
2320 dnl and can be compiled. If all of these are true,
2321 dnl and usage has not been previously disallowed with
2322 dnl shell variable curl_disallow_gai_strerror, then
2323 dnl HAVE_GAI_STRERROR will be defined.
2325 AC_DEFUN([CURL_CHECK_FUNC_GAI_STRERROR], [
2326 AC_REQUIRE([CURL_INCLUDES_WINSOCK2])dnl
2327 AC_REQUIRE([CURL_INCLUDES_NETDB])dnl
2329 tst_links_gai_strerror="unknown"
2330 tst_proto_gai_strerror="unknown"
2331 tst_compi_gai_strerror="unknown"
2332 tst_allow_gai_strerror="unknown"
2334 AC_MSG_CHECKING([if gai_strerror can be linked])
2337 $curl_includes_winsock2
2338 $curl_includes_netdb
2340 if(0 != gai_strerror(0))
2344 AC_MSG_RESULT([yes])
2345 tst_links_gai_strerror="yes"
2348 tst_links_gai_strerror="no"
2351 if test "$tst_links_gai_strerror" = "yes"; then
2352 AC_MSG_CHECKING([if gai_strerror is prototyped])
2353 AC_EGREP_CPP([gai_strerror],[
2354 $curl_includes_winsock2
2355 $curl_includes_netdb
2357 AC_MSG_RESULT([yes])
2358 tst_proto_gai_strerror="yes"
2361 tst_proto_gai_strerror="no"
2365 if test "$tst_proto_gai_strerror" = "yes"; then
2366 AC_MSG_CHECKING([if gai_strerror is compilable])
2369 $curl_includes_winsock2
2370 $curl_includes_netdb
2372 if(0 != gai_strerror(0))
2376 AC_MSG_RESULT([yes])
2377 tst_compi_gai_strerror="yes"
2380 tst_compi_gai_strerror="no"
2384 if test "$tst_compi_gai_strerror" = "yes"; then
2385 AC_MSG_CHECKING([if gai_strerror usage allowed])
2386 if test "x$curl_disallow_gai_strerror" != "xyes"; then
2387 AC_MSG_RESULT([yes])
2388 tst_allow_gai_strerror="yes"
2391 tst_allow_gai_strerror="no"
2395 AC_MSG_CHECKING([if gai_strerror might be used])
2396 if test "$tst_links_gai_strerror" = "yes" &&
2397 test "$tst_proto_gai_strerror" = "yes" &&
2398 test "$tst_compi_gai_strerror" = "yes" &&
2399 test "$tst_allow_gai_strerror" = "yes"; then
2400 AC_MSG_RESULT([yes])
2401 AC_DEFINE_UNQUOTED(HAVE_GAI_STRERROR, 1,
2402 [Define to 1 if you have the gai_strerror function.])
2403 ac_cv_func_gai_strerror="yes"
2406 ac_cv_func_gai_strerror="no"
2411 dnl CURL_CHECK_FUNC_GETHOSTBYADDR_R
2412 dnl -------------------------------------------------
2413 dnl Verify if gethostbyaddr_r is available, prototyped,
2414 dnl and can be compiled. If all of these are true, and
2415 dnl usage has not been previously disallowed with
2416 dnl shell variable curl_disallow_gethostbyaddr_r, then
2417 dnl HAVE_GETHOSTBYADDR_R will be defined.
2419 AC_DEFUN([CURL_CHECK_FUNC_GETHOSTBYADDR_R], [
2420 AC_REQUIRE([CURL_INCLUDES_NETDB])dnl
2422 tst_links_gethostbyaddr_r="unknown"
2423 tst_proto_gethostbyaddr_r="unknown"
2424 tst_compi_gethostbyaddr_r="unknown"
2425 tst_allow_gethostbyaddr_r="unknown"
2426 tst_nargs_gethostbyaddr_r="unknown"
2428 AC_MSG_CHECKING([if gethostbyaddr_r can be linked])
2430 AC_LANG_FUNC_LINK_TRY([gethostbyaddr_r])
2432 AC_MSG_RESULT([yes])
2433 tst_links_gethostbyaddr_r="yes"
2436 tst_links_gethostbyaddr_r="no"
2439 if test "$tst_links_gethostbyaddr_r" = "yes"; then
2440 AC_MSG_CHECKING([if gethostbyaddr_r is prototyped])
2441 AC_EGREP_CPP([gethostbyaddr_r],[
2442 $curl_includes_netdb
2444 AC_MSG_RESULT([yes])
2445 tst_proto_gethostbyaddr_r="yes"
2448 tst_proto_gethostbyaddr_r="no"
2452 if test "$tst_proto_gethostbyaddr_r" = "yes"; then
2453 if test "$tst_nargs_gethostbyaddr_r" = "unknown"; then
2454 AC_MSG_CHECKING([if gethostbyaddr_r takes 5 args.])
2457 $curl_includes_netdb
2459 if(0 != gethostbyaddr_r(0, 0, 0, 0, 0))
2463 AC_MSG_RESULT([yes])
2464 tst_compi_gethostbyaddr_r="yes"
2465 tst_nargs_gethostbyaddr_r="5"
2468 tst_compi_gethostbyaddr_r="no"
2471 if test "$tst_nargs_gethostbyaddr_r" = "unknown"; then
2472 AC_MSG_CHECKING([if gethostbyaddr_r takes 7 args.])
2475 $curl_includes_netdb
2477 if(0 != gethostbyaddr_r(0, 0, 0, 0, 0, 0, 0))
2481 AC_MSG_RESULT([yes])
2482 tst_compi_gethostbyaddr_r="yes"
2483 tst_nargs_gethostbyaddr_r="7"
2486 tst_compi_gethostbyaddr_r="no"
2489 if test "$tst_nargs_gethostbyaddr_r" = "unknown"; then
2490 AC_MSG_CHECKING([if gethostbyaddr_r takes 8 args.])
2493 $curl_includes_netdb
2495 if(0 != gethostbyaddr_r(0, 0, 0, 0, 0, 0, 0, 0))
2499 AC_MSG_RESULT([yes])
2500 tst_compi_gethostbyaddr_r="yes"
2501 tst_nargs_gethostbyaddr_r="8"
2504 tst_compi_gethostbyaddr_r="no"
2507 AC_MSG_CHECKING([if gethostbyaddr_r is compilable])
2508 if test "$tst_compi_gethostbyaddr_r" = "yes"; then
2509 AC_MSG_RESULT([yes])
2515 if test "$tst_compi_gethostbyaddr_r" = "yes"; then
2516 AC_MSG_CHECKING([if gethostbyaddr_r usage allowed])
2517 if test "x$curl_disallow_gethostbyaddr_r" != "xyes"; then
2518 AC_MSG_RESULT([yes])
2519 tst_allow_gethostbyaddr_r="yes"
2522 tst_allow_gethostbyaddr_r="no"
2526 AC_MSG_CHECKING([if gethostbyaddr_r might be used])
2527 if test "$tst_links_gethostbyaddr_r" = "yes" &&
2528 test "$tst_proto_gethostbyaddr_r" = "yes" &&
2529 test "$tst_compi_gethostbyaddr_r" = "yes" &&
2530 test "$tst_allow_gethostbyaddr_r" = "yes"; then
2531 AC_MSG_RESULT([yes])
2532 AC_DEFINE_UNQUOTED(HAVE_GETHOSTBYADDR_R, 1,
2533 [Define to 1 if you have the gethostbyaddr_r function.])
2534 dnl AC_DEFINE_UNQUOTED(GETHOSTBYADDR_R_ARGS, $tst_nargs_gethostbyaddr_r,
2535 dnl [Specifies the number of arguments to gethostbyaddr_r])
2537 if test "$tst_nargs_gethostbyaddr_r" -eq "5"; then
2538 AC_DEFINE(HAVE_GETHOSTBYADDR_R_5, 1, [gethostbyaddr_r() takes 5 args])
2539 elif test "$tst_nargs_gethostbyaddr_r" -eq "7"; then
2540 AC_DEFINE(HAVE_GETHOSTBYADDR_R_7, 1, [gethostbyaddr_r() takes 7 args])
2541 elif test "$tst_nargs_gethostbyaddr_r" -eq "8"; then
2542 AC_DEFINE(HAVE_GETHOSTBYADDR_R_8, 1, [gethostbyaddr_r() takes 8 args])
2545 ac_cv_func_gethostbyaddr_r="yes"
2548 ac_cv_func_gethostbyaddr_r="no"
2553 dnl CURL_CHECK_FUNC_GETHOSTBYNAME
2554 dnl -------------------------------------------------
2555 dnl Verify if gethostbyname is available, prototyped,
2556 dnl and can be compiled. If all of these are true,
2557 dnl and usage has not been previously disallowed with
2558 dnl shell variable curl_disallow_gethostbyname, then
2559 dnl HAVE_GETHOSTBYNAME will be defined.
2561 AC_DEFUN([CURL_CHECK_FUNC_GETHOSTBYNAME], [
2562 AC_REQUIRE([CURL_INCLUDES_WINSOCK2])dnl
2563 AC_REQUIRE([CURL_INCLUDES_NETDB])dnl
2565 tst_links_gethostbyname="unknown"
2566 tst_proto_gethostbyname="unknown"
2567 tst_compi_gethostbyname="unknown"
2568 tst_allow_gethostbyname="unknown"
2570 AC_MSG_CHECKING([if gethostbyname can be linked])
2573 $curl_includes_winsock2
2574 $curl_includes_netdb
2576 if(0 != gethostbyname(0))
2580 AC_MSG_RESULT([yes])
2581 tst_links_gethostbyname="yes"
2584 tst_links_gethostbyname="no"
2587 if test "$tst_links_gethostbyname" = "yes"; then
2588 AC_MSG_CHECKING([if gethostbyname is prototyped])
2589 AC_EGREP_CPP([gethostbyname],[
2590 $curl_includes_winsock2
2591 $curl_includes_netdb
2593 AC_MSG_RESULT([yes])
2594 tst_proto_gethostbyname="yes"
2597 tst_proto_gethostbyname="no"
2601 if test "$tst_proto_gethostbyname" = "yes"; then
2602 AC_MSG_CHECKING([if gethostbyname is compilable])
2605 $curl_includes_winsock2
2606 $curl_includes_netdb
2608 if(0 != gethostbyname(0))
2612 AC_MSG_RESULT([yes])
2613 tst_compi_gethostbyname="yes"
2616 tst_compi_gethostbyname="no"
2620 if test "$tst_compi_gethostbyname" = "yes"; then
2621 AC_MSG_CHECKING([if gethostbyname usage allowed])
2622 if test "x$curl_disallow_gethostbyname" != "xyes"; then
2623 AC_MSG_RESULT([yes])
2624 tst_allow_gethostbyname="yes"
2627 tst_allow_gethostbyname="no"
2631 AC_MSG_CHECKING([if gethostbyname might be used])
2632 if test "$tst_links_gethostbyname" = "yes" &&
2633 test "$tst_proto_gethostbyname" = "yes" &&
2634 test "$tst_compi_gethostbyname" = "yes" &&
2635 test "$tst_allow_gethostbyname" = "yes"; then
2636 AC_MSG_RESULT([yes])
2637 AC_DEFINE_UNQUOTED(HAVE_GETHOSTBYNAME, 1,
2638 [Define to 1 if you have the gethostbyname function.])
2639 ac_cv_func_gethostbyname="yes"
2642 ac_cv_func_gethostbyname="no"
2647 dnl CURL_CHECK_FUNC_GETHOSTBYNAME_R
2648 dnl -------------------------------------------------
2649 dnl Verify if gethostbyname_r is available, prototyped,
2650 dnl and can be compiled. If all of these are true, and
2651 dnl usage has not been previously disallowed with
2652 dnl shell variable curl_disallow_gethostbyname_r, then
2653 dnl HAVE_GETHOSTBYNAME_R will be defined.
2655 AC_DEFUN([CURL_CHECK_FUNC_GETHOSTBYNAME_R], [
2656 AC_REQUIRE([CURL_INCLUDES_NETDB])dnl
2658 tst_links_gethostbyname_r="unknown"
2659 tst_proto_gethostbyname_r="unknown"
2660 tst_compi_gethostbyname_r="unknown"
2661 tst_allow_gethostbyname_r="unknown"
2662 tst_nargs_gethostbyname_r="unknown"
2664 AC_MSG_CHECKING([if gethostbyname_r can be linked])
2666 AC_LANG_FUNC_LINK_TRY([gethostbyname_r])
2668 AC_MSG_RESULT([yes])
2669 tst_links_gethostbyname_r="yes"
2672 tst_links_gethostbyname_r="no"
2675 if test "$tst_links_gethostbyname_r" = "yes"; then
2676 AC_MSG_CHECKING([if gethostbyname_r is prototyped])
2677 AC_EGREP_CPP([gethostbyname_r],[
2678 $curl_includes_netdb
2680 AC_MSG_RESULT([yes])
2681 tst_proto_gethostbyname_r="yes"
2684 tst_proto_gethostbyname_r="no"
2688 if test "$tst_proto_gethostbyname_r" = "yes"; then
2689 if test "$tst_nargs_gethostbyname_r" = "unknown"; then
2690 AC_MSG_CHECKING([if gethostbyname_r takes 3 args.])
2693 $curl_includes_netdb
2695 if(0 != gethostbyname_r(0, 0, 0))
2699 AC_MSG_RESULT([yes])
2700 tst_compi_gethostbyname_r="yes"
2701 tst_nargs_gethostbyname_r="3"
2704 tst_compi_gethostbyname_r="no"
2707 if test "$tst_nargs_gethostbyname_r" = "unknown"; then
2708 AC_MSG_CHECKING([if gethostbyname_r takes 5 args.])
2711 $curl_includes_netdb
2713 if(0 != gethostbyname_r(0, 0, 0, 0, 0))
2717 AC_MSG_RESULT([yes])
2718 tst_compi_gethostbyname_r="yes"
2719 tst_nargs_gethostbyname_r="5"
2722 tst_compi_gethostbyname_r="no"
2725 if test "$tst_nargs_gethostbyname_r" = "unknown"; then
2726 AC_MSG_CHECKING([if gethostbyname_r takes 6 args.])
2729 $curl_includes_netdb
2731 if(0 != gethostbyname_r(0, 0, 0, 0, 0, 0))
2735 AC_MSG_RESULT([yes])
2736 tst_compi_gethostbyname_r="yes"
2737 tst_nargs_gethostbyname_r="6"
2740 tst_compi_gethostbyname_r="no"
2743 AC_MSG_CHECKING([if gethostbyname_r is compilable])
2744 if test "$tst_compi_gethostbyname_r" = "yes"; then
2745 AC_MSG_RESULT([yes])
2751 if test "$tst_compi_gethostbyname_r" = "yes"; then
2752 AC_MSG_CHECKING([if gethostbyname_r usage allowed])
2753 if test "x$curl_disallow_gethostbyname_r" != "xyes"; then
2754 AC_MSG_RESULT([yes])
2755 tst_allow_gethostbyname_r="yes"
2758 tst_allow_gethostbyname_r="no"
2762 AC_MSG_CHECKING([if gethostbyname_r might be used])
2763 if test "$tst_links_gethostbyname_r" = "yes" &&
2764 test "$tst_proto_gethostbyname_r" = "yes" &&
2765 test "$tst_compi_gethostbyname_r" = "yes" &&
2766 test "$tst_allow_gethostbyname_r" = "yes"; then
2767 AC_MSG_RESULT([yes])
2768 AC_DEFINE_UNQUOTED(HAVE_GETHOSTBYNAME_R, 1,
2769 [Define to 1 if you have the gethostbyname_r function.])
2770 dnl AC_DEFINE_UNQUOTED(GETHOSTBYNAME_R_ARGS, $tst_nargs_gethostbyname_r,
2771 dnl [Specifies the number of arguments to gethostbyname_r])
2773 if test "$tst_nargs_gethostbyname_r" -eq "3"; then
2774 AC_DEFINE(HAVE_GETHOSTBYNAME_R_3, 1, [gethostbyname_r() takes 3 args])
2775 elif test "$tst_nargs_gethostbyname_r" -eq "5"; then
2776 AC_DEFINE(HAVE_GETHOSTBYNAME_R_5, 1, [gethostbyname_r() takes 5 args])
2777 elif test "$tst_nargs_gethostbyname_r" -eq "6"; then
2778 AC_DEFINE(HAVE_GETHOSTBYNAME_R_6, 1, [gethostbyname_r() takes 6 args])
2781 ac_cv_func_gethostbyname_r="yes"
2784 ac_cv_func_gethostbyname_r="no"
2789 dnl CURL_CHECK_FUNC_GETHOSTNAME
2790 dnl -------------------------------------------------
2791 dnl Verify if gethostname is available, prototyped, and
2792 dnl can be compiled. If all of these are true, and
2793 dnl usage has not been previously disallowed with
2794 dnl shell variable curl_disallow_gethostname, then
2795 dnl HAVE_GETHOSTNAME will be defined.
2797 AC_DEFUN([CURL_CHECK_FUNC_GETHOSTNAME], [
2798 AC_REQUIRE([CURL_INCLUDES_WINSOCK2])dnl
2799 AC_REQUIRE([CURL_INCLUDES_UNISTD])dnl
2801 tst_links_gethostname="unknown"
2802 tst_proto_gethostname="unknown"
2803 tst_compi_gethostname="unknown"
2804 tst_allow_gethostname="unknown"
2806 AC_MSG_CHECKING([if gethostname can be linked])
2809 $curl_includes_winsock2
2810 $curl_includes_unistd
2812 if(0 != gethostname(0, 0))
2816 AC_MSG_RESULT([yes])
2817 tst_links_gethostname="yes"
2820 tst_links_gethostname="no"
2823 if test "$tst_links_gethostname" = "yes"; then
2824 AC_MSG_CHECKING([if gethostname is prototyped])
2825 AC_EGREP_CPP([gethostname],[
2826 $curl_includes_winsock2
2827 $curl_includes_unistd
2829 AC_MSG_RESULT([yes])
2830 tst_proto_gethostname="yes"
2833 tst_proto_gethostname="no"
2837 if test "$tst_proto_gethostname" = "yes"; then
2838 AC_MSG_CHECKING([if gethostname is compilable])
2841 $curl_includes_winsock2
2842 $curl_includes_unistd
2844 if(0 != gethostname(0, 0))
2848 AC_MSG_RESULT([yes])
2849 tst_compi_gethostname="yes"
2852 tst_compi_gethostname="no"
2856 if test "$tst_compi_gethostname" = "yes"; then
2857 AC_MSG_CHECKING([if gethostname usage allowed])
2858 if test "x$curl_disallow_gethostname" != "xyes"; then
2859 AC_MSG_RESULT([yes])
2860 tst_allow_gethostname="yes"
2863 tst_allow_gethostname="no"
2867 AC_MSG_CHECKING([if gethostname might be used])
2868 if test "$tst_links_gethostname" = "yes" &&
2869 test "$tst_proto_gethostname" = "yes" &&
2870 test "$tst_compi_gethostname" = "yes" &&
2871 test "$tst_allow_gethostname" = "yes"; then
2872 AC_MSG_RESULT([yes])
2873 AC_DEFINE_UNQUOTED(HAVE_GETHOSTNAME, 1,
2874 [Define to 1 if you have the gethostname function.])
2875 ac_cv_func_gethostname="yes"
2878 ac_cv_func_gethostname="no"
2883 dnl CURL_CHECK_FUNC_GETIFADDRS
2884 dnl -------------------------------------------------
2885 dnl Verify if getifaddrs is available, prototyped, can
2886 dnl be compiled and seems to work. If all of these are
2887 dnl true, and usage has not been previously disallowed
2888 dnl with shell variable curl_disallow_getifaddrs, then
2889 dnl HAVE_GETIFADDRS will be defined.
2891 AC_DEFUN([CURL_CHECK_FUNC_GETIFADDRS], [
2892 AC_REQUIRE([CURL_INCLUDES_STDLIB])dnl
2893 AC_REQUIRE([CURL_INCLUDES_IFADDRS])dnl
2895 tst_links_getifaddrs="unknown"
2896 tst_proto_getifaddrs="unknown"
2897 tst_compi_getifaddrs="unknown"
2898 tst_works_getifaddrs="unknown"
2899 tst_allow_getifaddrs="unknown"
2901 AC_MSG_CHECKING([if getifaddrs can be linked])
2903 AC_LANG_FUNC_LINK_TRY([getifaddrs])
2905 AC_MSG_RESULT([yes])
2906 tst_links_getifaddrs="yes"
2909 tst_links_getifaddrs="no"
2912 if test "$tst_links_getifaddrs" = "yes"; then
2913 AC_MSG_CHECKING([if getifaddrs is prototyped])
2914 AC_EGREP_CPP([getifaddrs],[
2915 $curl_includes_ifaddrs
2917 AC_MSG_RESULT([yes])
2918 tst_proto_getifaddrs="yes"
2921 tst_proto_getifaddrs="no"
2925 if test "$tst_proto_getifaddrs" = "yes"; then
2926 AC_MSG_CHECKING([if getifaddrs is compilable])
2929 $curl_includes_ifaddrs
2931 if(0 != getifaddrs(0))
2935 AC_MSG_RESULT([yes])
2936 tst_compi_getifaddrs="yes"
2939 tst_compi_getifaddrs="no"
2943 dnl only do runtime verification when not cross-compiling
2944 if test "x$cross_compiling" != "xyes" &&
2945 test "$tst_compi_getifaddrs" = "yes"; then
2946 AC_MSG_CHECKING([if getifaddrs seems to work])
2949 $curl_includes_stdlib
2950 $curl_includes_ifaddrs
2952 struct ifaddrs *ifa = 0;
2955 error = getifaddrs(&ifa);
2962 AC_MSG_RESULT([yes])
2963 tst_works_getifaddrs="yes"
2966 tst_works_getifaddrs="no"
2970 if test "$tst_compi_getifaddrs" = "yes" &&
2971 test "$tst_works_getifaddrs" != "no"; then
2972 AC_MSG_CHECKING([if getifaddrs usage allowed])
2973 if test "x$curl_disallow_getifaddrs" != "xyes"; then
2974 AC_MSG_RESULT([yes])
2975 tst_allow_getifaddrs="yes"
2978 tst_allow_getifaddrs="no"
2982 AC_MSG_CHECKING([if getifaddrs might be used])
2983 if test "$tst_links_getifaddrs" = "yes" &&
2984 test "$tst_proto_getifaddrs" = "yes" &&
2985 test "$tst_compi_getifaddrs" = "yes" &&
2986 test "$tst_allow_getifaddrs" = "yes" &&
2987 test "$tst_works_getifaddrs" != "no"; then
2988 AC_MSG_RESULT([yes])
2989 AC_DEFINE_UNQUOTED(HAVE_GETIFADDRS, 1,
2990 [Define to 1 if you have a working getifaddrs function.])
2991 ac_cv_func_getifaddrs="yes"
2994 ac_cv_func_getifaddrs="no"
2999 dnl CURL_CHECK_FUNC_GETSERVBYPORT_R
3000 dnl -------------------------------------------------
3001 dnl Verify if getservbyport_r is available, prototyped,
3002 dnl and can be compiled. If all of these are true, and
3003 dnl usage has not been previously disallowed with
3004 dnl shell variable curl_disallow_getservbyport_r, then
3005 dnl HAVE_GETSERVBYPORT_R will be defined.
3007 AC_DEFUN([CURL_CHECK_FUNC_GETSERVBYPORT_R], [
3008 AC_REQUIRE([CURL_INCLUDES_NETDB])dnl
3010 tst_links_getservbyport_r="unknown"
3011 tst_proto_getservbyport_r="unknown"
3012 tst_compi_getservbyport_r="unknown"
3013 tst_allow_getservbyport_r="unknown"
3014 tst_nargs_getservbyport_r="unknown"
3016 AC_MSG_CHECKING([if getservbyport_r can be linked])
3018 AC_LANG_FUNC_LINK_TRY([getservbyport_r])
3020 AC_MSG_RESULT([yes])
3021 tst_links_getservbyport_r="yes"
3024 tst_links_getservbyport_r="no"
3027 if test "$tst_links_getservbyport_r" = "yes"; then
3028 AC_MSG_CHECKING([if getservbyport_r is prototyped])
3029 AC_EGREP_CPP([getservbyport_r],[
3030 $curl_includes_netdb
3032 AC_MSG_RESULT([yes])
3033 tst_proto_getservbyport_r="yes"
3036 tst_proto_getservbyport_r="no"
3040 if test "$tst_proto_getservbyport_r" = "yes"; then
3041 if test "$tst_nargs_getservbyport_r" = "unknown"; then
3042 AC_MSG_CHECKING([if getservbyport_r takes 4 args.])
3045 $curl_includes_netdb
3047 if(0 != getservbyport_r(0, 0, 0, 0))
3051 AC_MSG_RESULT([yes])
3052 tst_compi_getservbyport_r="yes"
3053 tst_nargs_getservbyport_r="4"
3056 tst_compi_getservbyport_r="no"
3059 if test "$tst_nargs_getservbyport_r" = "unknown"; then
3060 AC_MSG_CHECKING([if getservbyport_r takes 5 args.])
3063 $curl_includes_netdb
3065 if(0 != getservbyport_r(0, 0, 0, 0, 0))
3069 AC_MSG_RESULT([yes])
3070 tst_compi_getservbyport_r="yes"
3071 tst_nargs_getservbyport_r="5"
3074 tst_compi_getservbyport_r="no"
3077 if test "$tst_nargs_getservbyport_r" = "unknown"; then
3078 AC_MSG_CHECKING([if getservbyport_r takes 6 args.])
3081 $curl_includes_netdb
3083 if(0 != getservbyport_r(0, 0, 0, 0, 0, 0))
3087 AC_MSG_RESULT([yes])
3088 tst_compi_getservbyport_r="yes"
3089 tst_nargs_getservbyport_r="6"
3092 tst_compi_getservbyport_r="no"
3095 AC_MSG_CHECKING([if getservbyport_r is compilable])
3096 if test "$tst_compi_getservbyport_r" = "yes"; then
3097 AC_MSG_RESULT([yes])
3103 if test "$tst_compi_getservbyport_r" = "yes"; then
3104 AC_MSG_CHECKING([if getservbyport_r usage allowed])
3105 if test "x$curl_disallow_getservbyport_r" != "xyes"; then
3106 AC_MSG_RESULT([yes])
3107 tst_allow_getservbyport_r="yes"
3110 tst_allow_getservbyport_r="no"
3114 AC_MSG_CHECKING([if getservbyport_r might be used])
3115 if test "$tst_links_getservbyport_r" = "yes" &&
3116 test "$tst_proto_getservbyport_r" = "yes" &&
3117 test "$tst_compi_getservbyport_r" = "yes" &&
3118 test "$tst_allow_getservbyport_r" = "yes"; then
3119 AC_MSG_RESULT([yes])
3120 AC_DEFINE_UNQUOTED(HAVE_GETSERVBYPORT_R, 1,
3121 [Define to 1 if you have the getservbyport_r function.])
3122 AC_DEFINE_UNQUOTED(GETSERVBYPORT_R_ARGS, $tst_nargs_getservbyport_r,
3123 [Specifies the number of arguments to getservbyport_r])
3124 if test "$tst_nargs_getservbyport_r" -eq "4"; then
3125 AC_DEFINE(GETSERVBYPORT_R_BUFSIZE, sizeof(struct servent_data),
3126 [Specifies the size of the buffer to pass to getservbyport_r])
3128 AC_DEFINE(GETSERVBYPORT_R_BUFSIZE, 4096,
3129 [Specifies the size of the buffer to pass to getservbyport_r])
3131 ac_cv_func_getservbyport_r="yes"
3134 ac_cv_func_getservbyport_r="no"
3139 dnl CURL_CHECK_FUNC_GETXATTR
3140 dnl -------------------------------------------------
3141 dnl Verify if getxattr is available, prototyped, and
3142 dnl can be compiled. If all of these are true, and
3143 dnl usage has not been previously disallowed with
3144 dnl shell variable curl_disallow_getxattr, then
3145 dnl HAVE_GETXATTR will be defined.
3147 AC_DEFUN([CURL_CHECK_FUNC_GETXATTR], [
3148 AC_REQUIRE([CURL_INCLUDES_SYS_XATTR])dnl
3150 tst_links_getxattr="unknown"
3151 tst_proto_getxattr="unknown"
3152 tst_compi_getxattr="unknown"
3153 tst_allow_getxattr="unknown"
3154 tst_nargs_getxattr="unknown"
3156 AC_MSG_CHECKING([if getxattr can be linked])
3158 AC_LANG_FUNC_LINK_TRY([getxattr])
3160 AC_MSG_RESULT([yes])
3161 tst_links_getxattr="yes"
3164 tst_links_getxattr="no"
3167 if test "$tst_links_getxattr" = "yes"; then
3168 AC_MSG_CHECKING([if getxattr is prototyped])
3169 AC_EGREP_CPP([getxattr],[
3170 $curl_includes_sys_xattr
3172 AC_MSG_RESULT([yes])
3173 tst_proto_getxattr="yes"
3176 tst_proto_getxattr="no"
3180 if test "$tst_proto_getxattr" = "yes"; then
3181 if test "$tst_nargs_getxattr" = "unknown"; then
3182 AC_MSG_CHECKING([if getxattr takes 4 args.])
3185 $curl_includes_sys_xattr
3187 if(0 != getxattr(0, 0, 0, 0))
3191 AC_MSG_RESULT([yes])
3192 tst_compi_getxattr="yes"
3193 tst_nargs_getxattr="4"
3196 tst_compi_getxattr="no"
3199 if test "$tst_nargs_getxattr" = "unknown"; then
3200 AC_MSG_CHECKING([if getxattr takes 6 args.])
3203 $curl_includes_sys_xattr
3205 if(0 != getxattr(0, 0, 0, 0, 0, 0))
3209 AC_MSG_RESULT([yes])
3210 tst_compi_getxattr="yes"
3211 tst_nargs_getxattr="6"
3214 tst_compi_getxattr="no"
3217 AC_MSG_CHECKING([if getxattr is compilable])
3218 if test "$tst_compi_getxattr" = "yes"; then
3219 AC_MSG_RESULT([yes])
3225 if test "$tst_compi_getxattr" = "yes"; then
3226 AC_MSG_CHECKING([if getxattr usage allowed])
3227 if test "x$curl_disallow_getxattr" != "xyes"; then
3228 AC_MSG_RESULT([yes])
3229 tst_allow_getxattr="yes"
3232 tst_allow_getxattr="no"
3236 AC_MSG_CHECKING([if getxattr might be used])
3237 if test "$tst_links_getxattr" = "yes" &&
3238 test "$tst_proto_getxattr" = "yes" &&
3239 test "$tst_compi_getxattr" = "yes" &&
3240 test "$tst_allow_getxattr" = "yes"; then
3241 AC_MSG_RESULT([yes])
3242 AC_DEFINE_UNQUOTED(HAVE_GETXATTR, 1,
3243 [Define to 1 if you have the getxattr function.])
3244 dnl AC_DEFINE_UNQUOTED(GETXATTR_ARGS, $tst_nargs_getxattr,
3245 dnl [Specifies the number of arguments to getxattr])
3247 if test "$tst_nargs_getxattr" -eq "4"; then
3248 AC_DEFINE(HAVE_GETXATTR_4, 1, [getxattr() takes 4 args])
3249 elif test "$tst_nargs_getxattr" -eq "6"; then
3250 AC_DEFINE(HAVE_GETXATTR_6, 1, [getxattr() takes 6 args])
3253 ac_cv_func_getxattr="yes"
3256 ac_cv_func_getxattr="no"
3261 dnl CURL_CHECK_FUNC_GMTIME_R
3262 dnl -------------------------------------------------
3263 dnl Verify if gmtime_r is available, prototyped, can
3264 dnl be compiled and seems to work. If all of these are
3265 dnl true, and usage has not been previously disallowed
3266 dnl with shell variable curl_disallow_gmtime_r, then
3267 dnl HAVE_GMTIME_R will be defined.
3269 AC_DEFUN([CURL_CHECK_FUNC_GMTIME_R], [
3270 AC_REQUIRE([CURL_INCLUDES_STDLIB])dnl
3271 AC_REQUIRE([CURL_INCLUDES_TIME])dnl
3273 tst_links_gmtime_r="unknown"
3274 tst_proto_gmtime_r="unknown"
3275 tst_compi_gmtime_r="unknown"
3276 tst_works_gmtime_r="unknown"
3277 tst_allow_gmtime_r="unknown"
3279 AC_MSG_CHECKING([if gmtime_r can be linked])
3281 AC_LANG_FUNC_LINK_TRY([gmtime_r])
3283 AC_MSG_RESULT([yes])
3284 tst_links_gmtime_r="yes"
3287 tst_links_gmtime_r="no"
3290 if test "$tst_links_gmtime_r" = "yes"; then
3291 AC_MSG_CHECKING([if gmtime_r is prototyped])
3292 AC_EGREP_CPP([gmtime_r],[
3295 AC_MSG_RESULT([yes])
3296 tst_proto_gmtime_r="yes"
3299 tst_proto_gmtime_r="no"
3303 if test "$tst_proto_gmtime_r" = "yes"; then
3304 AC_MSG_CHECKING([if gmtime_r is compilable])
3309 if(0 != gmtime_r(0, 0))
3313 AC_MSG_RESULT([yes])
3314 tst_compi_gmtime_r="yes"
3317 tst_compi_gmtime_r="no"
3321 dnl only do runtime verification when not cross-compiling
3322 if test "x$cross_compiling" != "xyes" &&
3323 test "$tst_compi_gmtime_r" = "yes"; then
3324 AC_MSG_CHECKING([if gmtime_r seems to work])
3327 $curl_includes_stdlib
3330 time_t local = 1170352587;
3333 gmt = gmtime_r(&local, &result);
3340 AC_MSG_RESULT([yes])
3341 tst_works_gmtime_r="yes"
3344 tst_works_gmtime_r="no"
3348 if test "$tst_compi_gmtime_r" = "yes" &&
3349 test "$tst_works_gmtime_r" != "no"; then
3350 AC_MSG_CHECKING([if gmtime_r usage allowed])
3351 if test "x$curl_disallow_gmtime_r" != "xyes"; then
3352 AC_MSG_RESULT([yes])
3353 tst_allow_gmtime_r="yes"
3356 tst_allow_gmtime_r="no"
3360 AC_MSG_CHECKING([if gmtime_r might be used])
3361 if test "$tst_links_gmtime_r" = "yes" &&
3362 test "$tst_proto_gmtime_r" = "yes" &&
3363 test "$tst_compi_gmtime_r" = "yes" &&
3364 test "$tst_allow_gmtime_r" = "yes" &&
3365 test "$tst_works_gmtime_r" != "no"; then
3366 AC_MSG_RESULT([yes])
3367 AC_DEFINE_UNQUOTED(HAVE_GMTIME_R, 1,
3368 [Define to 1 if you have a working gmtime_r function.])
3369 ac_cv_func_gmtime_r="yes"
3372 ac_cv_func_gmtime_r="no"
3377 dnl CURL_CHECK_FUNC_INET_NTOA_R
3378 dnl -------------------------------------------------
3379 dnl Verify if inet_ntoa_r is available, prototyped,
3380 dnl and can be compiled. If all of these are true, and
3381 dnl usage has not been previously disallowed with
3382 dnl shell variable curl_disallow_inet_ntoa_r, then
3383 dnl HAVE_INET_NTOA_R will be defined.
3385 AC_DEFUN([CURL_CHECK_FUNC_INET_NTOA_R], [
3386 AC_REQUIRE([CURL_INCLUDES_ARPA_INET])dnl
3388 tst_links_inet_ntoa_r="unknown"
3389 tst_proto_inet_ntoa_r="unknown"
3390 tst_compi_inet_ntoa_r="unknown"
3391 tst_allow_inet_ntoa_r="unknown"
3392 tst_nargs_inet_ntoa_r="unknown"
3394 AC_MSG_CHECKING([if inet_ntoa_r can be linked])
3396 AC_LANG_FUNC_LINK_TRY([inet_ntoa_r])
3398 AC_MSG_RESULT([yes])
3399 tst_links_inet_ntoa_r="yes"
3402 tst_links_inet_ntoa_r="no"
3405 if test "$tst_links_inet_ntoa_r" = "yes"; then
3406 AC_MSG_CHECKING([if inet_ntoa_r is prototyped])
3407 AC_EGREP_CPP([inet_ntoa_r],[
3408 $curl_includes_arpa_inet
3410 AC_MSG_RESULT([yes])
3411 tst_proto_inet_ntoa_r="yes"
3414 tst_proto_inet_ntoa_r="no"
3418 if test "$tst_proto_inet_ntoa_r" = "yes"; then
3419 if test "$tst_nargs_inet_ntoa_r" = "unknown"; then
3420 AC_MSG_CHECKING([if inet_ntoa_r takes 2 args.])
3423 $curl_includes_arpa_inet
3425 struct in_addr addr;
3426 if(0 != inet_ntoa_r(addr, 0))
3430 AC_MSG_RESULT([yes])
3431 tst_compi_inet_ntoa_r="yes"
3432 tst_nargs_inet_ntoa_r="2"
3435 tst_compi_inet_ntoa_r="no"
3438 if test "$tst_nargs_inet_ntoa_r" = "unknown"; then
3439 AC_MSG_CHECKING([if inet_ntoa_r takes 3 args.])
3442 $curl_includes_arpa_inet
3444 struct in_addr addr;
3445 if(0 != inet_ntoa_r(addr, 0, 0))
3449 AC_MSG_RESULT([yes])
3450 tst_compi_inet_ntoa_r="yes"
3451 tst_nargs_inet_ntoa_r="3"
3454 tst_compi_inet_ntoa_r="no"
3457 AC_MSG_CHECKING([if inet_ntoa_r is compilable])
3458 if test "$tst_compi_inet_ntoa_r" = "yes"; then
3459 AC_MSG_RESULT([yes])
3465 if test "$tst_compi_inet_ntoa_r" = "yes"; then
3466 AC_MSG_CHECKING([if inet_ntoa_r usage allowed])
3467 if test "x$curl_disallow_inet_ntoa_r" != "xyes"; then
3468 AC_MSG_RESULT([yes])
3469 tst_allow_inet_ntoa_r="yes"
3472 tst_allow_inet_ntoa_r="no"
3476 AC_MSG_CHECKING([if inet_ntoa_r might be used])
3477 if test "$tst_links_inet_ntoa_r" = "yes" &&
3478 test "$tst_proto_inet_ntoa_r" = "yes" &&
3479 test "$tst_compi_inet_ntoa_r" = "yes" &&
3480 test "$tst_allow_inet_ntoa_r" = "yes"; then
3481 AC_MSG_RESULT([yes])
3482 AC_DEFINE_UNQUOTED(HAVE_INET_NTOA_R, 1,
3483 [Define to 1 if you have the inet_ntoa_r function.])
3484 dnl AC_DEFINE_UNQUOTED(INET_NTOA_R_ARGS, $tst_nargs_inet_ntoa_r,
3485 dnl [Specifies the number of arguments to inet_ntoa_r])
3487 if test "$tst_nargs_inet_ntoa_r" -eq "2"; then
3488 AC_DEFINE(HAVE_INET_NTOA_R_2, 1, [inet_ntoa_r() takes 2 args])
3489 elif test "$tst_nargs_inet_ntoa_r" -eq "3"; then
3490 AC_DEFINE(HAVE_INET_NTOA_R_3, 1, [inet_ntoa_r() takes 3 args])
3493 ac_cv_func_inet_ntoa_r="yes"
3496 ac_cv_func_inet_ntoa_r="no"
3501 dnl CURL_CHECK_FUNC_INET_NTOP
3502 dnl -------------------------------------------------
3503 dnl Verify if inet_ntop is available, prototyped, can
3504 dnl be compiled and seems to work. If all of these are
3505 dnl true, and usage has not been previously disallowed
3506 dnl with shell variable curl_disallow_inet_ntop, then
3507 dnl HAVE_INET_NTOP will be defined.
3509 AC_DEFUN([CURL_CHECK_FUNC_INET_NTOP], [
3510 AC_REQUIRE([CURL_INCLUDES_STDLIB])dnl
3511 AC_REQUIRE([CURL_INCLUDES_ARPA_INET])dnl
3512 AC_REQUIRE([CURL_INCLUDES_STRING])dnl
3514 tst_links_inet_ntop="unknown"
3515 tst_proto_inet_ntop="unknown"
3516 tst_compi_inet_ntop="unknown"
3517 tst_works_inet_ntop="unknown"
3518 tst_allow_inet_ntop="unknown"
3520 AC_MSG_CHECKING([if inet_ntop can be linked])
3522 AC_LANG_FUNC_LINK_TRY([inet_ntop])
3524 AC_MSG_RESULT([yes])
3525 tst_links_inet_ntop="yes"
3528 tst_links_inet_ntop="no"
3531 if test "$tst_links_inet_ntop" = "yes"; then
3532 AC_MSG_CHECKING([if inet_ntop is prototyped])
3533 AC_EGREP_CPP([inet_ntop],[
3534 $curl_includes_arpa_inet
3536 AC_MSG_RESULT([yes])
3537 tst_proto_inet_ntop="yes"
3540 tst_proto_inet_ntop="no"
3544 if test "$tst_proto_inet_ntop" = "yes"; then
3545 AC_MSG_CHECKING([if inet_ntop is compilable])
3548 $curl_includes_arpa_inet
3550 if(0 != inet_ntop(0, 0, 0, 0))
3554 AC_MSG_RESULT([yes])
3555 tst_compi_inet_ntop="yes"
3558 tst_compi_inet_ntop="no"
3562 dnl only do runtime verification when not cross-compiling
3563 if test "x$cross_compiling" != "xyes" &&
3564 test "$tst_compi_inet_ntop" = "yes"; then
3565 AC_MSG_CHECKING([if inet_ntop seems to work])
3568 $curl_includes_stdlib
3569 $curl_includes_arpa_inet
3570 $curl_includes_string
3572 char ipv6res[sizeof("ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255")];
3573 char ipv4res[sizeof "255.255.255.255"];
3574 unsigned char ipv6a[26];
3575 unsigned char ipv4a[5];
3586 ipv4ptr = inet_ntop(AF_INET, ipv4a, ipv4res, sizeof(ipv4res));
3589 if(ipv4ptr != ipv4res)
3593 if(memcmp(ipv4res, "192.168.100.1", 13) != 0)
3597 memset(ipv6a, 0, sizeof(ipv6a));
3610 ipv6ptr = inet_ntop(AF_INET6, ipv6a, ipv6res, sizeof(ipv6res));
3613 if(ipv6ptr != ipv6res)
3617 if(memcmp(ipv6res, "fe80::214:4fff:fe0b:76c8", 24) != 0)
3623 AC_MSG_RESULT([yes])
3624 tst_works_inet_ntop="yes"
3627 tst_works_inet_ntop="no"
3631 if test "$tst_compi_inet_ntop" = "yes" &&
3632 test "$tst_works_inet_ntop" != "no"; then
3633 AC_MSG_CHECKING([if inet_ntop usage allowed])
3634 if test "x$curl_disallow_inet_ntop" != "xyes"; then
3635 AC_MSG_RESULT([yes])
3636 tst_allow_inet_ntop="yes"
3639 tst_allow_inet_ntop="no"
3643 AC_MSG_CHECKING([if inet_ntop might be used])
3644 if test "$tst_links_inet_ntop" = "yes" &&
3645 test "$tst_proto_inet_ntop" = "yes" &&
3646 test "$tst_compi_inet_ntop" = "yes" &&
3647 test "$tst_allow_inet_ntop" = "yes" &&
3648 test "$tst_works_inet_ntop" != "no"; then
3649 AC_MSG_RESULT([yes])
3650 AC_DEFINE_UNQUOTED(HAVE_INET_NTOP, 1,
3651 [Define to 1 if you have a IPv6 capable working inet_ntop function.])
3652 ac_cv_func_inet_ntop="yes"
3655 ac_cv_func_inet_ntop="no"
3660 dnl CURL_CHECK_FUNC_INET_PTON
3661 dnl -------------------------------------------------
3662 dnl Verify if inet_pton is available, prototyped, can
3663 dnl be compiled and seems to work. If all of these are
3664 dnl true, and usage has not been previously disallowed
3665 dnl with shell variable curl_disallow_inet_pton, then
3666 dnl HAVE_INET_PTON will be defined.
3668 AC_DEFUN([CURL_CHECK_FUNC_INET_PTON], [
3669 AC_REQUIRE([CURL_INCLUDES_STDLIB])dnl
3670 AC_REQUIRE([CURL_INCLUDES_ARPA_INET])dnl
3671 AC_REQUIRE([CURL_INCLUDES_STRING])dnl
3673 tst_links_inet_pton="unknown"
3674 tst_proto_inet_pton="unknown"
3675 tst_compi_inet_pton="unknown"
3676 tst_works_inet_pton="unknown"
3677 tst_allow_inet_pton="unknown"
3679 AC_MSG_CHECKING([if inet_pton can be linked])
3681 AC_LANG_FUNC_LINK_TRY([inet_pton])
3683 AC_MSG_RESULT([yes])
3684 tst_links_inet_pton="yes"
3687 tst_links_inet_pton="no"
3690 if test "$tst_links_inet_pton" = "yes"; then
3691 AC_MSG_CHECKING([if inet_pton is prototyped])
3692 AC_EGREP_CPP([inet_pton],[
3693 $curl_includes_arpa_inet
3695 AC_MSG_RESULT([yes])
3696 tst_proto_inet_pton="yes"
3699 tst_proto_inet_pton="no"
3703 if test "$tst_proto_inet_pton" = "yes"; then
3704 AC_MSG_CHECKING([if inet_pton is compilable])
3707 $curl_includes_arpa_inet
3709 if(0 != inet_pton(0, 0, 0))
3713 AC_MSG_RESULT([yes])
3714 tst_compi_inet_pton="yes"
3717 tst_compi_inet_pton="no"
3721 dnl only do runtime verification when not cross-compiling
3722 if test "x$cross_compiling" != "xyes" &&
3723 test "$tst_compi_inet_pton" = "yes"; then
3724 AC_MSG_CHECKING([if inet_pton seems to work])
3727 $curl_includes_stdlib
3728 $curl_includes_arpa_inet
3729 $curl_includes_string
3731 unsigned char ipv6a[16+1];
3732 unsigned char ipv4a[4+1];
3733 const char *ipv6src = "fe80::214:4fff:fe0b:76c8";
3734 const char *ipv4src = "192.168.100.1";
3736 memset(ipv4a, 1, sizeof(ipv4a));
3737 if(1 != inet_pton(AF_INET, ipv4src, ipv4a))
3740 if( (ipv4a[0] != 0xc0) ||
3741 (ipv4a[1] != 0xa8) ||
3742 (ipv4a[2] != 0x64) ||
3743 (ipv4a[3] != 0x01) ||
3744 (ipv4a[4] != 0x01) )
3747 memset(ipv6a, 1, sizeof(ipv6a));
3748 if(1 != inet_pton(AF_INET6, ipv6src, ipv6a))
3751 if( (ipv6a[0] != 0xfe) ||
3752 (ipv6a[1] != 0x80) ||
3753 (ipv6a[8] != 0x02) ||
3754 (ipv6a[9] != 0x14) ||
3755 (ipv6a[10] != 0x4f) ||
3756 (ipv6a[11] != 0xff) ||
3757 (ipv6a[12] != 0xfe) ||
3758 (ipv6a[13] != 0x0b) ||
3759 (ipv6a[14] != 0x76) ||
3760 (ipv6a[15] != 0xc8) ||
3761 (ipv6a[16] != 0x01) )
3764 if( (ipv6a[2] != 0x0) ||
3765 (ipv6a[3] != 0x0) ||
3766 (ipv6a[4] != 0x0) ||
3767 (ipv6a[5] != 0x0) ||
3768 (ipv6a[6] != 0x0) ||
3775 AC_MSG_RESULT([yes])
3776 tst_works_inet_pton="yes"
3779 tst_works_inet_pton="no"
3783 if test "$tst_compi_inet_pton" = "yes" &&
3784 test "$tst_works_inet_pton" != "no"; then
3785 AC_MSG_CHECKING([if inet_pton usage allowed])
3786 if test "x$curl_disallow_inet_pton" != "xyes"; then
3787 AC_MSG_RESULT([yes])
3788 tst_allow_inet_pton="yes"
3791 tst_allow_inet_pton="no"
3795 AC_MSG_CHECKING([if inet_pton might be used])
3796 if test "$tst_links_inet_pton" = "yes" &&
3797 test "$tst_proto_inet_pton" = "yes" &&
3798 test "$tst_compi_inet_pton" = "yes" &&
3799 test "$tst_allow_inet_pton" = "yes" &&
3800 test "$tst_works_inet_pton" != "no"; then
3801 AC_MSG_RESULT([yes])
3802 AC_DEFINE_UNQUOTED(HAVE_INET_PTON, 1,
3803 [Define to 1 if you have a IPv6 capable working inet_pton function.])
3804 ac_cv_func_inet_pton="yes"
3807 ac_cv_func_inet_pton="no"
3812 dnl CURL_CHECK_FUNC_IOCTL
3813 dnl -------------------------------------------------
3814 dnl Verify if ioctl is available, prototyped, and
3815 dnl can be compiled. If all of these are true, and
3816 dnl usage has not been previously disallowed with
3817 dnl shell variable curl_disallow_ioctl, then
3818 dnl HAVE_IOCTL will be defined.
3820 AC_DEFUN([CURL_CHECK_FUNC_IOCTL], [
3821 AC_REQUIRE([CURL_INCLUDES_STROPTS])dnl
3823 tst_links_ioctl="unknown"
3824 tst_proto_ioctl="unknown"
3825 tst_compi_ioctl="unknown"
3826 tst_allow_ioctl="unknown"
3828 AC_MSG_CHECKING([if ioctl can be linked])
3830 AC_LANG_FUNC_LINK_TRY([ioctl])
3832 AC_MSG_RESULT([yes])
3833 tst_links_ioctl="yes"
3836 tst_links_ioctl="no"
3839 if test "$tst_links_ioctl" = "yes"; then
3840 AC_MSG_CHECKING([if ioctl is prototyped])
3841 AC_EGREP_CPP([ioctl],[
3842 $curl_includes_stropts
3844 AC_MSG_RESULT([yes])
3845 tst_proto_ioctl="yes"
3848 tst_proto_ioctl="no"
3852 if test "$tst_proto_ioctl" = "yes"; then
3853 AC_MSG_CHECKING([if ioctl is compilable])
3856 $curl_includes_stropts
3858 if(0 != ioctl(0, 0, 0))
3862 AC_MSG_RESULT([yes])
3863 tst_compi_ioctl="yes"
3866 tst_compi_ioctl="no"
3870 if test "$tst_compi_ioctl" = "yes"; then
3871 AC_MSG_CHECKING([if ioctl usage allowed])
3872 if test "x$curl_disallow_ioctl" != "xyes"; then
3873 AC_MSG_RESULT([yes])
3874 tst_allow_ioctl="yes"
3877 tst_allow_ioctl="no"
3881 AC_MSG_CHECKING([if ioctl might be used])
3882 if test "$tst_links_ioctl" = "yes" &&
3883 test "$tst_proto_ioctl" = "yes" &&
3884 test "$tst_compi_ioctl" = "yes" &&
3885 test "$tst_allow_ioctl" = "yes"; then
3886 AC_MSG_RESULT([yes])
3887 AC_DEFINE_UNQUOTED(HAVE_IOCTL, 1,
3888 [Define to 1 if you have the ioctl function.])
3889 ac_cv_func_ioctl="yes"
3890 CURL_CHECK_FUNC_IOCTL_FIONBIO
3891 CURL_CHECK_FUNC_IOCTL_SIOCGIFADDR
3894 ac_cv_func_ioctl="no"
3899 dnl CURL_CHECK_FUNC_IOCTL_FIONBIO
3900 dnl -------------------------------------------------
3901 dnl Verify if ioctl with the FIONBIO command is
3902 dnl available, can be compiled, and seems to work. If
3903 dnl all of these are true, then HAVE_IOCTL_FIONBIO
3904 dnl will be defined.
3906 AC_DEFUN([CURL_CHECK_FUNC_IOCTL_FIONBIO], [
3908 tst_compi_ioctl_fionbio="unknown"
3909 tst_allow_ioctl_fionbio="unknown"
3911 if test "$ac_cv_func_ioctl" = "yes"; then
3912 AC_MSG_CHECKING([if ioctl FIONBIO is compilable])
3915 $curl_includes_stropts
3918 if(0 != ioctl(0, FIONBIO, &flags))
3922 AC_MSG_RESULT([yes])
3923 tst_compi_ioctl_fionbio="yes"
3926 tst_compi_ioctl_fionbio="no"
3930 if test "$tst_compi_ioctl_fionbio" = "yes"; then
3931 AC_MSG_CHECKING([if ioctl FIONBIO usage allowed])
3932 if test "x$curl_disallow_ioctl_fionbio" != "xyes"; then
3933 AC_MSG_RESULT([yes])
3934 tst_allow_ioctl_fionbio="yes"
3937 tst_allow_ioctl_fionbio="no"
3941 AC_MSG_CHECKING([if ioctl FIONBIO might be used])
3942 if test "$tst_compi_ioctl_fionbio" = "yes" &&
3943 test "$tst_allow_ioctl_fionbio" = "yes"; then
3944 AC_MSG_RESULT([yes])
3945 AC_DEFINE_UNQUOTED(HAVE_IOCTL_FIONBIO, 1,
3946 [Define to 1 if you have a working ioctl FIONBIO function.])
3947 ac_cv_func_ioctl_fionbio="yes"
3950 ac_cv_func_ioctl_fionbio="no"
3955 dnl CURL_CHECK_FUNC_IOCTL_SIOCGIFADDR
3956 dnl -------------------------------------------------
3957 dnl Verify if ioctl with the SIOCGIFADDR command is available,
3958 dnl struct ifreq is defined, they can be compiled, and seem to
3959 dnl work. If all of these are true, then HAVE_IOCTL_SIOCGIFADDR
3960 dnl will be defined.
3962 AC_DEFUN([CURL_CHECK_FUNC_IOCTL_SIOCGIFADDR], [
3964 tst_compi_ioctl_siocgifaddr="unknown"
3965 tst_allow_ioctl_siocgifaddr="unknown"
3967 if test "$ac_cv_func_ioctl" = "yes"; then
3968 AC_MSG_CHECKING([if ioctl SIOCGIFADDR is compilable])
3971 $curl_includes_stropts
3975 if(0 != ioctl(0, SIOCGIFADDR, &ifr))
3979 AC_MSG_RESULT([yes])
3980 tst_compi_ioctl_siocgifaddr="yes"
3983 tst_compi_ioctl_siocgifaddr="no"
3987 if test "$tst_compi_ioctl_siocgifaddr" = "yes"; then
3988 AC_MSG_CHECKING([if ioctl SIOCGIFADDR usage allowed])
3989 if test "x$curl_disallow_ioctl_siocgifaddr" != "xyes"; then
3990 AC_MSG_RESULT([yes])
3991 tst_allow_ioctl_siocgifaddr="yes"
3994 tst_allow_ioctl_siocgifaddr="no"
3998 AC_MSG_CHECKING([if ioctl SIOCGIFADDR might be used])
3999 if test "$tst_compi_ioctl_siocgifaddr" = "yes" &&
4000 test "$tst_allow_ioctl_siocgifaddr" = "yes"; then
4001 AC_MSG_RESULT([yes])
4002 AC_DEFINE_UNQUOTED(HAVE_IOCTL_SIOCGIFADDR, 1,
4003 [Define to 1 if you have a working ioctl SIOCGIFADDR function.])
4004 ac_cv_func_ioctl_siocgifaddr="yes"
4007 ac_cv_func_ioctl_siocgifaddr="no"
4012 dnl CURL_CHECK_FUNC_IOCTLSOCKET
4013 dnl -------------------------------------------------
4014 dnl Verify if ioctlsocket is available, prototyped, and
4015 dnl can be compiled. If all of these are true, and
4016 dnl usage has not been previously disallowed with
4017 dnl shell variable curl_disallow_ioctlsocket, then
4018 dnl HAVE_IOCTLSOCKET will be defined.
4020 AC_DEFUN([CURL_CHECK_FUNC_IOCTLSOCKET], [
4021 AC_REQUIRE([CURL_INCLUDES_WINSOCK2])dnl
4023 tst_links_ioctlsocket="unknown"
4024 tst_proto_ioctlsocket="unknown"
4025 tst_compi_ioctlsocket="unknown"
4026 tst_allow_ioctlsocket="unknown"
4028 AC_MSG_CHECKING([if ioctlsocket can be linked])
4031 $curl_includes_winsock2
4033 if(0 != ioctlsocket(0, 0, 0))
4037 AC_MSG_RESULT([yes])
4038 tst_links_ioctlsocket="yes"
4041 tst_links_ioctlsocket="no"
4044 if test "$tst_links_ioctlsocket" = "yes"; then
4045 AC_MSG_CHECKING([if ioctlsocket is prototyped])
4046 AC_EGREP_CPP([ioctlsocket],[
4047 $curl_includes_winsock2
4049 AC_MSG_RESULT([yes])
4050 tst_proto_ioctlsocket="yes"
4053 tst_proto_ioctlsocket="no"
4057 if test "$tst_proto_ioctlsocket" = "yes"; then
4058 AC_MSG_CHECKING([if ioctlsocket is compilable])
4061 $curl_includes_winsock2
4063 if(0 != ioctlsocket(0, 0, 0))
4067 AC_MSG_RESULT([yes])
4068 tst_compi_ioctlsocket="yes"
4071 tst_compi_ioctlsocket="no"
4075 if test "$tst_compi_ioctlsocket" = "yes"; then
4076 AC_MSG_CHECKING([if ioctlsocket usage allowed])
4077 if test "x$curl_disallow_ioctlsocket" != "xyes"; then
4078 AC_MSG_RESULT([yes])
4079 tst_allow_ioctlsocket="yes"
4082 tst_allow_ioctlsocket="no"
4086 AC_MSG_CHECKING([if ioctlsocket might be used])
4087 if test "$tst_links_ioctlsocket" = "yes" &&
4088 test "$tst_proto_ioctlsocket" = "yes" &&
4089 test "$tst_compi_ioctlsocket" = "yes" &&
4090 test "$tst_allow_ioctlsocket" = "yes"; then
4091 AC_MSG_RESULT([yes])
4092 AC_DEFINE_UNQUOTED(HAVE_IOCTLSOCKET, 1,
4093 [Define to 1 if you have the ioctlsocket function.])
4094 ac_cv_func_ioctlsocket="yes"
4095 CURL_CHECK_FUNC_IOCTLSOCKET_FIONBIO
4098 ac_cv_func_ioctlsocket="no"
4103 dnl CURL_CHECK_FUNC_IOCTLSOCKET_FIONBIO
4104 dnl -------------------------------------------------
4105 dnl Verify if ioctlsocket with the FIONBIO command is
4106 dnl available, can be compiled, and seems to work. If
4107 dnl all of these are true, then HAVE_IOCTLSOCKET_FIONBIO
4108 dnl will be defined.
4110 AC_DEFUN([CURL_CHECK_FUNC_IOCTLSOCKET_FIONBIO], [
4112 tst_compi_ioctlsocket_fionbio="unknown"
4113 tst_allow_ioctlsocket_fionbio="unknown"
4115 if test "$ac_cv_func_ioctlsocket" = "yes"; then
4116 AC_MSG_CHECKING([if ioctlsocket FIONBIO is compilable])
4119 $curl_includes_winsock2
4122 if(0 != ioctlsocket(0, FIONBIO, &flags))
4126 AC_MSG_RESULT([yes])
4127 tst_compi_ioctlsocket_fionbio="yes"
4130 tst_compi_ioctlsocket_fionbio="no"
4134 if test "$tst_compi_ioctlsocket_fionbio" = "yes"; then
4135 AC_MSG_CHECKING([if ioctlsocket FIONBIO usage allowed])
4136 if test "x$curl_disallow_ioctlsocket_fionbio" != "xyes"; then
4137 AC_MSG_RESULT([yes])
4138 tst_allow_ioctlsocket_fionbio="yes"
4141 tst_allow_ioctlsocket_fionbio="no"
4145 AC_MSG_CHECKING([if ioctlsocket FIONBIO might be used])
4146 if test "$tst_compi_ioctlsocket_fionbio" = "yes" &&
4147 test "$tst_allow_ioctlsocket_fionbio" = "yes"; then
4148 AC_MSG_RESULT([yes])
4149 AC_DEFINE_UNQUOTED(HAVE_IOCTLSOCKET_FIONBIO, 1,
4150 [Define to 1 if you have a working ioctlsocket FIONBIO function.])
4151 ac_cv_func_ioctlsocket_fionbio="yes"
4154 ac_cv_func_ioctlsocket_fionbio="no"
4159 dnl CURL_CHECK_FUNC_IOCTLSOCKET_CAMEL
4160 dnl -------------------------------------------------
4161 dnl Verify if IoctlSocket is available, prototyped, and
4162 dnl can be compiled. If all of these are true, and
4163 dnl usage has not been previously disallowed with
4164 dnl shell variable curl_disallow_ioctlsocket_camel,
4165 dnl then HAVE_IOCTLSOCKET_CAMEL will be defined.
4167 AC_DEFUN([CURL_CHECK_FUNC_IOCTLSOCKET_CAMEL], [
4168 AC_REQUIRE([CURL_INCLUDES_STROPTS])dnl
4170 tst_links_ioctlsocket_camel="unknown"
4171 tst_proto_ioctlsocket_camel="unknown"
4172 tst_compi_ioctlsocket_camel="unknown"
4173 tst_allow_ioctlsocket_camel="unknown"
4175 AC_MSG_CHECKING([if IoctlSocket can be linked])
4177 AC_LANG_FUNC_LINK_TRY([IoctlSocket])
4179 AC_MSG_RESULT([yes])
4180 tst_links_ioctlsocket_camel="yes"
4183 tst_links_ioctlsocket_camel="no"
4186 if test "$tst_links_ioctlsocket_camel" = "yes"; then
4187 AC_MSG_CHECKING([if IoctlSocket is prototyped])
4188 AC_EGREP_CPP([IoctlSocket],[
4189 $curl_includes_stropts
4191 AC_MSG_RESULT([yes])
4192 tst_proto_ioctlsocket_camel="yes"
4195 tst_proto_ioctlsocket_camel="no"
4199 if test "$tst_proto_ioctlsocket_camel" = "yes"; then
4200 AC_MSG_CHECKING([if IoctlSocket is compilable])
4203 $curl_includes_stropts
4205 if(0 != IoctlSocket(0, 0, 0))
4209 AC_MSG_RESULT([yes])
4210 tst_compi_ioctlsocket_camel="yes"
4213 tst_compi_ioctlsocket_camel="no"
4217 if test "$tst_compi_ioctlsocket_camel" = "yes"; then
4218 AC_MSG_CHECKING([if IoctlSocket usage allowed])
4219 if test "x$curl_disallow_ioctlsocket_camel" != "xyes"; then
4220 AC_MSG_RESULT([yes])
4221 tst_allow_ioctlsocket_camel="yes"
4224 tst_allow_ioctlsocket_camel="no"
4228 AC_MSG_CHECKING([if IoctlSocket might be used])
4229 if test "$tst_links_ioctlsocket_camel" = "yes" &&
4230 test "$tst_proto_ioctlsocket_camel" = "yes" &&
4231 test "$tst_compi_ioctlsocket_camel" = "yes" &&
4232 test "$tst_allow_ioctlsocket_camel" = "yes"; then
4233 AC_MSG_RESULT([yes])
4234 AC_DEFINE_UNQUOTED(HAVE_IOCTLSOCKET_CAMEL, 1,
4235 [Define to 1 if you have the IoctlSocket camel case function.])
4236 ac_cv_func_ioctlsocket_camel="yes"
4237 CURL_CHECK_FUNC_IOCTLSOCKET_CAMEL_FIONBIO
4240 ac_cv_func_ioctlsocket_camel="no"
4245 dnl CURL_CHECK_FUNC_IOCTLSOCKET_CAMEL_FIONBIO
4246 dnl -------------------------------------------------
4247 dnl Verify if IoctlSocket with FIONBIO command is available,
4248 dnl can be compiled, and seems to work. If all of these are
4249 dnl true, then HAVE_IOCTLSOCKET_CAMEL_FIONBIO will be defined.
4251 AC_DEFUN([CURL_CHECK_FUNC_IOCTLSOCKET_CAMEL_FIONBIO], [
4253 tst_compi_ioctlsocket_camel_fionbio="unknown"
4254 tst_allow_ioctlsocket_camel_fionbio="unknown"
4256 if test "$ac_cv_func_ioctlsocket_camel" = "yes"; then
4257 AC_MSG_CHECKING([if IoctlSocket FIONBIO is compilable])
4260 $curl_includes_stropts
4263 if(0 != ioctlsocket(0, FIONBIO, &flags))
4267 AC_MSG_RESULT([yes])
4268 tst_compi_ioctlsocket_camel_fionbio="yes"
4271 tst_compi_ioctlsocket_camel_fionbio="no"
4275 if test "$tst_compi_ioctlsocket_camel_fionbio" = "yes"; then
4276 AC_MSG_CHECKING([if IoctlSocket FIONBIO usage allowed])
4277 if test "x$curl_disallow_ioctlsocket_camel_fionbio" != "xyes"; then
4278 AC_MSG_RESULT([yes])
4279 tst_allow_ioctlsocket_camel_fionbio="yes"
4282 tst_allow_ioctlsocket_camel_fionbio="no"
4286 AC_MSG_CHECKING([if IoctlSocket FIONBIO might be used])
4287 if test "$tst_compi_ioctlsocket_camel_fionbio" = "yes" &&
4288 test "$tst_allow_ioctlsocket_camel_fionbio" = "yes"; then
4289 AC_MSG_RESULT([yes])
4290 AC_DEFINE_UNQUOTED(HAVE_IOCTLSOCKET_CAMEL_FIONBIO, 1,
4291 [Define to 1 if you have a working IoctlSocket camel case FIONBIO function.])
4292 ac_cv_func_ioctlsocket_camel_fionbio="yes"
4295 ac_cv_func_ioctlsocket_camel_fionbio="no"
4300 dnl CURL_CHECK_FUNC_LISTXATTR
4301 dnl -------------------------------------------------
4302 dnl Verify if listxattr is available, prototyped, and
4303 dnl can be compiled. If all of these are true, and
4304 dnl usage has not been previously disallowed with
4305 dnl shell variable curl_disallow_listxattr, then
4306 dnl HAVE_LISTXATTR will be defined.
4308 AC_DEFUN([CURL_CHECK_FUNC_LISTXATTR], [
4309 AC_REQUIRE([CURL_INCLUDES_SYS_XATTR])dnl
4311 tst_links_listxattr="unknown"
4312 tst_proto_listxattr="unknown"
4313 tst_compi_listxattr="unknown"
4314 tst_allow_listxattr="unknown"
4315 tst_nargs_listxattr="unknown"
4317 AC_MSG_CHECKING([if listxattr can be linked])
4319 AC_LANG_FUNC_LINK_TRY([listxattr])
4321 AC_MSG_RESULT([yes])
4322 tst_links_listxattr="yes"
4325 tst_links_listxattr="no"
4328 if test "$tst_links_listxattr" = "yes"; then
4329 AC_MSG_CHECKING([if listxattr is prototyped])
4330 AC_EGREP_CPP([listxattr],[
4331 $curl_includes_sys_xattr
4333 AC_MSG_RESULT([yes])
4334 tst_proto_listxattr="yes"
4337 tst_proto_listxattr="no"
4341 if test "$tst_proto_listxattr" = "yes"; then
4342 if test "$tst_nargs_listxattr" = "unknown"; then
4343 AC_MSG_CHECKING([if listxattr takes 3 args.])
4346 $curl_includes_sys_xattr
4348 if(0 != listxattr(0, 0, 0))
4352 AC_MSG_RESULT([yes])
4353 tst_compi_listxattr="yes"
4354 tst_nargs_listxattr="3"
4357 tst_compi_listxattr="no"
4360 if test "$tst_nargs_listxattr" = "unknown"; then
4361 AC_MSG_CHECKING([if listxattr takes 4 args.])
4364 $curl_includes_sys_xattr
4366 if(0 != listxattr(0, 0, 0, 0))
4370 AC_MSG_RESULT([yes])
4371 tst_compi_listxattr="yes"
4372 tst_nargs_listxattr="4"
4375 tst_compi_listxattr="no"
4378 AC_MSG_CHECKING([if listxattr is compilable])
4379 if test "$tst_compi_listxattr" = "yes"; then
4380 AC_MSG_RESULT([yes])
4386 if test "$tst_compi_listxattr" = "yes"; then
4387 AC_MSG_CHECKING([if listxattr usage allowed])
4388 if test "x$curl_disallow_listxattr" != "xyes"; then
4389 AC_MSG_RESULT([yes])
4390 tst_allow_listxattr="yes"
4393 tst_allow_listxattr="no"
4397 AC_MSG_CHECKING([if listxattr might be used])
4398 if test "$tst_links_listxattr" = "yes" &&
4399 test "$tst_proto_listxattr" = "yes" &&
4400 test "$tst_compi_listxattr" = "yes" &&
4401 test "$tst_allow_listxattr" = "yes"; then
4402 AC_MSG_RESULT([yes])
4403 AC_DEFINE_UNQUOTED(HAVE_LISTXATTR, 1,
4404 [Define to 1 if you have the listxattr function.])
4405 dnl AC_DEFINE_UNQUOTED(LISTXATTR_ARGS, $tst_nargs_listxattr,
4406 dnl [Specifies the number of arguments to listxattr])
4408 if test "$tst_nargs_listxattr" -eq "3"; then
4409 AC_DEFINE(HAVE_LISTXATTR_3, 1, [listxattr() takes 3 args])
4410 elif test "$tst_nargs_listxattr" -eq "4"; then
4411 AC_DEFINE(HAVE_LISTXATTR_4, 1, [listxattr() takes 4 args])
4414 ac_cv_func_listxattr="yes"
4417 ac_cv_func_listxattr="no"
4422 dnl CURL_CHECK_FUNC_LOCALTIME_R
4423 dnl -------------------------------------------------
4424 dnl Verify if localtime_r is available, prototyped, can
4425 dnl be compiled and seems to work. If all of these are
4426 dnl true, and usage has not been previously disallowed
4427 dnl with shell variable curl_disallow_localtime_r, then
4428 dnl HAVE_LOCALTIME_R will be defined.
4430 AC_DEFUN([CURL_CHECK_FUNC_LOCALTIME_R], [
4431 AC_REQUIRE([CURL_INCLUDES_STDLIB])dnl
4432 AC_REQUIRE([CURL_INCLUDES_TIME])dnl
4434 tst_links_localtime_r="unknown"
4435 tst_proto_localtime_r="unknown"
4436 tst_compi_localtime_r="unknown"
4437 tst_works_localtime_r="unknown"
4438 tst_allow_localtime_r="unknown"
4440 AC_MSG_CHECKING([if localtime_r can be linked])
4442 AC_LANG_FUNC_LINK_TRY([localtime_r])
4444 AC_MSG_RESULT([yes])
4445 tst_links_localtime_r="yes"
4448 tst_links_localtime_r="no"
4451 if test "$tst_links_localtime_r" = "yes"; then
4452 AC_MSG_CHECKING([if localtime_r is prototyped])
4453 AC_EGREP_CPP([localtime_r],[
4456 AC_MSG_RESULT([yes])
4457 tst_proto_localtime_r="yes"
4460 tst_proto_localtime_r="no"
4464 if test "$tst_proto_localtime_r" = "yes"; then
4465 AC_MSG_CHECKING([if localtime_r is compilable])
4470 if(0 != localtime_r(0, 0))
4474 AC_MSG_RESULT([yes])
4475 tst_compi_localtime_r="yes"
4478 tst_compi_localtime_r="no"
4482 dnl only do runtime verification when not cross-compiling
4483 if test "x$cross_compiling" != "xyes" &&
4484 test "$tst_compi_localtime_r" = "yes"; then
4485 AC_MSG_CHECKING([if localtime_r seems to work])
4488 $curl_includes_stdlib
4491 time_t clock = 1170352587;
4494 tmp = localtime_r(&clock, &result);
4501 AC_MSG_RESULT([yes])
4502 tst_works_localtime_r="yes"
4505 tst_works_localtime_r="no"
4509 if test "$tst_compi_localtime_r" = "yes" &&
4510 test "$tst_works_localtime_r" != "no"; then
4511 AC_MSG_CHECKING([if localtime_r usage allowed])
4512 if test "x$curl_disallow_localtime_r" != "xyes"; then
4513 AC_MSG_RESULT([yes])
4514 tst_allow_localtime_r="yes"
4517 tst_allow_localtime_r="no"
4521 AC_MSG_CHECKING([if localtime_r might be used])
4522 if test "$tst_links_localtime_r" = "yes" &&
4523 test "$tst_proto_localtime_r" = "yes" &&
4524 test "$tst_compi_localtime_r" = "yes" &&
4525 test "$tst_allow_localtime_r" = "yes" &&
4526 test "$tst_works_localtime_r" != "no"; then
4527 AC_MSG_RESULT([yes])
4528 AC_DEFINE_UNQUOTED(HAVE_LOCALTIME_R, 1,
4529 [Define to 1 if you have a working localtime_r function.])
4530 ac_cv_func_localtime_r="yes"
4533 ac_cv_func_localtime_r="no"
4538 dnl CURL_CHECK_FUNC_MEMRCHR
4539 dnl -------------------------------------------------
4540 dnl Verify if memrchr is available, prototyped, and
4541 dnl can be compiled. If all of these are true, and
4542 dnl usage has not been previously disallowed with
4543 dnl shell variable curl_disallow_memrchr, then
4544 dnl HAVE_MEMRCHR will be defined.
4546 AC_DEFUN([CURL_CHECK_FUNC_MEMRCHR], [
4547 AC_REQUIRE([CURL_INCLUDES_STRING])dnl
4549 tst_links_memrchr="unknown"
4550 tst_macro_memrchr="unknown"
4551 tst_proto_memrchr="unknown"
4552 tst_compi_memrchr="unknown"
4553 tst_allow_memrchr="unknown"
4555 AC_MSG_CHECKING([if memrchr can be linked])
4557 AC_LANG_FUNC_LINK_TRY([memrchr])
4559 AC_MSG_RESULT([yes])
4560 tst_links_memrchr="yes"
4563 tst_links_memrchr="no"
4566 if test "$tst_links_memrchr" = "no"; then
4567 AC_MSG_CHECKING([if memrchr seems a macro])
4570 $curl_includes_string
4572 if(0 != memrchr(0, 0, 0))
4576 AC_MSG_RESULT([yes])
4577 tst_macro_memrchr="yes"
4580 tst_macro_memrchr="no"
4584 if test "$tst_links_memrchr" = "yes"; then
4585 AC_MSG_CHECKING([if memrchr is prototyped])
4586 AC_EGREP_CPP([memrchr],[
4587 $curl_includes_string
4589 AC_MSG_RESULT([yes])
4590 tst_proto_memrchr="yes"
4593 tst_proto_memrchr="no"
4597 if test "$tst_proto_memrchr" = "yes" ||
4598 test "$tst_macro_memrchr" = "yes"; then
4599 AC_MSG_CHECKING([if memrchr is compilable])
4602 $curl_includes_string
4604 if(0 != memrchr(0, 0, 0))
4608 AC_MSG_RESULT([yes])
4609 tst_compi_memrchr="yes"
4612 tst_compi_memrchr="no"
4616 if test "$tst_compi_memrchr" = "yes"; then
4617 AC_MSG_CHECKING([if memrchr usage allowed])
4618 if test "x$curl_disallow_memrchr" != "xyes"; then
4619 AC_MSG_RESULT([yes])
4620 tst_allow_memrchr="yes"
4623 tst_allow_memrchr="no"
4627 AC_MSG_CHECKING([if memrchr might be used])
4628 if (test "$tst_proto_memrchr" = "yes" ||
4629 test "$tst_macro_memrchr" = "yes") &&
4630 test "$tst_compi_memrchr" = "yes" &&
4631 test "$tst_allow_memrchr" = "yes"; then
4632 AC_MSG_RESULT([yes])
4633 AC_DEFINE_UNQUOTED(HAVE_MEMRCHR, 1,
4634 [Define to 1 if you have the memrchr function or macro.])
4635 ac_cv_func_memrchr="yes"
4638 ac_cv_func_memrchr="no"
4643 dnl CURL_CHECK_FUNC_POLL
4644 dnl -------------------------------------------------
4645 dnl Verify if poll is available, prototyped, can
4646 dnl be compiled and seems to work. If all of these are
4647 dnl true, and usage has not been previously disallowed
4648 dnl with shell variable curl_disallow_poll, then
4649 dnl HAVE_POLL will be defined.
4651 AC_DEFUN([CURL_CHECK_FUNC_POLL], [
4652 AC_REQUIRE([CURL_INCLUDES_STDLIB])dnl
4653 AC_REQUIRE([CURL_INCLUDES_POLL])dnl
4655 tst_links_poll="unknown"
4656 tst_proto_poll="unknown"
4657 tst_compi_poll="unknown"
4658 tst_works_poll="unknown"
4659 tst_allow_poll="unknown"
4663 dnl poll() does not work on these platforms
4664 dnl Interix: "does provide poll(), but the implementing developer must
4665 dnl have been in a bad mood, because poll() only works on the /proc
4666 dnl filesystem here"
4667 curl_disallow_poll="yes"
4671 AC_MSG_CHECKING([if poll can be linked])
4676 if(0 != poll(0, 0, 0))
4680 AC_MSG_RESULT([yes])
4681 tst_links_poll="yes"
4687 if test "$tst_links_poll" = "yes"; then
4688 AC_MSG_CHECKING([if poll is prototyped])
4689 AC_EGREP_CPP([poll],[
4692 AC_MSG_RESULT([yes])
4693 tst_proto_poll="yes"
4700 if test "$tst_proto_poll" = "yes"; then
4701 AC_MSG_CHECKING([if poll is compilable])
4706 if(0 != poll(0, 0, 0))
4710 AC_MSG_RESULT([yes])
4711 tst_compi_poll="yes"
4718 dnl only do runtime verification when not cross-compiling
4719 if test "x$cross_compiling" != "xyes" &&
4720 test "$tst_compi_poll" = "yes"; then
4721 AC_MSG_CHECKING([if poll seems to work])
4724 $curl_includes_stdlib
4727 if(0 != poll(0, 0, 10))
4733 AC_MSG_RESULT([yes])
4734 tst_works_poll="yes"
4741 if test "$tst_compi_poll" = "yes" &&
4742 test "$tst_works_poll" != "no"; then
4743 AC_MSG_CHECKING([if poll usage allowed])
4744 if test "x$curl_disallow_poll" != "xyes"; then
4745 AC_MSG_RESULT([yes])
4746 tst_allow_poll="yes"
4753 AC_MSG_CHECKING([if poll might be used])
4754 if test "$tst_links_poll" = "yes" &&
4755 test "$tst_proto_poll" = "yes" &&
4756 test "$tst_compi_poll" = "yes" &&
4757 test "$tst_allow_poll" = "yes" &&
4758 test "$tst_works_poll" != "no"; then
4759 AC_MSG_RESULT([yes])
4760 AC_DEFINE_UNQUOTED(HAVE_POLL, 1,
4761 [Define to 1 if you have a working poll function.])
4762 AC_DEFINE_UNQUOTED(HAVE_POLL_FINE, 1,
4763 [If you have a fine poll])
4764 ac_cv_func_poll="yes"
4767 ac_cv_func_poll="no"
4772 dnl CURL_CHECK_FUNC_REMOVEXATTR
4773 dnl -------------------------------------------------
4774 dnl Verify if removexattr is available, prototyped, and
4775 dnl can be compiled. If all of these are true, and
4776 dnl usage has not been previously disallowed with
4777 dnl shell variable curl_disallow_removexattr, then
4778 dnl HAVE_REMOVEXATTR will be defined.
4780 AC_DEFUN([CURL_CHECK_FUNC_REMOVEXATTR], [
4781 AC_REQUIRE([CURL_INCLUDES_SYS_XATTR])dnl
4783 tst_links_removexattr="unknown"
4784 tst_proto_removexattr="unknown"
4785 tst_compi_removexattr="unknown"
4786 tst_allow_removexattr="unknown"
4787 tst_nargs_removexattr="unknown"
4789 AC_MSG_CHECKING([if removexattr can be linked])
4791 AC_LANG_FUNC_LINK_TRY([removexattr])
4793 AC_MSG_RESULT([yes])
4794 tst_links_removexattr="yes"
4797 tst_links_removexattr="no"
4800 if test "$tst_links_removexattr" = "yes"; then
4801 AC_MSG_CHECKING([if removexattr is prototyped])
4802 AC_EGREP_CPP([removexattr],[
4803 $curl_includes_sys_xattr
4805 AC_MSG_RESULT([yes])
4806 tst_proto_removexattr="yes"
4809 tst_proto_removexattr="no"
4813 if test "$tst_proto_removexattr" = "yes"; then
4814 if test "$tst_nargs_removexattr" = "unknown"; then
4815 AC_MSG_CHECKING([if removexattr takes 2 args.])
4818 $curl_includes_sys_xattr
4820 if(0 != removexattr(0, 0))
4824 AC_MSG_RESULT([yes])
4825 tst_compi_removexattr="yes"
4826 tst_nargs_removexattr="2"
4829 tst_compi_removexattr="no"
4832 if test "$tst_nargs_removexattr" = "unknown"; then
4833 AC_MSG_CHECKING([if removexattr takes 3 args.])
4836 $curl_includes_sys_xattr
4838 if(0 != removexattr(0, 0, 0))
4842 AC_MSG_RESULT([yes])
4843 tst_compi_removexattr="yes"
4844 tst_nargs_removexattr="3"
4847 tst_compi_removexattr="no"
4850 AC_MSG_CHECKING([if removexattr is compilable])
4851 if test "$tst_compi_removexattr" = "yes"; then
4852 AC_MSG_RESULT([yes])
4858 if test "$tst_compi_removexattr" = "yes"; then
4859 AC_MSG_CHECKING([if removexattr usage allowed])
4860 if test "x$curl_disallow_removexattr" != "xyes"; then
4861 AC_MSG_RESULT([yes])
4862 tst_allow_removexattr="yes"
4865 tst_allow_removexattr="no"
4869 AC_MSG_CHECKING([if removexattr might be used])
4870 if test "$tst_links_removexattr" = "yes" &&
4871 test "$tst_proto_removexattr" = "yes" &&
4872 test "$tst_compi_removexattr" = "yes" &&
4873 test "$tst_allow_removexattr" = "yes"; then
4874 AC_MSG_RESULT([yes])
4875 AC_DEFINE_UNQUOTED(HAVE_REMOVEXATTR, 1,
4876 [Define to 1 if you have the removexattr function.])
4877 dnl AC_DEFINE_UNQUOTED(REMOVEXATTR_ARGS, $tst_nargs_removexattr,
4878 dnl [Specifies the number of arguments to removexattr])
4880 if test "$tst_nargs_removexattr" -eq "2"; then
4881 AC_DEFINE(HAVE_REMOVEXATTR_2, 1, [removexattr() takes 2 args])
4882 elif test "$tst_nargs_removexattr" -eq "3"; then
4883 AC_DEFINE(HAVE_REMOVEXATTR_3, 1, [removexattr() takes 3 args])
4886 ac_cv_func_removexattr="yes"
4889 ac_cv_func_removexattr="no"
4894 dnl CURL_CHECK_FUNC_SETSOCKOPT
4895 dnl -------------------------------------------------
4896 dnl Verify if setsockopt is available, prototyped, and
4897 dnl can be compiled. If all of these are true, and
4898 dnl usage has not been previously disallowed with
4899 dnl shell variable curl_disallow_setsockopt, then
4900 dnl HAVE_SETSOCKOPT will be defined.
4902 AC_DEFUN([CURL_CHECK_FUNC_SETSOCKOPT], [
4903 AC_REQUIRE([CURL_INCLUDES_WINSOCK2])dnl
4904 AC_REQUIRE([CURL_INCLUDES_SYS_SOCKET])dnl
4906 tst_links_setsockopt="unknown"
4907 tst_proto_setsockopt="unknown"
4908 tst_compi_setsockopt="unknown"
4909 tst_allow_setsockopt="unknown"
4911 AC_MSG_CHECKING([if setsockopt can be linked])
4914 $curl_includes_winsock2
4915 $curl_includes_sys_socket
4917 if(0 != setsockopt(0, 0, 0, 0, 0))
4921 AC_MSG_RESULT([yes])
4922 tst_links_setsockopt="yes"
4925 tst_links_setsockopt="no"
4928 if test "$tst_links_setsockopt" = "yes"; then
4929 AC_MSG_CHECKING([if setsockopt is prototyped])
4930 AC_EGREP_CPP([setsockopt],[
4931 $curl_includes_winsock2
4932 $curl_includes_sys_socket
4934 AC_MSG_RESULT([yes])
4935 tst_proto_setsockopt="yes"
4938 tst_proto_setsockopt="no"
4942 if test "$tst_proto_setsockopt" = "yes"; then
4943 AC_MSG_CHECKING([if setsockopt is compilable])
4946 $curl_includes_winsock2
4947 $curl_includes_sys_socket
4949 if(0 != setsockopt(0, 0, 0, 0, 0))
4953 AC_MSG_RESULT([yes])
4954 tst_compi_setsockopt="yes"
4957 tst_compi_setsockopt="no"
4961 if test "$tst_compi_setsockopt" = "yes"; then
4962 AC_MSG_CHECKING([if setsockopt usage allowed])
4963 if test "x$curl_disallow_setsockopt" != "xyes"; then
4964 AC_MSG_RESULT([yes])
4965 tst_allow_setsockopt="yes"
4968 tst_allow_setsockopt="no"
4972 AC_MSG_CHECKING([if setsockopt might be used])
4973 if test "$tst_links_setsockopt" = "yes" &&
4974 test "$tst_proto_setsockopt" = "yes" &&
4975 test "$tst_compi_setsockopt" = "yes" &&
4976 test "$tst_allow_setsockopt" = "yes"; then
4977 AC_MSG_RESULT([yes])
4978 AC_DEFINE_UNQUOTED(HAVE_SETSOCKOPT, 1,
4979 [Define to 1 if you have the setsockopt function.])
4980 ac_cv_func_setsockopt="yes"
4981 CURL_CHECK_FUNC_SETSOCKOPT_SO_NONBLOCK
4984 ac_cv_func_setsockopt="no"
4989 dnl CURL_CHECK_FUNC_SETSOCKOPT_SO_NONBLOCK
4990 dnl -------------------------------------------------
4991 dnl Verify if setsockopt with the SO_NONBLOCK command is
4992 dnl available, can be compiled, and seems to work. If
4993 dnl all of these are true, then HAVE_SETSOCKOPT_SO_NONBLOCK
4994 dnl will be defined.
4996 AC_DEFUN([CURL_CHECK_FUNC_SETSOCKOPT_SO_NONBLOCK], [
4998 tst_compi_setsockopt_so_nonblock="unknown"
4999 tst_allow_setsockopt_so_nonblock="unknown"
5001 if test "$ac_cv_func_setsockopt" = "yes"; then
5002 AC_MSG_CHECKING([if setsockopt SO_NONBLOCK is compilable])
5005 $curl_includes_winsock2
5006 $curl_includes_sys_socket
5008 if(0 != setsockopt(0, SOL_SOCKET, SO_NONBLOCK, 0, 0))
5012 AC_MSG_RESULT([yes])
5013 tst_compi_setsockopt_so_nonblock="yes"
5016 tst_compi_setsockopt_so_nonblock="no"
5020 if test "$tst_compi_setsockopt_so_nonblock" = "yes"; then
5021 AC_MSG_CHECKING([if setsockopt SO_NONBLOCK usage allowed])
5022 if test "x$curl_disallow_setsockopt_so_nonblock" != "xyes"; then
5023 AC_MSG_RESULT([yes])
5024 tst_allow_setsockopt_so_nonblock="yes"
5027 tst_allow_setsockopt_so_nonblock="no"
5031 AC_MSG_CHECKING([if setsockopt SO_NONBLOCK might be used])
5032 if test "$tst_compi_setsockopt_so_nonblock" = "yes" &&
5033 test "$tst_allow_setsockopt_so_nonblock" = "yes"; then
5034 AC_MSG_RESULT([yes])
5035 AC_DEFINE_UNQUOTED(HAVE_SETSOCKOPT_SO_NONBLOCK, 1,
5036 [Define to 1 if you have a working setsockopt SO_NONBLOCK function.])
5037 ac_cv_func_setsockopt_so_nonblock="yes"
5040 ac_cv_func_setsockopt_so_nonblock="no"
5045 dnl CURL_CHECK_FUNC_SETXATTR
5046 dnl -------------------------------------------------
5047 dnl Verify if setxattr is available, prototyped, and
5048 dnl can be compiled. If all of these are true, and
5049 dnl usage has not been previously disallowed with
5050 dnl shell variable curl_disallow_setxattr, then
5051 dnl HAVE_SETXATTR will be defined.
5053 AC_DEFUN([CURL_CHECK_FUNC_SETXATTR], [
5054 AC_REQUIRE([CURL_INCLUDES_SYS_XATTR])dnl
5056 tst_links_setxattr="unknown"
5057 tst_proto_setxattr="unknown"
5058 tst_compi_setxattr="unknown"
5059 tst_allow_setxattr="unknown"
5060 tst_nargs_setxattr="unknown"
5062 AC_MSG_CHECKING([if setxattr can be linked])
5064 AC_LANG_FUNC_LINK_TRY([setxattr])
5066 AC_MSG_RESULT([yes])
5067 tst_links_setxattr="yes"
5070 tst_links_setxattr="no"
5073 if test "$tst_links_setxattr" = "yes"; then
5074 AC_MSG_CHECKING([if setxattr is prototyped])
5075 AC_EGREP_CPP([setxattr],[
5076 $curl_includes_sys_xattr
5078 AC_MSG_RESULT([yes])
5079 tst_proto_setxattr="yes"
5082 tst_proto_setxattr="no"
5086 if test "$tst_proto_setxattr" = "yes"; then
5087 if test "$tst_nargs_setxattr" = "unknown"; then
5088 AC_MSG_CHECKING([if setxattr takes 5 args.])
5091 $curl_includes_sys_xattr
5093 if(0 != setxattr(0, 0, 0, 0, 0))
5097 AC_MSG_RESULT([yes])
5098 tst_compi_setxattr="yes"
5099 tst_nargs_setxattr="5"
5102 tst_compi_setxattr="no"
5105 if test "$tst_nargs_setxattr" = "unknown"; then
5106 AC_MSG_CHECKING([if setxattr takes 6 args.])
5109 $curl_includes_sys_xattr
5111 if(0 != setxattr(0, 0, 0, 0, 0, 0))
5115 AC_MSG_RESULT([yes])
5116 tst_compi_setxattr="yes"
5117 tst_nargs_setxattr="6"
5120 tst_compi_setxattr="no"
5123 AC_MSG_CHECKING([if setxattr is compilable])
5124 if test "$tst_compi_setxattr" = "yes"; then
5125 AC_MSG_RESULT([yes])
5131 if test "$tst_compi_setxattr" = "yes"; then
5132 AC_MSG_CHECKING([if setxattr usage allowed])
5133 if test "x$curl_disallow_setxattr" != "xyes"; then
5134 AC_MSG_RESULT([yes])
5135 tst_allow_setxattr="yes"
5138 tst_allow_setxattr="no"
5142 AC_MSG_CHECKING([if setxattr might be used])
5143 if test "$tst_links_setxattr" = "yes" &&
5144 test "$tst_proto_setxattr" = "yes" &&
5145 test "$tst_compi_setxattr" = "yes" &&
5146 test "$tst_allow_setxattr" = "yes"; then
5147 AC_MSG_RESULT([yes])
5148 AC_DEFINE_UNQUOTED(HAVE_SETXATTR, 1,
5149 [Define to 1 if you have the setxattr function.])
5150 dnl AC_DEFINE_UNQUOTED(SETXATTR_ARGS, $tst_nargs_setxattr,
5151 dnl [Specifies the number of arguments to setxattr])
5153 if test "$tst_nargs_setxattr" -eq "5"; then
5154 AC_DEFINE(HAVE_SETXATTR_5, 1, [setxattr() takes 5 args])
5155 elif test "$tst_nargs_setxattr" -eq "6"; then
5156 AC_DEFINE(HAVE_SETXATTR_6, 1, [setxattr() takes 6 args])
5159 ac_cv_func_setxattr="yes"
5162 ac_cv_func_setxattr="no"
5167 dnl CURL_CHECK_FUNC_SIGACTION
5168 dnl -------------------------------------------------
5169 dnl Verify if sigaction is available, prototyped, and
5170 dnl can be compiled. If all of these are true, and
5171 dnl usage has not been previously disallowed with
5172 dnl shell variable curl_disallow_sigaction, then
5173 dnl HAVE_SIGACTION will be defined.
5175 AC_DEFUN([CURL_CHECK_FUNC_SIGACTION], [
5176 AC_REQUIRE([CURL_INCLUDES_SIGNAL])dnl
5178 tst_links_sigaction="unknown"
5179 tst_proto_sigaction="unknown"
5180 tst_compi_sigaction="unknown"
5181 tst_allow_sigaction="unknown"
5183 AC_MSG_CHECKING([if sigaction can be linked])
5185 AC_LANG_FUNC_LINK_TRY([sigaction])
5187 AC_MSG_RESULT([yes])
5188 tst_links_sigaction="yes"
5191 tst_links_sigaction="no"
5194 if test "$tst_links_sigaction" = "yes"; then
5195 AC_MSG_CHECKING([if sigaction is prototyped])
5196 AC_EGREP_CPP([sigaction],[
5197 $curl_includes_signal
5199 AC_MSG_RESULT([yes])
5200 tst_proto_sigaction="yes"
5203 tst_proto_sigaction="no"
5207 if test "$tst_proto_sigaction" = "yes"; then
5208 AC_MSG_CHECKING([if sigaction is compilable])
5211 $curl_includes_signal
5213 if(0 != sigaction(0, 0, 0))
5217 AC_MSG_RESULT([yes])
5218 tst_compi_sigaction="yes"
5221 tst_compi_sigaction="no"
5225 if test "$tst_compi_sigaction" = "yes"; then
5226 AC_MSG_CHECKING([if sigaction usage allowed])
5227 if test "x$curl_disallow_sigaction" != "xyes"; then
5228 AC_MSG_RESULT([yes])
5229 tst_allow_sigaction="yes"
5232 tst_allow_sigaction="no"
5236 AC_MSG_CHECKING([if sigaction might be used])
5237 if test "$tst_links_sigaction" = "yes" &&
5238 test "$tst_proto_sigaction" = "yes" &&
5239 test "$tst_compi_sigaction" = "yes" &&
5240 test "$tst_allow_sigaction" = "yes"; then
5241 AC_MSG_RESULT([yes])
5242 AC_DEFINE_UNQUOTED(HAVE_SIGACTION, 1,
5243 [Define to 1 if you have the sigaction function.])
5244 ac_cv_func_sigaction="yes"
5247 ac_cv_func_sigaction="no"
5252 dnl CURL_CHECK_FUNC_SIGINTERRUPT
5253 dnl -------------------------------------------------
5254 dnl Verify if siginterrupt is available, prototyped, and
5255 dnl can be compiled. If all of these are true, and
5256 dnl usage has not been previously disallowed with
5257 dnl shell variable curl_disallow_siginterrupt, then
5258 dnl HAVE_SIGINTERRUPT will be defined.
5260 AC_DEFUN([CURL_CHECK_FUNC_SIGINTERRUPT], [
5261 AC_REQUIRE([CURL_INCLUDES_SIGNAL])dnl
5263 tst_links_siginterrupt="unknown"
5264 tst_proto_siginterrupt="unknown"
5265 tst_compi_siginterrupt="unknown"
5266 tst_allow_siginterrupt="unknown"
5268 AC_MSG_CHECKING([if siginterrupt can be linked])
5270 AC_LANG_FUNC_LINK_TRY([siginterrupt])
5272 AC_MSG_RESULT([yes])
5273 tst_links_siginterrupt="yes"
5276 tst_links_siginterrupt="no"
5279 if test "$tst_links_siginterrupt" = "yes"; then
5280 AC_MSG_CHECKING([if siginterrupt is prototyped])
5281 AC_EGREP_CPP([siginterrupt],[
5282 $curl_includes_signal
5284 AC_MSG_RESULT([yes])
5285 tst_proto_siginterrupt="yes"
5288 tst_proto_siginterrupt="no"
5292 if test "$tst_proto_siginterrupt" = "yes"; then
5293 AC_MSG_CHECKING([if siginterrupt is compilable])
5296 $curl_includes_signal
5298 if(0 != siginterrupt(0, 0))
5302 AC_MSG_RESULT([yes])
5303 tst_compi_siginterrupt="yes"
5306 tst_compi_siginterrupt="no"
5310 if test "$tst_compi_siginterrupt" = "yes"; then
5311 AC_MSG_CHECKING([if siginterrupt usage allowed])
5312 if test "x$curl_disallow_siginterrupt" != "xyes"; then
5313 AC_MSG_RESULT([yes])
5314 tst_allow_siginterrupt="yes"
5317 tst_allow_siginterrupt="no"
5321 AC_MSG_CHECKING([if siginterrupt might be used])
5322 if test "$tst_links_siginterrupt" = "yes" &&
5323 test "$tst_proto_siginterrupt" = "yes" &&
5324 test "$tst_compi_siginterrupt" = "yes" &&
5325 test "$tst_allow_siginterrupt" = "yes"; then
5326 AC_MSG_RESULT([yes])
5327 AC_DEFINE_UNQUOTED(HAVE_SIGINTERRUPT, 1,
5328 [Define to 1 if you have the siginterrupt function.])
5329 ac_cv_func_siginterrupt="yes"
5332 ac_cv_func_siginterrupt="no"
5337 dnl CURL_CHECK_FUNC_SIGNAL
5338 dnl -------------------------------------------------
5339 dnl Verify if signal is available, prototyped, and
5340 dnl can be compiled. If all of these are true, and
5341 dnl usage has not been previously disallowed with
5342 dnl shell variable curl_disallow_signal, then
5343 dnl HAVE_SIGNAL will be defined.
5345 AC_DEFUN([CURL_CHECK_FUNC_SIGNAL], [
5346 AC_REQUIRE([CURL_INCLUDES_SIGNAL])dnl
5348 tst_links_signal="unknown"
5349 tst_proto_signal="unknown"
5350 tst_compi_signal="unknown"
5351 tst_allow_signal="unknown"
5353 AC_MSG_CHECKING([if signal can be linked])
5355 AC_LANG_FUNC_LINK_TRY([signal])
5357 AC_MSG_RESULT([yes])
5358 tst_links_signal="yes"
5361 tst_links_signal="no"
5364 if test "$tst_links_signal" = "yes"; then
5365 AC_MSG_CHECKING([if signal is prototyped])
5366 AC_EGREP_CPP([signal],[
5367 $curl_includes_signal
5369 AC_MSG_RESULT([yes])
5370 tst_proto_signal="yes"
5373 tst_proto_signal="no"
5377 if test "$tst_proto_signal" = "yes"; then
5378 AC_MSG_CHECKING([if signal is compilable])
5381 $curl_includes_signal
5383 if(0 != signal(0, 0))
5387 AC_MSG_RESULT([yes])
5388 tst_compi_signal="yes"
5391 tst_compi_signal="no"
5395 if test "$tst_compi_signal" = "yes"; then
5396 AC_MSG_CHECKING([if signal usage allowed])
5397 if test "x$curl_disallow_signal" != "xyes"; then
5398 AC_MSG_RESULT([yes])
5399 tst_allow_signal="yes"
5402 tst_allow_signal="no"
5406 AC_MSG_CHECKING([if signal might be used])
5407 if test "$tst_links_signal" = "yes" &&
5408 test "$tst_proto_signal" = "yes" &&
5409 test "$tst_compi_signal" = "yes" &&
5410 test "$tst_allow_signal" = "yes"; then
5411 AC_MSG_RESULT([yes])
5412 AC_DEFINE_UNQUOTED(HAVE_SIGNAL, 1,
5413 [Define to 1 if you have the signal function.])
5414 ac_cv_func_signal="yes"
5417 ac_cv_func_signal="no"
5422 dnl CURL_CHECK_FUNC_SIGSETJMP
5423 dnl -------------------------------------------------
5424 dnl Verify if sigsetjmp is available, prototyped, and
5425 dnl can be compiled. If all of these are true, and
5426 dnl usage has not been previously disallowed with
5427 dnl shell variable curl_disallow_sigsetjmp, then
5428 dnl HAVE_SIGSETJMP will be defined.
5430 AC_DEFUN([CURL_CHECK_FUNC_SIGSETJMP], [
5431 AC_REQUIRE([CURL_INCLUDES_SETJMP])dnl
5433 tst_links_sigsetjmp="unknown"
5434 tst_macro_sigsetjmp="unknown"
5435 tst_proto_sigsetjmp="unknown"
5436 tst_compi_sigsetjmp="unknown"
5437 tst_allow_sigsetjmp="unknown"
5439 AC_MSG_CHECKING([if sigsetjmp can be linked])
5441 AC_LANG_FUNC_LINK_TRY([sigsetjmp])
5443 AC_MSG_RESULT([yes])
5444 tst_links_sigsetjmp="yes"
5447 tst_links_sigsetjmp="no"
5450 if test "$tst_links_sigsetjmp" = "no"; then
5451 AC_MSG_CHECKING([if sigsetjmp seems a macro])
5454 $curl_includes_setjmp
5457 if(0 != sigsetjmp(env, 0))
5461 AC_MSG_RESULT([yes])
5462 tst_macro_sigsetjmp="yes"
5465 tst_macro_sigsetjmp="no"
5469 if test "$tst_links_sigsetjmp" = "yes"; then
5470 AC_MSG_CHECKING([if sigsetjmp is prototyped])
5471 AC_EGREP_CPP([sigsetjmp],[
5472 $curl_includes_setjmp
5474 AC_MSG_RESULT([yes])
5475 tst_proto_sigsetjmp="yes"
5478 tst_proto_sigsetjmp="no"
5482 if test "$tst_proto_sigsetjmp" = "yes" ||
5483 test "$tst_macro_sigsetjmp" = "yes"; then
5484 AC_MSG_CHECKING([if sigsetjmp is compilable])
5487 $curl_includes_setjmp
5490 if(0 != sigsetjmp(env, 0))
5494 AC_MSG_RESULT([yes])
5495 tst_compi_sigsetjmp="yes"
5498 tst_compi_sigsetjmp="no"
5502 if test "$tst_compi_sigsetjmp" = "yes"; then
5503 AC_MSG_CHECKING([if sigsetjmp usage allowed])
5504 if test "x$curl_disallow_sigsetjmp" != "xyes"; then
5505 AC_MSG_RESULT([yes])
5506 tst_allow_sigsetjmp="yes"
5509 tst_allow_sigsetjmp="no"
5513 AC_MSG_CHECKING([if sigsetjmp might be used])
5514 if (test "$tst_proto_sigsetjmp" = "yes" ||
5515 test "$tst_macro_sigsetjmp" = "yes") &&
5516 test "$tst_compi_sigsetjmp" = "yes" &&
5517 test "$tst_allow_sigsetjmp" = "yes"; then
5518 AC_MSG_RESULT([yes])
5519 AC_DEFINE_UNQUOTED(HAVE_SIGSETJMP, 1,
5520 [Define to 1 if you have the sigsetjmp function or macro.])
5521 ac_cv_func_sigsetjmp="yes"
5524 ac_cv_func_sigsetjmp="no"
5529 dnl CURL_CHECK_FUNC_SOCKET
5530 dnl -------------------------------------------------
5531 dnl Verify if socket is available, prototyped, and
5532 dnl can be compiled. If all of these are true, and
5533 dnl usage has not been previously disallowed with
5534 dnl shell variable curl_disallow_socket, then
5535 dnl HAVE_SOCKET will be defined.
5537 AC_DEFUN([CURL_CHECK_FUNC_SOCKET], [
5538 AC_REQUIRE([CURL_INCLUDES_WINSOCK2])dnl
5539 AC_REQUIRE([CURL_INCLUDES_SYS_SOCKET])dnl
5540 AC_REQUIRE([CURL_INCLUDES_SOCKET])dnl
5542 tst_links_socket="unknown"
5543 tst_proto_socket="unknown"
5544 tst_compi_socket="unknown"
5545 tst_allow_socket="unknown"
5547 AC_MSG_CHECKING([if socket can be linked])
5550 $curl_includes_winsock2
5551 $curl_includes_sys_socket
5552 $curl_includes_socket
5554 if(0 != socket(0, 0, 0))
5558 AC_MSG_RESULT([yes])
5559 tst_links_socket="yes"
5562 tst_links_socket="no"
5565 if test "$tst_links_socket" = "yes"; then
5566 AC_MSG_CHECKING([if socket is prototyped])
5567 AC_EGREP_CPP([socket],[
5568 $curl_includes_winsock2
5569 $curl_includes_sys_socket
5570 $curl_includes_socket
5572 AC_MSG_RESULT([yes])
5573 tst_proto_socket="yes"
5576 tst_proto_socket="no"
5580 if test "$tst_proto_socket" = "yes"; then
5581 AC_MSG_CHECKING([if socket is compilable])
5584 $curl_includes_winsock2
5585 $curl_includes_sys_socket
5586 $curl_includes_socket
5588 if(0 != socket(0, 0, 0))
5592 AC_MSG_RESULT([yes])
5593 tst_compi_socket="yes"
5596 tst_compi_socket="no"
5600 if test "$tst_compi_socket" = "yes"; then
5601 AC_MSG_CHECKING([if socket usage allowed])
5602 if test "x$curl_disallow_socket" != "xyes"; then
5603 AC_MSG_RESULT([yes])
5604 tst_allow_socket="yes"
5607 tst_allow_socket="no"
5611 AC_MSG_CHECKING([if socket might be used])
5612 if test "$tst_links_socket" = "yes" &&
5613 test "$tst_proto_socket" = "yes" &&
5614 test "$tst_compi_socket" = "yes" &&
5615 test "$tst_allow_socket" = "yes"; then
5616 AC_MSG_RESULT([yes])
5617 AC_DEFINE_UNQUOTED(HAVE_SOCKET, 1,
5618 [Define to 1 if you have the socket function.])
5619 ac_cv_func_socket="yes"
5622 ac_cv_func_socket="no"
5627 dnl CURL_CHECK_FUNC_SOCKETPAIR
5628 dnl -------------------------------------------------
5629 dnl Verify if socketpair is available, prototyped, and
5630 dnl can be compiled. If all of these are true, and
5631 dnl usage has not been previously disallowed with
5632 dnl shell variable curl_disallow_socketpair, then
5633 dnl HAVE_SOCKETPAIR will be defined.
5635 AC_DEFUN([CURL_CHECK_FUNC_SOCKETPAIR], [
5636 AC_REQUIRE([CURL_INCLUDES_SYS_SOCKET])dnl
5637 AC_REQUIRE([CURL_INCLUDES_SOCKET])dnl
5639 tst_links_socketpair="unknown"
5640 tst_proto_socketpair="unknown"
5641 tst_compi_socketpair="unknown"
5642 tst_allow_socketpair="unknown"
5644 AC_MSG_CHECKING([if socketpair can be linked])
5646 AC_LANG_FUNC_LINK_TRY([socketpair])
5648 AC_MSG_RESULT([yes])
5649 tst_links_socketpair="yes"
5652 tst_links_socketpair="no"
5655 if test "$tst_links_socketpair" = "yes"; then
5656 AC_MSG_CHECKING([if socketpair is prototyped])
5657 AC_EGREP_CPP([socketpair],[
5658 $curl_includes_sys_socket
5659 $curl_includes_socket
5661 AC_MSG_RESULT([yes])
5662 tst_proto_socketpair="yes"
5665 tst_proto_socketpair="no"
5669 if test "$tst_proto_socketpair" = "yes"; then
5670 AC_MSG_CHECKING([if socketpair is compilable])
5673 $curl_includes_sys_socket
5674 $curl_includes_socket
5677 if(0 != socketpair(0, 0, 0, sv))
5681 AC_MSG_RESULT([yes])
5682 tst_compi_socketpair="yes"
5685 tst_compi_socketpair="no"
5689 if test "$tst_compi_socketpair" = "yes"; then
5690 AC_MSG_CHECKING([if socketpair usage allowed])
5691 if test "x$curl_disallow_socketpair" != "xyes"; then
5692 AC_MSG_RESULT([yes])
5693 tst_allow_socketpair="yes"
5696 tst_allow_socketpair="no"
5700 AC_MSG_CHECKING([if socketpair might be used])
5701 if test "$tst_links_socketpair" = "yes" &&
5702 test "$tst_proto_socketpair" = "yes" &&
5703 test "$tst_compi_socketpair" = "yes" &&
5704 test "$tst_allow_socketpair" = "yes"; then
5705 AC_MSG_RESULT([yes])
5706 AC_DEFINE_UNQUOTED(HAVE_SOCKETPAIR, 1,
5707 [Define to 1 if you have the socketpair function.])
5708 ac_cv_func_socketpair="yes"
5711 ac_cv_func_socketpair="no"
5716 dnl CURL_CHECK_FUNC_STRCASECMP
5717 dnl -------------------------------------------------
5718 dnl Verify if strcasecmp is available, prototyped, and
5719 dnl can be compiled. If all of these are true, and
5720 dnl usage has not been previously disallowed with
5721 dnl shell variable curl_disallow_strcasecmp, then
5722 dnl HAVE_STRCASECMP will be defined.
5724 AC_DEFUN([CURL_CHECK_FUNC_STRCASECMP], [
5725 AC_REQUIRE([CURL_INCLUDES_STRING])dnl
5727 tst_links_strcasecmp="unknown"
5728 tst_proto_strcasecmp="unknown"
5729 tst_compi_strcasecmp="unknown"
5730 tst_allow_strcasecmp="unknown"
5732 AC_MSG_CHECKING([if strcasecmp can be linked])
5734 AC_LANG_FUNC_LINK_TRY([strcasecmp])
5736 AC_MSG_RESULT([yes])
5737 tst_links_strcasecmp="yes"
5740 tst_links_strcasecmp="no"
5743 if test "$tst_links_strcasecmp" = "yes"; then
5744 AC_MSG_CHECKING([if strcasecmp is prototyped])
5745 AC_EGREP_CPP([strcasecmp],[
5746 $curl_includes_string
5748 AC_MSG_RESULT([yes])
5749 tst_proto_strcasecmp="yes"
5752 tst_proto_strcasecmp="no"
5756 if test "$tst_proto_strcasecmp" = "yes"; then
5757 AC_MSG_CHECKING([if strcasecmp is compilable])
5760 $curl_includes_string
5762 if(0 != strcasecmp(0, 0))
5766 AC_MSG_RESULT([yes])
5767 tst_compi_strcasecmp="yes"
5770 tst_compi_strcasecmp="no"
5774 if test "$tst_compi_strcasecmp" = "yes"; then
5775 AC_MSG_CHECKING([if strcasecmp usage allowed])
5776 if test "x$curl_disallow_strcasecmp" != "xyes"; then
5777 AC_MSG_RESULT([yes])
5778 tst_allow_strcasecmp="yes"
5781 tst_allow_strcasecmp="no"
5785 AC_MSG_CHECKING([if strcasecmp might be used])
5786 if test "$tst_links_strcasecmp" = "yes" &&
5787 test "$tst_proto_strcasecmp" = "yes" &&
5788 test "$tst_compi_strcasecmp" = "yes" &&
5789 test "$tst_allow_strcasecmp" = "yes"; then
5790 AC_MSG_RESULT([yes])
5791 AC_DEFINE_UNQUOTED(HAVE_STRCASECMP, 1,
5792 [Define to 1 if you have the strcasecmp function.])
5793 ac_cv_func_strcasecmp="yes"
5796 ac_cv_func_strcasecmp="no"
5801 dnl CURL_CHECK_FUNC_STRCASESTR
5802 dnl -------------------------------------------------
5803 dnl Verify if strcasestr is available, prototyped, and
5804 dnl can be compiled. If all of these are true, and
5805 dnl usage has not been previously disallowed with
5806 dnl shell variable curl_disallow_strcasestr, then
5807 dnl HAVE_STRCASESTR will be defined.
5809 AC_DEFUN([CURL_CHECK_FUNC_STRCASESTR], [
5810 AC_REQUIRE([CURL_INCLUDES_STRING])dnl
5812 tst_links_strcasestr="unknown"
5813 tst_proto_strcasestr="unknown"
5814 tst_compi_strcasestr="unknown"
5815 tst_allow_strcasestr="unknown"
5817 AC_MSG_CHECKING([if strcasestr can be linked])
5819 AC_LANG_FUNC_LINK_TRY([strcasestr])
5821 AC_MSG_RESULT([yes])
5822 tst_links_strcasestr="yes"
5825 tst_links_strcasestr="no"
5828 if test "$tst_links_strcasestr" = "yes"; then
5829 AC_MSG_CHECKING([if strcasestr is prototyped])
5830 AC_EGREP_CPP([strcasestr],[
5831 $curl_includes_string
5833 AC_MSG_RESULT([yes])
5834 tst_proto_strcasestr="yes"
5837 tst_proto_strcasestr="no"
5841 if test "$tst_proto_strcasestr" = "yes"; then
5842 AC_MSG_CHECKING([if strcasestr is compilable])
5845 $curl_includes_string
5847 if(0 != strcasestr(0, 0))
5851 AC_MSG_RESULT([yes])
5852 tst_compi_strcasestr="yes"
5855 tst_compi_strcasestr="no"
5859 if test "$tst_compi_strcasestr" = "yes"; then
5860 AC_MSG_CHECKING([if strcasestr usage allowed])
5861 if test "x$curl_disallow_strcasestr" != "xyes"; then
5862 AC_MSG_RESULT([yes])
5863 tst_allow_strcasestr="yes"
5866 tst_allow_strcasestr="no"
5870 AC_MSG_CHECKING([if strcasestr might be used])
5871 if test "$tst_links_strcasestr" = "yes" &&
5872 test "$tst_proto_strcasestr" = "yes" &&
5873 test "$tst_compi_strcasestr" = "yes" &&
5874 test "$tst_allow_strcasestr" = "yes"; then
5875 AC_MSG_RESULT([yes])
5876 AC_DEFINE_UNQUOTED(HAVE_STRCASESTR, 1,
5877 [Define to 1 if you have the strcasestr function.])
5878 ac_cv_func_strcasestr="yes"
5881 ac_cv_func_strcasestr="no"
5886 dnl CURL_CHECK_FUNC_STRCMPI
5887 dnl -------------------------------------------------
5888 dnl Verify if strcmpi is available, prototyped, and
5889 dnl can be compiled. If all of these are true, and
5890 dnl usage has not been previously disallowed with
5891 dnl shell variable curl_disallow_strcmpi, then
5892 dnl HAVE_STRCMPI will be defined.
5894 AC_DEFUN([CURL_CHECK_FUNC_STRCMPI], [
5895 AC_REQUIRE([CURL_INCLUDES_STRING])dnl
5897 tst_links_strcmpi="unknown"
5898 tst_proto_strcmpi="unknown"
5899 tst_compi_strcmpi="unknown"
5900 tst_allow_strcmpi="unknown"
5902 AC_MSG_CHECKING([if strcmpi can be linked])
5904 AC_LANG_FUNC_LINK_TRY([strcmpi])
5906 AC_MSG_RESULT([yes])
5907 tst_links_strcmpi="yes"
5910 tst_links_strcmpi="no"
5913 if test "$tst_links_strcmpi" = "yes"; then
5914 AC_MSG_CHECKING([if strcmpi is prototyped])
5915 AC_EGREP_CPP([strcmpi],[
5916 $curl_includes_string
5918 AC_MSG_RESULT([yes])
5919 tst_proto_strcmpi="yes"
5922 tst_proto_strcmpi="no"
5926 if test "$tst_proto_strcmpi" = "yes"; then
5927 AC_MSG_CHECKING([if strcmpi is compilable])
5930 $curl_includes_string
5932 if(0 != strcmpi(0, 0))
5936 AC_MSG_RESULT([yes])
5937 tst_compi_strcmpi="yes"
5940 tst_compi_strcmpi="no"
5944 if test "$tst_compi_strcmpi" = "yes"; then
5945 AC_MSG_CHECKING([if strcmpi usage allowed])
5946 if test "x$curl_disallow_strcmpi" != "xyes"; then
5947 AC_MSG_RESULT([yes])
5948 tst_allow_strcmpi="yes"
5951 tst_allow_strcmpi="no"
5955 AC_MSG_CHECKING([if strcmpi might be used])
5956 if test "$tst_links_strcmpi" = "yes" &&
5957 test "$tst_proto_strcmpi" = "yes" &&
5958 test "$tst_compi_strcmpi" = "yes" &&
5959 test "$tst_allow_strcmpi" = "yes"; then
5960 AC_MSG_RESULT([yes])
5961 AC_DEFINE_UNQUOTED(HAVE_STRCMPI, 1,
5962 [Define to 1 if you have the strcmpi function.])
5963 ac_cv_func_strcmpi="yes"
5966 ac_cv_func_strcmpi="no"
5971 dnl CURL_CHECK_FUNC_STRDUP
5972 dnl -------------------------------------------------
5973 dnl Verify if strdup is available, prototyped, and
5974 dnl can be compiled. If all of these are true, and
5975 dnl usage has not been previously disallowed with
5976 dnl shell variable curl_disallow_strdup, then
5977 dnl HAVE_STRDUP will be defined.
5979 AC_DEFUN([CURL_CHECK_FUNC_STRDUP], [
5980 AC_REQUIRE([CURL_INCLUDES_STRING])dnl
5982 tst_links_strdup="unknown"
5983 tst_proto_strdup="unknown"
5984 tst_compi_strdup="unknown"
5985 tst_allow_strdup="unknown"
5987 AC_MSG_CHECKING([if strdup can be linked])
5989 AC_LANG_FUNC_LINK_TRY([strdup])
5991 AC_MSG_RESULT([yes])
5992 tst_links_strdup="yes"
5995 tst_links_strdup="no"
5998 if test "$tst_links_strdup" = "yes"; then
5999 AC_MSG_CHECKING([if strdup is prototyped])
6000 AC_EGREP_CPP([strdup],[
6001 $curl_includes_string
6003 AC_MSG_RESULT([yes])
6004 tst_proto_strdup="yes"
6007 tst_proto_strdup="no"
6011 if test "$tst_proto_strdup" = "yes"; then
6012 AC_MSG_CHECKING([if strdup is compilable])
6015 $curl_includes_string
6021 AC_MSG_RESULT([yes])
6022 tst_compi_strdup="yes"
6025 tst_compi_strdup="no"
6029 if test "$tst_compi_strdup" = "yes"; then
6030 AC_MSG_CHECKING([if strdup usage allowed])
6031 if test "x$curl_disallow_strdup" != "xyes"; then
6032 AC_MSG_RESULT([yes])
6033 tst_allow_strdup="yes"
6036 tst_allow_strdup="no"
6040 AC_MSG_CHECKING([if strdup might be used])
6041 if test "$tst_links_strdup" = "yes" &&
6042 test "$tst_proto_strdup" = "yes" &&
6043 test "$tst_compi_strdup" = "yes" &&
6044 test "$tst_allow_strdup" = "yes"; then
6045 AC_MSG_RESULT([yes])
6046 AC_DEFINE_UNQUOTED(HAVE_STRDUP, 1,
6047 [Define to 1 if you have the strdup function.])
6048 ac_cv_func_strdup="yes"
6051 ac_cv_func_strdup="no"
6056 dnl CURL_CHECK_FUNC_STRERROR_R
6057 dnl -------------------------------------------------
6058 dnl Verify if strerror_r is available, prototyped, can be compiled and
6059 dnl seems to work. If all of these are true, and usage has not been
6060 dnl previously disallowed with shell variable curl_disallow_strerror_r,
6061 dnl then HAVE_STRERROR_R and STRERROR_R_TYPE_ARG3 will be defined, as
6062 dnl well as one of HAVE_GLIBC_STRERROR_R or HAVE_POSIX_STRERROR_R.
6064 dnl glibc-style strerror_r:
6066 dnl char *strerror_r(int errnum, char *workbuf, size_t bufsize);
6068 dnl glibc-style strerror_r returns a pointer to the the error string,
6069 dnl and might use the provided workbuf as a scratch area if needed. A
6070 dnl quick test on a few systems shows that it's usually not used at all.
6072 dnl POSIX-style strerror_r:
6074 dnl int strerror_r(int errnum, char *resultbuf, size_t bufsize);
6076 dnl POSIX-style strerror_r returns 0 upon successful completion and the
6077 dnl error string in the provided resultbuf.
6080 AC_DEFUN([CURL_CHECK_FUNC_STRERROR_R], [
6081 AC_REQUIRE([CURL_INCLUDES_STDLIB])dnl
6082 AC_REQUIRE([CURL_INCLUDES_STRING])dnl
6084 tst_links_strerror_r="unknown"
6085 tst_proto_strerror_r="unknown"
6086 tst_compi_strerror_r="unknown"
6087 tst_glibc_strerror_r="unknown"
6088 tst_posix_strerror_r="unknown"
6089 tst_allow_strerror_r="unknown"
6090 tst_works_glibc_strerror_r="unknown"
6091 tst_works_posix_strerror_r="unknown"
6092 tst_glibc_strerror_r_type_arg3="unknown"
6093 tst_posix_strerror_r_type_arg3="unknown"
6095 AC_MSG_CHECKING([if strerror_r can be linked])
6097 AC_LANG_FUNC_LINK_TRY([strerror_r])
6099 AC_MSG_RESULT([yes])
6100 tst_links_strerror_r="yes"
6103 tst_links_strerror_r="no"
6106 if test "$tst_links_strerror_r" = "yes"; then
6107 AC_MSG_CHECKING([if strerror_r is prototyped])
6108 AC_EGREP_CPP([strerror_r],[
6109 $curl_includes_string
6111 AC_MSG_RESULT([yes])
6112 tst_proto_strerror_r="yes"
6115 tst_proto_strerror_r="no"
6119 if test "$tst_proto_strerror_r" = "yes"; then
6120 AC_MSG_CHECKING([if strerror_r is compilable])
6123 $curl_includes_string
6125 if(0 != strerror_r(0, 0, 0))
6129 AC_MSG_RESULT([yes])
6130 tst_compi_strerror_r="yes"
6133 tst_compi_strerror_r="no"
6137 if test "$tst_compi_strerror_r" = "yes"; then
6138 AC_MSG_CHECKING([if strerror_r is glibc like])
6139 tst_glibc_strerror_r_type_arg3="unknown"
6140 for arg3 in 'size_t' 'int' 'unsigned int'; do
6141 if test "$tst_glibc_strerror_r_type_arg3" = "unknown"; then
6144 $curl_includes_string
6146 char *strerror_r(int errnum, char *workbuf, $arg3 bufsize);
6147 if(0 != strerror_r(0, 0, 0))
6151 tst_glibc_strerror_r_type_arg3="$arg3"
6155 case "$tst_glibc_strerror_r_type_arg3" in
6158 tst_glibc_strerror_r="no"
6161 AC_MSG_RESULT([yes])
6162 tst_glibc_strerror_r="yes"
6167 dnl only do runtime verification when not cross-compiling
6168 if test "x$cross_compiling" != "xyes" &&
6169 test "$tst_glibc_strerror_r" = "yes"; then
6170 AC_MSG_CHECKING([if strerror_r seems to work])
6173 $curl_includes_stdlib
6174 $curl_includes_string
6180 string = strerror_r(EACCES, buffer, sizeof(buffer));
6189 AC_MSG_RESULT([yes])
6190 tst_works_glibc_strerror_r="yes"
6193 tst_works_glibc_strerror_r="no"
6197 if test "$tst_compi_strerror_r" = "yes" &&
6198 test "$tst_works_glibc_strerror_r" != "yes"; then
6199 AC_MSG_CHECKING([if strerror_r is POSIX like])
6200 tst_posix_strerror_r_type_arg3="unknown"
6201 for arg3 in 'size_t' 'int' 'unsigned int'; do
6202 if test "$tst_posix_strerror_r_type_arg3" = "unknown"; then
6205 $curl_includes_string
6207 int strerror_r(int errnum, char *resultbuf, $arg3 bufsize);
6208 if(0 != strerror_r(0, 0, 0))
6212 tst_posix_strerror_r_type_arg3="$arg3"
6216 case "$tst_posix_strerror_r_type_arg3" in
6219 tst_posix_strerror_r="no"
6222 AC_MSG_RESULT([yes])
6223 tst_posix_strerror_r="yes"
6228 dnl only do runtime verification when not cross-compiling
6229 if test "x$cross_compiling" != "xyes" &&
6230 test "$tst_posix_strerror_r" = "yes"; then
6231 AC_MSG_CHECKING([if strerror_r seems to work])
6234 $curl_includes_stdlib
6235 $curl_includes_string
6241 error = strerror_r(EACCES, buffer, sizeof(buffer));
6244 if(buffer[0] == '\0')
6250 AC_MSG_RESULT([yes])
6251 tst_works_posix_strerror_r="yes"
6254 tst_works_posix_strerror_r="no"
6258 if test "$tst_works_glibc_strerror_r" = "yes"; then
6259 tst_posix_strerror_r="no"
6261 if test "$tst_works_posix_strerror_r" = "yes"; then
6262 tst_glibc_strerror_r="no"
6264 if test "$tst_glibc_strerror_r" = "yes" &&
6265 test "$tst_works_glibc_strerror_r" != "no" &&
6266 test "$tst_posix_strerror_r" != "yes"; then
6267 tst_allow_strerror_r="check"
6269 if test "$tst_posix_strerror_r" = "yes" &&
6270 test "$tst_works_posix_strerror_r" != "no" &&
6271 test "$tst_glibc_strerror_r" != "yes"; then
6272 tst_allow_strerror_r="check"
6274 if test "$tst_allow_strerror_r" = "check"; then
6275 AC_MSG_CHECKING([if strerror_r usage allowed])
6276 if test "x$curl_disallow_strerror_r" != "xyes"; then
6277 AC_MSG_RESULT([yes])
6278 tst_allow_strerror_r="yes"
6281 tst_allow_strerror_r="no"
6285 AC_MSG_CHECKING([if strerror_r might be used])
6286 if test "$tst_links_strerror_r" = "yes" &&
6287 test "$tst_proto_strerror_r" = "yes" &&
6288 test "$tst_compi_strerror_r" = "yes" &&
6289 test "$tst_allow_strerror_r" = "yes"; then
6290 AC_MSG_RESULT([yes])
6291 if test "$tst_glibc_strerror_r" = "yes"; then
6292 AC_DEFINE_UNQUOTED(HAVE_STRERROR_R, 1,
6293 [Define to 1 if you have the strerror_r function.])
6294 AC_DEFINE_UNQUOTED(HAVE_GLIBC_STRERROR_R, 1,
6295 [Define to 1 if you have a working glibc-style strerror_r function.])
6296 AC_DEFINE_UNQUOTED(STRERROR_R_TYPE_ARG3, $tst_glibc_strerror_r_type_arg3,
6297 [Define to the type of arg 3 for strerror_r.])
6299 if test "$tst_posix_strerror_r" = "yes"; then
6300 AC_DEFINE_UNQUOTED(HAVE_STRERROR_R, 1,
6301 [Define to 1 if you have the strerror_r function.])
6302 AC_DEFINE_UNQUOTED(HAVE_POSIX_STRERROR_R, 1,
6303 [Define to 1 if you have a working POSIX-style strerror_r function.])
6304 AC_DEFINE_UNQUOTED(STRERROR_R_TYPE_ARG3, $tst_posix_strerror_r_type_arg3,
6305 [Define to the type of arg 3 for strerror_r.])
6307 ac_cv_func_strerror_r="yes"
6310 ac_cv_func_strerror_r="no"
6313 if test "$tst_compi_strerror_r" = "yes" &&
6314 test "$tst_allow_strerror_r" = "unknown"; then
6315 AC_MSG_WARN([cannot determine strerror_r() style: edit lib/curl_config.h manually.])
6321 dnl CURL_CHECK_FUNC_STRICMP
6322 dnl -------------------------------------------------
6323 dnl Verify if stricmp is available, prototyped, and
6324 dnl can be compiled. If all of these are true, and
6325 dnl usage has not been previously disallowed with
6326 dnl shell variable curl_disallow_stricmp, then
6327 dnl HAVE_STRICMP will be defined.
6329 AC_DEFUN([CURL_CHECK_FUNC_STRICMP], [
6330 AC_REQUIRE([CURL_INCLUDES_STRING])dnl
6332 tst_links_stricmp="unknown"
6333 tst_proto_stricmp="unknown"
6334 tst_compi_stricmp="unknown"
6335 tst_allow_stricmp="unknown"
6337 AC_MSG_CHECKING([if stricmp can be linked])
6339 AC_LANG_FUNC_LINK_TRY([stricmp])
6341 AC_MSG_RESULT([yes])
6342 tst_links_stricmp="yes"
6345 tst_links_stricmp="no"
6348 if test "$tst_links_stricmp" = "yes"; then
6349 AC_MSG_CHECKING([if stricmp is prototyped])
6350 AC_EGREP_CPP([stricmp],[
6351 $curl_includes_string
6353 AC_MSG_RESULT([yes])
6354 tst_proto_stricmp="yes"
6357 tst_proto_stricmp="no"
6361 if test "$tst_proto_stricmp" = "yes"; then
6362 AC_MSG_CHECKING([if stricmp is compilable])
6365 $curl_includes_string
6367 if(0 != stricmp(0, 0))
6371 AC_MSG_RESULT([yes])
6372 tst_compi_stricmp="yes"
6375 tst_compi_stricmp="no"
6379 if test "$tst_compi_stricmp" = "yes"; then
6380 AC_MSG_CHECKING([if stricmp usage allowed])
6381 if test "x$curl_disallow_stricmp" != "xyes"; then
6382 AC_MSG_RESULT([yes])
6383 tst_allow_stricmp="yes"
6386 tst_allow_stricmp="no"
6390 AC_MSG_CHECKING([if stricmp might be used])
6391 if test "$tst_links_stricmp" = "yes" &&
6392 test "$tst_proto_stricmp" = "yes" &&
6393 test "$tst_compi_stricmp" = "yes" &&
6394 test "$tst_allow_stricmp" = "yes"; then
6395 AC_MSG_RESULT([yes])
6396 AC_DEFINE_UNQUOTED(HAVE_STRICMP, 1,
6397 [Define to 1 if you have the stricmp function.])
6398 ac_cv_func_stricmp="yes"
6401 ac_cv_func_stricmp="no"
6406 dnl CURL_CHECK_FUNC_STRLCAT
6407 dnl -------------------------------------------------
6408 dnl Verify if strlcat is available, prototyped, and
6409 dnl can be compiled. If all of these are true, and
6410 dnl usage has not been previously disallowed with
6411 dnl shell variable curl_disallow_strlcat, then
6412 dnl HAVE_STRLCAT will be defined.
6414 AC_DEFUN([CURL_CHECK_FUNC_STRLCAT], [
6415 AC_REQUIRE([CURL_INCLUDES_STRING])dnl
6417 tst_links_strlcat="unknown"
6418 tst_proto_strlcat="unknown"
6419 tst_compi_strlcat="unknown"
6420 tst_allow_strlcat="unknown"
6422 AC_MSG_CHECKING([if strlcat can be linked])
6424 AC_LANG_FUNC_LINK_TRY([strlcat])
6426 AC_MSG_RESULT([yes])
6427 tst_links_strlcat="yes"
6430 tst_links_strlcat="no"
6433 if test "$tst_links_strlcat" = "yes"; then
6434 AC_MSG_CHECKING([if strlcat is prototyped])
6435 AC_EGREP_CPP([strlcat],[
6436 $curl_includes_string
6438 AC_MSG_RESULT([yes])
6439 tst_proto_strlcat="yes"
6442 tst_proto_strlcat="no"
6446 if test "$tst_proto_strlcat" = "yes"; then
6447 AC_MSG_CHECKING([if strlcat is compilable])
6450 $curl_includes_string
6452 if(0 != strlcat(0, 0, 0))
6456 AC_MSG_RESULT([yes])
6457 tst_compi_strlcat="yes"
6460 tst_compi_strlcat="no"
6464 if test "$tst_compi_strlcat" = "yes"; then
6465 AC_MSG_CHECKING([if strlcat usage allowed])
6466 if test "x$curl_disallow_strlcat" != "xyes"; then
6467 AC_MSG_RESULT([yes])
6468 tst_allow_strlcat="yes"
6471 tst_allow_strlcat="no"
6475 AC_MSG_CHECKING([if strlcat might be used])
6476 if test "$tst_links_strlcat" = "yes" &&
6477 test "$tst_proto_strlcat" = "yes" &&
6478 test "$tst_compi_strlcat" = "yes" &&
6479 test "$tst_allow_strlcat" = "yes"; then
6480 AC_MSG_RESULT([yes])
6481 AC_DEFINE_UNQUOTED(HAVE_STRLCAT, 1,
6482 [Define to 1 if you have the strlcat function.])
6483 ac_cv_func_strlcat="yes"
6486 ac_cv_func_strlcat="no"
6491 dnl CURL_CHECK_FUNC_STRNCASECMP
6492 dnl -------------------------------------------------
6493 dnl Verify if strncasecmp is available, prototyped, and
6494 dnl can be compiled. If all of these are true, and
6495 dnl usage has not been previously disallowed with
6496 dnl shell variable curl_disallow_strncasecmp, then
6497 dnl HAVE_STRNCASECMP will be defined.
6499 AC_DEFUN([CURL_CHECK_FUNC_STRNCASECMP], [
6500 AC_REQUIRE([CURL_INCLUDES_STRING])dnl
6502 tst_links_strncasecmp="unknown"
6503 tst_proto_strncasecmp="unknown"
6504 tst_compi_strncasecmp="unknown"
6505 tst_allow_strncasecmp="unknown"
6507 AC_MSG_CHECKING([if strncasecmp can be linked])
6509 AC_LANG_FUNC_LINK_TRY([strncasecmp])
6511 AC_MSG_RESULT([yes])
6512 tst_links_strncasecmp="yes"
6515 tst_links_strncasecmp="no"
6518 if test "$tst_links_strncasecmp" = "yes"; then
6519 AC_MSG_CHECKING([if strncasecmp is prototyped])
6520 AC_EGREP_CPP([strncasecmp],[
6521 $curl_includes_string
6523 AC_MSG_RESULT([yes])
6524 tst_proto_strncasecmp="yes"
6527 tst_proto_strncasecmp="no"
6531 if test "$tst_proto_strncasecmp" = "yes"; then
6532 AC_MSG_CHECKING([if strncasecmp is compilable])
6535 $curl_includes_string
6537 if(0 != strncasecmp(0, 0, 0))
6541 AC_MSG_RESULT([yes])
6542 tst_compi_strncasecmp="yes"
6545 tst_compi_strncasecmp="no"
6549 if test "$tst_compi_strncasecmp" = "yes"; then
6550 AC_MSG_CHECKING([if strncasecmp usage allowed])
6551 if test "x$curl_disallow_strncasecmp" != "xyes"; then
6552 AC_MSG_RESULT([yes])
6553 tst_allow_strncasecmp="yes"
6556 tst_allow_strncasecmp="no"
6560 AC_MSG_CHECKING([if strncasecmp might be used])
6561 if test "$tst_links_strncasecmp" = "yes" &&
6562 test "$tst_proto_strncasecmp" = "yes" &&
6563 test "$tst_compi_strncasecmp" = "yes" &&
6564 test "$tst_allow_strncasecmp" = "yes"; then
6565 AC_MSG_RESULT([yes])
6566 AC_DEFINE_UNQUOTED(HAVE_STRNCASECMP, 1,
6567 [Define to 1 if you have the strncasecmp function.])
6568 ac_cv_func_strncasecmp="yes"
6571 ac_cv_func_strncasecmp="no"
6576 dnl CURL_CHECK_FUNC_STRNCMPI
6577 dnl -------------------------------------------------
6578 dnl Verify if strncmpi is available, prototyped, and
6579 dnl can be compiled. If all of these are true, and
6580 dnl usage has not been previously disallowed with
6581 dnl shell variable curl_disallow_strncmpi, then
6582 dnl HAVE_STRNCMPI will be defined.
6584 AC_DEFUN([CURL_CHECK_FUNC_STRNCMPI], [
6585 AC_REQUIRE([CURL_INCLUDES_STRING])dnl
6587 tst_links_strncmpi="unknown"
6588 tst_proto_strncmpi="unknown"
6589 tst_compi_strncmpi="unknown"
6590 tst_allow_strncmpi="unknown"
6592 AC_MSG_CHECKING([if strncmpi can be linked])
6594 AC_LANG_FUNC_LINK_TRY([strncmpi])
6596 AC_MSG_RESULT([yes])
6597 tst_links_strncmpi="yes"
6600 tst_links_strncmpi="no"
6603 if test "$tst_links_strncmpi" = "yes"; then
6604 AC_MSG_CHECKING([if strncmpi is prototyped])
6605 AC_EGREP_CPP([strncmpi],[
6606 $curl_includes_string
6608 AC_MSG_RESULT([yes])
6609 tst_proto_strncmpi="yes"
6612 tst_proto_strncmpi="no"
6616 if test "$tst_proto_strncmpi" = "yes"; then
6617 AC_MSG_CHECKING([if strncmpi is compilable])
6620 $curl_includes_string
6622 if(0 != strncmpi(0, 0))
6626 AC_MSG_RESULT([yes])
6627 tst_compi_strncmpi="yes"
6630 tst_compi_strncmpi="no"
6634 if test "$tst_compi_strncmpi" = "yes"; then
6635 AC_MSG_CHECKING([if strncmpi usage allowed])
6636 if test "x$curl_disallow_strncmpi" != "xyes"; then
6637 AC_MSG_RESULT([yes])
6638 tst_allow_strncmpi="yes"
6641 tst_allow_strncmpi="no"
6645 AC_MSG_CHECKING([if strncmpi might be used])
6646 if test "$tst_links_strncmpi" = "yes" &&
6647 test "$tst_proto_strncmpi" = "yes" &&
6648 test "$tst_compi_strncmpi" = "yes" &&
6649 test "$tst_allow_strncmpi" = "yes"; then
6650 AC_MSG_RESULT([yes])
6651 AC_DEFINE_UNQUOTED(HAVE_STRNCMPI, 1,
6652 [Define to 1 if you have the strncmpi function.])
6653 ac_cv_func_strncmpi="yes"
6656 ac_cv_func_strncmpi="no"
6661 dnl CURL_CHECK_FUNC_STRNICMP
6662 dnl -------------------------------------------------
6663 dnl Verify if strnicmp is available, prototyped, and
6664 dnl can be compiled. If all of these are true, and
6665 dnl usage has not been previously disallowed with
6666 dnl shell variable curl_disallow_strnicmp, then
6667 dnl HAVE_STRNICMP will be defined.
6669 AC_DEFUN([CURL_CHECK_FUNC_STRNICMP], [
6670 AC_REQUIRE([CURL_INCLUDES_STRING])dnl
6672 tst_links_strnicmp="unknown"
6673 tst_proto_strnicmp="unknown"
6674 tst_compi_strnicmp="unknown"
6675 tst_allow_strnicmp="unknown"
6677 AC_MSG_CHECKING([if strnicmp can be linked])
6679 AC_LANG_FUNC_LINK_TRY([strnicmp])
6681 AC_MSG_RESULT([yes])
6682 tst_links_strnicmp="yes"
6685 tst_links_strnicmp="no"
6688 if test "$tst_links_strnicmp" = "yes"; then
6689 AC_MSG_CHECKING([if strnicmp is prototyped])
6690 AC_EGREP_CPP([strnicmp],[
6691 $curl_includes_string
6693 AC_MSG_RESULT([yes])
6694 tst_proto_strnicmp="yes"
6697 tst_proto_strnicmp="no"
6701 if test "$tst_proto_strnicmp" = "yes"; then
6702 AC_MSG_CHECKING([if strnicmp is compilable])
6705 $curl_includes_string
6707 if(0 != strnicmp(0, 0))
6711 AC_MSG_RESULT([yes])
6712 tst_compi_strnicmp="yes"
6715 tst_compi_strnicmp="no"
6719 if test "$tst_compi_strnicmp" = "yes"; then
6720 AC_MSG_CHECKING([if strnicmp usage allowed])
6721 if test "x$curl_disallow_strnicmp" != "xyes"; then
6722 AC_MSG_RESULT([yes])
6723 tst_allow_strnicmp="yes"
6726 tst_allow_strnicmp="no"
6730 AC_MSG_CHECKING([if strnicmp might be used])
6731 if test "$tst_links_strnicmp" = "yes" &&
6732 test "$tst_proto_strnicmp" = "yes" &&
6733 test "$tst_compi_strnicmp" = "yes" &&
6734 test "$tst_allow_strnicmp" = "yes"; then
6735 AC_MSG_RESULT([yes])
6736 AC_DEFINE_UNQUOTED(HAVE_STRNICMP, 1,
6737 [Define to 1 if you have the strnicmp function.])
6738 ac_cv_func_strnicmp="yes"
6741 ac_cv_func_strnicmp="no"
6746 dnl CURL_CHECK_FUNC_STRSTR
6747 dnl -------------------------------------------------
6748 dnl Verify if strstr is available, prototyped, and
6749 dnl can be compiled. If all of these are true, and
6750 dnl usage has not been previously disallowed with
6751 dnl shell variable curl_disallow_strstr, then
6752 dnl HAVE_STRSTR will be defined.
6754 AC_DEFUN([CURL_CHECK_FUNC_STRSTR], [
6755 AC_REQUIRE([CURL_INCLUDES_STRING])dnl
6757 tst_links_strstr="unknown"
6758 tst_proto_strstr="unknown"
6759 tst_compi_strstr="unknown"
6760 tst_allow_strstr="unknown"
6762 AC_MSG_CHECKING([if strstr can be linked])
6764 AC_LANG_FUNC_LINK_TRY([strstr])
6766 AC_MSG_RESULT([yes])
6767 tst_links_strstr="yes"
6770 tst_links_strstr="no"
6773 if test "$tst_links_strstr" = "yes"; then
6774 AC_MSG_CHECKING([if strstr is prototyped])
6775 AC_EGREP_CPP([strstr],[
6776 $curl_includes_string
6778 AC_MSG_RESULT([yes])
6779 tst_proto_strstr="yes"
6782 tst_proto_strstr="no"
6786 if test "$tst_proto_strstr" = "yes"; then
6787 AC_MSG_CHECKING([if strstr is compilable])
6790 $curl_includes_string
6792 if(0 != strstr(0, 0))
6796 AC_MSG_RESULT([yes])
6797 tst_compi_strstr="yes"
6800 tst_compi_strstr="no"
6804 if test "$tst_compi_strstr" = "yes"; then
6805 AC_MSG_CHECKING([if strstr usage allowed])
6806 if test "x$curl_disallow_strstr" != "xyes"; then
6807 AC_MSG_RESULT([yes])
6808 tst_allow_strstr="yes"
6811 tst_allow_strstr="no"
6815 AC_MSG_CHECKING([if strstr might be used])
6816 if test "$tst_links_strstr" = "yes" &&
6817 test "$tst_proto_strstr" = "yes" &&
6818 test "$tst_compi_strstr" = "yes" &&
6819 test "$tst_allow_strstr" = "yes"; then
6820 AC_MSG_RESULT([yes])
6821 AC_DEFINE_UNQUOTED(HAVE_STRSTR, 1,
6822 [Define to 1 if you have the strstr function.])
6823 ac_cv_func_strstr="yes"
6826 ac_cv_func_strstr="no"
6831 dnl CURL_CHECK_FUNC_STRTOK_R
6832 dnl -------------------------------------------------
6833 dnl Verify if strtok_r is available, prototyped, and
6834 dnl can be compiled. If all of these are true, and
6835 dnl usage has not been previously disallowed with
6836 dnl shell variable curl_disallow_strtok_r, then
6837 dnl HAVE_STRTOK_R will be defined.
6839 AC_DEFUN([CURL_CHECK_FUNC_STRTOK_R], [
6840 AC_REQUIRE([CURL_INCLUDES_STRING])dnl
6842 tst_links_strtok_r="unknown"
6843 tst_proto_strtok_r="unknown"
6844 tst_compi_strtok_r="unknown"
6845 tst_allow_strtok_r="unknown"
6847 AC_MSG_CHECKING([if strtok_r can be linked])
6849 AC_LANG_FUNC_LINK_TRY([strtok_r])
6851 AC_MSG_RESULT([yes])
6852 tst_links_strtok_r="yes"
6855 tst_links_strtok_r="no"
6858 if test "$tst_links_strtok_r" = "yes"; then
6859 AC_MSG_CHECKING([if strtok_r is prototyped])
6860 AC_EGREP_CPP([strtok_r],[
6861 $curl_includes_string
6863 AC_MSG_RESULT([yes])
6864 tst_proto_strtok_r="yes"
6867 tst_proto_strtok_r="no"
6871 if test "$tst_proto_strtok_r" = "yes"; then
6872 AC_MSG_CHECKING([if strtok_r is compilable])
6875 $curl_includes_string
6877 if(0 != strtok_r(0, 0, 0))
6881 AC_MSG_RESULT([yes])
6882 tst_compi_strtok_r="yes"
6885 tst_compi_strtok_r="no"
6889 if test "$tst_compi_strtok_r" = "yes"; then
6890 AC_MSG_CHECKING([if strtok_r usage allowed])
6891 if test "x$curl_disallow_strtok_r" != "xyes"; then
6892 AC_MSG_RESULT([yes])
6893 tst_allow_strtok_r="yes"
6896 tst_allow_strtok_r="no"
6900 AC_MSG_CHECKING([if strtok_r might be used])
6901 if test "$tst_links_strtok_r" = "yes" &&
6902 test "$tst_proto_strtok_r" = "yes" &&
6903 test "$tst_compi_strtok_r" = "yes" &&
6904 test "$tst_allow_strtok_r" = "yes"; then
6905 AC_MSG_RESULT([yes])
6906 AC_DEFINE_UNQUOTED(HAVE_STRTOK_R, 1,
6907 [Define to 1 if you have the strtok_r function.])
6908 ac_cv_func_strtok_r="yes"
6911 ac_cv_func_strtok_r="no"
6916 dnl CURL_CHECK_FUNC_STRTOLL
6917 dnl -------------------------------------------------
6918 dnl Verify if strtoll is available, prototyped, and
6919 dnl can be compiled. If all of these are true, and
6920 dnl usage has not been previously disallowed with
6921 dnl shell variable curl_disallow_strtoll, then
6922 dnl HAVE_STRTOLL will be defined.
6924 AC_DEFUN([CURL_CHECK_FUNC_STRTOLL], [
6925 AC_REQUIRE([CURL_INCLUDES_STDLIB])dnl
6927 tst_links_strtoll="unknown"
6928 tst_proto_strtoll="unknown"
6929 tst_compi_strtoll="unknown"
6930 tst_allow_strtoll="unknown"
6932 AC_MSG_CHECKING([if strtoll can be linked])
6934 AC_LANG_FUNC_LINK_TRY([strtoll])
6936 AC_MSG_RESULT([yes])
6937 tst_links_strtoll="yes"
6940 tst_links_strtoll="no"
6943 if test "$tst_links_strtoll" = "yes"; then
6944 AC_MSG_CHECKING([if strtoll is prototyped])
6945 AC_EGREP_CPP([strtoll],[
6946 $curl_includes_stdlib
6948 AC_MSG_RESULT([yes])
6949 tst_proto_strtoll="yes"
6952 tst_proto_strtoll="no"
6956 if test "$tst_proto_strtoll" = "yes"; then
6957 AC_MSG_CHECKING([if strtoll is compilable])
6960 $curl_includes_stdlib
6962 if(0 != strtoll(0, 0, 0))
6966 AC_MSG_RESULT([yes])
6967 tst_compi_strtoll="yes"
6970 tst_compi_strtoll="no"
6974 if test "$tst_compi_strtoll" = "yes"; then
6975 AC_MSG_CHECKING([if strtoll usage allowed])
6976 if test "x$curl_disallow_strtoll" != "xyes"; then
6977 AC_MSG_RESULT([yes])
6978 tst_allow_strtoll="yes"
6981 tst_allow_strtoll="no"
6985 AC_MSG_CHECKING([if strtoll might be used])
6986 if test "$tst_links_strtoll" = "yes" &&
6987 test "$tst_proto_strtoll" = "yes" &&
6988 test "$tst_compi_strtoll" = "yes" &&
6989 test "$tst_allow_strtoll" = "yes"; then
6990 AC_MSG_RESULT([yes])
6991 AC_DEFINE_UNQUOTED(HAVE_STRTOLL, 1,
6992 [Define to 1 if you have the strtoll function.])
6993 ac_cv_func_strtoll="yes"
6996 ac_cv_func_strtoll="no"
7001 dnl CURL_CHECK_FUNC_WRITEV
7002 dnl -------------------------------------------------
7003 dnl Verify if writev is available, prototyped, and
7004 dnl can be compiled. If all of these are true, and
7005 dnl usage has not been previously disallowed with
7006 dnl shell variable curl_disallow_writev, then
7007 dnl HAVE_WRITEV will be defined.
7009 AC_DEFUN([CURL_CHECK_FUNC_WRITEV], [
7010 AC_REQUIRE([CURL_INCLUDES_SYS_UIO])dnl
7012 tst_links_writev="unknown"
7013 tst_proto_writev="unknown"
7014 tst_compi_writev="unknown"
7015 tst_allow_writev="unknown"
7017 AC_MSG_CHECKING([if writev can be linked])
7019 AC_LANG_FUNC_LINK_TRY([writev])
7021 AC_MSG_RESULT([yes])
7022 tst_links_writev="yes"
7025 tst_links_writev="no"
7028 if test "$tst_links_writev" = "yes"; then
7029 AC_MSG_CHECKING([if writev is prototyped])
7030 AC_EGREP_CPP([writev],[
7031 $curl_includes_sys_uio
7033 AC_MSG_RESULT([yes])
7034 tst_proto_writev="yes"
7037 tst_proto_writev="no"
7041 if test "$tst_proto_writev" = "yes"; then
7042 AC_MSG_CHECKING([if writev is compilable])
7045 $curl_includes_sys_uio
7047 if(0 != writev(0, 0, 0))
7051 AC_MSG_RESULT([yes])
7052 tst_compi_writev="yes"
7055 tst_compi_writev="no"
7059 if test "$tst_compi_writev" = "yes"; then
7060 AC_MSG_CHECKING([if writev usage allowed])
7061 if test "x$curl_disallow_writev" != "xyes"; then
7062 AC_MSG_RESULT([yes])
7063 tst_allow_writev="yes"
7066 tst_allow_writev="no"
7070 AC_MSG_CHECKING([if writev might be used])
7071 if test "$tst_links_writev" = "yes" &&
7072 test "$tst_proto_writev" = "yes" &&
7073 test "$tst_compi_writev" = "yes" &&
7074 test "$tst_allow_writev" = "yes"; then
7075 AC_MSG_RESULT([yes])
7076 AC_DEFINE_UNQUOTED(HAVE_WRITEV, 1,
7077 [Define to 1 if you have the writev function.])
7078 ac_cv_func_writev="yes"
7081 ac_cv_func_writev="no"