Mercurial > hgrepos > Python2 > PyMuPDF

comparison mupdf-source/thirdparty/curl/m4/curl-functions.m4 @ 2:b50eed0cc0ef upstream

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
ADD: MuPDF v1.26.7: the MuPDF source as downloaded by a default build of PyMuPDF 1.26.4. The directory name has changed: no version number in the expanded directory now.
author Franz Glasner <fzglas.hg@dom66.de>
date Mon, 15 Sep 2025 11:43:07 +0200
parents
children
comparison
equal deleted inserted replaced
1:1d09e1dec1d9 2:b50eed0cc0ef
1 #***************************************************************************
2 # _ _ ____ _
3 # Project ___| | | | _ \| |
4 # / __| | | | |_) | |
5 # | (__| |_| | _ <| |___
6 # \___|\___/|_| \_\_____|
7 #
8 # Copyright (C) 1998 - 2019, Daniel Stenberg, <daniel@haxx.se>, et al.
9 #
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 https://curl.haxx.se/docs/copyright.html.
13 #
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.
17 #
18 # This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
19 # KIND, either express or implied.
20 #
21 #***************************************************************************
22
23 # File version for 'aclocal' use. Keep it a single number.
24 # serial 73
25
26
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.
31
32 AC_DEFUN([CURL_INCLUDES_ARPA_INET], [
33 curl_includes_arpa_inet="\
34 /* includes start */
35 #ifdef HAVE_SYS_TYPES_H
36 # include <sys/types.h>
37 #endif
38 #ifdef HAVE_SYS_SOCKET_H
39 # include <sys/socket.h>
40 #endif
41 #ifdef HAVE_NETINET_IN_H
42 # include <netinet/in.h>
43 #endif
44 #ifdef HAVE_ARPA_INET_H
45 # include <arpa/inet.h>
46 #endif
47 #ifdef HAVE_WINSOCK2_H
48 #include <winsock2.h>
49 #include <ws2tcpip.h>
50 #endif
51 /* includes end */"
52 AC_CHECK_HEADERS(
53 sys/types.h sys/socket.h netinet/in.h arpa/inet.h,
54 [], [], [$curl_includes_arpa_inet])
55 ])
56
57
58 dnl CURL_INCLUDES_FCNTL
59 dnl -------------------------------------------------
60 dnl Set up variable with list of headers that must be
61 dnl included when fcntl.h is to be included.
62
63 AC_DEFUN([CURL_INCLUDES_FCNTL], [
64 curl_includes_fcntl="\
65 /* includes start */
66 #ifdef HAVE_SYS_TYPES_H
67 # include <sys/types.h>
68 #endif
69 #ifdef HAVE_UNISTD_H
70 # include <unistd.h>
71 #endif
72 #ifdef HAVE_FCNTL_H
73 # include <fcntl.h>
74 #endif
75 /* includes end */"
76 AC_CHECK_HEADERS(
77 sys/types.h unistd.h fcntl.h,
78 [], [], [$curl_includes_fcntl])
79 ])
80
81
82 dnl CURL_INCLUDES_IFADDRS
83 dnl -------------------------------------------------
84 dnl Set up variable with list of headers that must be
85 dnl included when ifaddrs.h is to be included.
86
87 AC_DEFUN([CURL_INCLUDES_IFADDRS], [
88 curl_includes_ifaddrs="\
89 /* includes start */
90 #ifdef HAVE_SYS_TYPES_H
91 # include <sys/types.h>
92 #endif
93 #ifdef HAVE_SYS_SOCKET_H
94 # include <sys/socket.h>
95 #endif
96 #ifdef HAVE_NETINET_IN_H
97 # include <netinet/in.h>
98 #endif
99 #ifdef HAVE_IFADDRS_H
100 # include <ifaddrs.h>
101 #endif
102 /* includes end */"
103 AC_CHECK_HEADERS(
104 sys/types.h sys/socket.h netinet/in.h ifaddrs.h,
105 [], [], [$curl_includes_ifaddrs])
106 ])
107
108
109 dnl CURL_INCLUDES_INTTYPES
110 dnl -------------------------------------------------
111 dnl Set up variable with list of headers that must be
112 dnl included when inttypes.h is to be included.
113
114 AC_DEFUN([CURL_INCLUDES_INTTYPES], [
115 curl_includes_inttypes="\
116 /* includes start */
117 #ifdef HAVE_SYS_TYPES_H
118 # include <sys/types.h>
119 #endif
120 #ifdef HAVE_STDINT_H
121 # include <stdint.h>
122 #endif
123 #ifdef HAVE_INTTYPES_H
124 # include <inttypes.h>
125 #endif
126 /* includes end */"
127 case $host_os in
128 irix*)
129 ac_cv_header_stdint_h="no"
130 ;;
131 esac
132 AC_CHECK_HEADERS(
133 sys/types.h stdint.h inttypes.h,
134 [], [], [$curl_includes_inttypes])
135 ])
136
137
138 dnl CURL_INCLUDES_LIBGEN
139 dnl -------------------------------------------------
140 dnl Set up variable with list of headers that must be
141 dnl included when libgen.h is to be included.
142
143 AC_DEFUN([CURL_INCLUDES_LIBGEN], [
144 curl_includes_libgen="\
145 /* includes start */
146 #ifdef HAVE_SYS_TYPES_H
147 # include <sys/types.h>
148 #endif
149 #ifdef HAVE_LIBGEN_H
150 # include <libgen.h>
151 #endif
152 /* includes end */"
153 AC_CHECK_HEADERS(
154 sys/types.h libgen.h,
155 [], [], [$curl_includes_libgen])
156 ])
157
158
159 dnl CURL_INCLUDES_NETDB
160 dnl -------------------------------------------------
161 dnl Set up variable with list of headers that must be
162 dnl included when netdb.h is to be included.
163
164 AC_DEFUN([CURL_INCLUDES_NETDB], [
165 curl_includes_netdb="\
166 /* includes start */
167 #ifdef HAVE_SYS_TYPES_H
168 # include <sys/types.h>
169 #endif
170 #ifdef HAVE_NETDB_H
171 # include <netdb.h>
172 #endif
173 /* includes end */"
174 AC_CHECK_HEADERS(
175 sys/types.h netdb.h,
176 [], [], [$curl_includes_netdb])
177 ])
178
179
180 dnl CURL_INCLUDES_POLL
181 dnl -------------------------------------------------
182 dnl Set up variable with list of headers that must be
183 dnl included when poll.h is to be included.
184
185 AC_DEFUN([CURL_INCLUDES_POLL], [
186 curl_includes_poll="\
187 /* includes start */
188 #ifdef HAVE_SYS_TYPES_H
189 # include <sys/types.h>
190 #endif
191 #ifdef HAVE_POLL_H
192 # include <poll.h>
193 #endif
194 #ifdef HAVE_SYS_POLL_H
195 # include <sys/poll.h>
196 #endif
197 /* includes end */"
198 AC_CHECK_HEADERS(
199 sys/types.h poll.h sys/poll.h,
200 [], [], [$curl_includes_poll])
201 ])
202
203
204 dnl CURL_INCLUDES_SETJMP
205 dnl -------------------------------------------------
206 dnl Set up variable with list of headers that must be
207 dnl included when setjmp.h is to be included.
208
209 AC_DEFUN([CURL_INCLUDES_SETJMP], [
210 curl_includes_setjmp="\
211 /* includes start */
212 #ifdef HAVE_SYS_TYPES_H
213 # include <sys/types.h>
214 #endif
215 #ifdef HAVE_SETJMP_H
216 # include <setjmp.h>
217 #endif
218 /* includes end */"
219 AC_CHECK_HEADERS(
220 sys/types.h setjmp.h,
221 [], [], [$curl_includes_setjmp])
222 ])
223
224
225 dnl CURL_INCLUDES_SIGNAL
226 dnl -------------------------------------------------
227 dnl Set up variable with list of headers that must be
228 dnl included when signal.h is to be included.
229
230 AC_DEFUN([CURL_INCLUDES_SIGNAL], [
231 curl_includes_signal="\
232 /* includes start */
233 #ifdef HAVE_SYS_TYPES_H
234 # include <sys/types.h>
235 #endif
236 #ifdef HAVE_SIGNAL_H
237 # include <signal.h>
238 #endif
239 /* includes end */"
240 AC_CHECK_HEADERS(
241 sys/types.h signal.h,
242 [], [], [$curl_includes_signal])
243 ])
244
245
246 dnl CURL_INCLUDES_SOCKET
247 dnl -------------------------------------------------
248 dnl Set up variable with list of headers that must be
249 dnl included when socket.h is to be included.
250
251 AC_DEFUN([CURL_INCLUDES_SOCKET], [
252 curl_includes_socket="\
253 /* includes start */
254 #ifdef HAVE_SYS_TYPES_H
255 # include <sys/types.h>
256 #endif
257 #ifdef HAVE_SOCKET_H
258 # include <socket.h>
259 #endif
260 /* includes end */"
261 AC_CHECK_HEADERS(
262 sys/types.h socket.h,
263 [], [], [$curl_includes_socket])
264 ])
265
266
267 dnl CURL_INCLUDES_STDIO
268 dnl -------------------------------------------------
269 dnl Set up variable with list of headers that must be
270 dnl included when stdio.h is to be included.
271
272 AC_DEFUN([CURL_INCLUDES_STDIO], [
273 curl_includes_stdio="\
274 /* includes start */
275 #ifdef HAVE_SYS_TYPES_H
276 # include <sys/types.h>
277 #endif
278 #ifdef HAVE_STDIO_H
279 # include <stdio.h>
280 #endif
281 /* includes end */"
282 AC_CHECK_HEADERS(
283 sys/types.h stdio.h,
284 [], [], [$curl_includes_stdio])
285 ])
286
287
288 dnl CURL_INCLUDES_STDLIB
289 dnl -------------------------------------------------
290 dnl Set up variable with list of headers that must be
291 dnl included when stdlib.h is to be included.
292
293 AC_DEFUN([CURL_INCLUDES_STDLIB], [
294 curl_includes_stdlib="\
295 /* includes start */
296 #ifdef HAVE_SYS_TYPES_H
297 # include <sys/types.h>
298 #endif
299 #ifdef HAVE_STDLIB_H
300 # include <stdlib.h>
301 #endif
302 /* includes end */"
303 AC_CHECK_HEADERS(
304 sys/types.h stdlib.h,
305 [], [], [$curl_includes_stdlib])
306 ])
307
308
309 dnl CURL_INCLUDES_STRING
310 dnl -------------------------------------------------
311 dnl Set up variable with list of headers that must be
312 dnl included when string(s).h is to be included.
313
314 AC_DEFUN([CURL_INCLUDES_STRING], [
315 curl_includes_string="\
316 /* includes start */
317 #ifdef HAVE_SYS_TYPES_H
318 # include <sys/types.h>
319 #endif
320 #ifdef HAVE_STRING_H
321 # include <string.h>
322 #endif
323 #ifdef HAVE_STRINGS_H
324 # include <strings.h>
325 #endif
326 /* includes end */"
327 AC_CHECK_HEADERS(
328 sys/types.h string.h strings.h,
329 [], [], [$curl_includes_string])
330 ])
331
332
333 dnl CURL_INCLUDES_STROPTS
334 dnl -------------------------------------------------
335 dnl Set up variable with list of headers that must be
336 dnl included when stropts.h is to be included.
337
338 AC_DEFUN([CURL_INCLUDES_STROPTS], [
339 curl_includes_stropts="\
340 /* includes start */
341 #ifdef HAVE_SYS_TYPES_H
342 # include <sys/types.h>
343 #endif
344 #ifdef HAVE_UNISTD_H
345 # include <unistd.h>
346 #endif
347 #ifdef HAVE_SYS_SOCKET_H
348 # include <sys/socket.h>
349 #endif
350 #ifdef HAVE_SYS_IOCTL_H
351 # include <sys/ioctl.h>
352 #endif
353 #ifdef HAVE_STROPTS_H
354 # include <stropts.h>
355 #endif
356 /* includes end */"
357 AC_CHECK_HEADERS(
358 sys/types.h unistd.h sys/socket.h sys/ioctl.h stropts.h,
359 [], [], [$curl_includes_stropts])
360 ])
361
362
363 dnl CURL_INCLUDES_SYS_SOCKET
364 dnl -------------------------------------------------
365 dnl Set up variable with list of headers that must be
366 dnl included when sys/socket.h is to be included.
367
368 AC_DEFUN([CURL_INCLUDES_SYS_SOCKET], [
369 curl_includes_sys_socket="\
370 /* includes start */
371 #ifdef HAVE_SYS_TYPES_H
372 # include <sys/types.h>
373 #endif
374 #ifdef HAVE_SYS_SOCKET_H
375 # include <sys/socket.h>
376 #endif
377 /* includes end */"
378 AC_CHECK_HEADERS(
379 sys/types.h sys/socket.h,
380 [], [], [$curl_includes_sys_socket])
381 ])
382
383
384 dnl CURL_INCLUDES_SYS_TYPES
385 dnl -------------------------------------------------
386 dnl Set up variable with list of headers that must be
387 dnl included when sys/types.h is to be included.
388
389 AC_DEFUN([CURL_INCLUDES_SYS_TYPES], [
390 curl_includes_sys_types="\
391 /* includes start */
392 #ifdef HAVE_SYS_TYPES_H
393 # include <sys/types.h>
394 #endif
395 /* includes end */"
396 AC_CHECK_HEADERS(
397 sys/types.h,
398 [], [], [$curl_includes_sys_types])
399 ])
400
401
402 dnl CURL_INCLUDES_SYS_UIO
403 dnl -------------------------------------------------
404 dnl Set up variable with list of headers that must be
405 dnl included when sys/uio.h is to be included.
406
407 AC_DEFUN([CURL_INCLUDES_SYS_UIO], [
408 curl_includes_sys_uio="\
409 /* includes start */
410 #ifdef HAVE_SYS_TYPES_H
411 # include <sys/types.h>
412 #endif
413 #ifdef HAVE_SYS_UIO_H
414 # include <sys/uio.h>
415 #endif
416 /* includes end */"
417 AC_CHECK_HEADERS(
418 sys/types.h sys/uio.h,
419 [], [], [$curl_includes_sys_uio])
420 ])
421
422
423 dnl CURL_INCLUDES_SYS_XATTR
424 dnl -------------------------------------------------
425 dnl Set up variable with list of headers that must be
426 dnl included when sys/xattr.h is to be included.
427
428 AC_DEFUN([CURL_INCLUDES_SYS_XATTR], [
429 curl_includes_sys_xattr="\
430 /* includes start */
431 #ifdef HAVE_SYS_TYPES_H
432 # include <sys/types.h>
433 #endif
434 #ifdef HAVE_SYS_XATTR_H
435 # include <sys/xattr.h>
436 #endif
437 /* includes end */"
438 AC_CHECK_HEADERS(
439 sys/types.h sys/xattr.h,
440 [], [], [$curl_includes_sys_xattr])
441 ])
442
443 dnl CURL_INCLUDES_TIME
444 dnl -------------------------------------------------
445 dnl Set up variable with list of headers that must be
446 dnl included when time.h is to be included.
447
448 AC_DEFUN([CURL_INCLUDES_TIME], [
449 AC_REQUIRE([AC_HEADER_TIME])dnl
450 curl_includes_time="\
451 /* includes start */
452 #ifdef HAVE_SYS_TYPES_H
453 # include <sys/types.h>
454 #endif
455 #ifdef HAVE_SYS_TIME_H
456 # include <sys/time.h>
457 # ifdef TIME_WITH_SYS_TIME
458 # include <time.h>
459 # endif
460 #else
461 # ifdef HAVE_TIME_H
462 # include <time.h>
463 # endif
464 #endif
465 /* includes end */"
466 AC_CHECK_HEADERS(
467 sys/types.h sys/time.h time.h,
468 [], [], [$curl_includes_time])
469 ])
470
471
472 dnl CURL_INCLUDES_UNISTD
473 dnl -------------------------------------------------
474 dnl Set up variable with list of headers that must be
475 dnl included when unistd.h is to be included.
476
477 AC_DEFUN([CURL_INCLUDES_UNISTD], [
478 curl_includes_unistd="\
479 /* includes start */
480 #ifdef HAVE_SYS_TYPES_H
481 # include <sys/types.h>
482 #endif
483 #ifdef HAVE_UNISTD_H
484 # include <unistd.h>
485 #endif
486 /* includes end */"
487 AC_CHECK_HEADERS(
488 sys/types.h unistd.h,
489 [], [], [$curl_includes_unistd])
490 ])
491
492
493 dnl CURL_INCLUDES_WINSOCK2
494 dnl -------------------------------------------------
495 dnl Set up variable with list of headers that must be
496 dnl included when winsock(2).h is to be included.
497
498 AC_DEFUN([CURL_INCLUDES_WINSOCK2], [
499 curl_includes_winsock2="\
500 /* includes start */
501 #ifdef HAVE_WINDOWS_H
502 # ifndef WIN32_LEAN_AND_MEAN
503 # define WIN32_LEAN_AND_MEAN
504 # endif
505 # include <windows.h>
506 # ifdef HAVE_WINSOCK2_H
507 # include <winsock2.h>
508 # else
509 # ifdef HAVE_WINSOCK_H
510 # include <winsock.h>
511 # endif
512 # endif
513 #endif
514 /* includes end */"
515 CURL_CHECK_HEADER_WINDOWS
516 CURL_CHECK_HEADER_WINSOCK
517 CURL_CHECK_HEADER_WINSOCK2
518 ])
519
520
521 dnl CURL_INCLUDES_WS2TCPIP
522 dnl -------------------------------------------------
523 dnl Set up variable with list of headers that must be
524 dnl included when ws2tcpip.h is to be included.
525
526 AC_DEFUN([CURL_INCLUDES_WS2TCPIP], [
527 curl_includes_ws2tcpip="\
528 /* includes start */
529 #ifdef HAVE_WINDOWS_H
530 # ifndef WIN32_LEAN_AND_MEAN
531 # define WIN32_LEAN_AND_MEAN
532 # endif
533 # include <windows.h>
534 # ifdef HAVE_WINSOCK2_H
535 # include <winsock2.h>
536 # ifdef HAVE_WS2TCPIP_H
537 # include <ws2tcpip.h>
538 # endif
539 # endif
540 #endif
541 /* includes end */"
542 CURL_CHECK_HEADER_WINDOWS
543 CURL_CHECK_HEADER_WINSOCK2
544 CURL_CHECK_HEADER_WS2TCPIP
545 ])
546
547
548 dnl CURL_INCLUDES_BSDSOCKET
549 dnl -------------------------------------------------
550 dnl Set up variable with list of headers that must be
551 dnl included when bsdsocket.h is to be included.
552
553 AC_DEFUN([CURL_INCLUDES_BSDSOCKET], [
554 curl_includes_bsdsocket="\
555 /* includes start */
556 #ifdef HAVE_PROTO_BSDSOCKET_H
557 # include <proto/bsdsocket.h>
558 struct Library *SocketBase = NULL;
559 #endif
560 /* includes end */"
561 AC_CHECK_HEADERS(
562 proto/bsdsocket.h,
563 [], [], [ $curl_includes_bsdsocket])
564 ])
565
566 dnl CURL_INCLUDES_NETIF
567 dnl -------------------------------------------------
568 dnl Set up variable with list of headers that must be
569 dnl included when net/if.h is to be included.
570
571 AC_DEFUN([CURL_INCLUDES_NETIF], [
572 curl_includes_netif="\
573 /* includes start */
574 #ifdef HAVE_NET_IF_H
575 # include <net/if.h>
576 #endif
577 /* includes end */"
578 AC_CHECK_HEADERS(
579 net/if.h,
580 [], [], [$curl_includes_netif])
581 ])
582
583
584 dnl CURL_PREPROCESS_CALLCONV
585 dnl -------------------------------------------------
586 dnl Set up variable with a preprocessor block which
587 dnl defines function calling convention.
588
589 AC_DEFUN([CURL_PREPROCESS_CALLCONV], [
590 curl_preprocess_callconv="\
591 /* preprocess start */
592 #ifdef HAVE_WINDOWS_H
593 # define FUNCALLCONV __stdcall
594 #else
595 # define FUNCALLCONV
596 #endif
597 /* preprocess end */"
598 ])
599
600
601 dnl CURL_CHECK_FUNC_ALARM
602 dnl -------------------------------------------------
603 dnl Verify if alarm is available, prototyped, and
604 dnl can be compiled. If all of these are true, and
605 dnl usage has not been previously disallowed with
606 dnl shell variable curl_disallow_alarm, then
607 dnl HAVE_ALARM will be defined.
608
609 AC_DEFUN([CURL_CHECK_FUNC_ALARM], [
610 AC_REQUIRE([CURL_INCLUDES_UNISTD])dnl
611 #
612 tst_links_alarm="unknown"
613 tst_proto_alarm="unknown"
614 tst_compi_alarm="unknown"
615 tst_allow_alarm="unknown"
616 #
617 AC_MSG_CHECKING([if alarm can be linked])
618 AC_LINK_IFELSE([
619 AC_LANG_FUNC_LINK_TRY([alarm])
620 ],[
621 AC_MSG_RESULT([yes])
622 tst_links_alarm="yes"
623 ],[
624 AC_MSG_RESULT([no])
625 tst_links_alarm="no"
626 ])
627 #
628 if test "$tst_links_alarm" = "yes"; then
629 AC_MSG_CHECKING([if alarm is prototyped])
630 AC_EGREP_CPP([alarm],[
631 $curl_includes_unistd
632 ],[
633 AC_MSG_RESULT([yes])
634 tst_proto_alarm="yes"
635 ],[
636 AC_MSG_RESULT([no])
637 tst_proto_alarm="no"
638 ])
639 fi
640 #
641 if test "$tst_proto_alarm" = "yes"; then
642 AC_MSG_CHECKING([if alarm is compilable])
643 AC_COMPILE_IFELSE([
644 AC_LANG_PROGRAM([[
645 $curl_includes_unistd
646 ]],[[
647 if(0 != alarm(0))
648 return 1;
649 ]])
650 ],[
651 AC_MSG_RESULT([yes])
652 tst_compi_alarm="yes"
653 ],[
654 AC_MSG_RESULT([no])
655 tst_compi_alarm="no"
656 ])
657 fi
658 #
659 if test "$tst_compi_alarm" = "yes"; then
660 AC_MSG_CHECKING([if alarm usage allowed])
661 if test "x$curl_disallow_alarm" != "xyes"; then
662 AC_MSG_RESULT([yes])
663 tst_allow_alarm="yes"
664 else
665 AC_MSG_RESULT([no])
666 tst_allow_alarm="no"
667 fi
668 fi
669 #
670 AC_MSG_CHECKING([if alarm might be used])
671 if test "$tst_links_alarm" = "yes" &&
672 test "$tst_proto_alarm" = "yes" &&
673 test "$tst_compi_alarm" = "yes" &&
674 test "$tst_allow_alarm" = "yes"; then
675 AC_MSG_RESULT([yes])
676 AC_DEFINE_UNQUOTED(HAVE_ALARM, 1,
677 [Define to 1 if you have the alarm function.])
678 curl_cv_func_alarm="yes"
679 else
680 AC_MSG_RESULT([no])
681 curl_cv_func_alarm="no"
682 fi
683 ])
684
685
686 dnl CURL_CHECK_FUNC_BASENAME
687 dnl -------------------------------------------------
688 dnl Verify if basename is available, prototyped, and
689 dnl can be compiled. If all of these are true, and
690 dnl usage has not been previously disallowed with
691 dnl shell variable curl_disallow_basename, then
692 dnl HAVE_BASENAME will be defined.
693
694 AC_DEFUN([CURL_CHECK_FUNC_BASENAME], [
695 AC_REQUIRE([CURL_INCLUDES_STRING])dnl
696 AC_REQUIRE([CURL_INCLUDES_LIBGEN])dnl
697 AC_REQUIRE([CURL_INCLUDES_UNISTD])dnl
698 #
699 tst_links_basename="unknown"
700 tst_proto_basename="unknown"
701 tst_compi_basename="unknown"
702 tst_allow_basename="unknown"
703 #
704 AC_MSG_CHECKING([if basename can be linked])
705 AC_LINK_IFELSE([
706 AC_LANG_FUNC_LINK_TRY([basename])
707 ],[
708 AC_MSG_RESULT([yes])
709 tst_links_basename="yes"
710 ],[
711 AC_MSG_RESULT([no])
712 tst_links_basename="no"
713 ])
714 #
715 if test "$tst_links_basename" = "yes"; then
716 AC_MSG_CHECKING([if basename is prototyped])
717 AC_EGREP_CPP([basename],[
718 $curl_includes_string
719 $curl_includes_libgen
720 $curl_includes_unistd
721 ],[
722 AC_MSG_RESULT([yes])
723 tst_proto_basename="yes"
724 ],[
725 AC_MSG_RESULT([no])
726 tst_proto_basename="no"
727 ])
728 fi
729 #
730 if test "$tst_proto_basename" = "yes"; then
731 AC_MSG_CHECKING([if basename is compilable])
732 AC_COMPILE_IFELSE([
733 AC_LANG_PROGRAM([[
734 $curl_includes_string
735 $curl_includes_libgen
736 $curl_includes_unistd
737 ]],[[
738 if(0 != basename(0))
739 return 1;
740 ]])
741 ],[
742 AC_MSG_RESULT([yes])
743 tst_compi_basename="yes"
744 ],[
745 AC_MSG_RESULT([no])
746 tst_compi_basename="no"
747 ])
748 fi
749 #
750 if test "$tst_compi_basename" = "yes"; then
751 AC_MSG_CHECKING([if basename usage allowed])
752 if test "x$curl_disallow_basename" != "xyes"; then
753 AC_MSG_RESULT([yes])
754 tst_allow_basename="yes"
755 else
756 AC_MSG_RESULT([no])
757 tst_allow_basename="no"
758 fi
759 fi
760 #
761 AC_MSG_CHECKING([if basename might be used])
762 if test "$tst_links_basename" = "yes" &&
763 test "$tst_proto_basename" = "yes" &&
764 test "$tst_compi_basename" = "yes" &&
765 test "$tst_allow_basename" = "yes"; then
766 AC_MSG_RESULT([yes])
767 AC_DEFINE_UNQUOTED(HAVE_BASENAME, 1,
768 [Define to 1 if you have the basename function.])
769 curl_cv_func_basename="yes"
770 else
771 AC_MSG_RESULT([no])
772 curl_cv_func_basename="no"
773 fi
774 ])
775
776
777 dnl CURL_CHECK_FUNC_CLOSESOCKET
778 dnl -------------------------------------------------
779 dnl Verify if closesocket is available, prototyped, and
780 dnl can be compiled. If all of these are true, and
781 dnl usage has not been previously disallowed with
782 dnl shell variable curl_disallow_closesocket, then
783 dnl HAVE_CLOSESOCKET will be defined.
784
785 AC_DEFUN([CURL_CHECK_FUNC_CLOSESOCKET], [
786 AC_REQUIRE([CURL_INCLUDES_WINSOCK2])dnl
787 AC_REQUIRE([CURL_INCLUDES_SOCKET])dnl
788 #
789 tst_links_closesocket="unknown"
790 tst_proto_closesocket="unknown"
791 tst_compi_closesocket="unknown"
792 tst_allow_closesocket="unknown"
793 #
794 AC_MSG_CHECKING([if closesocket can be linked])
795 AC_LINK_IFELSE([
796 AC_LANG_PROGRAM([[
797 $curl_includes_winsock2
798 $curl_includes_bsdsocket
799 $curl_includes_socket
800 ]],[[
801 if(0 != closesocket(0))
802 return 1;
803 ]])
804 ],[
805 AC_MSG_RESULT([yes])
806 tst_links_closesocket="yes"
807 ],[
808 AC_MSG_RESULT([no])
809 tst_links_closesocket="no"
810 ])
811 #
812 if test "$tst_links_closesocket" = "yes"; then
813 AC_MSG_CHECKING([if closesocket is prototyped])
814 AC_EGREP_CPP([closesocket],[
815 $curl_includes_winsock2
816 $curl_includes_bsdsocket
817 $curl_includes_socket
818 ],[
819 AC_MSG_RESULT([yes])
820 tst_proto_closesocket="yes"
821 ],[
822 AC_MSG_RESULT([no])
823 tst_proto_closesocket="no"
824 ])
825 fi
826 #
827 if test "$tst_proto_closesocket" = "yes"; then
828 AC_MSG_CHECKING([if closesocket is compilable])
829 AC_COMPILE_IFELSE([
830 AC_LANG_PROGRAM([[
831 $curl_includes_winsock2
832 $curl_includes_bsdsocket
833 $curl_includes_socket
834 ]],[[
835 if(0 != closesocket(0))
836 return 1;
837 ]])
838 ],[
839 AC_MSG_RESULT([yes])
840 tst_compi_closesocket="yes"
841 ],[
842 AC_MSG_RESULT([no])
843 tst_compi_closesocket="no"
844 ])
845 fi
846 #
847 if test "$tst_compi_closesocket" = "yes"; then
848 AC_MSG_CHECKING([if closesocket usage allowed])
849 if test "x$curl_disallow_closesocket" != "xyes"; then
850 AC_MSG_RESULT([yes])
851 tst_allow_closesocket="yes"
852 else
853 AC_MSG_RESULT([no])
854 tst_allow_closesocket="no"
855 fi
856 fi
857 #
858 AC_MSG_CHECKING([if closesocket might be used])
859 if test "$tst_links_closesocket" = "yes" &&
860 test "$tst_proto_closesocket" = "yes" &&
861 test "$tst_compi_closesocket" = "yes" &&
862 test "$tst_allow_closesocket" = "yes"; then
863 AC_MSG_RESULT([yes])
864 AC_DEFINE_UNQUOTED(HAVE_CLOSESOCKET, 1,
865 [Define to 1 if you have the closesocket function.])
866 curl_cv_func_closesocket="yes"
867 else
868 AC_MSG_RESULT([no])
869 curl_cv_func_closesocket="no"
870 fi
871 ])
872
873
874 dnl CURL_CHECK_FUNC_CLOSESOCKET_CAMEL
875 dnl -------------------------------------------------
876 dnl Verify if CloseSocket is available, prototyped, and
877 dnl can be compiled. If all of these are true, and
878 dnl usage has not been previously disallowed with
879 dnl shell variable curl_disallow_closesocket_camel,
880 dnl then HAVE_CLOSESOCKET_CAMEL will be defined.
881
882 AC_DEFUN([CURL_CHECK_FUNC_CLOSESOCKET_CAMEL], [
883 AC_REQUIRE([CURL_INCLUDES_SYS_SOCKET])dnl
884 #
885 tst_links_closesocket_camel="unknown"
886 tst_proto_closesocket_camel="unknown"
887 tst_compi_closesocket_camel="unknown"
888 tst_allow_closesocket_camel="unknown"
889 #
890 AC_MSG_CHECKING([if CloseSocket can be linked])
891 AC_LINK_IFELSE([
892 AC_LANG_PROGRAM([[
893 $curl_includes_sys_socket
894 ]],[[
895 if(0 != CloseSocket(0))
896 return 1;
897 ]])
898 ],[
899 AC_MSG_RESULT([yes])
900 tst_links_closesocket_camel="yes"
901 ],[
902 AC_MSG_RESULT([no])
903 tst_links_closesocket_camel="no"
904 ])
905 #
906 if test "$tst_links_closesocket_camel" = "yes"; then
907 AC_MSG_CHECKING([if CloseSocket is prototyped])
908 AC_EGREP_CPP([CloseSocket],[
909 $curl_includes_sys_socket
910 ],[
911 AC_MSG_RESULT([yes])
912 tst_proto_closesocket_camel="yes"
913 ],[
914 AC_MSG_RESULT([no])
915 tst_proto_closesocket_camel="no"
916 ])
917 fi
918 #
919 if test "$tst_proto_closesocket_camel" = "yes"; then
920 AC_MSG_CHECKING([if CloseSocket is compilable])
921 AC_COMPILE_IFELSE([
922 AC_LANG_PROGRAM([[
923 $curl_includes_sys_socket
924 ]],[[
925 if(0 != CloseSocket(0))
926 return 1;
927 ]])
928 ],[
929 AC_MSG_RESULT([yes])
930 tst_compi_closesocket_camel="yes"
931 ],[
932 AC_MSG_RESULT([no])
933 tst_compi_closesocket_camel="no"
934 ])
935 fi
936 #
937 if test "$tst_compi_closesocket_camel" = "yes"; then
938 AC_MSG_CHECKING([if CloseSocket usage allowed])
939 if test "x$curl_disallow_closesocket_camel" != "xyes"; then
940 AC_MSG_RESULT([yes])
941 tst_allow_closesocket_camel="yes"
942 else
943 AC_MSG_RESULT([no])
944 tst_allow_closesocket_camel="no"
945 fi
946 fi
947 #
948 AC_MSG_CHECKING([if CloseSocket might be used])
949 if test "$tst_links_closesocket_camel" = "yes" &&
950 test "$tst_proto_closesocket_camel" = "yes" &&
951 test "$tst_compi_closesocket_camel" = "yes" &&
952 test "$tst_allow_closesocket_camel" = "yes"; then
953 AC_MSG_RESULT([yes])
954 AC_DEFINE_UNQUOTED(HAVE_CLOSESOCKET_CAMEL, 1,
955 [Define to 1 if you have the CloseSocket camel case function.])
956 curl_cv_func_closesocket_camel="yes"
957 else
958 AC_MSG_RESULT([no])
959 curl_cv_func_closesocket_camel="no"
960 fi
961 ])
962
963
964 dnl CURL_CHECK_FUNC_CONNECT
965 dnl -------------------------------------------------
966 dnl Verify if connect is available, prototyped, and
967 dnl can be compiled. If all of these are true, and
968 dnl usage has not been previously disallowed with
969 dnl shell variable curl_disallow_connect, then
970 dnl HAVE_CONNECT will be defined.
971
972 AC_DEFUN([CURL_CHECK_FUNC_CONNECT], [
973 AC_REQUIRE([CURL_INCLUDES_WINSOCK2])dnl
974 AC_REQUIRE([CURL_INCLUDES_SYS_SOCKET])dnl
975 AC_REQUIRE([CURL_INCLUDES_SOCKET])dnl
976 #
977 tst_links_connect="unknown"
978 tst_proto_connect="unknown"
979 tst_compi_connect="unknown"
980 tst_allow_connect="unknown"
981 #
982 AC_MSG_CHECKING([if connect can be linked])
983 AC_LINK_IFELSE([
984 AC_LANG_PROGRAM([[
985 $curl_includes_winsock2
986 $curl_includes_bsdsocket
987 $curl_includes_sys_socket
988 $curl_includes_socket
989 ]],[[
990 if(0 != connect(0, 0, 0))
991 return 1;
992 ]])
993 ],[
994 AC_MSG_RESULT([yes])
995 tst_links_connect="yes"
996 ],[
997 AC_MSG_RESULT([no])
998 tst_links_connect="no"
999 ])
1000 #
1001 if test "$tst_links_connect" = "yes"; then
1002 AC_MSG_CHECKING([if connect is prototyped])
1003 AC_EGREP_CPP([connect],[
1004 $curl_includes_winsock2
1005 $curl_includes_bsdsocket
1006 $curl_includes_sys_socket
1007 $curl_includes_socket
1008 ],[
1009 AC_MSG_RESULT([yes])
1010 tst_proto_connect="yes"
1011 ],[
1012 AC_MSG_RESULT([no])
1013 tst_proto_connect="no"
1014 ])
1015 fi
1016 #
1017 if test "$tst_proto_connect" = "yes"; then
1018 AC_MSG_CHECKING([if connect is compilable])
1019 AC_COMPILE_IFELSE([
1020 AC_LANG_PROGRAM([[
1021 $curl_includes_winsock2
1022 $curl_includes_bsdsocket
1023 $curl_includes_sys_socket
1024 $curl_includes_socket
1025 ]],[[
1026 if(0 != connect(0, 0, 0))
1027 return 1;
1028 ]])
1029 ],[
1030 AC_MSG_RESULT([yes])
1031 tst_compi_connect="yes"
1032 ],[
1033 AC_MSG_RESULT([no])
1034 tst_compi_connect="no"
1035 ])
1036 fi
1037 #
1038 if test "$tst_compi_connect" = "yes"; then
1039 AC_MSG_CHECKING([if connect usage allowed])
1040 if test "x$curl_disallow_connect" != "xyes"; then
1041 AC_MSG_RESULT([yes])
1042 tst_allow_connect="yes"
1043 else
1044 AC_MSG_RESULT([no])
1045 tst_allow_connect="no"
1046 fi
1047 fi
1048 #
1049 AC_MSG_CHECKING([if connect might be used])
1050 if test "$tst_links_connect" = "yes" &&
1051 test "$tst_proto_connect" = "yes" &&
1052 test "$tst_compi_connect" = "yes" &&
1053 test "$tst_allow_connect" = "yes"; then
1054 AC_MSG_RESULT([yes])
1055 AC_DEFINE_UNQUOTED(HAVE_CONNECT, 1,
1056 [Define to 1 if you have the connect function.])
1057 curl_cv_func_connect="yes"
1058 else
1059 AC_MSG_RESULT([no])
1060 curl_cv_func_connect="no"
1061 fi
1062 ])
1063
1064
1065 dnl CURL_CHECK_FUNC_FCNTL
1066 dnl -------------------------------------------------
1067 dnl Verify if fcntl is available, prototyped, and
1068 dnl can be compiled. If all of these are true, and
1069 dnl usage has not been previously disallowed with
1070 dnl shell variable curl_disallow_fcntl, then
1071 dnl HAVE_FCNTL will be defined.
1072
1073 AC_DEFUN([CURL_CHECK_FUNC_FCNTL], [
1074 AC_REQUIRE([CURL_INCLUDES_FCNTL])dnl
1075 #
1076 tst_links_fcntl="unknown"
1077 tst_proto_fcntl="unknown"
1078 tst_compi_fcntl="unknown"
1079 tst_allow_fcntl="unknown"
1080 #
1081 AC_MSG_CHECKING([if fcntl can be linked])
1082 AC_LINK_IFELSE([
1083 AC_LANG_FUNC_LINK_TRY([fcntl])
1084 ],[
1085 AC_MSG_RESULT([yes])
1086 tst_links_fcntl="yes"
1087 ],[
1088 AC_MSG_RESULT([no])
1089 tst_links_fcntl="no"
1090 ])
1091 #
1092 if test "$tst_links_fcntl" = "yes"; then
1093 AC_MSG_CHECKING([if fcntl is prototyped])
1094 AC_EGREP_CPP([fcntl],[
1095 $curl_includes_fcntl
1096 ],[
1097 AC_MSG_RESULT([yes])
1098 tst_proto_fcntl="yes"
1099 ],[
1100 AC_MSG_RESULT([no])
1101 tst_proto_fcntl="no"
1102 ])
1103 fi
1104 #
1105 if test "$tst_proto_fcntl" = "yes"; then
1106 AC_MSG_CHECKING([if fcntl is compilable])
1107 AC_COMPILE_IFELSE([
1108 AC_LANG_PROGRAM([[
1109 $curl_includes_fcntl
1110 ]],[[
1111 if(0 != fcntl(0, 0, 0))
1112 return 1;
1113 ]])
1114 ],[
1115 AC_MSG_RESULT([yes])
1116 tst_compi_fcntl="yes"
1117 ],[
1118 AC_MSG_RESULT([no])
1119 tst_compi_fcntl="no"
1120 ])
1121 fi
1122 #
1123 if test "$tst_compi_fcntl" = "yes"; then
1124 AC_MSG_CHECKING([if fcntl usage allowed])
1125 if test "x$curl_disallow_fcntl" != "xyes"; then
1126 AC_MSG_RESULT([yes])
1127 tst_allow_fcntl="yes"
1128 else
1129 AC_MSG_RESULT([no])
1130 tst_allow_fcntl="no"
1131 fi
1132 fi
1133 #
1134 AC_MSG_CHECKING([if fcntl might be used])
1135 if test "$tst_links_fcntl" = "yes" &&
1136 test "$tst_proto_fcntl" = "yes" &&
1137 test "$tst_compi_fcntl" = "yes" &&
1138 test "$tst_allow_fcntl" = "yes"; then
1139 AC_MSG_RESULT([yes])
1140 AC_DEFINE_UNQUOTED(HAVE_FCNTL, 1,
1141 [Define to 1 if you have the fcntl function.])
1142 curl_cv_func_fcntl="yes"
1143 CURL_CHECK_FUNC_FCNTL_O_NONBLOCK
1144 else
1145 AC_MSG_RESULT([no])
1146 curl_cv_func_fcntl="no"
1147 fi
1148 ])
1149
1150
1151 dnl CURL_CHECK_FUNC_FCNTL_O_NONBLOCK
1152 dnl -------------------------------------------------
1153 dnl Verify if fcntl with status flag O_NONBLOCK is
1154 dnl available, can be compiled, and seems to work. If
1155 dnl all of these are true, then HAVE_FCNTL_O_NONBLOCK
1156 dnl will be defined.
1157
1158 AC_DEFUN([CURL_CHECK_FUNC_FCNTL_O_NONBLOCK], [
1159 #
1160 tst_compi_fcntl_o_nonblock="unknown"
1161 tst_allow_fcntl_o_nonblock="unknown"
1162 #
1163 case $host_os in
1164 sunos4* | aix3* | beos*)
1165 dnl O_NONBLOCK does not work on these platforms
1166 curl_disallow_fcntl_o_nonblock="yes"
1167 ;;
1168 esac
1169 #
1170 if test "$curl_cv_func_fcntl" = "yes"; then
1171 AC_MSG_CHECKING([if fcntl O_NONBLOCK is compilable])
1172 AC_COMPILE_IFELSE([
1173 AC_LANG_PROGRAM([[
1174 $curl_includes_fcntl
1175 ]],[[
1176 int flags = 0;
1177 if(0 != fcntl(0, F_SETFL, flags | O_NONBLOCK))
1178 return 1;
1179 ]])
1180 ],[
1181 AC_MSG_RESULT([yes])
1182 tst_compi_fcntl_o_nonblock="yes"
1183 ],[
1184 AC_MSG_RESULT([no])
1185 tst_compi_fcntl_o_nonblock="no"
1186 ])
1187 fi
1188 #
1189 if test "$tst_compi_fcntl_o_nonblock" = "yes"; then
1190 AC_MSG_CHECKING([if fcntl O_NONBLOCK usage allowed])
1191 if test "x$curl_disallow_fcntl_o_nonblock" != "xyes"; then
1192 AC_MSG_RESULT([yes])
1193 tst_allow_fcntl_o_nonblock="yes"
1194 else
1195 AC_MSG_RESULT([no])
1196 tst_allow_fcntl_o_nonblock="no"
1197 fi
1198 fi
1199 #
1200 AC_MSG_CHECKING([if fcntl O_NONBLOCK might be used])
1201 if test "$tst_compi_fcntl_o_nonblock" = "yes" &&
1202 test "$tst_allow_fcntl_o_nonblock" = "yes"; then
1203 AC_MSG_RESULT([yes])
1204 AC_DEFINE_UNQUOTED(HAVE_FCNTL_O_NONBLOCK, 1,
1205 [Define to 1 if you have a working fcntl O_NONBLOCK function.])
1206 curl_cv_func_fcntl_o_nonblock="yes"
1207 else
1208 AC_MSG_RESULT([no])
1209 curl_cv_func_fcntl_o_nonblock="no"
1210 fi
1211 ])
1212
1213 dnl CURL_CHECK_FUNC_FGETXATTR
1214 dnl -------------------------------------------------
1215 dnl Verify if fgetxattr is available, prototyped, and
1216 dnl can be compiled. If all of these are true, and
1217 dnl usage has not been previously disallowed with
1218 dnl shell variable curl_disallow_fgetxattr, then
1219 dnl HAVE_FGETXATTR will be defined.
1220
1221 AC_DEFUN([CURL_CHECK_FUNC_FGETXATTR], [
1222 AC_REQUIRE([CURL_INCLUDES_SYS_XATTR])dnl
1223 #
1224 tst_links_fgetxattr="unknown"
1225 tst_proto_fgetxattr="unknown"
1226 tst_compi_fgetxattr="unknown"
1227 tst_allow_fgetxattr="unknown"
1228 tst_nargs_fgetxattr="unknown"
1229 #
1230 AC_MSG_CHECKING([if fgetxattr can be linked])
1231 AC_LINK_IFELSE([
1232 AC_LANG_FUNC_LINK_TRY([fgetxattr])
1233 ],[
1234 AC_MSG_RESULT([yes])
1235 tst_links_fgetxattr="yes"
1236 ],[
1237 AC_MSG_RESULT([no])
1238 tst_links_fgetxattr="no"
1239 ])
1240 #
1241 if test "$tst_links_fgetxattr" = "yes"; then
1242 AC_MSG_CHECKING([if fgetxattr is prototyped])
1243 AC_EGREP_CPP([fgetxattr],[
1244 $curl_includes_sys_xattr
1245 ],[
1246 AC_MSG_RESULT([yes])
1247 tst_proto_fgetxattr="yes"
1248 ],[
1249 AC_MSG_RESULT([no])
1250 tst_proto_fgetxattr="no"
1251 ])
1252 fi
1253 #
1254 if test "$tst_proto_fgetxattr" = "yes"; then
1255 if test "$tst_nargs_fgetxattr" = "unknown"; then
1256 AC_MSG_CHECKING([if fgetxattr takes 4 args.])
1257 AC_COMPILE_IFELSE([
1258 AC_LANG_PROGRAM([[
1259 $curl_includes_sys_xattr
1260 ]],[[
1261 if(0 != fgetxattr(0, 0, 0, 0))
1262 return 1;
1263 ]])
1264 ],[
1265 AC_MSG_RESULT([yes])
1266 tst_compi_fgetxattr="yes"
1267 tst_nargs_fgetxattr="4"
1268 ],[
1269 AC_MSG_RESULT([no])
1270 tst_compi_fgetxattr="no"
1271 ])
1272 fi
1273 if test "$tst_nargs_fgetxattr" = "unknown"; then
1274 AC_MSG_CHECKING([if fgetxattr takes 6 args.])
1275 AC_COMPILE_IFELSE([
1276 AC_LANG_PROGRAM([[
1277 $curl_includes_sys_xattr
1278 ]],[[
1279 if(0 != fgetxattr(0, 0, 0, 0, 0, 0))
1280 return 1;
1281 ]])
1282 ],[
1283 AC_MSG_RESULT([yes])
1284 tst_compi_fgetxattr="yes"
1285 tst_nargs_fgetxattr="6"
1286 ],[
1287 AC_MSG_RESULT([no])
1288 tst_compi_fgetxattr="no"
1289 ])
1290 fi
1291 AC_MSG_CHECKING([if fgetxattr is compilable])
1292 if test "$tst_compi_fgetxattr" = "yes"; then
1293 AC_MSG_RESULT([yes])
1294 else
1295 AC_MSG_RESULT([no])
1296 fi
1297 fi
1298 #
1299 if test "$tst_compi_fgetxattr" = "yes"; then
1300 AC_MSG_CHECKING([if fgetxattr usage allowed])
1301 if test "x$curl_disallow_fgetxattr" != "xyes"; then
1302 AC_MSG_RESULT([yes])
1303 tst_allow_fgetxattr="yes"
1304 else
1305 AC_MSG_RESULT([no])
1306 tst_allow_fgetxattr="no"
1307 fi
1308 fi
1309 #
1310 AC_MSG_CHECKING([if fgetxattr might be used])
1311 if test "$tst_links_fgetxattr" = "yes" &&
1312 test "$tst_proto_fgetxattr" = "yes" &&
1313 test "$tst_compi_fgetxattr" = "yes" &&
1314 test "$tst_allow_fgetxattr" = "yes"; then
1315 AC_MSG_RESULT([yes])
1316 AC_DEFINE_UNQUOTED(HAVE_FGETXATTR, 1,
1317 [Define to 1 if you have the fgetxattr function.])
1318 dnl AC_DEFINE_UNQUOTED(FGETXATTR_ARGS, $tst_nargs_fgetxattr,
1319 dnl [Specifies the number of arguments to fgetxattr])
1320 #
1321 if test "$tst_nargs_fgetxattr" -eq "4"; then
1322 AC_DEFINE(HAVE_FGETXATTR_4, 1, [fgetxattr() takes 4 args])
1323 elif test "$tst_nargs_fgetxattr" -eq "6"; then
1324 AC_DEFINE(HAVE_FGETXATTR_6, 1, [fgetxattr() takes 6 args])
1325 fi
1326 #
1327 curl_cv_func_fgetxattr="yes"
1328 else
1329 AC_MSG_RESULT([no])
1330 curl_cv_func_fgetxattr="no"
1331 fi
1332 ])
1333
1334
1335 dnl CURL_CHECK_FUNC_FLISTXATTR
1336 dnl -------------------------------------------------
1337 dnl Verify if flistxattr is available, prototyped, and
1338 dnl can be compiled. If all of these are true, and
1339 dnl usage has not been previously disallowed with
1340 dnl shell variable curl_disallow_flistxattr, then
1341 dnl HAVE_FLISTXATTR will be defined.
1342
1343 AC_DEFUN([CURL_CHECK_FUNC_FLISTXATTR], [
1344 AC_REQUIRE([CURL_INCLUDES_SYS_XATTR])dnl
1345 #
1346 tst_links_flistxattr="unknown"
1347 tst_proto_flistxattr="unknown"
1348 tst_compi_flistxattr="unknown"
1349 tst_allow_flistxattr="unknown"
1350 tst_nargs_flistxattr="unknown"
1351 #
1352 AC_MSG_CHECKING([if flistxattr can be linked])
1353 AC_LINK_IFELSE([
1354 AC_LANG_FUNC_LINK_TRY([flistxattr])
1355 ],[
1356 AC_MSG_RESULT([yes])
1357 tst_links_flistxattr="yes"
1358 ],[
1359 AC_MSG_RESULT([no])
1360 tst_links_flistxattr="no"
1361 ])
1362 #
1363 if test "$tst_links_flistxattr" = "yes"; then
1364 AC_MSG_CHECKING([if flistxattr is prototyped])
1365 AC_EGREP_CPP([flistxattr],[
1366 $curl_includes_sys_xattr
1367 ],[
1368 AC_MSG_RESULT([yes])
1369 tst_proto_flistxattr="yes"
1370 ],[
1371 AC_MSG_RESULT([no])
1372 tst_proto_flistxattr="no"
1373 ])
1374 fi
1375 #
1376 if test "$tst_proto_flistxattr" = "yes"; then
1377 if test "$tst_nargs_flistxattr" = "unknown"; then
1378 AC_MSG_CHECKING([if flistxattr takes 3 args.])
1379 AC_COMPILE_IFELSE([
1380 AC_LANG_PROGRAM([[
1381 $curl_includes_sys_xattr
1382 ]],[[
1383 if(0 != flistxattr(0, 0, 0))
1384 return 1;
1385 ]])
1386 ],[
1387 AC_MSG_RESULT([yes])
1388 tst_compi_flistxattr="yes"
1389 tst_nargs_flistxattr="3"
1390 ],[
1391 AC_MSG_RESULT([no])
1392 tst_compi_flistxattr="no"
1393 ])
1394 fi
1395 if test "$tst_nargs_flistxattr" = "unknown"; then
1396 AC_MSG_CHECKING([if flistxattr takes 4 args.])
1397 AC_COMPILE_IFELSE([
1398 AC_LANG_PROGRAM([[
1399 $curl_includes_sys_xattr
1400 ]],[[
1401 if(0 != flistxattr(0, 0, 0, 0))
1402 return 1;
1403 ]])
1404 ],[
1405 AC_MSG_RESULT([yes])
1406 tst_compi_flistxattr="yes"
1407 tst_nargs_flistxattr="4"
1408 ],[
1409 AC_MSG_RESULT([no])
1410 tst_compi_flistxattr="no"
1411 ])
1412 fi
1413 AC_MSG_CHECKING([if flistxattr is compilable])
1414 if test "$tst_compi_flistxattr" = "yes"; then
1415 AC_MSG_RESULT([yes])
1416 else
1417 AC_MSG_RESULT([no])
1418 fi
1419 fi
1420 #
1421 if test "$tst_compi_flistxattr" = "yes"; then
1422 AC_MSG_CHECKING([if flistxattr usage allowed])
1423 if test "x$curl_disallow_flistxattr" != "xyes"; then
1424 AC_MSG_RESULT([yes])
1425 tst_allow_flistxattr="yes"
1426 else
1427 AC_MSG_RESULT([no])
1428 tst_allow_flistxattr="no"
1429 fi
1430 fi
1431 #
1432 AC_MSG_CHECKING([if flistxattr might be used])
1433 if test "$tst_links_flistxattr" = "yes" &&
1434 test "$tst_proto_flistxattr" = "yes" &&
1435 test "$tst_compi_flistxattr" = "yes" &&
1436 test "$tst_allow_flistxattr" = "yes"; then
1437 AC_MSG_RESULT([yes])
1438 AC_DEFINE_UNQUOTED(HAVE_FLISTXATTR, 1,
1439 [Define to 1 if you have the flistxattr function.])
1440 dnl AC_DEFINE_UNQUOTED(FLISTXATTR_ARGS, $tst_nargs_flistxattr,
1441 dnl [Specifies the number of arguments to flistxattr])
1442 #
1443 if test "$tst_nargs_flistxattr" -eq "3"; then
1444 AC_DEFINE(HAVE_FLISTXATTR_3, 1, [flistxattr() takes 3 args])
1445 elif test "$tst_nargs_flistxattr" -eq "4"; then
1446 AC_DEFINE(HAVE_FLISTXATTR_4, 1, [flistxattr() takes 4 args])
1447 fi
1448 #
1449 curl_cv_func_flistxattr="yes"
1450 else
1451 AC_MSG_RESULT([no])
1452 curl_cv_func_flistxattr="no"
1453 fi
1454 ])
1455
1456
1457 dnl CURL_CHECK_FUNC_FREEADDRINFO
1458 dnl -------------------------------------------------
1459 dnl Verify if freeaddrinfo is available, prototyped,
1460 dnl and can be compiled. If all of these are true,
1461 dnl and usage has not been previously disallowed with
1462 dnl shell variable curl_disallow_freeaddrinfo, then
1463 dnl HAVE_FREEADDRINFO will be defined.
1464
1465 AC_DEFUN([CURL_CHECK_FUNC_FREEADDRINFO], [
1466 AC_REQUIRE([CURL_INCLUDES_WS2TCPIP])dnl
1467 AC_REQUIRE([CURL_INCLUDES_SYS_SOCKET])dnl
1468 AC_REQUIRE([CURL_INCLUDES_NETDB])dnl
1469 #
1470 tst_links_freeaddrinfo="unknown"
1471 tst_proto_freeaddrinfo="unknown"
1472 tst_compi_freeaddrinfo="unknown"
1473 tst_allow_freeaddrinfo="unknown"
1474 #
1475 AC_MSG_CHECKING([if freeaddrinfo can be linked])
1476 AC_LINK_IFELSE([
1477 AC_LANG_PROGRAM([[
1478 $curl_includes_ws2tcpip
1479 $curl_includes_sys_socket
1480 $curl_includes_netdb
1481 ]],[[
1482 freeaddrinfo(0);
1483 ]])
1484 ],[
1485 AC_MSG_RESULT([yes])
1486 tst_links_freeaddrinfo="yes"
1487 ],[
1488 AC_MSG_RESULT([no])
1489 tst_links_freeaddrinfo="no"
1490 ])
1491 #
1492 if test "$tst_links_freeaddrinfo" = "yes"; then
1493 AC_MSG_CHECKING([if freeaddrinfo is prototyped])
1494 AC_EGREP_CPP([freeaddrinfo],[
1495 $curl_includes_ws2tcpip
1496 $curl_includes_sys_socket
1497 $curl_includes_netdb
1498 ],[
1499 AC_MSG_RESULT([yes])
1500 tst_proto_freeaddrinfo="yes"
1501 ],[
1502 AC_MSG_RESULT([no])
1503 tst_proto_freeaddrinfo="no"
1504 ])
1505 fi
1506 #
1507 if test "$tst_proto_freeaddrinfo" = "yes"; then
1508 AC_MSG_CHECKING([if freeaddrinfo is compilable])
1509 AC_COMPILE_IFELSE([
1510 AC_LANG_PROGRAM([[
1511 $curl_includes_ws2tcpip
1512 $curl_includes_sys_socket
1513 $curl_includes_netdb
1514 ]],[[
1515 freeaddrinfo(0);
1516 ]])
1517 ],[
1518 AC_MSG_RESULT([yes])
1519 tst_compi_freeaddrinfo="yes"
1520 ],[
1521 AC_MSG_RESULT([no])
1522 tst_compi_freeaddrinfo="no"
1523 ])
1524 fi
1525 #
1526 if test "$tst_compi_freeaddrinfo" = "yes"; then
1527 AC_MSG_CHECKING([if freeaddrinfo usage allowed])
1528 if test "x$curl_disallow_freeaddrinfo" != "xyes"; then
1529 AC_MSG_RESULT([yes])
1530 tst_allow_freeaddrinfo="yes"
1531 else
1532 AC_MSG_RESULT([no])
1533 tst_allow_freeaddrinfo="no"
1534 fi
1535 fi
1536 #
1537 AC_MSG_CHECKING([if freeaddrinfo might be used])
1538 if test "$tst_links_freeaddrinfo" = "yes" &&
1539 test "$tst_proto_freeaddrinfo" = "yes" &&
1540 test "$tst_compi_freeaddrinfo" = "yes" &&
1541 test "$tst_allow_freeaddrinfo" = "yes"; then
1542 AC_MSG_RESULT([yes])
1543 AC_DEFINE_UNQUOTED(HAVE_FREEADDRINFO, 1,
1544 [Define to 1 if you have the freeaddrinfo function.])
1545 curl_cv_func_freeaddrinfo="yes"
1546 else
1547 AC_MSG_RESULT([no])
1548 curl_cv_func_freeaddrinfo="no"
1549 fi
1550 ])
1551
1552
1553 dnl CURL_CHECK_FUNC_FREEIFADDRS
1554 dnl -------------------------------------------------
1555 dnl Verify if freeifaddrs is available, prototyped, and
1556 dnl can be compiled. If all of these are true, and
1557 dnl usage has not been previously disallowed with
1558 dnl shell variable curl_disallow_freeifaddrs, then
1559 dnl HAVE_FREEIFADDRS will be defined.
1560
1561 AC_DEFUN([CURL_CHECK_FUNC_FREEIFADDRS], [
1562 AC_REQUIRE([CURL_INCLUDES_IFADDRS])dnl
1563 #
1564 tst_links_freeifaddrs="unknown"
1565 tst_proto_freeifaddrs="unknown"
1566 tst_compi_freeifaddrs="unknown"
1567 tst_allow_freeifaddrs="unknown"
1568 #
1569 AC_MSG_CHECKING([if freeifaddrs can be linked])
1570 AC_LINK_IFELSE([
1571 AC_LANG_FUNC_LINK_TRY([freeifaddrs])
1572 ],[
1573 AC_MSG_RESULT([yes])
1574 tst_links_freeifaddrs="yes"
1575 ],[
1576 AC_MSG_RESULT([no])
1577 tst_links_freeifaddrs="no"
1578 ])
1579 #
1580 if test "$tst_links_freeifaddrs" = "yes"; then
1581 AC_MSG_CHECKING([if freeifaddrs is prototyped])
1582 AC_EGREP_CPP([freeifaddrs],[
1583 $curl_includes_ifaddrs
1584 ],[
1585 AC_MSG_RESULT([yes])
1586 tst_proto_freeifaddrs="yes"
1587 ],[
1588 AC_MSG_RESULT([no])
1589 tst_proto_freeifaddrs="no"
1590 ])
1591 fi
1592 #
1593 if test "$tst_proto_freeifaddrs" = "yes"; then
1594 AC_MSG_CHECKING([if freeifaddrs is compilable])
1595 AC_COMPILE_IFELSE([
1596 AC_LANG_PROGRAM([[
1597 $curl_includes_ifaddrs
1598 ]],[[
1599 freeifaddrs(0);
1600 ]])
1601 ],[
1602 AC_MSG_RESULT([yes])
1603 tst_compi_freeifaddrs="yes"
1604 ],[
1605 AC_MSG_RESULT([no])
1606 tst_compi_freeifaddrs="no"
1607 ])
1608 fi
1609 #
1610 if test "$tst_compi_freeifaddrs" = "yes"; then
1611 AC_MSG_CHECKING([if freeifaddrs usage allowed])
1612 if test "x$curl_disallow_freeifaddrs" != "xyes"; then
1613 AC_MSG_RESULT([yes])
1614 tst_allow_freeifaddrs="yes"
1615 else
1616 AC_MSG_RESULT([no])
1617 tst_allow_freeifaddrs="no"
1618 fi
1619 fi
1620 #
1621 AC_MSG_CHECKING([if freeifaddrs might be used])
1622 if test "$tst_links_freeifaddrs" = "yes" &&
1623 test "$tst_proto_freeifaddrs" = "yes" &&
1624 test "$tst_compi_freeifaddrs" = "yes" &&
1625 test "$tst_allow_freeifaddrs" = "yes"; then
1626 AC_MSG_RESULT([yes])
1627 AC_DEFINE_UNQUOTED(HAVE_FREEIFADDRS, 1,
1628 [Define to 1 if you have the freeifaddrs function.])
1629 curl_cv_func_freeifaddrs="yes"
1630 else
1631 AC_MSG_RESULT([no])
1632 curl_cv_func_freeifaddrs="no"
1633 fi
1634 ])
1635
1636
1637 dnl CURL_CHECK_FUNC_FREMOVEXATTR
1638 dnl -------------------------------------------------
1639 dnl Verify if fremovexattr is available, prototyped, and
1640 dnl can be compiled. If all of these are true, and
1641 dnl usage has not been previously disallowed with
1642 dnl shell variable curl_disallow_fremovexattr, then
1643 dnl HAVE_FREMOVEXATTR will be defined.
1644
1645 AC_DEFUN([CURL_CHECK_FUNC_FREMOVEXATTR], [
1646 AC_REQUIRE([CURL_INCLUDES_SYS_XATTR])dnl
1647 #
1648 tst_links_fremovexattr="unknown"
1649 tst_proto_fremovexattr="unknown"
1650 tst_compi_fremovexattr="unknown"
1651 tst_allow_fremovexattr="unknown"
1652 tst_nargs_fremovexattr="unknown"
1653 #
1654 AC_MSG_CHECKING([if fremovexattr can be linked])
1655 AC_LINK_IFELSE([
1656 AC_LANG_FUNC_LINK_TRY([fremovexattr])
1657 ],[
1658 AC_MSG_RESULT([yes])
1659 tst_links_fremovexattr="yes"
1660 ],[
1661 AC_MSG_RESULT([no])
1662 tst_links_fremovexattr="no"
1663 ])
1664 #
1665 if test "$tst_links_fremovexattr" = "yes"; then
1666 AC_MSG_CHECKING([if fremovexattr is prototyped])
1667 AC_EGREP_CPP([fremovexattr],[
1668 $curl_includes_sys_xattr
1669 ],[
1670 AC_MSG_RESULT([yes])
1671 tst_proto_fremovexattr="yes"
1672 ],[
1673 AC_MSG_RESULT([no])
1674 tst_proto_fremovexattr="no"
1675 ])
1676 fi
1677 #
1678 if test "$tst_proto_fremovexattr" = "yes"; then
1679 if test "$tst_nargs_fremovexattr" = "unknown"; then
1680 AC_MSG_CHECKING([if fremovexattr takes 2 args.])
1681 AC_COMPILE_IFELSE([
1682 AC_LANG_PROGRAM([[
1683 $curl_includes_sys_xattr
1684 ]],[[
1685 if(0 != fremovexattr(0, 0))
1686 return 1;
1687 ]])
1688 ],[
1689 AC_MSG_RESULT([yes])
1690 tst_compi_fremovexattr="yes"
1691 tst_nargs_fremovexattr="2"
1692 ],[
1693 AC_MSG_RESULT([no])
1694 tst_compi_fremovexattr="no"
1695 ])
1696 fi
1697 if test "$tst_nargs_fremovexattr" = "unknown"; then
1698 AC_MSG_CHECKING([if fremovexattr takes 3 args.])
1699 AC_COMPILE_IFELSE([
1700 AC_LANG_PROGRAM([[
1701 $curl_includes_sys_xattr
1702 ]],[[
1703 if(0 != fremovexattr(0, 0, 0))
1704 return 1;
1705 ]])
1706 ],[
1707 AC_MSG_RESULT([yes])
1708 tst_compi_fremovexattr="yes"
1709 tst_nargs_fremovexattr="3"
1710 ],[
1711 AC_MSG_RESULT([no])
1712 tst_compi_fremovexattr="no"
1713 ])
1714 fi
1715 AC_MSG_CHECKING([if fremovexattr is compilable])
1716 if test "$tst_compi_fremovexattr" = "yes"; then
1717 AC_MSG_RESULT([yes])
1718 else
1719 AC_MSG_RESULT([no])
1720 fi
1721 fi
1722 #
1723 if test "$tst_compi_fremovexattr" = "yes"; then
1724 AC_MSG_CHECKING([if fremovexattr usage allowed])
1725 if test "x$curl_disallow_fremovexattr" != "xyes"; then
1726 AC_MSG_RESULT([yes])
1727 tst_allow_fremovexattr="yes"
1728 else
1729 AC_MSG_RESULT([no])
1730 tst_allow_fremovexattr="no"
1731 fi
1732 fi
1733 #
1734 AC_MSG_CHECKING([if fremovexattr might be used])
1735 if test "$tst_links_fremovexattr" = "yes" &&
1736 test "$tst_proto_fremovexattr" = "yes" &&
1737 test "$tst_compi_fremovexattr" = "yes" &&
1738 test "$tst_allow_fremovexattr" = "yes"; then
1739 AC_MSG_RESULT([yes])
1740 AC_DEFINE_UNQUOTED(HAVE_FREMOVEXATTR, 1,
1741 [Define to 1 if you have the fremovexattr function.])
1742 dnl AC_DEFINE_UNQUOTED(FREMOVEXATTR_ARGS, $tst_nargs_fremovexattr,
1743 dnl [Specifies the number of arguments to fremovexattr])
1744 #
1745 if test "$tst_nargs_fremovexattr" -eq "2"; then
1746 AC_DEFINE(HAVE_FREMOVEXATTR_2, 1, [fremovexattr() takes 2 args])
1747 elif test "$tst_nargs_fremovexattr" -eq "3"; then
1748 AC_DEFINE(HAVE_FREMOVEXATTR_3, 1, [fremovexattr() takes 3 args])
1749 fi
1750 #
1751 curl_cv_func_fremovexattr="yes"
1752 else
1753 AC_MSG_RESULT([no])
1754 curl_cv_func_fremovexattr="no"
1755 fi
1756 ])
1757
1758
1759 dnl CURL_CHECK_FUNC_FSETXATTR
1760 dnl -------------------------------------------------
1761 dnl Verify if fsetxattr is available, prototyped, and
1762 dnl can be compiled. If all of these are true, and
1763 dnl usage has not been previously disallowed with
1764 dnl shell variable curl_disallow_fsetxattr, then
1765 dnl HAVE_FSETXATTR will be defined.
1766
1767 AC_DEFUN([CURL_CHECK_FUNC_FSETXATTR], [
1768 AC_REQUIRE([CURL_INCLUDES_SYS_XATTR])dnl
1769 #
1770 tst_links_fsetxattr="unknown"
1771 tst_proto_fsetxattr="unknown"
1772 tst_compi_fsetxattr="unknown"
1773 tst_allow_fsetxattr="unknown"
1774 tst_nargs_fsetxattr="unknown"
1775 #
1776 AC_MSG_CHECKING([if fsetxattr can be linked])
1777 AC_LINK_IFELSE([
1778 AC_LANG_FUNC_LINK_TRY([fsetxattr])
1779 ],[
1780 AC_MSG_RESULT([yes])
1781 tst_links_fsetxattr="yes"
1782 ],[
1783 AC_MSG_RESULT([no])
1784 tst_links_fsetxattr="no"
1785 ])
1786 #
1787 if test "$tst_links_fsetxattr" = "yes"; then
1788 AC_MSG_CHECKING([if fsetxattr is prototyped])
1789 AC_EGREP_CPP([fsetxattr],[
1790 $curl_includes_sys_xattr
1791 ],[
1792 AC_MSG_RESULT([yes])
1793 tst_proto_fsetxattr="yes"
1794 ],[
1795 AC_MSG_RESULT([no])
1796 tst_proto_fsetxattr="no"
1797 ])
1798 fi
1799 #
1800 if test "$tst_proto_fsetxattr" = "yes"; then
1801 if test "$tst_nargs_fsetxattr" = "unknown"; then
1802 AC_MSG_CHECKING([if fsetxattr takes 5 args.])
1803 AC_COMPILE_IFELSE([
1804 AC_LANG_PROGRAM([[
1805 $curl_includes_sys_xattr
1806 ]],[[
1807 if(0 != fsetxattr(0, 0, 0, 0, 0))
1808 return 1;
1809 ]])
1810 ],[
1811 AC_MSG_RESULT([yes])
1812 tst_compi_fsetxattr="yes"
1813 tst_nargs_fsetxattr="5"
1814 ],[
1815 AC_MSG_RESULT([no])
1816 tst_compi_fsetxattr="no"
1817 ])
1818 fi
1819 if test "$tst_nargs_fsetxattr" = "unknown"; then
1820 AC_MSG_CHECKING([if fsetxattr takes 6 args.])
1821 AC_COMPILE_IFELSE([
1822 AC_LANG_PROGRAM([[
1823 $curl_includes_sys_xattr
1824 ]],[[
1825 if(0 != fsetxattr(0, 0, 0, 0, 0, 0))
1826 return 1;
1827 ]])
1828 ],[
1829 AC_MSG_RESULT([yes])
1830 tst_compi_fsetxattr="yes"
1831 tst_nargs_fsetxattr="6"
1832 ],[
1833 AC_MSG_RESULT([no])
1834 tst_compi_fsetxattr="no"
1835 ])
1836 fi
1837 AC_MSG_CHECKING([if fsetxattr is compilable])
1838 if test "$tst_compi_fsetxattr" = "yes"; then
1839 AC_MSG_RESULT([yes])
1840 else
1841 AC_MSG_RESULT([no])
1842 fi
1843 fi
1844 #
1845 if test "$tst_compi_fsetxattr" = "yes"; then
1846 AC_MSG_CHECKING([if fsetxattr usage allowed])
1847 if test "x$curl_disallow_fsetxattr" != "xyes"; then
1848 AC_MSG_RESULT([yes])
1849 tst_allow_fsetxattr="yes"
1850 else
1851 AC_MSG_RESULT([no])
1852 tst_allow_fsetxattr="no"
1853 fi
1854 fi
1855 #
1856 AC_MSG_CHECKING([if fsetxattr might be used])
1857 if test "$tst_links_fsetxattr" = "yes" &&
1858 test "$tst_proto_fsetxattr" = "yes" &&
1859 test "$tst_compi_fsetxattr" = "yes" &&
1860 test "$tst_allow_fsetxattr" = "yes"; then
1861 AC_MSG_RESULT([yes])
1862 AC_DEFINE_UNQUOTED(HAVE_FSETXATTR, 1,
1863 [Define to 1 if you have the fsetxattr function.])
1864 dnl AC_DEFINE_UNQUOTED(FSETXATTR_ARGS, $tst_nargs_fsetxattr,
1865 dnl [Specifies the number of arguments to fsetxattr])
1866 #
1867 if test "$tst_nargs_fsetxattr" -eq "5"; then
1868 AC_DEFINE(HAVE_FSETXATTR_5, 1, [fsetxattr() takes 5 args])
1869 elif test "$tst_nargs_fsetxattr" -eq "6"; then
1870 AC_DEFINE(HAVE_FSETXATTR_6, 1, [fsetxattr() takes 6 args])
1871 fi
1872 #
1873 curl_cv_func_fsetxattr="yes"
1874 else
1875 AC_MSG_RESULT([no])
1876 curl_cv_func_fsetxattr="no"
1877 fi
1878 ])
1879
1880
1881 dnl CURL_CHECK_FUNC_FTRUNCATE
1882 dnl -------------------------------------------------
1883 dnl Verify if ftruncate is available, prototyped, and
1884 dnl can be compiled. If all of these are true, and
1885 dnl usage has not been previously disallowed with
1886 dnl shell variable curl_disallow_ftruncate, then
1887 dnl HAVE_FTRUNCATE will be defined.
1888
1889 AC_DEFUN([CURL_CHECK_FUNC_FTRUNCATE], [
1890 AC_REQUIRE([CURL_INCLUDES_UNISTD])dnl
1891 #
1892 tst_links_ftruncate="unknown"
1893 tst_proto_ftruncate="unknown"
1894 tst_compi_ftruncate="unknown"
1895 tst_allow_ftruncate="unknown"
1896 #
1897 AC_MSG_CHECKING([if ftruncate can be linked])
1898 AC_LINK_IFELSE([
1899 AC_LANG_FUNC_LINK_TRY([ftruncate])
1900 ],[
1901 AC_MSG_RESULT([yes])
1902 tst_links_ftruncate="yes"
1903 ],[
1904 AC_MSG_RESULT([no])
1905 tst_links_ftruncate="no"
1906 ])
1907 #
1908 if test "$tst_links_ftruncate" = "yes"; then
1909 AC_MSG_CHECKING([if ftruncate is prototyped])
1910 AC_EGREP_CPP([ftruncate],[
1911 $curl_includes_unistd
1912 ],[
1913 AC_MSG_RESULT([yes])
1914 tst_proto_ftruncate="yes"
1915 ],[
1916 AC_MSG_RESULT([no])
1917 tst_proto_ftruncate="no"
1918 ])
1919 fi
1920 #
1921 if test "$tst_proto_ftruncate" = "yes"; then
1922 AC_MSG_CHECKING([if ftruncate is compilable])
1923 AC_COMPILE_IFELSE([
1924 AC_LANG_PROGRAM([[
1925 $curl_includes_unistd
1926 ]],[[
1927 if(0 != ftruncate(0, 0))
1928 return 1;
1929 ]])
1930 ],[
1931 AC_MSG_RESULT([yes])
1932 tst_compi_ftruncate="yes"
1933 ],[
1934 AC_MSG_RESULT([no])
1935 tst_compi_ftruncate="no"
1936 ])
1937 fi
1938 #
1939 if test "$tst_compi_ftruncate" = "yes"; then
1940 AC_MSG_CHECKING([if ftruncate usage allowed])
1941 if test "x$curl_disallow_ftruncate" != "xyes"; then
1942 AC_MSG_RESULT([yes])
1943 tst_allow_ftruncate="yes"
1944 else
1945 AC_MSG_RESULT([no])
1946 tst_allow_ftruncate="no"
1947 fi
1948 fi
1949 #
1950 AC_MSG_CHECKING([if ftruncate might be used])
1951 if test "$tst_links_ftruncate" = "yes" &&
1952 test "$tst_proto_ftruncate" = "yes" &&
1953 test "$tst_compi_ftruncate" = "yes" &&
1954 test "$tst_allow_ftruncate" = "yes"; then
1955 AC_MSG_RESULT([yes])
1956 AC_DEFINE_UNQUOTED(HAVE_FTRUNCATE, 1,
1957 [Define to 1 if you have the ftruncate function.])
1958 curl_cv_func_ftruncate="yes"
1959 else
1960 AC_MSG_RESULT([no])
1961 curl_cv_func_ftruncate="no"
1962 fi
1963 ])
1964
1965
1966 dnl CURL_CHECK_FUNC_GETADDRINFO
1967 dnl -------------------------------------------------
1968 dnl Verify if getaddrinfo is available, prototyped, can
1969 dnl be compiled and seems to work. If all of these are
1970 dnl true, and usage has not been previously disallowed
1971 dnl with shell variable curl_disallow_getaddrinfo, then
1972 dnl HAVE_GETADDRINFO will be defined. Additionally when
1973 dnl HAVE_GETADDRINFO gets defined this will also attempt
1974 dnl to find out if getaddrinfo happens to be threadsafe,
1975 dnl defining HAVE_GETADDRINFO_THREADSAFE when true.
1976
1977 AC_DEFUN([CURL_CHECK_FUNC_GETADDRINFO], [
1978 AC_REQUIRE([CURL_INCLUDES_WS2TCPIP])dnl
1979 AC_REQUIRE([CURL_INCLUDES_STDLIB])dnl
1980 AC_REQUIRE([CURL_INCLUDES_STRING])dnl
1981 AC_REQUIRE([CURL_INCLUDES_SYS_SOCKET])dnl
1982 AC_REQUIRE([CURL_INCLUDES_NETDB])dnl
1983 AC_REQUIRE([CURL_CHECK_NATIVE_WINDOWS])dnl
1984 #
1985 tst_links_getaddrinfo="unknown"
1986 tst_proto_getaddrinfo="unknown"
1987 tst_compi_getaddrinfo="unknown"
1988 tst_works_getaddrinfo="unknown"
1989 tst_allow_getaddrinfo="unknown"
1990 tst_tsafe_getaddrinfo="unknown"
1991 #
1992 AC_MSG_CHECKING([if getaddrinfo can be linked])
1993 AC_LINK_IFELSE([
1994 AC_LANG_PROGRAM([[
1995 $curl_includes_ws2tcpip
1996 $curl_includes_sys_socket
1997 $curl_includes_netdb
1998 ]],[[
1999 if(0 != getaddrinfo(0, 0, 0, 0))
2000 return 1;
2001 ]])
2002 ],[
2003 AC_MSG_RESULT([yes])
2004 tst_links_getaddrinfo="yes"
2005 ],[
2006 AC_MSG_RESULT([no])
2007 tst_links_getaddrinfo="no"
2008 ])
2009 #
2010 if test "$tst_links_getaddrinfo" = "yes"; then
2011 AC_MSG_CHECKING([if getaddrinfo is prototyped])
2012 AC_EGREP_CPP([getaddrinfo],[
2013 $curl_includes_ws2tcpip
2014 $curl_includes_sys_socket
2015 $curl_includes_netdb
2016 ],[
2017 AC_MSG_RESULT([yes])
2018 tst_proto_getaddrinfo="yes"
2019 ],[
2020 AC_MSG_RESULT([no])
2021 tst_proto_getaddrinfo="no"
2022 ])
2023 fi
2024 #
2025 if test "$tst_proto_getaddrinfo" = "yes"; then
2026 AC_MSG_CHECKING([if getaddrinfo is compilable])
2027 AC_COMPILE_IFELSE([
2028 AC_LANG_PROGRAM([[
2029 $curl_includes_ws2tcpip
2030 $curl_includes_sys_socket
2031 $curl_includes_netdb
2032 ]],[[
2033 if(0 != getaddrinfo(0, 0, 0, 0))
2034 return 1;
2035 ]])
2036 ],[
2037 AC_MSG_RESULT([yes])
2038 tst_compi_getaddrinfo="yes"
2039 ],[
2040 AC_MSG_RESULT([no])
2041 tst_compi_getaddrinfo="no"
2042 ])
2043 fi
2044 #
2045 dnl only do runtime verification when not cross-compiling
2046 if test "x$cross_compiling" != "xyes" &&
2047 test "$tst_compi_getaddrinfo" = "yes"; then
2048 AC_MSG_CHECKING([if getaddrinfo seems to work])
2049 CURL_RUN_IFELSE([
2050 AC_LANG_PROGRAM([[
2051 $curl_includes_ws2tcpip
2052 $curl_includes_stdlib
2053 $curl_includes_string
2054 $curl_includes_sys_socket
2055 $curl_includes_netdb
2056 ]],[[
2057 struct addrinfo hints;
2058 struct addrinfo *ai = 0;
2059 int error;
2060
2061 #ifdef HAVE_WINSOCK2_H
2062 WSADATA wsa;
2063 if (WSAStartup(MAKEWORD(2,2), &wsa))
2064 exit(2);
2065 #endif
2066
2067 memset(&hints, 0, sizeof(hints));
2068 hints.ai_flags = AI_NUMERICHOST;
2069 hints.ai_family = AF_UNSPEC;
2070 hints.ai_socktype = SOCK_STREAM;
2071 error = getaddrinfo("127.0.0.1", 0, &hints, &ai);
2072 if(error || !ai)
2073 exit(1); /* fail */
2074 else
2075 exit(0);
2076 ]])
2077 ],[
2078 AC_MSG_RESULT([yes])
2079 tst_works_getaddrinfo="yes"
2080 ],[
2081 AC_MSG_RESULT([no])
2082 tst_works_getaddrinfo="no"
2083 ])
2084 fi
2085 #
2086 if test "$tst_compi_getaddrinfo" = "yes" &&
2087 test "$tst_works_getaddrinfo" != "no"; then
2088 AC_MSG_CHECKING([if getaddrinfo usage allowed])
2089 if test "x$curl_disallow_getaddrinfo" != "xyes"; then
2090 AC_MSG_RESULT([yes])
2091 tst_allow_getaddrinfo="yes"
2092 else
2093 AC_MSG_RESULT([no])
2094 tst_allow_getaddrinfo="no"
2095 fi
2096 fi
2097 #
2098 AC_MSG_CHECKING([if getaddrinfo might be used])
2099 if test "$tst_links_getaddrinfo" = "yes" &&
2100 test "$tst_proto_getaddrinfo" = "yes" &&
2101 test "$tst_compi_getaddrinfo" = "yes" &&
2102 test "$tst_allow_getaddrinfo" = "yes" &&
2103 test "$tst_works_getaddrinfo" != "no"; then
2104 AC_MSG_RESULT([yes])
2105 AC_DEFINE_UNQUOTED(HAVE_GETADDRINFO, 1,
2106 [Define to 1 if you have a working getaddrinfo function.])
2107 curl_cv_func_getaddrinfo="yes"
2108 else
2109 AC_MSG_RESULT([no])
2110 curl_cv_func_getaddrinfo="no"
2111 curl_cv_func_getaddrinfo_threadsafe="no"
2112 fi
2113 #
2114 if test "$curl_cv_func_getaddrinfo" = "yes"; then
2115 AC_MSG_CHECKING([if getaddrinfo is threadsafe])
2116 case $host_os in
2117 aix[[1234]].* | aix5.[[01]].*)
2118 dnl aix 5.1 and older
2119 tst_tsafe_getaddrinfo="no"
2120 ;;
2121 aix*)
2122 dnl aix 5.2 and newer
2123 tst_tsafe_getaddrinfo="yes"
2124 ;;
2125 darwin[[12345]].*)
2126 dnl darwin 5.0 and mac os x 10.1.X and older
2127 tst_tsafe_getaddrinfo="no"
2128 ;;
2129 darwin*)
2130 dnl darwin 6.0 and mac os x 10.2.X and newer
2131 tst_tsafe_getaddrinfo="yes"
2132 ;;
2133 freebsd[[1234]].* | freebsd5.[[1234]]*)
2134 dnl freebsd 5.4 and older
2135 tst_tsafe_getaddrinfo="no"
2136 ;;
2137 freebsd*)
2138 dnl freebsd 5.5 and newer
2139 tst_tsafe_getaddrinfo="yes"
2140 ;;
2141 hpux[[123456789]].* | hpux10.* | hpux11.0* | hpux11.10*)
2142 dnl hpux 11.10 and older
2143 tst_tsafe_getaddrinfo="no"
2144 ;;
2145 hpux*)
2146 dnl hpux 11.11 and newer
2147 tst_tsafe_getaddrinfo="yes"
2148 ;;
2149 netbsd[[123]].*)
2150 dnl netbsd 3.X and older
2151 tst_tsafe_getaddrinfo="no"
2152 ;;
2153 netbsd*)
2154 dnl netbsd 4.X and newer
2155 tst_tsafe_getaddrinfo="yes"
2156 ;;
2157 *bsd*)
2158 dnl All other bsd's
2159 tst_tsafe_getaddrinfo="no"
2160 ;;
2161 solaris2*)
2162 dnl solaris which have it
2163 tst_tsafe_getaddrinfo="yes"
2164 ;;
2165 esac
2166 if test "$tst_tsafe_getaddrinfo" = "unknown" &&
2167 test "$curl_cv_native_windows" = "yes"; then
2168 tst_tsafe_getaddrinfo="yes"
2169 fi
2170 if test "$tst_tsafe_getaddrinfo" = "unknown"; then
2171 CURL_CHECK_DEF_CC([h_errno], [
2172 $curl_includes_sys_socket
2173 $curl_includes_netdb
2174 ], [silent])
2175 if test "$curl_cv_have_def_h_errno" = "yes"; then
2176 tst_h_errno_macro="yes"
2177 else
2178 tst_h_errno_macro="no"
2179 fi
2180 AC_COMPILE_IFELSE([
2181 AC_LANG_PROGRAM([[
2182 $curl_includes_sys_socket
2183 $curl_includes_netdb
2184 ]],[[
2185 h_errno = 2;
2186 if(0 != h_errno)
2187 return 1;
2188 ]])
2189 ],[
2190 tst_h_errno_modifiable_lvalue="yes"
2191 ],[
2192 tst_h_errno_modifiable_lvalue="no"
2193 ])
2194 AC_COMPILE_IFELSE([
2195 AC_LANG_PROGRAM([[
2196 ]],[[
2197 #if defined(_POSIX_C_SOURCE) && (_POSIX_C_SOURCE >= 200809L)
2198 return 0;
2199 #elif defined(_XOPEN_SOURCE) && (_XOPEN_SOURCE >= 700)
2200 return 0;
2201 #else
2202 force compilation error
2203 #endif
2204 ]])
2205 ],[
2206 tst_h_errno_sbs_issue_7="yes"
2207 ],[
2208 tst_h_errno_sbs_issue_7="no"
2209 ])
2210 if test "$tst_h_errno_macro" = "no" &&
2211 test "$tst_h_errno_modifiable_lvalue" = "no" &&
2212 test "$tst_h_errno_sbs_issue_7" = "no"; then
2213 tst_tsafe_getaddrinfo="no"
2214 else
2215 tst_tsafe_getaddrinfo="yes"
2216 fi
2217 fi
2218 AC_MSG_RESULT([$tst_tsafe_getaddrinfo])
2219 if test "$tst_tsafe_getaddrinfo" = "yes"; then
2220 AC_DEFINE_UNQUOTED(HAVE_GETADDRINFO_THREADSAFE, 1,
2221 [Define to 1 if the getaddrinfo function is threadsafe.])
2222 curl_cv_func_getaddrinfo_threadsafe="yes"
2223 else
2224 curl_cv_func_getaddrinfo_threadsafe="no"
2225 fi
2226 fi
2227 ])
2228
2229
2230 dnl CURL_CHECK_FUNC_GETHOSTBYADDR
2231 dnl -------------------------------------------------
2232 dnl Verify if gethostbyaddr is available, prototyped,
2233 dnl and can be compiled. If all of these are true,
2234 dnl and usage has not been previously disallowed with
2235 dnl shell variable curl_disallow_gethostbyaddr, then
2236 dnl HAVE_GETHOSTBYADDR will be defined.
2237
2238 AC_DEFUN([CURL_CHECK_FUNC_GETHOSTBYADDR], [
2239 AC_REQUIRE([CURL_INCLUDES_WINSOCK2])dnl
2240 AC_REQUIRE([CURL_INCLUDES_NETDB])dnl
2241 #
2242 tst_links_gethostbyaddr="unknown"
2243 tst_proto_gethostbyaddr="unknown"
2244 tst_compi_gethostbyaddr="unknown"
2245 tst_allow_gethostbyaddr="unknown"
2246 #
2247 AC_MSG_CHECKING([if gethostbyaddr can be linked])
2248 AC_LINK_IFELSE([
2249 AC_LANG_PROGRAM([[
2250 $curl_includes_winsock2
2251 $curl_includes_bsdsocket
2252 $curl_includes_netdb
2253 ]],[[
2254 if(0 != gethostbyaddr(0, 0, 0))
2255 return 1;
2256 ]])
2257 ],[
2258 AC_MSG_RESULT([yes])
2259 tst_links_gethostbyaddr="yes"
2260 ],[
2261 AC_MSG_RESULT([no])
2262 tst_links_gethostbyaddr="no"
2263 ])
2264 #
2265 if test "$tst_links_gethostbyaddr" = "yes"; then
2266 AC_MSG_CHECKING([if gethostbyaddr is prototyped])
2267 AC_EGREP_CPP([gethostbyaddr],[
2268 $curl_includes_winsock2
2269 $curl_includes_bsdsocket
2270 $curl_includes_netdb
2271 ],[
2272 AC_MSG_RESULT([yes])
2273 tst_proto_gethostbyaddr="yes"
2274 ],[
2275 AC_MSG_RESULT([no])
2276 tst_proto_gethostbyaddr="no"
2277 ])
2278 fi
2279 #
2280 if test "$tst_proto_gethostbyaddr" = "yes"; then
2281 AC_MSG_CHECKING([if gethostbyaddr is compilable])
2282 AC_COMPILE_IFELSE([
2283 AC_LANG_PROGRAM([[
2284 $curl_includes_winsock2
2285 $curl_includes_bsdsocket
2286 $curl_includes_netdb
2287 ]],[[
2288 if(0 != gethostbyaddr(0, 0, 0))
2289 return 1;
2290 ]])
2291 ],[
2292 AC_MSG_RESULT([yes])
2293 tst_compi_gethostbyaddr="yes"
2294 ],[
2295 AC_MSG_RESULT([no])
2296 tst_compi_gethostbyaddr="no"
2297 ])
2298 fi
2299 #
2300 if test "$tst_compi_gethostbyaddr" = "yes"; then
2301 AC_MSG_CHECKING([if gethostbyaddr usage allowed])
2302 if test "x$curl_disallow_gethostbyaddr" != "xyes"; then
2303 AC_MSG_RESULT([yes])
2304 tst_allow_gethostbyaddr="yes"
2305 else
2306 AC_MSG_RESULT([no])
2307 tst_allow_gethostbyaddr="no"
2308 fi
2309 fi
2310 #
2311 AC_MSG_CHECKING([if gethostbyaddr might be used])
2312 if test "$tst_links_gethostbyaddr" = "yes" &&
2313 test "$tst_proto_gethostbyaddr" = "yes" &&
2314 test "$tst_compi_gethostbyaddr" = "yes" &&
2315 test "$tst_allow_gethostbyaddr" = "yes"; then
2316 AC_MSG_RESULT([yes])
2317 AC_DEFINE_UNQUOTED(HAVE_GETHOSTBYADDR, 1,
2318 [Define to 1 if you have the gethostbyaddr function.])
2319 curl_cv_func_gethostbyaddr="yes"
2320 else
2321 AC_MSG_RESULT([no])
2322 curl_cv_func_gethostbyaddr="no"
2323 fi
2324 ])
2325
2326 dnl CURL_CHECK_FUNC_GAI_STRERROR
2327 dnl -------------------------------------------------
2328 dnl Verify if gai_strerror is available, prototyped,
2329 dnl and can be compiled. If all of these are true,
2330 dnl and usage has not been previously disallowed with
2331 dnl shell variable curl_disallow_gai_strerror, then
2332 dnl HAVE_GAI_STRERROR will be defined.
2333
2334 AC_DEFUN([CURL_CHECK_FUNC_GAI_STRERROR], [
2335 AC_REQUIRE([CURL_INCLUDES_WINSOCK2])dnl
2336 AC_REQUIRE([CURL_INCLUDES_NETDB])dnl
2337 #
2338 tst_links_gai_strerror="unknown"
2339 tst_proto_gai_strerror="unknown"
2340 tst_compi_gai_strerror="unknown"
2341 tst_allow_gai_strerror="unknown"
2342 #
2343 AC_MSG_CHECKING([if gai_strerror can be linked])
2344 AC_LINK_IFELSE([
2345 AC_LANG_PROGRAM([[
2346 $curl_includes_winsock2
2347 $curl_includes_bsdsocket
2348 $curl_includes_netdb
2349 ]],[[
2350 if(0 != gai_strerror(0))
2351 return 1;
2352 ]])
2353 ],[
2354 AC_MSG_RESULT([yes])
2355 tst_links_gai_strerror="yes"
2356 ],[
2357 AC_MSG_RESULT([no])
2358 tst_links_gai_strerror="no"
2359 ])
2360 #
2361 if test "$tst_links_gai_strerror" = "yes"; then
2362 AC_MSG_CHECKING([if gai_strerror is prototyped])
2363 AC_EGREP_CPP([gai_strerror],[
2364 $curl_includes_winsock2
2365 $curl_includes_bsdsocket
2366 $curl_includes_netdb
2367 ],[
2368 AC_MSG_RESULT([yes])
2369 tst_proto_gai_strerror="yes"
2370 ],[
2371 AC_MSG_RESULT([no])
2372 tst_proto_gai_strerror="no"
2373 ])
2374 fi
2375 #
2376 if test "$tst_proto_gai_strerror" = "yes"; then
2377 AC_MSG_CHECKING([if gai_strerror is compilable])
2378 AC_COMPILE_IFELSE([
2379 AC_LANG_PROGRAM([[
2380 $curl_includes_winsock2
2381 $curl_includes_bsdsocket
2382 $curl_includes_netdb
2383 ]],[[
2384 if(0 != gai_strerror(0))
2385 return 1;
2386 ]])
2387 ],[
2388 AC_MSG_RESULT([yes])
2389 tst_compi_gai_strerror="yes"
2390 ],[
2391 AC_MSG_RESULT([no])
2392 tst_compi_gai_strerror="no"
2393 ])
2394 fi
2395 #
2396 if test "$tst_compi_gai_strerror" = "yes"; then
2397 AC_MSG_CHECKING([if gai_strerror usage allowed])
2398 if test "x$curl_disallow_gai_strerror" != "xyes"; then
2399 AC_MSG_RESULT([yes])
2400 tst_allow_gai_strerror="yes"
2401 else
2402 AC_MSG_RESULT([no])
2403 tst_allow_gai_strerror="no"
2404 fi
2405 fi
2406 #
2407 AC_MSG_CHECKING([if gai_strerror might be used])
2408 if test "$tst_links_gai_strerror" = "yes" &&
2409 test "$tst_proto_gai_strerror" = "yes" &&
2410 test "$tst_compi_gai_strerror" = "yes" &&
2411 test "$tst_allow_gai_strerror" = "yes"; then
2412 AC_MSG_RESULT([yes])
2413 AC_DEFINE_UNQUOTED(HAVE_GAI_STRERROR, 1,
2414 [Define to 1 if you have the gai_strerror function.])
2415 curl_cv_func_gai_strerror="yes"
2416 else
2417 AC_MSG_RESULT([no])
2418 curl_cv_func_gai_strerror="no"
2419 fi
2420 ])
2421
2422
2423 dnl CURL_CHECK_FUNC_GETHOSTBYADDR_R
2424 dnl -------------------------------------------------
2425 dnl Verify if gethostbyaddr_r is available, prototyped,
2426 dnl and can be compiled. If all of these are true, and
2427 dnl usage has not been previously disallowed with
2428 dnl shell variable curl_disallow_gethostbyaddr_r, then
2429 dnl HAVE_GETHOSTBYADDR_R will be defined.
2430
2431 AC_DEFUN([CURL_CHECK_FUNC_GETHOSTBYADDR_R], [
2432 AC_REQUIRE([CURL_INCLUDES_NETDB])dnl
2433 #
2434 tst_links_gethostbyaddr_r="unknown"
2435 tst_proto_gethostbyaddr_r="unknown"
2436 tst_compi_gethostbyaddr_r="unknown"
2437 tst_allow_gethostbyaddr_r="unknown"
2438 tst_nargs_gethostbyaddr_r="unknown"
2439 #
2440 AC_MSG_CHECKING([if gethostbyaddr_r can be linked])
2441 AC_LINK_IFELSE([
2442 AC_LANG_FUNC_LINK_TRY([gethostbyaddr_r])
2443 ],[
2444 AC_MSG_RESULT([yes])
2445 tst_links_gethostbyaddr_r="yes"
2446 ],[
2447 AC_MSG_RESULT([no])
2448 tst_links_gethostbyaddr_r="no"
2449 ])
2450 #
2451 if test "$tst_links_gethostbyaddr_r" = "yes"; then
2452 AC_MSG_CHECKING([if gethostbyaddr_r is prototyped])
2453 AC_EGREP_CPP([gethostbyaddr_r],[
2454 $curl_includes_netdb
2455 ],[
2456 AC_MSG_RESULT([yes])
2457 tst_proto_gethostbyaddr_r="yes"
2458 ],[
2459 AC_MSG_RESULT([no])
2460 tst_proto_gethostbyaddr_r="no"
2461 ])
2462 fi
2463 #
2464 if test "$tst_proto_gethostbyaddr_r" = "yes"; then
2465 if test "$tst_nargs_gethostbyaddr_r" = "unknown"; then
2466 AC_MSG_CHECKING([if gethostbyaddr_r takes 5 args.])
2467 AC_COMPILE_IFELSE([
2468 AC_LANG_PROGRAM([[
2469 $curl_includes_netdb
2470 ]],[[
2471 if(0 != gethostbyaddr_r(0, 0, 0, 0, 0))
2472 return 1;
2473 ]])
2474 ],[
2475 AC_MSG_RESULT([yes])
2476 tst_compi_gethostbyaddr_r="yes"
2477 tst_nargs_gethostbyaddr_r="5"
2478 ],[
2479 AC_MSG_RESULT([no])
2480 tst_compi_gethostbyaddr_r="no"
2481 ])
2482 fi
2483 if test "$tst_nargs_gethostbyaddr_r" = "unknown"; then
2484 AC_MSG_CHECKING([if gethostbyaddr_r takes 7 args.])
2485 AC_COMPILE_IFELSE([
2486 AC_LANG_PROGRAM([[
2487 $curl_includes_netdb
2488 ]],[[
2489 if(0 != gethostbyaddr_r(0, 0, 0, 0, 0, 0, 0))
2490 return 1;
2491 ]])
2492 ],[
2493 AC_MSG_RESULT([yes])
2494 tst_compi_gethostbyaddr_r="yes"
2495 tst_nargs_gethostbyaddr_r="7"
2496 ],[
2497 AC_MSG_RESULT([no])
2498 tst_compi_gethostbyaddr_r="no"
2499 ])
2500 fi
2501 if test "$tst_nargs_gethostbyaddr_r" = "unknown"; then
2502 AC_MSG_CHECKING([if gethostbyaddr_r takes 8 args.])
2503 AC_COMPILE_IFELSE([
2504 AC_LANG_PROGRAM([[
2505 $curl_includes_netdb
2506 ]],[[
2507 if(0 != gethostbyaddr_r(0, 0, 0, 0, 0, 0, 0, 0))
2508 return 1;
2509 ]])
2510 ],[
2511 AC_MSG_RESULT([yes])
2512 tst_compi_gethostbyaddr_r="yes"
2513 tst_nargs_gethostbyaddr_r="8"
2514 ],[
2515 AC_MSG_RESULT([no])
2516 tst_compi_gethostbyaddr_r="no"
2517 ])
2518 fi
2519 AC_MSG_CHECKING([if gethostbyaddr_r is compilable])
2520 if test "$tst_compi_gethostbyaddr_r" = "yes"; then
2521 AC_MSG_RESULT([yes])
2522 else
2523 AC_MSG_RESULT([no])
2524 fi
2525 fi
2526 #
2527 if test "$tst_compi_gethostbyaddr_r" = "yes"; then
2528 AC_MSG_CHECKING([if gethostbyaddr_r usage allowed])
2529 if test "x$curl_disallow_gethostbyaddr_r" != "xyes"; then
2530 AC_MSG_RESULT([yes])
2531 tst_allow_gethostbyaddr_r="yes"
2532 else
2533 AC_MSG_RESULT([no])
2534 tst_allow_gethostbyaddr_r="no"
2535 fi
2536 fi
2537 #
2538 AC_MSG_CHECKING([if gethostbyaddr_r might be used])
2539 if test "$tst_links_gethostbyaddr_r" = "yes" &&
2540 test "$tst_proto_gethostbyaddr_r" = "yes" &&
2541 test "$tst_compi_gethostbyaddr_r" = "yes" &&
2542 test "$tst_allow_gethostbyaddr_r" = "yes"; then
2543 AC_MSG_RESULT([yes])
2544 AC_DEFINE_UNQUOTED(HAVE_GETHOSTBYADDR_R, 1,
2545 [Define to 1 if you have the gethostbyaddr_r function.])
2546 dnl AC_DEFINE_UNQUOTED(GETHOSTBYADDR_R_ARGS, $tst_nargs_gethostbyaddr_r,
2547 dnl [Specifies the number of arguments to gethostbyaddr_r])
2548 #
2549 if test "$tst_nargs_gethostbyaddr_r" -eq "5"; then
2550 AC_DEFINE(HAVE_GETHOSTBYADDR_R_5, 1, [gethostbyaddr_r() takes 5 args])
2551 elif test "$tst_nargs_gethostbyaddr_r" -eq "7"; then
2552 AC_DEFINE(HAVE_GETHOSTBYADDR_R_7, 1, [gethostbyaddr_r() takes 7 args])
2553 elif test "$tst_nargs_gethostbyaddr_r" -eq "8"; then
2554 AC_DEFINE(HAVE_GETHOSTBYADDR_R_8, 1, [gethostbyaddr_r() takes 8 args])
2555 fi
2556 #
2557 curl_cv_func_gethostbyaddr_r="yes"
2558 else
2559 AC_MSG_RESULT([no])
2560 curl_cv_func_gethostbyaddr_r="no"
2561 fi
2562 ])
2563
2564
2565 dnl CURL_CHECK_FUNC_GETHOSTBYNAME
2566 dnl -------------------------------------------------
2567 dnl Verify if gethostbyname is available, prototyped,
2568 dnl and can be compiled. If all of these are true,
2569 dnl and usage has not been previously disallowed with
2570 dnl shell variable curl_disallow_gethostbyname, then
2571 dnl HAVE_GETHOSTBYNAME will be defined.
2572
2573 AC_DEFUN([CURL_CHECK_FUNC_GETHOSTBYNAME], [
2574 AC_REQUIRE([CURL_INCLUDES_WINSOCK2])dnl
2575 AC_REQUIRE([CURL_INCLUDES_NETDB])dnl
2576 #
2577 tst_links_gethostbyname="unknown"
2578 tst_proto_gethostbyname="unknown"
2579 tst_compi_gethostbyname="unknown"
2580 tst_allow_gethostbyname="unknown"
2581 #
2582 AC_MSG_CHECKING([if gethostbyname can be linked])
2583 AC_LINK_IFELSE([
2584 AC_LANG_PROGRAM([[
2585 $curl_includes_winsock2
2586 $curl_includes_bsdsocket
2587 $curl_includes_netdb
2588 ]],[[
2589 if(0 != gethostbyname(0))
2590 return 1;
2591 ]])
2592 ],[
2593 AC_MSG_RESULT([yes])
2594 tst_links_gethostbyname="yes"
2595 ],[
2596 AC_MSG_RESULT([no])
2597 tst_links_gethostbyname="no"
2598 ])
2599 #
2600 if test "$tst_links_gethostbyname" = "yes"; then
2601 AC_MSG_CHECKING([if gethostbyname is prototyped])
2602 AC_EGREP_CPP([gethostbyname],[
2603 $curl_includes_winsock2
2604 $curl_includes_bsdsocket
2605 $curl_includes_netdb
2606 ],[
2607 AC_MSG_RESULT([yes])
2608 tst_proto_gethostbyname="yes"
2609 ],[
2610 AC_MSG_RESULT([no])
2611 tst_proto_gethostbyname="no"
2612 ])
2613 fi
2614 #
2615 if test "$tst_proto_gethostbyname" = "yes"; then
2616 AC_MSG_CHECKING([if gethostbyname is compilable])
2617 AC_COMPILE_IFELSE([
2618 AC_LANG_PROGRAM([[
2619 $curl_includes_winsock2
2620 $curl_includes_bsdsocket
2621 $curl_includes_netdb
2622 ]],[[
2623 if(0 != gethostbyname(0))
2624 return 1;
2625 ]])
2626 ],[
2627 AC_MSG_RESULT([yes])
2628 tst_compi_gethostbyname="yes"
2629 ],[
2630 AC_MSG_RESULT([no])
2631 tst_compi_gethostbyname="no"
2632 ])
2633 fi
2634 #
2635 if test "$tst_compi_gethostbyname" = "yes"; then
2636 AC_MSG_CHECKING([if gethostbyname usage allowed])
2637 if test "x$curl_disallow_gethostbyname" != "xyes"; then
2638 AC_MSG_RESULT([yes])
2639 tst_allow_gethostbyname="yes"
2640 else
2641 AC_MSG_RESULT([no])
2642 tst_allow_gethostbyname="no"
2643 fi
2644 fi
2645 #
2646 AC_MSG_CHECKING([if gethostbyname might be used])
2647 if test "$tst_links_gethostbyname" = "yes" &&
2648 test "$tst_proto_gethostbyname" = "yes" &&
2649 test "$tst_compi_gethostbyname" = "yes" &&
2650 test "$tst_allow_gethostbyname" = "yes"; then
2651 AC_MSG_RESULT([yes])
2652 AC_DEFINE_UNQUOTED(HAVE_GETHOSTBYNAME, 1,
2653 [Define to 1 if you have the gethostbyname function.])
2654 curl_cv_func_gethostbyname="yes"
2655 else
2656 AC_MSG_RESULT([no])
2657 curl_cv_func_gethostbyname="no"
2658 fi
2659 ])
2660
2661
2662 dnl CURL_CHECK_FUNC_GETHOSTBYNAME_R
2663 dnl -------------------------------------------------
2664 dnl Verify if gethostbyname_r is available, prototyped,
2665 dnl and can be compiled. If all of these are true, and
2666 dnl usage has not been previously disallowed with
2667 dnl shell variable curl_disallow_gethostbyname_r, then
2668 dnl HAVE_GETHOSTBYNAME_R will be defined.
2669
2670 AC_DEFUN([CURL_CHECK_FUNC_GETHOSTBYNAME_R], [
2671 AC_REQUIRE([CURL_INCLUDES_NETDB])dnl
2672 #
2673 tst_links_gethostbyname_r="unknown"
2674 tst_proto_gethostbyname_r="unknown"
2675 tst_compi_gethostbyname_r="unknown"
2676 tst_allow_gethostbyname_r="unknown"
2677 tst_nargs_gethostbyname_r="unknown"
2678 #
2679 AC_MSG_CHECKING([if gethostbyname_r can be linked])
2680 AC_LINK_IFELSE([
2681 AC_LANG_FUNC_LINK_TRY([gethostbyname_r])
2682 ],[
2683 AC_MSG_RESULT([yes])
2684 tst_links_gethostbyname_r="yes"
2685 ],[
2686 AC_MSG_RESULT([no])
2687 tst_links_gethostbyname_r="no"
2688 ])
2689 #
2690 if test "$tst_links_gethostbyname_r" = "yes"; then
2691 AC_MSG_CHECKING([if gethostbyname_r is prototyped])
2692 AC_EGREP_CPP([gethostbyname_r],[
2693 $curl_includes_netdb
2694 ],[
2695 AC_MSG_RESULT([yes])
2696 tst_proto_gethostbyname_r="yes"
2697 ],[
2698 AC_MSG_RESULT([no])
2699 tst_proto_gethostbyname_r="no"
2700 ])
2701 fi
2702 #
2703 if test "$tst_proto_gethostbyname_r" = "yes"; then
2704 if test "$tst_nargs_gethostbyname_r" = "unknown"; then
2705 AC_MSG_CHECKING([if gethostbyname_r takes 3 args.])
2706 AC_COMPILE_IFELSE([
2707 AC_LANG_PROGRAM([[
2708 $curl_includes_netdb
2709 ]],[[
2710 if(0 != gethostbyname_r(0, 0, 0))
2711 return 1;
2712 ]])
2713 ],[
2714 AC_MSG_RESULT([yes])
2715 tst_compi_gethostbyname_r="yes"
2716 tst_nargs_gethostbyname_r="3"
2717 ],[
2718 AC_MSG_RESULT([no])
2719 tst_compi_gethostbyname_r="no"
2720 ])
2721 fi
2722 if test "$tst_nargs_gethostbyname_r" = "unknown"; then
2723 AC_MSG_CHECKING([if gethostbyname_r takes 5 args.])
2724 AC_COMPILE_IFELSE([
2725 AC_LANG_PROGRAM([[
2726 $curl_includes_netdb
2727 ]],[[
2728 if(0 != gethostbyname_r(0, 0, 0, 0, 0))
2729 return 1;
2730 ]])
2731 ],[
2732 AC_MSG_RESULT([yes])
2733 tst_compi_gethostbyname_r="yes"
2734 tst_nargs_gethostbyname_r="5"
2735 ],[
2736 AC_MSG_RESULT([no])
2737 tst_compi_gethostbyname_r="no"
2738 ])
2739 fi
2740 if test "$tst_nargs_gethostbyname_r" = "unknown"; then
2741 AC_MSG_CHECKING([if gethostbyname_r takes 6 args.])
2742 AC_COMPILE_IFELSE([
2743 AC_LANG_PROGRAM([[
2744 $curl_includes_netdb
2745 ]],[[
2746 if(0 != gethostbyname_r(0, 0, 0, 0, 0, 0))
2747 return 1;
2748 ]])
2749 ],[
2750 AC_MSG_RESULT([yes])
2751 tst_compi_gethostbyname_r="yes"
2752 tst_nargs_gethostbyname_r="6"
2753 ],[
2754 AC_MSG_RESULT([no])
2755 tst_compi_gethostbyname_r="no"
2756 ])
2757 fi
2758 AC_MSG_CHECKING([if gethostbyname_r is compilable])
2759 if test "$tst_compi_gethostbyname_r" = "yes"; then
2760 AC_MSG_RESULT([yes])
2761 else
2762 AC_MSG_RESULT([no])
2763 fi
2764 fi
2765 #
2766 if test "$tst_compi_gethostbyname_r" = "yes"; then
2767 AC_MSG_CHECKING([if gethostbyname_r usage allowed])
2768 if test "x$curl_disallow_gethostbyname_r" != "xyes"; then
2769 AC_MSG_RESULT([yes])
2770 tst_allow_gethostbyname_r="yes"
2771 else
2772 AC_MSG_RESULT([no])
2773 tst_allow_gethostbyname_r="no"
2774 fi
2775 fi
2776 #
2777 AC_MSG_CHECKING([if gethostbyname_r might be used])
2778 if test "$tst_links_gethostbyname_r" = "yes" &&
2779 test "$tst_proto_gethostbyname_r" = "yes" &&
2780 test "$tst_compi_gethostbyname_r" = "yes" &&
2781 test "$tst_allow_gethostbyname_r" = "yes"; then
2782 AC_MSG_RESULT([yes])
2783 AC_DEFINE_UNQUOTED(HAVE_GETHOSTBYNAME_R, 1,
2784 [Define to 1 if you have the gethostbyname_r function.])
2785 dnl AC_DEFINE_UNQUOTED(GETHOSTBYNAME_R_ARGS, $tst_nargs_gethostbyname_r,
2786 dnl [Specifies the number of arguments to gethostbyname_r])
2787 #
2788 if test "$tst_nargs_gethostbyname_r" -eq "3"; then
2789 AC_DEFINE(HAVE_GETHOSTBYNAME_R_3, 1, [gethostbyname_r() takes 3 args])
2790 elif test "$tst_nargs_gethostbyname_r" -eq "5"; then
2791 AC_DEFINE(HAVE_GETHOSTBYNAME_R_5, 1, [gethostbyname_r() takes 5 args])
2792 elif test "$tst_nargs_gethostbyname_r" -eq "6"; then
2793 AC_DEFINE(HAVE_GETHOSTBYNAME_R_6, 1, [gethostbyname_r() takes 6 args])
2794 fi
2795 #
2796 curl_cv_func_gethostbyname_r="yes"
2797 else
2798 AC_MSG_RESULT([no])
2799 curl_cv_func_gethostbyname_r="no"
2800 fi
2801 ])
2802
2803
2804 dnl CURL_CHECK_FUNC_GETHOSTNAME
2805 dnl -------------------------------------------------
2806 dnl Verify if gethostname is available, prototyped, and
2807 dnl can be compiled. If all of these are true, and
2808 dnl usage has not been previously disallowed with
2809 dnl shell variable curl_disallow_gethostname, then
2810 dnl HAVE_GETHOSTNAME will be defined.
2811
2812 AC_DEFUN([CURL_CHECK_FUNC_GETHOSTNAME], [
2813 AC_REQUIRE([CURL_INCLUDES_WINSOCK2])dnl
2814 AC_REQUIRE([CURL_INCLUDES_UNISTD])dnl
2815 AC_REQUIRE([CURL_PREPROCESS_CALLCONV])dnl
2816 AC_REQUIRE([CURL_INCLUDES_BSDSOCKET])dnl
2817 #
2818 tst_links_gethostname="unknown"
2819 tst_proto_gethostname="unknown"
2820 tst_compi_gethostname="unknown"
2821 tst_allow_gethostname="unknown"
2822 #
2823 AC_MSG_CHECKING([if gethostname can be linked])
2824 AC_LINK_IFELSE([
2825 AC_LANG_PROGRAM([[
2826 $curl_includes_winsock2
2827 $curl_includes_bsdsocket
2828 $curl_includes_unistd
2829 ]],[[
2830 if(0 != gethostname(0, 0))
2831 return 1;
2832 ]])
2833 ],[
2834 AC_MSG_RESULT([yes])
2835 tst_links_gethostname="yes"
2836 ],[
2837 AC_MSG_RESULT([no])
2838 tst_links_gethostname="no"
2839 ])
2840 #
2841 if test "$tst_links_gethostname" = "yes"; then
2842 AC_MSG_CHECKING([if gethostname is prototyped])
2843 AC_EGREP_CPP([gethostname],[
2844 $curl_includes_winsock2
2845 $curl_includes_bsdsocket
2846 $curl_includes_unistd
2847 ],[
2848 AC_MSG_RESULT([yes])
2849 tst_proto_gethostname="yes"
2850 ],[
2851 AC_MSG_RESULT([no])
2852 tst_proto_gethostname="no"
2853 ])
2854 fi
2855 #
2856 if test "$tst_proto_gethostname" = "yes"; then
2857 AC_MSG_CHECKING([if gethostname is compilable])
2858 AC_COMPILE_IFELSE([
2859 AC_LANG_PROGRAM([[
2860 $curl_includes_winsock2
2861 $curl_includes_bsdsocket
2862 $curl_includes_unistd
2863 ]],[[
2864 if(0 != gethostname(0, 0))
2865 return 1;
2866 ]])
2867 ],[
2868 AC_MSG_RESULT([yes])
2869 tst_compi_gethostname="yes"
2870 ],[
2871 AC_MSG_RESULT([no])
2872 tst_compi_gethostname="no"
2873 ])
2874 fi
2875 #
2876 if test "$tst_compi_gethostname" = "yes"; then
2877 AC_MSG_CHECKING([for gethostname arg 2 data type])
2878 tst_gethostname_type_arg2="unknown"
2879 for tst_arg1 in 'char *' 'unsigned char *' 'void *'; do
2880 for tst_arg2 in 'int' 'unsigned int' 'size_t'; do
2881 if test "$tst_gethostname_type_arg2" = "unknown"; then
2882 AC_COMPILE_IFELSE([
2883 AC_LANG_PROGRAM([[
2884 $curl_includes_winsock2
2885 $curl_includes_bsdsocket
2886 $curl_includes_unistd
2887 $curl_preprocess_callconv
2888 extern int FUNCALLCONV gethostname($tst_arg1, $tst_arg2);
2889 ]],[[
2890 if(0 != gethostname(0, 0))
2891 return 1;
2892 ]])
2893 ],[
2894 tst_gethostname_type_arg2="$tst_arg2"
2895 ])
2896 fi
2897 done
2898 done
2899 AC_MSG_RESULT([$tst_gethostname_type_arg2])
2900 if test "$tst_gethostname_type_arg2" != "unknown"; then
2901 AC_DEFINE_UNQUOTED(GETHOSTNAME_TYPE_ARG2, $tst_gethostname_type_arg2,
2902 [Define to the type of arg 2 for gethostname.])
2903 fi
2904 fi
2905 #
2906 if test "$tst_compi_gethostname" = "yes"; then
2907 AC_MSG_CHECKING([if gethostname usage allowed])
2908 if test "x$curl_disallow_gethostname" != "xyes"; then
2909 AC_MSG_RESULT([yes])
2910 tst_allow_gethostname="yes"
2911 else
2912 AC_MSG_RESULT([no])
2913 tst_allow_gethostname="no"
2914 fi
2915 fi
2916 #
2917 AC_MSG_CHECKING([if gethostname might be used])
2918 if test "$tst_links_gethostname" = "yes" &&
2919 test "$tst_proto_gethostname" = "yes" &&
2920 test "$tst_compi_gethostname" = "yes" &&
2921 test "$tst_allow_gethostname" = "yes"; then
2922 AC_MSG_RESULT([yes])
2923 AC_DEFINE_UNQUOTED(HAVE_GETHOSTNAME, 1,
2924 [Define to 1 if you have the gethostname function.])
2925 curl_cv_func_gethostname="yes"
2926 else
2927 AC_MSG_RESULT([no])
2928 curl_cv_func_gethostname="no"
2929 fi
2930 ])
2931
2932 dnl CURL_CHECK_FUNC_GETPEERNAME
2933 dnl -------------------------------------------------
2934 dnl Verify if getpeername is available, prototyped, and
2935 dnl can be compiled. If all of these are true, and
2936 dnl usage has not been previously disallowed with
2937 dnl shell variable curl_disallow_getpeername, then
2938 dnl HAVE_GETPEERNAME will be defined.
2939
2940 AC_DEFUN([CURL_CHECK_FUNC_GETPEERNAME], [
2941 AC_REQUIRE([CURL_INCLUDES_WINSOCK2])dnl
2942 AC_REQUIRE([CURL_INCLUDES_UNISTD])dnl
2943 AC_REQUIRE([CURL_PREPROCESS_CALLCONV])dnl
2944 AC_REQUIRE([CURL_INCLUDES_BSDSOCKET])dnl
2945 #
2946 tst_links_getpeername="unknown"
2947 tst_proto_getpeername="unknown"
2948 tst_compi_getpeername="unknown"
2949 tst_allow_getpeername="unknown"
2950 #
2951 AC_MSG_CHECKING([if getpeername can be linked])
2952 AC_LINK_IFELSE([
2953 AC_LANG_PROGRAM([[
2954 $curl_includes_winsock2
2955 $curl_includes_bsdsocket
2956 $curl_includes_sys_socket
2957 ]],[[
2958 if(0 != getpeername(0, (void *)0, (void *)0))
2959 return 1;
2960 ]])
2961 ],[
2962 AC_MSG_RESULT([yes])
2963 tst_links_getpeername="yes"
2964 ],[
2965 AC_MSG_RESULT([no])
2966 tst_links_getpeername="no"
2967 ])
2968 #
2969 if test "$tst_links_getpeername" = "yes"; then
2970 AC_MSG_CHECKING([if getpeername is prototyped])
2971 AC_EGREP_CPP([getpeername],[
2972 $curl_includes_winsock2
2973 $curl_includes_bsdsocket
2974 $curl_includes_sys_socket
2975 ],[
2976 AC_MSG_RESULT([yes])
2977 tst_proto_getpeername="yes"
2978 ],[
2979 AC_MSG_RESULT([no])
2980 tst_proto_getpeername="no"
2981 ])
2982 fi
2983 #
2984 if test "$tst_proto_getpeername" = "yes"; then
2985 AC_MSG_CHECKING([if getpeername is compilable])
2986 AC_COMPILE_IFELSE([
2987 AC_LANG_PROGRAM([[
2988 $curl_includes_winsock2
2989 $curl_includes_bsdsocket
2990 $curl_includes_sys_socket
2991 ]],[[
2992 if(0 != getpeername(0, (void *)0, (void *)0))
2993 return 1;
2994 ]])
2995 ],[
2996 AC_MSG_RESULT([yes])
2997 tst_compi_getpeername="yes"
2998 ],[
2999 AC_MSG_RESULT([no])
3000 tst_compi_getpeername="no"
3001 ])
3002 fi
3003 #
3004 if test "$tst_compi_getpeername" = "yes"; then
3005 AC_MSG_CHECKING([if getpeername usage allowed])
3006 if test "x$curl_disallow_getpeername" != "xyes"; then
3007 AC_MSG_RESULT([yes])
3008 tst_allow_getpeername="yes"
3009 else
3010 AC_MSG_RESULT([no])
3011 tst_allow_getpeername="no"
3012 fi
3013 fi
3014 #
3015 AC_MSG_CHECKING([if getpeername might be used])
3016 if test "$tst_links_getpeername" = "yes" &&
3017 test "$tst_proto_getpeername" = "yes" &&
3018 test "$tst_compi_getpeername" = "yes" &&
3019 test "$tst_allow_getpeername" = "yes"; then
3020 AC_MSG_RESULT([yes])
3021 AC_DEFINE_UNQUOTED(HAVE_GETPEERNAME, 1,
3022 [Define to 1 if you have the getpeername function.])
3023 curl_cv_func_getpeername="yes"
3024 else
3025 AC_MSG_RESULT([no])
3026 curl_cv_func_getpeername="no"
3027 fi
3028 ])
3029
3030 dnl CURL_CHECK_FUNC_GETSOCKNAME
3031 dnl -------------------------------------------------
3032 dnl Verify if getsockname is available, prototyped, and
3033 dnl can be compiled. If all of these are true, and
3034 dnl usage has not been previously disallowed with
3035 dnl shell variable curl_disallow_getsockname, then
3036 dnl HAVE_GETSOCKNAME will be defined.
3037
3038 AC_DEFUN([CURL_CHECK_FUNC_GETSOCKNAME], [
3039 AC_REQUIRE([CURL_INCLUDES_WINSOCK2])dnl
3040 AC_REQUIRE([CURL_INCLUDES_UNISTD])dnl
3041 AC_REQUIRE([CURL_PREPROCESS_CALLCONV])dnl
3042 AC_REQUIRE([CURL_INCLUDES_BSDSOCKET])dnl
3043 #
3044 tst_links_getsockname="unknown"
3045 tst_proto_getsockname="unknown"
3046 tst_compi_getsockname="unknown"
3047 tst_allow_getsockname="unknown"
3048 #
3049 AC_MSG_CHECKING([if getsockname can be linked])
3050 AC_LINK_IFELSE([
3051 AC_LANG_PROGRAM([[
3052 $curl_includes_winsock2
3053 $curl_includes_bsdsocket
3054 $curl_includes_sys_socket
3055 ]],[[
3056 if(0 != getsockname(0, (void *)0, (void *)0))
3057 return 1;
3058 ]])
3059 ],[
3060 AC_MSG_RESULT([yes])
3061 tst_links_getsockname="yes"
3062 ],[
3063 AC_MSG_RESULT([no])
3064 tst_links_getsockname="no"
3065 ])
3066 #
3067 if test "$tst_links_getsockname" = "yes"; then
3068 AC_MSG_CHECKING([if getsockname is prototyped])
3069 AC_EGREP_CPP([getsockname],[
3070 $curl_includes_winsock2
3071 $curl_includes_bsdsocket
3072 $curl_includes_sys_socket
3073 ],[
3074 AC_MSG_RESULT([yes])
3075 tst_proto_getsockname="yes"
3076 ],[
3077 AC_MSG_RESULT([no])
3078 tst_proto_getsockname="no"
3079 ])
3080 fi
3081 #
3082 if test "$tst_proto_getsockname" = "yes"; then
3083 AC_MSG_CHECKING([if getsockname is compilable])
3084 AC_COMPILE_IFELSE([
3085 AC_LANG_PROGRAM([[
3086 $curl_includes_winsock2
3087 $curl_includes_bsdsocket
3088 $curl_includes_sys_socket
3089 ]],[[
3090 if(0 != getsockname(0, (void *)0, (void *)0))
3091 return 1;
3092 ]])
3093 ],[
3094 AC_MSG_RESULT([yes])
3095 tst_compi_getsockname="yes"
3096 ],[
3097 AC_MSG_RESULT([no])
3098 tst_compi_getsockname="no"
3099 ])
3100 fi
3101 #
3102 if test "$tst_compi_getsockname" = "yes"; then
3103 AC_MSG_CHECKING([if getsockname usage allowed])
3104 if test "x$curl_disallow_getsockname" != "xyes"; then
3105 AC_MSG_RESULT([yes])
3106 tst_allow_getsockname="yes"
3107 else
3108 AC_MSG_RESULT([no])
3109 tst_allow_getsockname="no"
3110 fi
3111 fi
3112 #
3113 AC_MSG_CHECKING([if getsockname might be used])
3114 if test "$tst_links_getsockname" = "yes" &&
3115 test "$tst_proto_getsockname" = "yes" &&
3116 test "$tst_compi_getsockname" = "yes" &&
3117 test "$tst_allow_getsockname" = "yes"; then
3118 AC_MSG_RESULT([yes])
3119 AC_DEFINE_UNQUOTED(HAVE_GETSOCKNAME, 1,
3120 [Define to 1 if you have the getsockname function.])
3121 curl_cv_func_getsockname="yes"
3122 else
3123 AC_MSG_RESULT([no])
3124 curl_cv_func_getsockname="no"
3125 fi
3126 ])
3127
3128 dnl CURL_CHECK_FUNC_IF_NAMETOINDEX
3129 dnl -------------------------------------------------
3130 dnl Verify if if_nametoindex is available, prototyped, and
3131 dnl can be compiled. If all of these are true, and
3132 dnl usage has not been previously disallowed with
3133 dnl shell variable curl_disallow_if_nametoindex, then
3134 dnl HAVE_IF_NAMETOINDEX will be defined.
3135
3136 AC_DEFUN([CURL_CHECK_FUNC_IF_NAMETOINDEX], [
3137 AC_REQUIRE([CURL_INCLUDES_WINSOCK2])dnl
3138 AC_REQUIRE([CURL_INCLUDES_NETIF])dnl
3139 AC_REQUIRE([CURL_PREPROCESS_CALLCONV])dnl
3140 #
3141 tst_links_if_nametoindex="unknown"
3142 tst_proto_if_nametoindex="unknown"
3143 tst_compi_if_nametoindex="unknown"
3144 tst_allow_if_nametoindex="unknown"
3145 #
3146 AC_MSG_CHECKING([if if_nametoindex can be linked])
3147 AC_LINK_IFELSE([
3148 AC_LANG_PROGRAM([[
3149 $curl_includes_winsock2
3150 $curl_includes_bsdsocket
3151 #include <net/if.h>
3152 ]],[[
3153 if(0 != if_nametoindex(""))
3154 return 1;
3155 ]])
3156 ],[
3157 AC_MSG_RESULT([yes])
3158 tst_links_if_nametoindex="yes"
3159 ],[
3160 AC_MSG_RESULT([no])
3161 tst_links_if_nametoindex="no"
3162 ])
3163 #
3164 if test "$tst_links_if_nametoindex" = "yes"; then
3165 AC_MSG_CHECKING([if if_nametoindex is prototyped])
3166 AC_EGREP_CPP([if_nametoindex],[
3167 $curl_includes_winsock2
3168 $curl_includes_netif
3169 ],[
3170 AC_MSG_RESULT([yes])
3171 tst_proto_if_nametoindex="yes"
3172 ],[
3173 AC_MSG_RESULT([no])
3174 tst_proto_if_nametoindex="no"
3175 ])
3176 fi
3177 #
3178 if test "$tst_proto_if_nametoindex" = "yes"; then
3179 AC_MSG_CHECKING([if if_nametoindex is compilable])
3180 AC_COMPILE_IFELSE([
3181 AC_LANG_PROGRAM([[
3182 $curl_includes_winsock2
3183 $curl_includes_netif
3184 ]],[[
3185 if(0 != if_nametoindex(""))
3186 return 1;
3187 ]])
3188 ],[
3189 AC_MSG_RESULT([yes])
3190 tst_compi_if_nametoindex="yes"
3191 ],[
3192 AC_MSG_RESULT([no])
3193 tst_compi_if_nametoindex="no"
3194 ])
3195 fi
3196 #
3197 if test "$tst_compi_if_nametoindex" = "yes"; then
3198 AC_MSG_CHECKING([if if_nametoindex usage allowed])
3199 if test "x$curl_disallow_if_nametoindex" != "xyes"; then
3200 AC_MSG_RESULT([yes])
3201 tst_allow_if_nametoindex="yes"
3202 else
3203 AC_MSG_RESULT([no])
3204 tst_allow_if_nametoindex="no"
3205 fi
3206 fi
3207 #
3208 AC_MSG_CHECKING([if if_nametoindex might be used])
3209 if test "$tst_links_if_nametoindex" = "yes" &&
3210 test "$tst_proto_if_nametoindex" = "yes" &&
3211 test "$tst_compi_if_nametoindex" = "yes" &&
3212 test "$tst_allow_if_nametoindex" = "yes"; then
3213 AC_MSG_RESULT([yes])
3214 AC_DEFINE_UNQUOTED(HAVE_IF_NAMETOINDEX, 1,
3215 [Define to 1 if you have the if_nametoindex function.])
3216 curl_cv_func_if_nametoindex="yes"
3217 else
3218 AC_MSG_RESULT([no])
3219 curl_cv_func_if_nametoindex="no"
3220 fi
3221 ])
3222
3223
3224 dnl CURL_CHECK_FUNC_GETIFADDRS
3225 dnl -------------------------------------------------
3226 dnl Verify if getifaddrs is available, prototyped, can
3227 dnl be compiled and seems to work. If all of these are
3228 dnl true, and usage has not been previously disallowed
3229 dnl with shell variable curl_disallow_getifaddrs, then
3230 dnl HAVE_GETIFADDRS will be defined.
3231
3232 AC_DEFUN([CURL_CHECK_FUNC_GETIFADDRS], [
3233 AC_REQUIRE([CURL_INCLUDES_STDLIB])dnl
3234 AC_REQUIRE([CURL_INCLUDES_IFADDRS])dnl
3235 #
3236 tst_links_getifaddrs="unknown"
3237 tst_proto_getifaddrs="unknown"
3238 tst_compi_getifaddrs="unknown"
3239 tst_works_getifaddrs="unknown"
3240 tst_allow_getifaddrs="unknown"
3241 #
3242 AC_MSG_CHECKING([if getifaddrs can be linked])
3243 AC_LINK_IFELSE([
3244 AC_LANG_FUNC_LINK_TRY([getifaddrs])
3245 ],[
3246 AC_MSG_RESULT([yes])
3247 tst_links_getifaddrs="yes"
3248 ],[
3249 AC_MSG_RESULT([no])
3250 tst_links_getifaddrs="no"
3251 ])
3252 #
3253 if test "$tst_links_getifaddrs" = "yes"; then
3254 AC_MSG_CHECKING([if getifaddrs is prototyped])
3255 AC_EGREP_CPP([getifaddrs],[
3256 $curl_includes_ifaddrs
3257 ],[
3258 AC_MSG_RESULT([yes])
3259 tst_proto_getifaddrs="yes"
3260 ],[
3261 AC_MSG_RESULT([no])
3262 tst_proto_getifaddrs="no"
3263 ])
3264 fi
3265 #
3266 if test "$tst_proto_getifaddrs" = "yes"; then
3267 AC_MSG_CHECKING([if getifaddrs is compilable])
3268 AC_COMPILE_IFELSE([
3269 AC_LANG_PROGRAM([[
3270 $curl_includes_ifaddrs
3271 ]],[[
3272 if(0 != getifaddrs(0))
3273 return 1;
3274 ]])
3275 ],[
3276 AC_MSG_RESULT([yes])
3277 tst_compi_getifaddrs="yes"
3278 ],[
3279 AC_MSG_RESULT([no])
3280 tst_compi_getifaddrs="no"
3281 ])
3282 fi
3283 #
3284 dnl only do runtime verification when not cross-compiling
3285 if test "x$cross_compiling" != "xyes" &&
3286 test "$tst_compi_getifaddrs" = "yes"; then
3287 AC_MSG_CHECKING([if getifaddrs seems to work])
3288 CURL_RUN_IFELSE([
3289 AC_LANG_PROGRAM([[
3290 $curl_includes_stdlib
3291 $curl_includes_ifaddrs
3292 ]],[[
3293 struct ifaddrs *ifa = 0;
3294 int error;
3295
3296 error = getifaddrs(&ifa);
3297 if(error || !ifa)
3298 exit(1); /* fail */
3299 else
3300 exit(0);
3301 ]])
3302 ],[
3303 AC_MSG_RESULT([yes])
3304 tst_works_getifaddrs="yes"
3305 ],[
3306 AC_MSG_RESULT([no])
3307 tst_works_getifaddrs="no"
3308 ])
3309 fi
3310 #
3311 if test "$tst_compi_getifaddrs" = "yes" &&
3312 test "$tst_works_getifaddrs" != "no"; then
3313 AC_MSG_CHECKING([if getifaddrs usage allowed])
3314 if test "x$curl_disallow_getifaddrs" != "xyes"; then
3315 AC_MSG_RESULT([yes])
3316 tst_allow_getifaddrs="yes"
3317 else
3318 AC_MSG_RESULT([no])
3319 tst_allow_getifaddrs="no"
3320 fi
3321 fi
3322 #
3323 AC_MSG_CHECKING([if getifaddrs might be used])
3324 if test "$tst_links_getifaddrs" = "yes" &&
3325 test "$tst_proto_getifaddrs" = "yes" &&
3326 test "$tst_compi_getifaddrs" = "yes" &&
3327 test "$tst_allow_getifaddrs" = "yes" &&
3328 test "$tst_works_getifaddrs" != "no"; then
3329 AC_MSG_RESULT([yes])
3330 AC_DEFINE_UNQUOTED(HAVE_GETIFADDRS, 1,
3331 [Define to 1 if you have a working getifaddrs function.])
3332 curl_cv_func_getifaddrs="yes"
3333 else
3334 AC_MSG_RESULT([no])
3335 curl_cv_func_getifaddrs="no"
3336 fi
3337 ])
3338
3339
3340 dnl CURL_CHECK_FUNC_GETSERVBYPORT_R
3341 dnl -------------------------------------------------
3342 dnl Verify if getservbyport_r is available, prototyped,
3343 dnl and can be compiled. If all of these are true, and
3344 dnl usage has not been previously disallowed with
3345 dnl shell variable curl_disallow_getservbyport_r, then
3346 dnl HAVE_GETSERVBYPORT_R will be defined.
3347
3348 AC_DEFUN([CURL_CHECK_FUNC_GETSERVBYPORT_R], [
3349 AC_REQUIRE([CURL_INCLUDES_NETDB])dnl
3350 #
3351 tst_links_getservbyport_r="unknown"
3352 tst_proto_getservbyport_r="unknown"
3353 tst_compi_getservbyport_r="unknown"
3354 tst_allow_getservbyport_r="unknown"
3355 tst_nargs_getservbyport_r="unknown"
3356 #
3357 AC_MSG_CHECKING([if getservbyport_r can be linked])
3358 AC_LINK_IFELSE([
3359 AC_LANG_FUNC_LINK_TRY([getservbyport_r])
3360 ],[
3361 AC_MSG_RESULT([yes])
3362 tst_links_getservbyport_r="yes"
3363 ],[
3364 AC_MSG_RESULT([no])
3365 tst_links_getservbyport_r="no"
3366 ])
3367 #
3368 if test "$tst_links_getservbyport_r" = "yes"; then
3369 AC_MSG_CHECKING([if getservbyport_r is prototyped])
3370 AC_EGREP_CPP([getservbyport_r],[
3371 $curl_includes_netdb
3372 ],[
3373 AC_MSG_RESULT([yes])
3374 tst_proto_getservbyport_r="yes"
3375 ],[
3376 AC_MSG_RESULT([no])
3377 tst_proto_getservbyport_r="no"
3378 ])
3379 fi
3380 #
3381 if test "$tst_proto_getservbyport_r" = "yes"; then
3382 if test "$tst_nargs_getservbyport_r" = "unknown"; then
3383 AC_MSG_CHECKING([if getservbyport_r takes 4 args.])
3384 AC_COMPILE_IFELSE([
3385 AC_LANG_PROGRAM([[
3386 $curl_includes_netdb
3387 ]],[[
3388 if(0 != getservbyport_r(0, 0, 0, 0))
3389 return 1;
3390 ]])
3391 ],[
3392 AC_MSG_RESULT([yes])
3393 tst_compi_getservbyport_r="yes"
3394 tst_nargs_getservbyport_r="4"
3395 ],[
3396 AC_MSG_RESULT([no])
3397 tst_compi_getservbyport_r="no"
3398 ])
3399 fi
3400 if test "$tst_nargs_getservbyport_r" = "unknown"; then
3401 AC_MSG_CHECKING([if getservbyport_r takes 5 args.])
3402 AC_COMPILE_IFELSE([
3403 AC_LANG_PROGRAM([[
3404 $curl_includes_netdb
3405 ]],[[
3406 if(0 != getservbyport_r(0, 0, 0, 0, 0))
3407 return 1;
3408 ]])
3409 ],[
3410 AC_MSG_RESULT([yes])
3411 tst_compi_getservbyport_r="yes"
3412 tst_nargs_getservbyport_r="5"
3413 ],[
3414 AC_MSG_RESULT([no])
3415 tst_compi_getservbyport_r="no"
3416 ])
3417 fi
3418 if test "$tst_nargs_getservbyport_r" = "unknown"; then
3419 AC_MSG_CHECKING([if getservbyport_r takes 6 args.])
3420 AC_COMPILE_IFELSE([
3421 AC_LANG_PROGRAM([[
3422 $curl_includes_netdb
3423 ]],[[
3424 if(0 != getservbyport_r(0, 0, 0, 0, 0, 0))
3425 return 1;
3426 ]])
3427 ],[
3428 AC_MSG_RESULT([yes])
3429 tst_compi_getservbyport_r="yes"
3430 tst_nargs_getservbyport_r="6"
3431 ],[
3432 AC_MSG_RESULT([no])
3433 tst_compi_getservbyport_r="no"
3434 ])
3435 fi
3436 AC_MSG_CHECKING([if getservbyport_r is compilable])
3437 if test "$tst_compi_getservbyport_r" = "yes"; then
3438 AC_MSG_RESULT([yes])
3439 else
3440 AC_MSG_RESULT([no])
3441 fi
3442 fi
3443 #
3444 if test "$tst_compi_getservbyport_r" = "yes"; then
3445 AC_MSG_CHECKING([if getservbyport_r usage allowed])
3446 if test "x$curl_disallow_getservbyport_r" != "xyes"; then
3447 AC_MSG_RESULT([yes])
3448 tst_allow_getservbyport_r="yes"
3449 else
3450 AC_MSG_RESULT([no])
3451 tst_allow_getservbyport_r="no"
3452 fi
3453 fi
3454 #
3455 AC_MSG_CHECKING([if getservbyport_r might be used])
3456 if test "$tst_links_getservbyport_r" = "yes" &&
3457 test "$tst_proto_getservbyport_r" = "yes" &&
3458 test "$tst_compi_getservbyport_r" = "yes" &&
3459 test "$tst_allow_getservbyport_r" = "yes"; then
3460 AC_MSG_RESULT([yes])
3461 AC_DEFINE_UNQUOTED(HAVE_GETSERVBYPORT_R, 1,
3462 [Define to 1 if you have the getservbyport_r function.])
3463 AC_DEFINE_UNQUOTED(GETSERVBYPORT_R_ARGS, $tst_nargs_getservbyport_r,
3464 [Specifies the number of arguments to getservbyport_r])
3465 if test "$tst_nargs_getservbyport_r" -eq "4"; then
3466 AC_DEFINE(GETSERVBYPORT_R_BUFSIZE, sizeof(struct servent_data),
3467 [Specifies the size of the buffer to pass to getservbyport_r])
3468 else
3469 AC_DEFINE(GETSERVBYPORT_R_BUFSIZE, 4096,
3470 [Specifies the size of the buffer to pass to getservbyport_r])
3471 fi
3472 curl_cv_func_getservbyport_r="yes"
3473 else
3474 AC_MSG_RESULT([no])
3475 curl_cv_func_getservbyport_r="no"
3476 fi
3477 ])
3478
3479
3480 dnl CURL_CHECK_FUNC_GETXATTR
3481 dnl -------------------------------------------------
3482 dnl Verify if getxattr is available, prototyped, and
3483 dnl can be compiled. If all of these are true, and
3484 dnl usage has not been previously disallowed with
3485 dnl shell variable curl_disallow_getxattr, then
3486 dnl HAVE_GETXATTR will be defined.
3487
3488 AC_DEFUN([CURL_CHECK_FUNC_GETXATTR], [
3489 AC_REQUIRE([CURL_INCLUDES_SYS_XATTR])dnl
3490 #
3491 tst_links_getxattr="unknown"
3492 tst_proto_getxattr="unknown"
3493 tst_compi_getxattr="unknown"
3494 tst_allow_getxattr="unknown"
3495 tst_nargs_getxattr="unknown"
3496 #
3497 AC_MSG_CHECKING([if getxattr can be linked])
3498 AC_LINK_IFELSE([
3499 AC_LANG_FUNC_LINK_TRY([getxattr])
3500 ],[
3501 AC_MSG_RESULT([yes])
3502 tst_links_getxattr="yes"
3503 ],[
3504 AC_MSG_RESULT([no])
3505 tst_links_getxattr="no"
3506 ])
3507 #
3508 if test "$tst_links_getxattr" = "yes"; then
3509 AC_MSG_CHECKING([if getxattr is prototyped])
3510 AC_EGREP_CPP([getxattr],[
3511 $curl_includes_sys_xattr
3512 ],[
3513 AC_MSG_RESULT([yes])
3514 tst_proto_getxattr="yes"
3515 ],[
3516 AC_MSG_RESULT([no])
3517 tst_proto_getxattr="no"
3518 ])
3519 fi
3520 #
3521 if test "$tst_proto_getxattr" = "yes"; then
3522 if test "$tst_nargs_getxattr" = "unknown"; then
3523 AC_MSG_CHECKING([if getxattr takes 4 args.])
3524 AC_COMPILE_IFELSE([
3525 AC_LANG_PROGRAM([[
3526 $curl_includes_sys_xattr
3527 ]],[[
3528 if(0 != getxattr(0, 0, 0, 0))
3529 return 1;
3530 ]])
3531 ],[
3532 AC_MSG_RESULT([yes])
3533 tst_compi_getxattr="yes"
3534 tst_nargs_getxattr="4"
3535 ],[
3536 AC_MSG_RESULT([no])
3537 tst_compi_getxattr="no"
3538 ])
3539 fi
3540 if test "$tst_nargs_getxattr" = "unknown"; then
3541 AC_MSG_CHECKING([if getxattr takes 6 args.])
3542 AC_COMPILE_IFELSE([
3543 AC_LANG_PROGRAM([[
3544 $curl_includes_sys_xattr
3545 ]],[[
3546 if(0 != getxattr(0, 0, 0, 0, 0, 0))
3547 return 1;
3548 ]])
3549 ],[
3550 AC_MSG_RESULT([yes])
3551 tst_compi_getxattr="yes"
3552 tst_nargs_getxattr="6"
3553 ],[
3554 AC_MSG_RESULT([no])
3555 tst_compi_getxattr="no"
3556 ])
3557 fi
3558 AC_MSG_CHECKING([if getxattr is compilable])
3559 if test "$tst_compi_getxattr" = "yes"; then
3560 AC_MSG_RESULT([yes])
3561 else
3562 AC_MSG_RESULT([no])
3563 fi
3564 fi
3565 #
3566 if test "$tst_compi_getxattr" = "yes"; then
3567 AC_MSG_CHECKING([if getxattr usage allowed])
3568 if test "x$curl_disallow_getxattr" != "xyes"; then
3569 AC_MSG_RESULT([yes])
3570 tst_allow_getxattr="yes"
3571 else
3572 AC_MSG_RESULT([no])
3573 tst_allow_getxattr="no"
3574 fi
3575 fi
3576 #
3577 AC_MSG_CHECKING([if getxattr might be used])
3578 if test "$tst_links_getxattr" = "yes" &&
3579 test "$tst_proto_getxattr" = "yes" &&
3580 test "$tst_compi_getxattr" = "yes" &&
3581 test "$tst_allow_getxattr" = "yes"; then
3582 AC_MSG_RESULT([yes])
3583 AC_DEFINE_UNQUOTED(HAVE_GETXATTR, 1,
3584 [Define to 1 if you have the getxattr function.])
3585 dnl AC_DEFINE_UNQUOTED(GETXATTR_ARGS, $tst_nargs_getxattr,
3586 dnl [Specifies the number of arguments to getxattr])
3587 #
3588 if test "$tst_nargs_getxattr" -eq "4"; then
3589 AC_DEFINE(HAVE_GETXATTR_4, 1, [getxattr() takes 4 args])
3590 elif test "$tst_nargs_getxattr" -eq "6"; then
3591 AC_DEFINE(HAVE_GETXATTR_6, 1, [getxattr() takes 6 args])
3592 fi
3593 #
3594 curl_cv_func_getxattr="yes"
3595 else
3596 AC_MSG_RESULT([no])
3597 curl_cv_func_getxattr="no"
3598 fi
3599 ])
3600
3601
3602 dnl CURL_CHECK_FUNC_GMTIME_R
3603 dnl -------------------------------------------------
3604 dnl Verify if gmtime_r is available, prototyped, can
3605 dnl be compiled and seems to work. If all of these are
3606 dnl true, and usage has not been previously disallowed
3607 dnl with shell variable curl_disallow_gmtime_r, then
3608 dnl HAVE_GMTIME_R will be defined.
3609
3610 AC_DEFUN([CURL_CHECK_FUNC_GMTIME_R], [
3611 AC_REQUIRE([CURL_INCLUDES_STDLIB])dnl
3612 AC_REQUIRE([CURL_INCLUDES_TIME])dnl
3613 #
3614 tst_links_gmtime_r="unknown"
3615 tst_proto_gmtime_r="unknown"
3616 tst_compi_gmtime_r="unknown"
3617 tst_works_gmtime_r="unknown"
3618 tst_allow_gmtime_r="unknown"
3619 #
3620 AC_MSG_CHECKING([if gmtime_r can be linked])
3621 AC_LINK_IFELSE([
3622 AC_LANG_FUNC_LINK_TRY([gmtime_r])
3623 ],[
3624 AC_MSG_RESULT([yes])
3625 tst_links_gmtime_r="yes"
3626 ],[
3627 AC_MSG_RESULT([no])
3628 tst_links_gmtime_r="no"
3629 ])
3630 #
3631 if test "$tst_links_gmtime_r" = "yes"; then
3632 AC_MSG_CHECKING([if gmtime_r is prototyped])
3633 AC_EGREP_CPP([gmtime_r],[
3634 $curl_includes_time
3635 ],[
3636 AC_MSG_RESULT([yes])
3637 tst_proto_gmtime_r="yes"
3638 ],[
3639 AC_MSG_RESULT([no])
3640 tst_proto_gmtime_r="no"
3641 ])
3642 fi
3643 #
3644 if test "$tst_proto_gmtime_r" = "yes"; then
3645 AC_MSG_CHECKING([if gmtime_r is compilable])
3646 AC_COMPILE_IFELSE([
3647 AC_LANG_PROGRAM([[
3648 $curl_includes_time
3649 ]],[[
3650 if(0 != gmtime_r(0, 0))
3651 return 1;
3652 ]])
3653 ],[
3654 AC_MSG_RESULT([yes])
3655 tst_compi_gmtime_r="yes"
3656 ],[
3657 AC_MSG_RESULT([no])
3658 tst_compi_gmtime_r="no"
3659 ])
3660 fi
3661 #
3662 dnl only do runtime verification when not cross-compiling
3663 if test "x$cross_compiling" != "xyes" &&
3664 test "$tst_compi_gmtime_r" = "yes"; then
3665 AC_MSG_CHECKING([if gmtime_r seems to work])
3666 CURL_RUN_IFELSE([
3667 AC_LANG_PROGRAM([[
3668 $curl_includes_stdlib
3669 $curl_includes_time
3670 ]],[[
3671 time_t local = 1170352587;
3672 struct tm *gmt = 0;
3673 struct tm result;
3674 gmt = gmtime_r(&local, &result);
3675 if(gmt)
3676 exit(0);
3677 else
3678 exit(1);
3679 ]])
3680 ],[
3681 AC_MSG_RESULT([yes])
3682 tst_works_gmtime_r="yes"
3683 ],[
3684 AC_MSG_RESULT([no])
3685 tst_works_gmtime_r="no"
3686 ])
3687 fi
3688 #
3689 if test "$tst_compi_gmtime_r" = "yes" &&
3690 test "$tst_works_gmtime_r" != "no"; then
3691 AC_MSG_CHECKING([if gmtime_r usage allowed])
3692 if test "x$curl_disallow_gmtime_r" != "xyes"; then
3693 AC_MSG_RESULT([yes])
3694 tst_allow_gmtime_r="yes"
3695 else
3696 AC_MSG_RESULT([no])
3697 tst_allow_gmtime_r="no"
3698 fi
3699 fi
3700 #
3701 AC_MSG_CHECKING([if gmtime_r might be used])
3702 if test "$tst_links_gmtime_r" = "yes" &&
3703 test "$tst_proto_gmtime_r" = "yes" &&
3704 test "$tst_compi_gmtime_r" = "yes" &&
3705 test "$tst_allow_gmtime_r" = "yes" &&
3706 test "$tst_works_gmtime_r" != "no"; then
3707 AC_MSG_RESULT([yes])
3708 AC_DEFINE_UNQUOTED(HAVE_GMTIME_R, 1,
3709 [Define to 1 if you have a working gmtime_r function.])
3710 curl_cv_func_gmtime_r="yes"
3711 else
3712 AC_MSG_RESULT([no])
3713 curl_cv_func_gmtime_r="no"
3714 fi
3715 ])
3716
3717
3718 dnl CURL_CHECK_FUNC_INET_NTOA_R
3719 dnl -------------------------------------------------
3720 dnl Verify if inet_ntoa_r is available, prototyped,
3721 dnl and can be compiled. If all of these are true, and
3722 dnl usage has not been previously disallowed with
3723 dnl shell variable curl_disallow_inet_ntoa_r, then
3724 dnl HAVE_INET_NTOA_R will be defined.
3725
3726 AC_DEFUN([CURL_CHECK_FUNC_INET_NTOA_R], [
3727 AC_REQUIRE([CURL_INCLUDES_ARPA_INET])dnl
3728 #
3729 tst_links_inet_ntoa_r="unknown"
3730 tst_proto_inet_ntoa_r="unknown"
3731 tst_compi_inet_ntoa_r="unknown"
3732 tst_allow_inet_ntoa_r="unknown"
3733 tst_nargs_inet_ntoa_r="unknown"
3734 #
3735 AC_MSG_CHECKING([if inet_ntoa_r can be linked])
3736 AC_LINK_IFELSE([
3737 AC_LANG_FUNC_LINK_TRY([inet_ntoa_r])
3738 ],[
3739 AC_MSG_RESULT([yes])
3740 tst_links_inet_ntoa_r="yes"
3741 ],[
3742 AC_MSG_RESULT([no])
3743 tst_links_inet_ntoa_r="no"
3744 ])
3745 #
3746 if test "$tst_links_inet_ntoa_r" = "yes"; then
3747 AC_MSG_CHECKING([if inet_ntoa_r is prototyped])
3748 AC_EGREP_CPP([inet_ntoa_r],[
3749 $curl_includes_arpa_inet
3750 ],[
3751 AC_MSG_RESULT([yes])
3752 tst_proto_inet_ntoa_r="yes"
3753 ],[
3754 AC_MSG_RESULT([no])
3755 tst_proto_inet_ntoa_r="no"
3756 ])
3757 fi
3758 #
3759 if test "$tst_proto_inet_ntoa_r" = "yes"; then
3760 if test "$tst_nargs_inet_ntoa_r" = "unknown"; then
3761 AC_MSG_CHECKING([if inet_ntoa_r takes 2 args.])
3762 AC_COMPILE_IFELSE([
3763 AC_LANG_PROGRAM([[
3764 $curl_includes_arpa_inet
3765 ]],[[
3766 struct in_addr addr;
3767 if(0 != inet_ntoa_r(addr, 0))
3768 return 1;
3769 ]])
3770 ],[
3771 AC_MSG_RESULT([yes])
3772 tst_compi_inet_ntoa_r="yes"
3773 tst_nargs_inet_ntoa_r="2"
3774 ],[
3775 AC_MSG_RESULT([no])
3776 tst_compi_inet_ntoa_r="no"
3777 ])
3778 fi
3779 if test "$tst_nargs_inet_ntoa_r" = "unknown"; then
3780 AC_MSG_CHECKING([if inet_ntoa_r takes 3 args.])
3781 AC_COMPILE_IFELSE([
3782 AC_LANG_PROGRAM([[
3783 $curl_includes_arpa_inet
3784 ]],[[
3785 struct in_addr addr;
3786 if(0 != inet_ntoa_r(addr, 0, 0))
3787 return 1;
3788 ]])
3789 ],[
3790 AC_MSG_RESULT([yes])
3791 tst_compi_inet_ntoa_r="yes"
3792 tst_nargs_inet_ntoa_r="3"
3793 ],[
3794 AC_MSG_RESULT([no])
3795 tst_compi_inet_ntoa_r="no"
3796 ])
3797 fi
3798 AC_MSG_CHECKING([if inet_ntoa_r is compilable])
3799 if test "$tst_compi_inet_ntoa_r" = "yes"; then
3800 AC_MSG_RESULT([yes])
3801 else
3802 AC_MSG_RESULT([no])
3803 fi
3804 fi
3805 #
3806 if test "$tst_compi_inet_ntoa_r" = "yes"; then
3807 AC_MSG_CHECKING([if inet_ntoa_r usage allowed])
3808 if test "x$curl_disallow_inet_ntoa_r" != "xyes"; then
3809 AC_MSG_RESULT([yes])
3810 tst_allow_inet_ntoa_r="yes"
3811 else
3812 AC_MSG_RESULT([no])
3813 tst_allow_inet_ntoa_r="no"
3814 fi
3815 fi
3816 #
3817 AC_MSG_CHECKING([if inet_ntoa_r might be used])
3818 if test "$tst_links_inet_ntoa_r" = "yes" &&
3819 test "$tst_proto_inet_ntoa_r" = "yes" &&
3820 test "$tst_compi_inet_ntoa_r" = "yes" &&
3821 test "$tst_allow_inet_ntoa_r" = "yes"; then
3822 AC_MSG_RESULT([yes])
3823 AC_DEFINE_UNQUOTED(HAVE_INET_NTOA_R, 1,
3824 [Define to 1 if you have the inet_ntoa_r function.])
3825 dnl AC_DEFINE_UNQUOTED(INET_NTOA_R_ARGS, $tst_nargs_inet_ntoa_r,
3826 dnl [Specifies the number of arguments to inet_ntoa_r])
3827 #
3828 if test "$tst_nargs_inet_ntoa_r" -eq "2"; then
3829 AC_DEFINE(HAVE_INET_NTOA_R_2, 1, [inet_ntoa_r() takes 2 args])
3830 elif test "$tst_nargs_inet_ntoa_r" -eq "3"; then
3831 AC_DEFINE(HAVE_INET_NTOA_R_3, 1, [inet_ntoa_r() takes 3 args])
3832 fi
3833 #
3834 curl_cv_func_inet_ntoa_r="yes"
3835 else
3836 AC_MSG_RESULT([no])
3837 curl_cv_func_inet_ntoa_r="no"
3838 fi
3839 ])
3840
3841
3842 dnl CURL_CHECK_FUNC_INET_NTOP
3843 dnl -------------------------------------------------
3844 dnl Verify if inet_ntop is available, prototyped, can
3845 dnl be compiled and seems to work. If all of these are
3846 dnl true, and usage has not been previously disallowed
3847 dnl with shell variable curl_disallow_inet_ntop, then
3848 dnl HAVE_INET_NTOP will be defined.
3849
3850 AC_DEFUN([CURL_CHECK_FUNC_INET_NTOP], [
3851 AC_REQUIRE([CURL_INCLUDES_STDLIB])dnl
3852 AC_REQUIRE([CURL_INCLUDES_ARPA_INET])dnl
3853 AC_REQUIRE([CURL_INCLUDES_STRING])dnl
3854 #
3855 tst_links_inet_ntop="unknown"
3856 tst_proto_inet_ntop="unknown"
3857 tst_compi_inet_ntop="unknown"
3858 tst_works_inet_ntop="unknown"
3859 tst_allow_inet_ntop="unknown"
3860 #
3861 AC_MSG_CHECKING([if inet_ntop can be linked])
3862 AC_LINK_IFELSE([
3863 AC_LANG_FUNC_LINK_TRY([inet_ntop])
3864 ],[
3865 AC_MSG_RESULT([yes])
3866 tst_links_inet_ntop="yes"
3867 ],[
3868 AC_MSG_RESULT([no])
3869 tst_links_inet_ntop="no"
3870 ])
3871 #
3872 if test "$tst_links_inet_ntop" = "yes"; then
3873 AC_MSG_CHECKING([if inet_ntop is prototyped])
3874 AC_EGREP_CPP([inet_ntop],[
3875 $curl_includes_arpa_inet
3876 ],[
3877 AC_MSG_RESULT([yes])
3878 tst_proto_inet_ntop="yes"
3879 ],[
3880 AC_MSG_RESULT([no])
3881 tst_proto_inet_ntop="no"
3882 ])
3883 fi
3884 #
3885 if test "$tst_proto_inet_ntop" = "yes"; then
3886 AC_MSG_CHECKING([if inet_ntop is compilable])
3887 AC_COMPILE_IFELSE([
3888 AC_LANG_PROGRAM([[
3889 $curl_includes_arpa_inet
3890 ]],[[
3891 if(0 != inet_ntop(0, 0, 0, 0))
3892 return 1;
3893 ]])
3894 ],[
3895 AC_MSG_RESULT([yes])
3896 tst_compi_inet_ntop="yes"
3897 ],[
3898 AC_MSG_RESULT([no])
3899 tst_compi_inet_ntop="no"
3900 ])
3901 fi
3902 #
3903 dnl only do runtime verification when not cross-compiling
3904 if test "x$cross_compiling" != "xyes" &&
3905 test "$tst_compi_inet_ntop" = "yes"; then
3906 AC_MSG_CHECKING([if inet_ntop seems to work])
3907 CURL_RUN_IFELSE([
3908 AC_LANG_PROGRAM([[
3909 $curl_includes_stdlib
3910 $curl_includes_arpa_inet
3911 $curl_includes_string
3912 ]],[[
3913 char ipv6res[sizeof("ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255")];
3914 char ipv4res[sizeof "255.255.255.255"];
3915 unsigned char ipv6a[26];
3916 unsigned char ipv4a[5];
3917 char *ipv6ptr = 0;
3918 char *ipv4ptr = 0;
3919 /* - */
3920 ipv4res[0] = '\0';
3921 ipv4a[0] = 0xc0;
3922 ipv4a[1] = 0xa8;
3923 ipv4a[2] = 0x64;
3924 ipv4a[3] = 0x01;
3925 ipv4a[4] = 0x01;
3926 /* - */
3927 ipv4ptr = inet_ntop(AF_INET, ipv4a, ipv4res, sizeof(ipv4res));
3928 if(!ipv4ptr)
3929 exit(1); /* fail */
3930 if(ipv4ptr != ipv4res)
3931 exit(1); /* fail */
3932 if(!ipv4ptr[0])
3933 exit(1); /* fail */
3934 if(memcmp(ipv4res, "192.168.100.1", 13) != 0)
3935 exit(1); /* fail */
3936 /* - */
3937 ipv6res[0] = '\0';
3938 memset(ipv6a, 0, sizeof(ipv6a));
3939 ipv6a[0] = 0xfe;
3940 ipv6a[1] = 0x80;
3941 ipv6a[8] = 0x02;
3942 ipv6a[9] = 0x14;
3943 ipv6a[10] = 0x4f;
3944 ipv6a[11] = 0xff;
3945 ipv6a[12] = 0xfe;
3946 ipv6a[13] = 0x0b;
3947 ipv6a[14] = 0x76;
3948 ipv6a[15] = 0xc8;
3949 ipv6a[25] = 0x01;
3950 /* - */
3951 ipv6ptr = inet_ntop(AF_INET6, ipv6a, ipv6res, sizeof(ipv6res));
3952 if(!ipv6ptr)
3953 exit(1); /* fail */
3954 if(ipv6ptr != ipv6res)
3955 exit(1); /* fail */
3956 if(!ipv6ptr[0])
3957 exit(1); /* fail */
3958 if(memcmp(ipv6res, "fe80::214:4fff:fe0b:76c8", 24) != 0)
3959 exit(1); /* fail */
3960 /* - */
3961 exit(0);
3962 ]])
3963 ],[
3964 AC_MSG_RESULT([yes])
3965 tst_works_inet_ntop="yes"
3966 ],[
3967 AC_MSG_RESULT([no])
3968 tst_works_inet_ntop="no"
3969 ])
3970 fi
3971 #
3972 if test "$tst_compi_inet_ntop" = "yes" &&
3973 test "$tst_works_inet_ntop" != "no"; then
3974 AC_MSG_CHECKING([if inet_ntop usage allowed])
3975 if test "x$curl_disallow_inet_ntop" != "xyes"; then
3976 AC_MSG_RESULT([yes])
3977 tst_allow_inet_ntop="yes"
3978 else
3979 AC_MSG_RESULT([no])
3980 tst_allow_inet_ntop="no"
3981 fi
3982 fi
3983 #
3984 AC_MSG_CHECKING([if inet_ntop might be used])
3985 if test "$tst_links_inet_ntop" = "yes" &&
3986 test "$tst_proto_inet_ntop" = "yes" &&
3987 test "$tst_compi_inet_ntop" = "yes" &&
3988 test "$tst_allow_inet_ntop" = "yes" &&
3989 test "$tst_works_inet_ntop" != "no"; then
3990 AC_MSG_RESULT([yes])
3991 AC_DEFINE_UNQUOTED(HAVE_INET_NTOP, 1,
3992 [Define to 1 if you have a IPv6 capable working inet_ntop function.])
3993 curl_cv_func_inet_ntop="yes"
3994 else
3995 AC_MSG_RESULT([no])
3996 curl_cv_func_inet_ntop="no"
3997 fi
3998 ])
3999
4000
4001 dnl CURL_CHECK_FUNC_INET_PTON
4002 dnl -------------------------------------------------
4003 dnl Verify if inet_pton is available, prototyped, can
4004 dnl be compiled and seems to work. If all of these are
4005 dnl true, and usage has not been previously disallowed
4006 dnl with shell variable curl_disallow_inet_pton, then
4007 dnl HAVE_INET_PTON will be defined.
4008
4009 AC_DEFUN([CURL_CHECK_FUNC_INET_PTON], [
4010 AC_REQUIRE([CURL_INCLUDES_STDLIB])dnl
4011 AC_REQUIRE([CURL_INCLUDES_ARPA_INET])dnl
4012 AC_REQUIRE([CURL_INCLUDES_STRING])dnl
4013 #
4014 tst_links_inet_pton="unknown"
4015 tst_proto_inet_pton="unknown"
4016 tst_compi_inet_pton="unknown"
4017 tst_works_inet_pton="unknown"
4018 tst_allow_inet_pton="unknown"
4019 #
4020 AC_MSG_CHECKING([if inet_pton can be linked])
4021 AC_LINK_IFELSE([
4022 AC_LANG_FUNC_LINK_TRY([inet_pton])
4023 ],[
4024 AC_MSG_RESULT([yes])
4025 tst_links_inet_pton="yes"
4026 ],[
4027 AC_MSG_RESULT([no])
4028 tst_links_inet_pton="no"
4029 ])
4030 #
4031 if test "$tst_links_inet_pton" = "yes"; then
4032 AC_MSG_CHECKING([if inet_pton is prototyped])
4033 AC_EGREP_CPP([inet_pton],[
4034 $curl_includes_arpa_inet
4035 ],[
4036 AC_MSG_RESULT([yes])
4037 tst_proto_inet_pton="yes"
4038 ],[
4039 AC_MSG_RESULT([no])
4040 tst_proto_inet_pton="no"
4041 ])
4042 fi
4043 #
4044 if test "$tst_proto_inet_pton" = "yes"; then
4045 AC_MSG_CHECKING([if inet_pton is compilable])
4046 AC_COMPILE_IFELSE([
4047 AC_LANG_PROGRAM([[
4048 $curl_includes_arpa_inet
4049 ]],[[
4050 if(0 != inet_pton(0, 0, 0))
4051 return 1;
4052 ]])
4053 ],[
4054 AC_MSG_RESULT([yes])
4055 tst_compi_inet_pton="yes"
4056 ],[
4057 AC_MSG_RESULT([no])
4058 tst_compi_inet_pton="no"
4059 ])
4060 fi
4061 #
4062 dnl only do runtime verification when not cross-compiling
4063 if test "x$cross_compiling" != "xyes" &&
4064 test "$tst_compi_inet_pton" = "yes"; then
4065 AC_MSG_CHECKING([if inet_pton seems to work])
4066 CURL_RUN_IFELSE([
4067 AC_LANG_PROGRAM([[
4068 $curl_includes_stdlib
4069 $curl_includes_arpa_inet
4070 $curl_includes_string
4071 ]],[[
4072 unsigned char ipv6a[16+1];
4073 unsigned char ipv4a[4+1];
4074 const char *ipv6src = "fe80::214:4fff:fe0b:76c8";
4075 const char *ipv4src = "192.168.100.1";
4076 /* - */
4077 memset(ipv4a, 1, sizeof(ipv4a));
4078 if(1 != inet_pton(AF_INET, ipv4src, ipv4a))
4079 exit(1); /* fail */
4080 /* - */
4081 if( (ipv4a[0] != 0xc0) ||
4082 (ipv4a[1] != 0xa8) ||
4083 (ipv4a[2] != 0x64) ||
4084 (ipv4a[3] != 0x01) ||
4085 (ipv4a[4] != 0x01) )
4086 exit(1); /* fail */
4087 /* - */
4088 memset(ipv6a, 1, sizeof(ipv6a));
4089 if(1 != inet_pton(AF_INET6, ipv6src, ipv6a))
4090 exit(1); /* fail */
4091 /* - */
4092 if( (ipv6a[0] != 0xfe) ||
4093 (ipv6a[1] != 0x80) ||
4094 (ipv6a[8] != 0x02) ||
4095 (ipv6a[9] != 0x14) ||
4096 (ipv6a[10] != 0x4f) ||
4097 (ipv6a[11] != 0xff) ||
4098 (ipv6a[12] != 0xfe) ||
4099 (ipv6a[13] != 0x0b) ||
4100 (ipv6a[14] != 0x76) ||
4101 (ipv6a[15] != 0xc8) ||
4102 (ipv6a[16] != 0x01) )
4103 exit(1); /* fail */
4104 /* - */
4105 if( (ipv6a[2] != 0x0) ||
4106 (ipv6a[3] != 0x0) ||
4107 (ipv6a[4] != 0x0) ||
4108 (ipv6a[5] != 0x0) ||
4109 (ipv6a[6] != 0x0) ||
4110 (ipv6a[7] != 0x0) )
4111 exit(1); /* fail */
4112 /* - */
4113 exit(0);
4114 ]])
4115 ],[
4116 AC_MSG_RESULT([yes])
4117 tst_works_inet_pton="yes"
4118 ],[
4119 AC_MSG_RESULT([no])
4120 tst_works_inet_pton="no"
4121 ])
4122 fi
4123 #
4124 if test "$tst_compi_inet_pton" = "yes" &&
4125 test "$tst_works_inet_pton" != "no"; then
4126 AC_MSG_CHECKING([if inet_pton usage allowed])
4127 if test "x$curl_disallow_inet_pton" != "xyes"; then
4128 AC_MSG_RESULT([yes])
4129 tst_allow_inet_pton="yes"
4130 else
4131 AC_MSG_RESULT([no])
4132 tst_allow_inet_pton="no"
4133 fi
4134 fi
4135 #
4136 AC_MSG_CHECKING([if inet_pton might be used])
4137 if test "$tst_links_inet_pton" = "yes" &&
4138 test "$tst_proto_inet_pton" = "yes" &&
4139 test "$tst_compi_inet_pton" = "yes" &&
4140 test "$tst_allow_inet_pton" = "yes" &&
4141 test "$tst_works_inet_pton" != "no"; then
4142 AC_MSG_RESULT([yes])
4143 AC_DEFINE_UNQUOTED(HAVE_INET_PTON, 1,
4144 [Define to 1 if you have a IPv6 capable working inet_pton function.])
4145 curl_cv_func_inet_pton="yes"
4146 else
4147 AC_MSG_RESULT([no])
4148 curl_cv_func_inet_pton="no"
4149 fi
4150 ])
4151
4152
4153 dnl CURL_CHECK_FUNC_IOCTL
4154 dnl -------------------------------------------------
4155 dnl Verify if ioctl is available, prototyped, and
4156 dnl can be compiled. If all of these are true, and
4157 dnl usage has not been previously disallowed with
4158 dnl shell variable curl_disallow_ioctl, then
4159 dnl HAVE_IOCTL will be defined.
4160
4161 AC_DEFUN([CURL_CHECK_FUNC_IOCTL], [
4162 AC_REQUIRE([CURL_INCLUDES_STROPTS])dnl
4163 #
4164 tst_links_ioctl="unknown"
4165 tst_proto_ioctl="unknown"
4166 tst_compi_ioctl="unknown"
4167 tst_allow_ioctl="unknown"
4168 #
4169 AC_MSG_CHECKING([if ioctl can be linked])
4170 AC_LINK_IFELSE([
4171 AC_LANG_FUNC_LINK_TRY([ioctl])
4172 ],[
4173 AC_MSG_RESULT([yes])
4174 tst_links_ioctl="yes"
4175 ],[
4176 AC_MSG_RESULT([no])
4177 tst_links_ioctl="no"
4178 ])
4179 #
4180 if test "$tst_links_ioctl" = "yes"; then
4181 AC_MSG_CHECKING([if ioctl is prototyped])
4182 AC_EGREP_CPP([ioctl],[
4183 $curl_includes_stropts
4184 ],[
4185 AC_MSG_RESULT([yes])
4186 tst_proto_ioctl="yes"
4187 ],[
4188 AC_MSG_RESULT([no])
4189 tst_proto_ioctl="no"
4190 ])
4191 fi
4192 #
4193 if test "$tst_proto_ioctl" = "yes"; then
4194 AC_MSG_CHECKING([if ioctl is compilable])
4195 AC_COMPILE_IFELSE([
4196 AC_LANG_PROGRAM([[
4197 $curl_includes_stropts
4198 ]],[[
4199 if(0 != ioctl(0, 0, 0))
4200 return 1;
4201 ]])
4202 ],[
4203 AC_MSG_RESULT([yes])
4204 tst_compi_ioctl="yes"
4205 ],[
4206 AC_MSG_RESULT([no])
4207 tst_compi_ioctl="no"
4208 ])
4209 fi
4210 #
4211 if test "$tst_compi_ioctl" = "yes"; then
4212 AC_MSG_CHECKING([if ioctl usage allowed])
4213 if test "x$curl_disallow_ioctl" != "xyes"; then
4214 AC_MSG_RESULT([yes])
4215 tst_allow_ioctl="yes"
4216 else
4217 AC_MSG_RESULT([no])
4218 tst_allow_ioctl="no"
4219 fi
4220 fi
4221 #
4222 AC_MSG_CHECKING([if ioctl might be used])
4223 if test "$tst_links_ioctl" = "yes" &&
4224 test "$tst_proto_ioctl" = "yes" &&
4225 test "$tst_compi_ioctl" = "yes" &&
4226 test "$tst_allow_ioctl" = "yes"; then
4227 AC_MSG_RESULT([yes])
4228 AC_DEFINE_UNQUOTED(HAVE_IOCTL, 1,
4229 [Define to 1 if you have the ioctl function.])
4230 curl_cv_func_ioctl="yes"
4231 CURL_CHECK_FUNC_IOCTL_FIONBIO
4232 CURL_CHECK_FUNC_IOCTL_SIOCGIFADDR
4233 else
4234 AC_MSG_RESULT([no])
4235 curl_cv_func_ioctl="no"
4236 fi
4237 ])
4238
4239
4240 dnl CURL_CHECK_FUNC_IOCTL_FIONBIO
4241 dnl -------------------------------------------------
4242 dnl Verify if ioctl with the FIONBIO command is
4243 dnl available, can be compiled, and seems to work. If
4244 dnl all of these are true, then HAVE_IOCTL_FIONBIO
4245 dnl will be defined.
4246
4247 AC_DEFUN([CURL_CHECK_FUNC_IOCTL_FIONBIO], [
4248 #
4249 tst_compi_ioctl_fionbio="unknown"
4250 tst_allow_ioctl_fionbio="unknown"
4251 #
4252 if test "$curl_cv_func_ioctl" = "yes"; then
4253 AC_MSG_CHECKING([if ioctl FIONBIO is compilable])
4254 AC_COMPILE_IFELSE([
4255 AC_LANG_PROGRAM([[
4256 $curl_includes_stropts
4257 ]],[[
4258 int flags = 0;
4259 if(0 != ioctl(0, FIONBIO, &flags))
4260 return 1;
4261 ]])
4262 ],[
4263 AC_MSG_RESULT([yes])
4264 tst_compi_ioctl_fionbio="yes"
4265 ],[
4266 AC_MSG_RESULT([no])
4267 tst_compi_ioctl_fionbio="no"
4268 ])
4269 fi
4270 #
4271 if test "$tst_compi_ioctl_fionbio" = "yes"; then
4272 AC_MSG_CHECKING([if ioctl FIONBIO usage allowed])
4273 if test "x$curl_disallow_ioctl_fionbio" != "xyes"; then
4274 AC_MSG_RESULT([yes])
4275 tst_allow_ioctl_fionbio="yes"
4276 else
4277 AC_MSG_RESULT([no])
4278 tst_allow_ioctl_fionbio="no"
4279 fi
4280 fi
4281 #
4282 AC_MSG_CHECKING([if ioctl FIONBIO might be used])
4283 if test "$tst_compi_ioctl_fionbio" = "yes" &&
4284 test "$tst_allow_ioctl_fionbio" = "yes"; then
4285 AC_MSG_RESULT([yes])
4286 AC_DEFINE_UNQUOTED(HAVE_IOCTL_FIONBIO, 1,
4287 [Define to 1 if you have a working ioctl FIONBIO function.])
4288 curl_cv_func_ioctl_fionbio="yes"
4289 else
4290 AC_MSG_RESULT([no])
4291 curl_cv_func_ioctl_fionbio="no"
4292 fi
4293 ])
4294
4295
4296 dnl CURL_CHECK_FUNC_IOCTL_SIOCGIFADDR
4297 dnl -------------------------------------------------
4298 dnl Verify if ioctl with the SIOCGIFADDR command is available,
4299 dnl struct ifreq is defined, they can be compiled, and seem to
4300 dnl work. If all of these are true, then HAVE_IOCTL_SIOCGIFADDR
4301 dnl will be defined.
4302
4303 AC_DEFUN([CURL_CHECK_FUNC_IOCTL_SIOCGIFADDR], [
4304 #
4305 tst_compi_ioctl_siocgifaddr="unknown"
4306 tst_allow_ioctl_siocgifaddr="unknown"
4307 #
4308 if test "$curl_cv_func_ioctl" = "yes"; then
4309 AC_MSG_CHECKING([if ioctl SIOCGIFADDR is compilable])
4310 AC_COMPILE_IFELSE([
4311 AC_LANG_PROGRAM([[
4312 $curl_includes_stropts
4313 #include <net/if.h>
4314 ]],[[
4315 struct ifreq ifr;
4316 if(0 != ioctl(0, SIOCGIFADDR, &ifr))
4317 return 1;
4318 ]])
4319 ],[
4320 AC_MSG_RESULT([yes])
4321 tst_compi_ioctl_siocgifaddr="yes"
4322 ],[
4323 AC_MSG_RESULT([no])
4324 tst_compi_ioctl_siocgifaddr="no"
4325 ])
4326 fi
4327 #
4328 if test "$tst_compi_ioctl_siocgifaddr" = "yes"; then
4329 AC_MSG_CHECKING([if ioctl SIOCGIFADDR usage allowed])
4330 if test "x$curl_disallow_ioctl_siocgifaddr" != "xyes"; then
4331 AC_MSG_RESULT([yes])
4332 tst_allow_ioctl_siocgifaddr="yes"
4333 else
4334 AC_MSG_RESULT([no])
4335 tst_allow_ioctl_siocgifaddr="no"
4336 fi
4337 fi
4338 #
4339 AC_MSG_CHECKING([if ioctl SIOCGIFADDR might be used])
4340 if test "$tst_compi_ioctl_siocgifaddr" = "yes" &&
4341 test "$tst_allow_ioctl_siocgifaddr" = "yes"; then
4342 AC_MSG_RESULT([yes])
4343 AC_DEFINE_UNQUOTED(HAVE_IOCTL_SIOCGIFADDR, 1,
4344 [Define to 1 if you have a working ioctl SIOCGIFADDR function.])
4345 curl_cv_func_ioctl_siocgifaddr="yes"
4346 else
4347 AC_MSG_RESULT([no])
4348 curl_cv_func_ioctl_siocgifaddr="no"
4349 fi
4350 ])
4351
4352
4353 dnl CURL_CHECK_FUNC_IOCTLSOCKET
4354 dnl -------------------------------------------------
4355 dnl Verify if ioctlsocket is available, prototyped, and
4356 dnl can be compiled. If all of these are true, and
4357 dnl usage has not been previously disallowed with
4358 dnl shell variable curl_disallow_ioctlsocket, then
4359 dnl HAVE_IOCTLSOCKET will be defined.
4360
4361 AC_DEFUN([CURL_CHECK_FUNC_IOCTLSOCKET], [
4362 AC_REQUIRE([CURL_INCLUDES_WINSOCK2])dnl
4363 #
4364 tst_links_ioctlsocket="unknown"
4365 tst_proto_ioctlsocket="unknown"
4366 tst_compi_ioctlsocket="unknown"
4367 tst_allow_ioctlsocket="unknown"
4368 #
4369 AC_MSG_CHECKING([if ioctlsocket can be linked])
4370 AC_LINK_IFELSE([
4371 AC_LANG_PROGRAM([[
4372 $curl_includes_winsock2
4373 $curl_includes_bsdsocket
4374 ]],[[
4375 if(0 != ioctlsocket(0, 0, 0))
4376 return 1;
4377 ]])
4378 ],[
4379 AC_MSG_RESULT([yes])
4380 tst_links_ioctlsocket="yes"
4381 ],[
4382 AC_MSG_RESULT([no])
4383 tst_links_ioctlsocket="no"
4384 ])
4385 #
4386 if test "$tst_links_ioctlsocket" = "yes"; then
4387 AC_MSG_CHECKING([if ioctlsocket is prototyped])
4388 AC_EGREP_CPP([ioctlsocket],[
4389 $curl_includes_winsock2
4390 $curl_includes_bsdsocket
4391 ],[
4392 AC_MSG_RESULT([yes])
4393 tst_proto_ioctlsocket="yes"
4394 ],[
4395 AC_MSG_RESULT([no])
4396 tst_proto_ioctlsocket="no"
4397 ])
4398 fi
4399 #
4400 if test "$tst_proto_ioctlsocket" = "yes"; then
4401 AC_MSG_CHECKING([if ioctlsocket is compilable])
4402 AC_COMPILE_IFELSE([
4403 AC_LANG_PROGRAM([[
4404 $curl_includes_winsock2
4405 $curl_includes_bsdsocket
4406 ]],[[
4407 if(0 != ioctlsocket(0, 0, 0))
4408 return 1;
4409 ]])
4410 ],[
4411 AC_MSG_RESULT([yes])
4412 tst_compi_ioctlsocket="yes"
4413 ],[
4414 AC_MSG_RESULT([no])
4415 tst_compi_ioctlsocket="no"
4416 ])
4417 fi
4418 #
4419 if test "$tst_compi_ioctlsocket" = "yes"; then
4420 AC_MSG_CHECKING([if ioctlsocket usage allowed])
4421 if test "x$curl_disallow_ioctlsocket" != "xyes"; then
4422 AC_MSG_RESULT([yes])
4423 tst_allow_ioctlsocket="yes"
4424 else
4425 AC_MSG_RESULT([no])
4426 tst_allow_ioctlsocket="no"
4427 fi
4428 fi
4429 #
4430 AC_MSG_CHECKING([if ioctlsocket might be used])
4431 if test "$tst_links_ioctlsocket" = "yes" &&
4432 test "$tst_proto_ioctlsocket" = "yes" &&
4433 test "$tst_compi_ioctlsocket" = "yes" &&
4434 test "$tst_allow_ioctlsocket" = "yes"; then
4435 AC_MSG_RESULT([yes])
4436 AC_DEFINE_UNQUOTED(HAVE_IOCTLSOCKET, 1,
4437 [Define to 1 if you have the ioctlsocket function.])
4438 curl_cv_func_ioctlsocket="yes"
4439 CURL_CHECK_FUNC_IOCTLSOCKET_FIONBIO
4440 else
4441 AC_MSG_RESULT([no])
4442 curl_cv_func_ioctlsocket="no"
4443 fi
4444 ])
4445
4446
4447 dnl CURL_CHECK_FUNC_IOCTLSOCKET_FIONBIO
4448 dnl -------------------------------------------------
4449 dnl Verify if ioctlsocket with the FIONBIO command is
4450 dnl available, can be compiled, and seems to work. If
4451 dnl all of these are true, then HAVE_IOCTLSOCKET_FIONBIO
4452 dnl will be defined.
4453
4454 AC_DEFUN([CURL_CHECK_FUNC_IOCTLSOCKET_FIONBIO], [
4455 #
4456 tst_compi_ioctlsocket_fionbio="unknown"
4457 tst_allow_ioctlsocket_fionbio="unknown"
4458 #
4459 if test "$curl_cv_func_ioctlsocket" = "yes"; then
4460 AC_MSG_CHECKING([if ioctlsocket FIONBIO is compilable])
4461 AC_COMPILE_IFELSE([
4462 AC_LANG_PROGRAM([[
4463 $curl_includes_winsock2
4464 $curl_includes_bsdsocket
4465 ]],[[
4466 int flags = 0;
4467 if(0 != ioctlsocket(0, FIONBIO, &flags))
4468 return 1;
4469 ]])
4470 ],[
4471 AC_MSG_RESULT([yes])
4472 tst_compi_ioctlsocket_fionbio="yes"
4473 ],[
4474 AC_MSG_RESULT([no])
4475 tst_compi_ioctlsocket_fionbio="no"
4476 ])
4477 fi
4478 #
4479 if test "$tst_compi_ioctlsocket_fionbio" = "yes"; then
4480 AC_MSG_CHECKING([if ioctlsocket FIONBIO usage allowed])
4481 if test "x$curl_disallow_ioctlsocket_fionbio" != "xyes"; then
4482 AC_MSG_RESULT([yes])
4483 tst_allow_ioctlsocket_fionbio="yes"
4484 else
4485 AC_MSG_RESULT([no])
4486 tst_allow_ioctlsocket_fionbio="no"
4487 fi
4488 fi
4489 #
4490 AC_MSG_CHECKING([if ioctlsocket FIONBIO might be used])
4491 if test "$tst_compi_ioctlsocket_fionbio" = "yes" &&
4492 test "$tst_allow_ioctlsocket_fionbio" = "yes"; then
4493 AC_MSG_RESULT([yes])
4494 AC_DEFINE_UNQUOTED(HAVE_IOCTLSOCKET_FIONBIO, 1,
4495 [Define to 1 if you have a working ioctlsocket FIONBIO function.])
4496 curl_cv_func_ioctlsocket_fionbio="yes"
4497 else
4498 AC_MSG_RESULT([no])
4499 curl_cv_func_ioctlsocket_fionbio="no"
4500 fi
4501 ])
4502
4503
4504 dnl CURL_CHECK_FUNC_IOCTLSOCKET_CAMEL
4505 dnl -------------------------------------------------
4506 dnl Verify if IoctlSocket is available, prototyped, and
4507 dnl can be compiled. If all of these are true, and
4508 dnl usage has not been previously disallowed with
4509 dnl shell variable curl_disallow_ioctlsocket_camel,
4510 dnl then HAVE_IOCTLSOCKET_CAMEL will be defined.
4511
4512 AC_DEFUN([CURL_CHECK_FUNC_IOCTLSOCKET_CAMEL], [
4513 AC_REQUIRE([CURL_INCLUDES_STROPTS])dnl
4514 #
4515 tst_links_ioctlsocket_camel="unknown"
4516 tst_proto_ioctlsocket_camel="unknown"
4517 tst_compi_ioctlsocket_camel="unknown"
4518 tst_allow_ioctlsocket_camel="unknown"
4519 #
4520 AC_MSG_CHECKING([if IoctlSocket can be linked])
4521 AC_LINK_IFELSE([
4522 AC_LANG_FUNC_LINK_TRY([IoctlSocket])
4523 ],[
4524 AC_MSG_RESULT([yes])
4525 tst_links_ioctlsocket_camel="yes"
4526 ],[
4527 AC_MSG_RESULT([no])
4528 tst_links_ioctlsocket_camel="no"
4529 ])
4530 #
4531 if test "$tst_links_ioctlsocket_camel" = "yes"; then
4532 AC_MSG_CHECKING([if IoctlSocket is prototyped])
4533 AC_EGREP_CPP([IoctlSocket],[
4534 $curl_includes_stropts
4535 ],[
4536 AC_MSG_RESULT([yes])
4537 tst_proto_ioctlsocket_camel="yes"
4538 ],[
4539 AC_MSG_RESULT([no])
4540 tst_proto_ioctlsocket_camel="no"
4541 ])
4542 fi
4543 #
4544 if test "$tst_proto_ioctlsocket_camel" = "yes"; then
4545 AC_MSG_CHECKING([if IoctlSocket is compilable])
4546 AC_COMPILE_IFELSE([
4547 AC_LANG_PROGRAM([[
4548 $curl_includes_stropts
4549 ]],[[
4550 if(0 != IoctlSocket(0, 0, 0))
4551 return 1;
4552 ]])
4553 ],[
4554 AC_MSG_RESULT([yes])
4555 tst_compi_ioctlsocket_camel="yes"
4556 ],[
4557 AC_MSG_RESULT([no])
4558 tst_compi_ioctlsocket_camel="no"
4559 ])
4560 fi
4561 #
4562 if test "$tst_compi_ioctlsocket_camel" = "yes"; then
4563 AC_MSG_CHECKING([if IoctlSocket usage allowed])
4564 if test "x$curl_disallow_ioctlsocket_camel" != "xyes"; then
4565 AC_MSG_RESULT([yes])
4566 tst_allow_ioctlsocket_camel="yes"
4567 else
4568 AC_MSG_RESULT([no])
4569 tst_allow_ioctlsocket_camel="no"
4570 fi
4571 fi
4572 #
4573 AC_MSG_CHECKING([if IoctlSocket might be used])
4574 if test "$tst_links_ioctlsocket_camel" = "yes" &&
4575 test "$tst_proto_ioctlsocket_camel" = "yes" &&
4576 test "$tst_compi_ioctlsocket_camel" = "yes" &&
4577 test "$tst_allow_ioctlsocket_camel" = "yes"; then
4578 AC_MSG_RESULT([yes])
4579 AC_DEFINE_UNQUOTED(HAVE_IOCTLSOCKET_CAMEL, 1,
4580 [Define to 1 if you have the IoctlSocket camel case function.])
4581 curl_cv_func_ioctlsocket_camel="yes"
4582 CURL_CHECK_FUNC_IOCTLSOCKET_CAMEL_FIONBIO
4583 else
4584 AC_MSG_RESULT([no])
4585 curl_cv_func_ioctlsocket_camel="no"
4586 fi
4587 ])
4588
4589
4590 dnl CURL_CHECK_FUNC_IOCTLSOCKET_CAMEL_FIONBIO
4591 dnl -------------------------------------------------
4592 dnl Verify if IoctlSocket with FIONBIO command is available,
4593 dnl can be compiled, and seems to work. If all of these are
4594 dnl true, then HAVE_IOCTLSOCKET_CAMEL_FIONBIO will be defined.
4595
4596 AC_DEFUN([CURL_CHECK_FUNC_IOCTLSOCKET_CAMEL_FIONBIO], [
4597 #
4598 tst_compi_ioctlsocket_camel_fionbio="unknown"
4599 tst_allow_ioctlsocket_camel_fionbio="unknown"
4600 #
4601 if test "$curl_cv_func_ioctlsocket_camel" = "yes"; then
4602 AC_MSG_CHECKING([if IoctlSocket FIONBIO is compilable])
4603 AC_COMPILE_IFELSE([
4604 AC_LANG_PROGRAM([[
4605 $curl_includes_stropts
4606 ]],[[
4607 long flags = 0;
4608 if(0 != ioctlsocket(0, FIONBIO, &flags))
4609 return 1;
4610 ]])
4611 ],[
4612 AC_MSG_RESULT([yes])
4613 tst_compi_ioctlsocket_camel_fionbio="yes"
4614 ],[
4615 AC_MSG_RESULT([no])
4616 tst_compi_ioctlsocket_camel_fionbio="no"
4617 ])
4618 fi
4619 #
4620 if test "$tst_compi_ioctlsocket_camel_fionbio" = "yes"; then
4621 AC_MSG_CHECKING([if IoctlSocket FIONBIO usage allowed])
4622 if test "x$curl_disallow_ioctlsocket_camel_fionbio" != "xyes"; then
4623 AC_MSG_RESULT([yes])
4624 tst_allow_ioctlsocket_camel_fionbio="yes"
4625 else
4626 AC_MSG_RESULT([no])
4627 tst_allow_ioctlsocket_camel_fionbio="no"
4628 fi
4629 fi
4630 #
4631 AC_MSG_CHECKING([if IoctlSocket FIONBIO might be used])
4632 if test "$tst_compi_ioctlsocket_camel_fionbio" = "yes" &&
4633 test "$tst_allow_ioctlsocket_camel_fionbio" = "yes"; then
4634 AC_MSG_RESULT([yes])
4635 AC_DEFINE_UNQUOTED(HAVE_IOCTLSOCKET_CAMEL_FIONBIO, 1,
4636 [Define to 1 if you have a working IoctlSocket camel case FIONBIO function.])
4637 curl_cv_func_ioctlsocket_camel_fionbio="yes"
4638 else
4639 AC_MSG_RESULT([no])
4640 curl_cv_func_ioctlsocket_camel_fionbio="no"
4641 fi
4642 ])
4643
4644
4645 dnl CURL_CHECK_FUNC_LISTXATTR
4646 dnl -------------------------------------------------
4647 dnl Verify if listxattr is available, prototyped, and
4648 dnl can be compiled. If all of these are true, and
4649 dnl usage has not been previously disallowed with
4650 dnl shell variable curl_disallow_listxattr, then
4651 dnl HAVE_LISTXATTR will be defined.
4652
4653 AC_DEFUN([CURL_CHECK_FUNC_LISTXATTR], [
4654 AC_REQUIRE([CURL_INCLUDES_SYS_XATTR])dnl
4655 #
4656 tst_links_listxattr="unknown"
4657 tst_proto_listxattr="unknown"
4658 tst_compi_listxattr="unknown"
4659 tst_allow_listxattr="unknown"
4660 tst_nargs_listxattr="unknown"
4661 #
4662 AC_MSG_CHECKING([if listxattr can be linked])
4663 AC_LINK_IFELSE([
4664 AC_LANG_FUNC_LINK_TRY([listxattr])
4665 ],[
4666 AC_MSG_RESULT([yes])
4667 tst_links_listxattr="yes"
4668 ],[
4669 AC_MSG_RESULT([no])
4670 tst_links_listxattr="no"
4671 ])
4672 #
4673 if test "$tst_links_listxattr" = "yes"; then
4674 AC_MSG_CHECKING([if listxattr is prototyped])
4675 AC_EGREP_CPP([listxattr],[
4676 $curl_includes_sys_xattr
4677 ],[
4678 AC_MSG_RESULT([yes])
4679 tst_proto_listxattr="yes"
4680 ],[
4681 AC_MSG_RESULT([no])
4682 tst_proto_listxattr="no"
4683 ])
4684 fi
4685 #
4686 if test "$tst_proto_listxattr" = "yes"; then
4687 if test "$tst_nargs_listxattr" = "unknown"; then
4688 AC_MSG_CHECKING([if listxattr takes 3 args.])
4689 AC_COMPILE_IFELSE([
4690 AC_LANG_PROGRAM([[
4691 $curl_includes_sys_xattr
4692 ]],[[
4693 if(0 != listxattr(0, 0, 0))
4694 return 1;
4695 ]])
4696 ],[
4697 AC_MSG_RESULT([yes])
4698 tst_compi_listxattr="yes"
4699 tst_nargs_listxattr="3"
4700 ],[
4701 AC_MSG_RESULT([no])
4702 tst_compi_listxattr="no"
4703 ])
4704 fi
4705 if test "$tst_nargs_listxattr" = "unknown"; then
4706 AC_MSG_CHECKING([if listxattr takes 4 args.])
4707 AC_COMPILE_IFELSE([
4708 AC_LANG_PROGRAM([[
4709 $curl_includes_sys_xattr
4710 ]],[[
4711 if(0 != listxattr(0, 0, 0, 0))
4712 return 1;
4713 ]])
4714 ],[
4715 AC_MSG_RESULT([yes])
4716 tst_compi_listxattr="yes"
4717 tst_nargs_listxattr="4"
4718 ],[
4719 AC_MSG_RESULT([no])
4720 tst_compi_listxattr="no"
4721 ])
4722 fi
4723 AC_MSG_CHECKING([if listxattr is compilable])
4724 if test "$tst_compi_listxattr" = "yes"; then
4725 AC_MSG_RESULT([yes])
4726 else
4727 AC_MSG_RESULT([no])
4728 fi
4729 fi
4730 #
4731 if test "$tst_compi_listxattr" = "yes"; then
4732 AC_MSG_CHECKING([if listxattr usage allowed])
4733 if test "x$curl_disallow_listxattr" != "xyes"; then
4734 AC_MSG_RESULT([yes])
4735 tst_allow_listxattr="yes"
4736 else
4737 AC_MSG_RESULT([no])
4738 tst_allow_listxattr="no"
4739 fi
4740 fi
4741 #
4742 AC_MSG_CHECKING([if listxattr might be used])
4743 if test "$tst_links_listxattr" = "yes" &&
4744 test "$tst_proto_listxattr" = "yes" &&
4745 test "$tst_compi_listxattr" = "yes" &&
4746 test "$tst_allow_listxattr" = "yes"; then
4747 AC_MSG_RESULT([yes])
4748 AC_DEFINE_UNQUOTED(HAVE_LISTXATTR, 1,
4749 [Define to 1 if you have the listxattr function.])
4750 dnl AC_DEFINE_UNQUOTED(LISTXATTR_ARGS, $tst_nargs_listxattr,
4751 dnl [Specifies the number of arguments to listxattr])
4752 #
4753 if test "$tst_nargs_listxattr" -eq "3"; then
4754 AC_DEFINE(HAVE_LISTXATTR_3, 1, [listxattr() takes 3 args])
4755 elif test "$tst_nargs_listxattr" -eq "4"; then
4756 AC_DEFINE(HAVE_LISTXATTR_4, 1, [listxattr() takes 4 args])
4757 fi
4758 #
4759 curl_cv_func_listxattr="yes"
4760 else
4761 AC_MSG_RESULT([no])
4762 curl_cv_func_listxattr="no"
4763 fi
4764 ])
4765
4766
4767 dnl CURL_CHECK_FUNC_LOCALTIME_R
4768 dnl -------------------------------------------------
4769 dnl Verify if localtime_r is available, prototyped, can
4770 dnl be compiled and seems to work. If all of these are
4771 dnl true, and usage has not been previously disallowed
4772 dnl with shell variable curl_disallow_localtime_r, then
4773 dnl HAVE_LOCALTIME_R will be defined.
4774
4775 AC_DEFUN([CURL_CHECK_FUNC_LOCALTIME_R], [
4776 AC_REQUIRE([CURL_INCLUDES_STDLIB])dnl
4777 AC_REQUIRE([CURL_INCLUDES_TIME])dnl
4778 #
4779 tst_links_localtime_r="unknown"
4780 tst_proto_localtime_r="unknown"
4781 tst_compi_localtime_r="unknown"
4782 tst_works_localtime_r="unknown"
4783 tst_allow_localtime_r="unknown"
4784 #
4785 AC_MSG_CHECKING([if localtime_r can be linked])
4786 AC_LINK_IFELSE([
4787 AC_LANG_FUNC_LINK_TRY([localtime_r])
4788 ],[
4789 AC_MSG_RESULT([yes])
4790 tst_links_localtime_r="yes"
4791 ],[
4792 AC_MSG_RESULT([no])
4793 tst_links_localtime_r="no"
4794 ])
4795 #
4796 if test "$tst_links_localtime_r" = "yes"; then
4797 AC_MSG_CHECKING([if localtime_r is prototyped])
4798 AC_EGREP_CPP([localtime_r],[
4799 $curl_includes_time
4800 ],[
4801 AC_MSG_RESULT([yes])
4802 tst_proto_localtime_r="yes"
4803 ],[
4804 AC_MSG_RESULT([no])
4805 tst_proto_localtime_r="no"
4806 ])
4807 fi
4808 #
4809 if test "$tst_proto_localtime_r" = "yes"; then
4810 AC_MSG_CHECKING([if localtime_r is compilable])
4811 AC_COMPILE_IFELSE([
4812 AC_LANG_PROGRAM([[
4813 $curl_includes_time
4814 ]],[[
4815 if(0 != localtime_r(0, 0))
4816 return 1;
4817 ]])
4818 ],[
4819 AC_MSG_RESULT([yes])
4820 tst_compi_localtime_r="yes"
4821 ],[
4822 AC_MSG_RESULT([no])
4823 tst_compi_localtime_r="no"
4824 ])
4825 fi
4826 #
4827 dnl only do runtime verification when not cross-compiling
4828 if test "x$cross_compiling" != "xyes" &&
4829 test "$tst_compi_localtime_r" = "yes"; then
4830 AC_MSG_CHECKING([if localtime_r seems to work])
4831 CURL_RUN_IFELSE([
4832 AC_LANG_PROGRAM([[
4833 $curl_includes_stdlib
4834 $curl_includes_time
4835 ]],[[
4836 time_t clock = 1170352587;
4837 struct tm *tmp = 0;
4838 struct tm result;
4839 tmp = localtime_r(&clock, &result);
4840 if(tmp)
4841 exit(0);
4842 else
4843 exit(1);
4844 ]])
4845 ],[
4846 AC_MSG_RESULT([yes])
4847 tst_works_localtime_r="yes"
4848 ],[
4849 AC_MSG_RESULT([no])
4850 tst_works_localtime_r="no"
4851 ])
4852 fi
4853 #
4854 if test "$tst_compi_localtime_r" = "yes" &&
4855 test "$tst_works_localtime_r" != "no"; then
4856 AC_MSG_CHECKING([if localtime_r usage allowed])
4857 if test "x$curl_disallow_localtime_r" != "xyes"; then
4858 AC_MSG_RESULT([yes])
4859 tst_allow_localtime_r="yes"
4860 else
4861 AC_MSG_RESULT([no])
4862 tst_allow_localtime_r="no"
4863 fi
4864 fi
4865 #
4866 AC_MSG_CHECKING([if localtime_r might be used])
4867 if test "$tst_links_localtime_r" = "yes" &&
4868 test "$tst_proto_localtime_r" = "yes" &&
4869 test "$tst_compi_localtime_r" = "yes" &&
4870 test "$tst_allow_localtime_r" = "yes" &&
4871 test "$tst_works_localtime_r" != "no"; then
4872 AC_MSG_RESULT([yes])
4873 AC_DEFINE_UNQUOTED(HAVE_LOCALTIME_R, 1,
4874 [Define to 1 if you have a working localtime_r function.])
4875 curl_cv_func_localtime_r="yes"
4876 else
4877 AC_MSG_RESULT([no])
4878 curl_cv_func_localtime_r="no"
4879 fi
4880 ])
4881
4882
4883 dnl CURL_CHECK_FUNC_MEMRCHR
4884 dnl -------------------------------------------------
4885 dnl Verify if memrchr is available, prototyped, and
4886 dnl can be compiled. If all of these are true, and
4887 dnl usage has not been previously disallowed with
4888 dnl shell variable curl_disallow_memrchr, then
4889 dnl HAVE_MEMRCHR will be defined.
4890
4891 AC_DEFUN([CURL_CHECK_FUNC_MEMRCHR], [
4892 AC_REQUIRE([CURL_INCLUDES_STRING])dnl
4893 #
4894 tst_links_memrchr="unknown"
4895 tst_macro_memrchr="unknown"
4896 tst_proto_memrchr="unknown"
4897 tst_compi_memrchr="unknown"
4898 tst_allow_memrchr="unknown"
4899 #
4900 AC_MSG_CHECKING([if memrchr can be linked])
4901 AC_LINK_IFELSE([
4902 AC_LANG_FUNC_LINK_TRY([memrchr])
4903 ],[
4904 AC_MSG_RESULT([yes])
4905 tst_links_memrchr="yes"
4906 ],[
4907 AC_MSG_RESULT([no])
4908 tst_links_memrchr="no"
4909 ])
4910 #
4911 if test "$tst_links_memrchr" = "no"; then
4912 AC_MSG_CHECKING([if memrchr seems a macro])
4913 AC_LINK_IFELSE([
4914 AC_LANG_PROGRAM([[
4915 $curl_includes_string
4916 ]],[[
4917 if(0 != memrchr(0, 0, 0))
4918 return 1;
4919 ]])
4920 ],[
4921 AC_MSG_RESULT([yes])
4922 tst_macro_memrchr="yes"
4923 ],[
4924 AC_MSG_RESULT([no])
4925 tst_macro_memrchr="no"
4926 ])
4927 fi
4928 #
4929 if test "$tst_links_memrchr" = "yes"; then
4930 AC_MSG_CHECKING([if memrchr is prototyped])
4931 AC_EGREP_CPP([memrchr],[
4932 $curl_includes_string
4933 ],[
4934 AC_MSG_RESULT([yes])
4935 tst_proto_memrchr="yes"
4936 ],[
4937 AC_MSG_RESULT([no])
4938 tst_proto_memrchr="no"
4939 ])
4940 fi
4941 #
4942 if test "$tst_proto_memrchr" = "yes" ||
4943 test "$tst_macro_memrchr" = "yes"; then
4944 AC_MSG_CHECKING([if memrchr is compilable])
4945 AC_COMPILE_IFELSE([
4946 AC_LANG_PROGRAM([[
4947 $curl_includes_string
4948 ]],[[
4949 if(0 != memrchr(0, 0, 0))
4950 return 1;
4951 ]])
4952 ],[
4953 AC_MSG_RESULT([yes])
4954 tst_compi_memrchr="yes"
4955 ],[
4956 AC_MSG_RESULT([no])
4957 tst_compi_memrchr="no"
4958 ])
4959 fi
4960 #
4961 if test "$tst_compi_memrchr" = "yes"; then
4962 AC_MSG_CHECKING([if memrchr usage allowed])
4963 if test "x$curl_disallow_memrchr" != "xyes"; then
4964 AC_MSG_RESULT([yes])
4965 tst_allow_memrchr="yes"
4966 else
4967 AC_MSG_RESULT([no])
4968 tst_allow_memrchr="no"
4969 fi
4970 fi
4971 #
4972 AC_MSG_CHECKING([if memrchr might be used])
4973 if (test "$tst_proto_memrchr" = "yes" ||
4974 test "$tst_macro_memrchr" = "yes") &&
4975 test "$tst_compi_memrchr" = "yes" &&
4976 test "$tst_allow_memrchr" = "yes"; then
4977 AC_MSG_RESULT([yes])
4978 AC_DEFINE_UNQUOTED(HAVE_MEMRCHR, 1,
4979 [Define to 1 if you have the memrchr function or macro.])
4980 curl_cv_func_memrchr="yes"
4981 else
4982 AC_MSG_RESULT([no])
4983 curl_cv_func_memrchr="no"
4984 fi
4985 ])
4986
4987
4988 dnl CURL_CHECK_FUNC_POLL
4989 dnl -------------------------------------------------
4990 dnl Verify if poll is available, prototyped, can
4991 dnl be compiled and seems to work. If all of these are
4992 dnl true, and usage has not been previously disallowed
4993 dnl with shell variable curl_disallow_poll, then
4994 dnl HAVE_POLL will be defined.
4995
4996 AC_DEFUN([CURL_CHECK_FUNC_POLL], [
4997 AC_REQUIRE([CURL_INCLUDES_STDLIB])dnl
4998 AC_REQUIRE([CURL_INCLUDES_POLL])dnl
4999 #
5000 tst_links_poll="unknown"
5001 tst_proto_poll="unknown"
5002 tst_compi_poll="unknown"
5003 tst_works_poll="unknown"
5004 tst_allow_poll="unknown"
5005 #
5006 case $host_os in
5007 darwin*|interix*)
5008 dnl poll() does not work on these platforms
5009 dnl Interix: "does provide poll(), but the implementing developer must
5010 dnl have been in a bad mood, because poll() only works on the /proc
5011 dnl filesystem here"
5012 dnl macOS: poll() first didn't exist, then was broken until fixed in 10.9
5013 dnl only to break again in 10.12.
5014 curl_disallow_poll="yes"
5015 tst_compi_poll="no"
5016 ;;
5017 esac
5018 #
5019 AC_MSG_CHECKING([if poll can be linked])
5020 AC_LINK_IFELSE([
5021 AC_LANG_PROGRAM([[
5022 $curl_includes_poll
5023 ]],[[
5024 if(0 != poll(0, 0, 0))
5025 return 1;
5026 ]])
5027 ],[
5028 AC_MSG_RESULT([yes])
5029 tst_links_poll="yes"
5030 ],[
5031 AC_MSG_RESULT([no])
5032 tst_links_poll="no"
5033 ])
5034 #
5035 if test "$tst_links_poll" = "yes"; then
5036 AC_MSG_CHECKING([if poll is prototyped])
5037 AC_EGREP_CPP([poll],[
5038 $curl_includes_poll
5039 ],[
5040 AC_MSG_RESULT([yes])
5041 tst_proto_poll="yes"
5042 ],[
5043 AC_MSG_RESULT([no])
5044 tst_proto_poll="no"
5045 ])
5046 fi
5047 #
5048 if test "$tst_proto_poll" = "yes"; then
5049 AC_MSG_CHECKING([if poll is compilable])
5050 AC_COMPILE_IFELSE([
5051 AC_LANG_PROGRAM([[
5052 $curl_includes_poll
5053 ]],[[
5054 if(0 != poll(0, 0, 0))
5055 return 1;
5056 ]])
5057 ],[
5058 AC_MSG_RESULT([yes])
5059 tst_compi_poll="yes"
5060 ],[
5061 AC_MSG_RESULT([no])
5062 tst_compi_poll="no"
5063 ])
5064 fi
5065 #
5066 dnl only do runtime verification when not cross-compiling
5067 if test "x$cross_compiling" != "xyes" &&
5068 test "$tst_compi_poll" = "yes"; then
5069 AC_MSG_CHECKING([if poll seems to work])
5070 CURL_RUN_IFELSE([
5071 AC_LANG_PROGRAM([[
5072 $curl_includes_stdlib
5073 $curl_includes_poll
5074 $curl_includes_time
5075 ]],[[
5076 /* detect the original poll() breakage */
5077 if(0 != poll(0, 0, 10))
5078 exit(1); /* fail */
5079 else {
5080 /* detect the 10.12 poll() breakage */
5081 struct timeval before, after;
5082 int rc;
5083 size_t us;
5084
5085 gettimeofday(&before, NULL);
5086 rc = poll(NULL, 0, 500);
5087 gettimeofday(&after, NULL);
5088
5089 us = (after.tv_sec - before.tv_sec) * 1000000 +
5090 (after.tv_usec - before.tv_usec);
5091
5092 if(us < 400000)
5093 exit(1);
5094 }
5095 ]])
5096 ],[
5097 AC_MSG_RESULT([yes])
5098 tst_works_poll="yes"
5099 ],[
5100 AC_MSG_RESULT([no])
5101 tst_works_poll="no"
5102 ])
5103 fi
5104 #
5105 if test "$tst_compi_poll" = "yes" &&
5106 test "$tst_works_poll" != "no"; then
5107 AC_MSG_CHECKING([if poll usage allowed])
5108 if test "x$curl_disallow_poll" != "xyes"; then
5109 AC_MSG_RESULT([yes])
5110 tst_allow_poll="yes"
5111 else
5112 AC_MSG_RESULT([no])
5113 tst_allow_poll="no"
5114 fi
5115 fi
5116 #
5117 AC_MSG_CHECKING([if poll might be used])
5118 if test "$tst_links_poll" = "yes" &&
5119 test "$tst_proto_poll" = "yes" &&
5120 test "$tst_compi_poll" = "yes" &&
5121 test "$tst_allow_poll" = "yes" &&
5122 test "$tst_works_poll" != "no"; then
5123 AC_MSG_RESULT([yes])
5124 AC_DEFINE_UNQUOTED(HAVE_POLL, 1,
5125 [Define to 1 if you have a working poll function.])
5126 AC_DEFINE_UNQUOTED(HAVE_POLL_FINE, 1,
5127 [If you have a fine poll])
5128 curl_cv_func_poll="yes"
5129 else
5130 AC_MSG_RESULT([no])
5131 curl_cv_func_poll="no"
5132 fi
5133 ])
5134
5135
5136 dnl CURL_CHECK_FUNC_REMOVEXATTR
5137 dnl -------------------------------------------------
5138 dnl Verify if removexattr is available, prototyped, and
5139 dnl can be compiled. If all of these are true, and
5140 dnl usage has not been previously disallowed with
5141 dnl shell variable curl_disallow_removexattr, then
5142 dnl HAVE_REMOVEXATTR will be defined.
5143
5144 AC_DEFUN([CURL_CHECK_FUNC_REMOVEXATTR], [
5145 AC_REQUIRE([CURL_INCLUDES_SYS_XATTR])dnl
5146 #
5147 tst_links_removexattr="unknown"
5148 tst_proto_removexattr="unknown"
5149 tst_compi_removexattr="unknown"
5150 tst_allow_removexattr="unknown"
5151 tst_nargs_removexattr="unknown"
5152 #
5153 AC_MSG_CHECKING([if removexattr can be linked])
5154 AC_LINK_IFELSE([
5155 AC_LANG_FUNC_LINK_TRY([removexattr])
5156 ],[
5157 AC_MSG_RESULT([yes])
5158 tst_links_removexattr="yes"
5159 ],[
5160 AC_MSG_RESULT([no])
5161 tst_links_removexattr="no"
5162 ])
5163 #
5164 if test "$tst_links_removexattr" = "yes"; then
5165 AC_MSG_CHECKING([if removexattr is prototyped])
5166 AC_EGREP_CPP([removexattr],[
5167 $curl_includes_sys_xattr
5168 ],[
5169 AC_MSG_RESULT([yes])
5170 tst_proto_removexattr="yes"
5171 ],[
5172 AC_MSG_RESULT([no])
5173 tst_proto_removexattr="no"
5174 ])
5175 fi
5176 #
5177 if test "$tst_proto_removexattr" = "yes"; then
5178 if test "$tst_nargs_removexattr" = "unknown"; then
5179 AC_MSG_CHECKING([if removexattr takes 2 args.])
5180 AC_COMPILE_IFELSE([
5181 AC_LANG_PROGRAM([[
5182 $curl_includes_sys_xattr
5183 ]],[[
5184 if(0 != removexattr(0, 0))
5185 return 1;
5186 ]])
5187 ],[
5188 AC_MSG_RESULT([yes])
5189 tst_compi_removexattr="yes"
5190 tst_nargs_removexattr="2"
5191 ],[
5192 AC_MSG_RESULT([no])
5193 tst_compi_removexattr="no"
5194 ])
5195 fi
5196 if test "$tst_nargs_removexattr" = "unknown"; then
5197 AC_MSG_CHECKING([if removexattr takes 3 args.])
5198 AC_COMPILE_IFELSE([
5199 AC_LANG_PROGRAM([[
5200 $curl_includes_sys_xattr
5201 ]],[[
5202 if(0 != removexattr(0, 0, 0))
5203 return 1;
5204 ]])
5205 ],[
5206 AC_MSG_RESULT([yes])
5207 tst_compi_removexattr="yes"
5208 tst_nargs_removexattr="3"
5209 ],[
5210 AC_MSG_RESULT([no])
5211 tst_compi_removexattr="no"
5212 ])
5213 fi
5214 AC_MSG_CHECKING([if removexattr is compilable])
5215 if test "$tst_compi_removexattr" = "yes"; then
5216 AC_MSG_RESULT([yes])
5217 else
5218 AC_MSG_RESULT([no])
5219 fi
5220 fi
5221 #
5222 if test "$tst_compi_removexattr" = "yes"; then
5223 AC_MSG_CHECKING([if removexattr usage allowed])
5224 if test "x$curl_disallow_removexattr" != "xyes"; then
5225 AC_MSG_RESULT([yes])
5226 tst_allow_removexattr="yes"
5227 else
5228 AC_MSG_RESULT([no])
5229 tst_allow_removexattr="no"
5230 fi
5231 fi
5232 #
5233 AC_MSG_CHECKING([if removexattr might be used])
5234 if test "$tst_links_removexattr" = "yes" &&
5235 test "$tst_proto_removexattr" = "yes" &&
5236 test "$tst_compi_removexattr" = "yes" &&
5237 test "$tst_allow_removexattr" = "yes"; then
5238 AC_MSG_RESULT([yes])
5239 AC_DEFINE_UNQUOTED(HAVE_REMOVEXATTR, 1,
5240 [Define to 1 if you have the removexattr function.])
5241 dnl AC_DEFINE_UNQUOTED(REMOVEXATTR_ARGS, $tst_nargs_removexattr,
5242 dnl [Specifies the number of arguments to removexattr])
5243 #
5244 if test "$tst_nargs_removexattr" -eq "2"; then
5245 AC_DEFINE(HAVE_REMOVEXATTR_2, 1, [removexattr() takes 2 args])
5246 elif test "$tst_nargs_removexattr" -eq "3"; then
5247 AC_DEFINE(HAVE_REMOVEXATTR_3, 1, [removexattr() takes 3 args])
5248 fi
5249 #
5250 curl_cv_func_removexattr="yes"
5251 else
5252 AC_MSG_RESULT([no])
5253 curl_cv_func_removexattr="no"
5254 fi
5255 ])
5256
5257
5258 dnl CURL_CHECK_FUNC_SETSOCKOPT
5259 dnl -------------------------------------------------
5260 dnl Verify if setsockopt is available, prototyped, and
5261 dnl can be compiled. If all of these are true, and
5262 dnl usage has not been previously disallowed with
5263 dnl shell variable curl_disallow_setsockopt, then
5264 dnl HAVE_SETSOCKOPT will be defined.
5265
5266 AC_DEFUN([CURL_CHECK_FUNC_SETSOCKOPT], [
5267 AC_REQUIRE([CURL_INCLUDES_WINSOCK2])dnl
5268 AC_REQUIRE([CURL_INCLUDES_SYS_SOCKET])dnl
5269 #
5270 tst_links_setsockopt="unknown"
5271 tst_proto_setsockopt="unknown"
5272 tst_compi_setsockopt="unknown"
5273 tst_allow_setsockopt="unknown"
5274 #
5275 AC_MSG_CHECKING([if setsockopt can be linked])
5276 AC_LINK_IFELSE([
5277 AC_LANG_PROGRAM([[
5278 $curl_includes_winsock2
5279 $curl_includes_bsdsocket
5280 $curl_includes_sys_socket
5281 ]],[[
5282 if(0 != setsockopt(0, 0, 0, 0, 0))
5283 return 1;
5284 ]])
5285 ],[
5286 AC_MSG_RESULT([yes])
5287 tst_links_setsockopt="yes"
5288 ],[
5289 AC_MSG_RESULT([no])
5290 tst_links_setsockopt="no"
5291 ])
5292 #
5293 if test "$tst_links_setsockopt" = "yes"; then
5294 AC_MSG_CHECKING([if setsockopt is prototyped])
5295 AC_EGREP_CPP([setsockopt],[
5296 $curl_includes_winsock2
5297 $curl_includes_bsdsocket
5298 $curl_includes_sys_socket
5299 ],[
5300 AC_MSG_RESULT([yes])
5301 tst_proto_setsockopt="yes"
5302 ],[
5303 AC_MSG_RESULT([no])
5304 tst_proto_setsockopt="no"
5305 ])
5306 fi
5307 #
5308 if test "$tst_proto_setsockopt" = "yes"; then
5309 AC_MSG_CHECKING([if setsockopt is compilable])
5310 AC_COMPILE_IFELSE([
5311 AC_LANG_PROGRAM([[
5312 $curl_includes_winsock2
5313 $curl_includes_bsdsocket
5314 $curl_includes_sys_socket
5315 ]],[[
5316 if(0 != setsockopt(0, 0, 0, 0, 0))
5317 return 1;
5318 ]])
5319 ],[
5320 AC_MSG_RESULT([yes])
5321 tst_compi_setsockopt="yes"
5322 ],[
5323 AC_MSG_RESULT([no])
5324 tst_compi_setsockopt="no"
5325 ])
5326 fi
5327 #
5328 if test "$tst_compi_setsockopt" = "yes"; then
5329 AC_MSG_CHECKING([if setsockopt usage allowed])
5330 if test "x$curl_disallow_setsockopt" != "xyes"; then
5331 AC_MSG_RESULT([yes])
5332 tst_allow_setsockopt="yes"
5333 else
5334 AC_MSG_RESULT([no])
5335 tst_allow_setsockopt="no"
5336 fi
5337 fi
5338 #
5339 AC_MSG_CHECKING([if setsockopt might be used])
5340 if test "$tst_links_setsockopt" = "yes" &&
5341 test "$tst_proto_setsockopt" = "yes" &&
5342 test "$tst_compi_setsockopt" = "yes" &&
5343 test "$tst_allow_setsockopt" = "yes"; then
5344 AC_MSG_RESULT([yes])
5345 AC_DEFINE_UNQUOTED(HAVE_SETSOCKOPT, 1,
5346 [Define to 1 if you have the setsockopt function.])
5347 curl_cv_func_setsockopt="yes"
5348 CURL_CHECK_FUNC_SETSOCKOPT_SO_NONBLOCK
5349 else
5350 AC_MSG_RESULT([no])
5351 curl_cv_func_setsockopt="no"
5352 fi
5353 ])
5354
5355
5356 dnl CURL_CHECK_FUNC_SETSOCKOPT_SO_NONBLOCK
5357 dnl -------------------------------------------------
5358 dnl Verify if setsockopt with the SO_NONBLOCK command is
5359 dnl available, can be compiled, and seems to work. If
5360 dnl all of these are true, then HAVE_SETSOCKOPT_SO_NONBLOCK
5361 dnl will be defined.
5362
5363 AC_DEFUN([CURL_CHECK_FUNC_SETSOCKOPT_SO_NONBLOCK], [
5364 #
5365 tst_compi_setsockopt_so_nonblock="unknown"
5366 tst_allow_setsockopt_so_nonblock="unknown"
5367 #
5368 if test "$curl_cv_func_setsockopt" = "yes"; then
5369 AC_MSG_CHECKING([if setsockopt SO_NONBLOCK is compilable])
5370 AC_COMPILE_IFELSE([
5371 AC_LANG_PROGRAM([[
5372 $curl_includes_winsock2
5373 $curl_includes_bsdsocket
5374 $curl_includes_sys_socket
5375 ]],[[
5376 if(0 != setsockopt(0, SOL_SOCKET, SO_NONBLOCK, 0, 0))
5377 return 1;
5378 ]])
5379 ],[
5380 AC_MSG_RESULT([yes])
5381 tst_compi_setsockopt_so_nonblock="yes"
5382 ],[
5383 AC_MSG_RESULT([no])
5384 tst_compi_setsockopt_so_nonblock="no"
5385 ])
5386 fi
5387 #
5388 if test "$tst_compi_setsockopt_so_nonblock" = "yes"; then
5389 AC_MSG_CHECKING([if setsockopt SO_NONBLOCK usage allowed])
5390 if test "x$curl_disallow_setsockopt_so_nonblock" != "xyes"; then
5391 AC_MSG_RESULT([yes])
5392 tst_allow_setsockopt_so_nonblock="yes"
5393 else
5394 AC_MSG_RESULT([no])
5395 tst_allow_setsockopt_so_nonblock="no"
5396 fi
5397 fi
5398 #
5399 AC_MSG_CHECKING([if setsockopt SO_NONBLOCK might be used])
5400 if test "$tst_compi_setsockopt_so_nonblock" = "yes" &&
5401 test "$tst_allow_setsockopt_so_nonblock" = "yes"; then
5402 AC_MSG_RESULT([yes])
5403 AC_DEFINE_UNQUOTED(HAVE_SETSOCKOPT_SO_NONBLOCK, 1,
5404 [Define to 1 if you have a working setsockopt SO_NONBLOCK function.])
5405 curl_cv_func_setsockopt_so_nonblock="yes"
5406 else
5407 AC_MSG_RESULT([no])
5408 curl_cv_func_setsockopt_so_nonblock="no"
5409 fi
5410 ])
5411
5412
5413 dnl CURL_CHECK_FUNC_SETXATTR
5414 dnl -------------------------------------------------
5415 dnl Verify if setxattr is available, prototyped, and
5416 dnl can be compiled. If all of these are true, and
5417 dnl usage has not been previously disallowed with
5418 dnl shell variable curl_disallow_setxattr, then
5419 dnl HAVE_SETXATTR will be defined.
5420
5421 AC_DEFUN([CURL_CHECK_FUNC_SETXATTR], [
5422 AC_REQUIRE([CURL_INCLUDES_SYS_XATTR])dnl
5423 #
5424 tst_links_setxattr="unknown"
5425 tst_proto_setxattr="unknown"
5426 tst_compi_setxattr="unknown"
5427 tst_allow_setxattr="unknown"
5428 tst_nargs_setxattr="unknown"
5429 #
5430 AC_MSG_CHECKING([if setxattr can be linked])
5431 AC_LINK_IFELSE([
5432 AC_LANG_FUNC_LINK_TRY([setxattr])
5433 ],[
5434 AC_MSG_RESULT([yes])
5435 tst_links_setxattr="yes"
5436 ],[
5437 AC_MSG_RESULT([no])
5438 tst_links_setxattr="no"
5439 ])
5440 #
5441 if test "$tst_links_setxattr" = "yes"; then
5442 AC_MSG_CHECKING([if setxattr is prototyped])
5443 AC_EGREP_CPP([setxattr],[
5444 $curl_includes_sys_xattr
5445 ],[
5446 AC_MSG_RESULT([yes])
5447 tst_proto_setxattr="yes"
5448 ],[
5449 AC_MSG_RESULT([no])
5450 tst_proto_setxattr="no"
5451 ])
5452 fi
5453 #
5454 if test "$tst_proto_setxattr" = "yes"; then
5455 if test "$tst_nargs_setxattr" = "unknown"; then
5456 AC_MSG_CHECKING([if setxattr takes 5 args.])
5457 AC_COMPILE_IFELSE([
5458 AC_LANG_PROGRAM([[
5459 $curl_includes_sys_xattr
5460 ]],[[
5461 if(0 != setxattr(0, 0, 0, 0, 0))
5462 return 1;
5463 ]])
5464 ],[
5465 AC_MSG_RESULT([yes])
5466 tst_compi_setxattr="yes"
5467 tst_nargs_setxattr="5"
5468 ],[
5469 AC_MSG_RESULT([no])
5470 tst_compi_setxattr="no"
5471 ])
5472 fi
5473 if test "$tst_nargs_setxattr" = "unknown"; then
5474 AC_MSG_CHECKING([if setxattr takes 6 args.])
5475 AC_COMPILE_IFELSE([
5476 AC_LANG_PROGRAM([[
5477 $curl_includes_sys_xattr
5478 ]],[[
5479 if(0 != setxattr(0, 0, 0, 0, 0, 0))
5480 return 1;
5481 ]])
5482 ],[
5483 AC_MSG_RESULT([yes])
5484 tst_compi_setxattr="yes"
5485 tst_nargs_setxattr="6"
5486 ],[
5487 AC_MSG_RESULT([no])
5488 tst_compi_setxattr="no"
5489 ])
5490 fi
5491 AC_MSG_CHECKING([if setxattr is compilable])
5492 if test "$tst_compi_setxattr" = "yes"; then
5493 AC_MSG_RESULT([yes])
5494 else
5495 AC_MSG_RESULT([no])
5496 fi
5497 fi
5498 #
5499 if test "$tst_compi_setxattr" = "yes"; then
5500 AC_MSG_CHECKING([if setxattr usage allowed])
5501 if test "x$curl_disallow_setxattr" != "xyes"; then
5502 AC_MSG_RESULT([yes])
5503 tst_allow_setxattr="yes"
5504 else
5505 AC_MSG_RESULT([no])
5506 tst_allow_setxattr="no"
5507 fi
5508 fi
5509 #
5510 AC_MSG_CHECKING([if setxattr might be used])
5511 if test "$tst_links_setxattr" = "yes" &&
5512 test "$tst_proto_setxattr" = "yes" &&
5513 test "$tst_compi_setxattr" = "yes" &&
5514 test "$tst_allow_setxattr" = "yes"; then
5515 AC_MSG_RESULT([yes])
5516 AC_DEFINE_UNQUOTED(HAVE_SETXATTR, 1,
5517 [Define to 1 if you have the setxattr function.])
5518 dnl AC_DEFINE_UNQUOTED(SETXATTR_ARGS, $tst_nargs_setxattr,
5519 dnl [Specifies the number of arguments to setxattr])
5520 #
5521 if test "$tst_nargs_setxattr" -eq "5"; then
5522 AC_DEFINE(HAVE_SETXATTR_5, 1, [setxattr() takes 5 args])
5523 elif test "$tst_nargs_setxattr" -eq "6"; then
5524 AC_DEFINE(HAVE_SETXATTR_6, 1, [setxattr() takes 6 args])
5525 fi
5526 #
5527 curl_cv_func_setxattr="yes"
5528 else
5529 AC_MSG_RESULT([no])
5530 curl_cv_func_setxattr="no"
5531 fi
5532 ])
5533
5534
5535 dnl CURL_CHECK_FUNC_SIGACTION
5536 dnl -------------------------------------------------
5537 dnl Verify if sigaction is available, prototyped, and
5538 dnl can be compiled. If all of these are true, and
5539 dnl usage has not been previously disallowed with
5540 dnl shell variable curl_disallow_sigaction, then
5541 dnl HAVE_SIGACTION will be defined.
5542
5543 AC_DEFUN([CURL_CHECK_FUNC_SIGACTION], [
5544 AC_REQUIRE([CURL_INCLUDES_SIGNAL])dnl
5545 #
5546 tst_links_sigaction="unknown"
5547 tst_proto_sigaction="unknown"
5548 tst_compi_sigaction="unknown"
5549 tst_allow_sigaction="unknown"
5550 #
5551 AC_MSG_CHECKING([if sigaction can be linked])
5552 AC_LINK_IFELSE([
5553 AC_LANG_FUNC_LINK_TRY([sigaction])
5554 ],[
5555 AC_MSG_RESULT([yes])
5556 tst_links_sigaction="yes"
5557 ],[
5558 AC_MSG_RESULT([no])
5559 tst_links_sigaction="no"
5560 ])
5561 #
5562 if test "$tst_links_sigaction" = "yes"; then
5563 AC_MSG_CHECKING([if sigaction is prototyped])
5564 AC_EGREP_CPP([sigaction],[
5565 $curl_includes_signal
5566 ],[
5567 AC_MSG_RESULT([yes])
5568 tst_proto_sigaction="yes"
5569 ],[
5570 AC_MSG_RESULT([no])
5571 tst_proto_sigaction="no"
5572 ])
5573 fi
5574 #
5575 if test "$tst_proto_sigaction" = "yes"; then
5576 AC_MSG_CHECKING([if sigaction is compilable])
5577 AC_COMPILE_IFELSE([
5578 AC_LANG_PROGRAM([[
5579 $curl_includes_signal
5580 ]],[[
5581 if(0 != sigaction(0, 0, 0))
5582 return 1;
5583 ]])
5584 ],[
5585 AC_MSG_RESULT([yes])
5586 tst_compi_sigaction="yes"
5587 ],[
5588 AC_MSG_RESULT([no])
5589 tst_compi_sigaction="no"
5590 ])
5591 fi
5592 #
5593 if test "$tst_compi_sigaction" = "yes"; then
5594 AC_MSG_CHECKING([if sigaction usage allowed])
5595 if test "x$curl_disallow_sigaction" != "xyes"; then
5596 AC_MSG_RESULT([yes])
5597 tst_allow_sigaction="yes"
5598 else
5599 AC_MSG_RESULT([no])
5600 tst_allow_sigaction="no"
5601 fi
5602 fi
5603 #
5604 AC_MSG_CHECKING([if sigaction might be used])
5605 if test "$tst_links_sigaction" = "yes" &&
5606 test "$tst_proto_sigaction" = "yes" &&
5607 test "$tst_compi_sigaction" = "yes" &&
5608 test "$tst_allow_sigaction" = "yes"; then
5609 AC_MSG_RESULT([yes])
5610 AC_DEFINE_UNQUOTED(HAVE_SIGACTION, 1,
5611 [Define to 1 if you have the sigaction function.])
5612 curl_cv_func_sigaction="yes"
5613 else
5614 AC_MSG_RESULT([no])
5615 curl_cv_func_sigaction="no"
5616 fi
5617 ])
5618
5619
5620 dnl CURL_CHECK_FUNC_SIGINTERRUPT
5621 dnl -------------------------------------------------
5622 dnl Verify if siginterrupt is available, prototyped, and
5623 dnl can be compiled. If all of these are true, and
5624 dnl usage has not been previously disallowed with
5625 dnl shell variable curl_disallow_siginterrupt, then
5626 dnl HAVE_SIGINTERRUPT will be defined.
5627
5628 AC_DEFUN([CURL_CHECK_FUNC_SIGINTERRUPT], [
5629 AC_REQUIRE([CURL_INCLUDES_SIGNAL])dnl
5630 #
5631 tst_links_siginterrupt="unknown"
5632 tst_proto_siginterrupt="unknown"
5633 tst_compi_siginterrupt="unknown"
5634 tst_allow_siginterrupt="unknown"
5635 #
5636 AC_MSG_CHECKING([if siginterrupt can be linked])
5637 AC_LINK_IFELSE([
5638 AC_LANG_FUNC_LINK_TRY([siginterrupt])
5639 ],[
5640 AC_MSG_RESULT([yes])
5641 tst_links_siginterrupt="yes"
5642 ],[
5643 AC_MSG_RESULT([no])
5644 tst_links_siginterrupt="no"
5645 ])
5646 #
5647 if test "$tst_links_siginterrupt" = "yes"; then
5648 AC_MSG_CHECKING([if siginterrupt is prototyped])
5649 AC_EGREP_CPP([siginterrupt],[
5650 $curl_includes_signal
5651 ],[
5652 AC_MSG_RESULT([yes])
5653 tst_proto_siginterrupt="yes"
5654 ],[
5655 AC_MSG_RESULT([no])
5656 tst_proto_siginterrupt="no"
5657 ])
5658 fi
5659 #
5660 if test "$tst_proto_siginterrupt" = "yes"; then
5661 AC_MSG_CHECKING([if siginterrupt is compilable])
5662 AC_COMPILE_IFELSE([
5663 AC_LANG_PROGRAM([[
5664 $curl_includes_signal
5665 ]],[[
5666 if(0 != siginterrupt(0, 0))
5667 return 1;
5668 ]])
5669 ],[
5670 AC_MSG_RESULT([yes])
5671 tst_compi_siginterrupt="yes"
5672 ],[
5673 AC_MSG_RESULT([no])
5674 tst_compi_siginterrupt="no"
5675 ])
5676 fi
5677 #
5678 if test "$tst_compi_siginterrupt" = "yes"; then
5679 AC_MSG_CHECKING([if siginterrupt usage allowed])
5680 if test "x$curl_disallow_siginterrupt" != "xyes"; then
5681 AC_MSG_RESULT([yes])
5682 tst_allow_siginterrupt="yes"
5683 else
5684 AC_MSG_RESULT([no])
5685 tst_allow_siginterrupt="no"
5686 fi
5687 fi
5688 #
5689 AC_MSG_CHECKING([if siginterrupt might be used])
5690 if test "$tst_links_siginterrupt" = "yes" &&
5691 test "$tst_proto_siginterrupt" = "yes" &&
5692 test "$tst_compi_siginterrupt" = "yes" &&
5693 test "$tst_allow_siginterrupt" = "yes"; then
5694 AC_MSG_RESULT([yes])
5695 AC_DEFINE_UNQUOTED(HAVE_SIGINTERRUPT, 1,
5696 [Define to 1 if you have the siginterrupt function.])
5697 curl_cv_func_siginterrupt="yes"
5698 else
5699 AC_MSG_RESULT([no])
5700 curl_cv_func_siginterrupt="no"
5701 fi
5702 ])
5703
5704
5705 dnl CURL_CHECK_FUNC_SIGNAL
5706 dnl -------------------------------------------------
5707 dnl Verify if signal is available, prototyped, and
5708 dnl can be compiled. If all of these are true, and
5709 dnl usage has not been previously disallowed with
5710 dnl shell variable curl_disallow_signal, then
5711 dnl HAVE_SIGNAL will be defined.
5712
5713 AC_DEFUN([CURL_CHECK_FUNC_SIGNAL], [
5714 AC_REQUIRE([CURL_INCLUDES_SIGNAL])dnl
5715 #
5716 tst_links_signal="unknown"
5717 tst_proto_signal="unknown"
5718 tst_compi_signal="unknown"
5719 tst_allow_signal="unknown"
5720 #
5721 AC_MSG_CHECKING([if signal can be linked])
5722 AC_LINK_IFELSE([
5723 AC_LANG_FUNC_LINK_TRY([signal])
5724 ],[
5725 AC_MSG_RESULT([yes])
5726 tst_links_signal="yes"
5727 ],[
5728 AC_MSG_RESULT([no])
5729 tst_links_signal="no"
5730 ])
5731 #
5732 if test "$tst_links_signal" = "yes"; then
5733 AC_MSG_CHECKING([if signal is prototyped])
5734 AC_EGREP_CPP([signal],[
5735 $curl_includes_signal
5736 ],[
5737 AC_MSG_RESULT([yes])
5738 tst_proto_signal="yes"
5739 ],[
5740 AC_MSG_RESULT([no])
5741 tst_proto_signal="no"
5742 ])
5743 fi
5744 #
5745 if test "$tst_proto_signal" = "yes"; then
5746 AC_MSG_CHECKING([if signal is compilable])
5747 AC_COMPILE_IFELSE([
5748 AC_LANG_PROGRAM([[
5749 $curl_includes_signal
5750 ]],[[
5751 if(0 != signal(0, 0))
5752 return 1;
5753 ]])
5754 ],[
5755 AC_MSG_RESULT([yes])
5756 tst_compi_signal="yes"
5757 ],[
5758 AC_MSG_RESULT([no])
5759 tst_compi_signal="no"
5760 ])
5761 fi
5762 #
5763 if test "$tst_compi_signal" = "yes"; then
5764 AC_MSG_CHECKING([if signal usage allowed])
5765 if test "x$curl_disallow_signal" != "xyes"; then
5766 AC_MSG_RESULT([yes])
5767 tst_allow_signal="yes"
5768 else
5769 AC_MSG_RESULT([no])
5770 tst_allow_signal="no"
5771 fi
5772 fi
5773 #
5774 AC_MSG_CHECKING([if signal might be used])
5775 if test "$tst_links_signal" = "yes" &&
5776 test "$tst_proto_signal" = "yes" &&
5777 test "$tst_compi_signal" = "yes" &&
5778 test "$tst_allow_signal" = "yes"; then
5779 AC_MSG_RESULT([yes])
5780 AC_DEFINE_UNQUOTED(HAVE_SIGNAL, 1,
5781 [Define to 1 if you have the signal function.])
5782 curl_cv_func_signal="yes"
5783 else
5784 AC_MSG_RESULT([no])
5785 curl_cv_func_signal="no"
5786 fi
5787 ])
5788
5789
5790 dnl CURL_CHECK_FUNC_SIGSETJMP
5791 dnl -------------------------------------------------
5792 dnl Verify if sigsetjmp is available, prototyped, and
5793 dnl can be compiled. If all of these are true, and
5794 dnl usage has not been previously disallowed with
5795 dnl shell variable curl_disallow_sigsetjmp, then
5796 dnl HAVE_SIGSETJMP will be defined.
5797
5798 AC_DEFUN([CURL_CHECK_FUNC_SIGSETJMP], [
5799 AC_REQUIRE([CURL_INCLUDES_SETJMP])dnl
5800 #
5801 tst_links_sigsetjmp="unknown"
5802 tst_macro_sigsetjmp="unknown"
5803 tst_proto_sigsetjmp="unknown"
5804 tst_compi_sigsetjmp="unknown"
5805 tst_allow_sigsetjmp="unknown"
5806 #
5807 AC_MSG_CHECKING([if sigsetjmp can be linked])
5808 AC_LINK_IFELSE([
5809 AC_LANG_FUNC_LINK_TRY([sigsetjmp])
5810 ],[
5811 AC_MSG_RESULT([yes])
5812 tst_links_sigsetjmp="yes"
5813 ],[
5814 AC_MSG_RESULT([no])
5815 tst_links_sigsetjmp="no"
5816 ])
5817 #
5818 if test "$tst_links_sigsetjmp" = "no"; then
5819 AC_MSG_CHECKING([if sigsetjmp seems a macro])
5820 AC_LINK_IFELSE([
5821 AC_LANG_PROGRAM([[
5822 $curl_includes_setjmp
5823 ]],[[
5824 sigjmp_buf env;
5825 if(0 != sigsetjmp(env, 0))
5826 return 1;
5827 ]])
5828 ],[
5829 AC_MSG_RESULT([yes])
5830 tst_macro_sigsetjmp="yes"
5831 ],[
5832 AC_MSG_RESULT([no])
5833 tst_macro_sigsetjmp="no"
5834 ])
5835 fi
5836 #
5837 if test "$tst_links_sigsetjmp" = "yes"; then
5838 AC_MSG_CHECKING([if sigsetjmp is prototyped])
5839 AC_EGREP_CPP([sigsetjmp],[
5840 $curl_includes_setjmp
5841 ],[
5842 AC_MSG_RESULT([yes])
5843 tst_proto_sigsetjmp="yes"
5844 ],[
5845 AC_MSG_RESULT([no])
5846 tst_proto_sigsetjmp="no"
5847 ])
5848 fi
5849 #
5850 if test "$tst_proto_sigsetjmp" = "yes" ||
5851 test "$tst_macro_sigsetjmp" = "yes"; then
5852 AC_MSG_CHECKING([if sigsetjmp is compilable])
5853 AC_COMPILE_IFELSE([
5854 AC_LANG_PROGRAM([[
5855 $curl_includes_setjmp
5856 ]],[[
5857 sigjmp_buf env;
5858 if(0 != sigsetjmp(env, 0))
5859 return 1;
5860 ]])
5861 ],[
5862 AC_MSG_RESULT([yes])
5863 tst_compi_sigsetjmp="yes"
5864 ],[
5865 AC_MSG_RESULT([no])
5866 tst_compi_sigsetjmp="no"
5867 ])
5868 fi
5869 #
5870 if test "$tst_compi_sigsetjmp" = "yes"; then
5871 AC_MSG_CHECKING([if sigsetjmp usage allowed])
5872 if test "x$curl_disallow_sigsetjmp" != "xyes"; then
5873 AC_MSG_RESULT([yes])
5874 tst_allow_sigsetjmp="yes"
5875 else
5876 AC_MSG_RESULT([no])
5877 tst_allow_sigsetjmp="no"
5878 fi
5879 fi
5880 #
5881 AC_MSG_CHECKING([if sigsetjmp might be used])
5882 if (test "$tst_proto_sigsetjmp" = "yes" ||
5883 test "$tst_macro_sigsetjmp" = "yes") &&
5884 test "$tst_compi_sigsetjmp" = "yes" &&
5885 test "$tst_allow_sigsetjmp" = "yes"; then
5886 AC_MSG_RESULT([yes])
5887 AC_DEFINE_UNQUOTED(HAVE_SIGSETJMP, 1,
5888 [Define to 1 if you have the sigsetjmp function or macro.])
5889 curl_cv_func_sigsetjmp="yes"
5890 else
5891 AC_MSG_RESULT([no])
5892 curl_cv_func_sigsetjmp="no"
5893 fi
5894 ])
5895
5896
5897 dnl CURL_CHECK_FUNC_SOCKET
5898 dnl -------------------------------------------------
5899 dnl Verify if socket is available, prototyped, and
5900 dnl can be compiled. If all of these are true, and
5901 dnl usage has not been previously disallowed with
5902 dnl shell variable curl_disallow_socket, then
5903 dnl HAVE_SOCKET will be defined.
5904
5905 AC_DEFUN([CURL_CHECK_FUNC_SOCKET], [
5906 AC_REQUIRE([CURL_INCLUDES_WINSOCK2])dnl
5907 AC_REQUIRE([CURL_INCLUDES_SYS_SOCKET])dnl
5908 AC_REQUIRE([CURL_INCLUDES_SOCKET])dnl
5909 #
5910 tst_links_socket="unknown"
5911 tst_proto_socket="unknown"
5912 tst_compi_socket="unknown"
5913 tst_allow_socket="unknown"
5914 #
5915 AC_MSG_CHECKING([if socket can be linked])
5916 AC_LINK_IFELSE([
5917 AC_LANG_PROGRAM([[
5918 $curl_includes_winsock2
5919 $curl_includes_bsdsocket
5920 $curl_includes_sys_socket
5921 $curl_includes_socket
5922 ]],[[
5923 if(0 != socket(0, 0, 0))
5924 return 1;
5925 ]])
5926 ],[
5927 AC_MSG_RESULT([yes])
5928 tst_links_socket="yes"
5929 ],[
5930 AC_MSG_RESULT([no])
5931 tst_links_socket="no"
5932 ])
5933 #
5934 if test "$tst_links_socket" = "yes"; then
5935 AC_MSG_CHECKING([if socket is prototyped])
5936 AC_EGREP_CPP([socket],[
5937 $curl_includes_winsock2
5938 $curl_includes_bsdsocket
5939 $curl_includes_sys_socket
5940 $curl_includes_socket
5941 ],[
5942 AC_MSG_RESULT([yes])
5943 tst_proto_socket="yes"
5944 ],[
5945 AC_MSG_RESULT([no])
5946 tst_proto_socket="no"
5947 ])
5948 fi
5949 #
5950 if test "$tst_proto_socket" = "yes"; then
5951 AC_MSG_CHECKING([if socket is compilable])
5952 AC_COMPILE_IFELSE([
5953 AC_LANG_PROGRAM([[
5954 $curl_includes_winsock2
5955 $curl_includes_bsdsocket
5956 $curl_includes_sys_socket
5957 $curl_includes_socket
5958 ]],[[
5959 if(0 != socket(0, 0, 0))
5960 return 1;
5961 ]])
5962 ],[
5963 AC_MSG_RESULT([yes])
5964 tst_compi_socket="yes"
5965 ],[
5966 AC_MSG_RESULT([no])
5967 tst_compi_socket="no"
5968 ])
5969 fi
5970 #
5971 if test "$tst_compi_socket" = "yes"; then
5972 AC_MSG_CHECKING([if socket usage allowed])
5973 if test "x$curl_disallow_socket" != "xyes"; then
5974 AC_MSG_RESULT([yes])
5975 tst_allow_socket="yes"
5976 else
5977 AC_MSG_RESULT([no])
5978 tst_allow_socket="no"
5979 fi
5980 fi
5981 #
5982 AC_MSG_CHECKING([if socket might be used])
5983 if test "$tst_links_socket" = "yes" &&
5984 test "$tst_proto_socket" = "yes" &&
5985 test "$tst_compi_socket" = "yes" &&
5986 test "$tst_allow_socket" = "yes"; then
5987 AC_MSG_RESULT([yes])
5988 AC_DEFINE_UNQUOTED(HAVE_SOCKET, 1,
5989 [Define to 1 if you have the socket function.])
5990 curl_cv_func_socket="yes"
5991 else
5992 AC_MSG_RESULT([no])
5993 curl_cv_func_socket="no"
5994 fi
5995 ])
5996
5997
5998 dnl CURL_CHECK_FUNC_SOCKETPAIR
5999 dnl -------------------------------------------------
6000 dnl Verify if socketpair is available, prototyped, and
6001 dnl can be compiled. If all of these are true, and
6002 dnl usage has not been previously disallowed with
6003 dnl shell variable curl_disallow_socketpair, then
6004 dnl HAVE_SOCKETPAIR will be defined.
6005
6006 AC_DEFUN([CURL_CHECK_FUNC_SOCKETPAIR], [
6007 AC_REQUIRE([CURL_INCLUDES_SYS_SOCKET])dnl
6008 AC_REQUIRE([CURL_INCLUDES_SOCKET])dnl
6009 #
6010 tst_links_socketpair="unknown"
6011 tst_proto_socketpair="unknown"
6012 tst_compi_socketpair="unknown"
6013 tst_allow_socketpair="unknown"
6014 #
6015 AC_MSG_CHECKING([if socketpair can be linked])
6016 AC_LINK_IFELSE([
6017 AC_LANG_FUNC_LINK_TRY([socketpair])
6018 ],[
6019 AC_MSG_RESULT([yes])
6020 tst_links_socketpair="yes"
6021 ],[
6022 AC_MSG_RESULT([no])
6023 tst_links_socketpair="no"
6024 ])
6025 #
6026 if test "$tst_links_socketpair" = "yes"; then
6027 AC_MSG_CHECKING([if socketpair is prototyped])
6028 AC_EGREP_CPP([socketpair],[
6029 $curl_includes_sys_socket
6030 $curl_includes_socket
6031 ],[
6032 AC_MSG_RESULT([yes])
6033 tst_proto_socketpair="yes"
6034 ],[
6035 AC_MSG_RESULT([no])
6036 tst_proto_socketpair="no"
6037 ])
6038 fi
6039 #
6040 if test "$tst_proto_socketpair" = "yes"; then
6041 AC_MSG_CHECKING([if socketpair is compilable])
6042 AC_COMPILE_IFELSE([
6043 AC_LANG_PROGRAM([[
6044 $curl_includes_sys_socket
6045 $curl_includes_socket
6046 ]],[[
6047 int sv[2];
6048 if(0 != socketpair(0, 0, 0, sv))
6049 return 1;
6050 ]])
6051 ],[
6052 AC_MSG_RESULT([yes])
6053 tst_compi_socketpair="yes"
6054 ],[
6055 AC_MSG_RESULT([no])
6056 tst_compi_socketpair="no"
6057 ])
6058 fi
6059 #
6060 if test "$tst_compi_socketpair" = "yes"; then
6061 AC_MSG_CHECKING([if socketpair usage allowed])
6062 if test "x$curl_disallow_socketpair" != "xyes"; then
6063 AC_MSG_RESULT([yes])
6064 tst_allow_socketpair="yes"
6065 else
6066 AC_MSG_RESULT([no])
6067 tst_allow_socketpair="no"
6068 fi
6069 fi
6070 #
6071 AC_MSG_CHECKING([if socketpair might be used])
6072 if test "$tst_links_socketpair" = "yes" &&
6073 test "$tst_proto_socketpair" = "yes" &&
6074 test "$tst_compi_socketpair" = "yes" &&
6075 test "$tst_allow_socketpair" = "yes"; then
6076 AC_MSG_RESULT([yes])
6077 AC_DEFINE_UNQUOTED(HAVE_SOCKETPAIR, 1,
6078 [Define to 1 if you have the socketpair function.])
6079 curl_cv_func_socketpair="yes"
6080 else
6081 AC_MSG_RESULT([no])
6082 curl_cv_func_socketpair="no"
6083 fi
6084 ])
6085
6086
6087 dnl CURL_CHECK_FUNC_STRCASECMP
6088 dnl -------------------------------------------------
6089 dnl Verify if strcasecmp is available, prototyped, and
6090 dnl can be compiled. If all of these are true, and
6091 dnl usage has not been previously disallowed with
6092 dnl shell variable curl_disallow_strcasecmp, then
6093 dnl HAVE_STRCASECMP will be defined.
6094
6095 AC_DEFUN([CURL_CHECK_FUNC_STRCASECMP], [
6096 AC_REQUIRE([CURL_INCLUDES_STRING])dnl
6097 #
6098 tst_links_strcasecmp="unknown"
6099 tst_proto_strcasecmp="unknown"
6100 tst_compi_strcasecmp="unknown"
6101 tst_allow_strcasecmp="unknown"
6102 #
6103 AC_MSG_CHECKING([if strcasecmp can be linked])
6104 AC_LINK_IFELSE([
6105 AC_LANG_FUNC_LINK_TRY([strcasecmp])
6106 ],[
6107 AC_MSG_RESULT([yes])
6108 tst_links_strcasecmp="yes"
6109 ],[
6110 AC_MSG_RESULT([no])
6111 tst_links_strcasecmp="no"
6112 ])
6113 #
6114 if test "$tst_links_strcasecmp" = "yes"; then
6115 AC_MSG_CHECKING([if strcasecmp is prototyped])
6116 AC_EGREP_CPP([strcasecmp],[
6117 $curl_includes_string
6118 ],[
6119 AC_MSG_RESULT([yes])
6120 tst_proto_strcasecmp="yes"
6121 ],[
6122 AC_MSG_RESULT([no])
6123 tst_proto_strcasecmp="no"
6124 ])
6125 fi
6126 #
6127 if test "$tst_proto_strcasecmp" = "yes"; then
6128 AC_MSG_CHECKING([if strcasecmp is compilable])
6129 AC_COMPILE_IFELSE([
6130 AC_LANG_PROGRAM([[
6131 $curl_includes_string
6132 ]],[[
6133 if(0 != strcasecmp(0, 0))
6134 return 1;
6135 ]])
6136 ],[
6137 AC_MSG_RESULT([yes])
6138 tst_compi_strcasecmp="yes"
6139 ],[
6140 AC_MSG_RESULT([no])
6141 tst_compi_strcasecmp="no"
6142 ])
6143 fi
6144 #
6145 if test "$tst_compi_strcasecmp" = "yes"; then
6146 AC_MSG_CHECKING([if strcasecmp usage allowed])
6147 if test "x$curl_disallow_strcasecmp" != "xyes"; then
6148 AC_MSG_RESULT([yes])
6149 tst_allow_strcasecmp="yes"
6150 else
6151 AC_MSG_RESULT([no])
6152 tst_allow_strcasecmp="no"
6153 fi
6154 fi
6155 #
6156 AC_MSG_CHECKING([if strcasecmp might be used])
6157 if test "$tst_links_strcasecmp" = "yes" &&
6158 test "$tst_proto_strcasecmp" = "yes" &&
6159 test "$tst_compi_strcasecmp" = "yes" &&
6160 test "$tst_allow_strcasecmp" = "yes"; then
6161 AC_MSG_RESULT([yes])
6162 AC_DEFINE_UNQUOTED(HAVE_STRCASECMP, 1,
6163 [Define to 1 if you have the strcasecmp function.])
6164 curl_cv_func_strcasecmp="yes"
6165 else
6166 AC_MSG_RESULT([no])
6167 curl_cv_func_strcasecmp="no"
6168 fi
6169 ])
6170
6171 dnl CURL_CHECK_FUNC_STRCMPI
6172 dnl -------------------------------------------------
6173 dnl Verify if strcmpi is available, prototyped, and
6174 dnl can be compiled. If all of these are true, and
6175 dnl usage has not been previously disallowed with
6176 dnl shell variable curl_disallow_strcmpi, then
6177 dnl HAVE_STRCMPI will be defined.
6178
6179 AC_DEFUN([CURL_CHECK_FUNC_STRCMPI], [
6180 AC_REQUIRE([CURL_INCLUDES_STRING])dnl
6181 #
6182 tst_links_strcmpi="unknown"
6183 tst_proto_strcmpi="unknown"
6184 tst_compi_strcmpi="unknown"
6185 tst_allow_strcmpi="unknown"
6186 #
6187 AC_MSG_CHECKING([if strcmpi can be linked])
6188 AC_LINK_IFELSE([
6189 AC_LANG_FUNC_LINK_TRY([strcmpi])
6190 ],[
6191 AC_MSG_RESULT([yes])
6192 tst_links_strcmpi="yes"
6193 ],[
6194 AC_MSG_RESULT([no])
6195 tst_links_strcmpi="no"
6196 ])
6197 #
6198 if test "$tst_links_strcmpi" = "yes"; then
6199 AC_MSG_CHECKING([if strcmpi is prototyped])
6200 AC_EGREP_CPP([strcmpi],[
6201 $curl_includes_string
6202 ],[
6203 AC_MSG_RESULT([yes])
6204 tst_proto_strcmpi="yes"
6205 ],[
6206 AC_MSG_RESULT([no])
6207 tst_proto_strcmpi="no"
6208 ])
6209 fi
6210 #
6211 if test "$tst_proto_strcmpi" = "yes"; then
6212 AC_MSG_CHECKING([if strcmpi is compilable])
6213 AC_COMPILE_IFELSE([
6214 AC_LANG_PROGRAM([[
6215 $curl_includes_string
6216 ]],[[
6217 if(0 != strcmpi(0, 0))
6218 return 1;
6219 ]])
6220 ],[
6221 AC_MSG_RESULT([yes])
6222 tst_compi_strcmpi="yes"
6223 ],[
6224 AC_MSG_RESULT([no])
6225 tst_compi_strcmpi="no"
6226 ])
6227 fi
6228 #
6229 if test "$tst_compi_strcmpi" = "yes"; then
6230 AC_MSG_CHECKING([if strcmpi usage allowed])
6231 if test "x$curl_disallow_strcmpi" != "xyes"; then
6232 AC_MSG_RESULT([yes])
6233 tst_allow_strcmpi="yes"
6234 else
6235 AC_MSG_RESULT([no])
6236 tst_allow_strcmpi="no"
6237 fi
6238 fi
6239 #
6240 AC_MSG_CHECKING([if strcmpi might be used])
6241 if test "$tst_links_strcmpi" = "yes" &&
6242 test "$tst_proto_strcmpi" = "yes" &&
6243 test "$tst_compi_strcmpi" = "yes" &&
6244 test "$tst_allow_strcmpi" = "yes"; then
6245 AC_MSG_RESULT([yes])
6246 AC_DEFINE_UNQUOTED(HAVE_STRCMPI, 1,
6247 [Define to 1 if you have the strcmpi function.])
6248 curl_cv_func_strcmpi="yes"
6249 else
6250 AC_MSG_RESULT([no])
6251 curl_cv_func_strcmpi="no"
6252 fi
6253 ])
6254
6255
6256 dnl CURL_CHECK_FUNC_STRDUP
6257 dnl -------------------------------------------------
6258 dnl Verify if strdup is available, prototyped, and
6259 dnl can be compiled. If all of these are true, and
6260 dnl usage has not been previously disallowed with
6261 dnl shell variable curl_disallow_strdup, then
6262 dnl HAVE_STRDUP will be defined.
6263
6264 AC_DEFUN([CURL_CHECK_FUNC_STRDUP], [
6265 AC_REQUIRE([CURL_INCLUDES_STRING])dnl
6266 #
6267 tst_links_strdup="unknown"
6268 tst_proto_strdup="unknown"
6269 tst_compi_strdup="unknown"
6270 tst_allow_strdup="unknown"
6271 #
6272 AC_MSG_CHECKING([if strdup can be linked])
6273 AC_LINK_IFELSE([
6274 AC_LANG_FUNC_LINK_TRY([strdup])
6275 ],[
6276 AC_MSG_RESULT([yes])
6277 tst_links_strdup="yes"
6278 ],[
6279 AC_MSG_RESULT([no])
6280 tst_links_strdup="no"
6281 ])
6282 #
6283 if test "$tst_links_strdup" = "yes"; then
6284 AC_MSG_CHECKING([if strdup is prototyped])
6285 AC_EGREP_CPP([strdup],[
6286 $curl_includes_string
6287 ],[
6288 AC_MSG_RESULT([yes])
6289 tst_proto_strdup="yes"
6290 ],[
6291 AC_MSG_RESULT([no])
6292 tst_proto_strdup="no"
6293 ])
6294 fi
6295 #
6296 if test "$tst_proto_strdup" = "yes"; then
6297 AC_MSG_CHECKING([if strdup is compilable])
6298 AC_COMPILE_IFELSE([
6299 AC_LANG_PROGRAM([[
6300 $curl_includes_string
6301 ]],[[
6302 if(0 != strdup(0))
6303 return 1;
6304 ]])
6305 ],[
6306 AC_MSG_RESULT([yes])
6307 tst_compi_strdup="yes"
6308 ],[
6309 AC_MSG_RESULT([no])
6310 tst_compi_strdup="no"
6311 ])
6312 fi
6313 #
6314 if test "$tst_compi_strdup" = "yes"; then
6315 AC_MSG_CHECKING([if strdup usage allowed])
6316 if test "x$curl_disallow_strdup" != "xyes"; then
6317 AC_MSG_RESULT([yes])
6318 tst_allow_strdup="yes"
6319 else
6320 AC_MSG_RESULT([no])
6321 tst_allow_strdup="no"
6322 fi
6323 fi
6324 #
6325 AC_MSG_CHECKING([if strdup might be used])
6326 if test "$tst_links_strdup" = "yes" &&
6327 test "$tst_proto_strdup" = "yes" &&
6328 test "$tst_compi_strdup" = "yes" &&
6329 test "$tst_allow_strdup" = "yes"; then
6330 AC_MSG_RESULT([yes])
6331 AC_DEFINE_UNQUOTED(HAVE_STRDUP, 1,
6332 [Define to 1 if you have the strdup function.])
6333 curl_cv_func_strdup="yes"
6334 else
6335 AC_MSG_RESULT([no])
6336 curl_cv_func_strdup="no"
6337 fi
6338 ])
6339
6340
6341 dnl CURL_CHECK_FUNC_STRERROR_R
6342 dnl -------------------------------------------------
6343 dnl Verify if strerror_r is available, prototyped, can be compiled and
6344 dnl seems to work. If all of these are true, and usage has not been
6345 dnl previously disallowed with shell variable curl_disallow_strerror_r,
6346 dnl then HAVE_STRERROR_R and STRERROR_R_TYPE_ARG3 will be defined, as
6347 dnl well as one of HAVE_GLIBC_STRERROR_R or HAVE_POSIX_STRERROR_R.
6348 dnl
6349 dnl glibc-style strerror_r:
6350 dnl
6351 dnl char *strerror_r(int errnum, char *workbuf, size_t bufsize);
6352 dnl
6353 dnl glibc-style strerror_r returns a pointer to the the error string,
6354 dnl and might use the provided workbuf as a scratch area if needed. A
6355 dnl quick test on a few systems shows that it's usually not used at all.
6356 dnl
6357 dnl POSIX-style strerror_r:
6358 dnl
6359 dnl int strerror_r(int errnum, char *resultbuf, size_t bufsize);
6360 dnl
6361 dnl POSIX-style strerror_r returns 0 upon successful completion and the
6362 dnl error string in the provided resultbuf.
6363 dnl
6364
6365 AC_DEFUN([CURL_CHECK_FUNC_STRERROR_R], [
6366 AC_REQUIRE([CURL_INCLUDES_STDLIB])dnl
6367 AC_REQUIRE([CURL_INCLUDES_STRING])dnl
6368 #
6369 tst_links_strerror_r="unknown"
6370 tst_proto_strerror_r="unknown"
6371 tst_compi_strerror_r="unknown"
6372 tst_glibc_strerror_r="unknown"
6373 tst_posix_strerror_r="unknown"
6374 tst_allow_strerror_r="unknown"
6375 tst_works_glibc_strerror_r="unknown"
6376 tst_works_posix_strerror_r="unknown"
6377 tst_glibc_strerror_r_type_arg3="unknown"
6378 tst_posix_strerror_r_type_arg3="unknown"
6379 #
6380 AC_MSG_CHECKING([if strerror_r can be linked])
6381 AC_LINK_IFELSE([
6382 AC_LANG_FUNC_LINK_TRY([strerror_r])
6383 ],[
6384 AC_MSG_RESULT([yes])
6385 tst_links_strerror_r="yes"
6386 ],[
6387 AC_MSG_RESULT([no])
6388 tst_links_strerror_r="no"
6389 ])
6390 #
6391 if test "$tst_links_strerror_r" = "yes"; then
6392 AC_MSG_CHECKING([if strerror_r is prototyped])
6393 AC_EGREP_CPP([strerror_r],[
6394 $curl_includes_string
6395 ],[
6396 AC_MSG_RESULT([yes])
6397 tst_proto_strerror_r="yes"
6398 ],[
6399 AC_MSG_RESULT([no])
6400 tst_proto_strerror_r="no"
6401 ])
6402 fi
6403 #
6404 if test "$tst_proto_strerror_r" = "yes"; then
6405 AC_MSG_CHECKING([if strerror_r is compilable])
6406 AC_COMPILE_IFELSE([
6407 AC_LANG_PROGRAM([[
6408 $curl_includes_string
6409 ]],[[
6410 if(0 != strerror_r(0, 0, 0))
6411 return 1;
6412 ]])
6413 ],[
6414 AC_MSG_RESULT([yes])
6415 tst_compi_strerror_r="yes"
6416 ],[
6417 AC_MSG_RESULT([no])
6418 tst_compi_strerror_r="no"
6419 ])
6420 fi
6421 #
6422 if test "$tst_compi_strerror_r" = "yes"; then
6423 AC_MSG_CHECKING([if strerror_r is glibc like])
6424 tst_glibc_strerror_r_type_arg3="unknown"
6425 for arg3 in 'size_t' 'int' 'unsigned int'; do
6426 if test "$tst_glibc_strerror_r_type_arg3" = "unknown"; then
6427 AC_COMPILE_IFELSE([
6428 AC_LANG_PROGRAM([[
6429 $curl_includes_string
6430 char *strerror_r(int errnum, char *workbuf, $arg3 bufsize);
6431 ]],[[
6432 if(0 != strerror_r(0, 0, 0))
6433 return 1;
6434 ]])
6435 ],[
6436 tst_glibc_strerror_r_type_arg3="$arg3"
6437 ])
6438 fi
6439 done
6440 case "$tst_glibc_strerror_r_type_arg3" in
6441 unknown)
6442 AC_MSG_RESULT([no])
6443 tst_glibc_strerror_r="no"
6444 ;;
6445 *)
6446 AC_MSG_RESULT([yes])
6447 tst_glibc_strerror_r="yes"
6448 ;;
6449 esac
6450 fi
6451 #
6452 dnl only do runtime verification when not cross-compiling
6453 if test "x$cross_compiling" != "xyes" &&
6454 test "$tst_glibc_strerror_r" = "yes"; then
6455 AC_MSG_CHECKING([if strerror_r seems to work])
6456 CURL_RUN_IFELSE([
6457 AC_LANG_PROGRAM([[
6458 $curl_includes_stdlib
6459 $curl_includes_string
6460 # include <errno.h>
6461 ]],[[
6462 char buffer[1024];
6463 char *string = 0;
6464 buffer[0] = '\0';
6465 string = strerror_r(EACCES, buffer, sizeof(buffer));
6466 if(!string)
6467 exit(1); /* fail */
6468 if(!string[0])
6469 exit(1); /* fail */
6470 else
6471 exit(0);
6472 ]])
6473 ],[
6474 AC_MSG_RESULT([yes])
6475 tst_works_glibc_strerror_r="yes"
6476 ],[
6477 AC_MSG_RESULT([no])
6478 tst_works_glibc_strerror_r="no"
6479 ])
6480 fi
6481 #
6482 if test "$tst_compi_strerror_r" = "yes" &&
6483 test "$tst_works_glibc_strerror_r" != "yes"; then
6484 AC_MSG_CHECKING([if strerror_r is POSIX like])
6485 tst_posix_strerror_r_type_arg3="unknown"
6486 for arg3 in 'size_t' 'int' 'unsigned int'; do
6487 if test "$tst_posix_strerror_r_type_arg3" = "unknown"; then
6488 AC_COMPILE_IFELSE([
6489 AC_LANG_PROGRAM([[
6490 $curl_includes_string
6491 int strerror_r(int errnum, char *resultbuf, $arg3 bufsize);
6492 ]],[[
6493 if(0 != strerror_r(0, 0, 0))
6494 return 1;
6495 ]])
6496 ],[
6497 tst_posix_strerror_r_type_arg3="$arg3"
6498 ])
6499 fi
6500 done
6501 case "$tst_posix_strerror_r_type_arg3" in
6502 unknown)
6503 AC_MSG_RESULT([no])
6504 tst_posix_strerror_r="no"
6505 ;;
6506 *)
6507 AC_MSG_RESULT([yes])
6508 tst_posix_strerror_r="yes"
6509 ;;
6510 esac
6511 fi
6512 #
6513 dnl only do runtime verification when not cross-compiling
6514 if test "x$cross_compiling" != "xyes" &&
6515 test "$tst_posix_strerror_r" = "yes"; then
6516 AC_MSG_CHECKING([if strerror_r seems to work])
6517 CURL_RUN_IFELSE([
6518 AC_LANG_PROGRAM([[
6519 $curl_includes_stdlib
6520 $curl_includes_string
6521 # include <errno.h>
6522 ]],[[
6523 char buffer[1024];
6524 int error = 1;
6525 buffer[0] = '\0';
6526 error = strerror_r(EACCES, buffer, sizeof(buffer));
6527 if(error)
6528 exit(1); /* fail */
6529 if(buffer[0] == '\0')
6530 exit(1); /* fail */
6531 else
6532 exit(0);
6533 ]])
6534 ],[
6535 AC_MSG_RESULT([yes])
6536 tst_works_posix_strerror_r="yes"
6537 ],[
6538 AC_MSG_RESULT([no])
6539 tst_works_posix_strerror_r="no"
6540 ])
6541 fi
6542 #
6543 if test "$tst_works_glibc_strerror_r" = "yes"; then
6544 tst_posix_strerror_r="no"
6545 fi
6546 if test "$tst_works_posix_strerror_r" = "yes"; then
6547 tst_glibc_strerror_r="no"
6548 fi
6549 if test "$tst_glibc_strerror_r" = "yes" &&
6550 test "$tst_works_glibc_strerror_r" != "no" &&
6551 test "$tst_posix_strerror_r" != "yes"; then
6552 tst_allow_strerror_r="check"
6553 fi
6554 if test "$tst_posix_strerror_r" = "yes" &&
6555 test "$tst_works_posix_strerror_r" != "no" &&
6556 test "$tst_glibc_strerror_r" != "yes"; then
6557 tst_allow_strerror_r="check"
6558 fi
6559 if test "$tst_allow_strerror_r" = "check"; then
6560 AC_MSG_CHECKING([if strerror_r usage allowed])
6561 if test "x$curl_disallow_strerror_r" != "xyes"; then
6562 AC_MSG_RESULT([yes])
6563 tst_allow_strerror_r="yes"
6564 else
6565 AC_MSG_RESULT([no])
6566 tst_allow_strerror_r="no"
6567 fi
6568 fi
6569 #
6570 AC_MSG_CHECKING([if strerror_r might be used])
6571 if test "$tst_links_strerror_r" = "yes" &&
6572 test "$tst_proto_strerror_r" = "yes" &&
6573 test "$tst_compi_strerror_r" = "yes" &&
6574 test "$tst_allow_strerror_r" = "yes"; then
6575 AC_MSG_RESULT([yes])
6576 if test "$tst_glibc_strerror_r" = "yes"; then
6577 AC_DEFINE_UNQUOTED(HAVE_STRERROR_R, 1,
6578 [Define to 1 if you have the strerror_r function.])
6579 AC_DEFINE_UNQUOTED(HAVE_GLIBC_STRERROR_R, 1,
6580 [Define to 1 if you have a working glibc-style strerror_r function.])
6581 AC_DEFINE_UNQUOTED(STRERROR_R_TYPE_ARG3, $tst_glibc_strerror_r_type_arg3,
6582 [Define to the type of arg 3 for strerror_r.])
6583 fi
6584 if test "$tst_posix_strerror_r" = "yes"; then
6585 AC_DEFINE_UNQUOTED(HAVE_STRERROR_R, 1,
6586 [Define to 1 if you have the strerror_r function.])
6587 AC_DEFINE_UNQUOTED(HAVE_POSIX_STRERROR_R, 1,
6588 [Define to 1 if you have a working POSIX-style strerror_r function.])
6589 AC_DEFINE_UNQUOTED(STRERROR_R_TYPE_ARG3, $tst_posix_strerror_r_type_arg3,
6590 [Define to the type of arg 3 for strerror_r.])
6591 fi
6592 curl_cv_func_strerror_r="yes"
6593 else
6594 AC_MSG_RESULT([no])
6595 curl_cv_func_strerror_r="no"
6596 fi
6597 #
6598 if test "$tst_compi_strerror_r" = "yes" &&
6599 test "$tst_allow_strerror_r" = "unknown"; then
6600 AC_MSG_WARN([cannot determine strerror_r() style: edit lib/curl_config.h manually.])
6601 fi
6602 #
6603 ])
6604
6605
6606 dnl CURL_CHECK_FUNC_STRICMP
6607 dnl -------------------------------------------------
6608 dnl Verify if stricmp is available, prototyped, and
6609 dnl can be compiled. If all of these are true, and
6610 dnl usage has not been previously disallowed with
6611 dnl shell variable curl_disallow_stricmp, then
6612 dnl HAVE_STRICMP will be defined.
6613
6614 AC_DEFUN([CURL_CHECK_FUNC_STRICMP], [
6615 AC_REQUIRE([CURL_INCLUDES_STRING])dnl
6616 #
6617 tst_links_stricmp="unknown"
6618 tst_proto_stricmp="unknown"
6619 tst_compi_stricmp="unknown"
6620 tst_allow_stricmp="unknown"
6621 #
6622 AC_MSG_CHECKING([if stricmp can be linked])
6623 AC_LINK_IFELSE([
6624 AC_LANG_FUNC_LINK_TRY([stricmp])
6625 ],[
6626 AC_MSG_RESULT([yes])
6627 tst_links_stricmp="yes"
6628 ],[
6629 AC_MSG_RESULT([no])
6630 tst_links_stricmp="no"
6631 ])
6632 #
6633 if test "$tst_links_stricmp" = "yes"; then
6634 AC_MSG_CHECKING([if stricmp is prototyped])
6635 AC_EGREP_CPP([stricmp],[
6636 $curl_includes_string
6637 ],[
6638 AC_MSG_RESULT([yes])
6639 tst_proto_stricmp="yes"
6640 ],[
6641 AC_MSG_RESULT([no])
6642 tst_proto_stricmp="no"
6643 ])
6644 fi
6645 #
6646 if test "$tst_proto_stricmp" = "yes"; then
6647 AC_MSG_CHECKING([if stricmp is compilable])
6648 AC_COMPILE_IFELSE([
6649 AC_LANG_PROGRAM([[
6650 $curl_includes_string
6651 ]],[[
6652 if(0 != stricmp(0, 0))
6653 return 1;
6654 ]])
6655 ],[
6656 AC_MSG_RESULT([yes])
6657 tst_compi_stricmp="yes"
6658 ],[
6659 AC_MSG_RESULT([no])
6660 tst_compi_stricmp="no"
6661 ])
6662 fi
6663 #
6664 if test "$tst_compi_stricmp" = "yes"; then
6665 AC_MSG_CHECKING([if stricmp usage allowed])
6666 if test "x$curl_disallow_stricmp" != "xyes"; then
6667 AC_MSG_RESULT([yes])
6668 tst_allow_stricmp="yes"
6669 else
6670 AC_MSG_RESULT([no])
6671 tst_allow_stricmp="no"
6672 fi
6673 fi
6674 #
6675 AC_MSG_CHECKING([if stricmp might be used])
6676 if test "$tst_links_stricmp" = "yes" &&
6677 test "$tst_proto_stricmp" = "yes" &&
6678 test "$tst_compi_stricmp" = "yes" &&
6679 test "$tst_allow_stricmp" = "yes"; then
6680 AC_MSG_RESULT([yes])
6681 AC_DEFINE_UNQUOTED(HAVE_STRICMP, 1,
6682 [Define to 1 if you have the stricmp function.])
6683 curl_cv_func_stricmp="yes"
6684 else
6685 AC_MSG_RESULT([no])
6686 curl_cv_func_stricmp="no"
6687 fi
6688 ])
6689
6690 dnl CURL_CHECK_FUNC_STRNCASECMP
6691 dnl -------------------------------------------------
6692 dnl Verify if strncasecmp is available, prototyped, and
6693 dnl can be compiled. If all of these are true, and
6694 dnl usage has not been previously disallowed with
6695 dnl shell variable curl_disallow_strncasecmp, then
6696 dnl HAVE_STRNCASECMP will be defined.
6697
6698 AC_DEFUN([CURL_CHECK_FUNC_STRNCASECMP], [
6699 AC_REQUIRE([CURL_INCLUDES_STRING])dnl
6700 #
6701 tst_links_strncasecmp="unknown"
6702 tst_proto_strncasecmp="unknown"
6703 tst_compi_strncasecmp="unknown"
6704 tst_allow_strncasecmp="unknown"
6705 #
6706 AC_MSG_CHECKING([if strncasecmp can be linked])
6707 AC_LINK_IFELSE([
6708 AC_LANG_FUNC_LINK_TRY([strncasecmp])
6709 ],[
6710 AC_MSG_RESULT([yes])
6711 tst_links_strncasecmp="yes"
6712 ],[
6713 AC_MSG_RESULT([no])
6714 tst_links_strncasecmp="no"
6715 ])
6716 #
6717 if test "$tst_links_strncasecmp" = "yes"; then
6718 AC_MSG_CHECKING([if strncasecmp is prototyped])
6719 AC_EGREP_CPP([strncasecmp],[
6720 $curl_includes_string
6721 ],[
6722 AC_MSG_RESULT([yes])
6723 tst_proto_strncasecmp="yes"
6724 ],[
6725 AC_MSG_RESULT([no])
6726 tst_proto_strncasecmp="no"
6727 ])
6728 fi
6729 #
6730 if test "$tst_proto_strncasecmp" = "yes"; then
6731 AC_MSG_CHECKING([if strncasecmp is compilable])
6732 AC_COMPILE_IFELSE([
6733 AC_LANG_PROGRAM([[
6734 $curl_includes_string
6735 ]],[[
6736 if(0 != strncasecmp(0, 0, 0))
6737 return 1;
6738 ]])
6739 ],[
6740 AC_MSG_RESULT([yes])
6741 tst_compi_strncasecmp="yes"
6742 ],[
6743 AC_MSG_RESULT([no])
6744 tst_compi_strncasecmp="no"
6745 ])
6746 fi
6747 #
6748 if test "$tst_compi_strncasecmp" = "yes"; then
6749 AC_MSG_CHECKING([if strncasecmp usage allowed])
6750 if test "x$curl_disallow_strncasecmp" != "xyes"; then
6751 AC_MSG_RESULT([yes])
6752 tst_allow_strncasecmp="yes"
6753 else
6754 AC_MSG_RESULT([no])
6755 tst_allow_strncasecmp="no"
6756 fi
6757 fi
6758 #
6759 AC_MSG_CHECKING([if strncasecmp might be used])
6760 if test "$tst_links_strncasecmp" = "yes" &&
6761 test "$tst_proto_strncasecmp" = "yes" &&
6762 test "$tst_compi_strncasecmp" = "yes" &&
6763 test "$tst_allow_strncasecmp" = "yes"; then
6764 AC_MSG_RESULT([yes])
6765 AC_DEFINE_UNQUOTED(HAVE_STRNCASECMP, 1,
6766 [Define to 1 if you have the strncasecmp function.])
6767 curl_cv_func_strncasecmp="yes"
6768 else
6769 AC_MSG_RESULT([no])
6770 curl_cv_func_strncasecmp="no"
6771 fi
6772 ])
6773
6774
6775 dnl CURL_CHECK_FUNC_STRNCMPI
6776 dnl -------------------------------------------------
6777 dnl Verify if strncmpi is available, prototyped, and
6778 dnl can be compiled. If all of these are true, and
6779 dnl usage has not been previously disallowed with
6780 dnl shell variable curl_disallow_strncmpi, then
6781 dnl HAVE_STRNCMPI will be defined.
6782
6783 AC_DEFUN([CURL_CHECK_FUNC_STRNCMPI], [
6784 AC_REQUIRE([CURL_INCLUDES_STRING])dnl
6785 #
6786 tst_links_strncmpi="unknown"
6787 tst_proto_strncmpi="unknown"
6788 tst_compi_strncmpi="unknown"
6789 tst_allow_strncmpi="unknown"
6790 #
6791 AC_MSG_CHECKING([if strncmpi can be linked])
6792 AC_LINK_IFELSE([
6793 AC_LANG_FUNC_LINK_TRY([strncmpi])
6794 ],[
6795 AC_MSG_RESULT([yes])
6796 tst_links_strncmpi="yes"
6797 ],[
6798 AC_MSG_RESULT([no])
6799 tst_links_strncmpi="no"
6800 ])
6801 #
6802 if test "$tst_links_strncmpi" = "yes"; then
6803 AC_MSG_CHECKING([if strncmpi is prototyped])
6804 AC_EGREP_CPP([strncmpi],[
6805 $curl_includes_string
6806 ],[
6807 AC_MSG_RESULT([yes])
6808 tst_proto_strncmpi="yes"
6809 ],[
6810 AC_MSG_RESULT([no])
6811 tst_proto_strncmpi="no"
6812 ])
6813 fi
6814 #
6815 if test "$tst_proto_strncmpi" = "yes"; then
6816 AC_MSG_CHECKING([if strncmpi is compilable])
6817 AC_COMPILE_IFELSE([
6818 AC_LANG_PROGRAM([[
6819 $curl_includes_string
6820 ]],[[
6821 if(0 != strncmpi(0, 0))
6822 return 1;
6823 ]])
6824 ],[
6825 AC_MSG_RESULT([yes])
6826 tst_compi_strncmpi="yes"
6827 ],[
6828 AC_MSG_RESULT([no])
6829 tst_compi_strncmpi="no"
6830 ])
6831 fi
6832 #
6833 if test "$tst_compi_strncmpi" = "yes"; then
6834 AC_MSG_CHECKING([if strncmpi usage allowed])
6835 if test "x$curl_disallow_strncmpi" != "xyes"; then
6836 AC_MSG_RESULT([yes])
6837 tst_allow_strncmpi="yes"
6838 else
6839 AC_MSG_RESULT([no])
6840 tst_allow_strncmpi="no"
6841 fi
6842 fi
6843 #
6844 AC_MSG_CHECKING([if strncmpi might be used])
6845 if test "$tst_links_strncmpi" = "yes" &&
6846 test "$tst_proto_strncmpi" = "yes" &&
6847 test "$tst_compi_strncmpi" = "yes" &&
6848 test "$tst_allow_strncmpi" = "yes"; then
6849 AC_MSG_RESULT([yes])
6850 AC_DEFINE_UNQUOTED(HAVE_STRNCMPI, 1,
6851 [Define to 1 if you have the strncmpi function.])
6852 curl_cv_func_strncmpi="yes"
6853 else
6854 AC_MSG_RESULT([no])
6855 curl_cv_func_strncmpi="no"
6856 fi
6857 ])
6858
6859
6860 dnl CURL_CHECK_FUNC_STRNICMP
6861 dnl -------------------------------------------------
6862 dnl Verify if strnicmp is available, prototyped, and
6863 dnl can be compiled. If all of these are true, and
6864 dnl usage has not been previously disallowed with
6865 dnl shell variable curl_disallow_strnicmp, then
6866 dnl HAVE_STRNICMP will be defined.
6867
6868 AC_DEFUN([CURL_CHECK_FUNC_STRNICMP], [
6869 AC_REQUIRE([CURL_INCLUDES_STRING])dnl
6870 #
6871 tst_links_strnicmp="unknown"
6872 tst_proto_strnicmp="unknown"
6873 tst_compi_strnicmp="unknown"
6874 tst_allow_strnicmp="unknown"
6875 #
6876 AC_MSG_CHECKING([if strnicmp can be linked])
6877 AC_LINK_IFELSE([
6878 AC_LANG_FUNC_LINK_TRY([strnicmp])
6879 ],[
6880 AC_MSG_RESULT([yes])
6881 tst_links_strnicmp="yes"
6882 ],[
6883 AC_MSG_RESULT([no])
6884 tst_links_strnicmp="no"
6885 ])
6886 #
6887 if test "$tst_links_strnicmp" = "yes"; then
6888 AC_MSG_CHECKING([if strnicmp is prototyped])
6889 AC_EGREP_CPP([strnicmp],[
6890 $curl_includes_string
6891 ],[
6892 AC_MSG_RESULT([yes])
6893 tst_proto_strnicmp="yes"
6894 ],[
6895 AC_MSG_RESULT([no])
6896 tst_proto_strnicmp="no"
6897 ])
6898 fi
6899 #
6900 if test "$tst_proto_strnicmp" = "yes"; then
6901 AC_MSG_CHECKING([if strnicmp is compilable])
6902 AC_COMPILE_IFELSE([
6903 AC_LANG_PROGRAM([[
6904 $curl_includes_string
6905 ]],[[
6906 if(0 != strnicmp(0, 0))
6907 return 1;
6908 ]])
6909 ],[
6910 AC_MSG_RESULT([yes])
6911 tst_compi_strnicmp="yes"
6912 ],[
6913 AC_MSG_RESULT([no])
6914 tst_compi_strnicmp="no"
6915 ])
6916 fi
6917 #
6918 if test "$tst_compi_strnicmp" = "yes"; then
6919 AC_MSG_CHECKING([if strnicmp usage allowed])
6920 if test "x$curl_disallow_strnicmp" != "xyes"; then
6921 AC_MSG_RESULT([yes])
6922 tst_allow_strnicmp="yes"
6923 else
6924 AC_MSG_RESULT([no])
6925 tst_allow_strnicmp="no"
6926 fi
6927 fi
6928 #
6929 AC_MSG_CHECKING([if strnicmp might be used])
6930 if test "$tst_links_strnicmp" = "yes" &&
6931 test "$tst_proto_strnicmp" = "yes" &&
6932 test "$tst_compi_strnicmp" = "yes" &&
6933 test "$tst_allow_strnicmp" = "yes"; then
6934 AC_MSG_RESULT([yes])
6935 AC_DEFINE_UNQUOTED(HAVE_STRNICMP, 1,
6936 [Define to 1 if you have the strnicmp function.])
6937 curl_cv_func_strnicmp="yes"
6938 else
6939 AC_MSG_RESULT([no])
6940 curl_cv_func_strnicmp="no"
6941 fi
6942 ])
6943
6944
6945 dnl CURL_CHECK_FUNC_STRSTR
6946 dnl -------------------------------------------------
6947 dnl Verify if strstr is available, prototyped, and
6948 dnl can be compiled. If all of these are true, and
6949 dnl usage has not been previously disallowed with
6950 dnl shell variable curl_disallow_strstr, then
6951 dnl HAVE_STRSTR will be defined.
6952
6953 AC_DEFUN([CURL_CHECK_FUNC_STRSTR], [
6954 AC_REQUIRE([CURL_INCLUDES_STRING])dnl
6955 #
6956 tst_links_strstr="unknown"
6957 tst_proto_strstr="unknown"
6958 tst_compi_strstr="unknown"
6959 tst_allow_strstr="unknown"
6960 #
6961 AC_MSG_CHECKING([if strstr can be linked])
6962 AC_LINK_IFELSE([
6963 AC_LANG_FUNC_LINK_TRY([strstr])
6964 ],[
6965 AC_MSG_RESULT([yes])
6966 tst_links_strstr="yes"
6967 ],[
6968 AC_MSG_RESULT([no])
6969 tst_links_strstr="no"
6970 ])
6971 #
6972 if test "$tst_links_strstr" = "yes"; then
6973 AC_MSG_CHECKING([if strstr is prototyped])
6974 AC_EGREP_CPP([strstr],[
6975 $curl_includes_string
6976 ],[
6977 AC_MSG_RESULT([yes])
6978 tst_proto_strstr="yes"
6979 ],[
6980 AC_MSG_RESULT([no])
6981 tst_proto_strstr="no"
6982 ])
6983 fi
6984 #
6985 if test "$tst_proto_strstr" = "yes"; then
6986 AC_MSG_CHECKING([if strstr is compilable])
6987 AC_COMPILE_IFELSE([
6988 AC_LANG_PROGRAM([[
6989 $curl_includes_string
6990 ]],[[
6991 if(0 != strstr(0, 0))
6992 return 1;
6993 ]])
6994 ],[
6995 AC_MSG_RESULT([yes])
6996 tst_compi_strstr="yes"
6997 ],[
6998 AC_MSG_RESULT([no])
6999 tst_compi_strstr="no"
7000 ])
7001 fi
7002 #
7003 if test "$tst_compi_strstr" = "yes"; then
7004 AC_MSG_CHECKING([if strstr usage allowed])
7005 if test "x$curl_disallow_strstr" != "xyes"; then
7006 AC_MSG_RESULT([yes])
7007 tst_allow_strstr="yes"
7008 else
7009 AC_MSG_RESULT([no])
7010 tst_allow_strstr="no"
7011 fi
7012 fi
7013 #
7014 AC_MSG_CHECKING([if strstr might be used])
7015 if test "$tst_links_strstr" = "yes" &&
7016 test "$tst_proto_strstr" = "yes" &&
7017 test "$tst_compi_strstr" = "yes" &&
7018 test "$tst_allow_strstr" = "yes"; then
7019 AC_MSG_RESULT([yes])
7020 AC_DEFINE_UNQUOTED(HAVE_STRSTR, 1,
7021 [Define to 1 if you have the strstr function.])
7022 curl_cv_func_strstr="yes"
7023 else
7024 AC_MSG_RESULT([no])
7025 curl_cv_func_strstr="no"
7026 fi
7027 ])
7028
7029
7030 dnl CURL_CHECK_FUNC_STRTOK_R
7031 dnl -------------------------------------------------
7032 dnl Verify if strtok_r is available, prototyped, and
7033 dnl can be compiled. If all of these are true, and
7034 dnl usage has not been previously disallowed with
7035 dnl shell variable curl_disallow_strtok_r, then
7036 dnl HAVE_STRTOK_R will be defined.
7037
7038 AC_DEFUN([CURL_CHECK_FUNC_STRTOK_R], [
7039 AC_REQUIRE([CURL_INCLUDES_STRING])dnl
7040 #
7041 tst_links_strtok_r="unknown"
7042 tst_proto_strtok_r="unknown"
7043 tst_compi_strtok_r="unknown"
7044 tst_allow_strtok_r="unknown"
7045 #
7046 AC_MSG_CHECKING([if strtok_r can be linked])
7047 AC_LINK_IFELSE([
7048 AC_LANG_FUNC_LINK_TRY([strtok_r])
7049 ],[
7050 AC_MSG_RESULT([yes])
7051 tst_links_strtok_r="yes"
7052 ],[
7053 AC_MSG_RESULT([no])
7054 tst_links_strtok_r="no"
7055 ])
7056 #
7057 if test "$tst_links_strtok_r" = "yes"; then
7058 AC_MSG_CHECKING([if strtok_r is prototyped])
7059 AC_EGREP_CPP([strtok_r],[
7060 $curl_includes_string
7061 ],[
7062 AC_MSG_RESULT([yes])
7063 tst_proto_strtok_r="yes"
7064 ],[
7065 AC_MSG_RESULT([no])
7066 tst_proto_strtok_r="no"
7067 ])
7068 fi
7069 #
7070 if test "$tst_proto_strtok_r" = "yes"; then
7071 AC_MSG_CHECKING([if strtok_r is compilable])
7072 AC_COMPILE_IFELSE([
7073 AC_LANG_PROGRAM([[
7074 $curl_includes_string
7075 ]],[[
7076 if(0 != strtok_r(0, 0, 0))
7077 return 1;
7078 ]])
7079 ],[
7080 AC_MSG_RESULT([yes])
7081 tst_compi_strtok_r="yes"
7082 ],[
7083 AC_MSG_RESULT([no])
7084 tst_compi_strtok_r="no"
7085 ])
7086 fi
7087 #
7088 if test "$tst_compi_strtok_r" = "yes"; then
7089 AC_MSG_CHECKING([if strtok_r usage allowed])
7090 if test "x$curl_disallow_strtok_r" != "xyes"; then
7091 AC_MSG_RESULT([yes])
7092 tst_allow_strtok_r="yes"
7093 else
7094 AC_MSG_RESULT([no])
7095 tst_allow_strtok_r="no"
7096 fi
7097 fi
7098 #
7099 AC_MSG_CHECKING([if strtok_r might be used])
7100 if test "$tst_links_strtok_r" = "yes" &&
7101 test "$tst_proto_strtok_r" = "yes" &&
7102 test "$tst_compi_strtok_r" = "yes" &&
7103 test "$tst_allow_strtok_r" = "yes"; then
7104 AC_MSG_RESULT([yes])
7105 AC_DEFINE_UNQUOTED(HAVE_STRTOK_R, 1,
7106 [Define to 1 if you have the strtok_r function.])
7107 curl_cv_func_strtok_r="yes"
7108 else
7109 AC_MSG_RESULT([no])
7110 curl_cv_func_strtok_r="no"
7111 fi
7112 ])
7113
7114
7115 dnl CURL_CHECK_FUNC_STRTOLL
7116 dnl -------------------------------------------------
7117 dnl Verify if strtoll is available, prototyped, and
7118 dnl can be compiled. If all of these are true, and
7119 dnl usage has not been previously disallowed with
7120 dnl shell variable curl_disallow_strtoll, then
7121 dnl HAVE_STRTOLL will be defined.
7122
7123 AC_DEFUN([CURL_CHECK_FUNC_STRTOLL], [
7124 AC_REQUIRE([CURL_INCLUDES_STDLIB])dnl
7125 #
7126 tst_links_strtoll="unknown"
7127 tst_proto_strtoll="unknown"
7128 tst_compi_strtoll="unknown"
7129 tst_allow_strtoll="unknown"
7130 #
7131 AC_MSG_CHECKING([if strtoll can be linked])
7132 AC_LINK_IFELSE([
7133 AC_LANG_FUNC_LINK_TRY([strtoll])
7134 ],[
7135 AC_MSG_RESULT([yes])
7136 tst_links_strtoll="yes"
7137 ],[
7138 AC_MSG_RESULT([no])
7139 tst_links_strtoll="no"
7140 ])
7141 #
7142 if test "$tst_links_strtoll" = "yes"; then
7143 AC_MSG_CHECKING([if strtoll is prototyped])
7144 AC_EGREP_CPP([strtoll],[
7145 $curl_includes_stdlib
7146 ],[
7147 AC_MSG_RESULT([yes])
7148 tst_proto_strtoll="yes"
7149 ],[
7150 AC_MSG_RESULT([no])
7151 tst_proto_strtoll="no"
7152 ])
7153 fi
7154 #
7155 if test "$tst_proto_strtoll" = "yes"; then
7156 AC_MSG_CHECKING([if strtoll is compilable])
7157 AC_COMPILE_IFELSE([
7158 AC_LANG_PROGRAM([[
7159 $curl_includes_stdlib
7160 ]],[[
7161 if(0 != strtoll(0, 0, 0))
7162 return 1;
7163 ]])
7164 ],[
7165 AC_MSG_RESULT([yes])
7166 tst_compi_strtoll="yes"
7167 ],[
7168 AC_MSG_RESULT([no])
7169 tst_compi_strtoll="no"
7170 ])
7171 fi
7172 #
7173 if test "$tst_compi_strtoll" = "yes"; then
7174 AC_MSG_CHECKING([if strtoll usage allowed])
7175 if test "x$curl_disallow_strtoll" != "xyes"; then
7176 AC_MSG_RESULT([yes])
7177 tst_allow_strtoll="yes"
7178 else
7179 AC_MSG_RESULT([no])
7180 tst_allow_strtoll="no"
7181 fi
7182 fi
7183 #
7184 AC_MSG_CHECKING([if strtoll might be used])
7185 if test "$tst_links_strtoll" = "yes" &&
7186 test "$tst_proto_strtoll" = "yes" &&
7187 test "$tst_compi_strtoll" = "yes" &&
7188 test "$tst_allow_strtoll" = "yes"; then
7189 AC_MSG_RESULT([yes])
7190 AC_DEFINE_UNQUOTED(HAVE_STRTOLL, 1,
7191 [Define to 1 if you have the strtoll function.])
7192 curl_cv_func_strtoll="yes"
7193 else
7194 AC_MSG_RESULT([no])
7195 curl_cv_func_strtoll="no"
7196 fi
7197 ])
7198
7199
7200 dnl CURL_CHECK_FUNC_WRITEV
7201 dnl -------------------------------------------------
7202 dnl Verify if writev is available, prototyped, and
7203 dnl can be compiled. If all of these are true, and
7204 dnl usage has not been previously disallowed with
7205 dnl shell variable curl_disallow_writev, then
7206 dnl HAVE_WRITEV will be defined.
7207
7208 AC_DEFUN([CURL_CHECK_FUNC_WRITEV], [
7209 AC_REQUIRE([CURL_INCLUDES_SYS_UIO])dnl
7210 #
7211 tst_links_writev="unknown"
7212 tst_proto_writev="unknown"
7213 tst_compi_writev="unknown"
7214 tst_allow_writev="unknown"
7215 #
7216 AC_MSG_CHECKING([if writev can be linked])
7217 AC_LINK_IFELSE([
7218 AC_LANG_FUNC_LINK_TRY([writev])
7219 ],[
7220 AC_MSG_RESULT([yes])
7221 tst_links_writev="yes"
7222 ],[
7223 AC_MSG_RESULT([no])
7224 tst_links_writev="no"
7225 ])
7226 #
7227 if test "$tst_links_writev" = "yes"; then
7228 AC_MSG_CHECKING([if writev is prototyped])
7229 AC_EGREP_CPP([writev],[
7230 $curl_includes_sys_uio
7231 ],[
7232 AC_MSG_RESULT([yes])
7233 tst_proto_writev="yes"
7234 ],[
7235 AC_MSG_RESULT([no])
7236 tst_proto_writev="no"
7237 ])
7238 fi
7239 #
7240 if test "$tst_proto_writev" = "yes"; then
7241 AC_MSG_CHECKING([if writev is compilable])
7242 AC_COMPILE_IFELSE([
7243 AC_LANG_PROGRAM([[
7244 $curl_includes_sys_uio
7245 ]],[[
7246 if(0 != writev(0, 0, 0))
7247 return 1;
7248 ]])
7249 ],[
7250 AC_MSG_RESULT([yes])
7251 tst_compi_writev="yes"
7252 ],[
7253 AC_MSG_RESULT([no])
7254 tst_compi_writev="no"
7255 ])
7256 fi
7257 #
7258 if test "$tst_compi_writev" = "yes"; then
7259 AC_MSG_CHECKING([if writev usage allowed])
7260 if test "x$curl_disallow_writev" != "xyes"; then
7261 AC_MSG_RESULT([yes])
7262 tst_allow_writev="yes"
7263 else
7264 AC_MSG_RESULT([no])
7265 tst_allow_writev="no"
7266 fi
7267 fi
7268 #
7269 AC_MSG_CHECKING([if writev might be used])
7270 if test "$tst_links_writev" = "yes" &&
7271 test "$tst_proto_writev" = "yes" &&
7272 test "$tst_compi_writev" = "yes" &&
7273 test "$tst_allow_writev" = "yes"; then
7274 AC_MSG_RESULT([yes])
7275 AC_DEFINE_UNQUOTED(HAVE_WRITEV, 1,
7276 [Define to 1 if you have the writev function.])
7277 curl_cv_func_writev="yes"
7278 else
7279 AC_MSG_RESULT([no])
7280 curl_cv_func_writev="no"
7281 fi
7282 ])
7283
7284 dnl CURL_RUN_IFELSE
7285 dnl -------------------------------------------------
7286 dnl Wrapper macro to use instead of AC_RUN_IFELSE. It
7287 dnl sets LD_LIBRARY_PATH locally for this run only, from the
7288 dnl CURL_LIBRARY_PATH variable. It keeps the LD_LIBRARY_PATH
7289 dnl changes contained within this macro.
7290
7291 AC_DEFUN([CURL_RUN_IFELSE], [
7292 AC_REQUIRE([AC_RUN_IFELSE])dnl
7293
7294 old=$LD_LIBRARY_PATH
7295 LD_LIBRARY_PATH=$CURL_LIBRARY_PATH:$old
7296 export LD_LIBRARY_PATH
7297 AC_RUN_IFELSE([AC_LANG_SOURCE([$1])], $2, $3, $4)
7298 LD_LIBRARY_PATH=$old # restore
7299 ])
7300
7301 dnl CURL_COVERAGE
7302 dnl --------------------------------------------------
7303 dnl Switch on options and libs to build with gcc's code coverage.
7304 dnl
7305
7306 AC_DEFUN([CURL_COVERAGE],[
7307 AC_REQUIRE([AC_PROG_SED])
7308 AC_REQUIRE([AC_ARG_ENABLE])
7309 AC_MSG_CHECKING([for code coverage support])
7310 coverage="no"
7311 curl_coverage_msg="disabled"
7312
7313 dnl check if enabled by argument
7314 AC_ARG_ENABLE(code-coverage,
7315 AC_HELP_STRING([--enable-code-coverage], [Provide code coverage]),
7316 coverage="$enableval")
7317
7318 dnl if not gcc switch off again
7319 AS_IF([ test "$GCC" != "yes" ], coverage="no" )
7320 AC_MSG_RESULT($coverage)
7321
7322 if test "x$coverage" = "xyes"; then
7323 curl_coverage_msg="enabled"
7324
7325 AC_CHECK_TOOL([GCOV], [gcov], [gcov])
7326 if test -z "$GCOV"; then
7327 AC_MSG_ERROR([needs gcov for code coverage])
7328 fi
7329 AC_CHECK_PROG([LCOV], [lcov], [lcov])
7330 if test -z "$LCOV"; then
7331 AC_MSG_ERROR([needs lcov for code coverage])
7332 fi
7333
7334 CPPFLAGS="$CPPFLAGS -DNDEBUG"
7335 CFLAGS="$CLAGS -O0 -g -fprofile-arcs -ftest-coverage"
7336 LIBS="$LIBS -lgcov"
7337 fi
7338 ])