X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=bacula%2Fsrc%2Ffiled%2Fxattr.c;h=5781e76feb44bf136ef0b111d33fd8e07c5d5dc7;hb=cdf54bf846ee8177604133eca433417401a7f44f;hp=2c0b4aaeafeb96b9c3bc4511d02e4719ef144d9e;hpb=173d70a431c01b7235d70458208e2843932d472d;p=bacula%2Fbacula diff --git a/bacula/src/filed/xattr.c b/bacula/src/filed/xattr.c index 2c0b4aaeaf..5781e76feb 100644 --- a/bacula/src/filed/xattr.c +++ b/bacula/src/filed/xattr.c @@ -1,12 +1,12 @@ /* Bacula® - The Network Backup Solution - Copyright (C) 2008-2009 Free Software Foundation Europe e.V. + Copyright (C) 2008-2010 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. This program is Free Software; you can redistribute it and/or - modify it under the terms of version two of the GNU General Public + modify it under the terms of version three of the GNU Affero General Public License as published by the Free Software Foundation and included in the file LICENSE. @@ -15,7 +15,7 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. - You should have received a copy of the GNU General Public License + You should have received a copy of the GNU Affero General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. @@ -25,58 +25,65 @@ (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich, Switzerland, email:ftf@fsfeurope.org. */ -/* +/** * Functions to handle Extended Attributes for bacula. * * Extended Attributes are so OS specific we only restore Extended Attributes if * they were saved using a filed on the same platform. * * Currently we support the following OSes: - * - FreeBSD (Extended Attributes) + * - AIX (Extended Attributes) * - Darwin (Extended Attributes) + * - FreeBSD (Extended Attributes) + * - IRIX (Extended Attributes) * - Linux (Extended Attributes) * - NetBSD (Extended Attributes) + * - OpenBSD (Extended Attributes) + * (As it seems either they never implemented xattr or they are removed + * the support as it stated it was in version 3.1 but the current syscall + * tabled shows the extattr_ functions are not implemented. So as such we + * might eventually support xattr on OpenBSD when they implemented them using + * the same interface as FreeBSD and NetBSD. * - Solaris (Extended Attributes and Extensible Attributes) + * - Tru64 (Extended Attributes) * * Written by Marco van Wieringen, November MMVIII - * - * Version $Id$ */ #include "bacula.h" #include "filed.h" -#include "xattr.h" #if !defined(HAVE_XATTR) -/* +/** * Entry points when compiled without support for XATTRs or on an unsupported platform. */ -bsub_exit_code build_xattr_streams(JCR *jcr, FF_PKT *ff_pkt) +bxattr_exit_code build_xattr_streams(JCR *jcr, FF_PKT *ff_pkt) { - return bsub_exit_fatal; + return bxattr_exit_fatal; } -bsub_exit_code parse_xattr_streams(JCR *jcr, int stream) +bxattr_exit_code parse_xattr_streams(JCR *jcr, int stream) { - return bsub_exit_fatal; + return bxattr_exit_fatal; } #else -/* +/** * Send a XATTR stream to the SD. */ -static bsub_exit_code send_xattr_stream(JCR *jcr, int stream) +static bxattr_exit_code send_xattr_stream(JCR *jcr, int stream) { BSOCK *sd = jcr->store_bsock; POOLMEM *msgsave; #ifdef FD_NO_SEND_TEST - return bsub_exit_ok; + return bxattr_exit_ok; #endif /* * Sanity check */ - if (jcr->xattr_data_len <= 0) - return bsub_exit_ok; + if (jcr->xattr_data->content_length <= 0) { + return bxattr_exit_ok; + } /* * Send header @@ -84,22 +91,22 @@ static bsub_exit_code send_xattr_stream(JCR *jcr, int stream) if (!sd->fsend("%ld %d 0", jcr->JobFiles, stream)) { Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"), sd->bstrerror()); - return bsub_exit_fatal; + return bxattr_exit_fatal; } /* * Send the buffer to the storage deamon */ - Dmsg1(400, "Backing up XATTR <%s>\n", jcr->xattr_data); + Dmsg1(400, "Backing up XATTR <%s>\n", jcr->xattr_data->content); msgsave = sd->msg; - sd->msg = jcr->xattr_data; - sd->msglen = jcr->xattr_data_len; + sd->msg = jcr->xattr_data->content; + sd->msglen = jcr->xattr_data->content_length; if (!sd->send()) { sd->msg = msgsave; sd->msglen = 0; Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"), sd->bstrerror()); - return bsub_exit_fatal; + return bxattr_exit_fatal; } jcr->JobBytes += sd->msglen; @@ -107,92 +114,43 @@ static bsub_exit_code send_xattr_stream(JCR *jcr, int stream) if (!sd->signal(BNET_EOD)) { Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"), sd->bstrerror()); - return bsub_exit_fatal; + return bxattr_exit_fatal; } Dmsg1(200, "XATTR of file: %s successfully backed up!\n", jcr->last_fname); - return bsub_exit_ok; + return bxattr_exit_ok; } -/* - * 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 - -/* - * All these os-es have 1 xattr stream. - */ -#if defined(HAVE_DARWIN_OS) -static int os_default_xattr_streams[1] = { STREAM_XATTR_DARWIN }; -#elif defined(HAVE_FREEBSD_OS) -static int os_default_xattr_streams[1] = { STREAM_XATTR_FREEBSD }; -#elif defined(HAVE_LINUX_OS) -static int os_default_xattr_streams[1] = { STREAM_XATTR_LINUX }; -#elif defined(HAVE_NETBSD_OS) -static int os_default_xattr_streams[1] = { STREAM_XATTR_NETBSD }; -#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. +/** + * First some generic functions for OSes that use the same xattr encoding scheme. + * Currently for all OSes except for Solaris. */ -#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) +#if !defined(HAVE_SUN_OS) +static void xattr_drop_internal_table(alist *xattr_value_list) { xattr_t *current_xattr; /* * Walk the list of xattrs and free allocated memory on traversing. */ - for (current_xattr = xattr_value_list; - current_xattr != (xattr_t *)NULL; - current_xattr++) { + foreach_alist(current_xattr, xattr_value_list) { /* * See if we can shortcut. */ - if (current_xattr->magic != XATTR_MAGIC) + if (current_xattr == NULL || current_xattr->magic != XATTR_MAGIC) break; free(current_xattr->name); if (current_xattr->value_length > 0) free(current_xattr->value); + + free(current_xattr); } - /* - * Free the array of control structs. - */ - free(xattr_value_list); + delete 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. * @@ -206,7 +164,7 @@ static void xattr_drop_internal_table(xattr_t *xattr_value_list) * 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) +static uint32_t serialize_xattr_stream(JCR *jcr, uint32_t expected_serialize_len, alist *xattr_value_list) { xattr_t *current_xattr; ser_declare; @@ -215,17 +173,17 @@ static uint32_t serialize_xattr_stream(JCR *jcr, uint32_t expected_serialize_len * Make sure the serialized stream fits in the poolmem buffer. * We allocate some more to be sure the stream is gonna fit. */ - jcr->xattr_data = check_pool_memory_size(jcr->xattr_data, expected_serialize_len + 10); - ser_begin(jcr->xattr_data, expected_serialize_len + 10); + jcr->xattr_data->content = check_pool_memory_size(jcr->xattr_data->content, expected_serialize_len + 10); + ser_begin(jcr->xattr_data->content, expected_serialize_len + 10); /* * Walk the list of xattrs and serialize the data. */ - for (current_xattr = xattr_value_list; current_xattr != (xattr_t *)NULL; current_xattr++) { + foreach_alist(current_xattr, xattr_value_list) { /* * See if we can shortcut. */ - if (current_xattr->magic != XATTR_MAGIC) + if (current_xattr == NULL || current_xattr->magic != XATTR_MAGIC) break; ser_uint32(current_xattr->magic); @@ -233,41 +191,174 @@ static uint32_t serialize_xattr_stream(JCR *jcr, uint32_t expected_serialize_len ser_bytes(current_xattr->name, current_xattr->name_length); ser_uint32(current_xattr->value_length); - ser_bytes(current_xattr->value, current_xattr->value_length); + if (current_xattr->value_length > 0 && current_xattr->value) { + ser_bytes(current_xattr->value, current_xattr->value_length); + + Dmsg3(100, "Backup xattr named %s, value %*s\n", + current_xattr->name, current_xattr->value, current_xattr->value); + } else { + Dmsg1(100, "Backup empty xattr named %s\n", current_xattr->name); + } + } + + ser_end(jcr->xattr_data->content, expected_serialize_len + 10); + jcr->xattr_data->content_length = ser_length(jcr->xattr_data->content); + + return jcr->xattr_data->content_length; +} + +static bxattr_exit_code unserialize_xattr_stream(JCR *jcr, alist *xattr_value_list) +{ + unser_declare; + xattr_t *current_xattr; + bxattr_exit_code retval = bxattr_exit_ok; + + /** + * Parse the stream and call restore_xattr_on_file for each extended attribute. + * + * Start unserializing the data. We keep on looping while we have not + * unserialized all bytes in the stream. + */ + unser_begin(jcr->xattr_data->content, jcr->xattr_data->content_length); + while (unser_length(jcr->xattr_data->content) < jcr->xattr_data->content_length) { + /* + * First make sure the magic is present. This way we can easily catch corruption. + * Any missing MAGIC is fatal we do NOT try to continue. + */ + current_xattr = (xattr_t *)malloc(sizeof(xattr_t)); + unser_uint32(current_xattr->magic); + if (current_xattr->magic != XATTR_MAGIC) { + Mmsg1(jcr->errmsg, _("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); + free(current_xattr); + return bxattr_exit_error; + } + + /* + * Decode the valuepair. First decode the length of the name. + */ + unser_uint32(current_xattr->name_length); + if (current_xattr->name_length == 0) { + Mmsg1(jcr->errmsg, _("Illegal xattr stream, xattr name length <= 0 on file \"%s\"\n"), + jcr->last_fname); + Dmsg1(100, "Illegal xattr stream, xattr name length <= 0 on file \"%s\"\n", + jcr->last_fname); + free(current_xattr); + return bxattr_exit_error; + } + + /* + * Allocate room for the name and decode its content. + */ + current_xattr->name = (char *)malloc(current_xattr->name_length + 1); + unser_bytes(current_xattr->name, current_xattr->name_length); + + /* + * The xattr_name needs to be null terminated. + */ + current_xattr->name[current_xattr->name_length] = '\0'; + + /* + * Decode the value length. + */ + unser_uint32(current_xattr->value_length); + + if (current_xattr->value_length > 0) { + /* + * Allocate room for the value and decode its content. + */ + current_xattr->value = (char *)malloc(current_xattr->value_length); + unser_bytes(current_xattr->value, current_xattr->value_length); + + Dmsg3(100, "Restoring xattr named %s, value %*s\n", + current_xattr->name, current_xattr->value, current_xattr->value); + } else { + current_xattr->value = NULL; + Dmsg1(100, "Restoring empty xattr named %s\n", current_xattr->name); + } + + xattr_value_list->append(current_xattr); } - ser_end(jcr->xattr_data, expected_serialize_len + 10); - jcr->xattr_data_len = ser_length(jcr->xattr_data); - return jcr->xattr_data_len; + unser_end(jcr->xattr_data->content, jcr->xattr_data->content_length); + return retval; } +#endif + +/* + * This is a supported OS, See what kind of interface we should use. + */ +#if defined(HAVE_AIX_OS) + +#if (!defined(HAVE_LISTEA) && !defined(HAVE_LLISTEA)) || \ + (!defined(HAVE_GETEA) && !defined(HAVE_LGETEA)) || \ + (!defined(HAVE_SETEA) && !defined(HAVE_LSETEA)) +#error "Missing full support for the Extended Attributes (EA) functions." +#endif + +#ifdef HAVE_SYS_EA_H +#include +#else +#error "Missing sys/ea.h header file" +#endif + +/* + * Define the supported XATTR streams for this OS + */ +static int os_default_xattr_streams[1] = { STREAM_XATTR_AIX }; + +/* + * Fallback to the non l-functions when those are not available. + */ +#if defined(HAVE_GETEA) && !defined(HAVE_LGETEA) +#define lgetea getea +#endif +#if defined(HAVE_SETEA) && !defined(HAVE_LSETEA) +#define lsetea setea +#endif +#if defined(HAVE_LISTEA) && !defined(HAVE_LLISTEA) +#define llistea listea +#endif -static bsub_exit_code generic_xattr_build_streams(JCR *jcr, FF_PKT *ff_pkt, int default_stream) +static bxattr_exit_code aix_xattr_build_streams(JCR *jcr, FF_PKT *ff_pkt) { - int count = 0; + bool skip_xattr; + char *xattr_list, *bp; + int cnt, xattr_count = 0; + uint32_t name_length; int32_t xattr_list_len, xattr_value_len; uint32_t expected_serialize_len = 0; - char *xattr_list, *bp; - xattr_t *xattr_value_list, *current_xattr; + xattr_t *current_xattr = NULL; + alist *xattr_value_list = NULL; + bxattr_exit_code retval = bxattr_exit_error; berrno be; /* * First get the length of the available list with extended attributes. */ - xattr_list_len = llistxattr(jcr->last_fname, NULL, 0); - if (xattr_list_len < 0) { + xattr_list_len = llistea(jcr->last_fname, NULL, 0); + switch (xattr_list_len) { + case -1: switch (errno) { case ENOENT: - return bsub_exit_nok; + case EFORMAT: + case ENOTSUP: + return bxattr_exit_ok; default: - Mmsg2(jcr->errmsg, _("llistxattr error on file \"%s\": ERR=%s\n"), + Mmsg2(jcr->errmsg, _("llistea error on file \"%s\": ERR=%s\n"), jcr->last_fname, be.bstrerror()); - Dmsg2(100, "llistxattr error file=%s ERR=%s\n", + Dmsg2(100, "llistea error file=%s ERR=%s\n", jcr->last_fname, be.bstrerror()); - return bsub_exit_nok; + return bxattr_exit_error; } - } else if (xattr_list_len == 0) { - return bsub_exit_ok; + break; + case 0: + return bxattr_exit_ok; + default: + break; } /* @@ -279,125 +370,1461 @@ static bsub_exit_code generic_xattr_build_streams(JCR *jcr, FF_PKT *ff_pkt, int /* * Get the actual list of extended attributes names for a file. */ - xattr_list_len = llistxattr(jcr->last_fname, xattr_list, xattr_list_len); - if (xattr_list_len < 0) { + xattr_list_len = llistea(jcr->last_fname, xattr_list, xattr_list_len); + switch (xattr_list_len) { + case -1: switch (errno) { case ENOENT: - free(xattr_list); - return bsub_exit_nok; + case EFORMAT: + case ENOTSUP: + retval = bxattr_exit_ok; + goto bail_out; default: - Mmsg2(jcr->errmsg, _("llistxattr error on file \"%s\": ERR=%s\n"), + Mmsg2(jcr->errmsg, _("llistea error on file \"%s\": ERR=%s\n"), jcr->last_fname, be.bstrerror()); - Dmsg2(100, "llistxattr error file=%s ERR=%s\n", + Dmsg2(100, "llistea error file=%s ERR=%s\n", jcr->last_fname, be.bstrerror()); - free(xattr_list); - return bsub_exit_nok; + goto bail_out; + } + break; + default: + break; + } + xattr_list[xattr_list_len] = '\0'; + + /* + * Walk the list of extended attributes names and retrieve the data. + * We already count the bytes needed for serializing the stream later on. + */ + bp = xattr_list; + while ((bp - xattr_list) + 1 < xattr_list_len) { + skip_xattr = false; + + /* + * We want to skip certain xattrs which start with a 0xF8 character on AIX. + */ + if (*bp == 0xF8) { + skip_xattr = true; + } + + name_length = strlen(bp); + if (skip_xattr || name_length == 0) { + Dmsg1(100, "Skipping xattr named %s\n", bp); + bp = strchr(bp, '\0') + 1; + continue; + } + + /* + * Each xattr valuepair starts with a magic so we can parse it easier. + */ + current_xattr = (xattr_t *)malloc(sizeof(xattr_t)); + current_xattr->magic = XATTR_MAGIC; + expected_serialize_len += sizeof(current_xattr->magic); + + /* + * Allocate space for storing the name. + */ + current_xattr->name_length = name_length; + current_xattr->name = (char *)malloc(current_xattr->name_length); + memcpy((caddr_t)current_xattr->name, (caddr_t)bp, current_xattr->name_length); + + expected_serialize_len += sizeof(current_xattr->name_length) + current_xattr->name_length; + + /* + * First see how long the value is for the extended attribute. + */ + xattr_value_len = lgetea(jcr->last_fname, bp, NULL, 0); + switch (xattr_value_len) { + case -1: + switch (errno) { + case ENOENT: + case EFORMAT: + case ENOTSUP: + retval = bxattr_exit_ok; + goto bail_out; + default: + Mmsg2(jcr->errmsg, _("lgetea error on file \"%s\": ERR=%s\n"), + jcr->last_fname, be.bstrerror()); + Dmsg2(100, "lgetea error file=%s ERR=%s\n", + jcr->last_fname, be.bstrerror()); + goto bail_out; + } + break; + case 0: + current_xattr->value = NULL; + current_xattr->value_length = 0; + expected_serialize_len += sizeof(current_xattr->value_length); + break; + default: + /* + * Allocate space for storing the value. + */ + current_xattr->value = (char *)malloc(xattr_value_len); + memset((caddr_t)current_xattr->value, 0, xattr_value_len); + + xattr_value_len = lgetea(jcr->last_fname, bp, current_xattr->value, xattr_value_len); + if (xattr_value_len < 0) { + switch (errno) { + case ENOENT: + case EFORMAT: + case ENOTSUP: + retval = bxattr_exit_ok; + goto bail_out; + default: + Mmsg2(jcr->errmsg, _("lgetea error on file \"%s\": ERR=%s\n"), + jcr->last_fname, be.bstrerror()); + Dmsg2(100, "lgetea error file=%s ERR=%s\n", + jcr->last_fname, be.bstrerror()); + goto bail_out; + } + } + /* + * 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) { + Mmsg2(jcr->errmsg, _("Xattr stream on file \"%s\" exceeds maximum size of %d bytes\n"), + jcr->last_fname, MAX_XATTR_STREAM); + goto bail_out; + } + } + + if (xattr_value_list == NULL) { + xattr_value_list = New(alist(10, not_owned_by_alist)); + } + + xattr_value_list->append(current_xattr); + current_xattr = NULL; + xattr_count++; + bp = strchr(bp, '\0') + 1; + break; + } + + free(xattr_list); + xattr_list = (char *)NULL; + + /* + * If we found any xattr send them to the SD. + */ + if (xattr_count > 0) { + /* + * Serialize the datastream. + */ + if (serialize_xattr_stream(jcr, expected_serialize_len, xattr_value_list) < expected_serialize_len) { + Mmsg1(jcr->errmsg, _("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; + } + + /* + * Send the datastream to the SD. + */ + retval = send_xattr_stream(jcr, os_default_xattr_streams[0]); + } else { + retval = bxattr_exit_ok; + } + +bail_out: + if (current_xattr != NULL) { + if (current_xattr->value != NULL) { + free(current_xattr->value); + } + if (current_xattr->name != NULL) { + free(current_xattr->name); + } + free(current_xattr); + } + if (xattr_list != NULL) { + free(xattr_list); + } + if (xattr_value_list != NULL) { + xattr_drop_internal_table(xattr_value_list); + } + return retval; +} + +static bxattr_exit_code aix_xattr_parse_streams(JCR *jcr, int stream) +{ + xattr_t *current_xattr; + alist *xattr_value_list; + berrno be; + + xattr_value_list = New(alist(10, not_owned_by_alist)); + + if (unserialize_xattr_stream(jcr, xattr_value_list) != bxattr_exit_ok) { + xattr_drop_internal_table(xattr_value_list); + return bxattr_exit_error; + } + + foreach_alist(current_xattr, xattr_value_list) { + if (lsetea(jcr->last_fname, current_xattr->name, current_xattr->value, current_xattr->value_length, 0) != 0) { + switch (errno) { + case ENOENT: + case EFORMAT: + case ENOTSUP: + goto bail_out; + default: + Mmsg2(jcr->errmsg, _("lsetea error on file \"%s\": ERR=%s\n"), + jcr->last_fname, be.bstrerror()); + Dmsg2(100, "lsetea error file=%s ERR=%s\n", + jcr->last_fname, be.bstrerror()); + goto bail_out; + } } } - xattr_list[xattr_list_len] = '\0'; + + xattr_drop_internal_table(xattr_value_list); + return bxattr_exit_ok; + +bail_out: + xattr_drop_internal_table(xattr_value_list); + return bxattr_exit_error; +} + +/* + * Function pointers to the build and parse function to use for these xattrs. + */ +static bxattr_exit_code (*os_build_xattr_streams)(JCR *jcr, FF_PKT *ff_pkt) = aix_xattr_build_streams; +static bxattr_exit_code (*os_parse_xattr_streams)(JCR *jcr, int stream) = aix_xattr_parse_streams; + +#elif defined(HAVE_IRIX_OS) + +/* + * Define the supported XATTR streams for this OS + */ +static int os_default_xattr_streams[1] = { STREAM_XATTR_IRIX }; +static const char *xattr_acl_skiplist[1] = { NULL }; +static const char *xattr_skiplist[1] = { NULL }; + +struct xattr_naming_space { + const char *name; + int flags; +}; + +static xattr_naming_space xattr_naming_spaces[] = { + { "user.", ATTR_DONTFOLLOW }, + { "root.", ATTR_ROOT | ATTR_DONTFOLLOW }, + { NULL, 0 } +}; + +static bxattr_exit_code irix_xattr_build_streams(JCR *jcr, FF_PKT *ff_pkt) +{ + int cnt, xattr_count = 0; + attrlist_cursor_t cursor; + attrlist_t *attrlist; + attrlist_ent_t *attrlist_ent; + xattr_t *current_xattr = NULL; + alist *xattr_value_list = NULL; + uint32_t expected_serialize_len = 0; + bxattr_exit_code retval = bxattr_exit_error; + POOLMEM *xattrbuf = get_memory(ATTR_MAX_VALUELEN); + berrno be; + + for (cnt = 0; xattr_naming_spaces[cnt].name != NULL; cnt++) { + memset(cursor, 0, sizeof(attrlist_cursor_t)); + while (1) { + if (attr_list(jcr->last_fname, xattrbuf, ATTR_MAX_VALUELEN, + xattr_naming_spaces[cnt].flags, &cursor) != 0) { + switch (errno) { + case ENOENT: + retval = bxattr_exit_ok; + goto bail_out; + default: + Mmsg2(jcr->errmsg, _("attr_list error on file \"%s\": ERR=%s\n"), + jcr->last_fname, be.bstrerror()); + Dmsg2(100, "attr_list error file=%s ERR=%s\n", + jcr->last_fname, be.bstrerror()); + goto bail_out; + } + } + + attrlist = (attrlist_t *)xattrbuf; + + /* + * Walk the available attributes. + */ + for (cnt = 0; cnt < attrlist->al_count; cnt++) { + attrlist_ent = ATTR_ENTRY(xattrbuf, cnt); + + /* + * Each xattr valuepair starts with a magic so we can parse it easier. + */ + current_xattr = (xattr_t *)malloc(sizeof(xattr_t)); + current_xattr->magic = XATTR_MAGIC; + expected_serialize_len += sizeof(current_xattr->magic); + + /* + * Allocate space for storing the name. + * We store the name as + */ + current_xattr->name_length = strlen(xattr_naming_spaces[cnt].name) + strlen(attrlist_ent->a_name) + 1; + current_xattr->name = (char *)malloc(current_xattr->name_length); + bsnprintf(current_xattr->name, current_xattr->name_length, "%s%s", + xattr_naming_spaces[cnt].name, attrlist_ent->a_name); + + expected_serialize_len += sizeof(current_xattr->name_length) + current_xattr->name_length; + + current_xattr->value_length = attrlist_ent->a_valuelen; + current_xattr->value = (char *)malloc(current_xattr->value_length); + + /* + * Retrieve the actual value of the xattr. + */ + if (attr_get(jcr->last_fname, attrlist_ent->a_name, current_xattr->value, + current_xattr->value_length, xattr_naming_spaces[cnt].flags) != 0) { + switch (errno) { + case ENOENT: + case ENOATTR: + retval = bxattr_exit_ok; + goto bail_out; + case E2BIG: + /* + * The buffer for the xattr isn't big enough. the value of + * current_xattr->value_length is updated with the actual size + * of the xattr. So we free the old buffer and create a new one + * and try again. + */ + free(current_xattr->value); + current_xattr->value = (char *)malloc(current_xattr->value_length); + if (attr_get(jcr->last_fname, attrlist_ent->a_name, current_xattr->value, + current_xattr->value_length, xattr_naming_spaces[cnt].flags) != 0) { + switch (errno) { + case ENOENT: + case ENOATTR: + retval = bxattr_exit_ok; + goto bail_out; + default: + Mmsg2(jcr->errmsg, _("attr_list error on file \"%s\": ERR=%s\n"), + jcr->last_fname, be.bstrerror()); + Dmsg2(100, "attr_list error file=%s ERR=%s\n", + jcr->last_fname, be.bstrerror()); + goto bail_out; + } + } + break; + default: + Mmsg2(jcr->errmsg, _("attr_list error on file \"%s\": ERR=%s\n"), + jcr->last_fname, be.bstrerror()); + Dmsg2(100, "attr_list error file=%s ERR=%s\n", + jcr->last_fname, be.bstrerror()); + goto bail_out; + } + } + + 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) { + Mmsg2(jcr->errmsg, _("Xattr stream on file \"%s\" exceeds maximum size of %d bytes\n"), + jcr->last_fname, MAX_XATTR_STREAM); + goto bail_out; + } + + if (xattr_value_list == NULL) { + xattr_value_list = New(alist(10, not_owned_by_alist)); + } + + xattr_value_list->append(current_xattr); + current_xattr = NULL; + xattr_count++; + } + + /* + * See if there are more attributes available for a next run of attr_list. + */ + if (attrlist->al_more == 0) { + break; + } + } + } + + /* + * If we found any xattr send them to the SD. + */ + if (xattr_count > 0) { + /* + * Serialize the datastream. + */ + if (serialize_xattr_stream(jcr, expected_serialize_len, xattr_value_list) < expected_serialize_len) { + Mmsg1(jcr->errmsg, _("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; + } + + /* + * Send the datastream to the SD. + */ + retval = send_xattr_stream(jcr, os_default_xattr_streams[0]); + } else { + retval = bxattr_exit_ok; + } + +bail_out: + if (current_xattr != NULL) { + if (current_xattr->value != NULL) { + free(current_xattr->value); + } + if (current_xattr->name != NULL) { + free(current_xattr->name); + } + free(current_xattr); + } + free_pool_memory(xattrbuf); + + if (xattr_value_list != NULL) { + xattr_drop_internal_table(xattr_value_list); + } + return retval; +} + +static bxattr_exit_code irix_xattr_parse_streams(JCR *jcr, int stream) +{ + char *bp; + int cnt, cmp_size, name_space_index; + xattr_t *current_xattr; + alist *xattr_value_list; + berrno be; + + xattr_value_list = New(alist(10, not_owned_by_alist)); + + if (unserialize_xattr_stream(jcr, xattr_value_list) != bxattr_exit_ok) { + xattr_drop_internal_table(xattr_value_list); + return bxattr_exit_error; + } + + foreach_alist(current_xattr, xattr_value_list) { + /* + * See to what namingspace this xattr belongs to. + */ + name_space_index = 0; + for (cnt = 0; xattr_naming_spaces[cnt].name != NULL; cnt++) { + cmp_size = strlen(xattr_naming_spaces[cnt].name); + if (!strncasecmp(current_xattr->name, + xattr_naming_spaces[cnt].name, + cmp_size)) { + name_space_index = cnt; + break; + } + } + + /* + * If we got a xattr that doesn't belong to an valid namespace complain. + */ + if (name_space_index == 0) { + Mmsg2(jcr->errmsg, _("Received illegal xattr named %s on file \"%s\"\n"), + current_xattr->name, jcr->last_fname); + Dmsg2(100, "Received illegal xattr named %s on file \"%s\"\n", + current_xattr->name, jcr->last_fname); + goto bail_out; + } + + /* + * Restore the xattr first try to create the attribute from scratch. + */ + flags = xattr_naming_spaces[name_space_index].flags | ATTR_CREATE; + bp = strchr(current_xattr->name, '.'); + if (attr_set(jcr->last_fname, ++bp, current_xattr->value, + current_xattr->value_len, flags) != 0) { + switch (errno) { + case ENOENT: + retval = bxattr_exit_ok; + goto bail_out; + case EEXIST: + /* + * The xattr already exists we need to replace it. + */ + flags = xattr_naming_spaces[name_space_index].flags | ATTR_REPLACE; + if (attr_set(jcr->last_fname, bp, current_xattr->value, + current_xattr->value_len, flags) != 0) { + switch (errno) { + case ENOENT: + retval = bxattr_exit_ok; + goto bail_out; + default: + Mmsg2(jcr->errmsg, _("attr_set error on file \"%s\": ERR=%s\n"), + jcr->last_fname, be.bstrerror()); + Dmsg2(100, "attr_set error file=%s ERR=%s\n", + jcr->last_fname, be.bstrerror()); + goto bail_out; + } + } + break; + default: + Mmsg2(jcr->errmsg, _("attr_set error on file \"%s\": ERR=%s\n"), + jcr->last_fname, be.bstrerror()); + Dmsg2(100, "attr_set error file=%s ERR=%s\n", + jcr->last_fname, be.bstrerror()); + goto bail_out; + } + } + } + + xattr_drop_internal_table(xattr_value_list); + return bxattr_exit_ok; + +bail_out: + xattr_drop_internal_table(xattr_value_list); + return bxattr_exit_error; +} + +/* + * Function pointers to the build and parse function to use for these xattrs. + */ +static bxattr_exit_code (*os_build_xattr_streams)(JCR *jcr, FF_PKT *ff_pkt) = irix_xattr_build_streams; +static bxattr_exit_code (*os_parse_xattr_streams)(JCR *jcr, int stream) = irix_xattr_parse_streams; + +#elif defined(HAVE_DARWIN_OS) || \ + defined(HAVE_LINUX_OS) + +#if (!defined(HAVE_LISTXATTR) && !defined(HAVE_LLISTXATTR)) || \ + (!defined(HAVE_GETXATTR) && !defined(HAVE_LGETXATTR)) || \ + (!defined(HAVE_SETXATTR) && !defined(HAVE_LSETXATTR)) +#error "Missing full support for the XATTR functions." +#endif + +#ifdef HAVE_SYS_XATTR_H +#include +#else +#error "Missing sys/xattr.h header file" +#endif + +/* + * Define the supported XATTR streams for this OS + */ +#if defined(HAVE_DARWIN_OS) +static int os_default_xattr_streams[1] = { STREAM_XATTR_DARWIN }; +static const char *xattr_acl_skiplist[2] = { "com.apple.system.Security", NULL }; +static const char *xattr_skiplist[3] = { "com.apple.system.extendedsecurity", "com.apple.ResourceFork", NULL }; +#elif defined(HAVE_LINUX_OS) +static int os_default_xattr_streams[1] = { STREAM_XATTR_LINUX }; +static const char *xattr_acl_skiplist[2] = { "system.posix_acl_access", NULL }; +static const char *xattr_skiplist[1] = { NULL }; +#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 bxattr_exit_code generic_xattr_build_streams(JCR *jcr, FF_PKT *ff_pkt) +{ + bool skip_xattr; + char *xattr_list, *bp; + int cnt, xattr_count = 0; + uint32_t name_length; + int32_t xattr_list_len, + xattr_value_len; + uint32_t expected_serialize_len = 0; + xattr_t *current_xattr = NULL; + alist *xattr_value_list = NULL; + bxattr_exit_code retval = bxattr_exit_error; + berrno be; + + /* + * First get the length of the available list with extended attributes. + */ + xattr_list_len = llistxattr(jcr->last_fname, NULL, 0); + switch (xattr_list_len) { + case -1: + switch (errno) { + case ENOENT: + case ENOTSUP: + return bxattr_exit_ok; + default: + Mmsg2(jcr->errmsg, _("llistxattr error on file \"%s\": ERR=%s\n"), + jcr->last_fname, be.bstrerror()); + Dmsg2(100, "llistxattr error file=%s ERR=%s\n", + jcr->last_fname, be.bstrerror()); + return bxattr_exit_error; + } + break; + case 0: + return bxattr_exit_ok; + default: + break; + } + + /* + * Allocate room for the extented attribute list. + */ + xattr_list = (char *)malloc(xattr_list_len + 1); + memset((caddr_t)xattr_list, 0, xattr_list_len + 1); + + /* + * Get the actual list of extended attributes names for a file. + */ + xattr_list_len = llistxattr(jcr->last_fname, xattr_list, xattr_list_len); + switch (xattr_list_len) { + case -1: + switch (errno) { + case ENOENT: + case ENOTSUP: + retval = bxattr_exit_ok; + goto bail_out; + default: + Mmsg2(jcr->errmsg, _("llistxattr error on file \"%s\": ERR=%s\n"), + jcr->last_fname, be.bstrerror()); + Dmsg2(100, "llistxattr error file=%s ERR=%s\n", + jcr->last_fname, be.bstrerror()); + goto bail_out; + } + break; + default: + break; + } + xattr_list[xattr_list_len] = '\0'; + + /* + * Walk the list of extended attributes names and retrieve the data. + * We already count the bytes needed for serializing the stream later on. + */ + bp = xattr_list; + while ((bp - xattr_list) + 1 < xattr_list_len) { + skip_xattr = false; + + /* + * On some OSes you also get the acls in the extented attribute list. + * So we check if we are already backing up acls and if we do we + * don't store the extended attribute with the same info. + */ + if (ff_pkt->flags & FO_ACL) { + for (cnt = 0; xattr_acl_skiplist[cnt] != NULL; cnt++) { + if (bstrcmp(bp, xattr_acl_skiplist[cnt])) { + skip_xattr = true; + break; + } + } + } + + /* + * On some OSes we want to skip certain xattrs which are in the xattr_skiplist array. + */ + if (!skip_xattr) { + for (cnt = 0; xattr_skiplist[cnt] != NULL; cnt++) { + if (bstrcmp(bp, xattr_skiplist[cnt])) { + skip_xattr = true; + break; + } + } + } + + name_length = strlen(bp); + if (skip_xattr || name_length == 0) { + Dmsg1(100, "Skipping xattr named %s\n", bp); + bp = strchr(bp, '\0') + 1; + continue; + } + + /* + * Each xattr valuepair starts with a magic so we can parse it easier. + */ + current_xattr = (xattr_t *)malloc(sizeof(xattr_t)); + current_xattr->magic = XATTR_MAGIC; + expected_serialize_len += sizeof(current_xattr->magic); + + /* + * Allocate space for storing the name. + */ + current_xattr->name_length = name_length; + current_xattr->name = (char *)malloc(current_xattr->name_length); + memcpy((caddr_t)current_xattr->name, (caddr_t)bp, current_xattr->name_length); + + expected_serialize_len += sizeof(current_xattr->name_length) + current_xattr->name_length; + + /* + * First see how long the value is for the extended attribute. + */ + xattr_value_len = lgetxattr(jcr->last_fname, bp, NULL, 0); + switch (xattr_value_len) { + case -1: + switch (errno) { + case ENOENT: + case ENOTSUP: + retval = bxattr_exit_ok; + goto bail_out; + default: + Mmsg2(jcr->errmsg, _("lgetxattr error on file \"%s\": ERR=%s\n"), + jcr->last_fname, be.bstrerror()); + Dmsg2(100, "lgetxattr error file=%s ERR=%s\n", + jcr->last_fname, be.bstrerror()); + goto bail_out; + } + break; + case 0: + current_xattr->value = NULL; + current_xattr->value_length = 0; + expected_serialize_len += sizeof(current_xattr->value_length); + break; + default: + /* + * Allocate space for storing the value. + */ + current_xattr->value = (char *)malloc(xattr_value_len); + memset((caddr_t)current_xattr->value, 0, xattr_value_len); + + xattr_value_len = lgetxattr(jcr->last_fname, bp, current_xattr->value, xattr_value_len); + if (xattr_value_len < 0) { + switch (errno) { + case ENOENT: + case ENOTSUP: + retval = bxattr_exit_ok; + goto bail_out; + default: + Mmsg2(jcr->errmsg, _("lgetxattr error on file \"%s\": ERR=%s\n"), + jcr->last_fname, be.bstrerror()); + Dmsg2(100, "lgetxattr error file=%s ERR=%s\n", + jcr->last_fname, be.bstrerror()); + goto bail_out; + } + } + /* + * 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) { + Mmsg2(jcr->errmsg, _("Xattr stream on file \"%s\" exceeds maximum size of %d bytes\n"), + jcr->last_fname, MAX_XATTR_STREAM); + goto bail_out; + } + } + + if (xattr_value_list == NULL) { + xattr_value_list = New(alist(10, not_owned_by_alist)); + } + + xattr_value_list->append(current_xattr); + current_xattr = NULL; + xattr_count++; + bp = strchr(bp, '\0') + 1; + break; + } + + free(xattr_list); + xattr_list = (char *)NULL; + + /* + * If we found any xattr send them to the SD. + */ + if (xattr_count > 0) { + /* + * Serialize the datastream. + */ + if (serialize_xattr_stream(jcr, expected_serialize_len, xattr_value_list) < expected_serialize_len) { + Mmsg1(jcr->errmsg, _("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; + } + + /* + * Send the datastream to the SD. + */ + retval = send_xattr_stream(jcr, os_default_xattr_streams[0]); + } else { + retval = bxattr_exit_ok; + } + +bail_out: + if (current_xattr != NULL) { + if (current_xattr->value != NULL) { + free(current_xattr->value); + } + if (current_xattr->name != NULL) { + free(current_xattr->name); + } + free(current_xattr); + } + if (xattr_list != NULL) { + free(xattr_list); + } + if (xattr_value_list != NULL) { + xattr_drop_internal_table(xattr_value_list); + } + return retval; +} + +static bxattr_exit_code generic_xattr_parse_streams(JCR *jcr, int stream) +{ + xattr_t *current_xattr; + alist *xattr_value_list; + berrno be; + + xattr_value_list = New(alist(10, not_owned_by_alist)); + + if (unserialize_xattr_stream(jcr, xattr_value_list) != bxattr_exit_ok) { + xattr_drop_internal_table(xattr_value_list); + return bxattr_exit_error; + } + + foreach_alist(current_xattr, xattr_value_list) { + if (lsetxattr(jcr->last_fname, current_xattr->name, current_xattr->value, current_xattr->value_length, 0) != 0) { + switch (errno) { + case ENOENT: + case ENOTSUP: + goto bail_out; + default: + Mmsg2(jcr->errmsg, _("lsetxattr error on file \"%s\": ERR=%s\n"), + jcr->last_fname, be.bstrerror()); + Dmsg2(100, "lsetxattr error file=%s ERR=%s\n", + jcr->last_fname, be.bstrerror()); + goto bail_out; + } + } + } + + xattr_drop_internal_table(xattr_value_list); + return bxattr_exit_ok; + +bail_out: + xattr_drop_internal_table(xattr_value_list); + return bxattr_exit_error; +} + +/* + * Function pointers to the build and parse function to use for these xattrs. + */ +static bxattr_exit_code (*os_build_xattr_streams)(JCR *jcr, FF_PKT *ff_pkt) = generic_xattr_build_streams; +static bxattr_exit_code (*os_parse_xattr_streams)(JCR *jcr, int stream) = generic_xattr_parse_streams; + +#elif defined(HAVE_FREEBSD_OS) || \ + defined(HAVE_NETBSD_OS) || \ + defined(HAVE_OPENBSD_OS) + +#if (!defined(HAVE_EXTATTR_GET_LINK) && !defined(HAVE_EXTATTR_GET_FILE)) || \ + (!defined(HAVE_EXTATTR_SET_LINK) && !defined(HAVE_EXTATTR_SET_FILE)) || \ + (!defined(HAVE_EXTATTR_LIST_LINK) && !defined(HAVE_EXTATTR_LIST_FILE)) || \ + !defined(HAVE_EXTATTR_NAMESPACE_TO_STRING) || \ + !defined(HAVE_EXTATTR_STRING_TO_NAMESPACE) +#error "Missing full support for the extattr functions." +#endif + +#ifdef HAVE_SYS_EXTATTR_H +#include +#else +#error "Missing sys/extattr.h header file" +#endif + +#ifdef HAVE_LIBUTIL_H +#include +#endif + +#if !defined(HAVE_EXTATTR_GET_LINK) && defined(HAVE_EXTATTR_GET_FILE) +#define extattr_get_link extattr_get_file +#endif +#if !defined(HAVE_EXTATTR_SET_LINK) && defined(HAVE_EXTATTR_SET_FILE) +#define extattr_set_link extattr_set_file +#endif +#if !defined(HAVE_EXTATTR_LIST_LINK) && defined(HAVE_EXTATTR_LIST_FILE) +#define extattr_list_link extattr_list_file +#endif + +#if defined(HAVE_FREEBSD_OS) +static int os_default_xattr_streams[1] = { STREAM_XATTR_FREEBSD }; +static int os_default_xattr_namespaces[2] = { EXTATTR_NAMESPACE_USER, EXTATTR_NAMESPACE_SYSTEM }; +static const char *xattr_acl_skiplist[2] = { "system.posix1e.acl_access", NULL }; +static const char *xattr_skiplist[1] = { NULL }; +#elif defined(HAVE_NETBSD_OS) +static int os_default_xattr_streams[1] = { STREAM_XATTR_NETBSD }; +static int os_default_xattr_namespaces[2] = { EXTATTR_NAMESPACE_USER, EXTATTR_NAMESPACE_SYSTEM }; +static const char *xattr_acl_skiplist[1] = { NULL }; +static const char *xattr_skiplist[1] = { NULL }; +#elif defined(HAVE_OPENBSD_OS) +static int os_default_xattr_streams[1] = { STREAM_XATTR_OPENBSD }; +static int os_default_xattr_namespaces[2] = { EXTATTR_NAMESPACE_USER, EXTATTR_NAMESPACE_SYSTEM }; +static const char *xattr_acl_skiplist[1] = { NULL }; +static const char *xattr_skiplist[1] = { NULL }; +#endif + +static bxattr_exit_code bsd_build_xattr_streams(JCR *jcr, FF_PKT *ff_pkt) +{ + bool skip_xattr; + char *xattr_list; + int cnt, index, xattr_count = 0; + int32_t xattr_list_len, + xattr_value_len; + uint32_t expected_serialize_len = 0; + unsigned int namespace_index; + int attrnamespace; + char *current_attrnamespace = NULL; + char current_attrname[XATTR_BUFSIZ], current_attrtuple[XATTR_BUFSIZ]; + xattr_t *current_xattr = NULL; + alist *xattr_value_list = NULL; + bxattr_exit_code retval = bxattr_exit_error; + berrno be; + + /* + * Loop over all available xattr namespaces. + */ + for (namespace_index = 0; namespace_index < sizeof(os_default_xattr_namespaces) / sizeof(int); namespace_index++) { + attrnamespace = os_default_xattr_namespaces[namespace_index]; + + /* + * Convert the numeric attrnamespace into a string representation and make a private copy of that string. + * The extattr_namespace_to_string functions returns a strdupped string which we need to free. + */ + if (extattr_namespace_to_string(attrnamespace, ¤t_attrnamespace) != 0) { + Mmsg2(jcr->errmsg, _("Failed to convert %d into namespace on file \"%s\"\n"), + attrnamespace, jcr->last_fname); + Dmsg2(100, "Failed to convert %d into namespace on file \"%s\"\n", + attrnamespace, jcr->last_fname); + goto bail_out; + } + + /* + * First get the length of the available list with extended attributes. + * If we get EPERM on system namespace, don't return error. + * This is expected for normal users trying to archive the system + * namespace on FreeBSD 6.2 and later. On NetBSD 3.1 and later, + * they've decided to return EOPNOTSUPP instead. + */ + xattr_list_len = extattr_list_link(jcr->last_fname, attrnamespace, NULL, 0); + switch (xattr_list_len) { + case -1: + switch (errno) { + case ENOENT: + retval = bxattr_exit_ok; + goto bail_out; +#if defined(EOPNOTSUPP) + case EOPNOTSUPP: +#endif + case EPERM: + if (attrnamespace == EXTATTR_NAMESPACE_SYSTEM) { + actuallyfree(current_attrnamespace); + current_attrnamespace = NULL; + continue; + } + /* + * FALLTHROUGH + */ + default: + Mmsg2(jcr->errmsg, _("extattr_list_link error on file \"%s\": ERR=%s\n"), + jcr->last_fname, be.bstrerror()); + Dmsg2(100, "extattr_list_link error file=%s ERR=%s\n", + jcr->last_fname, be.bstrerror()); + goto bail_out; + } + break; + case 0: + continue; + default: + break; + } + + /* + * Allocate room for the extented attribute list. + */ + xattr_list = (char *)malloc(xattr_list_len + 1); + memset((caddr_t)xattr_list, 0, xattr_list_len + 1); + + /* + * Get the actual list of extended attributes names for a file. + */ + xattr_list_len = extattr_list_link(jcr->last_fname, attrnamespace, xattr_list, xattr_list_len); + switch (xattr_list_len) { + case -1: + switch (errno) { + case ENOENT: + retval = bxattr_exit_ok; + goto bail_out; + default: + Mmsg2(jcr->errmsg, _("extattr_list_link error on file \"%s\": ERR=%s\n"), + jcr->last_fname, be.bstrerror()); + Dmsg2(100, "extattr_list_link error file=%s ERR=%s\n", + jcr->last_fname, be.bstrerror()); + goto bail_out; + } + break; + default: + break; + } + xattr_list[xattr_list_len] = '\0'; + + /* + * Walk the list of extended attributes names and retrieve the data. + * We already count the bytes needed for serializing the stream later on. + */ + for (index = 0; index < xattr_list_len; index += xattr_list[index] + 1) { + skip_xattr = false; + + /* + * Print the current name into the buffer as its not null terminated we need to + * use the length encoded in the string for copying only the needed bytes. + */ + cnt = xattr_list[index]; + if (cnt > ((int)sizeof(current_attrname) - 1)) { + cnt = ((int)sizeof(current_attrname) - 1); + } + strncpy(current_attrname, xattr_list + (index + 1), cnt); + current_attrname[cnt] = '\0'; + + /* + * First make a xattr tuple of the current namespace and the name of the xattr. + * e.g. something like user. or system. + */ + bsnprintf(current_attrtuple, sizeof(current_attrtuple), "%s.%s", current_attrnamespace, current_attrname); + + /* + * On some OSes you also get the acls in the extented attribute list. + * So we check if we are already backing up acls and if we do we + * don't store the extended attribute with the same info. + */ + if (ff_pkt->flags & FO_ACL) { + for (cnt = 0; xattr_acl_skiplist[cnt] != NULL; cnt++) { + if (bstrcmp(current_attrtuple, xattr_acl_skiplist[cnt])) { + skip_xattr = true; + break; + } + } + } + + /* + * On some OSes we want to skip certain xattrs which are in the xattr_skiplist array. + */ + if (!skip_xattr) { + for (cnt = 0; xattr_skiplist[cnt] != NULL; cnt++) { + if (bstrcmp(current_attrtuple, xattr_skiplist[cnt])) { + skip_xattr = true; + break; + } + } + } + + if (skip_xattr) { + Dmsg1(100, "Skipping xattr named %s\n", current_attrname); + continue; + } + + /* + * Each xattr valuepair starts with a magic so we can parse it easier. + */ + current_xattr = (xattr_t *)malloc(sizeof(xattr_t)); + current_xattr->magic = XATTR_MAGIC; + expected_serialize_len += sizeof(current_xattr->magic); + + /* + * Allocate space for storing the name. + */ + current_xattr->name_length = strlen(current_attrtuple); + current_xattr->name = (char *)malloc(current_xattr->name_length); + memcpy((caddr_t)current_xattr->name, (caddr_t)current_attrtuple, current_xattr->name_length); + + expected_serialize_len += sizeof(current_xattr->name_length) + current_xattr->name_length; + + /* + * First see how long the value is for the extended attribute. + */ + xattr_value_len = extattr_get_link(jcr->last_fname, attrnamespace, current_attrname, NULL, 0); + switch (xattr_value_len) { + case -1: + switch (errno) { + case ENOENT: + retval = bxattr_exit_ok; + goto bail_out; + default: + Mmsg2(jcr->errmsg, _("extattr_get_link error on file \"%s\": ERR=%s\n"), + jcr->last_fname, be.bstrerror()); + Dmsg2(100, "extattr_get_link error file=%s ERR=%s\n", + jcr->last_fname, be.bstrerror()); + goto bail_out; + } + break; + case 0: + current_xattr->value = NULL; + current_xattr->value_length = 0; + expected_serialize_len += sizeof(current_xattr->value_length); + break; + default: + /* + * Allocate space for storing the value. + */ + current_xattr->value = (char *)malloc(xattr_value_len); + memset((caddr_t)current_xattr->value, 0, xattr_value_len); + + xattr_value_len = extattr_get_link(jcr->last_fname, attrnamespace, current_attrname, current_xattr->value, xattr_value_len); + if (xattr_value_len < 0) { + switch (errno) { + case ENOENT: + retval = bxattr_exit_ok; + goto bail_out; + default: + Mmsg2(jcr->errmsg, _("extattr_get_link error on file \"%s\": ERR=%s\n"), + jcr->last_fname, be.bstrerror()); + Dmsg2(100, "extattr_get_link error file=%s ERR=%s\n", + jcr->last_fname, be.bstrerror()); + goto bail_out; + } + } + + /* + * 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) { + Mmsg2(jcr->errmsg, _("Xattr stream on file \"%s\" exceeds maximum size of %d bytes\n"), + jcr->last_fname, MAX_XATTR_STREAM); + goto bail_out; + } + break; + } + + if (xattr_value_list == NULL) { + xattr_value_list = New(alist(10, not_owned_by_alist)); + } + + xattr_value_list->append(current_xattr); + current_xattr = NULL; + xattr_count++; + + } + + /* + * Drop the local copy of the current_attrnamespace. + */ + actuallyfree(current_attrnamespace); + current_attrnamespace = NULL; + + /* + * We are done with this xattr list. + */ + free(xattr_list); + xattr_list = (char *)NULL; + } + + /* + * If we found any xattr send them to the SD. + */ + if (xattr_count > 0) { + /* + * Serialize the datastream. + */ + if (serialize_xattr_stream(jcr, expected_serialize_len, xattr_value_list) < expected_serialize_len) { + Mmsg1(jcr->errmsg, _("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; + } + + /* + * Send the datastream to the SD. + */ + retval = send_xattr_stream(jcr, os_default_xattr_streams[0]); + } else { + retval = bxattr_exit_ok; + } + +bail_out: + if (current_attrnamespace != NULL) { + actuallyfree(current_attrnamespace); + } + if (current_xattr != NULL) { + if (current_xattr->value != NULL) { + free(current_xattr->value); + } + if (current_xattr->name != NULL) { + free(current_xattr->name); + } + free(current_xattr); + } + if (xattr_list != NULL) { + free(xattr_list); + } + if (xattr_value_list != NULL) { + xattr_drop_internal_table(xattr_value_list); + } + return retval; +} + +static bxattr_exit_code bsd_parse_xattr_streams(JCR *jcr, int stream) +{ + xattr_t *current_xattr; + alist *xattr_value_list; + int current_attrnamespace, cnt; + char *attrnamespace, *attrname; + berrno be; + + xattr_value_list = New(alist(10, not_owned_by_alist)); + + if (unserialize_xattr_stream(jcr, xattr_value_list) != bxattr_exit_ok) { + xattr_drop_internal_table(xattr_value_list); + return bxattr_exit_error; + } + + foreach_alist(current_xattr, xattr_value_list) { + /* + * Try splitting the xattr_name into a namespace and name part. + * The splitting character is a . + */ + attrnamespace = current_xattr->name; + if ((attrname = strchr(attrnamespace, '.')) == (char *)NULL) { + Mmsg2(jcr->errmsg, _("Failed to split %s into namespace and name part on file \"%s\"\n"), + current_xattr->name, jcr->last_fname); + Dmsg2(100, "Failed to split %s into namespace and name part on file \"%s\"\n", + current_xattr->name, jcr->last_fname); + goto bail_out; + } + *attrname++ = '\0'; + + /* + * Make sure the attrnamespace makes sense. + */ + if (extattr_string_to_namespace(attrnamespace, ¤t_attrnamespace) != 0) { + Mmsg2(jcr->errmsg, _("Failed to convert %s into namespace on file \"%s\"\n"), + attrnamespace, jcr->last_fname); + Dmsg2(100, "Failed to convert %s into namespace on file \"%s\"\n", + attrnamespace, jcr->last_fname); + goto bail_out; + } + + /* + * Try restoring the extended attribute. + */ + cnt = extattr_set_link(jcr->last_fname, current_attrnamespace, + attrname, current_xattr->value, current_xattr->value_length); + if (cnt < 0 || cnt != (int)current_xattr->value_length) { + switch (errno) { + case ENOENT: + goto bail_out; + break; + default: + Mmsg2(jcr->errmsg, _("extattr_set_link error on file \"%s\": ERR=%s\n"), + jcr->last_fname, be.bstrerror()); + Dmsg2(100, "extattr_set_link error file=%s ERR=%s\n", + jcr->last_fname, be.bstrerror()); + goto bail_out; + break; + } + } + } + + xattr_drop_internal_table(xattr_value_list); + return bxattr_exit_ok; + +bail_out: + xattr_drop_internal_table(xattr_value_list); + return bxattr_exit_error; +} + +/* + * Function pointers to the build and parse function to use for these xattrs. + */ +static bxattr_exit_code (*os_build_xattr_streams)(JCR *jcr, FF_PKT *ff_pkt) = bsd_build_xattr_streams; +static bxattr_exit_code (*os_parse_xattr_streams)(JCR *jcr, int stream) = bsd_parse_xattr_streams; + +#elif defined(HAVE_OSF1_OS) + +#if !defined(HAVE_GETPROPLIST) || \ + !defined(HAVE_GET_PROPLIST_ENTRY) || \ + !defined(HAVE_SIZEOF_PROPLIST_ENTRY) || \ + !defined(HAVE_ADD_PROPLIST_ENTRY) || \ + !defined(HAVE_SETPROPLIST) +#error "Missing full support for the Extended Attributes functions." +#endif + +#ifdef HAVE_SYS_PROPLIST_H +#include +#else +#error "Missing sys/proplist.h header file" +#endif + +/* + * Define the supported XATTR streams for this OS + */ +static int os_default_xattr_streams[1] = { STREAM_XATTR_TRU64 }; +static const char *xattr_acl_skiplist[1] = { NULL }; +static const char *xattr_skiplist[1] = { NULL }; + +static bxattr_exit_code tru64_build_xattr_streams(JCR *jcr, FF_PKT *ff_pkt) +{ + char *bp, + *xattr_name, + *xattr_value; + bool skip_xattr; + int xattr_count = 0; + int32_t *flags, + *xattr_value_len; + int32_t xattr_list_len, + xattrbuf_size, + xattrbuf_min_size; + uint32_t expected_serialize_len = 0; + xattr_t *current_xattr = NULL; + alist *xattr_value_list = NULL; + struct proplistname_args prop_args; + bxattr_exit_code retval = bxattr_exit_error; + POOLMEM *xattrbuf = get_pool_memory(PM_MESSAGE); + berrno be; + + xattrbuf_size = sizeof_pool_memory(xattrbuf); + xattrbuf_min_size = 0; + xattr_list_len = getproplist(jcr->last_fname, 1, &prop_args, xattrbuf_size, + xattrbuf, &xattrbuf_min_size); + + /* + * See what xattr are available. + */ + switch (xattr_list_len) { + case -1: + switch (errno) { + case EOPNOTSUPP: + retval = bacl_exit_ok; + goto bail_out; + default: + Mmsg2(jcr->errmsg, _("getproplist error on file \"%s\": ERR=%s\n"), + jcr->last_fname, be.bstrerror()); + Dmsg2(100, "getproplist error file=%s ERR=%s\n", + jcr->last_fname, be.bstrerror()); + goto bail_out; + } + break; + case 0: + if (xattrbuf_min_size) { + /* + * The buffer isn't big enough to hold the xattr data, we now have + * a minimum buffersize so we resize the buffer and try again. + */ + xattrbuf = check_pool_memory_size(xattrbuf, xattrbuf_min_size + 1); + xattrbuf_size = xattrbuf_min_size + 1; + xattr_list_len = getproplist(jcr->last_fname, 1, &prop_args, xattrbuf_size, + xattrbuf, &xattrbuf_min_size); + switch (xattr_list_len) { + case -1: + switch (errno) { + case EOPNOTSUPP: + retval = bacl_exit_ok; + goto bail_out; + default: + Mmsg2(jcr->errmsg, _("getproplist error on file \"%s\": ERR=%s\n"), + jcr->last_fname, be.bstrerror()); + Dmsg2(100, "getproplist error file=%s ERR=%s\n", + jcr->last_fname, be.bstrerror()); + goto bail_out; + } + break; + case 0: + /* + * This should never happen as we sized the buffer according to the minimumsize + * returned by a previous getproplist call. If it does happen things are fishy and + * we are better of forgetting this xattr as it seems its list is changing at this + * exact moment so we can never make a good backup copy of it. + */ + retval = bacl_exit_ok; + goto bail_out; + default: + break; + } + } else { + /** + * No xattr on file. + */ + retval = bacl_exit_ok; + goto bail_out; + } + break; + default: + break; + } /* - * Count the number of extended attributes on a file. + * Walk the list of extended attributes names and retrieve the data. + * We already count the bytes needed for serializing the stream later on. */ - bp = xattr_list; - while ((bp - xattr_list) + 1 < xattr_list_len) { -#if defined(HAVE_LINUX_OS) + bp = xattrbuf; + while (xattrbuf_size > 0) { + /* + * Call getproplist_entry to initialize name and value + * pointers to entries position within buffer. + */ + xattrbuf_size -= get_proplist_entry(&xattr_name, &flags, &xattr_value_len, &xattr_value, &bp); + /* - * On Linux you also get the acls in the extented attribute list. + * On some OSes you also get the acls in the extented attribute list. * So we check if we are already backing up acls and if we do we * don't store the extended attribute with the same info. */ - if ((ff_pkt->flags & FO_ACL) == 0 || strcmp(bp, "system.posix_acl_access")) - count++; -#else - count++; -#endif - - bp = strchr(bp, '\0') + 1; - } - - if (count == 0) { - free(xattr_list); - return bsub_exit_ok; - } + if (ff_pkt->flags & FO_ACL) { + for (cnt = 0; xattr_acl_skiplist[cnt] != NULL; cnt++) { + if (bstrcmp(xattr_name, xattr_acl_skiplist[cnt])) { + skip_xattr = true; + break; + } + } + } - /* - * Allocate enough room to hold all extended attributes. - * After allocating the storage make sure its empty by zeroing it. - */ - xattr_value_list = (xattr_t *)malloc(count * sizeof(xattr_t)); - memset((caddr_t)xattr_value_list, 0, count * sizeof(xattr_t)); + /* + * On some OSes we want to skip certain xattrs which are in the xattr_skiplist array. + */ + if (!skip_xattr) { + for (cnt = 0; xattr_skiplist[cnt] != NULL; cnt++) { + if (bstrcmp(xattr_name, xattr_skiplist[cnt])) { + skip_xattr = true; + break; + } + } + } - /* - * Walk the list of extended attributes names and retrieve the data. - * We already count the bytes needed for serializing the stream later on. - */ - current_xattr = xattr_value_list; - bp = xattr_list; - while ((bp - xattr_list) + 1 < xattr_list_len) { -#if defined(HAVE_LINUX_OS) - if (ff_pkt->flags & FO_ACL && !strcmp(bp, "system.posix_acl_access")) { - bp = strchr(bp, '\0') + 1; + if (skip_xattr) { + Dmsg1(100, "Skipping xattr named %s\n", xattr_name); continue; } -#endif /* * Each xattr valuepair starts with a magic so we can parse it easier. */ + current_xattr = (xattr_t *)malloc(sizeof(xattr_t)); current_xattr->magic = XATTR_MAGIC; expected_serialize_len += sizeof(current_xattr->magic); - /* - * Allocate space for storing the name. - */ - current_xattr->name_length = strlen(bp); - current_xattr->name = (char *)malloc(current_xattr->name_length); - memcpy((caddr_t)current_xattr->name, (caddr_t)bp, current_xattr->name_length); + current_xattr->name_length = strlen(xattr_name); + current_xattr->name = bstrdup(xattr_name); expected_serialize_len += sizeof(current_xattr->name_length) + current_xattr->name_length; - /* - * First see how long the value is for the extended attribute. - */ - xattr_value_len = lgetxattr(jcr->last_fname, bp, NULL, 0); - if (xattr_value_len < 0) { - switch (errno) { - case ENOENT: - goto bail_out; - default: - Mmsg2(jcr->errmsg, _("lgetxattr error on file \"%s\": ERR=%s\n"), - jcr->last_fname, be.bstrerror()); - Dmsg2(100, "lgetxattr error file=%s ERR=%s\n", - jcr->last_fname, be.bstrerror()); - goto bail_out; - } - } - - /* - * Allocate space for storing the value. - */ - current_xattr->value = (char *)malloc(xattr_value_len); - memset((caddr_t)current_xattr->value, 0, xattr_value_len); - - xattr_value_len = lgetxattr(jcr->last_fname, bp, current_xattr->value, xattr_value_len); - if (xattr_value_len < 0) { - switch (errno) { - case ENOENT: - goto bail_out; - default: - Mmsg2(jcr->errmsg, _("lgetxattr error on file \"%s\": ERR=%s\n"), - jcr->last_fname, be.bstrerror()); - Dmsg2(100, "lgetxattr error file=%s ERR=%s\n", - jcr->last_fname, be.bstrerror()); - goto bail_out; - } - } + current_xattr->value_length = *xattr_value_len; + current_xattr->value = (char *)malloc(current_xattr->value_length); + memcpy(current_xattr->value, xattr_value, current_xattr->value_length); - /* - * 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; /* @@ -408,129 +1835,141 @@ static bsub_exit_code generic_xattr_build_streams(JCR *jcr, FF_PKT *ff_pkt, int jcr->last_fname, MAX_XATTR_STREAM); goto bail_out; } - - /* - * Next attribute. - */ - current_xattr++; - bp = strchr(bp, '\0') + 1; - } - /* - * Serialize the datastream. - */ - if (serialize_xattr_stream(jcr, expected_serialize_len, xattr_value_list) < expected_serialize_len) { - Mmsg1(jcr->errmsg, _("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; - } + if (xattr_value_list == NULL) { + xattr_value_list = New(alist(10, not_owned_by_alist)); + } - xattr_drop_internal_table(xattr_value_list); - free(xattr_list); + xattr_value_list->append(current_xattr); + current_xattr = NULL; + xattr_count++; + } /* - * Send the datastream to the SD. + * If we found any xattr send them to the SD. */ - return send_xattr_stream(jcr, default_stream); + if (xattr_count > 0) { + /* + * Serialize the datastream. + */ + if (serialize_xattr_stream(jcr, expected_serialize_len, xattr_value_list) < expected_serialize_len) { + Mmsg1(jcr->errmsg, _("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; + } + + /* + * Send the datastream to the SD. + */ + retval = send_xattr_stream(jcr, os_default_xattr_streams[0]); + } bail_out: - xattr_drop_internal_table(xattr_value_list); - free(xattr_list); - return bsub_exit_nok; + if (current_xattr != NULL) { + if (current_xattr->value != NULL) { + free(current_xattr->value); + } + if (current_xattr->name != NULL) { + free(current_xattr->name); + } + free(current_xattr); + } + if (xattr_value_list != NULL) { + xattr_drop_internal_table(xattr_value_list); + } + free_pool_memory(xattrbuf); + + return retval; } -static bsub_exit_code generic_xattr_parse_streams(JCR *jcr, int stream) +static bxattr_exit_code tru64_parse_xattr_streams(JCR *jcr, int stream) { - unser_declare; - xattr_t current_xattr; - bsub_exit_code retval = bsub_exit_nok; + char *bp, *xattrbuf = NULL; + int32_t xattrbuf_size, cnt; + xattr_t *current_xattr; + alist *xattr_value_list; berrno be; + xattr_value_list = New(alist(10, not_owned_by_alist)); + + if (unserialize_xattr_stream(jcr, xattr_value_list) != bxattr_exit_ok) { + xattr_drop_internal_table(xattr_value_list); + return bxattr_exit_error; + } + /* - * Parse the stream and perform the setxattr calls on the file. - * - * Start unserializing the data. We keep on looping while we have not - * unserialized all bytes in the stream. + * See how big the propertylist must be. */ - unser_begin(jcr->xattr_data, jcr->xattr_data_len); - while (unser_length(jcr->xattr_data) < jcr->xattr_data_len) { - /* - * First make sure the magic is present. This way we can easily catch corruption. - * Any missing MAGIC is fatal we do NOT try to continue. - */ - unser_uint32(current_xattr.magic); - if (current_xattr.magic != XATTR_MAGIC) { - Mmsg1(jcr->errmsg, _("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 bsub_exit_nok; - } - - /* - * Decode the valuepair. First decode the length of the name. - */ - unser_uint32(current_xattr.name_length); - - /* - * Allocate room for the name and decode its content. - */ - current_xattr.name = (char *)malloc(current_xattr.name_length + 1); - unser_bytes(current_xattr.name, current_xattr.name_length); + xattrbuf_size = 0; + foreach_alist(current_xattr, xattr_value_list) { + xattrbuf_size += sizeof_proplist_entry(current_xattr->name, current_xattr->value_length); + } - /* - * The xattr_name needs to be null terminated for lsetxattr. - */ - current_xattr.name[current_xattr.name_length] = '\0'; + xattrbuf = (char *)malloc(xattrbuf_size); - /* - * Decode the value length. - */ - unser_uint32(current_xattr.value_length); + /* + * Add all value pairs to the proplist. + */ + cnt = 0; + bp = xattrbuf; + foreach_alist(current_xattr, xattr_value_list) { + cnt = add_proplist_entry(current_xattr->name, 0, current_xattr->value_length, + current_xattr->value, &bp); + } - /* - * Allocate room for the value and decode its content. - */ - current_xattr.value = (char *)malloc(current_xattr.value_length); - unser_bytes(current_xattr.value, current_xattr.value_length); + /* + * Sanity check. + */ + if (cnt != xattrbuf_size) { + Mmsg1(jcr->errmsg, _("Unable create proper proplist to restore xattrs on file \"%s\"\n"), + jcr->last_fname); + Dmsg1(100, "Unable create proper proplist to restore xattrs on file \"%s\"\n", + jcr->last_fname); + goto bail_out; + } - /* - * Try to set the extended attribute on the file. - * If we fail to set this attribute we flag the error but its not fatal, - * we try to restore the other extended attributes too. - */ - if (lsetxattr(jcr->last_fname, current_xattr.name, current_xattr.value, - current_xattr.value_length, 0) != 0) { - switch (errno) { - case ENOENT: - break; - default: - Mmsg2(jcr->errmsg, _("lsetxattr error on file \"%s\": ERR=%s\n"), - jcr->last_fname, be.bstrerror()); - Dmsg2(100, "lsetxattr error file=%s ERR=%s\n", - jcr->last_fname, be.bstrerror()); - break; - } + /* + * Restore the list of extended attributes on the file. + */ + cnt = setproplist(jcr->last_fname, 1, xattrbuf_size, xattrbuf); + switch (cnt) { + case -1: + switch (errno) { + case EOPNOTSUPP: + retval = bacl_exit_ok; + goto bail_out; + default: + Mmsg2(jcr->errmsg, _("setproplist error on file \"%s\": ERR=%s\n"), + jcr->last_fname, be.bstrerror()); + Dmsg2(100, "setproplist error file=%s ERR=%s\n", + jcr->last_fname, be.bstrerror()); + goto bail_out; } - - /* - * Free the temporary buffers. - */ - free(current_xattr.name); - free(current_xattr.value); + break; + default: + break; } - unser_end(jcr->xattr_data, jcr->xattr_data_len); - return retval; + free(xattrbuf); + + xattr_drop_internal_table(xattr_value_list); + return bxattr_exit_ok; + +bail_out: + if (xattrbuf) { + free(xattrbuf); + } + xattr_drop_internal_table(xattr_value_list); + return bxattr_exit_error; } /* - * For all these os-es setup the build and parse function pointer to the generic functions. + * Function pointers to the build and parse function to use for these xattrs. */ -static bsub_exit_code (*os_build_xattr_streams)(JCR *jcr, FF_PKT *ff_pkt, int default_stream) = generic_xattr_build_streams; -static bsub_exit_code (*os_parse_xattr_streams)(JCR *jcr, int stream) = generic_xattr_parse_streams; +static bxattr_exit_code (*os_build_xattr_streams)(JCR *jcr, FF_PKT *ff_pkt) = tru64_build_xattr_streams; +static bxattr_exit_code (*os_parse_xattr_streams)(JCR *jcr, int stream) = tru64_parse_xattr_streams; #elif defined(HAVE_SUN_OS) /* @@ -628,8 +2067,15 @@ static bsub_exit_code (*os_parse_xattr_streams)(JCR *jcr, int stream) = generic_ #include #endif +#if !defined(HAVE_OPENAT) || \ + !defined(HAVE_UNLINKAT) || \ + !defined(HAVE_FCHOWNAT) || \ + !defined(HAVE_FUTIMESAT) +#error "Unable to compile code because of missing openat, unlinkat, fchownat or futimesat function" +#endif + /* - * Number of xattr streams this OS supports and an array with integers with the actual stream numbers. + * Define the supported XATTR streams for this OS */ #if defined(HAVE_SYS_NVPAIR_H) && defined(_PC_SATTR_ENABLED) static int os_default_xattr_streams[2] = { STREAM_XATTR_SOLARIS, STREAM_XATTR_SOLARIS_SYS}; @@ -637,27 +2083,15 @@ static int os_default_xattr_streams[2] = { STREAM_XATTR_SOLARIS, STREAM_XATTR_SO static int os_default_xattr_streams[1] = { STREAM_XATTR_SOLARIS }; #endif /* defined(HAVE_SYS_NVPAIR_H) && defined(_PC_SATTR_ENABLED) */ -/* - * 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 alist *xattr_link_cache = NULL; - -static struct xattr_link_cache_entry *find_xattr_link_cache_entry(ino_t inum) +static xattr_link_cache_entry_t *find_xattr_link_cache_entry(JCR *jcr, ino_t inum) { xattr_link_cache_entry_t *ptr; - foreach_alist(ptr, xattr_link_cache) { + foreach_alist(ptr, jcr->xattr_data->link_cache) { if (ptr && ptr->inum == inum) { return ptr; } @@ -665,15 +2099,15 @@ static struct xattr_link_cache_entry *find_xattr_link_cache_entry(ino_t inum) return NULL; } -static void add_xattr_link_cache_entry(ino_t inum, char *target) +static void add_xattr_link_cache_entry(JCR *jcr, ino_t inum, char *target) { xattr_link_cache_entry_t *ptr; - ptr = (xattr_link_cache_entry_t *)malloc(sizeof(struct xattr_link_cache_entry)); - memset((caddr_t)ptr, 0, sizeof(struct xattr_link_cache_entry)); + ptr = (xattr_link_cache_entry_t *)malloc(sizeof(xattr_link_cache_entry_t)); + memset((caddr_t)ptr, 0, sizeof(xattr_link_cache_entry_t)); ptr->inum = inum; bstrncpy(ptr->target, target, sizeof(ptr->target)); - xattr_link_cache->append(ptr); + jcr->xattr_data->link_cache->append(ptr); } #if defined(HAVE_SYS_NVPAIR_H) && defined(_PC_SATTR_ENABLED) @@ -713,7 +2147,7 @@ static bool solaris_has_non_transient_extensible_attributes(int fd) fattr = name_to_attr(name); } else { retval = true; - goto cleanup; + goto bail_out; } type = nvpair_type(pair); @@ -725,23 +2159,23 @@ static bool solaris_has_non_transient_extensible_attributes(int fd) if (value && fattr != F_ARCHIVE && fattr != F_AV_MODIFIED) { retval = true; - goto cleanup; + goto bail_out; } break; case DATA_TYPE_UINT64_ARRAY: if (fattr != F_CRTIME) { retval = true; - goto cleanup; + goto bail_out; } break; case DATA_TYPE_NVLIST: default: retval = true; - goto cleanup; + goto bail_out; } } -cleanup: +bail_out: if (response != NULL) { nvlist_free(response); } @@ -771,7 +2205,7 @@ static bool acl_is_trivial(int count, aclent_t *entries) } #endif /* HAVE_ACL && !HAVE_EXTENDED_ACL */ -static bsub_exit_code solaris_save_xattr_acl(JCR *jcr, int fd, const char *attrname, char **acl_text) +static bxattr_exit_code solaris_save_xattr_acl(JCR *jcr, int fd, const char *attrname, char **acl_text) { #ifdef HAVE_ACL #ifdef HAVE_EXTENDED_ACL @@ -791,13 +2225,13 @@ static bsub_exit_code solaris_save_xattr_acl(JCR *jcr, int fd, const char *attrn acl_get(attrname, ACL_NO_TRIVIAL, &aclp) != 0) { switch (errno) { case ENOENT: - return bsub_exit_nok; + return bxattr_exit_ok; default: Mmsg3(jcr->errmsg, _("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 bsub_exit_nok; + return bxattr_exit_error; } } @@ -819,7 +2253,7 @@ static bsub_exit_code solaris_save_xattr_acl(JCR *jcr, int fd, const char *attrn } else { *acl_text = NULL; } - return bsub_exit_ok; + return bxattr_exit_ok; #else /* HAVE_EXTENDED_ACL */ int n; aclent_t *acls = NULL; @@ -841,14 +2275,14 @@ static bsub_exit_code solaris_save_xattr_acl(JCR *jcr, int fd, const char *attrn switch (errno) { case ENOENT: free(acls); - return bsub_exit_nok; + return bxattr_exit_ok; default: Mmsg3(jcr->errmsg, _("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 bsub_exit_nok; + return bxattr_exit_error; } } @@ -862,7 +2296,7 @@ static bsub_exit_code solaris_save_xattr_acl(JCR *jcr, int fd, const char *attrn Dmsg3(100, "acltotext of xattr %s on \"%s\" failed: ERR=%s\n", attrname, jcr->last_fname, be.bstrerror()); free(acls); - return bsub_exit_nok; + return bxattr_exit_error; } } else { *acl_text = NULL; @@ -872,18 +2306,18 @@ static bsub_exit_code solaris_save_xattr_acl(JCR *jcr, int fd, const char *attrn } else { *acl_text = NULL; } - return bsub_exit_ok; + return bxattr_exit_ok; #endif /* HAVE_EXTENDED_ACL */ #else /* HAVE_ACL */ - return bsub_exit_ok; + return bxattr_exit_ok; #endif /* HAVE_ACL */ } /* * Forward declaration for recursive function call. */ -static bsub_exit_code solaris_save_xattrs(JCR *jcr, const char *xattr_namespace, const char *attr_parent); +static bxattr_exit_code solaris_save_xattrs(JCR *jcr, const char *xattr_namespace, const char *attr_parent); /* * Save an extended or extensible attribute. @@ -900,19 +2334,19 @@ static bsub_exit_code solaris_save_xattrs(JCR *jcr, const char *xattr_namespace, * 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 bsub_exit_code solaris_save_xattr(JCR *jcr, int fd, const char *xattr_namespace, - const char *attrname, bool toplevel_hidden_dir, int stream) +static bxattr_exit_code solaris_save_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; + xattr_link_cache_entry_t *xlce; char target_attrname[PATH_MAX]; char link_source[PATH_MAX]; char *acl_text = NULL; char attribs[MAXSTRING]; - char buffer[BUFSIZ]; - bsub_exit_code retval = bsub_exit_nok; + char buffer[XATTR_BUFSIZ]; + bxattr_exit_code retval = bxattr_exit_error; berrno be; bsnprintf(target_attrname, sizeof(target_attrname), "%s%s", xattr_namespace, attrname); @@ -923,13 +2357,14 @@ static bsub_exit_code solaris_save_xattr(JCR *jcr, int fd, const char *xattr_nam if (fstatat(fd, attrname, &st, AT_SYMLINK_NOFOLLOW) < 0) { switch (errno) { case ENOENT: - goto cleanup; + retval = bxattr_exit_ok; + goto bail_out; default: Mmsg3(jcr->errmsg, _("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; + goto bail_out; } } @@ -945,8 +2380,8 @@ static bsub_exit_code solaris_save_xattr(JCR *jcr, int fd, const char *xattr_nam /* * Get any acl on the xattr. */ - if (solaris_save_xattr_acl(jcr, attrfd, attrname, &acl_text) != bsub_exit_ok) - goto cleanup; + if (solaris_save_xattr_acl(jcr, attrfd, attrname, &acl_text) != bxattr_exit_ok) + goto bail_out; /* * The current implementation of xattr on Solaris doesn't support this, but if it ever does we are prepared. @@ -956,29 +2391,30 @@ static bsub_exit_code solaris_save_xattr(JCR *jcr, int fd, const char *xattr_nam cnt = bsnprintf(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_save_xattr_acl(jcr, attrfd, attrname, &acl_text) != bsub_exit_ok) - goto cleanup; + if (solaris_save_xattr_acl(jcr, attrfd, attrname, &acl_text) != bxattr_exit_ok) + goto bail_out; /* * See if this is the toplevel_hidden_dir being saved. */ 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. + * Save the data for later storage when we encounter a real xattr. We store the data + * in the jcr->xattr_data->content buffer and flush that just before sending out the + * first 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 = bsnprintf(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; + cnt = bsnprintf(buffer, sizeof(buffer), + "%s%c%s%c%s%c", + target_attrname, 0, attribs, 0, (acl_text) ? acl_text : "", 0); + pm_memcpy(jcr->xattr_data->content, buffer, cnt); + jcr->xattr_data->content_length = cnt; + goto bail_out; } else { /* * The current implementation of xattr on Solaris doesn't support this, but if it ever does we are prepared. @@ -998,7 +2434,7 @@ static bsub_exit_code solaris_save_xattr(JCR *jcr, int fd, const char *xattr_nam /* * See if the cache already knows this inode number. */ - if ((xlce = find_xattr_link_cache_entry(st.st_ino)) != NULL) { + if ((xlce = find_xattr_link_cache_entry(jcr, st.st_ino)) != NULL) { /* * Generate a xattr encoding with the reference to the target in there. */ @@ -1006,28 +2442,28 @@ static bsub_exit_code solaris_save_xattr(JCR *jcr, int fd, const char *xattr_nam cnt = bsnprintf(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; + pm_memcpy(jcr->xattr_data->content, buffer, cnt); + jcr->xattr_data->content_length = cnt; retval = send_xattr_stream(jcr, stream); /* * For a hard linked file we are ready now, no need to recursively save the attributes. */ - goto cleanup; + goto bail_out; } /* * 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); + add_xattr_link_cache_entry(jcr, st.st_ino, target_attrname + 1); } /* * Get any acl on the xattr. */ - if (solaris_save_xattr_acl(jcr, attrfd, attrname, &acl_text) != bsub_exit_ok) { - goto cleanup; + if (solaris_save_xattr_acl(jcr, attrfd, attrname, &acl_text) != bxattr_exit_ok) { + goto bail_out; } /* @@ -1044,17 +2480,17 @@ static bsub_exit_code solaris_save_xattr(JCR *jcr, int fd, const char *xattr_nam if ((attrfd = openat(fd, attrname, O_RDONLY)) < 0) { switch (errno) { case ENOENT: - goto cleanup; + retval = bxattr_exit_ok; + goto bail_out; default: Mmsg3(jcr->errmsg, _("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; + goto bail_out; } } break; - case S_IFLNK: /* * The current implementation of xattr on Solaris doesn't support this, but if it ever does we are prepared. @@ -1063,13 +2499,14 @@ static bsub_exit_code solaris_save_xattr(JCR *jcr, int fd, const char *xattr_nam if (readlink(attrname, link_source, sizeof(link_source)) < 0) { switch (errno) { case ENOENT: - goto cleanup; + retval = bxattr_exit_ok; + goto bail_out; default: Mmsg3(jcr->errmsg, _("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; + goto bail_out; } } @@ -1080,30 +2517,37 @@ static bsub_exit_code solaris_save_xattr(JCR *jcr, int fd, const char *xattr_nam cnt = bsnprintf(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; + pm_memcpy(jcr->xattr_data->content, buffer, cnt); + jcr->xattr_data->content_length = cnt; retval = send_xattr_stream(jcr, stream); + if (retval == bxattr_exit_ok) { + jcr->xattr_data->nr_saved++; + } + /* * For a soft linked file we are ready now, no need to recursively save the attributes. */ - goto cleanup; - + goto bail_out; default: - goto cleanup; + goto bail_out; } /* - * See if this is the first real xattr being saved. If it is save the toplevel_hidden_dir attributes first. + * See if this is the first real xattr being saved. + * If it is save the toplevel_hidden_dir attributes first. + * This is easy as its stored already in the jcr->xattr_data->content buffer. */ - 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; + if (jcr->xattr_data->nr_saved == 0) { retval = send_xattr_stream(jcr, STREAM_XATTR_SOLARIS); + if (retval != bxattr_exit_ok) { + goto bail_out; + } + jcr->xattr_data->nr_saved++; } - pm_memcpy(jcr->xattr_data, buffer, cnt); - jcr->xattr_data_len = cnt; + pm_memcpy(jcr->xattr_data->content, buffer, cnt); + jcr->xattr_data->content_length = cnt; /* * Only dump the content of regular files. @@ -1117,13 +2561,13 @@ static bsub_exit_code solaris_save_xattr(JCR *jcr, int fd, const char *xattr_nam if (st.st_size >= MAX_XATTR_STREAM) { Mmsg2(jcr->errmsg, _("Xattr stream on file \"%s\" exceeds maximum size of %d bytes\n"), jcr->last_fname, MAX_XATTR_STREAM); - goto cleanup; + goto bail_out; } 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; + jcr->xattr_data->content = check_pool_memory_size(jcr->xattr_data->content, jcr->xattr_data->content_length + cnt); + memcpy(jcr->xattr_data->content + jcr->xattr_data->content_length, buffer, cnt); + jcr->xattr_data->content_length += cnt; } if (cnt < 0) { @@ -1131,7 +2575,7 @@ static bsub_exit_code solaris_save_xattr(JCR *jcr, int fd, const char *xattr_nam target_attrname, jcr->last_fname); Dmsg2(100, "read of data from xattr %s on \"%s\" failed\n", target_attrname, jcr->last_fname); - goto cleanup; + goto bail_out; } } break; @@ -1142,7 +2586,9 @@ static bsub_exit_code solaris_save_xattr(JCR *jcr, int fd, const char *xattr_nam if (retval) { retval = send_xattr_stream(jcr, stream); - nr_xattr_saved++; + if (retval == bxattr_exit_ok) { + jcr->xattr_data->nr_saved++; + } } /* @@ -1158,19 +2604,20 @@ static bsub_exit_code solaris_save_xattr(JCR *jcr, int fd, const char *xattr_nam if (fchdir(fd) < 0) { switch (errno) { case ENOENT: - goto cleanup; + retval = bxattr_exit_ok; + goto bail_out; default: Mmsg2(jcr->errmsg, _("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; + goto bail_out; } } } -cleanup: - if (acl_text) { +bail_out: + if (acl_text != NULL) { free(acl_text); } if (attrfd != -1) { @@ -1179,14 +2626,14 @@ cleanup: return retval; } -static bsub_exit_code solaris_save_xattrs(JCR *jcr, const char *xattr_namespace, const char *attr_parent) +static bxattr_exit_code solaris_save_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]; - bsub_exit_code retval = bsub_exit_nok; + bxattr_exit_code retval = bxattr_exit_error; berrno be; /* @@ -1213,13 +2660,14 @@ static bsub_exit_code solaris_save_xattrs(JCR *jcr, const char *xattr_namespace, if ((filefd = open(name, O_RDONLY | O_NONBLOCK)) < 0) { switch (errno) { case ENOENT: - goto cleanup; + retval = bxattr_exit_ok; + goto bail_out; default: Mmsg2(jcr->errmsg, _("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; + goto bail_out; } } @@ -1234,16 +2682,17 @@ static bsub_exit_code solaris_save_xattrs(JCR *jcr, const char *xattr_namespace, * 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 = bsub_exit_ok; - goto cleanup; + retval = bxattr_exit_ok; + goto bail_out; case ENOENT: - goto cleanup; + retval = bxattr_exit_ok; + goto bail_out; default: Mmsg3(jcr->errmsg, _("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; + goto bail_out; } } @@ -1256,7 +2705,7 @@ static bsub_exit_code solaris_save_xattrs(JCR *jcr, const char *xattr_namespace, 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; + goto bail_out; } /* @@ -1266,7 +2715,7 @@ static bsub_exit_code solaris_save_xattrs(JCR *jcr, const char *xattr_namespace, */ if (!attr_parent) solaris_save_xattr(jcr, attrdirfd, current_xattr_namespace, ".", - true, STREAM_XATTR_SOLARIS); + true, STREAM_XATTR_SOLARIS); if ((fd = dup(attrdirfd)) == -1 || (dirp = fdopendir(fd)) == (DIR *)NULL) { @@ -1275,23 +2724,23 @@ static bsub_exit_code solaris_save_xattrs(JCR *jcr, const char *xattr_namespace, Dmsg3(100, "Unable to fdopendir xattr space on file \"%s\" using fd %d: ERR=%s\n", jcr->last_fname, fd, be.bstrerror()); - goto cleanup; + goto bail_out; } /* * Walk the namespace. */ - while (dp = readdir(dirp)) { + while ((dp = readdir(dirp)) != NULL) { /* * Skip only the toplevel . dir. */ - if (!attr_parent && !strcmp(dp->d_name, ".")) + if (!attr_parent && bstrcmp(dp->d_name, ".")) continue; /* * Skip all .. directories */ - if (!strcmp(dp->d_name, "..")) + if (bstrcmp(dp->d_name, "..")) continue; Dmsg3(400, "processing extended attribute %s%s on file \"%s\"\n", @@ -1301,7 +2750,7 @@ static bsub_exit_code solaris_save_xattrs(JCR *jcr, const char *xattr_namespace, /* * We are not interested in read-only extensible attributes. */ - if (!strcmp(dp->d_name, VIEW_READONLY)) { + if (bstrcmp(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); @@ -1312,7 +2761,7 @@ static bsub_exit_code solaris_save_xattrs(JCR *jcr, const char *xattr_namespace, * We are only interested in read-write extensible attributes * when they contain non-transient values. */ - if (!strcmp(dp->d_name, VIEW_READWRITE)) { + if (bstrcmp(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. @@ -1327,7 +2776,7 @@ static bsub_exit_code solaris_save_xattrs(JCR *jcr, const char *xattr_namespace, * Save the xattr. */ solaris_save_xattr(jcr, attrdirfd, current_xattr_namespace, dp->d_name, - false, STREAM_XATTR_SOLARIS_SYS); + false, STREAM_XATTR_SOLARIS_SYS); continue; } #endif /* HAVE_SYS_NVPAIR_H && _PC_SATTR_ENABLED */ @@ -1336,13 +2785,13 @@ static bsub_exit_code solaris_save_xattrs(JCR *jcr, const char *xattr_namespace, * Save the xattr. */ solaris_save_xattr(jcr, attrdirfd, current_xattr_namespace, dp->d_name, - false, STREAM_XATTR_SOLARIS); + false, STREAM_XATTR_SOLARIS); } closedir(dirp); - retval = bsub_exit_ok; + retval = bxattr_exit_ok; -cleanup: +bail_out: if (attrdirfd != -1) close(attrdirfd); if (filefd != -1) @@ -1351,7 +2800,7 @@ cleanup: } #ifdef HAVE_ACL -static bsub_exit_code solaris_restore_xattr_acl(JCR *jcr, int fd, const char *attrname, char *acl_text) +static bxattr_exit_code solaris_restore_xattr_acl(JCR *jcr, int fd, const char *attrname, char *acl_text) { #ifdef HAVE_EXTENDED_ACL int error; @@ -1361,7 +2810,7 @@ static bsub_exit_code solaris_restore_xattr_acl(JCR *jcr, int fd, const char *at if ((error = acl_fromtext(acl_text, &aclp)) != 0) { Mmsg1(jcr->errmsg, _("Unable to convert acl from text on file \"%s\"\n"), jcr->last_fname); - return bsub_exit_nok; + return bxattr_exit_error; } if ((fd != -1 && facl_set(fd, aclp) != 0) || @@ -1370,13 +2819,13 @@ static bsub_exit_code solaris_restore_xattr_acl(JCR *jcr, int fd, const char *at 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 bsub_exit_nok; + return bxattr_exit_error; } if (aclp) { acl_free(aclp); } - return bsub_exit_ok; + return bxattr_exit_ok; #else /* HAVE_EXTENDED_ACL */ int n; @@ -1391,21 +2840,21 @@ static bsub_exit_code solaris_restore_xattr_acl(JCR *jcr, int fd, const char *at 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 bsub_exit_nok; + return bxattr_exit_error; } } if (acls) { free(acls); } - return bsub_exit_ok; + return bxattr_exit_ok; #endif /* HAVE_EXTENDED_ACL */ } #endif /* HAVE_ACL */ -static bsub_exit_code solaris_restore_xattrs(JCR *jcr, bool is_extensible) +static bxattr_exit_code solaris_restore_xattrs(JCR *jcr, bool is_extensible) { int fd, filefd = -1, attrdirfd = -1, attrfd = -1; int used_bytes, total_bytes, cnt; @@ -1416,23 +2865,23 @@ static bsub_exit_code solaris_restore_xattrs(JCR *jcr, bool is_extensible) int32_t inum; struct stat st; struct timeval times[2]; - bsub_exit_code retval = bsub_exit_nok; + bxattr_exit_code retval = bxattr_exit_error; berrno be; /* * Parse the xattr stream. First the part that is the same for all xattrs. */ used_bytes = 0; - total_bytes = jcr->xattr_data_len; + total_bytes = jcr->xattr_data->content_length; /* * 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; + target_attrname = jcr->xattr_data->content + 1; if ((bp = strchr(target_attrname, '\0')) == (char *)NULL || - (used_bytes = (bp - jcr->xattr_data)) >= (total_bytes - 1)) { + (used_bytes = (bp - jcr->xattr_data->content)) >= (total_bytes - 1)) { goto parse_error; } attribs = ++bp; @@ -1445,7 +2894,7 @@ static bsub_exit_code solaris_restore_xattrs(JCR *jcr, bool is_extensible) jcr->last_fname, be.bstrerror()); Dmsg2(100, "Unable to open file \"%s\": ERR=%s\n", jcr->last_fname, be.bstrerror()); - goto cleanup; + goto bail_out; } /* @@ -1456,7 +2905,7 @@ static bsub_exit_code solaris_restore_xattrs(JCR *jcr, bool is_extensible) 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; + goto bail_out; } if (fchdir(attrdirfd) < 0) { @@ -1464,7 +2913,7 @@ static bsub_exit_code solaris_restore_xattrs(JCR *jcr, bool is_extensible) 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; + goto bail_out; } /* @@ -1480,7 +2929,7 @@ static bsub_exit_code solaris_restore_xattrs(JCR *jcr, bool is_extensible) 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; + goto bail_out; } close(filefd); @@ -1494,7 +2943,7 @@ static bsub_exit_code solaris_restore_xattrs(JCR *jcr, bool is_extensible) 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; + goto bail_out; } close(attrdirfd); @@ -1508,7 +2957,7 @@ static bsub_exit_code solaris_restore_xattrs(JCR *jcr, bool is_extensible) 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; + goto bail_out; } target_attrname = ++bp; @@ -1523,7 +2972,7 @@ static bsub_exit_code solaris_restore_xattrs(JCR *jcr, bool is_extensible) * Decode the next field (acl_text). */ if ((bp = strchr(attribs, '\0')) == (char *)NULL || - (used_bytes = (bp - jcr->xattr_data)) >= (total_bytes - 1)) { + (used_bytes = (bp - jcr->xattr_data->content)) >= (total_bytes - 1)) { goto parse_error; } acl_text = ++bp; @@ -1544,7 +2993,7 @@ static bsub_exit_code solaris_restore_xattrs(JCR *jcr, bool is_extensible) 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; + goto bail_out; } break; case S_IFCHR: @@ -1558,7 +3007,7 @@ static bsub_exit_code solaris_restore_xattrs(JCR *jcr, bool is_extensible) 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; + goto bail_out; } break; case S_IFDIR: @@ -1566,14 +3015,14 @@ static bsub_exit_code solaris_restore_xattrs(JCR *jcr, bool is_extensible) * 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, ".")) { + if (!bstrcmp(target_attrname, ".")) { unlinkat(attrdirfd, target_attrname, AT_REMOVEDIR); if (mkdir(target_attrname, st.st_mode) < 0) { 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; + goto bail_out; } } break; @@ -1590,17 +3039,17 @@ static bsub_exit_code solaris_restore_xattrs(JCR *jcr, bool is_extensible) 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; + goto bail_out; } /* * Successfully restored xattr. */ - retval = bsub_exit_ok; - goto cleanup; + retval = bxattr_exit_ok; + goto bail_out; } else { if ((bp = strchr(acl_text, '\0')) == (char *)NULL || - (used_bytes = (bp - jcr->xattr_data)) >= total_bytes) { + (used_bytes = (bp - jcr->xattr_data->content)) >= total_bytes) { goto parse_error; } @@ -1619,7 +3068,7 @@ static bsub_exit_code solaris_restore_xattrs(JCR *jcr, bool is_extensible) 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; + goto bail_out; } } @@ -1627,7 +3076,7 @@ static bsub_exit_code solaris_restore_xattrs(JCR *jcr, bool is_extensible) * Restore the actual data. */ if (st.st_size > 0) { - used_bytes = (data - jcr->xattr_data); + used_bytes = (data - jcr->xattr_data->content); cnt = total_bytes - used_bytes; /* @@ -1639,7 +3088,7 @@ static bsub_exit_code solaris_restore_xattrs(JCR *jcr, bool is_extensible) 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; + goto bail_out; } while (cnt > 0) { @@ -1649,7 +3098,7 @@ static bsub_exit_code solaris_restore_xattrs(JCR *jcr, bool is_extensible) 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; + goto bail_out; } used_bytes += cnt; @@ -1669,16 +3118,16 @@ static bsub_exit_code solaris_restore_xattrs(JCR *jcr, bool is_extensible) 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; + goto bail_out; } /* * Successfully restored xattr. */ - retval = bsub_exit_ok; - goto cleanup; + retval = bxattr_exit_ok; + goto bail_out; default: - goto cleanup; + goto bail_out; } /* @@ -1692,7 +3141,10 @@ static bsub_exit_code solaris_restore_xattrs(JCR *jcr, bool is_extensible) * 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 = bsub_exit_ok; + retval = bxattr_exit_ok; + break; + case ENOENT: + retval = bxattr_exit_ok; break; default: Mmsg3(jcr->errmsg, _("Unable to restore owner of xattr %s on file \"%s\": ERR=%s\n"), @@ -1700,14 +3152,14 @@ static bsub_exit_code solaris_restore_xattrs(JCR *jcr, bool is_extensible) Dmsg3(100, "Unable to restore owner of xattr %s on file \"%s\": ERR=%s\n", target_attrname, jcr->last_fname, be.bstrerror()); } - goto cleanup; + goto bail_out; } } #ifdef HAVE_ACL if (acl_text && *acl_text) - if (solaris_restore_xattr_acl(jcr, attrfd, target_attrname, acl_text) != bsub_exit_ok) - goto cleanup; + if (solaris_restore_xattr_acl(jcr, attrfd, target_attrname, acl_text) != bxattr_exit_ok) + goto bail_out; #endif /* HAVE_ACL */ /* @@ -1724,15 +3176,15 @@ static bsub_exit_code solaris_restore_xattrs(JCR *jcr, bool is_extensible) 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; + goto bail_out; } } /* * Successfully restored xattr. */ - retval = bsub_exit_ok; - goto cleanup; + retval = bxattr_exit_ok; + goto bail_out; parse_error: Mmsg1(jcr->errmsg, _("Illegal xattr stream, failed to parse xattr stream on file \"%s\"\n"), @@ -1740,7 +3192,7 @@ parse_error: Dmsg1(100, "Illegal xattr stream, failed to parse xattr stream on file \"%s\"\n", jcr->last_fname); -cleanup: +bail_out: if (attrfd != -1) { close(attrfd); } @@ -1753,37 +3205,37 @@ cleanup: return retval; } -static bsub_exit_code solaris_build_xattr_streams(JCR *jcr, FF_PKT *ff_pkt, int default_stream) +static bxattr_exit_code solaris_build_xattr_streams(JCR *jcr, FF_PKT *ff_pkt) { char cwd[PATH_MAX]; - bsub_exit_code retval = bsub_exit_ok; + bxattr_exit_code retval = bxattr_exit_ok; /* * 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; + jcr->xattr_data->nr_saved = 0; + jcr->xattr_data->link_cache = New(alist(10, not_owned_by_alist)); /* * As we change the cwd in the save function save the current cwd * for restore after return from the solaris_save_xattrs function. */ - xattr_link_cache = New(alist(10, not_owned_by_alist)); getcwd(cwd, sizeof(cwd)); retval = solaris_save_xattrs(jcr, NULL, NULL); chdir(cwd); - delete xattr_link_cache; - xattr_link_cache = NULL; + delete jcr->xattr_data->link_cache; + jcr->xattr_data->link_cache = NULL; } return retval; } -static bsub_exit_code solaris_parse_xattr_streams(JCR *jcr, int stream) +static bxattr_exit_code solaris_parse_xattr_streams(JCR *jcr, int stream) { char cwd[PATH_MAX]; bool is_extensible = false; - bsub_exit_code retval; + bxattr_exit_code retval; /* * First make sure we can restore xattr on the filesystem. @@ -1792,12 +3244,10 @@ static bsub_exit_code solaris_parse_xattr_streams(JCR *jcr, int 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); + Mmsg1(jcr->errmsg, _("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 bsub_exit_nok; + return bxattr_exit_error; } is_extensible = true; @@ -1805,16 +3255,14 @@ static bsub_exit_code solaris_parse_xattr_streams(JCR *jcr, int stream) #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); + Mmsg1(jcr->errmsg, _("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 bsub_exit_nok; + return bxattr_exit_error; } break; default: - return bsub_exit_nok; + return bxattr_exit_error; } /* @@ -1831,22 +3279,25 @@ static bsub_exit_code solaris_parse_xattr_streams(JCR *jcr, int stream) /* * Function pointers to the build and parse function to use for these xattrs. */ -static bsub_exit_code (*os_build_xattr_streams)(JCR *jcr, FF_PKT *ff_pkt, int default_stream) = solaris_build_xattr_streams; -static bsub_exit_code (*os_parse_xattr_streams)(JCR *jcr, int stream) = solaris_parse_xattr_streams; +static bxattr_exit_code (*os_build_xattr_streams)(JCR *jcr, FF_PKT *ff_pkt) = solaris_build_xattr_streams; +static bxattr_exit_code (*os_parse_xattr_streams)(JCR *jcr, int stream) = solaris_parse_xattr_streams; #endif /* defined(HAVE_SUN_OS) */ -bsub_exit_code build_xattr_streams(JCR *jcr, FF_PKT *ff_pkt) +/* + * Entry points when compiled with support for XATTRs on a supported platform. + */ +bxattr_exit_code build_xattr_streams(JCR *jcr, FF_PKT *ff_pkt) { if (os_build_xattr_streams) { - return (*os_build_xattr_streams)(jcr, ff_pkt, os_default_xattr_streams[0]); + return (*os_build_xattr_streams)(jcr, ff_pkt); } - return bsub_exit_nok; + return bxattr_exit_error; } -bsub_exit_code parse_xattr_streams(JCR *jcr, int stream) +bxattr_exit_code parse_xattr_streams(JCR *jcr, int stream) { - int cnt; + unsigned int cnt; if (os_parse_xattr_streams) { /* @@ -1864,6 +3315,6 @@ bsub_exit_code parse_xattr_streams(JCR *jcr, int stream) Jmsg2(jcr, M_WARNING, 0, _("Can't restore Extended Attributes of %s - incompatible xattr stream encountered - %d\n"), jcr->last_fname, stream); - return bsub_exit_nok; + return bxattr_exit_error; } #endif