]> git.sur5r.net Git - bacula/bacula/blobdiff - bacula/src/findlib/bfile.c
bat: Add pattern filter and make restore to start from brestore
[bacula/bacula] / bacula / src / findlib / bfile.c
index 1473db59993bc27b5104ac7697631a8d27ac8a61..6d2d797c6ffd625e9ac41ac0c01aad03993e06e6 100644 (file)
@@ -1,12 +1,12 @@
 /*
    Bacula® - The Network Backup Solution
 
-   Copyright (C) 2003-2008 Free Software Foundation Europe e.V.
+   Copyright (C) 2003-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.
 
-   Bacula® is a registered trademark of John Walker.
+   Bacula® is a registered trademark of Kern Sibbald.
    The licensor of Bacula is the Free Software Foundation Europe
    (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
    Switzerland, email:ftf@fsfeurope.org.
  *
  *    Kern Sibbald, April MMIII
  *
- *   Version $Id$
- *
  */
 
 #include "bacula.h"
 #include "find.h"
 
-int     (*plugin_bopen)(JCR *jcr, const char *fname, int flags, mode_t mode) = NULL;
-int     (*plugin_bclose)(JCR *jcr) = NULL;
-ssize_t (*plugin_bread)(JCR *jcr, void *buf, size_t count) = NULL;
-ssize_t (*plugin_bwrite)(JCR *jcr, void *buf, size_t count) = NULL;
-boffset_t (*plugin_blseek)(JCR *jcr, boffset_t offset, int whence) = NULL;
+const int dbglvl = 200;
+
+int       (*plugin_bopen)(BFILE *bfd, const char *fname, int flags, mode_t mode) = NULL;
+int       (*plugin_bclose)(BFILE *bfd) = NULL;
+ssize_t   (*plugin_bread)(BFILE *bfd, void *buf, size_t count) = NULL;
+ssize_t   (*plugin_bwrite)(BFILE *bfd, void *buf, size_t count) = NULL;
+boffset_t (*plugin_blseek)(BFILE *bfd, boffset_t offset, int whence) = NULL;
 
 
 #ifdef HAVE_DARWIN_OS
@@ -54,6 +54,18 @@ boffset_t (*plugin_blseek)(JCR *jcr, boffset_t offset, int whence) = NULL;
 #define fdatasync(fd)
 #endif
 
