+#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 <naming_space_name><xattr_name>
+ */
+ 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 <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
+
+/*
+ * 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 <sys/extattr.h>
+#else
+#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
+
+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;
+ }
projects / bacula / bacula / blobdiff