X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=bacula%2Fsrc%2Ffiled%2Fxattr.c;h=5781e76feb44bf136ef0b111d33fd8e07c5d5dc7;hb=cdf54bf846ee8177604133eca433417401a7f44f;hp=3a1f1ea85cce1b8c4fb80fe371ffbec4a8c9d5cf;hpb=3265e231ad7d68e28bfb34190e3f9f05e6535321;p=bacula%2Fbacula

diff --git a/bacula/src/filed/xattr.c b/bacula/src/filed/xattr.c
index 3a1f1ea85c..5781e76feb 100644
--- a/bacula/src/filed/xattr.c
+++ b/bacula/src/filed/xattr.c
@@ -25,7 +25,7 @@
    (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
@@ -34,9 +34,10 @@
  * Currently we support the following OSes:
  *   - AIX (Extended Attributes)
  *   - Darwin (Extended Attributes)
+ *   - FreeBSD (Extended Attributes)
+ *   - IRIX (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
@@ -44,16 +45,16 @@
  *      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
- *
  */
 
 #include "bacula.h"
 #include "filed.h"
 
 #if !defined(HAVE_XATTR)
-/*
+/**
  * Entry points when compiled without support for XATTRs or on an unsupported platform.
  */
 bxattr_exit_code build_xattr_streams(JCR *jcr, FF_PKT *ff_pkt)
@@ -66,7 +67,7 @@ bxattr_exit_code parse_xattr_streams(JCR *jcr, int stream)
    return bxattr_exit_fatal;
 }
 #else
-/*
+/**
  * Send a XATTR stream to the SD.
  */
 static bxattr_exit_code send_xattr_stream(JCR *jcr, int stream)
@@ -119,16 +120,11 @@ static bxattr_exit_code send_xattr_stream(JCR *jcr, int stream)
    return bxattr_exit_ok;
 }
 
-/*
+/**
  * First some generic functions for OSes that use the same xattr encoding scheme.
+ * Currently for all OSes except for Solaris.
  */