+#ifdef HAVE_WIN32
+void pause_msg(const char *file, const char *func, int line, const char *msg)
+{
+   char buf[1000];
+   if (msg) {
+      bsnprintf(buf, sizeof(buf), "%s:%s:%d %s", file, func, line, msg);
+   } else {
+      bsnprintf(buf, sizeof(buf), "%s:%s:%d", file, func, line);
+   }
+   MessageBox(NULL, buf, "Pause", MB_OK);
+}
+#endif
 
 /* ===============================================================
  *
@@ -129,49 +141,104 @@ const char *stream_to_ascii(int stream)
       return _("Encrypted Win32 GZIP data");
    case STREAM_ENCRYPTED_MACOS_FORK_DATA:
       return _("Encrypted MacOS fork data");
+   case STREAM_ACL_AIX_TEXT:
+      return _("AIX Specific ACL attribs");
+   case STREAM_ACL_DARWIN_ACCESS_ACL:
+      return _("Darwin Specific ACL attribs");
+   case STREAM_ACL_FREEBSD_DEFAULT_ACL:
+      return _("FreeBSD Specific Default ACL attribs");
+   case STREAM_ACL_FREEBSD_ACCESS_ACL:
+      return _("FreeBSD Specific Access ACL attribs");
+   case STREAM_ACL_HPUX_ACL_ENTRY:
+      return _("HPUX Specific ACL attribs");
+   case STREAM_ACL_IRIX_DEFAULT_ACL:
+      return _("Irix Specific Default ACL attribs");
+   case STREAM_ACL_IRIX_ACCESS_ACL:
+      return _("Irix Specific Access ACL attribs");
+   case STREAM_ACL_LINUX_DEFAULT_ACL:
+      return _("Linux Specific Default ACL attribs");
+   case STREAM_ACL_LINUX_ACCESS_ACL:
+      return _("Linux Specific Access ACL attribs");
+   case STREAM_ACL_TRU64_DEFAULT_ACL:
+      return _("OSF1 Specific Default ACL attribs");
+   case STREAM_ACL_TRU64_ACCESS_ACL:
+      return _("OSF1 Specific Access ACL attribs");
+   case STREAM_ACL_SOLARIS_ACLENT:
+      return _("Solaris Specific ACL attribs");
+   case STREAM_ACL_SOLARIS_ACE:
+      return _("Solaris Specific ACL attribs");
+   case STREAM_ACL_AFS_TEXT:
+      return _("AFS Specific ACL attribs");
+   case STREAM_ACL_AIX_AIXC:
+      return _("AIX Specific ACL attribs");
+   case STREAM_ACL_AIX_NFS4:
+      return _("AIX Specific ACL attribs");
+   case STREAM_XATTR_AIX:
+      return _("AIX Specific Extended attribs");
+   case STREAM_XATTR_OPENBSD:
+      return _("OpenBSD Specific Extended attribs");
+   case STREAM_XATTR_SOLARIS_SYS:
+      return _("Solaris Specific Extensible attribs or System Extended attribs");
+   case STREAM_XATTR_SOLARIS:
+      return _("Solaris Specific Extended attribs");
+   case STREAM_XATTR_DARWIN:
+      return _("Darwin Specific Extended attribs");
+   case STREAM_XATTR_FREEBSD:
+      return _("FreeBSD Specific Extended attribs");
+   case STREAM_XATTR_LINUX:
+      return _("Linux Specific Extended attribs");
+   case STREAM_XATTR_NETBSD:
+      return _("NetBSD Specific Extended attribs");
    default:
       sprintf(buf, "%d", stream);
       return (const char *)buf;
    }
 }
 
-   
+/**   
+ *  Convert a 64 bit little endian to a big endian
+ */
 void int64_LE2BE(int64_t* pBE, const int64_t v)
 {
    /* convert little endian to big endian */
    if (htonl(1) != 1L) { /* no work if on little endian machine */
-           memcpy(pBE, &v, sizeof(int64_t));
+      memcpy(pBE, &v, sizeof(int64_t));
    } else {
-           int i;
-           uint8_t rv[sizeof(int64_t)];
-           uint8_t *pv = (uint8_t *) &v;
-
-           for (i = 0; i < 8; i++) {
-              rv[i] = pv[7 - i];
-           }
-           memcpy(pBE, &rv, sizeof(int64_t));
+      int i;
+      uint8_t rv[sizeof(int64_t)];
+      uint8_t *pv = (uint8_t *) &v;
+
+      for (i = 0; i < 8; i++) {
+         rv[i] = pv[7 - i];
+      }
+      memcpy(pBE, &rv, sizeof(int64_t));
    }    
 }
 
-
+/**
+ *  Convert a 32 bit little endian to a big endian
+ */
 void int32_LE2BE(int32_t* pBE, const int32_t v)
 {
    /* convert little endian to big endian */
    if (htonl(1) != 1L) { /* no work if on little endian machine */
-           memcpy(pBE, &v, sizeof(int32_t));
+      memcpy(pBE, &v, sizeof(int32_t));
    } else {
-           int i;
-           uint8_t rv[sizeof(int32_t)];
-           uint8_t *pv = (uint8_t *) &v;
-
-           for (i = 0; i < 4; i++) {
-              rv[i] = pv[3 - i];
-           }
-           memcpy(pBE, &rv, sizeof(int32_t));
+      int i;
+      uint8_t rv[sizeof(int32_t)];
+      uint8_t *pv = (uint8_t *) &v;
+
+      for (i = 0; i < 4; i++) {
+         rv[i] = pv[3 - i];
+      }
+      memcpy(pBE, &rv, sizeof(int32_t));
    }    
 }
 
 
