mpack-1.6-4/cmulocal/kerberos_v4.m4

dnl kerberos_v4.m4--Kerberos 4 libraries and includes
dnl Derrick Brashear
dnl from KTH krb and Arla
dnl $Id: kerberos_v4.m4,v 1.25 2002/12/29 05:13:02 cg2v Exp $

AC_DEFUN(CMU_KRB_SENDAUTH_PROTO, [
AC_MSG_CHECKING(for krb_sendauth prototype)
AC_TRY_COMPILE(
[#include <krb.h>
int krb_sendauth (long options, int fd, KTEXT ktext, char *service,
                  char *inst, char *realm, u_long checksum,
                  MSG_DAT *msg_data, CREDENTIALS *cred,
                  Key_schedule schedule, struct sockaddr_in *laddr,
                  struct sockaddr_in *faddr, char *version);],
[int foo = krb_sendauth(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); ],
ac_cv_krb_sendauth_proto=no,
ac_cv_krb_sendauth_proto=yes)
AC_MSG_RESULT($ac_cv_krb_sendauth_proto)
if test "$ac_cv_krb_sendauth_proto" = yes; then
        AC_DEFINE(HAVE_KRB_SENDAUTH_PROTO)dnl
fi
AC_MSG_RESULT($ac_cv_krb_sendauth_proto)
])

AC_DEFUN(CMU_KRB_SET_KEY_PROTO, [
AC_MSG_CHECKING(for krb_set_key prototype)
AC_CACHE_VAL(ac_cv_krb_set_key_proto, [
cmu_save_CPPFLAGS="$CPPFLAGS"
CPPFLAGS="${CPPFLAGS} ${KRB_INC_FLAGS}"
AC_TRY_COMPILE(
[#include <krb.h>
int krb_set_key(char *key, int cvt);],
[int foo = krb_set_key(0, 0);],
ac_cv_krb_set_key_proto=no,
ac_cv_krb_set_key_proto=yes)
])
CPPFLAGS="${cmu_save_CPPFLAGS}"
if test "$ac_cv_krb_set_key_proto" = yes; then
        AC_DEFINE(HAVE_KRB_SET_KEY_PROTO)dnl
fi
AC_MSG_RESULT($ac_cv_krb_set_key_proto)
])

AC_DEFUN(CMU_KRB4_32_DEFN, [
AC_MSG_CHECKING(for KRB4_32 definition)
AC_CACHE_VAL(ac_cv_krb4_32_defn, [
cmu_save_CPPFLAGS="$CPPFLAGS"
CPPFLAGS="${CPPFLAGS} ${KRB_INC_FLAGS}"
AC_TRY_COMPILE(
[#include <krb.h>
],
[KRB4_32 foo = 1;],
ac_cv_krb4_32_defn=yes,
ac_cv_krb4_32_defn=no)
])
CPPFLAGS="${cmu_save_CPPFLAGS}"
if test "$ac_cv_krb4_32_defn" = yes; then
        AC_DEFINE(HAVE_KRB4_32_DEFINE)dnl
fi
AC_MSG_RESULT($ac_cv_krb4_32_defn)
])

AC_DEFUN(CMU_KRB_RD_REQ_PROTO, [
AC_MSG_CHECKING(for krb_rd_req prototype)
AC_CACHE_VAL(ac_cv_krb_rd_req_proto, [
cmu_save_CPPFLAGS="$CPPFLAGS"
CPPFLAGS="${CPPFLAGS} ${KRB_INC_FLAGS}"
AC_TRY_COMPILE(
[#include <krb.h>
int krb_rd_req(KTEXT authent, char *service, char *instance,
unsigned KRB_INT32 from_addr, AUTH_DAT *ad, char *fn);],
[int foo = krb_rd_req(0,0,0,0,0,0);],
ac_cv_krb_rd_req_proto=no,
ac_cv_krb_rd_req_proto=yes)
])
CPPFLAGS="${cmu_save_CPPFLAGS}"
if test "$ac_cv_krb_rd_req_proto" = yes; then
        AC_DEFINE(HAVE_KRB_RD_REQ_PROTO)dnl
fi
AC_MSG_RESULT($ac_cv_krb_rd_req_proto)
])

