From 1d2ba2a26fd4e3398ab72fe1211febfc577e7e46 Mon Sep 17 00:00:00 2001 From: Marco van Wieringen Date: Sat, 28 Feb 2009 14:52:14 +0000 Subject: [PATCH] - Implemented xattr support for Solaris 9 and above and extensible attributes for OpenSolaris. - Added some limits to the xattr code so that we don't blow up the filed on big xattrs. - Fixed some comments which changed due to xattrs being implemented. - Changed xattr support checking in configure to test first for generic solutions and when not found for specific OS functions. git-svn-id: https://bacula.svn.sourceforge.net/svnroot/bacula/trunk@8495 91ce42f0-d328-0410-95d8-f526ca767f89 --- bacula/autoconf/config.h.in | 32 +- bacula/autoconf/configure.in | 53 +- bacula/configure | 617 +++++++++++++- bacula/src/baconfig.h | 5 +- bacula/src/filed/backup.c | 17 +- bacula/src/filed/restore.c | 19 +- bacula/src/filed/verify.c | 2 +- bacula/src/filed/xattr.c | 1489 ++++++++++++++++++++++++++++++++-- bacula/src/filed/xattr.h | 16 +- bacula/src/findlib/attribs.c | 6 +- bacula/src/findlib/bfile.c | 4 +- bacula/src/findlib/protos.h | 2 +- bacula/src/lib/base64.c | 4 +- bacula/src/stored/bscan.c | 1 + bacula/technotes-2.5 | 8 + 15 files changed, 2156 insertions(+), 119 deletions(-) diff --git a/bacula/autoconf/config.h.in b/bacula/autoconf/config.h.in index 1b549320ca..71617e4dd9 100644 --- a/bacula/autoconf/config.h.in +++ b/bacula/autoconf/config.h.in @@ -21,12 +21,6 @@ /* Define to `int' if doesn't define. */ #undef ssize_t -/* Typedef to intxx if doesn't declare. */ -#undef HAVE_INTPTR_T - -/* Typedef to uintxx if doesn't declare. */ -#undef HAVE_UINTPTR_T - /* Define if you want to use PostgreSQL */ #undef HAVE_POSTGRESQL @@ -285,6 +279,9 @@ /* Define to 1 if you have the header file. */ #undef HAVE_ASSERT_H +/* Defines if your system have the attr.h header file */ +#undef HAVE_ATTR_H + /* Set if Bacula bat Qt4 GUI support enabled */ #undef HAVE_BAT @@ -436,6 +433,9 @@ /* Define if you have the 'intmax_t' type in or . */ #undef HAVE_INTMAX_T +/* Define to 1 if the system has the type `intptr_t'. */ +#undef HAVE_INTPTR_T + /* Define if exists and doesn't clash with . */ #undef HAVE_INTTYPES_H @@ -542,6 +542,9 @@ /* Define to 1 if you have the header file. */ #undef HAVE_NL_TYPES_H +/* OPENAT support */ +#undef HAVE_OPENAT + /* Define if OpenSSL library is available */ #undef HAVE_OPENSSL @@ -684,6 +687,9 @@ /* Defines if your system have the sys/acl.h header file */ #undef HAVE_SYS_ACL_H +/* Defines if your system have the sys/attr.h header file */ +#undef HAVE_SYS_ATTR_H + /* Define to 1 if you have the header file. */ #undef HAVE_SYS_BITYPES_H @@ -704,6 +710,9 @@ */ #undef HAVE_SYS_NDIR_H +/* Defines if your system have the sys/nvpair.h header file */ +#undef HAVE_SYS_NVPAIR_H + /* Define to 1 if you have the header file. */ #undef HAVE_SYS_PARAM_H @@ -769,6 +778,9 @@ /* Define if you have the 'uintmax_t' type in or . */ #undef HAVE_UINTMAX_T +/* Define to 1 if the system has the type `uintptr_t'. */ +#undef HAVE_UINTPTR_T + /* Define to 1 if you have the header file. */ #undef HAVE_UNISTD_H @@ -946,6 +958,10 @@ /* Define to `unsigned long' if does not define. */ #undef ino_t +/* Define to the type of a signed integer type wide enough to hold a pointer, + if such a type exists, and if the system does not define it. */ +#undef intptr_t + /* Define to `int' if does not define. */ #undef major_t @@ -980,3 +996,7 @@ /* Define to unsigned long or unsigned long long if and don't define. */ #undef uintmax_t + +/* Define to the type of an unsigned integer type wide enough to hold a + pointer, if such a type exists, and if the system does not define it. */ +#undef uintptr_t diff --git a/bacula/autoconf/configure.in b/bacula/autoconf/configure.in index 586e17825c..ca80170ed6 100644 --- a/bacula/autoconf/configure.in +++ b/bacula/autoconf/configure.in @@ -2297,7 +2297,7 @@ AC_ARG_ENABLE(xattr, AC_HELP_STRING([--disable-xattr], [disable xattr support @<:@default=auto@:>@]), [ if test x$enableval = xno; then - support_acl=no + support_xattr=no fi ] ) @@ -2311,18 +2311,51 @@ if test x$support_xattr = xyes; then AC_DEFINE([HAVE_LLISTXATTR], [], [LLISTXATTR support]) AC_DEFINE([HAVE_LGETXATTR], [], [LGETXATTR support]) AC_DEFINE([HAVE_LSETXATTR], [], [LSETXATTR support]) - ], [ - AC_CHECK_FUNCS(listxattr getxattr setxattr, - [ - have_xattr=yes - AC_DEFINE([HAVE_LLISTXATTR], [], [LLISTXATTR support]) - AC_DEFINE([HAVE_LGETXATTR], [], [LGETXATTR support]) - AC_DEFINE([HAVE_LSETXATTR], [], [LSETXATTR support]) - ] - ) ] ) + # + # OSX specific + # + if test $have_xattr = no; then + AC_CHECK_FUNCS(listxattr getxattr setxattr, + [ + have_xattr=yes + AC_DEFINE([HAVE_LLISTXATTR], [], [LLISTXATTR support]) + AC_DEFINE([HAVE_LGETXATTR], [], [LGETXATTR support]) + AC_DEFINE([HAVE_LSETXATTR], [], [LSETXATTR support]) + ] + ) + fi + + # + # Solaris specific + # + if test $have_xattr = no; then + AC_CHECK_HEADER(sys/attr.h, [ AC_DEFINE(HAVE_SYS_ATTR_H,1,[Defines if your system have the sys/attr.h header file])] , ) + AC_CHECK_HEADER(sys/nvpair.h, [ AC_DEFINE(HAVE_SYS_NVPAIR_H,1,[Defines if your system have the sys/nvpair.h header file])] , ) + AC_CHECK_HEADER(attr.h, [ AC_DEFINE(HAVE_ATTR_H,1,[Defines if your system have the attr.h header file])] , ) + + AC_CHECK_FUNCS(openat fstatat unlinkat fchownat futimesat, + [ + have_xattr=yes + AC_DEFINE([HAVE_OPENAT], [], [OPENAT support]) + AC_DEFINE([HAVE_FSTATAT], [], [FSTATAT support]) + AC_DEFINE([HAVE_UNLINKAT], [], [UNLINKAT support]) + AC_DEFINE([HAVE_FCHOWNAT], [], [FCHOWNAT support]) + AC_DEFINE([HAVE_FUTIMESAT], [], [FUTIMESAT support]) + ] + ) + + if test $have_xattr = yes; then + AC_CHECK_LIB(nvpair, nvlist_next_nvpair, + [ + FDLIBS="-lnvpair $FDLIBS" + ] + ) + fi + fi + if test $have_xattr = yes; then AC_DEFINE([HAVE_XATTR], [], [XATTR support]) fi diff --git a/bacula/configure b/bacula/configure index 40d7e7b3e0..843ca9f6d0 100755 --- a/bacula/configure +++ b/bacula/configure @@ -40019,7 +40019,7 @@ if test "$ac_res" != no; then ac_cv_func_getmntent=yes cat >>confdefs.h <<\_ACEOF -#define HAVE_GETMNTENT 1 +#define HAVE_GETMNTENT _ACEOF else @@ -41068,7 +41068,7 @@ support_xattr=yes if test "${enable_xattr+set}" = set; then enableval=$enable_xattr; if test x$enableval = xno; then - support_acl=no + support_xattr=no fi @@ -41321,8 +41321,15 @@ cat >>confdefs.h <<\_ACEOF _ACEOF -else +fi +done + + + # + # OSX specific + # + if test $have_xattr = no; then @@ -41416,7 +41423,7 @@ if test `eval echo '${'$as_ac_var'}'` = yes; then #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1 _ACEOF - have_xattr=yes + have_xattr=yes cat >>confdefs.h <<\_ACEOF #define HAVE_LLISTXATTR @@ -41437,12 +41444,614 @@ _ACEOF fi done + fi + + # + # Solaris specific + # + if test $have_xattr = no; then + if test "${ac_cv_header_sys_attr_h+set}" = set; then + { echo "$as_me:$LINENO: checking for sys/attr.h" >&5 +echo $ECHO_N "checking for sys/attr.h... $ECHO_C" >&6; } +if test "${ac_cv_header_sys_attr_h+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +fi +{ echo "$as_me:$LINENO: result: $ac_cv_header_sys_attr_h" >&5 +echo "${ECHO_T}$ac_cv_header_sys_attr_h" >&6; } +else + # Is the header compilable? +{ echo "$as_me:$LINENO: checking sys/attr.h usability" >&5 +echo $ECHO_N "checking sys/attr.h usability... $ECHO_C" >&6; } +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +#include +_ACEOF +rm -f conftest.$ac_objext +if { (ac_try="$ac_compile" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 + (eval "$ac_compile") 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && { + test -z "$ac_c_werror_flag" || + test ! -s conftest.err + } && test -s conftest.$ac_objext; then + ac_header_compiler=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_header_compiler=no +fi + +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +{ echo "$as_me:$LINENO: result: $ac_header_compiler" >&5 +echo "${ECHO_T}$ac_header_compiler" >&6; } + +# Is the header present? +{ echo "$as_me:$LINENO: checking sys/attr.h presence" >&5 +echo $ECHO_N "checking sys/attr.h presence... $ECHO_C" >&6; } +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#include +_ACEOF +if { (ac_try="$ac_cpp conftest.$ac_ext" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 + (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } >/dev/null && { + test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" || + test ! -s conftest.err + }; then + ac_header_preproc=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_header_preproc=no +fi + +rm -f conftest.err conftest.$ac_ext +{ echo "$as_me:$LINENO: result: $ac_header_preproc" >&5 +echo "${ECHO_T}$ac_header_preproc" >&6; } + +# So? What about this header? +case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in + yes:no: ) + { echo "$as_me:$LINENO: WARNING: sys/attr.h: accepted by the compiler, rejected by the preprocessor!" >&5 +echo "$as_me: WARNING: sys/attr.h: accepted by the compiler, rejected by the preprocessor!" >&2;} + { echo "$as_me:$LINENO: WARNING: sys/attr.h: proceeding with the compiler's result" >&5 +echo "$as_me: WARNING: sys/attr.h: proceeding with the compiler's result" >&2;} + ac_header_preproc=yes + ;; + no:yes:* ) + { echo "$as_me:$LINENO: WARNING: sys/attr.h: present but cannot be compiled" >&5 +echo "$as_me: WARNING: sys/attr.h: present but cannot be compiled" >&2;} + { echo "$as_me:$LINENO: WARNING: sys/attr.h: check for missing prerequisite headers?" >&5 +echo "$as_me: WARNING: sys/attr.h: check for missing prerequisite headers?" >&2;} + { echo "$as_me:$LINENO: WARNING: sys/attr.h: see the Autoconf documentation" >&5 +echo "$as_me: WARNING: sys/attr.h: see the Autoconf documentation" >&2;} + { echo "$as_me:$LINENO: WARNING: sys/attr.h: section \"Present But Cannot Be Compiled\"" >&5 +echo "$as_me: WARNING: sys/attr.h: section \"Present But Cannot Be Compiled\"" >&2;} + { echo "$as_me:$LINENO: WARNING: sys/attr.h: proceeding with the preprocessor's result" >&5 +echo "$as_me: WARNING: sys/attr.h: proceeding with the preprocessor's result" >&2;} + { echo "$as_me:$LINENO: WARNING: sys/attr.h: in the future, the compiler will take precedence" >&5 +echo "$as_me: WARNING: sys/attr.h: in the future, the compiler will take precedence" >&2;} + + ;; +esac +{ echo "$as_me:$LINENO: checking for sys/attr.h" >&5 +echo $ECHO_N "checking for sys/attr.h... $ECHO_C" >&6; } +if test "${ac_cv_header_sys_attr_h+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + ac_cv_header_sys_attr_h=$ac_header_preproc +fi +{ echo "$as_me:$LINENO: result: $ac_cv_header_sys_attr_h" >&5 +echo "${ECHO_T}$ac_cv_header_sys_attr_h" >&6; } + +fi +if test $ac_cv_header_sys_attr_h = yes; then + +cat >>confdefs.h <<\_ACEOF +#define HAVE_SYS_ATTR_H 1 +_ACEOF + +fi + + + if test "${ac_cv_header_sys_nvpair_h+set}" = set; then + { echo "$as_me:$LINENO: checking for sys/nvpair.h" >&5 +echo $ECHO_N "checking for sys/nvpair.h... $ECHO_C" >&6; } +if test "${ac_cv_header_sys_nvpair_h+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +fi +{ echo "$as_me:$LINENO: result: $ac_cv_header_sys_nvpair_h" >&5 +echo "${ECHO_T}$ac_cv_header_sys_nvpair_h" >&6; } +else + # Is the header compilable? +{ echo "$as_me:$LINENO: checking sys/nvpair.h usability" >&5 +echo $ECHO_N "checking sys/nvpair.h usability... $ECHO_C" >&6; } +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +#include +_ACEOF +rm -f conftest.$ac_objext +if { (ac_try="$ac_compile" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 + (eval "$ac_compile") 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && { + test -z "$ac_c_werror_flag" || + test ! -s conftest.err + } && test -s conftest.$ac_objext; then + ac_header_compiler=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_header_compiler=no +fi + +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +{ echo "$as_me:$LINENO: result: $ac_header_compiler" >&5 +echo "${ECHO_T}$ac_header_compiler" >&6; } + +# Is the header present? +{ echo "$as_me:$LINENO: checking sys/nvpair.h presence" >&5 +echo $ECHO_N "checking sys/nvpair.h presence... $ECHO_C" >&6; } +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#include +_ACEOF +if { (ac_try="$ac_cpp conftest.$ac_ext" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 + (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } >/dev/null && { + test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" || + test ! -s conftest.err + }; then + ac_header_preproc=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_header_preproc=no +fi + +rm -f conftest.err conftest.$ac_ext +{ echo "$as_me:$LINENO: result: $ac_header_preproc" >&5 +echo "${ECHO_T}$ac_header_preproc" >&6; } + +# So? What about this header? +case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in + yes:no: ) + { echo "$as_me:$LINENO: WARNING: sys/nvpair.h: accepted by the compiler, rejected by the preprocessor!" >&5 +echo "$as_me: WARNING: sys/nvpair.h: accepted by the compiler, rejected by the preprocessor!" >&2;} + { echo "$as_me:$LINENO: WARNING: sys/nvpair.h: proceeding with the compiler's result" >&5 +echo "$as_me: WARNING: sys/nvpair.h: proceeding with the compiler's result" >&2;} + ac_header_preproc=yes + ;; + no:yes:* ) + { echo "$as_me:$LINENO: WARNING: sys/nvpair.h: present but cannot be compiled" >&5 +echo "$as_me: WARNING: sys/nvpair.h: present but cannot be compiled" >&2;} + { echo "$as_me:$LINENO: WARNING: sys/nvpair.h: check for missing prerequisite headers?" >&5 +echo "$as_me: WARNING: sys/nvpair.h: check for missing prerequisite headers?" >&2;} + { echo "$as_me:$LINENO: WARNING: sys/nvpair.h: see the Autoconf documentation" >&5 +echo "$as_me: WARNING: sys/nvpair.h: see the Autoconf documentation" >&2;} + { echo "$as_me:$LINENO: WARNING: sys/nvpair.h: section \"Present But Cannot Be Compiled\"" >&5 +echo "$as_me: WARNING: sys/nvpair.h: section \"Present But Cannot Be Compiled\"" >&2;} + { echo "$as_me:$LINENO: WARNING: sys/nvpair.h: proceeding with the preprocessor's result" >&5 +echo "$as_me: WARNING: sys/nvpair.h: proceeding with the preprocessor's result" >&2;} + { echo "$as_me:$LINENO: WARNING: sys/nvpair.h: in the future, the compiler will take precedence" >&5 +echo "$as_me: WARNING: sys/nvpair.h: in the future, the compiler will take precedence" >&2;} + + ;; +esac +{ echo "$as_me:$LINENO: checking for sys/nvpair.h" >&5 +echo $ECHO_N "checking for sys/nvpair.h... $ECHO_C" >&6; } +if test "${ac_cv_header_sys_nvpair_h+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + ac_cv_header_sys_nvpair_h=$ac_header_preproc +fi +{ echo "$as_me:$LINENO: result: $ac_cv_header_sys_nvpair_h" >&5 +echo "${ECHO_T}$ac_cv_header_sys_nvpair_h" >&6; } + +fi +if test $ac_cv_header_sys_nvpair_h = yes; then + +cat >>confdefs.h <<\_ACEOF +#define HAVE_SYS_NVPAIR_H 1 +_ACEOF + +fi + + + if test "${ac_cv_header_attr_h+set}" = set; then + { echo "$as_me:$LINENO: checking for attr.h" >&5 +echo $ECHO_N "checking for attr.h... $ECHO_C" >&6; } +if test "${ac_cv_header_attr_h+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +fi +{ echo "$as_me:$LINENO: result: $ac_cv_header_attr_h" >&5 +echo "${ECHO_T}$ac_cv_header_attr_h" >&6; } +else + # Is the header compilable? +{ echo "$as_me:$LINENO: checking attr.h usability" >&5 +echo $ECHO_N "checking attr.h usability... $ECHO_C" >&6; } +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +#include +_ACEOF +rm -f conftest.$ac_objext +if { (ac_try="$ac_compile" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 + (eval "$ac_compile") 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && { + test -z "$ac_c_werror_flag" || + test ! -s conftest.err + } && test -s conftest.$ac_objext; then + ac_header_compiler=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_header_compiler=no +fi + +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +{ echo "$as_me:$LINENO: result: $ac_header_compiler" >&5 +echo "${ECHO_T}$ac_header_compiler" >&6; } + +# Is the header present? +{ echo "$as_me:$LINENO: checking attr.h presence" >&5 +echo $ECHO_N "checking attr.h presence... $ECHO_C" >&6; } +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#include +_ACEOF +if { (ac_try="$ac_cpp conftest.$ac_ext" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 + (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } >/dev/null && { + test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" || + test ! -s conftest.err + }; then + ac_header_preproc=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_header_preproc=no +fi + +rm -f conftest.err conftest.$ac_ext +{ echo "$as_me:$LINENO: result: $ac_header_preproc" >&5 +echo "${ECHO_T}$ac_header_preproc" >&6; } + +# So? What about this header? +case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in + yes:no: ) + { echo "$as_me:$LINENO: WARNING: attr.h: accepted by the compiler, rejected by the preprocessor!" >&5 +echo "$as_me: WARNING: attr.h: accepted by the compiler, rejected by the preprocessor!" >&2;} + { echo "$as_me:$LINENO: WARNING: attr.h: proceeding with the compiler's result" >&5 +echo "$as_me: WARNING: attr.h: proceeding with the compiler's result" >&2;} + ac_header_preproc=yes + ;; + no:yes:* ) + { echo "$as_me:$LINENO: WARNING: attr.h: present but cannot be compiled" >&5 +echo "$as_me: WARNING: attr.h: present but cannot be compiled" >&2;} + { echo "$as_me:$LINENO: WARNING: attr.h: check for missing prerequisite headers?" >&5 +echo "$as_me: WARNING: attr.h: check for missing prerequisite headers?" >&2;} + { echo "$as_me:$LINENO: WARNING: attr.h: see the Autoconf documentation" >&5 +echo "$as_me: WARNING: attr.h: see the Autoconf documentation" >&2;} + { echo "$as_me:$LINENO: WARNING: attr.h: section \"Present But Cannot Be Compiled\"" >&5 +echo "$as_me: WARNING: attr.h: section \"Present But Cannot Be Compiled\"" >&2;} + { echo "$as_me:$LINENO: WARNING: attr.h: proceeding with the preprocessor's result" >&5 +echo "$as_me: WARNING: attr.h: proceeding with the preprocessor's result" >&2;} + { echo "$as_me:$LINENO: WARNING: attr.h: in the future, the compiler will take precedence" >&5 +echo "$as_me: WARNING: attr.h: in the future, the compiler will take precedence" >&2;} + + ;; +esac +{ echo "$as_me:$LINENO: checking for attr.h" >&5 +echo $ECHO_N "checking for attr.h... $ECHO_C" >&6; } +if test "${ac_cv_header_attr_h+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + ac_cv_header_attr_h=$ac_header_preproc +fi +{ echo "$as_me:$LINENO: result: $ac_cv_header_attr_h" >&5 +echo "${ECHO_T}$ac_cv_header_attr_h" >&6; } + +fi +if test $ac_cv_header_attr_h = yes; then + +cat >>confdefs.h <<\_ACEOF +#define HAVE_ATTR_H 1 +_ACEOF + +fi + + + + + + + + +for ac_func in openat fstatat unlinkat fchownat futimesat +do +as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh` +{ echo "$as_me:$LINENO: checking for $ac_func" >&5 +echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6; } +if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +/* Define $ac_func to an innocuous variant, in case declares $ac_func. + For example, HP-UX 11i declares gettimeofday. */ +#define $ac_func innocuous_$ac_func + +/* System header to define __stub macros and hopefully few prototypes, + which can conflict with char $ac_func (); below. + Prefer to if __STDC__ is defined, since + exists even on freestanding compilers. */ + +#ifdef __STDC__ +# include +#else +# include +#endif + +#undef $ac_func + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char $ac_func (); +/* The GNU C library defines this for functions which it implements + to always fail with ENOSYS. Some functions are actually named + something starting with __ and the normal name is an alias. */ +#if defined __stub_$ac_func || defined __stub___$ac_func +choke me +#endif + +int +main () +{ +return $ac_func (); + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext conftest$ac_exeext +if { (ac_try="$ac_link" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 + (eval "$ac_link") 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && { + test -z "$ac_c_werror_flag" || + test ! -s conftest.err + } && test -s conftest$ac_exeext && + $as_test_x conftest$ac_exeext; then + eval "$as_ac_var=yes" +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + eval "$as_ac_var=no" +fi + +rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ + conftest$ac_exeext conftest.$ac_ext +fi +ac_res=`eval echo '${'$as_ac_var'}'` + { echo "$as_me:$LINENO: result: $ac_res" >&5 +echo "${ECHO_T}$ac_res" >&6; } +if test `eval echo '${'$as_ac_var'}'` = yes; then + cat >>confdefs.h <<_ACEOF +#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1 +_ACEOF + + have_xattr=yes + +cat >>confdefs.h <<\_ACEOF +#define HAVE_OPENAT +_ACEOF + + +cat >>confdefs.h <<\_ACEOF +#define HAVE_FSTATAT +_ACEOF + + +cat >>confdefs.h <<\_ACEOF +#define HAVE_UNLINKAT +_ACEOF + + +cat >>confdefs.h <<\_ACEOF +#define HAVE_FCHOWNAT +_ACEOF + + +cat >>confdefs.h <<\_ACEOF +#define HAVE_FUTIMESAT +_ACEOF + fi done + if test $have_xattr = yes; then + { echo "$as_me:$LINENO: checking for nvlist_next_nvpair in -lnvpair" >&5 +echo $ECHO_N "checking for nvlist_next_nvpair in -lnvpair... $ECHO_C" >&6; } +if test "${ac_cv_lib_nvpair_nvlist_next_nvpair+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-lnvpair $LIBS" +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char nvlist_next_nvpair (); +int +main () +{ +return nvlist_next_nvpair (); + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext conftest$ac_exeext +if { (ac_try="$ac_link" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 + (eval "$ac_link") 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && { + test -z "$ac_c_werror_flag" || + test ! -s conftest.err + } && test -s conftest$ac_exeext && + $as_test_x conftest$ac_exeext; then + ac_cv_lib_nvpair_nvlist_next_nvpair=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_cv_lib_nvpair_nvlist_next_nvpair=no +fi + +rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ echo "$as_me:$LINENO: result: $ac_cv_lib_nvpair_nvlist_next_nvpair" >&5 +echo "${ECHO_T}$ac_cv_lib_nvpair_nvlist_next_nvpair" >&6; } +if test $ac_cv_lib_nvpair_nvlist_next_nvpair = yes; then + + FDLIBS="-lnvpair $FDLIBS" + + +fi + + fi + fi + if test $have_xattr = yes; then cat >>confdefs.h <<\_ACEOF diff --git a/bacula/src/baconfig.h b/bacula/src/baconfig.h index 1974c5a88b..f7d2327b01 100644 --- a/bacula/src/baconfig.h +++ b/bacula/src/baconfig.h @@ -294,7 +294,10 @@ void InitWinAPIWrapper(); #define STREAM_ACL_SOLARIS_ACE 1013 /* Solaris specific ace_t string representation from * from acl_totext (NFSv4 or ZFS acl) */ -#define STREAM_XATTR_SOLARIS 1995 /* Solaris specific extented attributes and extensible attributes */ +#define STREAM_XATTR_SOLARIS_SYS 1994 /* Solaris specific extensible attributes or + * otherwise named extended system attributes. + */ +#define STREAM_XATTR_SOLARIS 1995 /* Solaris specific extented attributes */ #define STREAM_XATTR_DARWIN 1996 /* Darwin (OSX) specific extended attributes */ #define STREAM_XATTR_FREEBSD 1997 /* FreeBSD specific extended attributes */ #define STREAM_XATTR_LINUX 1998 /* Linux specific extended attributes */ diff --git a/bacula/src/filed/backup.c b/bacula/src/filed/backup.c index 1d54c285bc..9a5db19fbf 100644 --- a/bacula/src/filed/backup.c +++ b/bacula/src/filed/backup.c @@ -155,13 +155,18 @@ bool blast_data_to_storage_daemon(JCR *jcr, char *addr) accurate_send_deleted_list(jcr); /* send deleted list to SD */ - free_pool_memory(jcr->acl_data); - free_pool_memory(jcr->xattr_data); - stop_heartbeat_monitor(jcr); sd->signal(BNET_EOD); /* end of sending data */ + if (jcr->acl_data) { + free_pool_memory(jcr->acl_data); + jcr->acl_data = NULL; + } + if (jcr->xattr_data) { + free_pool_memory(jcr->xattr_data); + jcr->xattr_data = NULL; + } if (jcr->big_buf) { free(jcr->big_buf); jcr->big_buf = NULL; @@ -706,8 +711,8 @@ bail_out: * Currently this is not a problem as the only other stream, resource forks, * are not handled as sparse files. */ -int send_data(JCR *jcr, int stream, FF_PKT *ff_pkt, DIGEST *digest, - DIGEST *signing_digest) +static int send_data(JCR *jcr, int stream, FF_PKT *ff_pkt, DIGEST *digest, + DIGEST *signing_digest) { BSOCK *sd = jcr->store_bsock; uint64_t fileAddr = 0; /* file address */ @@ -1043,7 +1048,7 @@ bool encode_and_send_attributes(JCR *jcr, FF_PKT *ff_pkt, int &data_stream) Jmsg0(jcr, M_FATAL, 0, _("Invalid file flags, no supported data stream type.\n")); return false; } - encode_stat(attribs, ff_pkt, data_stream); + encode_stat(attribs, &ff_pkt->statp, ff_pkt->LinkFI, data_stream); /* Now possibly extend the attributes */ attr_stream = encode_attribsEx(jcr, attribsEx, ff_pkt); diff --git a/bacula/src/filed/restore.c b/bacula/src/filed/restore.c index 1ec7dfaa10..b8435e132a 100644 --- a/bacula/src/filed/restore.c +++ b/bacula/src/filed/restore.c @@ -229,8 +229,9 @@ void do_restore(JCR *jcr) * d. Alternate data stream (e.g. Resource Fork) * e. Finder info * f. ACLs - * g. Possibly a cryptographic signature - * h. Possibly MD5 or SHA1 record + * g. XATTRs + * h. Possibly a cryptographic signature + * i. Possibly MD5 or SHA1 record * 3. Repeat step 1 * * NOTE: We keep track of two bacula file descriptors: @@ -613,6 +614,8 @@ void do_restore(JCR *jcr) } break; + case STREAM_XATTR_SOLARIS_SYS: + case STREAM_XATTR_SOLARIS: case STREAM_XATTR_DARWIN: case STREAM_XATTR_FREEBSD: case STREAM_XATTR_LINUX: @@ -728,11 +731,19 @@ ok_out: jcr->compress_buf = NULL; jcr->compress_buf_size = 0; } + + if (jcr->xattr_data) { + free_pool_memory(jcr->xattr_data); + jcr->xattr_data = NULL; + } + if (jcr->acl_data) { + free_pool_memory(jcr->acl_data); + jcr->acl_data = NULL; + } + bclose(&rctx.forkbfd); bclose(&rctx.bfd); free_attr(rctx.attr); - free_pool_memory(jcr->xattr_data); - free_pool_memory(jcr->acl_data); Dmsg2(10, "End Do Restore. Files=%d Bytes=%s\n", jcr->JobFiles, edit_uint64(jcr->JobBytes, ec1)); if (non_support_data > 1 || non_support_attr > 1) { diff --git a/bacula/src/filed/verify.c b/bacula/src/filed/verify.c index 257a51618d..2d0d8e753b 100644 --- a/bacula/src/filed/verify.c +++ b/bacula/src/filed/verify.c @@ -165,7 +165,7 @@ static int verify_file(JCR *jcr, FF_PKT *ff_pkt, bool top_level) } /* Encode attributes and possibly extend them */ - encode_stat(attribs, ff_pkt, 0); + encode_stat(attribs, &ff_pkt->statp, ff_pkt->LinkFI, 0); encode_attribsEx(jcr, attribsEx, ff_pkt); jcr->lock(); diff --git a/bacula/src/filed/xattr.c b/bacula/src/filed/xattr.c index 0d85570bd9..f03aad6a1e 100644 --- a/bacula/src/filed/xattr.c +++ b/bacula/src/filed/xattr.c @@ -1,7 +1,7 @@ /* Bacula® - The Network Backup Solution - Copyright (C) 2008-2008 Free Software Foundation Europe e.V. + Copyright (C) 2008-2009 Free Software Foundation Europe e.V. The main author of Bacula is Kern Sibbald, with contributions from many others, a complete list can be found in the file AUTHORS. @@ -48,7 +48,7 @@ #include "xattr.h" /* - * List of supported OSs. Everything outside that gets stub functions. + * List of supported OSes. Everything outside that gets stub functions. * Also when XATTR support is explicitly disabled. */ #if !defined(HAVE_XATTR) /* Extended Attributes support is required, of course */ \ @@ -73,48 +73,10 @@ bool parse_xattr_stream(JCR *jcr, int stream) #else -/* - * This is a supported OS, See what kind of interface we should use. - * Start with the generic interface used by most OS-es. - */ -#if defined(HAVE_DARWIN_OS) \ - || defined(HAVE_FREEBSD_OS) \ - || defined(HAVE_LINUX_OS) \ - || defined(HAVE_NETBSD_OS) - -#ifdef HAVE_SYS_XATTR_H -#include -#endif - -/* - * OSX doesn't have llistxattr, lgetxattr and lsetxattr but has - * listxattr, getxattr and setxattr with an extra options argument - * which mimics the l variants of the functions when we specify - * XATTR_NOFOLLOW as the options value. - */ -#if defined(HAVE_DARWIN_OS) - #define llistxattr(path, list, size) listxattr((path), (list), (size), XATTR_NOFOLLOW) - #define lgetxattr(path, name, value, size) getxattr((path), (name), (value), (size), 0, XATTR_NOFOLLOW) - #define lsetxattr(path, name, value, size, flags) setxattr((path), (name), (value), (size), (flags), XATTR_NOFOLLOW) -#else - /* - * Fallback to the non l-functions when those are not available. - */ - #if defined(HAVE_GETXATTR) && !defined(HAVE_LGETXATTR) - #define lgetxattr getxattr - #endif - #if defined(HAVE_SETXATTR) && !defined(HAVE_LSETXATTR) - #define lsetxattr setxattr - #endif - #if defined(HAVE_LISTXATTR) && !defined(HAVE_LLISTXATTR) - #define llistxattr listxattr - #endif -#endif - /* * Send a XATTR stream to the SD. */ -static bool send_xattr_stream(JCR *jcr, int stream, int len) +static bool send_xattr_stream(JCR *jcr, int stream) { BSOCK *sd = jcr->store_bsock; POOLMEM *msgsave; @@ -138,7 +100,7 @@ static bool send_xattr_stream(JCR *jcr, int stream, int len) Dmsg1(400, "Backing up XATTR <%s>\n", jcr->xattr_data); msgsave = sd->msg; sd->msg = jcr->xattr_data; - sd->msglen = len; + sd->msglen = jcr->xattr_data_len; if (!sd->send()) { sd->msg = msgsave; sd->msglen = 0; @@ -162,6 +124,44 @@ static bool send_xattr_stream(JCR *jcr, int stream, int len) return true; } +/* + * This is a supported OS, See what kind of interface we should use. + * Start with the generic interface used by most OS-es. + */ +#if defined(HAVE_DARWIN_OS) \ + || defined(HAVE_FREEBSD_OS) \ + || defined(HAVE_LINUX_OS) \ + || defined(HAVE_NETBSD_OS) + +#ifdef HAVE_SYS_XATTR_H +#include +#endif + +/* + * OSX doesn't have llistxattr, lgetxattr and lsetxattr but has + * listxattr, getxattr and setxattr with an extra options argument + * which mimics the l variants of the functions when we specify + * XATTR_NOFOLLOW as the options value. + */ +#if defined(HAVE_DARWIN_OS) + #define llistxattr(path, list, size) listxattr((path), (list), (size), XATTR_NOFOLLOW) + #define lgetxattr(path, name, value, size) getxattr((path), (name), (value), (size), 0, XATTR_NOFOLLOW) + #define lsetxattr(path, name, value, size, flags) setxattr((path), (name), (value), (size), (flags), XATTR_NOFOLLOW) +#else + /* + * Fallback to the non l-functions when those are not available. + */ + #if defined(HAVE_GETXATTR) && !defined(HAVE_LGETXATTR) + #define lgetxattr getxattr + #endif + #if defined(HAVE_SETXATTR) && !defined(HAVE_LSETXATTR) + #define lsetxattr setxattr + #endif + #if defined(HAVE_LISTXATTR) && !defined(HAVE_LLISTXATTR) + #define llistxattr listxattr + #endif +#endif + static void xattr_drop_internal_table(xattr_t *xattr_value_list) { xattr_t *current_xattr; @@ -190,7 +190,20 @@ static void xattr_drop_internal_table(xattr_t *xattr_value_list) free(xattr_value_list); } - +/* + * The xattr stream for OSX, FreeBSD, Linux and NetBSD is a serialized stream of bytes + * which encodes one or more xattr_t structures. + * + * The Serialized stream consists of the following elements: + * magic - A magic string which makes it easy to detect any binary incompatabilites + * name_length - The length of the following xattr name + * name - The name of the extended attribute + * value_length - The length of the following xattr data + * value - The actual content of the extended attribute + * + * This is repeated 1 or more times. + * + */ static uint32_t serialize_xattr_stream(JCR *jcr, uint32_t expected_serialize_len, xattr_t *xattr_value_list) { xattr_t *current_xattr; @@ -222,8 +235,9 @@ static uint32_t serialize_xattr_stream(JCR *jcr, uint32_t expected_serialize_len } ser_end(jcr->xattr_data, expected_serialize_len + 10); + jcr->xattr_data_len = ser_length(jcr->xattr_data); - return ser_length(jcr->xattr_data); + return jcr->xattr_data_len; } static bool generic_xattr_build_streams(JCR *jcr, FF_PKT *ff_pkt, int stream) @@ -231,8 +245,7 @@ static bool generic_xattr_build_streams(JCR *jcr, FF_PKT *ff_pkt, int stream) int count = 0; int32_t xattr_list_len, xattr_value_len, - expected_serialize_len = 0, - serialize_len = 0; + expected_serialize_len = 0; char *xattr_list, *bp; xattr_t *xattr_value_list, *current_xattr; @@ -376,8 +389,17 @@ static bool generic_xattr_build_streams(JCR *jcr, FF_PKT *ff_pkt, int stream) * Store the actual length of the value. */ current_xattr->value_length = xattr_value_len; - expected_serialize_len += sizeof(current_xattr->value_length) + current_xattr->value_length; + + /* + * Protect ourself against things getting out of hand. + */ + if (expected_serialize_len >= MAX_XATTR_STREAM) { + Jmsg2(jcr, M_ERROR, 0, _("Xattr stream on file \"%s\" exceeds maximum size of %d bytes\n"), + jcr->last_fname, MAX_XATTR_STREAM); + + goto bail_out; + } /* * Next attribute. @@ -389,9 +411,10 @@ static bool generic_xattr_build_streams(JCR *jcr, FF_PKT *ff_pkt, int stream) /* * Serialize the datastream. */ - if ((serialize_len = serialize_xattr_stream(jcr, expected_serialize_len, - xattr_value_list)) < expected_serialize_len) { - Jmsg1(jcr, M_ERROR, 0, _("failed to serialize extended attributes on file \"%s\"\n"), + if (serialize_xattr_stream(jcr, expected_serialize_len, xattr_value_list) < expected_serialize_len) { + Jmsg1(jcr, M_ERROR, 0, _("Failed to serialize extended attributes on file \"%s\"\n"), + jcr->last_fname); + Dmsg1(100, "Failed to serialize extended attributes on file \"%s\"\n", jcr->last_fname); goto bail_out; @@ -403,7 +426,7 @@ static bool generic_xattr_build_streams(JCR *jcr, FF_PKT *ff_pkt, int stream) /* * Send the datastream to the SD. */ - return send_xattr_stream(jcr, stream, serialize_len); + return send_xattr_stream(jcr, stream); bail_out: xattr_drop_internal_table(xattr_value_list); @@ -434,6 +457,8 @@ static bool generic_xattr_parse_streams(JCR *jcr) if (current_xattr.magic != XATTR_MAGIC) { Jmsg1(jcr, M_ERROR, 0, _("Illegal xattr stream, no XATTR_MAGIC on file \"%s\"\n"), jcr->last_fname); + Dmsg1(100, "Illegal xattr stream, no XATTR_MAGIC on file \"%s\"\n", + jcr->last_fname); return false; } @@ -566,50 +591,1356 @@ static bool netbsd_parse_xattr_stream(JCR *jcr, int stream) } #endif #elif defined(HAVE_SUN_OS) +/* + * Solaris extended attributes were introduced in Solaris 9 + * by PSARC 1999/209 + * + * Solaris extensible attributes were introduced in OpenSolaris + * by PSARC 2007/315 Solaris extensible attributes are also + * sometimes called extended system attributes. + * + * man fsattr(5) on Solaris gives a wealth of info. The most + * important bits are: + * + * Attributes are logically supported as files within the file + * system. The file system is therefore augmented with an + * orthogonal name space of file attributes. Any file (includ- + * ing attribute files) can have an arbitrarily deep attribute + * tree associated with it. Attribute values are accessed by + * file descriptors obtained through a special attribute inter- + * face. This logical view of "attributes as files" allows the + * leveraging of existing file system interface functionality + * to support the construction, deletion, and manipulation of + * attributes. + * + * The special files "." and ".." retain their accustomed + * semantics within the attribute hierarchy. The "." attribute + * file refers to the current directory and the ".." attribute + * file refers to the parent directory. The unnamed directory + * at the head of each attribute tree is considered the "child" + * of the file it is associated with and the ".." file refers + * to the associated file. For any non-directory file with + * attributes, the ".." entry in the unnamed directory refers + * to a file that is not a directory. + * + * Conceptually, the attribute model is fully general. Extended + * attributes can be any type of file (doors, links, direc- + * tories, and so forth) and can even have their own attributes + * (fully recursive). As a result, the attributes associated + * with a file could be an arbitrarily deep directory hierarchy + * where each attribute could have an equally complex attribute + * tree associated with it. Not all implementations are able + * to, or want to, support the full model. Implementation are + * therefore permitted to reject operations that are not sup- + * ported. For example, the implementation for the UFS file + * system allows only regular files as attributes (for example, + * no sub-directories) and rejects attempts to place attributes + * on attributes. + * + * The following list details the operations that are rejected + * in the current implementation: + * + * link Any attempt to create links between + * attribute and non-attribute space + * is rejected to prevent security- + * related or otherwise sensitive + * attributes from being exposed, and + * therefore manipulable, as regular + * files. + * + * rename Any attempt to rename between + * attribute and non-attribute space + * is rejected to prevent an already + * linked file from being renamed and + * thereby circumventing the link res- + * triction above. + * + * mkdir, symlink, mknod Any attempt to create a "non- + * regular" file in attribute space is + * rejected to reduce the functional- + * ity, and therefore exposure and + * risk, of the initial implementa- + * tion. + * + * The entire available name space has been allocated to "gen- + * eral use" to bring the implementation in line with the NFSv4 + * draft standard [NFSv4]. That standard defines "named attri- + * butes" (equivalent to Solaris Extended Attributes) with no + * naming restrictions. All Sun applications making use of + * opaque extended attributes will use the prefix "SUNW". + * + */ +#ifdef HAVE_SYS_ATTR_H +#include +#endif + +#ifdef HAVE_ATTR_H +#include +#endif + +#ifdef HAVE_SYS_NVPAIR_H +#include +#endif + +#ifdef HAVE_SYS_ACL_H +#include +#endif + +/* + * This is the count of xattrs saved on a certain file, it gets reset + * on each new file processed and is used to see if we need to send + * the hidden xattr dir data. We only send that data when we encounter + * an other xattr on the file. + */ +static int nr_xattr_saved = 0; +static char toplevel_hidden_dir_xattr_data[MAXSTRING]; +static int toplevel_hidden_dir_xattr_data_len; + +/* + * This code creates a temporary cache with entries for each xattr which has + * a link count > 1 (which indicates it has one or more hard linked counterpart(s)) + */ +static xattr_link_cache_entry_t *xattr_link_cache_head = NULL, + *xattr_link_cache_tail = NULL; -static bool solaris_build_xattr_streams(JCR *jcr, FF_PKT *ff_pkt) +static struct xattr_link_cache_entry *find_xattr_link_cache_entry(ino_t inum) { - return true; + xattr_link_cache_entry_t *ptr; + + for (ptr = xattr_link_cache_head; ptr != NULL; ptr = ptr->next) + if (ptr->inum == inum) + return ptr; + + return NULL; } -static bool solaris_parse_xattr_stream(JCR *jcr, int stream) +static void add_xattr_link_cache_entry(ino_t inum, char *target) { - switch (stream) { - case STREAM_XATTR_SOLARIS: - return true; - default: + xattr_link_cache_entry_t *ptr; + + if ((ptr = (xattr_link_cache_entry_t *)malloc(sizeof(struct xattr_link_cache_entry))) != NULL) { + memset((caddr_t)ptr, 0, sizeof(struct xattr_link_cache_entry)); + ptr->inum = inum; + strncpy(ptr->target, target, sizeof(ptr->target)); + if (xattr_link_cache_head == NULL) + xattr_link_cache_head = ptr; + xattr_link_cache_tail = ptr; + } +} + +static void drop_xattr_link_cache(void) +{ + xattr_link_cache_entry_t *ptr, *next; + + for (ptr = xattr_link_cache_tail; ptr != NULL; ptr = next) { + next = ptr->next; + free(ptr); + } + + xattr_link_cache_head = NULL; + xattr_link_cache_tail = NULL; +} + +#if defined(HAVE_SYS_NVPAIR_H) && defined(_PC_SATTR_ENABLED) +/* + * This function returns true if a non default extended system attribute + * list is associated with fd and returns false when an error has occured + * or when only extended system attributes other than archive, + * av_modified or crtime are set. + * + * The function returns true for the following cases: + * + * - any extended system attribute other than the default attributes + * ('archive', 'av_modified' and 'crtime') is set + * - nvlist has NULL name string + * - nvpair has data type of 'nvlist' + * - default data type. + */ +static bool solaris_has_non_transient_extensible_attributes(int fd) +{ + boolean_t value; + data_type_t type; + nvlist_t *response; + nvpair_t *pair; + f_attr_t fattr; + char *name; + bool retval = false; + + if (fgetattr(fd, XATTR_VIEW_READWRITE, &response) != 0) { return false; } + + pair = NULL; + while ((pair = nvlist_next_nvpair(response, pair)) != NULL) { + name = nvpair_name(pair); + + if (name != NULL) { + fattr = name_to_attr(name); + } else { + retval = true; + goto cleanup; + } + + type = nvpair_type(pair); + switch (type) { + case DATA_TYPE_BOOLEAN_VALUE: + if (nvpair_value_boolean_value(pair, &value) != 0) { + continue; + } + if (value && fattr != F_ARCHIVE && + fattr != F_AV_MODIFIED) { + retval = true; + goto cleanup; + } + break; + case DATA_TYPE_UINT64_ARRAY: + if (fattr != F_CRTIME) { + retval = true; + goto cleanup; + } + break; + case DATA_TYPE_NVLIST: + default: + retval = true; + goto cleanup; + } + } + +cleanup: + if (response != NULL) + nvlist_free(response); + + return retval; } +#endif /* HAVE_SYS_NVPAIR_H && _PC_SATTR_ENABLED */ -#endif +#if defined(HAVE_ACL) && !defined(HAVE_EXTENDED_ACL) +/* + * See if an acl is a trivial one (e.g. just the stat bits encoded as acl.) + * There is no need to store those acls as we already store the stat bits too. + */ +static bool acl_is_trivial(int count, aclent_t *entries) +{ + int n; + aclent_t *ace; -bool build_xattr_streams(JCR *jcr, FF_PKT *ff_pkt) + for (n = 0; n < count; n++) { + ace = &entries[n]; + + if (!(ace->a_type == USER_OBJ || + ace->a_type == GROUP_OBJ || + ace->a_type == OTHER_OBJ || + ace->a_type == CLASS_OBJ)) + return false; + } + + return true; +} +#endif /* HAVE_ACL && !HAVE_EXTENDED_ACL */ + +static bool solaris_archive_xattr_acl(JCR *jcr, int fd, const char *attrname, char **acl_text) { -#if defined(HAVE_SUN_OS) - return solaris_build_xattr_streams(jcr, ff_pkt); -#elif defined(HAVE_DARWIN_OS) - return darwin_build_xattr_streams(jcr, ff_pkt); -#elif defined(HAVE_FREEBSD_OS) - return freebsd_build_xattr_streams(jcr, ff_pkt); -#elif defined(HAVE_LINUX_OS) - return linux_build_xattr_streams(jcr, ff_pkt); -#elif defined(HAVE_NETBSD_OS) - return netbsd_build_xattr_streams(jcr, ff_pkt); -#endif +#ifdef HAVE_ACL +#ifdef HAVE_EXTENDED_ACL + int flags; + acl_t *aclp = NULL; + + /* + * See if this attribute has an ACL + */ + if ((fd != -1 && fpathconf(fd, _PC_ACL_ENABLED) > 0) || + pathconf(attrname, _PC_ACL_ENABLED) > 0) { + /* + * See if there is a non trivial acl on the file. + */ + if ((fd != -1 && facl_get(fd, ACL_NO_TRIVIAL, &aclp) != 0) || + acl_get(attrname, ACL_NO_TRIVIAL, &aclp) != 0) { + berrno be; + Jmsg3(jcr, M_ERROR, 0, _("Unable to get acl on xattr %s on file \"%s\": ERR=%s\n"), + attrname, jcr->last_fname, be.bstrerror()); + Dmsg3(100, "facl_get/acl_get of xattr %s on \"%s\" failed: ERR=%s\n", + attrname, jcr->last_fname, be.bstrerror()); + + return false; + } + + if (aclp != NULL) { +#if defined(ACL_SID_FMT) + /* + * New format flag added in newer Solaris versions. + */ + flags = ACL_APPEND_ID | ACL_COMPACT_FMT | ACL_SID_FMT; +#else + flags = ACL_APPEND_ID | ACL_COMPACT_FMT; +#endif /* ACL_SID_FMT */ + + *acl_text = acl_totext(aclp, flags); + acl_free(aclp); + } else { + *acl_text = NULL; + } + } else { + *acl_text = NULL; + } + + return true; +#else /* HAVE_EXTENDED_ACL */ + int n; + aclent_t *acls = NULL; + + /* + * See if this attribute has an ACL + */ + if (fd != -1) + n = facl(fd, GETACLCNT, 0, NULL); + else + n = acl(attrname, GETACLCNT, 0, NULL); + + if (n >= MIN_ACL_ENTRIES) { + acls = (aclent_t *)malloc(n * sizeof(aclent_t)); + if ((fd != -1 && facl(fd, GETACL, n, acls) != n) || + acl(attrname, GETACL, n, acls) != n) { + berrno be; + Jmsg3(jcr, M_ERROR, 0, _("Unable to get acl on xattr %s on file \"%s\": ERR=%s\n"), + attrname, jcr->last_fname, be.bstrerror()); + Dmsg3(100, "facl/acl of xattr %s on \"%s\" failed: ERR=%s\n", + attrname, jcr->last_fname, be.bstrerror()); + + free(acls); + return false; + } + + /* + * See if there is a non trivial acl on the file. + */ + if (!acl_is_trivial(n, acls)) { + if ((*acl_text = acltotext(acls, n)) == NULL) { + berrno be; + Jmsg3(jcr, M_ERROR, 0, _("Unable to get acl text on xattr %s on file \"%s\": ERR=%s\n"), + attrname, jcr->last_fname, be.bstrerror()); + Dmsg3(100, "acltotext of xattr %s on \"%s\" failed: ERR=%s\n", + attrname, jcr->last_fname, be.bstrerror()); + + free(acls); + return false; + } + } else { + *acl_text = NULL; + } + + free(acls); + } else { + *acl_text = NULL; + } + + return true; +#endif /* HAVE_EXTENDED_ACL */ +#else /* HAVE_ACL */ + return NULL; +#endif /* HAVE_ACL */ } -bool parse_xattr_stream(JCR *jcr, int stream) +/* + * Forward declaration for recursive function call. + */ +static bool solaris_archive_xattrs(JCR *jcr, const char *xattr_namespace, const char *attr_parent); + +/* + * Archive an extended or extensible attribute. + * This is stored as an opaque stream of bytes with the following encoding: + * + * \0\0\0 + * + * or for a hardlinked or symlinked attribute + * + * \0\0\0 + * + * xattr_name can be a subpath relative to the file the xattr is on. + * stat_buffer is the string representation of the stat struct. + * acl_string is an acl text when a non trivial acl is set on the xattr. + * actual_xattr_data is the content of the xattr file. + */ +static bool solaris_archive_xattr(JCR *jcr, int fd, const char *xattr_namespace, + const char *attrname, bool toplevel_hidden_dir, int stream) { + int cnt; + int attrfd = -1; + struct stat st; + struct xattr_link_cache_entry *xlce; + char target_attrname[PATH_MAX]; + char link_source[PATH_MAX]; + char *acl_text = NULL; + char attribs[MAXSTRING]; + char buffer[BUFSIZ]; + bool retval = false; + + snprintf(target_attrname, sizeof(target_attrname), "%s%s", xattr_namespace, attrname); + /* - * Based on the stream being passed in dispatch to the right function - * for parsing and restoring a specific xattr. The platform determines - * which streams are recognized and parsed and which are handled by - * the default case and ignored. As only one of the platform defines - * is true per compile we never end up with duplicate switch values. + * Get the stats of the extended or extensible attribute. */ - switch (stream) { -#if defined(HAVE_SUN_OS) + if (fstatat(fd, attrname, &st, AT_SYMLINK_NOFOLLOW) < 0) { + berrno be; + Jmsg3(jcr, M_ERROR, 0, _("Unable to get status on xattr %s on file \"%s\": ERR=%s\n"), + target_attrname, jcr->last_fname, be.bstrerror()); + Dmsg3(100, "fstatat of xattr %s on \"%s\" failed: ERR=%s\n", + target_attrname, jcr->last_fname, be.bstrerror()); + + goto cleanup; + } + + /* + * Based on the filetype perform the correct action. We support most filetypes here, more + * then the actual implementation on Solaris supports so some code may never get executed + * due to limitations in the implementation. + */ + switch (st.st_mode & S_IFMT) { + case S_IFIFO: + case S_IFCHR: + case S_IFBLK: + /* + * Get any acl on the xattr. + */ + if (!solaris_archive_xattr_acl(jcr, attrfd, attrname, &acl_text)) + goto cleanup; + + /* + * The current implementation of xattr on Solaris doesn't support this, but if it ever does we are prepared. + * Encode the stat struct into an ASCII representation. + */ + encode_stat(attribs, &st, 0, stream); + cnt = snprintf(buffer, sizeof(buffer), "%s%c%s%c%s%c", + target_attrname, 0, attribs, 0, (acl_text) ? acl_text : "", 0); + break; + case S_IFDIR: + /* + * Get any acl on the xattr. + */ + if (!solaris_archive_xattr_acl(jcr, attrfd, attrname, &acl_text)) + goto cleanup; + + /* + * See if this is the toplevel_hidden_dir being archived. + */ + if (toplevel_hidden_dir) { + /* + * Save the data for later storage when we encounter a real xattr. + * Encode the stat struct into an ASCII representation and jump out of the function. + */ + encode_stat(attribs, &st, 0, stream); + toplevel_hidden_dir_xattr_data_len = snprintf(toplevel_hidden_dir_xattr_data, + sizeof(toplevel_hidden_dir_xattr_data), + "%s%c%s%c%s%c", + target_attrname, 0, attribs, 0, + (acl_text) ? acl_text : "", 0); + + goto cleanup; + } else { + /* + * The current implementation of xattr on Solaris doesn't support this, but if it ever does we are prepared. + * Encode the stat struct into an ASCII representation. + */ + encode_stat(attribs, &st, 0, stream); + cnt = snprintf(buffer, sizeof(buffer), + "%s%c%s%c%s%c", + target_attrname, 0, attribs, 0, (acl_text) ? acl_text : "", 0); + } + break; + case S_IFREG: + /* + * If this is a hardlinked file check the inode cache for a hit. + */ + if (st.st_nlink > 1) { + /* + * See if the cache already knows this inode number. + */ + if ((xlce = find_xattr_link_cache_entry(st.st_ino)) != NULL) { + /* + * Generate a xattr encoding with the reference to the target in there. + */ + encode_stat(attribs, &st, st.st_ino, stream); + cnt = snprintf(buffer, sizeof(buffer), + "%s%c%s%c%s%c", + target_attrname, 0, attribs, 0, xlce->target, 0); + pm_memcpy(jcr->xattr_data, buffer, cnt); + jcr->xattr_data_len = cnt; + retval = send_xattr_stream(jcr, stream); + + /* + * For a hard linked file we are ready now, no need to recursively archive the attributes. + */ + goto cleanup; + } + + /* + * Store this hard linked file in the cache. + * Store the name relative to the top level xattr space. + */ + add_xattr_link_cache_entry(st.st_ino, target_attrname + 1); + } + + /* + * Get any acl on the xattr. + */ + if (!solaris_archive_xattr_acl(jcr, attrfd, attrname, &acl_text)) + goto cleanup; + + /* + * Encode the stat struct into an ASCII representation. + */ + encode_stat(attribs, &st, 0, stream); + cnt = snprintf(buffer, sizeof(buffer), + "%s%c%s%c%s%c", + target_attrname, 0, attribs, 0, (acl_text) ? acl_text : "", 0); + + /* + * Open the extended or extensible attribute file. + */ + if ((attrfd = openat(fd, attrname, O_RDONLY)) < 0) { + berrno be; + Jmsg3(jcr, M_ERROR, 0, _("Unable to open xattr %s on \"%s\": ERR=%s\n"), + target_attrname, jcr->last_fname, be.bstrerror()); + Dmsg3(100, "openat of xattr %s on \"%s\" failed: ERR=%s\n", + target_attrname, jcr->last_fname, be.bstrerror()); + + goto cleanup; + } + break; + case S_IFLNK: + /* + * The current implementation of xattr on Solaris doesn't support this, but if it ever does we are prepared. + * Encode the stat struct into an ASCII representation. + */ + if (readlink(attrname, link_source, sizeof(link_source)) < 0) { + berrno be; + Jmsg3(jcr, M_ERROR, 0, _("Unable to read symlin %s on \"%s\": ERR=%s\n"), + target_attrname, jcr->last_fname, be.bstrerror()); + Dmsg3(100, "readlink of xattr %s on \"%s\" failed: ERR=%s\n", + target_attrname, jcr->last_fname, be.bstrerror()); + + goto cleanup; + } + + /* + * Generate a xattr encoding with the reference to the target in there. + */ + encode_stat(attribs, &st, st.st_ino, stream); + cnt = snprintf(buffer, sizeof(buffer), + "%s%c%s%c%s%c", + target_attrname, 0, attribs, 0, link_source, 0); + pm_memcpy(jcr->xattr_data, buffer, cnt); + jcr->xattr_data_len = cnt; + retval = send_xattr_stream(jcr, stream); + + /* + * For a soft linked file we are ready now, no need to recursively archive the attributes. + */ + goto cleanup; + default: + goto cleanup; + } + + /* + * See if this is the first real xattr being saved. If it is save the toplevel_hidden_dir attributes first. + */ + if (nr_xattr_saved == 0) { + pm_memcpy(jcr->xattr_data, toplevel_hidden_dir_xattr_data, toplevel_hidden_dir_xattr_data_len); + jcr->xattr_data_len = toplevel_hidden_dir_xattr_data_len; + send_xattr_stream(jcr, STREAM_XATTR_SOLARIS); + } + + pm_memcpy(jcr->xattr_data, buffer, cnt); + jcr->xattr_data_len = cnt; + + /* + * Only dump the content of regular files. + */ + switch (st.st_mode & S_IFMT) { + case S_IFREG: + if (st.st_size > 0) { + /* + * Protect ourself against things getting out of hand. + */ + if (st.st_size >= MAX_XATTR_STREAM) { + Jmsg2(jcr, M_ERROR, 0, _("Xattr stream on file \"%s\" exceeds maximum size of %d bytes\n"), + jcr->last_fname, MAX_XATTR_STREAM); + + goto cleanup; + } + + while ((cnt = read(attrfd, buffer, sizeof(buffer))) > 0) { + jcr->xattr_data = check_pool_memory_size(jcr->xattr_data, jcr->xattr_data_len + cnt); + memcpy(jcr->xattr_data + jcr->xattr_data_len, buffer, cnt); + jcr->xattr_data_len += cnt; + } + + if (cnt < 0) { + Jmsg2(jcr, M_ERROR, 0, _("Unable to read content of xattr %s on file \"%s\"\n"), + target_attrname, jcr->last_fname); + Dmsg2(100, "read of data from xattr %s on \"%s\" failed\n", + target_attrname, jcr->last_fname); + + goto cleanup; + } + } + break; + default: + break; + } + + retval = send_xattr_stream(jcr, stream); + nr_xattr_saved++; + + /* + * Recursivly call solaris_archive_extended_attributes for archiving the attributes + * available on this extended attribute. + */ + if (retval) { + retval = solaris_archive_xattrs(jcr, xattr_namespace, attrname); + + /* + * The recursive call could change our working dir so change back to the wanted workdir. + */ + if (fchdir(fd) < 0) { + berrno be; + Jmsg2(jcr, M_ERROR, 0, _("Unable to chdir to xattr space of file \"%s\": ERR=%s\n"), + jcr->last_fname, be.bstrerror()); + Dmsg3(100, "Unable to fchdir to xattr space of file \"%s\" using fd %d: ERR=%s\n", + jcr->last_fname, fd, be.bstrerror()); + + goto cleanup; + } + } + +cleanup: + if (acl_text) + free(acl_text); + if (attrfd != -1) + close(attrfd); + + return retval; +} + +static bool solaris_archive_xattrs(JCR *jcr, const char *xattr_namespace, const char *attr_parent) +{ + const char *name; + int fd, filefd = -1, attrdirfd = -1; + DIR *dirp; + struct dirent *dp; + char current_xattr_namespace[PATH_MAX]; + bool retval = false; + + /* + * Determine what argument to use. Use attr_parent when set + * (recursive call) or jcr->last_fname for first call. Also save + * the current depth of the xattr_space we are in. + */ + if (attr_parent) { + name = attr_parent; + if (xattr_namespace) + snprintf(current_xattr_namespace, sizeof(current_xattr_namespace), "%s%s/", + xattr_namespace, attr_parent); + else + strcpy(current_xattr_namespace, "/"); + } else { + name = jcr->last_fname; + strcpy(current_xattr_namespace, "/"); + } + + /* + * Open the file on which to archive the xattrs read-only. + */ + if ((filefd = open(name, O_RDONLY | O_NONBLOCK)) < 0) { + berrno be; + Jmsg2(jcr, M_ERROR, 0, _("Unable to open file \"%s\": ERR=%s\n"), + jcr->last_fname, be.bstrerror()); + Dmsg2(100, "Unable to open file \"%s\": ERR=%s\n", + jcr->last_fname, be.bstrerror()); + + goto cleanup; + } + + /* + * Open the xattr naming space. + */ + if ((attrdirfd = openat(filefd, ".", O_RDONLY | O_XATTR)) < 0) { + switch (errno) { + case EINVAL: + /* + * Gentile way of the system saying this type of xattr layering is not supported. + * Which is not problem we just forget about this this xattr. + * But as this is not an error we return a positive return value. + */ + retval = true; + break; + default: + berrno be; + Jmsg3(jcr, M_ERROR, 0, _("Unable to open xattr space %s on file \"%s\": ERR=%s\n"), + name, jcr->last_fname, be.bstrerror()); + Dmsg3(100, "Unable to open xattr space %s on file \"%s\": ERR=%s\n", + name, jcr->last_fname, be.bstrerror()); + } + + goto cleanup; + } + + /* + * We need to change into the attribute directory to determine if each of the + * attributes should be archived. + */ + if (fchdir(attrdirfd) < 0) { + berrno be; + Jmsg2(jcr, M_ERROR, 0, _("Unable to chdir to xattr space on file \"%s\": ERR=%s\n"), + jcr->last_fname, be.bstrerror()); + Dmsg3(100, "Unable to fchdir to xattr space on file \"%s\" using fd %d: ERR=%s\n", + jcr->last_fname, attrdirfd, be.bstrerror()); + + goto cleanup; + } + + /* + * Save the data of the toplevel xattr hidden_dir. We save this one before anything + * else because the readdir returns "." entry after the extensible attr entry. + * And as we want this entry before anything else we better just save its data. + */ + if (!attr_parent) + solaris_archive_xattr(jcr, attrdirfd, current_xattr_namespace, ".", + true, STREAM_XATTR_SOLARIS); + + if ((fd = dup(attrdirfd)) == -1 || + (dirp = fdopendir(fd)) == (DIR *)NULL) { + berrno be; + Jmsg2(jcr, M_ERROR, 0, _("Unable to list the xattr space on file \"%s\": ERR=%s\n"), + jcr->last_fname, be.bstrerror()); + Dmsg3(100, "Unable to fdopendir xattr space on file \"%s\" using fd %d: ERR=%s\n", + jcr->last_fname, fd, be.bstrerror()); + + goto cleanup; + } + + /* + * Walk the namespace. + */ + while (dp = readdir(dirp)) { + /* + * Skip only the toplevel . dir. + */ + if (!attr_parent && !strcmp(dp->d_name, ".")) + continue; + + /* + * Skip all .. directories + */ + if (!strcmp(dp->d_name, "..")) + continue; + + Dmsg3(400, "processing extended attribute %s%s on file \"%s\"\n", + current_xattr_namespace, dp->d_name, jcr->last_fname); + +#if defined(HAVE_SYS_NVPAIR_H) && defined(_PC_SATTR_ENABLED) + /* + * We are not interested in read-only extensible attributes. + */ + if (!strcmp(dp->d_name, VIEW_READONLY)) { + Dmsg3(400, "Skipping readonly extensible attributes %s%s on file \"%s\"\n", + current_xattr_namespace, dp->d_name, jcr->last_fname); + + continue; + } + + /* + * We are only interested in read-write extensible attributes + * when they contain non-transient values. + */ + if (!strcmp(dp->d_name, VIEW_READWRITE)) { + /* + * Determine if there are non-transient system attributes at the toplevel. + * We need to provide a fd to the open file. + */ + if (!solaris_has_non_transient_extensible_attributes(filefd)) { + Dmsg3(400, "Skipping transient extensible attributes %s%s on file \"%s\"\n", + current_xattr_namespace, dp->d_name, jcr->last_fname); + + continue; + } + + /* + * Archive the xattr. + */ + solaris_archive_xattr(jcr, attrdirfd, current_xattr_namespace, dp->d_name, + false, STREAM_XATTR_SOLARIS_SYS); + continue; + } +#endif /* HAVE_SYS_NVPAIR_H && _PC_SATTR_ENABLED */ + + /* + * Archive the xattr. + */ + solaris_archive_xattr(jcr, attrdirfd, current_xattr_namespace, dp->d_name, + false, STREAM_XATTR_SOLARIS); + } + + closedir(dirp); + retval = true; + +cleanup: + if (attrdirfd != -1) + close(attrdirfd); + if (filefd != -1) + close(filefd); + + return retval; +} + +#ifdef HAVE_ACL +static bool solaris_restore_xattr_acl(JCR *jcr, int fd, const char *attrname, char *acl_text) +{ +#ifdef HAVE_EXTENDED_ACL + int error; + acl_t *aclp = NULL; + + if ((error = acl_fromtext(acl_text, &aclp)) != 0) { + return false; + } + + if ((fd != -1 && facl_set(fd, aclp) != 0) || + acl_set(attrname, aclp) != 0) { + berrno be; + Jmsg3(jcr, M_ERROR, 0, _("Unable to restore acl of xattr %s on file \"%s\": ERR=%s\n"), + attrname, jcr->last_fname, be.bstrerror()); + Dmsg3(100, "Unable to restore acl of xattr %s on file \"%s\": ERR=%s\n", + attrname, jcr->last_fname, be.bstrerror()); + + return false; + } + + if (aclp) + acl_free(aclp); + + return true; +#else /* HAVE_EXTENDED_ACL */ + int n; + aclent_t *acls = NULL; + + acls = aclfromtext(acl_text, &n); + if (!acls) { + if ((fd != -1 && facl(fd, SETACL, n, acls) != 0) || + acl(attrname, SETACL, n, acls) != 0) { + berrno be; + Jmsg3(jcr, M_ERROR, 0, _("Unable to restore acl of xattr %s on file \"%s\": ERR=%s\n"), + attrname, jcr->last_fname, be.bstrerror()); + Dmsg3(100, "Unable to restore acl of xattr %s on file \"%s\": ERR=%s\n", + attrname, jcr->last_fname, be.bstrerror()); + + return false; + } + } + + if (acls) + free(acls); + + return true; +#endif /* HAVE_EXTENDED_ACL */ +} +#endif /* HAVE_ACL */ + +static bool solaris_restore_xattrs(JCR *jcr, bool is_extensible) +{ + int fd, filefd = -1, attrdirfd = -1, attrfd = -1; + int used_bytes, total_bytes, cnt; + char *bp, *target_attrname, *attribs; + char *linked_target = NULL; + char *acl_text = NULL; + char *data = NULL; + int32_t inum; + struct stat st; + struct timeval times[2]; + bool retval = false; + + /* + * Parse the xattr stream. First the part that is the same for all xattrs. + */ + used_bytes = 0; + total_bytes = jcr->xattr_data_len; + + /* + * The name of the target xattr has a leading / we are not interested + * in that so skip it when decoding the string. We always start a the / + * of the xattr space anyway. + */ + target_attrname = jcr->xattr_data + 1; + if ((bp = strchr(target_attrname, '\0')) == (char *)NULL || + (used_bytes = (bp - jcr->xattr_data)) >= (total_bytes - 1)) { + goto parse_error; + } + attribs = ++bp; + + /* + * Open the file on which to restore the xattrs read-only. + */ + if ((filefd = open(jcr->last_fname, O_RDONLY | O_NONBLOCK)) < 0) { + berrno be; + Jmsg2(jcr, M_ERROR, 0, _("Unable to open file \"%s\": ERR=%s\n"), + jcr->last_fname, be.bstrerror()); + Dmsg2(100, "Unable to open file \"%s\": ERR=%s\n", + jcr->last_fname, be.bstrerror()); + + goto cleanup; + } + + /* + * Open the xattr naming space and make it the current working dir. + */ + if ((attrdirfd = openat(filefd, ".", O_RDONLY | O_XATTR)) < 0) { + berrno be; + Jmsg2(jcr, M_ERROR, 0, _("Unable to open xattr space on file \"%s\": ERR=%s\n"), + jcr->last_fname, be.bstrerror()); + Dmsg2(100, "Unable to open xattr space on file \"%s\": ERR=%s\n", + jcr->last_fname, be.bstrerror()); + + goto cleanup; + } + + if (fchdir(attrdirfd) < 0) { + berrno be; + Jmsg2(jcr, M_ERROR, 0, _("Unable to chdir to xattr space on file \"%s\": ERR=%s\n"), + jcr->last_fname, be.bstrerror()); + Dmsg3(100, "Unable to fchdir to xattr space on file \"%s\" using fd %d: ERR=%s\n", + jcr->last_fname, attrdirfd, be.bstrerror()); + + goto cleanup; + } + + /* + * Try to open the correct xattr subdir based on the target_attrname given. + * e.g. check if its a subdir attrname. Each / in the string makes us go + * one level deeper. + */ + while ((bp = strchr(target_attrname, '/')) != (char *)NULL) { + *bp = '\0'; + + if ((fd = open(target_attrname, O_RDONLY | O_NONBLOCK)) < 0) { + berrno be; + Jmsg3(jcr, M_ERROR, 0, _("Unable to open xattr %s on file \"%s\": ERR=%s\n"), + target_attrname, jcr->last_fname, be.bstrerror()); + Dmsg3(100, "Unable to open xattr %s on file \"%s\": ERR=%s\n", + target_attrname, jcr->last_fname, be.bstrerror()); + + goto cleanup; + } + + close(filefd); + filefd = fd; + + /* + * Open the xattr naming space. + */ + if ((fd = openat(filefd, ".", O_RDONLY | O_XATTR)) < 0) { + berrno be; + Jmsg3(jcr, M_ERROR, 0, _("Unable to open xattr space %s on file \"%s\": ERR=%s\n"), + target_attrname, jcr->last_fname, be.bstrerror()); + Dmsg3(100, "Unable to open xattr space %s on file \"%s\": ERR=%s\n", + target_attrname, jcr->last_fname, be.bstrerror()); + + goto cleanup; + } + + close(attrdirfd); + attrdirfd = fd; + + /* + * Make the xattr space our current workingdir. + */ + if (fchdir(attrdirfd) < 0) { + berrno be; + Jmsg3(jcr, M_ERROR, 0, _("Unable to chdir to xattr space %s on file \"%s\": ERR=%s\n"), + target_attrname, jcr->last_fname, be.bstrerror()); + Dmsg4(100, "Unable to fchdir to xattr space %s on file \"%s\" using fd %d: ERR=%s\n", + target_attrname, jcr->last_fname, attrdirfd, be.bstrerror()); + + goto cleanup; + } + + target_attrname = ++bp; + } + + /* + * Decode the attributes from the stream. + */ + decode_stat(attribs, &st, &inum); + + /* + * Decode the next field (acl_text). + */ + if ((bp = strchr(attribs, '\0')) == (char *)NULL || + (used_bytes = (bp - jcr->xattr_data)) >= (total_bytes - 1)) { + goto parse_error; + } + acl_text = ++bp; + + /* + * Based on the filetype perform the correct action. We support most filetypes here, more + * then the actual implementation on Solaris supports so some code may never get executed + * due to limitations in the implementation. + */ + switch (st.st_mode & S_IFMT) { + case S_IFIFO: + /* + * The current implementation of xattr on Solaris doesn't support this, but if it ever does we are prepared. + */ + unlinkat(attrdirfd, target_attrname, 0); + if (mkfifo(target_attrname, st.st_mode) < 0) { + berrno be; + Jmsg3(jcr, M_ERROR, 0, _("Unable to mkfifo xattr %s on file \"%s\": ERR=%s\n"), + target_attrname, jcr->last_fname, be.bstrerror()); + Dmsg3(100, "Unable to mkfifo xattr %s on file \"%s\": ERR=%s\n", + target_attrname, jcr->last_fname, be.bstrerror()); + + goto cleanup; + } + break; + case S_IFCHR: + case S_IFBLK: + /* + * The current implementation of xattr on Solaris doesn't support this, but if it ever does we are prepared. + */ + unlinkat(attrdirfd, target_attrname, 0); + if (mknod(target_attrname, st.st_mode, st.st_rdev) < 0) { + berrno be; + Jmsg3(jcr, M_ERROR, 0, _("Unable to mknod xattr %s on file \"%s\": ERR=%s\n"), + target_attrname, jcr->last_fname, be.bstrerror()); + Dmsg3(100, "Unable to mknod xattr %s on file \"%s\": ERR=%s\n", + target_attrname, jcr->last_fname, be.bstrerror()); + + goto cleanup; + } + break; + case S_IFDIR: + /* + * If its not the hidden_dir create the entry. + * The current implementation of xattr on Solaris doesn't support this, but if it ever does we are prepared. + */ + if (strcmp(target_attrname, ".")) { + unlinkat(attrdirfd, target_attrname, AT_REMOVEDIR); + if (mkdir(target_attrname, st.st_mode) < 0) { + berrno be; + Jmsg3(jcr, M_WARNING, 0, _("Unable to mkdir xattr %s on file \"%s\": ERR=%s\n"), + target_attrname, jcr->last_fname, be.bstrerror()); + Dmsg3(100, "Unable to mkdir xattr %s on file \"%s\": ERR=%s\n", + target_attrname, jcr->last_fname, be.bstrerror()); + + goto cleanup; + } + } + break; + case S_IFREG: + /* + * See if this is a hard linked file. e.g. inum != 0 + */ + if (inum != 0) { + linked_target = bp; + + unlinkat(attrdirfd, target_attrname, 0); + if (link(linked_target, target_attrname) < 0) { + berrno be; + Jmsg4(jcr, M_ERROR, 0, _("Unable to link xattr %s to %s on file \"%s\": ERR=%s\n"), + target_attrname, linked_target, jcr->last_fname, be.bstrerror()); + Dmsg4(100, "Unable to link xattr %s to %s on file \"%s\": ERR=%s\n", + target_attrname, linked_target, jcr->last_fname, be.bstrerror()); + + goto cleanup; + } + + /* + * Successfully restored xattr. + */ + retval = true; + goto cleanup; + } else { + if ((bp = strchr(acl_text, '\0')) == (char *)NULL || + (used_bytes = (bp - jcr->xattr_data)) >= total_bytes) { + goto parse_error; + } + + if (used_bytes < (total_bytes - 1)) + data = ++bp; + + /* + * Restore the actual xattr. + */ + if (!is_extensible) { + unlinkat(attrdirfd, target_attrname, 0); + } + + if ((attrfd = openat(attrdirfd, target_attrname, O_RDWR | O_CREAT | O_TRUNC, st.st_mode)) < 0) { + berrno be; + Jmsg3(jcr, M_ERROR, 0, _("Unable to open xattr %s on file \"%s\": ERR=%s\n"), + target_attrname, jcr->last_fname, be.bstrerror()); + Dmsg3(100, "Unable to open xattr %s on file \"%s\": ERR=%s\n", + target_attrname, jcr->last_fname, be.bstrerror()); + + goto cleanup; + } + } + + /* + * Restore the actual data. + */ + if (st.st_size > 0) { + used_bytes = (data - jcr->xattr_data); + cnt = total_bytes - used_bytes; + + /* + * Do a sanity check, the st.st_size should be the same as the number of bytes + * we have available as data of the stream. + */ + if (cnt != st.st_size) { + Jmsg2(jcr, M_ERROR, 0, _("Unable to restore data of xattr %s on file \"%s\": Not all data available in xattr stream\n"), + target_attrname, jcr->last_fname); + Dmsg2(100, "Unable to restore data of xattr %s on file \"%s\": Not all data available in xattr stream\n", + target_attrname, jcr->last_fname); + + goto cleanup; + } + + while (cnt > 0) { + cnt = write(attrfd, data, cnt); + if (cnt < 0) { + berrno be; + Jmsg3(jcr, M_ERROR, 0, _("Unable to restore data of xattr %s on file \"%s\": ERR=%s\n"), + target_attrname, jcr->last_fname, be.bstrerror()); + Dmsg3(100, "Unable to restore data of xattr %s on file \"%s\": ERR=%s\n", + target_attrname, jcr->last_fname, be.bstrerror()); + + goto cleanup; + } + + used_bytes += cnt; + data += cnt; + cnt = total_bytes - used_bytes; + } + } + break; + case S_IFLNK: + /* + * The current implementation of xattr on Solaris doesn't support this, but if it ever does we are prepared. + */ + linked_target = bp; + + if (symlink(linked_target, target_attrname) < 0) { + berrno be; + Jmsg4(jcr, M_ERROR, 0, _("Unable to symlink xattr %s to %s on file \"%s\": ERR=%s\n"), + target_attrname, linked_target, jcr->last_fname, be.bstrerror()); + Dmsg4(100, "Unable to symlink xattr %s to %s on file \"%s\": ERR=%s\n", + target_attrname, linked_target, jcr->last_fname, be.bstrerror()); + + goto cleanup; + } + + /* + * Successfully restored xattr. + */ + retval = true; + goto cleanup; + default: + goto cleanup; + } + + /* + * Restore owner and acl for non extensible attributes. + */ + if (!is_extensible) { + if (fchownat(attrdirfd, target_attrname, st.st_uid, st.st_gid, AT_SYMLINK_NOFOLLOW) < 0) { + switch (errno) { + case EINVAL: + /* + * Gentile way of the system saying this type of xattr layering is not supported. + * But as this is not an error we return a positive return value. + */ + retval = true; + break; + default: + berrno be; + Jmsg3(jcr, M_ERROR, 0, _("Unable to restore owner of xattr %s on file \"%s\": ERR=%s\n"), + target_attrname, jcr->last_fname, be.bstrerror()); + Dmsg3(100, "Unable to restore owner of xattr %s on file \"%s\": ERR=%s\n", + target_attrname, jcr->last_fname, be.bstrerror()); + } + + goto cleanup; + } + } + +#ifdef HAVE_ACL + if (acl_text && *acl_text) + if (!solaris_restore_xattr_acl(jcr, attrfd, target_attrname, acl_text)) + goto cleanup; +#endif /* HAVE_ACL */ + + /* + * For a non extensible attribute restore access and modification time on the xattr. + */ + if (!is_extensible) { + times[0].tv_sec = st.st_atime; + times[0].tv_usec = 0; + times[1].tv_sec = st.st_mtime; + times[1].tv_usec = 0; + + if (futimesat(attrdirfd, target_attrname, times) < 0) { + berrno be; + Jmsg3(jcr, M_ERROR, 0, _("Unable to restore filetimes of xattr %s on file \"%s\": ERR=%s\n"), + target_attrname, jcr->last_fname, be.bstrerror()); + Dmsg3(100, "Unable to restore filetimes of xattr %s on file \"%s\": ERR=%s\n", + target_attrname, jcr->last_fname, be.bstrerror()); + + goto cleanup; + } + } + + /* + * Successfully restored xattr. + */ + retval = true; + goto cleanup; + +parse_error: + Jmsg1(jcr, M_ERROR, 0, _("Illegal xattr stream, failed to parse xattr stream on file \"%s\"\n"), + jcr->last_fname); + Dmsg1(100, "Illegal xattr stream, failed to parse xattr stream on file \"%s\"\n", + jcr->last_fname); + +cleanup: + if (attrfd != -1) + close(attrfd); + if (attrdirfd != -1) + close(attrdirfd); + if (filefd != -1) + close(filefd); + + return retval; +} + +static bool solaris_extract_xattr(JCR *jcr, int stream) +{ + char cwd[PATH_MAX]; + bool is_extensible = false; + bool retval; + + /* + * First make sure we can restore xattr on the filesystem. + */ + switch (stream) { +#if defined(HAVE_SYS_NVPAIR_H) && defined(_PC_SATTR_ENABLED) + case STREAM_XATTR_SOLARIS_SYS: + if (pathconf(jcr->last_fname, _PC_SATTR_ENABLED) <= 0) { + Qmsg1(jcr, M_WARNING, 0, + _("Failed to restore extensible attributes on file \"%s\"\n"), + jcr->last_fname); + Dmsg1(100, "Unable to restore extensible attributes on file \"%s\", filesystem doesn't support this\n", + jcr->last_fname); + + return false; + } + + is_extensible = true; + break; +#endif + case STREAM_XATTR_SOLARIS: + if (pathconf(jcr->last_fname, _PC_XATTR_ENABLED) <= 0) { + Qmsg1(jcr, M_WARNING, 0, + _("Failed to restore extended attributes on file \"%s\"\n"), + jcr->last_fname); + Dmsg1(100, "Unable to restore extended attributes on file \"%s\", filesystem doesn't support this\n", + jcr->last_fname); + + return false; + } + + break; + default: + return false; + } + + /* + * As we change the cwd in the restore function save the current cwd + * for restore after return from the solaris_restore_xattrs function. + */ + getcwd(cwd, sizeof(cwd)); + retval = solaris_restore_xattrs(jcr, is_extensible); + chdir(cwd); + + return retval; +} + +static int solaris_build_xattr_streams(JCR *jcr, FF_PKT *ff_pkt) +{ + char cwd[PATH_MAX]; + bool retval = true; + + /* + * First see if extended attributes or extensible attributes are present. + * If not just pretend things went ok. + */ + if (pathconf(jcr->last_fname, _PC_XATTR_EXISTS) > 0) { + nr_xattr_saved = 0; + + /* + * As we change the cwd in the archive function save the current cwd + * for restore after return from the solaris_archive_xattrs function. + */ + getcwd(cwd, sizeof(cwd)); + retval = solaris_archive_xattrs(jcr, NULL, NULL); + chdir(cwd); + + drop_xattr_link_cache(); + } + + return retval; +} + +static bool solaris_parse_xattr_stream(JCR *jcr, int stream) +{ + switch (stream) { +#if defined(HAVE_SYS_NVPAIR_H) && defined(_PC_SATTR_ENABLED) + case STREAM_XATTR_SOLARIS_SYS: +#endif + case STREAM_XATTR_SOLARIS: + return solaris_extract_xattr(jcr, stream); + default: + return false; + } +} +#endif + +bool build_xattr_streams(JCR *jcr, FF_PKT *ff_pkt) +{ +#if defined(HAVE_SUN_OS) + return solaris_build_xattr_streams(jcr, ff_pkt); +#elif defined(HAVE_DARWIN_OS) + return darwin_build_xattr_streams(jcr, ff_pkt); +#elif defined(HAVE_FREEBSD_OS) + return freebsd_build_xattr_streams(jcr, ff_pkt); +#elif defined(HAVE_LINUX_OS) + return linux_build_xattr_streams(jcr, ff_pkt); +#elif defined(HAVE_NETBSD_OS) + return netbsd_build_xattr_streams(jcr, ff_pkt); +#endif +} + +bool parse_xattr_stream(JCR *jcr, int stream) +{ + /* + * Based on the stream being passed in dispatch to the right function + * for parsing and restoring a specific xattr. The platform determines + * which streams are recognized and parsed and which are handled by + * the default case and ignored. As only one of the platform defines + * is true per compile we never end up with duplicate switch values. + */ + switch (stream) { +#if defined(HAVE_SUN_OS) +#if defined(HAVE_SYS_NVPAIR_H) && defined(_PC_SATTR_ENABLED) + case STREAM_XATTR_SOLARIS_SYS: +#endif case STREAM_XATTR_SOLARIS: return solaris_parse_xattr_stream(jcr, stream); #elif defined(HAVE_DARWIN_OS) diff --git a/bacula/src/filed/xattr.h b/bacula/src/filed/xattr.h index 8044c42d0a..2adec4fb97 100644 --- a/bacula/src/filed/xattr.h +++ b/bacula/src/filed/xattr.h @@ -1,7 +1,7 @@ /* Bacula® - The Network Backup Solution - Copyright (C) 2004-2008 Free Software Foundation Europe e.V. + Copyright (C) 2004-2009 Free Software Foundation Europe e.V. The main author of Bacula is Kern Sibbald, with contributions from many others, a complete list can be found in the file AUTHORS. @@ -46,4 +46,18 @@ typedef struct xattr { char *value; } xattr_t; +/* + * Internal representation of an extended attribute hardlinked file. + */ +typedef struct xattr_link_cache_entry { + uint32_t inum; + char target[PATH_MAX]; + struct xattr_link_cache_entry *next; +} xattr_link_cache_entry_t; + +/* + * Maximum size of the XATTR stream this prevents us from blowing up the filed. + */ +#define MAX_XATTR_STREAM (1 * 1024 * 1024) /* 1 Mb */ + #endif diff --git a/bacula/src/findlib/attribs.c b/bacula/src/findlib/attribs.c index c9f8521998..341ec2206c 100644 --- a/bacula/src/findlib/attribs.c +++ b/bacula/src/findlib/attribs.c @@ -162,10 +162,10 @@ int select_data_stream(FF_PKT *ff_pkt) * them in the encode_attribsEx() subroutine, but this is * not recommended. */ -void encode_stat(char *buf, FF_PKT *ff_pkt, int data_stream) +void encode_stat(char *buf, struct stat *statp, int32_t LinkFI, int data_stream) { char *p = buf; - struct stat *statp = &ff_pkt->statp; + /* * Encode a stat packet. I should have done this more intelligently * with a length so that it could be easily expanded. @@ -203,7 +203,7 @@ void encode_stat(char *buf, FF_PKT *ff_pkt, int data_stream) *p++ = ' '; p += to_base64((int64_t)statp->st_ctime, p); *p++ = ' '; - p += to_base64((int64_t)ff_pkt->LinkFI, p); + p += to_base64((int64_t)LinkFI, p); *p++ = ' '; #ifdef HAVE_CHFLAGS diff --git a/bacula/src/findlib/bfile.c b/bacula/src/findlib/bfile.c index 8c8c5bee0c..20999d935a 100644 --- a/bacula/src/findlib/bfile.c +++ b/bacula/src/findlib/bfile.c @@ -169,8 +169,10 @@ const char *stream_to_ascii(int stream) return _("Solaris Specific ACL attribs"); case STREAM_ACL_SOLARIS_ACE: return _("Solaris Specific ACL attribs"); + case STREAM_XATTR_SOLARIS_SYS: + return _("Solaris Specific Extensible attribs or System Extended attribs"); case STREAM_XATTR_SOLARIS: - return _("Solaris Specific Extended attribs and Extensible attribs"); + return _("Solaris Specific Extended attribs"); case STREAM_XATTR_DARWIN: return _("Darwin Specific Extended attribs"); case STREAM_XATTR_FREEBSD: diff --git a/bacula/src/findlib/protos.h b/bacula/src/findlib/protos.h index 83064d070d..6fafb62eaa 100644 --- a/bacula/src/findlib/protos.h +++ b/bacula/src/findlib/protos.h @@ -32,7 +32,7 @@ */ /* from attribs.c */ -void encode_stat (char *buf, FF_PKT *ff_pkt, int data_stream); +void encode_stat (char *buf, struct stat *statp, int32_t LinkFI, int data_stream); int decode_stat (char *buf, struct stat *statp, int32_t *LinkFI); int32_t decode_LinkFI (char *buf, struct stat *statp); int encode_attribsEx (JCR *jcr, char *attribsEx, FF_PKT *ff_pkt); diff --git a/bacula/src/lib/base64.c b/bacula/src/lib/base64.c index 87ab2c327d..02e42639c7 100644 --- a/bacula/src/lib/base64.c +++ b/bacula/src/lib/base64.c @@ -251,7 +251,7 @@ int main(int argc, char *argv[]) printf("Cannot stat %s: %s\n", fname, be.bstrerror(errno)); continue; } - encode_stat(where, &statp); + encode_stat(where, &statp, 0, 0); printf("Encoded stat=%s\n", where); @@ -297,7 +297,7 @@ int main(int argc, char *argv[]) statp.st_ctime != statn.st_ctime) { printf("%s: %s\n", fname, where); - encode_stat(where, &statn); + encode_stat(where, &statn, 0, 0); printf("%s: %s\n", fname, where); printf("NOT EQAL\n"); } diff --git a/bacula/src/stored/bscan.c b/bacula/src/stored/bscan.c index 17940eb75d..0a65d0d6dd 100644 --- a/bacula/src/stored/bscan.c +++ b/bacula/src/stored/bscan.c @@ -810,6 +810,7 @@ static bool record_cb(DCR *dcr, DEV_RECORD *rec) /* Ignore Unix ACL attributes */ break; + case STREAM_XATTR_SOLARIS_SYS: case STREAM_XATTR_SOLARIS: case STREAM_XATTR_DARWIN: case STREAM_XATTR_FREEBSD: diff --git a/bacula/technotes-2.5 b/bacula/technotes-2.5 index 0f7cf5e127..a8e3f82d69 100644 --- a/bacula/technotes-2.5 +++ b/bacula/technotes-2.5 @@ -25,6 +25,14 @@ filepattern (restore with regex in bsr) mixed priorities General: +28Feb09 +mvw Implemented xattr support for Solaris 9 and above and extensible + attributes for OpenSolaris. +mvw Added some limits to the xattr code so that we don't blow up the + filed on big xattrs. +mvw Fixed some comments which changed due to xattrs being implemented. +mvw Changed xattr support checking in configure to test first for + generic solutions and when not found for specific OS functions. 25Feb09 mvw Don't try to copy empty jobs (e.g. with jobbytes == 0) which gives Unable to get Job Volume Parameters errors. -- 2.39.5