-#if defined(HAVE_AIX_OS) || \
-    defined(HAVE_DARWIN_OS) || \
-    defined(HAVE_LINUX_OS) || \
-    defined(HAVE_NETBSD_OS) || \
-    defined(HAVE_FREEBSD_OS) || \
-    defined(HAVE_OPENBSD_OS)
-
+#if !defined(HAVE_SUN_OS)
 static void xattr_drop_internal_table(alist *xattr_value_list)
 {
    xattr_t *current_xattr;
@@ -154,7 +150,7 @@ static void xattr_drop_internal_table(alist *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.
  *
@@ -197,6 +193,11 @@ static uint32_t serialize_xattr_stream(JCR *jcr, uint32_t expected_serialize_len
       ser_uint32(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);
       }
    }
 
@@ -212,7 +213,7 @@ static bxattr_exit_code unserialize_xattr_stream(JCR *jcr, alist *xattr_value_li
    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
@@ -224,7 +225,6 @@ static bxattr_exit_code unserialize_xattr_stream(JCR *jcr, alist *xattr_value_li
        * 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) {
@@ -271,8 +271,12 @@ static bxattr_exit_code unserialize_xattr_stream(JCR *jcr, alist *xattr_value_li
           */
          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);
@@ -294,7 +298,7 @@ static bxattr_exit_code unserialize_xattr_stream(JCR *jcr, alist *xattr_value_li
 #error "Missing full support for the Extended Attributes (EA) functions."
 #endif
 
-#ifdef HAVE_SYS_EA
+#ifdef HAVE_SYS_EA_H
 #include <sys/ea.h>
 #else
 #error "Missing sys/ea.h header file"
@@ -327,7 +331,7 @@ static bxattr_exit_code aix_xattr_build_streams(JCR *jcr, FF_PKT *ff_pkt)
    int32_t xattr_list_len,
            xattr_value_len;
    uint32_t expected_serialize_len = 0;
-   xattr_t *current_xattr;
+   xattr_t *current_xattr = NULL;
    alist *xattr_value_list = NULL;
    bxattr_exit_code retval = bxattr_exit_error;
    berrno be;
@@ -388,8 +392,6 @@ static bxattr_exit_code aix_xattr_build_streams(JCR *jcr, FF_PKT *ff_pkt)
    }
    xattr_list[xattr_list_len] = '\0';
 
-   xattr_value_list = New(alist(10, not_owned_by_alist));
-
    /*
     * Walk the list of extended attributes names and retrieve the data.
     * We already count the bytes needed for serializing the stream later on.
@@ -407,6 +409,7 @@ static bxattr_exit_code aix_xattr_build_streams(JCR *jcr, FF_PKT *ff_pkt)
 
       name_length = strlen(bp);
       if (skip_xattr || name_length == 0) {
+         Dmsg1(100, "Skipping xattr named %s\n", bp);
          bp = strchr(bp, '\0') + 1;
          continue;
       }
@@ -438,16 +441,12 @@ static bxattr_exit_code aix_xattr_build_streams(JCR *jcr, FF_PKT *ff_pkt)
          case EFORMAT:
          case ENOTSUP:
             retval = bxattr_exit_ok;
-            free(current_xattr->name);
-            free(current_xattr);
             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());
-            free(current_xattr->name);
-            free(current_xattr);
             goto bail_out;
          }
          break;
@@ -470,18 +469,12 @@ static bxattr_exit_code aix_xattr_build_streams(JCR *jcr, FF_PKT *ff_pkt)
             case EFORMAT:
             case ENOTSUP:
                retval = bxattr_exit_ok;
-               free(current_xattr->value);
-               free(current_xattr->name);
-               free(current_xattr);
                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());
-               free(current_xattr->value);
-               free(current_xattr->name);
-               free(current_xattr);
                goto bail_out;
             }
          }
@@ -497,14 +490,16 @@ static bxattr_exit_code aix_xattr_build_streams(JCR *jcr, FF_PKT *ff_pkt)
          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;
          }
       }
 
+      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;
@@ -528,19 +523,24 @@ static bxattr_exit_code aix_xattr_build_streams(JCR *jcr, FF_PKT *ff_pkt)
          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]);
+      retval = send_xattr_stream(jcr, os_default_xattr_streams[0]);
    } else {
-      xattr_drop_internal_table(xattr_value_list);
-
-      return bxattr_exit_ok;
+      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);
    }
@@ -594,6 +594,296 @@ bail_out:
 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 <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)
 
@@ -652,10 +942,11 @@ 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;
+   xattr_t *current_xattr = NULL;
    alist *xattr_value_list = NULL;
    bxattr_exit_code retval = bxattr_exit_error;
    berrno be;
@@ -714,15 +1005,12 @@ static bxattr_exit_code generic_xattr_build_streams(JCR *jcr, FF_PKT *ff_pkt)
    }
    xattr_list[xattr_list_len] = '\0';
 
-   xattr_value_list = New(alist(10, not_owned_by_alist));
-
    /*
     * 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) {
-      int name_len;
       skip_xattr = false;
 
       /*
@@ -751,8 +1039,9 @@ static bxattr_exit_code generic_xattr_build_streams(JCR *jcr, FF_PKT *ff_pkt)
          }
       }
 
-      name_len = strlen(bp);
-      if (skip_xattr || name_len == 0) {
+      name_length = strlen(bp);
+      if (skip_xattr || name_length == 0) {
+         Dmsg1(100, "Skipping xattr named %s\n", bp);
          bp = strchr(bp, '\0') + 1;
          continue;
       }
@@ -767,7 +1056,7 @@ static bxattr_exit_code generic_xattr_build_streams(JCR *jcr, FF_PKT *ff_pkt)
       /*
        * Allocate space for storing the name.
        */
-      current_xattr->name_length = name_len;
+      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);
 
@@ -783,16 +1072,12 @@ static bxattr_exit_code generic_xattr_build_streams(JCR *jcr, FF_PKT *ff_pkt)
          case ENOENT:
          case ENOTSUP:
             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;
@@ -814,18 +1099,12 @@ static bxattr_exit_code generic_xattr_build_streams(JCR *jcr, FF_PKT *ff_pkt)
             case ENOENT:
             case ENOTSUP:
                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;
             }
          }