AC_DEFUN(CMU_KRB_INC_WHERE1, [
saved_CPPFLAGS=$CPPFLAGS
CPPFLAGS="$saved_CPPFLAGS -I$1"
AC_TRY_COMPILE([#include <krb.h>],
[struct ktext foo;],
ac_cv_found_krb_inc=yes,
ac_cv_found_krb_inc=no)
if test "$ac_cv_found_krb_inc" = "no"; then
  CPPFLAGS="$saved_CPPFLAGS -I$1 -I$1/kerberosIV"
  AC_TRY_COMPILE([#include <krb.h>],
  [struct ktext foo;],
  [ac_cv_found_krb_inc=yes],
  ac_cv_found_krb_inc=no)
fi
CPPFLAGS=$saved_CPPFLAGS
])

AC_DEFUN(CMU_KRB_INC_WHERE, [
   for i in $1; do
      AC_MSG_CHECKING(for kerberos headers in $i)
      CMU_KRB_INC_WHERE1($i)
      CMU_TEST_INCPATH($i, krb)
      if test "$ac_cv_found_krb_inc" = "yes"; then
        ac_cv_krb_where_inc=$i
        AC_MSG_RESULT(found)
        break
      else
        AC_MSG_RESULT(not found)
      fi
    done
])

#
# Test for kerberos lib files
#

AC_DEFUN(CMU_KRB_LIB_WHERE1, [
saved_LIBS=$LIBS
LIBS="$saved_LIBS -L$1 -lkrb $KRB_LIBDES"
AC_TRY_LINK(,
[dest_tkt();],
[ac_cv_found_krb_lib=yes],
ac_cv_found_krb_lib=no)
LIBS=$saved_LIBS
])

AC_DEFUN(CMU_KRB_LIB_WHERE, [
   for i in $1; do
      AC_MSG_CHECKING(for kerberos libraries in $i)
      CMU_KRB_LIB_WHERE1($i)
      dnl deal with false positives from implicit link paths
      CMU_TEST_LIBPATH($i, krb)
      if test "$ac_cv_found_krb_lib" = "yes" ; then
        ac_cv_krb_where_lib=$i
        AC_MSG_RESULT(found)
        break
      else
        AC_MSG_RESULT(not found)
      fi
    done
])

AC_DEFUN(CMU_KRB4, [
AC_REQUIRE([CMU_SOCKETS])
AC_REQUIRE([CMU_LIBSSL])
AC_ARG_WITH(krb4,
        [  --with-krb4=PREFIX      Compile with Kerberos 4 support],
        [if test "X$with_krb4" = "X"; then
                with_krb4=yes
        fi])
AC_ARG_WITH(krb4-lib,
        [  --with-krb4-lib=dir     use kerberos 4 libraries in dir],
        [if test "$withval" = "yes" -o "$withval" = "no"; then
                AC_MSG_ERROR([No argument for --with-krb4-lib])
        fi])
AC_ARG_WITH(krb4-include,
        [  --with-krb4-include=dir use kerberos 4 headers in dir],
        [if test "$withval" = "yes" -o "$withval" = "no"; then
                AC_MSG_ERROR([No argument for --with-krb4-include])
        fi])

        if test "X$with_krb4" != "X"; then
          if test "$with_krb4" != "yes" -a "$with_krb4" != "no"; then
            ac_cv_krb_where_lib=$with_krb4/lib
            ac_cv_krb_where_inc=$with_krb4/include
          fi
        fi

        if test "$with_krb4" != "no"; then
          if test "X$with_krb4_lib" != "X"; then
            ac_cv_krb_where_lib=$with_krb4_lib
          fi
          if test "X$with_krb4_include" != "X"; then
            ac_cv_krb_where_inc=$with_krb4_include
          fi
          if test "X$ac_cv_krb_where_inc" = "X"; then
            CMU_KRB_INC_WHERE(/usr/athena/include /usr/include/kerberosIV /usr/local/include /usr/include/kerberos)
          fi
        fi

          AC_MSG_CHECKING([if libdes is needed])
          AC_TRY_LINK([],[des_quad_cksum();],KRB_DES_LIB="",KRB_DES_LIB="maybe")
          if test "X$KRB_DES_LIB" != "X"; then
              LIBS="$cmu_save_LIBS -ldes"
              AC_TRY_LINK([], [des_quad_cksum();],KRB_DES_LIB="yes")
              if test "X$KRB_DES_LIB" = "Xyes"; then
                  AC_MSG_RESULT([yes])
                  KRB_LIBDES="-ldes"
                  KRB_LIBDESA="${KRB_LIB_DIR}/libdes.a"
              else
                  LIBS="$cmu_save_LIBS $LIBSSL_LIB_FLAGS"
                  AC_TRY_LINK([],
                  [des_quad_cksum();],KRB_DES_LIB="libcrypto")
                  if test "X$KRB_DES_LIB" = "Xlibcrypto"; then
                      AC_MSG_RESULT([libcrypto])
                      KRB_LIBDES="$LIBSSL_LIB_FLAGS"
                      KRB_LIBDESA="$LIBSSL_LIB_FLAGS"
                  else
                      AC_MSG_RESULT([unknown])
                      AC_MSG_ERROR([Could not use -ldes])
                  fi 
              fi 
          else
             AC_MSG_RESULT([no])
          fi
          LIBS="${cmu_save_LIBS}"

          if test "X$ac_cv_krb_where_lib" = "X"; then
            CMU_KRB_LIB_WHERE(/usr/athena/lib /usr/local/lib /usr/lib)
          fi

        AC_MSG_CHECKING(whether to include kerberos 4)
        if test "X$ac_cv_krb_where_lib" = "X" -o "X$ac_cv_krb_where_inc" = "X"; then
          ac_cv_found_krb=no
          AC_MSG_RESULT(no)
        else
          ac_cv_found_krb=yes
          AC_MSG_RESULT(yes)
          KRB_INC_DIR=$ac_cv_krb_where_inc
          KRB_LIB_DIR=$ac_cv_krb_where_lib
          KRB_INC_FLAGS="-I${KRB_INC_DIR}"
          KRB_LIB_FLAGS="-L${KRB_LIB_DIR} -lkrb ${KRB_LIBDES}"
          LIBS="${cmu_save_LIBS} ${KRB_LIB_FLAGS}"
          AC_CHECK_LIB(resolv, dns_lookup, KRB_LIB_FLAGS="${KRB_LIB_FLAGS} -lresolv",,"${KRB_LIB_FLAGS}")
          AC_CHECK_LIB(crypt, crypt, KRB_LIB_FLAGS="${KRB_LIB_FLAGS} -lcrypt",,"${KRB_LIB_FLAGS}")
          AC_CHECK_FUNCS(krb_get_int krb_life_to_time)
          AC_SUBST(KRB_INC_FLAGS)
          AC_SUBST(KRB_LIB_FLAGS)
          LIBS="${cmu_save_LIBS}"
          AC_DEFINE(KERBEROS,,[Use kerberos 4. find out what needs this symbol])
          if test "X$RPATH" = "X"; then
                RPATH=""
          fi
          case "${host}" in
            *-*-linux*)
              if test "X$RPATH" = "X"; then
                RPATH="-Wl,-rpath,${KRB_LIB_DIR}"
              else 
                RPATH="${RPATH}:${KRB_LIB_DIR}"
              fi
              ;;
            *-*-hpux*)
              if test "X$RPATH" = "X"; then
                RPATH="-Wl,+b${KRB_LIB_DIR}"
              else 
                RPATH="${RPATH}:${KRB_LIB_DIR}"
              fi
              ;;
            *-*-irix*)
              if test "X$RPATH" = "X"; then
                RPATH="-Wl,-rpath,${KRB_LIB_DIR}"
              else 
                RPATH="${RPATH}:${KRB_LIB_DIR}"
              fi
              ;;
            *-*-solaris2*)
              if test "$ac_cv_prog_gcc" = yes; then
                if test "X$RPATH" = "X"; then
                  RPATH="-Wl,-R${KRB_LIB_DIR}"
                else 
                  RPATH="${RPATH}:${KRB_LIB_DIR}"
                fi
              else
                RPATH="${RPATH} -R${KRB_LIB_DIR}"
              fi
              ;;
          esac
          AC_SUBST(RPATH)
        fi
        ])