+/**
+ *  Read a BackupRead block and pull out the file data
+ */
 bool processWin32BackupAPIBlock (BFILE *bfd, void *pBuffer, ssize_t dwSize)
 {
    /* pByte contains the buffer 
@@ -310,11 +377,6 @@ bool set_portable_backup(BFILE *bfd)
    return true;
 }
 
-bool set_prog(BFILE *bfd, char *prog, JCR *jcr)
-{
-   return false;
-}
-
 bool set_cmd_plugin(BFILE *bfd, JCR *jcr)
 {
    bfd->cmd_plugin = true;
@@ -409,11 +471,37 @@ int bopen(BFILE *bfd, const char *fname, int flags, mode_t mode)
    
    unix_name_to_win32(&win32_fname, (char *)fname);
 
-   if (!(p_CreateFileA || p_CreateFileW))
+   if (bfd->cmd_plugin && plugin_bopen) {
+      int rtnstat;
+      Dmsg1(50, "call plugin_bopen fname=%s\n", fname);
+      rtnstat = plugin_bopen(bfd, fname, flags, mode);
+      Dmsg1(50, "return from plugin_bopen status=%d\n", rtnstat);
+      if (rtnstat >= 0) {
+         if (flags & O_CREAT || flags & O_WRONLY) {   /* Open existing for write */
+            Dmsg1(50, "plugin_open for write OK file=%s.\n", fname);
+            bfd->mode = BF_WRITE;
+         } else {
+            Dmsg1(50, "plugin_open for read OK file=%s.\n", fname);
+            bfd->mode = BF_READ;
+         }
+      } else {
+         bfd->mode = BF_CLOSED;
+         Dmsg1(000, "==== plugin_bopen returned bad status=%d\n", rtnstat);
+      }
+      free_pool_memory(win32_fname_wchar);
+      free_pool_memory(win32_fname);
+      return bfd->mode == BF_CLOSED ? -1 : 1;
+   }
+   Dmsg0(50, "=== NO plugin\n");
+
+   if (!(p_CreateFileA || p_CreateFileW)) {
+      Dmsg0(50, "No CreateFileA and no CreateFileW!!!!!\n");
       return 0;
+   }
 
