/*
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.
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.
* they were saved using a filed on the same platform.
*
* Currently we support the following OSes:
- * - FreeBSD (Extended Attributes)
* - Darwin (Extended Attributes)
* - Linux (Extended Attributes)
* - NetBSD (Extended Attributes)
+ * - FreeBSD (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)
*
* 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
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;
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.
+ * First some generic functions for OSes that use the same xattr encoding scheme.
*/
#if defined(HAVE_DARWIN_OS) || \
- defined(HAVE_FREEBSD_OS) || \
defined(HAVE_LINUX_OS) || \
- defined(HAVE_NETBSD_OS)
-
-#ifdef HAVE_SYS_XATTR_H
-#include <sys/xattr.h>
-#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.
- */
-#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
+ defined(HAVE_NETBSD_OS) || \
+ defined(HAVE_FREEBSD_OS) || \
+ defined(HAVE_OPENBSD_OS)
-static void xattr_drop_internal_table(xattr_t *xattr_value_list)
+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;
}
/*
* 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;
* 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);
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);
+ }
+ }
+
+ 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 for lsetxattr.
+ */
+ 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);
+ } else {
+ current_xattr->value = NULL;
+ }
+
+ 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_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 either full support for the LXATTR or XATTR functions."
+#endif
+
+#ifdef HAVE_SYS_XATTR_H
+#include <sys/xattr.h>
+#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
-static bsub_exit_code generic_xattr_build_streams(JCR *jcr, FF_PKT *ff_pkt)
+/*
+ * 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 linux_xattr_build_streams(JCR *jcr, FF_PKT *ff_pkt)
{
- int count = 0;
+ bool skip_xattr;
+ char *xattr_list, *bp;
+ int cnt, xattr_count = 0;
int32_t xattr_list_len,
xattr_value_len;
uint32_t expected_serialize_len = 0;
- char *xattr_list, *bp;
- xattr_t *xattr_value_list = NULL, *current_xattr;
+ xattr_t *current_xattr;
+ 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) {
+ switch (xattr_list_len) {
+ case -1:
switch (errno) {
case ENOENT:
- return bsub_exit_nok;
+ 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 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;
}
/*
* 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) {
+ switch (xattr_list_len) {
+ case -1:
switch (errno) {
case ENOENT:
- free(xattr_list);
- return bsub_exit_nok;
+ 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());
- free(xattr_list);
- return bsub_exit_nok;
+ goto bail_out;
}
+ break;
+ default:
+ break;
}
xattr_list[xattr_list_len] = '\0';
+ xattr_value_list = New(alist(10, not_owned_by_alist));
+
/*
- * 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)
+ int name_len;
+ skip_xattr = false;
+
/*
- * 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++;
+ 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_len = strlen(bp);
+ if (skip_xattr || name_len == 0) {
+ 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_len;
+ 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:
+ retval = bxattr_exit_ok;
+ free(current_xattr->name);
+ free(current_xattr);
+ 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());
+ free(current_xattr->name);
+ free(current_xattr);
+ 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:
+ retval = bxattr_exit_ok;
+ free(current_xattr->value);
+ free(current_xattr->name);
+ free(current_xattr);
+ 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());
+ free(current_xattr->value);
+ free(current_xattr->name);
+ free(current_xattr);
+ 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);
+ free(current_xattr->value);
+ free(current_xattr->name);
+ free(current_xattr);
+ goto bail_out;
+ }
+ break;
+ }
+
+ xattr_value_list->append(current_xattr);
+ xattr_count++;
+ bp = strchr(bp, '\0') + 1;
+ }
+
+ 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;
+ }
+
+ xattr_drop_internal_table(xattr_value_list);
+
+ /*
+ * Send the datastream to the SD.
+ */
+ return send_xattr_stream(jcr, os_default_xattr_streams[0]);
+ } else {
+ xattr_drop_internal_table(xattr_value_list);
+
+ return bxattr_exit_ok;
+ }
+
+bail_out:
+ 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 linux_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:
+ 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) = linux_xattr_build_streams;
+static bxattr_exit_code (*os_parse_xattr_streams)(JCR *jcr, int stream) = linux_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 <sys/extattr.h>
#else
- count++;
+#error "Missing sys/extattr.h header file"
+#endif
+
+#ifdef HAVE_LIBUTIL_H
+#include <libutil.h>
+#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
- bp = strchr(bp, '\0') + 1;
- }
+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;
+ alist *xattr_value_list = NULL;
+ bxattr_exit_code retval = bxattr_exit_error;
+ berrno be;
- if (count == 0) {
- retval = bsub_exit_ok;
- goto bail_out;
- }
+ xattr_value_list = New(alist(10, not_owned_by_alist));
/*
- * Allocate enough room to hold all extended attributes.
- * After allocating the storage make sure its empty by zeroing it.
+ * Loop over all available xattr namespaces.
*/
- xattr_value_list = (xattr_t *)malloc(count * sizeof(xattr_t));
- memset((caddr_t)xattr_value_list, 0, count * sizeof(xattr_t));
+ for (namespace_index = 0; namespace_index < sizeof(os_default_xattr_namespaces) / sizeof(int); namespace_index++) {
+ attrnamespace = os_default_xattr_namespaces[namespace_index];
- /*
- * 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)
/*
- * On Linux 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.
+ * 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 (ff_pkt->flags & FO_ACL && !strcmp(bp, "system.posix_acl_access")) {
- bp = strchr(bp, '\0') + 1;
- continue;
+ 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;
}
-#endif
-
- /*
- * Each xattr valuepair starts with a magic so we can parse it easier.
- */
- 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);
-
- expected_serialize_len += sizeof(current_xattr->name_length) + current_xattr->name_length;
/*
- * First see how long the value is for the extended attribute.
+ * 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_value_len = lgetxattr(jcr->last_fname, bp, NULL, 0);
- if (xattr_value_len < 0) {
+ 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, _("lgetxattr error on file \"%s\": ERR=%s\n"),
+ Mmsg2(jcr->errmsg, _("extattr_list_link error on file \"%s\": ERR=%s\n"),
jcr->last_fname, be.bstrerror());
- Dmsg2(100, "lgetxattr error file=%s ERR=%s\n",
+ 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 space for storing the value.
+ * Allocate room for the extented attribute list.
*/
- current_xattr->value = (char *)malloc(xattr_value_len);
- memset((caddr_t)current_xattr->value, 0, xattr_value_len);
+ xattr_list = (char *)malloc(xattr_list_len + 1);
+ memset((caddr_t)xattr_list, 0, xattr_list_len + 1);
- xattr_value_len = lgetxattr(jcr->last_fname, bp, current_xattr->value, xattr_value_len);
- if (xattr_value_len < 0) {
+ /*
+ * 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, _("lgetxattr error on file \"%s\": ERR=%s\n"),
+ Mmsg2(jcr->errmsg, _("extattr_list_link error on file \"%s\": ERR=%s\n"),
jcr->last_fname, be.bstrerror());
- Dmsg2(100, "lgetxattr error file=%s ERR=%s\n",
+ 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';
/*
- * Store the actual length of the value.
+ * 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->value_length = xattr_value_len;
- expected_serialize_len += sizeof(current_xattr->value_length) + current_xattr->value_length;
+ 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.<attrname> or system.<attrname>
+ */
+ 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) {
+ 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;
+ free(current_xattr->name);
+ free(current_xattr);
+ 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());
+ free(current_xattr->name);
+ free(current_xattr);
+ 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;
+ free(current_xattr->value);
+ free(current_xattr->name);
+ free(current_xattr);
+ 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());
+ free(current_xattr->value);
+ free(current_xattr->name);
+ free(current_xattr);
+ 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);
+ free(current_xattr->value);
+ free(current_xattr->name);
+ free(current_xattr);
+ goto bail_out;
+ }
+ break;
+ }
+
+ xattr_value_list->append(current_xattr);
+ xattr_count++;
+
+ }
/*
- * Protect ourself against things getting out of hand.
+ * Drop the local copy of the current_attrnamespace.
*/
- 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;
- }
-
+ actuallyfree(current_attrnamespace);
+ current_attrnamespace = NULL;
+
/*
- * Next attribute.
+ * We are done with this xattr list.
*/
- current_xattr++;
- bp = strchr(bp, '\0') + 1;
+ free(xattr_list);
+ xattr_list = (char *)NULL;
}
/*
- * Serialize the datastream.
+ * If we found any xattr send them to the SD.
*/
- 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_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;
+ }
- xattr_drop_internal_table(xattr_value_list);
- free(xattr_list);
+ xattr_drop_internal_table(xattr_value_list);
- /*
- * Send the datastream to the SD.
- */
- return send_xattr_stream(jcr, os_default_xattr_streams[0]);
+ /*
+ * Send the datastream to the SD.
+ */
+ return send_xattr_stream(jcr, os_default_xattr_streams[0]);
+ } else {
+ xattr_drop_internal_table(xattr_value_list);
+
+ return bxattr_exit_ok;
+ }
bail_out:
- if (xattr_value_list) {
+ if (current_attrnamespace != NULL) {
+ actuallyfree(current_attrnamespace);
+ }
+ if (xattr_list != NULL) {
+ free(xattr_list);
+ }
+ if (xattr_value_list != NULL) {
xattr_drop_internal_table(xattr_value_list);
}
- free(xattr_list);
- return bsub_exit_nok;
+ return retval;
}
-static bsub_exit_code generic_xattr_parse_streams(JCR *jcr, int stream)
+static bxattr_exit_code bsd_parse_xattr_streams(JCR *jcr, int stream)
{
- unser_declare;
- xattr_t current_xattr;
- bsub_exit_code retval = bsub_exit_nok;
+ xattr_t *current_xattr;
+ alist *xattr_value_list;
+ int current_attrnamespace, cnt;
+ char *attrnamespace, *attrname;
berrno be;
- /*
- * 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.
- */
- 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);
+ xattr_value_list = New(alist(10, not_owned_by_alist));
- /*
- * The xattr_name needs to be null terminated for lsetxattr.
- */
- current_xattr.name[current_xattr.name_length] = '\0';
+ 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) {
/*
- * Decode the value length.
+ * Try splitting the xattr_name into a namespace and name part.
+ * The splitting character is a .
*/
- unser_uint32(current_xattr.value_length);
+ 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';
/*
- * Allocate room for the value and decode its content.
+ * Make sure the attrnamespace makes sense.
*/
- current_xattr.value = (char *)malloc(current_xattr.value_length);
- unser_bytes(current_xattr.value, current_xattr.value_length);
+ 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 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.
+ * Try restoring the extended attribute.
*/
- if (lsetxattr(jcr->last_fname, current_xattr.name, current_xattr.value,
- current_xattr.value_length, 0) != 0) {
+ 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, _("lsetxattr error on file \"%s\": ERR=%s\n"),
+ Mmsg2(jcr->errmsg, _("extattr_set_link error on file \"%s\": ERR=%s\n"),
jcr->last_fname, be.bstrerror());
- Dmsg2(100, "lsetxattr error file=%s ERR=%s\n",
+ Dmsg2(100, "extattr_set_link error file=%s ERR=%s\n",
jcr->last_fname, be.bstrerror());
+ goto bail_out;
break;
}
}
-
- /*
- * Free the temporary buffers.
- */
- free(current_xattr.name);
- free(current_xattr.value);
}
- unser_end(jcr->xattr_data, jcr->xattr_data_len);
- return retval;
+ xattr_drop_internal_table(xattr_value_list);
+ return bxattr_exit_ok;
+
+bail_out:
+ 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) = 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) = bsd_build_xattr_streams;
+static bxattr_exit_code (*os_parse_xattr_streams)(JCR *jcr, int stream) = bsd_parse_xattr_streams;
#elif defined(HAVE_SUN_OS)
/*
#include <sys/acl.h>
#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};
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;
}
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)
fattr = name_to_attr(name);
} else {
retval = true;
- goto cleanup;
+ goto bail_out;
}
type = nvpair_type(pair);
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);
}
}
#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
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;
}
}
} else {
*acl_text = NULL;
}
- return bsub_exit_ok;
+ return bxattr_exit_ok;
#else /* HAVE_EXTENDED_ACL */
int n;
aclent_t *acls = NULL;
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;
}
}
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;
} 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.
* 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);
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;
}
}
/*
* 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.
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.
/*
* 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.
*/
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;
}
/*
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.
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;
}
}
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.
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) {
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;
if (retval) {
retval = send_xattr_stream(jcr, stream);
- nr_xattr_saved++;
+ if (retval == bxattr_exit_ok) {
+ jcr->xattr_data->nr_saved++;
+ }
}
/*
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) {
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;
/*
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;
}
}
* 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;
}
}
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;
}
/*
*/
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) {
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;
}
/*
/*
* 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",
/*
* 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);
* 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.
* 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 */
* 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)
}
#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;
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) ||
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;
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;
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;
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;
}
/*
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) {
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;
}
/*
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);
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);
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;
* 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;
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:
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:
* 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;
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;
}
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;
}
}
* 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;
/*
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) {
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;
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;
}
/*
* 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"),
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 */
/*
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"),
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);
}
return retval;
}
-static bsub_exit_code solaris_build_xattr_streams(JCR *jcr, FF_PKT *ff_pkt)
+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.
#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;
#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;
}
/*
/*
* 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) = 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);
}
- 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) {
/*
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