1	jmc	1.1	dnl kerberos_v4.m4--Kerberos 4 libraries and includes
2			dnl Derrick Brashear
3			dnl from KTH krb and Arla
4			dnl $Id: kerberos_v4.m4,v 1.25 2002/12/29 05:13:02 cg2v Exp $
5
6			AC_DEFUN(CMU_KRB_SENDAUTH_PROTO, [
7			AC_MSG_CHECKING(for krb_sendauth prototype)
8			AC_TRY_COMPILE(
9			[#include <krb.h>
10			int krb_sendauth (long options, int fd, KTEXT ktext, char *service,
11			char inst, char realm, u_long checksum,
12			MSG_DAT msg_data, CREDENTIALS cred,
13			Key_schedule schedule, struct sockaddr_in *laddr,
14			struct sockaddr_in faddr, char version);],
15			[int foo = krb_sendauth(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); ],
16			ac_cv_krb_sendauth_proto=no,
17			ac_cv_krb_sendauth_proto=yes)
18			AC_MSG_RESULT($ac_cv_krb_sendauth_proto)
19			if test "$ac_cv_krb_sendauth_proto" = yes; then
20			AC_DEFINE(HAVE_KRB_SENDAUTH_PROTO)dnl
21			fi
22			AC_MSG_RESULT($ac_cv_krb_sendauth_proto)
23			])
24
25			AC_DEFUN(CMU_KRB_SET_KEY_PROTO, [
26			AC_MSG_CHECKING(for krb_set_key prototype)
27			AC_CACHE_VAL(ac_cv_krb_set_key_proto, [
28			cmu_save_CPPFLAGS="$CPPFLAGS"
29			CPPFLAGS="${CPPFLAGS} ${KRB_INC_FLAGS}"
30			AC_TRY_COMPILE(
31			[#include <krb.h>
32			int krb_set_key(char *key, int cvt);],
33			[int foo = krb_set_key(0, 0);],
34			ac_cv_krb_set_key_proto=no,
35			ac_cv_krb_set_key_proto=yes)
36			])
37			CPPFLAGS="${cmu_save_CPPFLAGS}"
38			if test "$ac_cv_krb_set_key_proto" = yes; then
39			AC_DEFINE(HAVE_KRB_SET_KEY_PROTO)dnl
40			fi
41			AC_MSG_RESULT($ac_cv_krb_set_key_proto)
42			])
43
44			AC_DEFUN(CMU_KRB4_32_DEFN, [
45			AC_MSG_CHECKING(for KRB4_32 definition)
46			AC_CACHE_VAL(ac_cv_krb4_32_defn, [
47			cmu_save_CPPFLAGS="$CPPFLAGS"
48			CPPFLAGS="${CPPFLAGS} ${KRB_INC_FLAGS}"
49			AC_TRY_COMPILE(
50			[#include <krb.h>
51			],
52			[KRB4_32 foo = 1;],
53			ac_cv_krb4_32_defn=yes,
54			ac_cv_krb4_32_defn=no)
55			])
56			CPPFLAGS="${cmu_save_CPPFLAGS}"
57			if test "$ac_cv_krb4_32_defn" = yes; then
58			AC_DEFINE(HAVE_KRB4_32_DEFINE)dnl
59			fi
60			AC_MSG_RESULT($ac_cv_krb4_32_defn)
61			])
62
63			AC_DEFUN(CMU_KRB_RD_REQ_PROTO, [
64			AC_MSG_CHECKING(for krb_rd_req prototype)
65			AC_CACHE_VAL(ac_cv_krb_rd_req_proto, [
66			cmu_save_CPPFLAGS="$CPPFLAGS"
67			CPPFLAGS="${CPPFLAGS} ${KRB_INC_FLAGS}"
68			AC_TRY_COMPILE(
69			[#include <krb.h>
70			int krb_rd_req(KTEXT authent, char service, char instance,
71			unsigned KRB_INT32 from_addr, AUTH_DAT ad, char fn);],
72			[int foo = krb_rd_req(0,0,0,0,0,0);],
73			ac_cv_krb_rd_req_proto=no,
74			ac_cv_krb_rd_req_proto=yes)
75			])
76			CPPFLAGS="${cmu_save_CPPFLAGS}"
77			if test "$ac_cv_krb_rd_req_proto" = yes; then
78			AC_DEFINE(HAVE_KRB_RD_REQ_PROTO)dnl
79			fi
80			AC_MSG_RESULT($ac_cv_krb_rd_req_proto)
81			])
82
83			AC_DEFUN(CMU_KRB_INC_WHERE1, [
84			saved_CPPFLAGS=$CPPFLAGS
85			CPPFLAGS="$saved_CPPFLAGS -I$1"
86			AC_TRY_COMPILE([#include <krb.h>],
87			[struct ktext foo;],
88			ac_cv_found_krb_inc=yes,
89			ac_cv_found_krb_inc=no)
90			if test "$ac_cv_found_krb_inc" = "no"; then
91			CPPFLAGS="$saved_CPPFLAGS -I$1 -I$1/kerberosIV"
92			AC_TRY_COMPILE([#include <krb.h>],
93			[struct ktext foo;],
94			[ac_cv_found_krb_inc=yes],
95			ac_cv_found_krb_inc=no)
96			fi
97			CPPFLAGS=$saved_CPPFLAGS
98			])
99
100			AC_DEFUN(CMU_KRB_INC_WHERE, [
101			for i in $1; do
102			AC_MSG_CHECKING(for kerberos headers in $i)
103			CMU_KRB_INC_WHERE1($i)
104			CMU_TEST_INCPATH($i, krb)
105			if test "$ac_cv_found_krb_inc" = "yes"; then
106			ac_cv_krb_where_inc=$i
107			AC_MSG_RESULT(found)
108			break
109			else
110			AC_MSG_RESULT(not found)
111			fi
112			done
113			])
114
115			#
116			# Test for kerberos lib files
117			#
118
119			AC_DEFUN(CMU_KRB_LIB_WHERE1, [
120			saved_LIBS=$LIBS
121			LIBS="$saved_LIBS -L$1 -lkrb $KRB_LIBDES"
122			AC_TRY_LINK(,
123			[dest_tkt();],
124			[ac_cv_found_krb_lib=yes],
125			ac_cv_found_krb_lib=no)
126			LIBS=$saved_LIBS
127			])
128
129			AC_DEFUN(CMU_KRB_LIB_WHERE, [
130			for i in $1; do
131			AC_MSG_CHECKING(for kerberos libraries in $i)
132			CMU_KRB_LIB_WHERE1($i)
133			dnl deal with false positives from implicit link paths
134			CMU_TEST_LIBPATH($i, krb)
135			if test "$ac_cv_found_krb_lib" = "yes" ; then
136			ac_cv_krb_where_lib=$i
137			AC_MSG_RESULT(found)
138			break
139			else
140			AC_MSG_RESULT(not found)
141			fi
142			done
143			])
144
145			AC_DEFUN(CMU_KRB4, [
146			AC_REQUIRE([CMU_SOCKETS])
147			AC_REQUIRE([CMU_LIBSSL])
148			AC_ARG_WITH(krb4,
149			[ --with-krb4=PREFIX Compile with Kerberos 4 support],
150			[if test "X$with_krb4" = "X"; then
151			with_krb4=yes
152			fi])
153			AC_ARG_WITH(krb4-lib,
154			[ --with-krb4-lib=dir use kerberos 4 libraries in dir],
155			[if test "$withval" = "yes" -o "$withval" = "no"; then
156			AC_MSG_ERROR([No argument for --with-krb4-lib])
157			fi])
158			AC_ARG_WITH(krb4-include,
159			[ --with-krb4-include=dir use kerberos 4 headers in dir],
160			[if test "$withval" = "yes" -o "$withval" = "no"; then
161			AC_MSG_ERROR([No argument for --with-krb4-include])
162			fi])
163
164			if test "X$with_krb4" != "X"; then
165			if test "$with_krb4" != "yes" -a "$with_krb4" != "no"; then
166			ac_cv_krb_where_lib=$with_krb4/lib
167			ac_cv_krb_where_inc=$with_krb4/include
168			fi
169			fi
170
171			if test "$with_krb4" != "no"; then
172			if test "X$with_krb4_lib" != "X"; then
173			ac_cv_krb_where_lib=$with_krb4_lib
174			fi
175			if test "X$with_krb4_include" != "X"; then
176			ac_cv_krb_where_inc=$with_krb4_include
177			fi
178			if test "X$ac_cv_krb_where_inc" = "X"; then
179			CMU_KRB_INC_WHERE(/usr/athena/include /usr/include/kerberosIV /usr/local/include /usr/include/kerberos)
180			fi
181			fi
182
183			AC_MSG_CHECKING([if libdes is needed])
184			AC_TRY_LINK([],[des_quad_cksum();],KRB_DES_LIB="",KRB_DES_LIB="maybe")
185			if test "X$KRB_DES_LIB" != "X"; then
186			LIBS="$cmu_save_LIBS -ldes"
187			AC_TRY_LINK([], [des_quad_cksum();],KRB_DES_LIB="yes")
188			if test "X$KRB_DES_LIB" = "Xyes"; then
189			AC_MSG_RESULT([yes])
190			KRB_LIBDES="-ldes"
191			KRB_LIBDESA="${KRB_LIB_DIR}/libdes.a"
192			else
193			LIBS="$cmu_save_LIBS $LIBSSL_LIB_FLAGS"
194			AC_TRY_LINK([],
195			[des_quad_cksum();],KRB_DES_LIB="libcrypto")
196			if test "X$KRB_DES_LIB" = "Xlibcrypto"; then
197			AC_MSG_RESULT([libcrypto])
198			KRB_LIBDES="$LIBSSL_LIB_FLAGS"
199			KRB_LIBDESA="$LIBSSL_LIB_FLAGS"
200			else
201			AC_MSG_RESULT([unknown])
202			AC_MSG_ERROR([Could not use -ldes])
203			fi
204			fi
205			else
206			AC_MSG_RESULT([no])
207			fi
208			LIBS="${cmu_save_LIBS}"
209
210			if test "X$ac_cv_krb_where_lib" = "X"; then
211			CMU_KRB_LIB_WHERE(/usr/athena/lib /usr/local/lib /usr/lib)
212			fi
213
214			AC_MSG_CHECKING(whether to include kerberos 4)
215			if test "X$ac_cv_krb_where_lib" = "X" -o "X$ac_cv_krb_where_inc" = "X"; then
216			ac_cv_found_krb=no
217			AC_MSG_RESULT(no)
218			else
219			ac_cv_found_krb=yes
220			AC_MSG_RESULT(yes)
221			KRB_INC_DIR=$ac_cv_krb_where_inc
222			KRB_LIB_DIR=$ac_cv_krb_where_lib
223			KRB_INC_FLAGS="-I${KRB_INC_DIR}"
224			KRB_LIB_FLAGS="-L${KRB_LIB_DIR} -lkrb ${KRB_LIBDES}"
225			LIBS="${cmu_save_LIBS} ${KRB_LIB_FLAGS}"
226			AC_CHECK_LIB(resolv, dns_lookup, KRB_LIB_FLAGS="${KRB_LIB_FLAGS} -lresolv",,"${KRB_LIB_FLAGS}")
227			AC_CHECK_LIB(crypt, crypt, KRB_LIB_FLAGS="${KRB_LIB_FLAGS} -lcrypt",,"${KRB_LIB_FLAGS}")
228			AC_CHECK_FUNCS(krb_get_int krb_life_to_time)
229			AC_SUBST(KRB_INC_FLAGS)
230			AC_SUBST(KRB_LIB_FLAGS)
231			LIBS="${cmu_save_LIBS}"
232			AC_DEFINE(KERBEROS,,[Use kerberos 4. find out what needs this symbol])
233			if test "X$RPATH" = "X"; then
234			RPATH=""
235			fi
236			case "${host}" in
237			--linux*)
238			if test "X$RPATH" = "X"; then
239			RPATH="-Wl,-rpath,${KRB_LIB_DIR}"
240			else
241			RPATH="${RPATH}:${KRB_LIB_DIR}"
242			fi
243			;;
244			--hpux*)
245			if test "X$RPATH" = "X"; then
246			RPATH="-Wl,+b${KRB_LIB_DIR}"
247			else
248			RPATH="${RPATH}:${KRB_LIB_DIR}"
249			fi
250			;;
251			--irix*)
252			if test "X$RPATH" = "X"; then
253			RPATH="-Wl,-rpath,${KRB_LIB_DIR}"
254			else
255			RPATH="${RPATH}:${KRB_LIB_DIR}"
256			fi
257			;;
258			--solaris2*)
259			if test "$ac_cv_prog_gcc" = yes; then
260			if test "X$RPATH" = "X"; then
261			RPATH="-Wl,-R${KRB_LIB_DIR}"
262			else
263			RPATH="${RPATH}:${KRB_LIB_DIR}"
264			fi
265			else
266			RPATH="${RPATH} -R${KRB_LIB_DIR}"
267			fi
268			;;
269			esac
270			AC_SUBST(RPATH)
271			fi
272			])