-   if (p_CreateFileW && p_MultiByteToWideChar)
+   if (p_CreateFileW && p_MultiByteToWideChar) {
       make_win32_path_UTF8_2_wchar(&win32_fname_wchar, fname);
+   }
 
    if (flags & O_CREAT) {             /* Create */
       if (bfd->use_backup_api) {
@@ -426,6 +514,7 @@ int bopen(BFILE *bfd, const char *fname, int flags, mode_t mode)
 
       if (p_CreateFileW && p_MultiByteToWideChar) {   
          // unicode open for create write
+         Dmsg1(100, "Create CreateFileW=%s\n", win32_fname);
          bfd->fh = p_CreateFileW((LPCWSTR)win32_fname_wchar,
                 dwaccess,                /* Requested access */
                 0,                       /* Shared mode */
@@ -435,6 +524,7 @@ int bopen(BFILE *bfd, const char *fname, int flags, mode_t mode)
                 NULL);                   /* TemplateFile */
       } else {
          // ascii open
+         Dmsg1(100, "Create CreateFileA=%s\n", win32_fname);
          bfd->fh = p_CreateFileA(win32_fname,
                 dwaccess,                /* Requested access */
                 0,                       /* Shared mode */
@@ -457,6 +547,7 @@ int bopen(BFILE *bfd, const char *fname, int flags, mode_t mode)
 
       if (p_CreateFileW && p_MultiByteToWideChar) {   
          // unicode open for open existing write
+         Dmsg1(100, "Write only CreateFileW=%s\n", win32_fname);
          bfd->fh = p_CreateFileW((LPCWSTR)win32_fname_wchar,
                 dwaccess,                /* Requested access */
                 0,                       /* Shared mode */
@@ -466,6 +557,7 @@ int bopen(BFILE *bfd, const char *fname, int flags, mode_t mode)
                 NULL);                   /* TemplateFile */
       } else {
          // ascii open
+         Dmsg1(100, "Write only CreateFileA=%s\n", win32_fname);
          bfd->fh = p_CreateFileA(win32_fname,
                 dwaccess,                /* Requested access */
                 0,                       /* Shared mode */
@@ -492,6 +584,7 @@ int bopen(BFILE *bfd, const char *fname, int flags, mode_t mode)
 
       if (p_CreateFileW && p_MultiByteToWideChar) {   
          // unicode open for open existing read
+         Dmsg1(100, "Read CreateFileW=%s\n", win32_fname);
          bfd->fh = p_CreateFileW((LPCWSTR)win32_fname_wchar,
                 dwaccess,                /* Requested access */
                 dwshare,                 /* Share modes */
@@ -501,6 +594,7 @@ int bopen(BFILE *bfd, const char *fname, int flags, mode_t mode)
                 NULL);                   /* TemplateFile */
       } else {
          // ascii open 
+         Dmsg1(100, "Read CreateFileA=%s\n", win32_fname);
          bfd->fh = p_CreateFileA(win32_fname,
                 dwaccess,                /* Requested access */
                 dwshare,                 /* Share modes */
@@ -536,16 +630,25 @@ int bclose(BFILE *bfd)
 {
    int stat = 0;
 
-   if (bfd->errmsg) {
-      free_pool_memory(bfd->errmsg);
-      bfd->errmsg = NULL;
-   }
    if (bfd->mode == BF_CLOSED) {
+      Dmsg0(50, "=== BFD already closed.\n");
       return 0;
    }
+
+   if (bfd->cmd_plugin && plugin_bclose) {
+      stat = plugin_bclose(bfd);
+      Dmsg0(50, "==== BFD closed!!!\n");
+      goto all_done;
+   }
+
+   /*
+    * We need to tell the API to release the buffer it
+    *  allocated in lpContext.  We do so by calling the
+    *  API one more time, but with the Abort bit set.
+    */
    if (bfd->use_backup_api && bfd->mode == BF_READ) {
       BYTE buf[10];
-      if (!bfd->lpContext && !p_BackupRead(bfd->fh,
+      if (bfd->lpContext && !p_BackupRead(bfd->fh,
               buf,                    /* buffer */
               (DWORD)0,               /* bytes to read */
               &bfd->rw_bytes,         /* bytes read */
@@ -557,7 +660,7 @@ int bclose(BFILE *bfd)
       }
    } else if (bfd->use_backup_api && bfd->mode == BF_WRITE) {
       BYTE buf[10];
-      if (!bfd->lpContext && !p_BackupWrite(bfd->fh,
+      if (bfd->lpContext && !p_BackupWrite(bfd->fh,
               buf,                    /* buffer */
               (DWORD)0,               /* bytes to read */
               &bfd->rw_bytes,         /* bytes written */
@@ -572,6 +675,12 @@ int bclose(BFILE *bfd)
       stat = -1;
       errno = b_errno_win32;
    }
+
+all_done:
+   if (bfd->errmsg) {
+      free_pool_memory(bfd->errmsg);
+      bfd->errmsg = NULL;
+   }
    bfd->mode = BF_CLOSED;
    bfd->lpContext = NULL;
    bfd->cmd_plugin = false;
@@ -586,6 +695,10 @@ ssize_t bread(BFILE *bfd, void *buf, size_t count)
 {
    bfd->rw_bytes = 0;
 
+   if (bfd->cmd_plugin && plugin_bread) {
+      return plugin_bread(bfd, buf, count);
+   }
+
    if (bfd->use_backup_api) {
       if (!p_BackupRead(bfd->fh,
            (BYTE *)buf,
@@ -619,6 +732,10 @@ ssize_t bwrite(BFILE *bfd, void *buf, size_t count)
 {
    bfd->rw_bytes = 0;
 
+   if (bfd->cmd_plugin && plugin_bwrite) {
+      return plugin_bwrite(bfd, buf, count);
+   }
+
    if (bfd->use_backup_api) {
       if (!p_BackupWrite(bfd->fh,
            (BYTE *)buf,
@@ -658,6 +775,10 @@ boffset_t blseek(BFILE *bfd, boffset_t offset, int whence)
    LONG  offset_high = (LONG)(offset >> 32);
    DWORD dwResult;
 
+   if (bfd->cmd_plugin && plugin_blseek) {
+      return plugin_blseek(bfd, offset, whence);
+   }
+
    dwResult = SetFilePointer(bfd->fh, offset_low, &offset_high, whence);
 
    if (dwResult == INVALID_SET_FILE_POINTER && GetLastError() != NO_ERROR) {
@@ -784,13 +905,18 @@ bool is_restore_stream_supported(int stream)
 int bopen(BFILE *bfd, const char *fname, int flags, mode_t mode)
 {
    if (bfd->cmd_plugin && plugin_bopen) {
-      return plugin_bopen(bfd->jcr, fname, flags, mode);
+      Dmsg1(50, "call plugin_bopen fname=%s\n", fname);
+      bfd->fid = plugin_bopen(bfd, fname, flags, mode);
+      Dmsg1(50, "Plugin bopen stat=%d\n", bfd->fid);
+      return bfd->fid;
    }
 
    /* Normal file open */
-   Dmsg1(400, "open file %s\n", fname);
+   Dmsg1(dbglvl, "open file %s\n", fname);
+
    /* We use fnctl to set O_NOATIME if requested to avoid open error */
    bfd->fid = open(fname, flags & ~O_NOATIME, mode);
+
    /* Set O_NOATIME if possible */
    if (bfd->fid != -1 && flags & O_NOATIME) {
       int oldflags = fcntl(bfd->fid, F_GETFL, 0);
@@ -839,6 +965,11 @@ int bopen_rsrc(BFILE *bfd, const char *fname, int flags, mode_t mode)
    free_pool_memory(rsrc_fname);
    return bfd->fid;
 }
+#else
+int bopen_rsrc(BFILE *bfd, const char *fname, int flags, mode_t mode)
+{
+   return -1;
+}
 #endif
 
 
@@ -849,7 +980,9 @@ int bclose(BFILE *bfd)
    Dmsg1(400, "Close file %d\n", bfd->fid);
 
    if (bfd->cmd_plugin && plugin_bclose) {
-      return plugin_bclose(bfd->jcr);
+      stat = plugin_bclose(bfd);
+      bfd->fid = -1;
+      bfd->cmd_plugin = false;
    }
 
    if (bfd->fid == -1) {
@@ -876,7 +1009,7 @@ ssize_t bread(BFILE *bfd, void *buf, size_t count)
    ssize_t stat;
 
    if (bfd->cmd_plugin && plugin_bread) {
-      return plugin_bread(bfd->jcr, buf, count);
+      return plugin_bread(bfd, buf, count);
    }
 
    stat = read(bfd->fid, buf, count);
@@ -889,7 +1022,7 @@ ssize_t bwrite(BFILE *bfd, void *buf, size_t count)
    ssize_t stat;
 
    if (bfd->cmd_plugin && plugin_bwrite) {
-      return plugin_bwrite(bfd->jcr, buf, count);
+      return plugin_bwrite(bfd, buf, count);
    }
    stat = write(bfd->fid, buf, count);
    bfd->berrno = errno;
@@ -903,14 +1036,14 @@ bool is_bopen(BFILE *bfd)
 
 boffset_t blseek(BFILE *bfd, boffset_t offset, int whence)
 {
-    boffset_t pos;
+   boffset_t pos;
 
    if (bfd->cmd_plugin && plugin_bwrite) {
-      return plugin_blseek(bfd->jcr, offset, whence);
+      return plugin_blseek(bfd, offset, whence);
    }
-    pos = (boffset_t)lseek(bfd->fid, (off_t)offset, whence);
-    bfd->berrno = errno;
-    return pos;
+   pos = (boffset_t)lseek(bfd->fid, offset, whence);
+   bfd->berrno = errno;
+   return pos;
 }
 
 #endif