@@ -841,14 +1120,16 @@ static bxattr_exit_code generic_xattr_build_streams(JCR *jcr, FF_PKT *ff_pkt)
          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;
          }
       }
 
+      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;
@@ -872,19 +1153,24 @@ static bxattr_exit_code generic_xattr_build_streams(JCR *jcr, FF_PKT *ff_pkt)
          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]);
+      retval = send_xattr_stream(jcr, os_default_xattr_streams[0]);
    } else {
-      xattr_drop_internal_table(xattr_value_list);
-
-      return bxattr_exit_ok;
+      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);
    }
@@ -998,13 +1284,11 @@ static bxattr_exit_code bsd_build_xattr_streams(JCR *jcr, FF_PKT *ff_pkt)
    int attrnamespace;
    char *current_attrnamespace = NULL;
    char current_attrname[XATTR_BUFSIZ], current_attrtuple[XATTR_BUFSIZ];
-   xattr_t *current_xattr;
+   xattr_t *current_xattr = NULL;
    alist *xattr_value_list = NULL;
    bxattr_exit_code retval = bxattr_exit_error;
    berrno be;
 
-   xattr_value_list = New(alist(10, not_owned_by_alist));
-
    /*
     * Loop over all available xattr namespaces.
     */
@@ -1143,6 +1427,7 @@ static bxattr_exit_code bsd_build_xattr_streams(JCR *jcr, FF_PKT *ff_pkt)
          }
 
          if (skip_xattr) {
+            Dmsg1(100, "Skipping xattr named %s\n", current_attrname);
             continue;
          }
 
@@ -1171,16 +1456,12 @@ static bxattr_exit_code bsd_build_xattr_streams(JCR *jcr, FF_PKT *ff_pkt)
             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;
@@ -1201,18 +1482,12 @@ static bxattr_exit_code bsd_build_xattr_streams(JCR *jcr, FF_PKT *ff_pkt)
                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;
                }
             }
@@ -1229,15 +1504,17 @@ static bxattr_exit_code bsd_build_xattr_streams(JCR *jcr, FF_PKT *ff_pkt)
             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;
          }
 
+         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++;
 
       }
@@ -1270,22 +1547,27 @@ static bxattr_exit_code bsd_build_xattr_streams(JCR *jcr, FF_PKT *ff_pkt)
          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]);
+      retval = send_xattr_stream(jcr, os_default_xattr_streams[0]);
    } else {
-      xattr_drop_internal_table(xattr_value_list);
-
-      return bxattr_exit_ok;
+      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);
    }
@@ -1371,6 +1653,324 @@ bail_out:
 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 <sys/proplist.h>
+#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;
+   }
+
+   /*
+    * Walk the list of extended attributes names and retrieve the data.
+    * We already count the bytes needed for serializing the stream later on.
+    */
+   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 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(xattr_name, 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(xattr_name, xattr_skiplist[cnt])) {
+               skip_xattr = true;
+               break;
+            }
+         }
+      }
+
+      if (skip_xattr) {
+         Dmsg1(100, "Skipping xattr named %s\n", xattr_name);
+         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);
+
+      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;
+
+      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);
+
+      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++;
+   }
+
+   /*
+    * 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]);
+   }
+
+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_value_list != NULL) {
+      xattr_drop_internal_table(xattr_value_list);
+   }
+   free_pool_memory(xattrbuf);
+
+   return retval;
+}
+
+static bxattr_exit_code tru64_parse_xattr_streams(JCR *jcr, int stream)
+{
+   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;
+   }
+
+   /*
+    * See how big the propertylist must be.
+    */
+   xattrbuf_size = 0;
+   foreach_alist(current_xattr, xattr_value_list) {
+      xattrbuf_size += sizeof_proplist_entry(current_xattr->name, current_xattr->value_length);
+   }
+
+   xattrbuf = (char *)malloc(xattrbuf_size);
+
+   /*
+    * 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);
+   }
+
+   /*
+    * 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;
+   }
+
+   /*
+    * 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;
+      }
+      break;
+   default:
+      break;
+   }
+
+   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;
+}
+
+/*
+ * 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) = 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)
 /*
  * Solaris extended attributes were introduced in Solaris 9