acinclude.m4

   1 dnl Macros that test for specific features.
   2 dnl This file is part of the Autoconf packaging for Wireshark.
   3 dnl Copyright (C) 1998-2000 by Gerald Combs.
   4 dnl
   5 dnl This program is free software; you can redistribute it and/or modify
   6 dnl it under the terms of the GNU General Public License as published by
   7 dnl the Free Software Foundation; either version 2, or (at your option)
   8 dnl any later version.
   9 dnl
  10 dnl This program is distributed in the hope that it will be useful,
  11 dnl but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 dnl GNU General Public License for more details.
  14 dnl
  15 dnl You should have received a copy of the GNU General Public License
  16 dnl along with this program; if not, write to the Free Software
  17 dnl Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  18 dnl 02111-1307, USA.
  19 dnl
  20 dnl As a special exception, the Free Software Foundation gives unlimited
  21 dnl permission to copy, distribute and modify the configure scripts that
  22 dnl are the output of Autoconf.  You need not follow the terms of the GNU
  23 dnl General Public License when using or distributing such scripts, even
  24 dnl though portions of the text of Autoconf appear in them.  The GNU
  25 dnl General Public License (GPL) does govern all other use of the material
  26 dnl that constitutes the Autoconf program.
  27 dnl
  28 dnl Certain portions of the Autoconf source text are designed to be copied
  29 dnl (in certain cases, depending on the input) into the output of
  30 dnl Autoconf.  We call these the "data" portions.  The rest of the Autoconf
  31 dnl source text consists of comments plus executable code that decides which
  32 dnl of the data portions to output in any given case.  We call these
  33 dnl comments and executable code the "non-data" portions.  Autoconf never
  34 dnl copies any of the non-data portions into its output.
  35 dnl
  36 dnl This special exception to the GPL applies to versions of Autoconf
  37 dnl released by the Free Software Foundation.  When you make and
  38 dnl distribute a modified version of Autoconf, you may extend this special
  39 dnl exception to the GPL to apply to your modified version as well, *unless*
  40 dnl your modified version has the potential to copy into its output some
  41 dnl of the text that was the non-data portion of the version that you started
  42 dnl with.  (In other words, unless your change moves or copies text from
  43 dnl the non-data portions to the data portions.)  If your modification has
  44 dnl such potential, you must delete any notice of this special exception
  45 dnl to the GPL from your modified version.
  46 dnl
  47 dnl Written by David MacKenzie, with help from
  48 dnl Franc,ois Pinard, Karl Berry, Richard Pixley, Ian Lance Taylor,
  49 dnl Roland McGrath, Noah Friedman, david d zuhn, and many others.
  50
  51 #
  52 # AC_WIRESHARK_ADD_DASH_L
  53 #
  54 # Add to the variable specified as the first argument a "-L" flag for the
  55 # directory specified as the second argument, and, on Solaris, add a
  56 # "-R" flag for it as well.
  57 #
  58 # XXX - IRIX, and other OSes, may require some flag equivalent to
  59 # "-R" here.
  60 #
  61 AC_DEFUN([AC_WIRESHARK_ADD_DASH_L],
  62 [AX_APPEND_FLAG(-L$2, $1)
  63 case "$host_os" in
  64   solaris*)
  65     AX_APPEND_FLAG(-R$2, $1)
  66   ;;
  67 esac
  68 ])
  69
  70 #
  71 # AC_WIRESHARK_PUSH_FLAGS
  72 #
  73 # Push our flags to CFLAGS/etc.
  74 #
  75 AC_DEFUN([AC_WIRESHARK_PUSH_FLAGS],
  76 [
  77   ac_ws_CPPLAGS_saved="$CPPFLAGS"
  78   ac_ws_CFLAGS_saved="$CFLAGS"
  79   ac_ws_CXXFLAGS_saved="$CXXFLAGS"
  80   ac_ws_LDFLAGS_saved="$LDFLAGS"
  81   CPPFLAGS="$WS_CPPFLAGS $CPPFLAGS"
  82   CFLAGS="$WS_CFLAGS $CFLAGS"
  83   CXXFLAGS="$WS_CXXFLAGS $CXXFLAGS"
  84   LDFLAGS="$WS_LDFLAGS $LDFLAGS"
  85 ])
  86
  87 #
  88 # AC_WIRESHARK_POP_FLAGS
  89 #
  90 # Restore user build flags.
  91 #
  92 AC_DEFUN([AC_WIRESHARK_POP_FLAGS],
  93 [
  94   CPPFLAGS="$ac_ws_CPPLAGS_saved"
  95   CFLAGS="$ac_ws_CFLAGS_saved"
  96   CXXFLAGS="$ac_ws_CXXFLAGS_saved"
  97   LDFLAGS="$ac_ws_LDFLAGS_saved"
  98 ])
  99
 100
 101 #
 102 # AC_WIRESHARK_BREAKLOOP_TRY_LINK
 103 #
 104 AC_DEFUN([AC_WIRESHARK_PCAP_BREAKLOOP_TRY_LINK],
 105 [
 106   AC_LINK_IFELSE(
 107   [
 108       AC_LANG_SOURCE(
 109       [[
 110 #       include <pcap.h>
 111         int main(void)
 112         {
 113           pcap_t  *pct = NULL;
 114           pcap_breakloop(pct);
 115           return 0;
 116         }
 117       ]])
 118   ],
 119   [
 120     ws_breakloop_compiled=yes
 121   ],
 122   [
 123     ws_breakloop_compiled=no
 124   ])
 125 ])
 126
 127
 128
 129 #
 130 # AC_WIRESHARK_PCAP_CHECK
 131 #
 132 AC_DEFUN([AC_WIRESHARK_PCAP_CHECK],
 133 [
 134         AC_WIRESHARK_PUSH_FLAGS
 135         ws_ac_save_LIBS="$LIBS"
 136
 137         if test -z "$pcap_dir"
 138         then
 139           # Pcap header checks
 140           # XXX need to set a var AC_CHECK_HEADER(pcap.h,,)
 141
 142           #
 143           # The user didn't specify a directory in which libpcap resides.
 144           # First, look for a pcap-config script.
 145           #
 146           AC_PATH_TOOL(PCAP_CONFIG, pcap-config)
 147
 148           if test -n "$PCAP_CONFIG" ; then
 149             #
 150             # Found it.
 151             #
 152             # Now check whether it's the libpcap 1.0 version, which
 153             # put a space after "-L" - on some platforms, that doesn't
 154             # work.
 155             #
 156             AC_MSG_CHECKING(for broken pcap-config)
 157             case "`\"$PCAP_CONFIG\" --libs`" in
 158
 159             "-L "*)
 160               #
 161               # Space after -L.  Pretend pcap-config doesn't exist.
 162               #
 163               AC_MSG_RESULT(yes)
 164               PCAP_CONFIG=""
 165               ;;
 166
 167             *)
 168               #
 169               # No space after -L.
 170               #
 171               AC_MSG_RESULT(no)
 172               ;;
 173             esac
 174           fi
 175           if test -n "$PCAP_CONFIG" ; then
 176             #
 177             # Found it, and it's usable; use it to get the include flags
 178             # for libpcap.
 179             #
 180             PCAP_CFLAGS=`\"$PCAP_CONFIG\" --cflags`
 181             #
 182             # We have pcap-config; we assume that means we have libpcap
 183             # installed and that pcap-config will tell us whatever
 184             # libraries libpcap needs.
 185             #
 186             if test x$enable_static = xyes; then
 187               PCAP_LIBS="`\"$PCAP_CONFIG\" --libs --static`"
 188             else
 189               PCAP_LIBS="`\"$PCAP_CONFIG\" --libs`"
 190             fi
 191           else
 192             #
 193             # Didn't find it; we have to look for libpcap ourselves.
 194             # We assume that the current library search path will work,
 195             # but we may have to look for the header in a "pcap"
 196             # subdirectory of "/usr/include" or "/usr/local/include",
 197             # as some systems apparently put "pcap.h" in a "pcap"
 198             # subdirectory without also providing a "pcap.h" in the top-level
 199             # include directory, and we also check "$prefix/include" - and
 200             # "$prefix/include/pcap", in case $prefix is set to
 201             # "/usr/include" or "/usr/local/include".
 202             #
 203             PCAP_CFLAGS=""
 204             PCAP_LIBS="-lpcap"
 205
 206             AC_MSG_CHECKING(for extraneous pcap header directories)
 207             found_pcap_dir=""
 208             pcap_dir_list="/usr/local/include/pcap /usr/include/pcap $prefix/include/pcap $prefix/include"
 209             for pcap_dir in $pcap_dir_list
 210             do
 211               if test -d $pcap_dir ; then
 212                 if test x$pcap_dir != x/usr/include -a x$pcap_dir != x/usr/local/include ; then
 213                     PCAP_CFLAGS="-I$pcap_dir"
 214                 fi
 215                 found_pcap_dir=" $found_pcap_dir -I$pcap_dir"
 216                 break
 217               fi
 218             done
 219
 220             if test "$found_pcap_dir" != "" ; then
 221               AC_MSG_RESULT(found --$found_pcap_dir added to CFLAGS)
 222             else
 223               AC_MSG_RESULT(not found)
 224             fi
 225           fi
 226         else
 227           #
 228           # The user specified a directory in which libpcap resides,
 229           # so add the "include" subdirectory of that directory to
 230           # the include file search path and the "lib" subdirectory
 231           # of that directory to the library search path.
 232           #
 233           # XXX - if there's also a libpcap in a directory that's
 234           # already in CPPFLAGS or LDFLAGS, this won't make us find
 235           # the version in the specified directory, as the compiler
 236           # and/or linker will search that other directory before it
 237           # searches the specified directory.
 238           #
 239           PCAP_CFLAGS="-I$pcap_dir/include"
 240           #
 241           # XXX - This doesn't use AC_WIRESHARK_ADD_DASH_L
 242           #
 243           PCAP_LIBS="-L$pcap_dir/lib -lpcap"
 244         fi
 245
 246         CFLAGS="$PCAP_CFLAGS $CFLAGS"
 247         LIBS="$PCAP_LIBS $LIBS"
 248
 249         # Pcap header check
 250         AC_CHECK_HEADER(pcap.h,
 251           [
 252               AC_DEFINE(HAVE_LIBPCAP, 1, [Define to use libpcap library])
 253           ],
 254           [
 255               AC_MSG_ERROR([[Header file pcap.h not found; if you installed libpcap
 256 from source, did you also do \"make install-incl\", and if you installed a
 257 binary package of libpcap, is there also a developer's package of libpcap,
 258 and did you also install that package?]])
 259           ])
 260
 261         #
 262         # Check to see if we find "pcap_open_live" in "-lpcap".
 263         # Also check for various additional libraries that libpcap might
 264         # require.
 265         #
 266         AC_CHECK_LIB(pcap, pcap_open_live,
 267           [
 268           ],
 269           [
 270             ac_wireshark_extras_found=no
 271             ac_save_LIBS="$LIBS"
 272             for extras in "-lcfg -lodm" "-lpfring"
 273             do
 274               AC_MSG_CHECKING([for pcap_open_live in -lpcap with $extras])
 275               LIBS="-lpcap $extras $ac_save_LIBS"
 276               #
 277               # XXX - can't we use AC_CHECK_LIB here?
 278               #
 279               AC_TRY_LINK(
 280                 [
 281 #       include <pcap.h>
 282                 ],
 283                 [
 284         pcap_open_live(NULL, 0, 0, 0, NULL);
 285                 ],
 286                 [
 287                   ac_wireshark_extras_found=yes
 288                   AC_MSG_RESULT([yes])
 289                   PCAP_LIBS="$PCAP_LIBS $extras"
 290                 ],
 291                 [
 292                   AC_MSG_RESULT([no])
 293                 ])
 294                 if test x$ac_wireshark_extras_found = xyes
 295                 then
 296                   break
 297                 fi
 298             done
 299             if test x$ac_wireshark_extras_found = xno
 300             then
 301               AC_MSG_ERROR([Can't link with library libpcap.])
 302             fi
 303             LIBS=$ac_save_LIBS
 304           ])
 305         AC_SUBST(PCAP_CFLAGS)
 306         AC_SUBST(PCAP_LIBS)
 307
 308         #
 309         # Check whether various variables and functions are defined by
 310         # libpcap.
 311         #
 312         AC_CHECK_FUNCS(pcap_open_dead pcap_freecode)
 313         #
 314         # pcap_breakloop may be present in the library but not declared
 315         # in the pcap.h header file.  If it's not declared in the header
 316         # file, attempts to use it will get warnings, and, if we're
 317         # building with warnings treated as errors, that warning will
 318         # cause compilation to fail.
 319         #
 320         # We are therefore first testing whether the function is present
 321         # and then, if we're compiling with warnings as errors, testing
 322         # whether it is usable.  It is usable if it compiles without
 323         # a -Wimplicit warning (the "compile with warnings as errors"
 324         # option requires GCC). If it is not usable, we fail and tell
 325         # the user that the pcap.h header needs to be updated.
 326         #
 327         # Ceteris paribus, this should only happen with Mac OS X 10.3[.x] which
 328         # can have an up-to-date pcap library without the corresponding pcap
 329         # header.
 330         #
 331         # However, it might also happen on some others OSes with some erroneous
 332         # system manipulations where multiple versions of libpcap might co-exist
 333         # e.g. hand made symbolic link from libpcap.so -> libpcap.so.0.8 but
 334         # having the pcap header version 0.7.
 335         #
 336         AC_MSG_CHECKING([whether pcap_breakloop is present])
 337         ac_CFLAGS_saved="$CFLAGS"
 338         AC_WIRESHARK_PCAP_BREAKLOOP_TRY_LINK
 339         if test "x$ws_breakloop_compiled" = "xyes"; then
 340           AC_MSG_RESULT(yes)
 341           AC_DEFINE(HAVE_PCAP_BREAKLOOP, 1, [Define if pcap_breakloop is known])
 342           if test "x$with_warnings_as_errors" = "xyes"; then
 343             AC_MSG_CHECKING([whether pcap_breakloop is usable])
 344             CFLAGS="$CFLAGS -Werror -Wimplicit"
 345             AC_WIRESHARK_PCAP_BREAKLOOP_TRY_LINK
 346             if test "x$ws_breakloop_compiled" = "xyes"; then
 347               AC_MSG_RESULT(yes)
 348             else
 349               AC_MSG_RESULT(no)
 350               AC_MSG_ERROR(
 351 [Your pcap library is more recent than your pcap header.
 352 As you are building with compiler warnings treated as errors, Wireshark
 353 won't be able to use functions not declared in that header.
 354 If you wish to build with compiler warnings treated as errors, You should
 355 install a newer version of the header file.])
 356             fi
 357             CFLAGS="$ac_CFLAGS_saved"
 358           fi
 359         else
 360           AC_MSG_RESULT(no)
 361         fi
 362
 363         #
 364         # Later versions of Mac OS X 10.3[.x] ship a pcap.h that
 365         # doesn't define pcap_if_t but ship an 0.8[.x] libpcap,
 366         # so the library has "pcap_findalldevs()", but pcap.h
 367         # doesn't define "pcap_if_t" so you can't actually *use*
 368         # "pcap_findalldevs()".
 369         #
 370         # That even appears to be true of systems shipped with
 371         # 10.3.4, so it doesn't appear only to be a case of
 372         # Software Update not updating header files.
 373         #
 374         # (You can work around this by installing the 0.8 header
 375         # files.)
 376         #
 377         AC_CACHE_CHECK([whether pcap_findalldevs is present and usable],
 378           [ac_cv_func_pcap_findalldevs],
 379           [
 380             AC_LINK_IFELSE(
 381               [
 382                 AC_LANG_SOURCE(
 383                   [[
 384                     #include <pcap.h>
 385                     int main()
 386                     {
 387                       pcap_if_t *devpointer;
 388                       char errbuf[1];
 389
 390                       pcap_findalldevs(&devpointer, errbuf);
 391                     }
 392                   ]])
 393               ],
 394               [
 395                 ac_cv_func_pcap_findalldevs=yes
 396               ],
 397               [
 398                 ac_cv_func_pcap_findalldevs=no
 399               ])
 400           ])
 401         #
 402         # Don't check for other new routines that showed up after
 403         # "pcap_findalldevs()" if we don't have a usable
 404         # "pcap_findalldevs()", so we don't end up using them if the
 405         # "pcap.h" is crufty and old and doesn't declare them.
 406         #
 407         if test $ac_cv_func_pcap_findalldevs = "yes" ; then
 408           AC_DEFINE(HAVE_PCAP_FINDALLDEVS, 1,
 409            [Define to 1 if you have the `pcap_findalldevs' function and a pcap.h that declares pcap_if_t.])
 410           AC_CHECK_FUNCS(pcap_datalink_val_to_name pcap_datalink_name_to_val)
 411           AC_CHECK_FUNCS(pcap_datalink_val_to_description)
 412           AC_CHECK_FUNCS(pcap_list_datalinks pcap_set_datalink pcap_lib_version)
 413           AC_CHECK_FUNCS(pcap_get_selectable_fd pcap_free_datalinks)
 414           AC_CHECK_FUNC(pcap_create,
 415           [
 416             AC_DEFINE(HAVE_PCAP_CREATE, 1,
 417              [Define to 1 if you have the `pcap_create' function.])
 418             AC_DEFINE(CAN_SET_CAPTURE_BUFFER_SIZE, 1,
 419              [Define to 1 if the capture buffer size can be set.])
 420           ])
 421           AC_CHECK_FUNCS(bpf_image pcap_set_tstamp_precision pcap_set_tstamp_type)
 422         fi
 423
 424         AC_WIRESHARK_POP_FLAGS
 425         LIBS="$ws_ac_save_LIBS"
 426 ])
 427
 428 AC_DEFUN([AC_WIRESHARK_PCAP_REMOTE_CHECK],
 429 [
 430     ac_save_LIBS="$LIBS"
 431     LIBS="$PCAP_LIBS $LIBS"
 432     AC_CHECK_FUNCS(pcap_open)
 433     if test $ac_cv_func_pcap_open = "yes" ; then
 434         AC_DEFINE(HAVE_PCAP_REMOTE, 1,
 435             [Define to 1 if you have libpcap/WinPcap remote capturing support and prefer to use these new API features.])
 436     fi
 437     AC_CHECK_FUNCS(pcap_setsampling)
 438     LIBS="$ac_save_LIBS"
 439 ])
 440
 441 #
 442 # AC_WIRESHARK_ZLIB_CHECK
 443 #
 444 AC_DEFUN([AC_WIRESHARK_ZLIB_CHECK],
 445 [
 446         AC_WIRESHARK_PUSH_FLAGS
 447
 448         if test "x$zlib_dir" != "x"
 449         then
 450           #
 451           # The user specified a directory in which zlib resides,
 452           # so add the "include" subdirectory of that directory to
 453           # the include file search path and the "lib" subdirectory
 454           # of that directory to the library search path.
 455           #
 456           # XXX - if there's also a zlib in a directory that's
 457           # already in CPPFLAGS or LDFLAGS, this won't make us find
 458           # the version in the specified directory, as the compiler
 459           # and/or linker will search that other directory before it
 460           # searches the specified directory.
 461           #
 462           CPPFLAGS="$CPPFLAGS -I$zlib_dir/include"
 463           AC_WIRESHARK_ADD_DASH_L(LDFLAGS, $zlib_dir/lib)
 464         fi
 465
 466         #
 467         # Make sure we have "zlib.h".  If we don't, it means we probably
 468         # don't have zlib, so don't use it.
 469         #
 470         AC_CHECK_HEADER(zlib.h,,
 471           [
 472             if test "x$zlib_dir" != "x"
 473             then
 474               #
 475               # The user used "--with-zlib=" to specify a directory
 476               # containing zlib, but we didn't find the header file
 477               # there; that either means they didn't specify the
 478               # right directory or are confused about whether zlib
 479               # is, in fact, installed.  Report the error and give up.
 480               #
 481               AC_MSG_ERROR([zlib header not found in directory specified in --with-zlib])
 482             else
 483               if test "x$want_zlib" = "xyes"
 484               then
 485                 #
 486                 # The user tried to force us to use the library, but we
 487                 # couldn't find the header file; report an error.
 488                 #
 489                 AC_MSG_ERROR(Header file zlib.h not found.)
 490               else
 491                 #
 492                 # We couldn't find the header file; don't use the
 493                 # library, as it's probably not present.
 494                 #
 495                 want_zlib=no
 496               fi
 497             fi
 498           ])
 499
 500         if test "x$want_zlib" != "xno"
 501         then
 502                 #
 503                 # Well, we at least have the zlib header file.
 504                 #
 505                 # We link with zlib to support uncompression of
 506                 # gzipped network traffic, e.g. in an HTTP request
 507                 # or response body.
 508                 #
 509                 # Check for inflate() in zlib, to make sure the
 510                 # zlib library is usable.  For example, on at
 511                 # least some versions of Fedora, if you have a
 512                 # 64-bit machine, have both the 32-bit and 64-bit
 513                 # versions of the run-time zlib package installed,
 514                 # and have only the *32-bit* version of the zlib
 515                 # development package installed, it'll find the
 516                 # header, and think it can use zlib, and will use
 517                 # it in subsequent tests, but it'll try and link
 518                 # 64-bit test programs with the 32-bit library,
 519                 # causing those tests to falsely fail.  Hilarity
 520                 # ensues.
 521                 #
 522                 if test "x$zlib_dir" != "x"
 523                 then
 524                   WS_CPPFLAGS="$WS_CPPFLAGS -I$zlib_dir/include"
 525                   AC_WIRESHARK_ADD_DASH_L(WS_LDFLAGS, $zlib_dir/lib)
 526                 fi
 527                 AC_DEFINE(HAVE_ZLIB, 1, [Define to use zlib library])
 528                 #
 529                 # Check for "inflate()" in zlib to make sure we can
 530                 # link with it.
 531                 #
 532                 AC_CHECK_LIB(z, inflate,,
 533                     AC_MSG_ERROR([zlib.h found but linking with -lz failed to find inflate(); do you have the right developer package installed (32-bit vs. 64-bit)?]))
 534
 535                 #
 536                 # Check for "inflatePrime()" in zlib, which we need
 537                 # in order to read compressed capture files.
 538                 #
 539                 AC_CHECK_FUNCS(inflatePrime)
 540
 541                 if test "x$ac_cv_func_inflatePrime" = "xyes" ; then
 542                         #
 543                         # Now check for "inflatePrime()" in zlib when
 544                         # linking with the linker flags for GTK+
 545                         # applications; people often grab XFree86 source
 546                         # and build and install it on their systems,
 547                         # and they appear sometimes to misconfigure
 548                         # XFree86 so that, even on systems with zlib,
 549                         # it assumes there is no zlib, so the XFree86
 550                         # build process builds and installs its
 551                         # own zlib in the X11 library directory.
 552                         #
 553                         # The zlib in at least some versions of XFree86
 554                         # is an older version that may lack "inflatePrime()",
 555                         # and that's the zlib with which Wireshark gets
 556                         # linked, so the build of Wireshark fails.
 557                         #
 558                         AC_MSG_CHECKING([for inflatePrime missing when linking with X11])
 559                         AC_TRY_LINK_FUNC(inflatePrime, AC_MSG_RESULT(no),
 560                           [
 561                             AC_MSG_RESULT(yes)
 562                             AC_MSG_ERROR(old zlib found when linking with X11 - get rid of old zlib.)
 563                           ])
 564                 fi
 565         fi
 566
 567         AC_WIRESHARK_POP_FLAGS
 568 ])
 569
 570 #
 571 # AC_WIRESHARK_LIBLUA_CHECK
 572 #
 573 # Sets $have_lua to yes or no.
 574 # If it's yes, it also sets $LUA_CFLAGS and $LUA_LIBS.
 575 AC_DEFUN([AC_WIRESHARK_LIBLUA_CHECK],[
 576
 577         AC_WIRESHARK_PUSH_FLAGS
 578
 579         if test "x$want_lua_dir" = "x"
 580         then
 581                 # The user didn't tell us where to find Lua.  Let's go look for it.
 582
 583                 # First, try the standard (pkg-config) way.
 584                 # Unfortunately Lua's pkg-config file isn't standardly named.
 585                 # Some distributions allow installation of multiple versions of
 586                 # Lua at the same time.  On such systems each version has its
 587                 # own package name.
 588                 #
 589                 # We use a for loop instead of giving all the package names to
 590                 # PKG_CHECK_MODULES because doing the latter doesn't appear to
 591                 # work reliably (some package names are not searched for).
 592                 for pkg in "lua < 5.3" lua5.2 lua-5.2 lua52 lua5.1 lua-5.1 lua51 lua5.0 lua-5.0 lua50
 593                 do
 594                         AC_MSG_CHECKING(if you have $pkg)
 595                         PKG_CHECK_EXISTS($pkg,
 596                         [
 597                          AC_MSG_RESULT(yes)
 598                          have_lua=yes
 599                         ],
 600                         [
 601                          AC_MSG_RESULT(no)
 602                         ])
 603
 604                         if test "x$have_lua" = "xyes"
 605                         then
 606                                 PKG_WIRESHARK_CHECK_SYSTEM_MODULES(LUA, $pkg)
 607                                 CPPFLAGS="$LUA_CFLAGS $CPPFLAGS"
 608                                 AC_CHECK_HEADERS(lua.h lualib.h lauxlib.h)
 609                                 break
 610                         fi
 611                 done
 612         fi
 613
 614         if test "x$have_lua" != "xyes"
 615         then
 616                 # We don't have pkg-config or the user specified the path to
 617                 # Lua (in $want_lua_dir).
 618                 # Let's look for the header file.
 619
 620                 AC_MSG_CHECKING(for the location of lua.h)
 621                 if test "x$want_lua_dir" = "x"
 622                 then
 623                         # The user didn't tell us where to look so we'll look in some
 624                         # standard locations.
 625                         want_lua_dir="/usr/local /usr $prefix"
 626                 fi
 627                 for dir in $want_lua_dir
 628                 do
 629                         if test -r "$dir/include/lua.h"
 630                         then
 631                                 header_dir="$dir/include"
 632                                 lua_dir=$dir
 633                                 break
 634                         fi
 635
 636                         for ver in 5.2 52 5.1 51 5.0 50
 637                         do
 638                                 if test -r "$dir/include/lua$ver/lua.h"
 639                                 then
 640                                         header_dir="$dir/include/lua$ver"
 641                                         lua_dir=$dir
 642                                         break
 643                                 fi
 644                         done
 645                 done
 646
 647                 if test "x$header_dir" = "x"
 648                 then
 649                         have_lua=no
 650                         AC_MSG_RESULT(not found)
 651                 else
 652                         AC_MSG_RESULT($header_dir)
 653
 654                         AC_MSG_CHECKING(the Lua version)
 655                         lua_ver=`$AWK AS_ESCAPE('/LUA_VERSION_NUM/ { print $NF; }' $header_dir/lua.h | sed 's/0/./')`
 656
 657                         if test "x$lua_ver" = "x5.3"
 658                         then
 659                                 # Wireshark doesn't compile with Lua 5.3 today
 660                                 AC_MSG_RESULT($lua_ver - disabling Lua support)
 661                                 have_lua=no
 662                         else
 663                                 AC_MSG_RESULT($lua_ver)
 664
 665                                 CPPFLAGS="$CPPFLAGS -I$header_dir"
 666                                 AC_CHECK_HEADERS(lua.h lualib.h lauxlib.h, ,
 667                                 [
 668                                         have_lua=no
 669                                 ])
 670                         fi
 671
 672                         if test "x$have_lua" = "x"
 673                         then
 674                                 # Set LUA_CFLAGS
 675                                 LUA_CFLAGS="-I$header_dir"
 676
 677                                 # We have the header files and they work.  Now let's check if we
 678                                 # have the library and it works.
 679                                 #
 680                                 # XXX - if there's also a liblua in a directory that's
 681                                 # already in CPPFLAGS or LDFLAGS, this won't make us find
 682                                 # the version in the specified directory, as the compiler
 683                                 # and/or linker will search that other directory before it
 684                                 # searches the specified directory.
 685                                 #
 686                                 # XXX - lib64?
 687                                 LDFLAGS="-L$lua_dir/lib $LDFLAGS"
 688                                 AC_SEARCH_LIBS(luaL_openlibs, [lua-${lua_ver} lua${lua_ver} lua],
 689                                 [
 690                                         LUA_LIBS="-L$lua_dir/lib $ac_cv_search_luaL_openlibs -lm"
 691                                         have_lua=yes
 692                                 ],[
 693                                         have_lua=no
 694                                 ], -lm)
 695                         fi
 696                 fi
 697         fi
 698
 699         AC_WIRESHARK_POP_FLAGS
 700 ])
 701
 702 #
 703 # AC_WIRESHARK_LIBPORTAUDIO_CHECK
 704 #
 705 AC_DEFUN([AC_WIRESHARK_LIBPORTAUDIO_CHECK],[
 706
 707         AC_WIRESHARK_PUSH_FLAGS
 708         wireshark_save_LIBS="$LIBS"
 709
 710         if test "x$portaudio_dir" != "x"
 711         then
 712                 #
 713                 # The user specified a directory in which libportaudio
 714                 # resides, so add the "include" subdirectory of that directory to
 715                 # the include file search path and the "lib" subdirectory
 716                 # of that directory to the library search path.
 717                 #
 718                 # XXX - if there's also a libportaudio in a directory that's
 719                 # already in CPPFLAGS or LDFLAGS, this won't make us find
 720                 # the version in the specified directory, as the compiler
 721                 # and/or linker will search that other directory before it
 722                 # searches the specified directory.
 723                 #
 724                 CPPFLAGS="$CPPFLAGS -I$portaudio_dir/include"
 725                 LDFLAGS="$LDFLAGS -L$portaudio_dir/lib"
 726         fi
 727         LIBS="-lportaudio $LIBS"
 728
 729         #
 730         # Make sure we have "portaudio.h".  If we don't, it means we probably
 731         # don't have libportaudio, so don't use it.
 732         #
 733         AC_CHECK_HEADERS(portaudio.h,,
 734         [
 735                 if test "x$portaudio_dir" != "x"
 736                 then
 737                         #
 738                         # The user used "--with-portaudio=" to specify a directory
 739                         # containing libportaudio, but we didn't find the header file
 740                         # there; that either means they didn't specify the
 741                         # right directory or are confused about whether libportaudio
 742                         # is, in fact, installed.  Report the error and give up.
 743                         #
 744                         AC_MSG_ERROR([libportaudio header not found in directory specified in --with-portaudio])
 745                 else
 746                         if test "x$want_portaudio" = "xyes"
 747                         then
 748                                 #
 749                                 # The user tried to force us to use the library, but we
 750                                 # couldn't find the header file; report an error.
 751                                 #
 752                                 AC_MSG_ERROR(Header file portaudio.h not found.)
 753                         else
 754                                 #
 755                                 # We couldn't find the header file; don't use the
 756                                 # library, as it's probably not present.
 757                                 #
 758                                 want_portaudio=no
 759                         fi
 760                 fi
 761         ])
 762
 763         #
 764         # Check whether we have the right version of portaudio
 765         #
 766         if test "x$want_portaudio" != "xno"
 767         then
 768                 AC_CHECK_TYPE(PortAudioStream,
 769                 AC_DEFINE(PORTAUDIO_API_1, 1, [Define if we are using version of of the Portaudio library API]),
 770                 ,
 771                 [#include <portaudio.h>])
 772         fi
 773
 774         if test "x$want_portaudio" != "xno"
 775         then
 776                 #
 777                 # Well, we at least have the portaudio header file.
 778                 #
 779                 # let's check if the libs are there
 780                 #
 781                 PORTAUDIO_LIBS=""
 782                 PORTAUDIO_INCLUDES=""
 783
 784                 AC_CHECK_LIB(portaudio, Pa_Initialize,
 785                 [
 786                         if test "x$portaudio_dir" != "x"
 787                         then
 788                                 #
 789                                 # Put the "-I" and "-L" flags for portaudio
 790                                 # into PORTAUDIO_INCLUDES and PORTAUDIO_LIBS,
 791                                 # respectively.
 792                                 #
 793                                 PORTAUDIO_LIBS="-L$portaudio_dir/lib -lportaudio"
 794                                 PORTAUDIO_INCLUDES="-I$portaudio_dir/include"
 795                         else
 796                                 PORTAUDIO_LIBS="-lportaudio"
 797                         fi
 798                         AC_DEFINE(HAVE_LIBPORTAUDIO, 1, [Define to use libportaudio library])
 799                         want_portaudio=yes
 800                 ],[
 801                         # User requested --with-portaudio but it isn't available
 802                         if test "x$want_portaudio" = "xyes"
 803                         then
 804                                 AC_MSG_ERROR(Linking with libportaudio failed.)
 805                         fi
 806                         want_portaudio=no
 807                 ])
 808                 AC_SUBST(PORTAUDIO_LIBS)
 809                 AC_SUBST(PORTAUDIO_INCLUDES)
 810
 811         fi
 812
 813         LIBS="$wireshark_save_LIBS"
 814         AC_WIRESHARK_POP_FLAGS
 815 ])
 816
 817
 818 #
 819 # AC_WIRESHARK_C_ARES_CHECK
 820 #
 821 AC_DEFUN([AC_WIRESHARK_C_ARES_CHECK],
 822 [
 823         want_c_ares=defaultyes
 824
 825         if test "x$want_c_ares" = "xdefaultyes"; then
 826                 want_c_ares=yes
 827         fi
 828
 829         if test "x$want_c_ares" = "xyes"; then
 830                 AC_CHECK_LIB(cares, ares_init,
 831                   [
 832                     #
 833                     # Make sure we have c-ares 1.5 or later; we don't
 834                     # support the older API.
 835                     #
 836                     AC_MSG_CHECKING([whether we have c-ares 1.5 or later])
 837                     AC_TRY_COMPILE(
 838                       [
 839 #include <ares.h>
 840 #include <ares_version.h>
 841                       ],
 842                       [
 843 #if ((ARES_VERSION_MAJOR < 1) || \
 844     (1 == ARES_VERSION_MAJOR == 1 && ARES_VERSION_MINOR < 5))
 845 #error You lose
 846 #else
 847                         return 0;
 848 #endif
 849                       ],
 850                       [
 851                         AC_MSG_RESULT([yes])
 852                         C_ARES_LIBS=-lcares
 853                         AC_DEFINE(HAVE_C_ARES, 1, [Define to use c-ares library])
 854                         have_good_c_ares=yes
 855                       ],
 856                       [
 857                         AC_MSG_RESULT([no])
 858                         AC_MSG_ERROR([Pre-1.5 versions of c-ares aren't supported])
 859                       ])
 860                   ])
 861         else
 862                 AC_MSG_RESULT(not required)
 863         fi
 864 ])
 865
 866
 867 #
 868 # AC_WIRESHARK_LIBCAP_CHECK
 869 #
 870 AC_DEFUN([AC_WIRESHARK_LIBCAP_CHECK],
 871 [
 872         want_libcap=defaultyes
 873
 874         if test "x$want_libcap" = "xdefaultyes"; then
 875                 want_libcap=yes
 876         fi
 877
 878         if test "x$want_libcap" = "xyes"; then
 879                 AC_CHECK_LIB(cap, cap_set_flag,
 880                   [
 881                     LIBCAP_LIBS=-lcap
 882                     AC_DEFINE(HAVE_LIBCAP, 1, [Define to use the libcap library])
 883                     have_good_libcap=yes
 884                   ],,
 885                 )
 886         else
 887                 AC_MSG_RESULT(not required)
 888         fi
 889 ])
 890
 891
 892 #
 893 # AC_WIRESHARK_KRB5_CHECK
 894 #
 895 AC_DEFUN([AC_WIRESHARK_KRB5_CHECK],
 896 [
 897         AC_WIRESHARK_PUSH_FLAGS
 898         wireshark_save_LIBS="$LIBS"
 899
 900         if test "x$krb5_dir" != "x"
 901         then
 902           #
 903           # The user specified a directory in which kerberos resides,
 904           # so add the "include" subdirectory of that directory to
 905           # the include file search path and the "lib" subdirectory
 906           # of that directory to the library search path.
 907           #
 908           # XXX - if there's also a kerberos in a directory that's
 909           # already in CPPFLAGS or LDFLAGS, this won't make us find
 910           # the version in the specified directory, as the compiler
 911           # and/or linker will search that other directory before it
 912           # searches the specified directory.
 913           #
 914           KRB5_CFLAGS="-I$krb5_dir/include"
 915           ac_heimdal_version=`grep heimdal $krb5_dir/include/krb5.h | head -n 1 | sed 's/^.*heimdal.*$/HEIMDAL/'`
 916           # MIT Kerberos moved krb5.h to krb5/krb5.h starting with release 1.5
 917           ac_mit_version_olddir=`grep 'Massachusetts' $krb5_dir/include/krb5.h | head -n 1 | sed 's/^.*Massachusetts.*$/MIT/'`
 918           ac_mit_version_newdir=`grep 'Massachusetts' $krb5_dir/include/krb5/krb5.h | head -n 1 | sed 's/^.*Massachusetts.*$/MIT/'`
 919           ac_krb5_version="$ac_heimdal_version$ac_mit_version_olddir$ac_mit_version_newdir"
 920           if test "x$ac_krb5_version" = "xHEIMDAL"
 921           then
 922               KRB5_LIBS="-L$krb5_dir/lib -lkrb5 -lasn1 $SSL_LIBS -lroken -lcrypt"
 923           else
 924               KRB5_LIBS="-L$krb5_dir/lib -lkrb5 -lk5crypto -lcom_err"
 925           fi
 926           if test "x$ac_krb5_version" = "xMIT"
 927           then
 928             AC_DEFINE(HAVE_MIT_KERBEROS, 1, [Define to use MIT kerberos])
 929           fi
 930         else
 931           AC_PATH_TOOL(KRB5_CONFIG, krb5-config)
 932           if test -x "$KRB5_CONFIG"
 933           then
 934             KRB5_CFLAGS=`"$KRB5_CONFIG" --cflags`
 935             KRB5_LIBS=`"$KRB5_CONFIG" --libs`
 936             #
 937             # If -lcrypto is in KRB5_FLAGS, we require it to build
 938             # with Heimdal/MIT.  We don't want to built with it by
 939             # default, due to annoying license incompatibilities
 940             # between the OpenSSL license and the GPL, so:
 941             #
 942             #   if SSL_LIBS is set to a non-empty string, we
 943             #   remove -lcrypto from KRB5_LIBS and replace
 944             #   it with SSL_LIBS;
 945             #
 946             #   if SSL_LIBS is not set to a non-empty string
 947             #   we fail with an appropriate error message.
 948             #
 949             case "$KRB5_LIBS" in
 950             *-lcrypto*)
 951                 if test ! -z "$SSL_LIBS"
 952                 then
 953                     KRB5_LIBS=`echo $KRB5_LIBS | sed 's/-lcrypto//'`
 954                     KRB5_LIBS="$KRB5_LIBS $SSL_LIBS"
 955                 else
 956                     AC_MSG_ERROR([Kerberos library requires -lcrypto, so you must specify --with-ssl])
 957                 fi
 958                 ;;
 959             esac
 960             ac_krb5_version=`"$KRB5_CONFIG" --version | head -n 1 | sed -e 's/^.*heimdal.*$/HEIMDAL/' -e 's/^Kerberos .*$/MIT/' -e 's/^Solaris Kerberos .*$/MIT/'`
 961           fi
 962         fi
 963
 964         CPPFLAGS="$CPPFLAGS $KRB5_CFLAGS"
 965
 966         #
 967         # Make sure we have "krb5.h".  If we don't, it means we probably
 968         # don't have kerberos, so don't use it.
 969         #
 970         AC_CHECK_HEADER(krb5.h,,
 971           [
 972             if test "x$krb5_dir" != "x"
 973             then
 974               #
 975               # The user used "--with-krb5=" to specify a directory
 976               # containing kerberos, but we didn't find the header file
 977               # there; that either means they didn't specify the
 978               # right directory or are confused about whether kerberos
 979               # is, in fact, installed.  Report the error and give up.
 980               #
 981               AC_MSG_ERROR([kerberos header not found in directory specified in --with-krb5])
 982             else
 983               if test "x$want_krb5" = "xyes"
 984               then
 985                 #
 986                 # The user tried to force us to use the library, but we
 987                 # couldn't find the header file; report an error.
 988                 #
 989                 AC_MSG_ERROR(Header file krb5.h not found.)
 990               else
 991                 #
 992                 # We couldn't find the header file; don't use the
 993                 # library, as it's probably not present.
 994                 #
 995                 KRB5_CFLAGS=""
 996                 KRB5_LIBS=""
 997                 want_krb5=no
 998                 AC_MSG_RESULT(No Heimdal or MIT header found - disabling dissection for some kerberos data in packet decoding)
 999               fi
1000             fi
1001           ])
1002
1003         if test "x$want_krb5" != "xno"
1004         then
1005             #
1006             # Well, we at least have the krb5 header file.
1007             # Check whether this is Heimdal or MIT.
1008             #
1009             AC_MSG_CHECKING(whether the Kerberos library is Heimdal or MIT)
1010             if test "x$ac_krb5_version" = "xHEIMDAL" -o "x$ac_krb5_version" = "xMIT"
1011             then
1012                 #
1013                 # Yes.
1014                 # Check whether we have krb5_kt_resolve - and whether
1015                 # we need to link with -lresolv when linking with
1016                 # the Kerberos library.
1017                 #
1018                 AC_MSG_RESULT($ac_krb5_version)
1019                 found_krb5_kt_resolve=no
1020                 for extras in "" "-lresolv"
1021                 do
1022                     LIBS="$KRB5_LIBS $extras $wireshark_save_LIBS"
1023                     if test -z "$extras"
1024                     then
1025                         AC_MSG_CHECKING([whether $ac_krb5_version includes krb5_kt_resolve])
1026                     else
1027                         AC_MSG_CHECKING([whether $ac_krb5_version includes krb5_kt_resolve (linking with $extras)])
1028                     fi
1029                     AC_TRY_LINK(
1030                         [
1031 #       include <krb5.h>
1032                         ],
1033                         [
1034                             krb5_kt_resolve(0, 0, 0);
1035                         ],
1036                         [
1037                             #
1038                             # We found "krb5_kt_resolve()".
1039                             #
1040                             AC_MSG_RESULT(yes)
1041                             if test -n "$extras"; then
1042                               KRB5_LIBS="$KRB5_LIBS $extras"
1043                             fi
1044                             AC_DEFINE(HAVE_KERBEROS, 1, [Define to use kerberos])
1045                             if test "x$ac_krb5_version" = "xHEIMDAL"
1046                             then
1047                                 AC_DEFINE(HAVE_HEIMDAL_KERBEROS, 1, [Define to use heimdal kerberos])
1048                             elif test "x$ac_krb5_version" = "xMIT"
1049                             then
1050                                 AC_DEFINE(HAVE_MIT_KERBEROS, 1, [Define to use MIT kerberos])
1051                             fi
1052                             found_krb5_kt_resolve=yes
1053                             break
1054                         ],
1055                         [
1056                             AC_MSG_RESULT(no)
1057                         ])
1058                 done
1059                 if test "$found_krb5_kt_resolve" = no
1060                 then
1061                     #
1062                     # We didn't find "krb5_kt_resolve()" in the
1063                     # Kerberos library, even when we tried linking
1064                     # with -lresolv; we can't link with kerberos.
1065                     #
1066                     if test "x$want_krb5" = "xyes"
1067                     then
1068                         #
1069                         # The user tried to force us to use the library,
1070                         # but we can't do so; report an error.
1071                         #
1072                         AC_MSG_ERROR(Usable $ac_krb5_version not found)
1073                     else
1074                         #
1075                         # Don't use
1076                         #
1077                         AC_MSG_RESULT(Usable $ac_krb5_version not found - disabling dissection for some kerberos data in packet decoding)
1078                         KRB5_CFLAGS=""
1079                         KRB5_LIBS=""
1080                         want_krb5=no
1081                     fi
1082                 else
1083                     #
1084                     # We can link with Kerberos; see whether krb5.h
1085                     # defines KEYTYPE_ARCFOUR_56 (where "defines" means
1086                     # "as a #define or as an enum member).
1087                     #
1088                     AC_MSG_CHECKING([whether krb5.h defines KEYTYPE_ARCFOUR_56])
1089                     AC_COMPILE_IFELSE(
1090                       [
1091                         AC_LANG_SOURCE(
1092                           [[
1093                             #include <krb5.h>
1094                             #include <stdio.h>
1095
1096                             int main()
1097                             {
1098                               printf("%u\n", KEYTYPE_ARCFOUR_56);
1099                             }
1100                           ]])
1101                       ],
1102                       [
1103                         AC_MSG_RESULT(yes)
1104                         AC_DEFINE(HAVE_KEYTYPE_ARCFOUR_56, 1, [Define if krb5.h defines KEYTYPE_ARCFOUR_56])
1105                       ],
1106                       [
1107                         AC_MSG_RESULT(no)
1108                       ])
1109                 fi
1110             else
1111                 #
1112                 # It's not Heimdal or MIT.
1113                 #
1114                 AC_MSG_RESULT(no)
1115                 if test "x$want_krb5" = "xyes"
1116                 then
1117                     #
1118                     # The user tried to force us to use the library,
1119                     # but we can't do so; report an error.
1120                     #
1121                     AC_MSG_ERROR(Kerberos not found)
1122                 else
1123                     #
1124                     # Don't use.
1125                     #
1126                     AC_MSG_RESULT(Kerberos not found - disabling dissection for some kerberos data in packet decoding)
1127                     KRB5_CFLAGS=""
1128                     KRB5_LIBS=""
1129                     want_krb5=no
1130                 fi
1131             fi
1132         else
1133             #
1134             # The user asked us not to use Kerberos, or they didn't
1135             # say whether they wanted us to use it but we found
1136             # that we couldn't.
1137             #
1138             KRB5_CFLAGS=""
1139             KRB5_LIBS=""
1140             want_krb5=no
1141         fi
1142         AC_SUBST(KRB5_CFLAGS)
1143         AC_SUBST(KRB5_LIBS)
1144
1145         LIBS="$wireshark_save_LIBS"
1146         AC_WIRESHARK_POP_FLAGS
1147 ])
1148
1149 #
1150 # AC_WIRESHARK_GEOIP_CHECK
1151 #
1152 AC_DEFUN([AC_WIRESHARK_GEOIP_CHECK],
1153 [
1154         want_geoip=defaultyes
1155
1156         if test "x$want_geoip" = "xdefaultyes"; then
1157                 want_geoip=yes
1158         fi
1159
1160         if test "x$want_geoip" = "xyes"; then
1161                 AC_CHECK_LIB(GeoIP, GeoIP_new,
1162                   [
1163                     GEOIP_LIBS=-lGeoIP
1164                 AC_DEFINE(HAVE_GEOIP, 1, [Define to use GeoIP library])
1165                 have_good_geoip=yes
1166                   ],,
1167                 )
1168                 if test "x$have_good_geoip" = "xyes"; then
1169                         AC_CHECK_LIB(GeoIP, GeoIP_country_name_by_ipnum_v6,
1170                           [
1171                                 AC_DEFINE(HAVE_GEOIP_V6, 1, [Define if GeoIP supports IPv6 (GeoIP 1.4.5 and later)])
1172                           ],,
1173                         )
1174                         AC_CHECK_LIB(GeoIP, GeoIP_free,
1175                           [
1176                                 AC_DEFINE(HAVE_GEOIP_FREE, 1, [Define if GeoIP has GeoIP_free (not available upstream with 1.6.10 or earlier)])
1177                           ],,
1178                         )
1179                 fi
1180         else
1181                 AC_MSG_RESULT(not required)
1182         fi
1183 ])
1184
1185 #
1186 # AC_WIRESHARK_LIBSSH_CHECK
1187 #
1188 AC_DEFUN([AC_WIRESHARK_LIBSSH_CHECK],
1189 [
1190         want_libssh=defaultyes
1191
1192         if test "x$want_libssh" = "xdefaultyes"; then
1193                 want_libssh=yes
1194         fi
1195
1196         if test "x$want_libssh" = "xyes"; then
1197                 AC_CHECK_LIB(ssh, ssh_new,
1198                   [
1199                     LIBSSH_LIBS=-lssh
1200                         AC_DEFINE(HAVE_LIBSSH, 1, [Define to use libssh library])
1201                         have_good_libssh=yes
1202                   ],,
1203                 )
1204                 AC_MSG_CHECKING([whether libssh >= 0.6.0 for sshdump, ciscodump])
1205                 PKG_CHECK_EXISTS([libssh >= 0.6.0],
1206                   [
1207                    AC_MSG_RESULT(yes)
1208                    AC_DEFINE(HAVE_LIBSSH_POINTSIX, 1, [Defined if libssh >= 0.6.0])
1209                    have_libssh_pointsix=yes
1210                   ],
1211                   [AC_MSG_RESULT(no)]
1212                 )
1213                 if test "x$have_libssh_pointsix" = "xyes"; then
1214                         # ssh_userauth_agent exists only >= 0.6.0, but not on Windows
1215                         # so check explicitly
1216                         AC_CHECK_LIB(ssh, ssh_userauth_agent,
1217                           [
1218                             AC_DEFINE(HAVE_SSH_USERAUTH_AGENT, 1, [Libssh library has ssh_userauth_agent])
1219                             have_ssh_userauth_agent=yes
1220                           ],,
1221                         )
1222                 fi
1223         else
1224                 AC_MSG_RESULT(not required)
1225         fi
1226 ])
1227
1228 #
1229 # AC_WIRESHARK_NGHTTP2_CHECK
1230 #
1231 AC_DEFUN([AC_WIRESHARK_NGHTTP2_CHECK],
1232 [
1233         want_nghttp2=defaultyes
1234
1235         if test "x$want_nghttp2" = "xdefaultyes"; then
1236                 want_nghttp2=yes
1237         fi
1238
1239         if test "x$want_nghttp2" = "xyes"; then
1240                 AC_CHECK_LIB(nghttp2, nghttp2_hd_inflate_new,
1241                         [
1242                                 AC_CHECK_HEADERS(nghttp2/nghttp2.h,
1243                                         [
1244                                                 NGHTTP2_LIBS=-lnghttp2
1245                                                 AC_DEFINE(HAVE_NGHTTP2, 1, [Define to use nghttp2 library])
1246                                                 have_good_nghttp2=yes
1247                                         ],,
1248                                 )
1249                         ],,
1250                 )
1251         else
1252                 AC_MSG_RESULT(not required)
1253         fi
1254 ])
1255
1256 #AC_WIRESHARK_LDFLAGS_CHECK
1257 #
1258 # $1 : ldflag(s) to test
1259 #
1260 # We attempt to compile and link a test program with the specified linker
1261 # flag. The defined flag is added to LDFLAGS only if the link succeeds.
1262 #
1263 AC_DEFUN([AC_WIRESHARK_LDFLAGS_CHECK],
1264 [LD_OPTION="$1"
1265 AC_MSG_CHECKING(whether we can add $LD_OPTION to LDFLAGS)
1266 AC_WIRESHARK_PUSH_FLAGS
1267 LDFLAGS="$LDFLAGS $LD_OPTION"
1268 can_add_to_ldflags=""
1269 AC_LINK_IFELSE(
1270   [
1271     AC_LANG_SOURCE([[int main() { return 0; }]])
1272   ],
1273   [
1274     AC_MSG_RESULT(yes)
1275     AX_APPEND_FLAG([$LD_OPTION], [WS_LDFLAGS])
1276     can_add_to_ldflags=yes
1277   ],
1278   [
1279     AC_MSG_RESULT(no)
1280     can_add_to_ldflags=no
1281   ])
1282   AC_WIRESHARK_POP_FLAGS
1283 ])
1284
1285 dnl
1286 dnl Check whether, if you pass an unknown warning option to the
1287 dnl compiler, it fails or just prints a warning message and succeeds.
1288 dnl Set ac_wireshark_unknown_warning_option_error to the appropriate flag
1289 dnl to force an error if it would otherwise just print a warning message
1290 dnl and succeed.
1291 dnl
1292 AC_DEFUN([AC_WIRESHARK_CHECK_UNKNOWN_WARNING_OPTION_ERROR],
1293     [
1294         AC_MSG_CHECKING([whether the compiler fails when given an unknown warning option])
1295         AC_WIRESHARK_PUSH_FLAGS
1296         CFLAGS="$CFLAGS -Wxyzzy-this-will-never-succeed-xyzzy"
1297         AC_TRY_COMPILE(
1298             [],
1299             [return 0],
1300             [
1301                 AC_MSG_RESULT([no, adding -Werror=unknown-warning-option])
1302                 #
1303                 # We're assuming this is clang, where
1304                 # -Werror=unknown-warning-option is the appropriate
1305                 # option to force the compiler to fail.
1306                 #
1307                 ac_wireshark_unknown_warning_option_error="-Werror=unknown-warning-option"
1308             ],
1309             [
1310                 AC_MSG_RESULT([yes])
1311             ])
1312         AC_WIRESHARK_POP_FLAGS
1313     ])
1314
1315 dnl
1316 dnl Check whether, if you pass a valid-for-C-but-not-C++ option to the
1317 dnl compiler, it fails or just prints a warning message and succeeds.
1318 dnl Set ac_wireshark_non_cxx_warning_option_error to the appropriate flag
1319 dnl to force an error if it would otherwise just print a warning message
1320 dnl and succeed.
1321 dnl
1322 AC_DEFUN([AC_WIRESHARK_CHECK_NON_CXX_WARNING_OPTION_ERROR],
1323     [
1324         AC_MSG_CHECKING([whether the compiler fails when given an warning option not supported for C++])
1325         #
1326         # Some C+ compilers warn about -Wmissing-prototypes, and some warn
1327         # about -Wmissing-declarations.  Check both.
1328         #
1329         AC_LANG_PUSH(C++)
1330         AC_WIRESHARK_PUSH_FLAGS
1331         save_CXXFLAGS="$CXXFLAGS"
1332         for flag in -Wmissing-prototypes -Wmissing-declarations; do
1333             CXXFLAGS="$save_CXXFLAGS $flag"
1334             AC_TRY_COMPILE(
1335                 [],
1336                 [return 0],
1337                 [
1338                     #
1339                     # We're assuming this is g++, where -Werror is the
1340                     # appropriate option to force the compiler to fail.
1341                     # Check whether it fails with -Werror.
1342                     #
1343                     # NOTE: it's important to put -Werror *before*
1344                     # the flag, otherwise, when it sees the flag,
1345                     # it doesn't yet know that warnings should be
1346                     # treated as errors, and doesn't treat the
1347                     # "that's C-only" warning as an error.
1348                     #
1349                     CXXFLAGS="$save_CXXFLAGS -Werror $flag"
1350                     AC_TRY_COMPILE(
1351                         [],
1352                         [return 0],
1353                         [
1354                             #
1355                             # No, so this option is actually OK
1356                             # with our C++ compiler.
1357                             #
1358                             # (We need an empty command here to
1359                             # prevent some versions of autoconf
1360                             # from generating a script with an
1361                             # empty "then" clause for an if statement.)
1362                             #
1363                             :
1364                         ],
1365                         [
1366                             #
1367                             # Yes, so we need -Werror for the tests.
1368                             #
1369                             ac_wireshark_non_cxx_warning_option_error="-Werror"
1370                             break
1371                         ])
1372                 ])
1373         done
1374         AC_WIRESHARK_POP_FLAGS
1375         AC_LANG_POP
1376         if test x$ac_wireshark_non_cxx_warning_option_error = x; then
1377             AC_MSG_RESULT([yes])
1378         else
1379             AC_MSG_RESULT([no, adding -Werror])
1380         fi
1381     ])
1382
1383 #
1384 # AC_WIRESHARK_COMPILER_FLAGS_CHECK
1385 #
1386 # $1 : flags to test
1387 # $2 : if supplied, C for C-only flags, CXX for C++-only flags
1388 # $3 : if supplied, a program to try to compile with the flag
1389 #      and, if the compile fails when -Werror is turned on,
1390 #      we don't add the flag - used for warning flags that
1391 #      issue incorrect or non-useful warnings with some
1392 #      compiler versions
1393 # $4 : must be supplied if $3 is supplied - a message describing
1394 #      for what the test program is testing
1395 #
1396 # The macro first determines if the compiler supports GCC-style flags.
1397 # Then it attempts to compile with the defined cflags.  The defined
1398 # flags are added to WS_CHECKED_CFLAGS only if the compilation succeeds.
1399 # CFLAGS remains unchanged. can_add_to_cflags is set to "no" when the
1400 # flag is checked but unavailable. (Like-wise for CXXFLAGS.)
1401 #
1402 # We do this because not all such options are necessarily supported by
1403 # the version of the particular compiler we're using.
1404 #
1405 AC_DEFUN([AC_WIRESHARK_COMPILER_FLAGS_CHECK],
1406 [GCC_OPTION="$1"
1407 can_add_to_cflags=""
1408 can_add_to_cxxflags=""
1409 if test "x$ac_supports_gcc_flags" = "xyes" ; then
1410   if test "$2" != CXX ; then
1411     #
1412     # Not C++-only; if this can be added to the C compiler flags, add them.
1413     #
1414     # If the option begins with "-W", add
1415     # $ac_wireshark_unknown_warning_option_error to make sure that
1416     # we'll get an error if it's an unknown warning option; not all
1417     # compilers treat unknown warning options as errors (I'm looking at
1418     # you, clang).
1419     #
1420     # If the option begins with "-f" or "-m", add -Werror to make sure
1421     # that we'll get an error if we get "argument unused during compilation"
1422     # warnings, as those will either cause a failure for files compiled
1423     # with -Werror or annoying noise for files compiled without it.
1424     # (Yeah, you, clang.)
1425     #
1426     AC_MSG_CHECKING(whether we can add $GCC_OPTION to CFLAGS)
1427     AC_WIRESHARK_PUSH_FLAGS
1428     if expr "x$GCC_OPTION" : "x-W.*" >/dev/null
1429     then
1430       CFLAGS="$CFLAGS $ac_wireshark_unknown_warning_option_error $GCC_OPTION"
1431     elif expr "x$GCC_OPTION" : "x-f.*" >/dev/null
1432     then
1433       CFLAGS="$CFLAGS -Werror $GCC_OPTION"
1434     elif expr "x$GCC_OPTION" : "x-m.*" >/dev/null
1435     then
1436       CFLAGS="$CFLAGS -Werror $GCC_OPTION"
1437     else
1438       CFLAGS="$CFLAGS $GCC_OPTION"
1439     fi
1440     AC_COMPILE_IFELSE(
1441       [
1442         AC_LANG_SOURCE([[int foo;]])
1443       ],
1444       [
1445         AC_MSG_RESULT(yes)
1446         can_add_to_cflags=yes
1447         #
1448         # OK, do we have a test program?  If so, check
1449         # whether it fails with this option and -Werror,
1450         # and, if so, don't include it.
1451         #
1452         # We test arg 4 here because arg 3 is a program which
1453         # could contain quotes (breaking the comparison).
1454         #
1455         if test "x$4" != "x" ; then
1456           CFLAGS="$CFLAGS -Werror"
1457           AC_MSG_CHECKING(whether $GCC_OPTION $4)
1458           AC_COMPILE_IFELSE(
1459             [AC_LANG_SOURCE($3)],
1460             [
1461               AC_MSG_RESULT(no)
1462               #
1463               # Remove "force an error for a warning" options, if we
1464               # added them, by setting CFLAGS to the saved value plus
1465               # just the new option.
1466               #
1467               AX_APPEND_FLAG([$GCC_OPTION], [WS_CFLAGS])
1468               if test "$CC" = "$CC_FOR_BUILD"; then
1469                 #
1470                 # We're building the build tools with the same compiler
1471                 # with which we're building Wireshark, so add the flags
1472                 # to the flags for that compiler as well.
1473                 #
1474                 AX_APPEND_FLAG([$GCC_OPTION], [WS_CFLAGS_FOR_BUILD])
1475               fi
1476             ],
1477             [
1478               AC_MSG_RESULT(yes)
1479             ])
1480         else
1481           #
1482           # Remove "force an error for a warning" options, if we
1483           # added them, by setting CFLAGS to the saved value plus
1484           # just the new option.
1485           #
1486           AX_APPEND_FLAG([$GCC_OPTION], [WS_CFLAGS])
1487           if test "$CC" = "$CC_FOR_BUILD"; then
1488             #
1489             # We're building the build tools with the same compiler
1490             # with which we're building Wireshark, so add the flags
1491             # to the flags for that compiler as well.
1492             #
1493             AX_APPEND_FLAG([$GCC_OPTION], [WS_CFLAGS_FOR_BUILD])
1494           fi
1495         fi
1496       ],
1497       [
1498         AC_MSG_RESULT(no)
1499         can_add_to_cflags=no
1500       ])
1501       AC_WIRESHARK_POP_FLAGS
1502   fi
1503   #
1504   # Did we find a C++ compiler?
1505   #
1506   if test "x$CXX" != "x" ; then
1507     #
1508     # Yes.  Is this option only for the C compiler?
1509     #
1510     if test "$2" != C ; then
1511       #
1512       # Not C-only; if this option can be added to the C++ compiler
1513       # options, add it.
1514       #
1515       # If the option begins with "-W", add
1516       # $ac_wireshark_unknown_warning_option_error, as per the above, and
1517       # also add $ac_wireshark_non_cxx_warning_option_error, because at
1518       # lease some versions of g++ whine about -Wmissing-prototypes, the
1519       # fact that at least one of those versions refuses to warn about
1520       # function declarations without an earlier declaration nonwithstanding;
1521       # perhaps there's a reason not to warn about that with C++ even though
1522       # warning about it can be a Good Idea with C, but it's not obvious to
1523       # me).
1524       #
1525       # If the option begins with "-f" or "-m", add -Werror to make sure
1526       # that we'll get an error if we get "argument unused during compilation"
1527       # warnings, as those will either cause a failure for files compiled
1528       # with -Werror or annoying noise for files compiled without it.
1529       # (Yeah, you, clang++.)
1530       #
1531       AC_MSG_CHECKING(whether we can add $GCC_OPTION to CXXFLAGS)
1532       AC_WIRESHARK_PUSH_FLAGS
1533       if expr "x$GCC_OPTION" : "x-W.*" >/dev/null
1534       then
1535         CXXFLAGS="$CXXFLAGS $ac_wireshark_unknown_warning_option_error $ac_wireshark_non_cxx_warning_option_error $GCC_OPTION"
1536       elif expr "x$GCC_OPTION" : "x-f.*" >/dev/null
1537       then
1538         CXXFLAGS="$CXXFLAGS -Werror $GCC_OPTION"
1539       elif expr "x$GCC_OPTION" : "x-m.*" >/dev/null
1540       then
1541         CXXFLAGS="$CXXFLAGS -Werror $GCC_OPTION"
1542       else
1543         CXXFLAGS="$CXXFLAGS $GCC_OPTION"
1544       fi
1545       AC_LANG_PUSH([C++])
1546       AC_COMPILE_IFELSE(
1547         [
1548           AC_LANG_SOURCE([[int foo;]])
1549         ],
1550         [
1551           AC_MSG_RESULT(yes)
1552           can_add_to_cxxflags=yes
1553           #
1554           # OK, do we have a test program?  If so, check
1555           # whether it fails with this option and -Werror,
1556           # and, if so, don't include it.
1557           #
1558           # We test arg 4 here because arg 3 is a program which
1559           # could contain quotes (breaking the comparison).
1560           #
1561           if test "x$4" != "x" ; then
1562             CXXFLAGS="$CXXFLAGS -Werror"
1563             AC_MSG_CHECKING(whether $GCC_OPTION $4)
1564             AC_COMPILE_IFELSE(
1565               [AC_LANG_SOURCE($3)],
1566               [
1567                 AC_MSG_RESULT(no)
1568                 #
1569                 # Remove "force an error for a warning" options, if we
1570                 # added them, by setting CXXFLAGS to the saved value plus
1571                 # just the new option.
1572                 #
1573                 AX_APPEND_FLAG([$GCC_OPTION], [WS_CXXFLAGS])
1574               ],
1575               [
1576                 AC_MSG_RESULT(yes)
1577               ])
1578           else
1579             #
1580             # Remove "force an error for a warning" options, if we
1581             # added them, by setting CXXFLAGS to the saved value plus
1582             # just the new option.
1583             #
1584             AX_APPEND_FLAG([$GCC_OPTION], [WS_CXXFLAGS])
1585           fi
1586         ],
1587         [
1588           AC_MSG_RESULT(no)
1589           can_add_to_cxxflags=no
1590         ])
1591       AC_WIRESHARK_POP_FLAGS
1592       AC_LANG_POP([C++])
1593     fi
1594     if test "(" "$can_add_to_cflags" = "yes" -a "$can_add_to_cxxflags" = "no" ")" \
1595          -o "(" "$can_add_to_cflags" = "no" -a "$can_add_to_cxxflags" = "yes" ")"
1596     then
1597       #
1598       # Confusingly, some C++ compilers like -Wmissing-prototypes but
1599       # don't like -Wmissing-declarations and others like
1600       # -Wmissing-declarations but don't like -Wmissing-prototypes,
1601       # the fact that the corresponding C compiler likes both.  Don't
1602       # warn about them.
1603       #
1604       if test "(" x$GCC_OPTION != x-Wmissing-prototypes ")" \
1605            -a "(" x$GCC_OPTION != x-Wmissing-declarations ")"
1606       then
1607          AC_MSG_WARN([$CC and $CXX appear to be a mismatched pair])
1608       fi
1609     fi
1610   fi
1611 fi
1612 ])
1613
1614 # AC_WIRESHARK_GCC_FORTIFY_SOURCE_CHECK
1615 #
1616 # Checks if '-D_FORTIFY_SOURCE=...' is OK to use in CPPFLAGS.
1617 #  Use '-D_FORTIFY_SOURCE=...' in CPPFLAGS only if the GCC 'optimization level' is > 0.
1618 #  The use of '-D_FORTIFY_SOURCE=...' will cause a warning with at least some versions
1619 #    of glibc if the  GCC "optimization level" is 0 (default or -O or -O0)
1620 #    when using GCC to compile a source file which references the macro definition.
1621 #
1622 # See: http://gcc.gnu.org/ml/gcc-patches/2004-09/msg02055.html
1623 # See: http://sourceware.org/bugzilla/show_bug.cgi?id=13979
1624 #
1625 #   We'll use '-D_FORTIFY_SOURCE=2' only if there's no warning; Among other things this means
1626 #    that the  use of '-D_FORTIFY_SOURCE=2' with '-Werror' and '-O0' won't cause
1627 #    the compiler to stop on error.
1628 #   Assumption: CFLAGS already contains whatever optimization option including none) is
1629 #    to be used.
1630 #
1631
1632 AC_DEFUN([AC_WIRESHARK_GCC_FORTIFY_SOURCE_CHECK],
1633 [
1634 if test "x$GCC" = "xyes" -o "x$CC" = "xclang" ; then
1635   AC_MSG_CHECKING([whether -D_FORTIFY_SOURCE=2 can be used (without generating a warning)])
1636   AC_WIRESHARK_PUSH_FLAGS
1637   CFLAGS="$CFLAGS -Werror"
1638   CPPFLAGS="$CPPFLAGS -D_FORTIFY_SOURCE=2"
1639   AC_COMPILE_IFELSE([
1640     AC_LANG_SOURCE([[
1641                   #include <stdio.h>
1642                       int foo;
1643                   ]])],
1644                   [
1645                     AC_MSG_RESULT(yes)
1646                     AX_APPEND_FLAG([-D_FORTIFY_SOURCE=2], [WS_CPPFLAGS])
1647                   ],
1648                   [
1649                     AC_MSG_RESULT(no)
1650                   ])
1651   AC_WIRESHARK_POP_FLAGS
1652 fi
1653 ])
1654
1655 #
1656 # AC_WIRESHARK_GCC_SYSTEM_INCLUDE
1657 #
1658 # Replace -I include flag for -isystem in FLAGS argument
1659 #
1660 AC_DEFUN([AC_WIRESHARK_GCC_SYSTEM_INCLUDE],
1661 [
1662         if test "x$GCC" = "xyes" -o "x$CC" = "xclang" ; then
1663                 $1=`echo " $$1" \
1664                         | sed -e 's/  *-I *\// -isystem\//g' -e 's/^ *//'`
1665         fi
1666 ])
1667
1668 #
1669 # PKG_WIRESHARK_CHECK_SYSTEM_MODULES
1670 #
1671 AC_DEFUN([PKG_WIRESHARK_CHECK_SYSTEM_MODULES],
1672 [
1673         PKG_CHECK_MODULES($@)
1674         AC_WIRESHARK_GCC_SYSTEM_INCLUDE($1_CFLAGS)
1675 ])
1676
1677 # Based on AM_PATH_GTK in gtk-2.0.m4.
1678
1679 dnl AC_WIRESHARK_QT_MODULE_CHECK_WITH_QT_VERSION([MODULE, MINIMUM-VERSION,
1680 dnl     REQUESTED-MAJOR_VERSION, [ACTION-IF-FOUND, [ACTION-IF-NOT-FOUND]]])
1681 dnl Test for a particular Qt module, for a particular Qt major version,
1682 dnl and, if we find it add the flags and libraries for it to Qt_CFLAGS
1683 dnl and Qt_LIBS.
1684 dnl
1685 AC_DEFUN([AC_WIRESHARK_QT_MODULE_CHECK_WITH_QT_VERSION],
1686 [
1687         case "$3" in
1688
1689         4)
1690                 #
1691                 # Check for Qt 4.
1692                 #
1693                 modprefix="Qt"
1694                 #
1695                 # Version of the module we're checking for.
1696                 # Default to 4.0.0.
1697                 #
1698                 min_qt_version=ifelse([$2], ,4.0.0,$2)
1699                 ;;
1700
1701         5)
1702                 #
1703                 # Check for Qt 5.
1704                 #
1705                 modprefix="Qt5"
1706                 #
1707                 # Version of the module we're checking for.
1708                 # Default to 5.0.0.
1709                 #
1710                 min_qt_version=5.0.0
1711                 ;;
1712
1713         *)
1714                 AC_MSG_ERROR([Qt version $3 is not a known Qt version])
1715                 ;;
1716         esac
1717
1718         pkg_config_module="${modprefix}$1"
1719         AC_MSG_CHECKING(for $pkg_config_module - version >= $min_qt_version)
1720         if $PKG_CONFIG --atleast-version $min_qt_version $pkg_config_module; then
1721                 mod_version=`$PKG_CONFIG --modversion $pkg_config_module`
1722                 AC_MSG_RESULT(yes (version $mod_version))
1723                 mod_cflags=`$PKG_CONFIG --cflags $pkg_config_module`
1724                 AC_WIRESHARK_GCC_SYSTEM_INCLUDE(mod_cflags)
1725                 Qt_CFLAGS="$Qt_CFLAGS $mod_cflags"
1726                 Qt_LIBS="$Qt_LIBS `$PKG_CONFIG --libs $pkg_config_module`"
1727                 # Run Action-If-Found
1728                 ifelse([$4], , :, [$4])
1729         else
1730                 AC_MSG_RESULT(no)
1731                 # Run Action-If-Not-Found
1732                 ifelse([$5], , :, [$5])
1733         fi
1734 ])
1735
1736 dnl AC_WIRESHARK_QT_MODULE_CHECK([MODULE, MINIMUM-VERSION,
1737 dnl     REQUESTED-MAJOR_VERSION, [ACTION-IF-FOUND, [ACTION-IF-NOT-FOUND]]])
1738 dnl Test for a particular Qt module and add the flags and libraries
1739 dnl for it to Qt_CFLAGS and Qt_LIBS.
1740 dnl
1741 AC_DEFUN([AC_WIRESHARK_QT_MODULE_CHECK],
1742 [
1743         #
1744         # Prior to Qt 5, modules were named QtXXX.
1745         # In Qt 5, they're named Qt5XXX.
1746         # This will need to change to handle future major Qt releases.
1747         #
1748         case "$3" in
1749
1750         yes|unspecified)
1751                 #
1752                 # Check for all versions of Qt we support.
1753                 # Try the Qt 5 version first.
1754                 #
1755                 versions="5 4"
1756                 ;;
1757
1758         4)
1759                 #
1760                 # Check for Qt 4.
1761                 #
1762                 versions="4"
1763                 ;;
1764
1765         5)
1766                 #
1767                 # Check for Qt 5.
1768                 #
1769                 versions="5"
1770                 ;;
1771
1772         *)
1773                 AC_MSG_ERROR([Qt version $3 is not a known Qt version])
1774                 ;;
1775         esac
1776
1777         for version in $versions
1778         do
1779                 AC_WIRESHARK_QT_MODULE_CHECK_WITH_QT_VERSION($1, $2,
1780                     $version, [foundit=yes], [foundit=no])
1781                 if test "x$foundit" = "xyes"; then
1782                         break
1783                 fi
1784         done
1785
1786         if test "x$foundit" = "xyes"; then
1787                 # Remember which version of Qt we found
1788                 qt_version=$version
1789                 # Run Action-If-Found
1790                 ifelse([$4], , :, [$4])
1791         else
1792                 # Run Action-If-Not-Found
1793                 ifelse([$5], , :, [$5])
1794         fi
1795 ])
1796
1797 AC_DEFUN([AC_WIRESHARK_QT_ADD_PIC_IF_NEEDED],
1798 [
1799     AC_LANG_PUSH([C++])
1800         AC_WIRESHARK_PUSH_FLAGS
1801         CPPFLAGS="$CPPFLAGS $Qt_CFLAGS"
1802         AC_MSG_CHECKING([whether Qt works without -fPIC])
1803         AC_PREPROC_IFELSE(
1804                 [AC_LANG_SOURCE([[#include <QtCore>]])],
1805                 [AC_MSG_RESULT(yes)],
1806                 [
1807                         AC_MSG_RESULT(no)
1808                         AC_MSG_CHECKING([whether Qt works with -fPIC])
1809                         CPPFLAGS="$CPPFLAGS -fPIC"
1810                         AC_PREPROC_IFELSE(
1811                                 [AC_LANG_SOURCE([[#include <QtCore>]])],
1812                                 [
1813                                         AC_MSG_RESULT(yes)
1814                                         Qt_CFLAGS="$Qt_CFLAGS -fPIC"
1815                                 ],
1816                                 [
1817                                         AC_MSG_RESULT(no)
1818                                         AC_MSG_ERROR(Couldn't compile Qt without -fPIC nor with -fPIC)
1819                                 ])
1820                 ])
1821         AC_WIRESHARK_POP_FLAGS
1822     AC_LANG_POP([C++])
1823 ])
1824
1825 dnl AC_WIRESHARK_QT_CHECK([MINIMUM-VERSION, REQUESTED-MAJOR_VERSION,
1826 dnl     [ACTION-IF-FOUND, [ACTION-IF-NOT-FOUND]]])
1827 dnl Test for Qt and define Qt_CFLAGS and Qt_LIBS.
1828 dnl
1829 AC_DEFUN([AC_WIRESHARK_QT_CHECK],
1830 [
1831         qt_version_to_check="$2"
1832
1833         #
1834         # Check for the Core module; if we don't have that,
1835         # we don't have Qt.  If we *do* have it, we know what
1836         # version it is, so only check for that version of
1837         # other modules.
1838         #
1839         AC_WIRESHARK_QT_MODULE_CHECK(Core, $1, $qt_version_to_check,
1840             [
1841               qt_version_to_check=$qt_version
1842               QT_VERSION=$mod_version
1843               QT_VERSION_MAJOR=`echo "$QT_VERSION" | cut -f1 -d.`
1844               QT_VERSION_MINOR=`echo "$QT_VERSION" | cut -f2 -d.`
1845               QT_VERSION_MICRO=`echo "$QT_VERSION" | cut -f3 -d.`
1846
1847               # Qt 5.7 and later requires C++11
1848               AS_IF([test $QT_VERSION_MAJOR -eq 5 -a $QT_VERSION_MINOR -ge 7],
1849                 [AS_IF([test "$HAVE_CXX11" -eq 0], [AC_MSG_ERROR([Qt 5.7 and later requires C++11])])])
1850
1851             ],
1852             [no_qt=yes])
1853
1854         if test x"$no_qt" = x ; then
1855                 #
1856                 # We need the Gui module as well.
1857                 #
1858                 AC_WIRESHARK_QT_MODULE_CHECK(Gui, $1, $qt_version_to_check, ,
1859                     [no_qt=yes])
1860         fi
1861
1862         if test x"$no_qt" = x ; then
1863                 #
1864                 # Qt 5.0 appears to move the widgets out of Qt GUI
1865                 # to Qt Widgets; look for the Widgets module, but
1866                 # don't fail if we don't have it.
1867                 #
1868                 AC_WIRESHARK_QT_MODULE_CHECK(Widgets, $1, $qt_version_to_check)
1869
1870                 #
1871                 # Qt 5.0 also appears to move the printing support into
1872                 # the Qt PrintSupport module.
1873                 #
1874                 AC_WIRESHARK_QT_MODULE_CHECK(PrintSupport, $1, $qt_version_to_check)
1875
1876                 #
1877                 # Qt 5.0 added multimedia in the Qt
1878                 # Multimedia module.
1879                 #
1880                 have_qt_multimedia_lib=no
1881                 AC_WIRESHARK_QT_MODULE_CHECK(Multimedia, $1, $qt_version_to_check,
1882                         have_qt_multimedia_lib=yes
1883                         AC_DEFINE(QT_MULTIMEDIA_LIB, 1, [Define if we have QtMultimedia]))
1884
1885                 #
1886                 # While we're at it, look for QtMacExtras.  (Presumably
1887                 # if we're not building for macOS, it won't be present.)
1888                 #
1889                 # XXX - is there anything in QtX11Extras or QtWinExtras
1890                 # that we should be using?
1891                 #
1892                 AC_WIRESHARK_QT_MODULE_CHECK(MacExtras, $1, $qt_version_to_check,
1893                         AC_DEFINE(QT_MACEXTRAS_LIB, 1, [Define if we have QtMacExtras]))
1894
1895                 AC_WIRESHARK_QT_ADD_PIC_IF_NEEDED
1896
1897                 # Run Action-If-Found
1898                 ifelse([$3], , :, [$3])
1899         else
1900                 # Run Action-If-Not-Found
1901                 ifelse([$4], , :, [$4])
1902         fi
1903
1904 ])
1905
1906 dnl AC_WIRESHARK_QT_TOOL_CHECK([TOOLPATHVAR, TOOL, REQUESTED-MAJOR_VERSION])
1907 dnl Test for a particular Qt tool for some specific version of Qt
1908 dnl
1909 AC_DEFUN([AC_WIRESHARK_QT_TOOL_CHECK],
1910 [
1911         #
1912         # At least in some versions of Debian/Ubuntu, and perhaps
1913         # other OSes, the Qt build tools are just links to a
1914         # program called "qtchooser", and even if you want to
1915         # build with Qt 5, running the tool might give you the
1916         # Qt 4 version of the tool unless you run the tool with
1917         # a -qt=5 argument.
1918         #
1919         # So we look for qtchooser and, if we find it, use the
1920         # -qt={version} argument, otherwise we look for particular
1921         # tool versions using tool name suffixes.
1922         #
1923         AC_PATH_PROG(QTCHOOSER, qtchooser)
1924         if test ! -z "$QTCHOOSER"; then
1925                 #
1926                 # We found qtchooser; we assume that means that
1927                 # the tool is linked to qtchooser, so that we
1928                 # can run it with the -qt={version} flag to get
1929                 # the appropriate version of the tool.
1930                 #
1931                 AC_PATH_PROG($1, $2)
1932                 if test "x$$1" = x; then
1933                         #
1934                         # We can't build Qt Wireshark without that
1935                         # tool..
1936                         #
1937                         AC_MSG_ERROR(I couldn't find $2; make sure it's installed and in your path)
1938                 fi
1939
1940                 #
1941                 # Add the -qt={version} argument to it.
1942                 #
1943                 $1="$$1 -qt=$qt_version"
1944         else
1945                 #
1946                 # Annoyingly, on some Linux distros (e.g. Debian)
1947                 # the Qt 5 tools have no suffix and the Qt 4 tools
1948                 # have suffix -qt4. On other distros (e.g. openSUSE)
1949                 # the Qt 5 tools have suffix -qt5 and the Qt 4 tools
1950                 # have no suffix.
1951                 #
1952                 # So we check for the tool first with the -qtN suffix
1953                 # and then with no suffix.
1954                 #
1955                 AC_PATH_PROGS($1, [$2-qt$qt_version $2])
1956                 if test "x$$1" = x; then
1957                         #
1958                         # We can't build Qt Wireshark without that
1959                         # tool..
1960                         #
1961                         AC_MSG_ERROR(I couldn't find $2-qt$qt_version or $2; make sure it's installed and in your path)
1962                 fi
1963         fi
1964 ])
1965
1966 AC_DEFUN([AC_WIRESHARK_QT_TOOL_CHECK_LRELEASE],
1967 [
1968   AC_WIRESHARK_QT_TOOL_CHECK(LRELEASE, lrelease, $2)
1969   AC_MSG_CHECKING(whether lrelease -version works)
1970   lrelease_version=`$LRELEASE -version 2>&AS_MESSAGE_LOG_FD`
1971   AS_IF([test $? -ne 0],
1972     [
1973       AC_MSG_RESULT(no)
1974       AC_MSG_ERROR([$LRELEASE -version returned non-zero exit status])
1975     ])
1976   AC_MSG_RESULT([ok, $lrelease_version])
1977 ])
1978
1979 #
1980 # AC_WIRESHARK_LZ4_CHECK
1981 #
1982 AC_DEFUN([AC_WIRESHARK_LZ4_CHECK],
1983 [
1984         AC_WIRESHARK_PUSH_FLAGS
1985
1986         if test "x$lz4_dir" != "x"
1987         then
1988           #
1989           # The user specified a directory in which lz4 resides,
1990           # so add the "include" subdirectory of that directory to
1991           # the include file search path and the "lib" subdirectory
1992           # of that directory to the library search path.
1993           #
1994           # XXX - if there's also a lz4 in a directory that's
1995           # already in CPPFLAGS or LDFLAGS, this won't make us find
1996           # the version in the specified directory, as the compiler
1997           # and/or linker will search that other directory before it
1998           # searches the specified directory.
1999           #
2000           LZ4_CFLAGS="-I$lz4_dir/include"
2001         fi
2002
2003         #
2004         # Make sure we have "lz4.h".  If we don't, it means we probably
2005         # don't have lz4, so don't use it.
2006         #
2007         AC_CHECK_HEADER(lz4.h,,
2008           [
2009             if test "x$lz4_dir" != "x"
2010             then
2011               #
2012               # The user used "--with-lz4=" to specify a directory
2013               # containing lz4, but we didn't find the header file
2014               # there; that either means they didn't specify the
2015               # right directory or are confused about whether lz4
2016               # is, in fact, installed.  Report the error and give up.
2017               #
2018               AC_MSG_ERROR([lz4 header not found in directory specified in --with-lz4])
2019             else
2020               if test "x$want_lz4" = "xyes"
2021               then
2022                 #
2023                 # The user tried to force us to use the library, but we
2024                 # couldn't find the header file; report an error.
2025                 #
2026                 AC_MSG_ERROR(Header file lz4.h not found.)
2027               else
2028                 #
2029                 # We couldn't find the header file; don't use the
2030                 # library, as it's probably not present.
2031                 #
2032                 want_lz4=no
2033               fi
2034             fi
2035           ])
2036
2037         if test "x$want_lz4" != "xno"
2038         then
2039                 #
2040                 # Well, we at least have the lz4 header file.
2041                 # We link with lz4 to support uncompression of
2042                 # CQL traffic.
2043                 #
2044                 LZ4_LIBS="-llz4"
2045                 ac_save_LIBS="$LIBS"
2046                 LIBS="$LZ4_LIBS $LIBS"
2047                 AC_DEFINE(HAVE_LZ4, 1, [Define to use lz4 library])
2048                 #
2049                 # Check for "LZ4_decompress_safe()" in lz4, which we need
2050                 # in order to read compressed capture files.
2051                 #
2052                 AC_CHECK_FUNCS(LZ4_decompress_safe)
2053                 LIBS="$ac_save_LIBS"
2054         fi
2055
2056         AC_WIRESHARK_POP_FLAGS
2057 ])
2058
2059 #
2060 # AC_WIRESHARK_SNAPPY_CHECK
2061 #
2062 AC_DEFUN([AC_WIRESHARK_SNAPPY_CHECK],
2063 [
2064         AC_WIRESHARK_PUSH_FLAGS
2065
2066         if test "x$snappy_dir" != "x"
2067         then
2068           #
2069           # The user specified a directory in which snappy resides,
2070           # so add the "include" subdirectory of that directory to
2071           # the include file search path and the "lib" subdirectory
2072           # of that directory to the library search path.
2073           #
2074           # XXX - if there's also a snappy in a directory that's
2075           # already in CPPFLAGS or LDFLAGS, this won't make us find
2076           # the version in the specified directory, as the compiler
2077           # and/or linker will search that other directory before it
2078           # searches the specified directory.
2079           #
2080           SNAPPY_CFLAGS="-I$snappy_dir/include"
2081         fi
2082
2083         #
2084         # Make sure we have "snappy-c.h".  If we don't, it means we probably
2085         # don't have snappy, so don't use it.
2086         #
2087         AC_CHECK_HEADER(snappy-c.h,,
2088           [
2089             if test "x$snappy_dir" != "x"
2090             then
2091               #
2092               # The user used "--with-snappy=" to specify a directory
2093               # containing snappy, but we didn't find the header file
2094               # there; that either means they didn't specify the
2095               # right directory or are confused about whether snappy
2096               # is, in fact, installed.  Report the error and give up.
2097               #
2098               AC_MSG_ERROR([snappy-c.header not found in directory specified in --with-snappy])
2099             else
2100               if test "x$want_snappy" = "xyes"
2101               then
2102                 #
2103                 # The user tried to force us to use the library, but we
2104                 # couldn't find the header file; report an error.
2105                 #
2106                 AC_MSG_ERROR(Header file snappy-c.h not found.)
2107               else
2108                 #
2109                 # We couldn't find the header file; don't use the
2110                 # library, as it's probably not present.
2111                 #
2112                 want_snappy=no
2113               fi
2114             fi
2115           ])
2116
2117         if test "x$want_snappy" != "xno"
2118         then
2119                 #
2120                 # Well, we at least have the snappy-c.header file.
2121                 # We link with snappy to support uncompression of
2122                 # compressed CQL traffic.
2123                 #
2124                 SNAPPY_LIBS=-lsnappy
2125                 ac_save_LIBS="$LIBS"
2126                 LIBS="$SNAPPY_LIBS $LIBS"
2127                 AC_DEFINE(HAVE_SNAPPY, 1, [Define to use snappy library])
2128                 #
2129                 # Check for "snappy_uncompress()" in snappy, which we need
2130                 # in order to read compressed capture files.
2131                 #
2132                 AC_CHECK_FUNCS(snappy_uncompress)
2133                 LIBS="$ac_save_LIBS"
2134         fi
2135
2136         AC_WIRESHARK_POP_FLAGS
2137 ])
2138
2139 #
2140 # AC_WIRESHARK_BCG729_CHECK
2141 #
2142 AC_DEFUN([AC_WIRESHARK_BCG729_CHECK],
2143 [
2144         want_bcg729=defaultyes
2145
2146         if test "x$want_bcg729" = "xdefaultyes"; then
2147                 want_bcg729=yes
2148         fi
2149
2150         if test "x$want_bcg729" = "xyes"; then
2151                 AC_CHECK_LIB(bcg729, bcg729Decoder,
2152                         [
2153                                 AC_CHECK_HEADERS(bcg729/decoder.h,
2154                                         [
2155                                                 BCG729_LIBS=-lbcg729
2156                                                 AC_DEFINE(HAVE_BCG729, 1, [Define to use bcg729 library])
2157                                                 have_good_bcg729=yes
2158                                         ],,
2159                                 )
2160                         ],,
2161                 )
2162         else
2163                 AC_MSG_RESULT(not required)
2164         fi
2165 ])