/*
- Bacula® - The Network Backup Solution
-
- 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 three of the GNU Affero General Public
- License as published by the Free Software Foundation and included
- in the file LICENSE.
-
- This program is distributed in the hope that it will be useful, but
- WITHOUT ANY WARRANTY; without even the implied warranty of
- 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 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 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.
+ Bacula(R) - The Network Backup Solution
+
+ Copyright (C) 2000-2018 Kern Sibbald
+
+ The original author of Bacula is Kern Sibbald, with contributions
+ from many others, a complete list can be found in the file AUTHORS.
+
+ You may use this file and others of this release according to the
+ license defined in the LICENSE file, which includes the Affero General
+ Public License, v3.0 ("AGPLv3") and some additional permissions and
+ terms pursuant to its AGPLv3 Section 7.
+
+ This notice must be preserved when any source code is
+ conveyed and/or propagated.
+
+ Bacula(R) is a registered trademark of Kern Sibbald.
*/
/*
* Bacula low level File I/O routines. This routine simulates
const int dbglvl = 200;
-int (*plugin_bopen)(BFILE *bfd, const char *fname, int flags, mode_t mode) = NULL;
+int (*plugin_bopen)(BFILE *bfd, const char *fname, uint64_t 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;
switch (stream) {
case STREAM_WIN32_DATA:
case STREAM_WIN32_GZIP_DATA:
+ case STREAM_WIN32_COMPRESSED_DATA:
case STREAM_ENCRYPTED_WIN32_DATA:
case STREAM_ENCRYPTED_WIN32_GZIP_DATA:
+ case STREAM_ENCRYPTED_WIN32_COMPRESSED_DATA:
return true;
}
return false;
{
static char buf[20];
- switch (stream) {
- case STREAM_UNIX_ATTRIBUTES:
- return _("Unix attributes");
- case STREAM_FILE_DATA:
- return _("File data");
- case STREAM_MD5_DIGEST:
- return _("MD5 digest");
- case STREAM_GZIP_DATA:
- return _("GZIP data");
- case STREAM_UNIX_ATTRIBUTES_EX:
- return _("Extended attributes");
- case STREAM_SPARSE_DATA:
- return _("Sparse data");
- case STREAM_SPARSE_GZIP_DATA:
- return _("GZIP sparse data");
- case STREAM_PROGRAM_NAMES:
- return _("Program names");
- case STREAM_PROGRAM_DATA:
- return _("Program data");
- case STREAM_SHA1_DIGEST:
- return _("SHA1 digest");
- case STREAM_WIN32_DATA:
- return _("Win32 data");
- case STREAM_WIN32_GZIP_DATA:
- return _("Win32 GZIP data");
- case STREAM_MACOS_FORK_DATA:
- return _("MacOS Fork data");
- case STREAM_HFSPLUS_ATTRIBUTES:
- return _("HFS+ attribs");
- case STREAM_UNIX_ACCESS_ACL:
- return _("Standard Unix ACL attribs");
- case STREAM_UNIX_DEFAULT_ACL:
- return _("Default Unix ACL attribs");
- case STREAM_SHA256_DIGEST:
- return _("SHA256 digest");
- case STREAM_SHA512_DIGEST:
- return _("SHA512 digest");
- case STREAM_SIGNED_DIGEST:
- return _("Signed digest");
- case STREAM_ENCRYPTED_FILE_DATA:
- return _("Encrypted File data");
- case STREAM_ENCRYPTED_WIN32_DATA:
- return _("Encrypted Win32 data");
- case STREAM_ENCRYPTED_SESSION_DATA:
- return _("Encrypted session data");
- case STREAM_ENCRYPTED_FILE_GZIP_DATA:
- return _("Encrypted GZIP data");
- case STREAM_ENCRYPTED_WIN32_GZIP_DATA:
- 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;
- }
+ switch (stream & STREAMMASK_TYPE) {
+ case STREAM_UNIX_ATTRIBUTES:
+ return _("Unix attributes");
+ case STREAM_FILE_DATA:
+ return _("File data");
+ case STREAM_MD5_DIGEST:
+ return _("MD5 digest");
+ case STREAM_GZIP_DATA:
+ return _("GZIP data");
+ case STREAM_COMPRESSED_DATA:
+ return _("Compressed data");
+ case STREAM_UNIX_ATTRIBUTES_EX:
+ return _("Extended attributes");
+ case STREAM_SPARSE_DATA:
+ return _("Sparse data");
+ case STREAM_SPARSE_GZIP_DATA:
+ return _("GZIP sparse data");
+ case STREAM_SPARSE_COMPRESSED_DATA:
+ return _("Compressed sparse data");
+ case STREAM_PROGRAM_NAMES:
+ return _("Program names");
+ case STREAM_PROGRAM_DATA:
+ return _("Program data");
+ case STREAM_SHA1_DIGEST:
+ return _("SHA1 digest");
+ case STREAM_WIN32_DATA:
+ return _("Win32 data");
+ case STREAM_WIN32_GZIP_DATA:
+ return _("Win32 GZIP data");
+ case STREAM_WIN32_COMPRESSED_DATA:
+ return _("Win32 compressed data");
+ case STREAM_MACOS_FORK_DATA:
+ return _("MacOS Fork data");
+ case STREAM_HFSPLUS_ATTRIBUTES:
+ return _("HFS+ attribs");
+ case STREAM_UNIX_ACCESS_ACL:
+ return _("Standard Unix ACL attribs");
+ case STREAM_UNIX_DEFAULT_ACL:
+ return _("Default Unix ACL attribs");
+ case STREAM_SHA256_DIGEST:
+ return _("SHA256 digest");
+ case STREAM_SHA512_DIGEST:
+ return _("SHA512 digest");
+ case STREAM_SIGNED_DIGEST:
+ return _("Signed digest");
+ case STREAM_ENCRYPTED_FILE_DATA:
+ return _("Encrypted File data");
+ case STREAM_ENCRYPTED_WIN32_DATA:
+ return _("Encrypted Win32 data");
+ case STREAM_ENCRYPTED_SESSION_DATA:
+ return _("Encrypted session data");
+ case STREAM_ENCRYPTED_FILE_GZIP_DATA:
+ return _("Encrypted GZIP data");
+ case STREAM_ENCRYPTED_FILE_COMPRESSED_DATA:
+ return _("Encrypted compressed data");
+ case STREAM_ENCRYPTED_WIN32_GZIP_DATA:
+ return _("Encrypted Win32 GZIP data");
+ case STREAM_ENCRYPTED_WIN32_COMPRESSED_DATA:
+ return _("Encrypted Win32 Compressed data");
+ case STREAM_ENCRYPTED_MACOS_FORK_DATA:
+ return _("Encrypted MacOS fork data");
+ case STREAM_PLUGIN_NAME:
+ return _("Plugin Name");
+ case STREAM_PLUGIN_DATA:
+ return _("Plugin Data");
+ case STREAM_RESTORE_OBJECT:
+ return _("Restore Object");
+ case STREAM_XACL_AIX_TEXT:
+ return _("AIX ACL attribs");
+ case STREAM_XACL_DARWIN_ACCESS:
+ return _("Darwin ACL attribs");
+ case STREAM_XACL_FREEBSD_DEFAULT:
+ return _("FreeBSD Default ACL attribs");
+ case STREAM_XACL_FREEBSD_ACCESS:
+ return _("FreeBSD Access ACL attribs");
+ case STREAM_XACL_HPUX_ACL_ENTRY:
+ return _("HPUX ACL attribs");
+ case STREAM_XACL_IRIX_DEFAULT:
+ return _("Irix Default ACL attribs");
+ case STREAM_XACL_IRIX_ACCESS:
+ return _("Irix Access ACL attribs");
+ case STREAM_XACL_LINUX_DEFAULT:
+ return _("Linux Default ACL attribs");
+ case STREAM_XACL_LINUX_ACCESS:
+ return _("Linux Access ACL attribs");
+ case STREAM_XACL_TRU64_DEFAULT:
+ return _("TRU64 Default ACL attribs");
+ case STREAM_XACL_TRU64_ACCESS:
+ return _("TRU64 Access ACL attribs");
+ case STREAM_XACL_SOLARIS_POSIX:
+ return _("Solaris POSIX ACL attribs");
+ case STREAM_XACL_SOLARIS_NFS4:
+ return _("Solaris NFSv4/ZFS ACL attribs");
+ case STREAM_XACL_AFS_TEXT:
+ return _("AFS ACL attribs");
+ case STREAM_XACL_AIX_AIXC:
+ return _("AIX POSIX ACL attribs");
+ case STREAM_XACL_AIX_NFS4:
+ return _("AIX NFSv4 ACL attribs");
+ case STREAM_XACL_FREEBSD_NFS4:
+ return _("FreeBSD NFSv4/ZFS ACL attribs");
+ case STREAM_XACL_HURD_DEFAULT:
+ return _("GNU Hurd Default ACL attribs");
+ case STREAM_XACL_HURD_ACCESS:
+ return _("GNU Hurd Access ACL attribs");
+ case STREAM_XACL_HURD_XATTR:
+ return _("GNU Hurd Extended attribs");
+ case STREAM_XACL_IRIX_XATTR:
+ return _("IRIX Extended attribs");
+ case STREAM_XACL_TRU64_XATTR:
+ return _("TRU64 Extended attribs");
+ case STREAM_XACL_AIX_XATTR:
+ return _("AIX Extended attribs");
+ case STREAM_XACL_OPENBSD_XATTR:
+ return _("OpenBSD Extended attribs");
+ case STREAM_XACL_SOLARIS_SYS_XATTR:
+ return _("Solaris Extensible attribs or System Extended attribs");
+ case STREAM_XACL_SOLARIS_XATTR:
+ return _("Solaris Extended attribs");
+ case STREAM_XACL_DARWIN_XATTR:
+ return _("Darwin Extended attribs");
+ case STREAM_XACL_FREEBSD_XATTR:
+ return _("FreeBSD Extended attribs");
+ case STREAM_XACL_LINUX_XATTR:
+ return _("Linux Extended attribs");
+ case STREAM_XACL_NETBSD_XATTR:
+ return _("NetBSD 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)
rv[i] = pv[7 - i];
}
memcpy(pBE, &rv, sizeof(int64_t));
- }
+ }
}
/**
rv[i] = pv[3 - i];
}
memcpy(pBE, &rv, sizeof(int32_t));
- }
+ }
}
*/
bool processWin32BackupAPIBlock (BFILE *bfd, void *pBuffer, ssize_t dwSize)
{
- /* pByte contains the buffer
- dwSize the len to be processed. function assumes to be
- called in successive incremental order over the complete
- BackupRead stream beginning at pos 0 and ending at the end.
- */
-
- PROCESS_WIN32_BACKUPAPIBLOCK_CONTEXT* pContext = &(bfd->win32DecompContext);
- bool bContinue = false;
- int64_t dwDataOffset = 0;
- int64_t dwDataLen;
-
- /* Win32 Stream Header size without name of stream.
- * = sizeof (WIN32_STREAM_ID)- sizeof(WCHAR*);
- */
- int32_t dwSizeHeader = 20;
-
- do {
- if (pContext->liNextHeader >= dwSize) {
- dwDataLen = dwSize-dwDataOffset;
- bContinue = false; /* 1 iteration is enough */
- } else {
- dwDataLen = pContext->liNextHeader-dwDataOffset;
- bContinue = true; /* multiple iterations may be necessary */
- }
-
- /* flush */
- /* copy block of real DATA */
- if (pContext->bIsInData) {
- if (bwrite(bfd, ((char *)pBuffer)+dwDataOffset, dwDataLen) != (ssize_t)dwDataLen)
- return false;
- }
-
- if (pContext->liNextHeader < dwSize) {/* is a header in this block ? */
- int32_t dwOffsetTarget;
- int32_t dwOffsetSource;
-
- if (pContext->liNextHeader < 0) {
- /* start of header was before this block, so we
- * continue with the part in the current block
- */
- dwOffsetTarget = -pContext->liNextHeader;
- dwOffsetSource = 0;
- } else {
- /* start of header is inside of this block */
- dwOffsetTarget = 0;
- dwOffsetSource = pContext->liNextHeader;
- }
-
- int32_t dwHeaderPartLen = dwSizeHeader-dwOffsetTarget;
- bool bHeaderIsComplete;
-
- if (dwHeaderPartLen <= dwSize-dwOffsetSource) {
- /* header (or rest of header) is completely available
- in current block
- */
- bHeaderIsComplete = true;
- } else {
- /* header will continue in next block */
- bHeaderIsComplete = false;
- dwHeaderPartLen = dwSize-dwOffsetSource;
- }
+ int64_t len = dwSize;
+ char *dat=(char *)pBuffer;
+ int64_t use_len;
- /* copy the available portion of header to persistent copy */
- memcpy(((char *)&pContext->header_stream)+dwOffsetTarget, ((char *)pBuffer)+dwOffsetSource, dwHeaderPartLen);
-
- /* recalculate position of next header */
- if (bHeaderIsComplete) {
- /* convert stream name size (32 bit little endian) to machine type */
- int32_t dwNameSize;
- int32_LE2BE (&dwNameSize, pContext->header_stream.dwStreamNameSize);
- dwDataOffset = dwNameSize+pContext->liNextHeader+dwSizeHeader;
-
- /* convert stream size (64 bit little endian) to machine type */
- int64_LE2BE (&(pContext->liNextHeader), pContext->header_stream.Size);
- pContext->liNextHeader += dwDataOffset;
-
- pContext->bIsInData = pContext->header_stream.dwStreamId == WIN32_BACKUP_DATA;
- if (dwDataOffset == dwSize)
- bContinue = false;
- } else {
- /* stop and continue with next block */
- bContinue = false;
- pContext->bIsInData = false;
- }
+ while (len>0 && bfd->win32filter.have_data(&dat, &len, &use_len)) {
+ if (bwrite(bfd, dat, use_len) != (ssize_t)use_len) {
+ return false;
}
- } while (bContinue);
-
- /* set "NextHeader" relative to the beginning of the next block */
- pContext->liNextHeader-= dwSize;
-
- return TRUE;
+ dat+=use_len;
+ }
+ return true;
}
-
-
/* ===============================================================
*
* W I N D O W S
#if defined(HAVE_WIN32)
-void unix_name_to_win32(POOLMEM **win32_name, char *name);
+void unix_name_to_win32(POOLMEM **win32_name, const char *name);
extern "C" HANDLE get_osfhandle(int fd);
return bfd->use_backup_api;
}
+void set_fattrs(BFILE *bfd, struct stat *statp)
+{
+ bfd->fattrs = statp->st_fattrs;
+ Dmsg1(200, "set_fattrs 0x%x\n", bfd->fattrs);
+}
bool set_portable_backup(BFILE *bfd)
{
case STREAM_GZIP_DATA:
case STREAM_SPARSE_GZIP_DATA:
case STREAM_WIN32_GZIP_DATA:
+#endif
+#ifndef HAVE_LZO
+ case STREAM_COMPRESSED_DATA:
+ case STREAM_SPARSE_COMPRESSED_DATA:
+ case STREAM_WIN32_COMPRESSED_DATA:
+ case STREAM_ENCRYPTED_FILE_COMPRESSED_DATA:
+ case STREAM_ENCRYPTED_WIN32_COMPRESSED_DATA:
#endif
case STREAM_MACOS_FORK_DATA:
case STREAM_HFSPLUS_ATTRIBUTES:
case STREAM_GZIP_DATA:
case STREAM_SPARSE_GZIP_DATA:
case STREAM_WIN32_GZIP_DATA:
+#endif
+#ifdef HAVE_LZO
+ case STREAM_COMPRESSED_DATA:
+ case STREAM_SPARSE_COMPRESSED_DATA:
+ case STREAM_WIN32_COMPRESSED_DATA:
#endif
case STREAM_WIN32_DATA:
case STREAM_UNIX_ATTRIBUTES:
case STREAM_ENCRYPTED_FILE_GZIP_DATA:
case STREAM_ENCRYPTED_WIN32_DATA:
case STREAM_ENCRYPTED_WIN32_GZIP_DATA:
+#ifdef HAVE_LZO
+ case STREAM_ENCRYPTED_FILE_COMPRESSED_DATA:
+ case STREAM_ENCRYPTED_WIN32_COMPRESSED_DATA:
#endif
+#endif /* !HAVE_CRYPTO */
case 0: /* compatibility with old tapes */
return true;
}
return bfd->fh;
}
-int bopen(BFILE *bfd, const char *fname, int flags, mode_t mode)
+/*
+ * The following code was contributed by Graham Keeling from his
+ * burp project. August 2014
+ */
+static int encrypt_bopen(BFILE *bfd, const char *fname, uint64_t flags, mode_t mode)
+{
+ ULONG ulFlags = 0;
+ POOLMEM *win32_fname;
+ POOLMEM *win32_fname_wchar;
+
+ bfd->mode = BF_CLOSED;
+ bfd->fid = -1;
+
+ if (!(p_OpenEncryptedFileRawA || p_OpenEncryptedFileRawW)) {
+ Dmsg0(50, "No OpenEncryptedFileRawA and no OpenEncryptedFileRawW APIs!!!\n");
+ return -1;
+ }
+
+ /* Convert to Windows path format */
+ win32_fname = get_pool_memory(PM_FNAME);
+ win32_fname_wchar = get_pool_memory(PM_FNAME);
+
+ unix_name_to_win32(&win32_fname, (char *)fname);
+
+ if (p_CreateFileW && p_MultiByteToWideChar) {
+ make_win32_path_UTF8_2_wchar(&win32_fname_wchar, fname);
+ }
+
+ if ((flags & O_CREAT) || (flags & O_WRONLY)) {
+ ulFlags = CREATE_FOR_IMPORT | OVERWRITE_HIDDEN;
+ if (bfd->fattrs & FILE_ATTRIBUTE_DIRECTORY) {
+ mkdir(fname, 0777);
+ ulFlags |= CREATE_FOR_DIR;
+ }
+ bfd->mode = BF_WRITE;
+ Dmsg0(200, "encrypt_bopen for write.\n");
+ } else {
+ /* Open existing for read */
+ ulFlags = CREATE_FOR_EXPORT;
+ bfd->mode = BF_READ;
+ Dmsg0(200, "encrypt_bopen for read.\n");
+ }
+
+ if (p_OpenEncryptedFileRawW && p_MultiByteToWideChar) {
+ /* unicode open */
+ if (p_OpenEncryptedFileRawW((LPCWSTR)win32_fname_wchar,
+ ulFlags, &(bfd->pvContext))) {
+ bfd->mode = BF_CLOSED;
+ errno = b_errno_win32;
+ bfd->berrno = b_errno_win32;
+ }
+ } else {
+ /* ascii open */
+ if (p_OpenEncryptedFileRawA(win32_fname, ulFlags, &(bfd->pvContext))) {
+ bfd->mode = BF_CLOSED;
+ errno = b_errno_win32;
+ bfd->berrno = b_errno_win32;
+ }
+ }
+ free_pool_memory(win32_fname_wchar);
+ free_pool_memory(win32_fname);
+ bfd->fid = (bfd->mode == BF_CLOSED) ? -1 : 0;
+ return bfd->mode==BF_CLOSED ? -1: 1;
+}
+
+static int encrypt_bclose(BFILE *bfd)
+{
+ Dmsg0(200, "encrypt_bclose\n");
+ if (p_CloseEncryptedFileRaw) {
+ p_CloseEncryptedFileRaw(bfd->pvContext);
+ }
+ bfd->pvContext = NULL;
+ bfd->mode = BF_CLOSED;
+ bfd->fattrs = 0;
+ bfd->fid = -1;
+ return 0;
+}
+
+/* Windows */
+int bopen(BFILE *bfd, const char *fname, uint64_t flags, mode_t mode)
{
POOLMEM *win32_fname;
POOLMEM *win32_fname_wchar;
DWORD dwaccess, dwflags, dwshare;
+ if (bfd->fattrs & FILE_ATTRIBUTE_ENCRYPTED) {
+ return encrypt_bopen(bfd, fname, flags, mode);
+ }
+
/* Convert to Windows path format */
win32_fname = get_pool_memory(PM_FNAME);
win32_fname_wchar = get_pool_memory(PM_FNAME);
-
+
unix_name_to_win32(&win32_fname, (char *)fname);
if (bfd->cmd_plugin && plugin_bopen) {
Dmsg1(50, "plugin_open for read OK file=%s.\n", fname);
bfd->mode = BF_READ;
}
+ bfd->fid = -1; /* The file descriptor is invalid */
} else {
bfd->mode = BF_CLOSED;
+ bfd->fid = -1;
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");
+ Dmsg0(100, "=== NO plugin\n");
if (!(p_CreateFileA || p_CreateFileW)) {
Dmsg0(50, "No CreateFileA and no CreateFileW!!!!!\n");
dwflags = 0;
}
- if (p_CreateFileW && p_MultiByteToWideChar) {
+ if (p_CreateFileW && p_MultiByteToWideChar) {
// unicode open for create write
- Dmsg1(100, "Create CreateFileW=%s\n", win32_fname);
+ Dmsg1(100, "Create CreateFileW=%ls\n", win32_fname_wchar);
bfd->fh = p_CreateFileW((LPCWSTR)win32_fname_wchar,
dwaccess, /* Requested access */
0, /* Shared mode */
} else if (flags & O_WRONLY) { /* Open existing for write */
if (bfd->use_backup_api) {
- dwaccess = GENERIC_WRITE|WRITE_OWNER|WRITE_DAC;
- dwflags = FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT;
+ dwaccess = GENERIC_READ|GENERIC_WRITE|WRITE_OWNER|WRITE_DAC;
+ /* If deduped we do not want to open the reparse point */
+ if (bfd->fattrs & FILE_ATTRIBUTE_DEDUP) {
+ dwflags = FILE_FLAG_BACKUP_SEMANTICS;
+ } else {
+ dwflags = FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT;
+ }
} else {
- dwaccess = GENERIC_WRITE;
+ dwaccess = GENERIC_READ|GENERIC_WRITE;
dwflags = 0;
}
- if (p_CreateFileW && p_MultiByteToWideChar) {
+ 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,
dwshare = FILE_SHARE_READ|FILE_SHARE_WRITE;
}
- if (p_CreateFileW && p_MultiByteToWideChar) {
+ if (p_CreateFileW && p_MultiByteToWideChar) {
// unicode open for open existing read
- Dmsg1(100, "Read CreateFileW=%s\n", win32_fname);
+ Dmsg1(100, "Read CreateFileW=%ls\n", win32_fname_wchar);
bfd->fh = p_CreateFileW((LPCWSTR)win32_fname_wchar,
dwaccess, /* Requested access */
dwshare, /* Share modes */
dwflags, /* Flags and attributes */
NULL); /* TemplateFile */
} else {
- // ascii open
+ // ascii open
Dmsg1(100, "Read CreateFileA=%s\n", win32_fname);
bfd->fh = p_CreateFileA(win32_fname,
dwaccess, /* Requested access */
}
if (bfd->fh == INVALID_HANDLE_VALUE) {
+ berrno be;
bfd->lerror = GetLastError();
bfd->berrno = b_errno_win32;
errno = b_errno_win32;
bfd->mode = BF_CLOSED;
+ Dmsg1(100, "Open failed: %s\n", be.bstrerror());
}
+ bfd->block = 0;
+ bfd->total_bytes = 0;
bfd->errmsg = NULL;
bfd->lpContext = NULL;
- bfd->win32DecompContext.bIsInData = false;
- bfd->win32DecompContext.liNextHeader = 0;
+ bfd->win32filter.init();
free_pool_memory(win32_fname_wchar);
free_pool_memory(win32_fname);
+ bfd->fid = (bfd->mode == BF_CLOSED) ? -1 : 0;
return bfd->mode == BF_CLOSED ? -1 : 1;
}
* Returns 0 on success
* -1 on error
*/
+/* Windows */
int bclose(BFILE *bfd)
{
int stat = 0;
goto all_done;
}
+ if (bfd->fattrs & FILE_ATTRIBUTE_ENCRYPTED) {
+ return encrypt_bclose(bfd);
+ }
+
/*
* We need to tell the API to release the buffer it
* allocated in lpContext. We do so by calling the
bfd->errmsg = NULL;
}
bfd->mode = BF_CLOSED;
+ bfd->fattrs = 0;
+ bfd->fid = -1;
bfd->lpContext = NULL;
bfd->cmd_plugin = false;
return stat;
* 0 on EOF
* -1 on error
*/
+/* Windows */
ssize_t bread(BFILE *bfd, void *buf, size_t count)
{
bfd->rw_bytes = 0;
0, /* no Abort */
1, /* Process Security */
&bfd->lpContext)) { /* Context */
+ berrno be;
bfd->lerror = GetLastError();
bfd->berrno = b_errno_win32;
errno = b_errno_win32;
+ Dmsg1(100, "Read failed: %s\n", be.bstrerror());
return -1;
}
} else {
return -1;
}
}
-
+ bfd->block++;
+ if (bfd->rw_bytes > 0) {
+ bfd->total_bytes += bfd->rw_bytes;
+ }
return (ssize_t)bfd->rw_bytes;
}
+/* Windows */
ssize_t bwrite(BFILE *bfd, void *buf, size_t count)
{
bfd->rw_bytes = 0;
0, /* No abort */
1, /* Process Security */
&bfd->lpContext)) { /* Context */
+ berrno be;
bfd->lerror = GetLastError();
bfd->berrno = b_errno_win32;
errno = b_errno_win32;
+ Dmsg1(100, "Write failed: %s\n", be.bstrerror());
return -1;
}
} else {
return -1;
}
}
+ bfd->block++;
+ if (bfd->rw_bytes > 0) {
+ bfd->total_bytes += bfd->rw_bytes;
+ }
return (ssize_t)bfd->rw_bytes;
}
+/* Windows */
bool is_bopen(BFILE *bfd)
{
return bfd->mode != BF_CLOSED;
}
+/* Windows */
boffset_t blseek(BFILE *bfd, boffset_t offset, int whence)
{
LONG offset_low = (LONG)offset;
*
* ===============================================================
*/
+/* Unix */
void binit(BFILE *bfd)
{
memset(bfd, 0, sizeof(BFILE));
bfd->fid = -1;
}
+/* Unix */
bool have_win32_api()
{
return false; /* no can do */
* Returns true if function worked
* Returns false if failed (i.e. do not have Backup API on this machine)
*/
+/* Unix */
bool set_win32_backup(BFILE *bfd)
{
return false; /* no can do */
}
+/* Unix */
bool set_portable_backup(BFILE *bfd)
{
return true; /* no problem */
* Return true if we are writing in portable format
* return false if not
*/
+/* Unix */
bool is_portable_backup(BFILE *bfd)
{
return true; /* portable by definition */
}
+/* Unix */
bool set_prog(BFILE *bfd, char *prog, JCR *jcr)
{
return false;
}
+/* Unix */
bool set_cmd_plugin(BFILE *bfd, JCR *jcr)
{
bfd->cmd_plugin = true;
return true;
}
-/*
- * This code is running on a non-Win32 machine
+/*
+ * This code is running on a non-Win32 machine
*/
+/* Unix */
bool is_restore_stream_supported(int stream)
{
/* No Win32 backup on this machine */
#ifndef HAVE_LIBZ
case STREAM_GZIP_DATA:
case STREAM_SPARSE_GZIP_DATA:
- case STREAM_WIN32_GZIP_DATA:
+ case STREAM_WIN32_GZIP_DATA:
+#endif
+#ifndef HAVE_LZO
+ case STREAM_COMPRESSED_DATA:
+ case STREAM_SPARSE_COMPRESSED_DATA:
+ case STREAM_WIN32_COMPRESSED_DATA:
+ case STREAM_ENCRYPTED_FILE_COMPRESSED_DATA:
+ case STREAM_ENCRYPTED_WIN32_COMPRESSED_DATA:
#endif
#ifndef HAVE_DARWIN_OS
case STREAM_MACOS_FORK_DATA:
#ifdef HAVE_LIBZ
case STREAM_GZIP_DATA:
case STREAM_SPARSE_GZIP_DATA:
- case STREAM_WIN32_GZIP_DATA:
+ case STREAM_WIN32_GZIP_DATA:
+#endif
+#ifdef HAVE_LZO
+ case STREAM_COMPRESSED_DATA:
+ case STREAM_SPARSE_COMPRESSED_DATA:
+ case STREAM_WIN32_COMPRESSED_DATA:
+ case STREAM_ENCRYPTED_FILE_COMPRESSED_DATA:
+ case STREAM_ENCRYPTED_WIN32_COMPRESSED_DATA:
#endif
case STREAM_WIN32_DATA:
case STREAM_UNIX_ATTRIBUTES:
return false;
}
-int bopen(BFILE *bfd, const char *fname, int flags, mode_t mode)
+/* Unix */
+int bopen(BFILE *bfd, const char *fname, uint64_t flags, mode_t mode)
{
if (bfd->cmd_plugin && plugin_bopen) {
- Dmsg1(50, "call plugin_bopen fname=%s\n", fname);
+ Dmsg1(400, "call plugin_bopen fname=%s\n", fname);
bfd->fid = plugin_bopen(bfd, fname, flags, mode);
- Dmsg1(50, "Plugin bopen stat=%d\n", bfd->fid);
+ Dmsg2(400, "Plugin bopen fid=%d file=%s\n", bfd->fid, fname);
return bfd->fid;
}
}
bfd->berrno = errno;
bfd->m_flags = flags;
+ bfd->block = 0;
+ bfd->total_bytes = 0;
Dmsg1(400, "Open file %d\n", bfd->fid);
errno = bfd->berrno;
- bfd->win32DecompContext.bIsInData = false;
- bfd->win32DecompContext.liNextHeader = 0;
+ bfd->win32filter.init();
#if defined(HAVE_POSIX_FADVISE) && defined(POSIX_FADV_WILLNEED)
- if (bfd->fid != -1 && flags & O_RDONLY) {
+ /* If not RDWR or WRONLY must be Read Only */
+ if (bfd->fid != -1 && !(flags & (O_RDWR|O_WRONLY))) {
int stat = posix_fadvise(bfd->fid, 0, 0, POSIX_FADV_WILLNEED);
- Dmsg2(400, "Did posix_fadvise on %s stat=%d\n", fname, stat);
+ Dmsg3(400, "Did posix_fadvise WILLNEED on %s fid=%d stat=%d\n", fname, bfd->fid, stat);
}
#endif
#ifdef HAVE_DARWIN_OS
/* Open the resource fork of a file. */
-int bopen_rsrc(BFILE *bfd, const char *fname, int flags, mode_t mode)
+int bopen_rsrc(BFILE *bfd, const char *fname, uint64_t flags, mode_t mode)
{
POOLMEM *rsrc_fname;
free_pool_memory(rsrc_fname);
return bfd->fid;
}
-#else
-int bopen_rsrc(BFILE *bfd, const char *fname, int flags, mode_t mode)
-{
- return -1;
-}
+#else /* Unix */
+
+/* Unix */
+int bopen_rsrc(BFILE *bfd, const char *fname, uint64_t flags, mode_t mode)
+ { return -1; }
+
#endif
+/* Unix */
int bclose(BFILE *bfd)
{
int stat;
- Dmsg1(400, "Close file %d\n", bfd->fid);
+ Dmsg2(400, "Close bfd=%p file %d\n", bfd, bfd->fid);
+ if (bfd->fid == -1) {
+ return 0;
+ }
if (bfd->cmd_plugin && plugin_bclose) {
stat = plugin_bclose(bfd);
bfd->fid = -1;
bfd->cmd_plugin = false;
}
- if (bfd->fid == -1) {
- return 0;
- }
#if defined(HAVE_POSIX_FADVISE) && defined(POSIX_FADV_DONTNEED)
- if (bfd->m_flags & O_RDONLY) {
+ /* If not RDWR or WRONLY must be Read Only */
+ if (!(bfd->m_flags & (O_RDWR|O_WRONLY))) {
fdatasync(bfd->fid); /* sync the file */
/* Tell OS we don't need it any more */
posix_fadvise(bfd->fid, 0, 0, POSIX_FADV_DONTNEED);
+ Dmsg1(400, "Did posix_fadvise DONTNEED on fid=%d\n", bfd->fid);
}
#endif
return stat;
}
+/* Unix */
ssize_t bread(BFILE *bfd, void *buf, size_t count)
{
ssize_t stat;
stat = read(bfd->fid, buf, count);
bfd->berrno = errno;
+ bfd->block++;
+ if (stat > 0) {
+ bfd->total_bytes += stat;
+ }
return stat;
}
+/* Unix */
ssize_t bwrite(BFILE *bfd, void *buf, size_t count)
{
ssize_t stat;
}
stat = write(bfd->fid, buf, count);
bfd->berrno = errno;
+ bfd->block++;
+ if (stat > 0) {
+ bfd->total_bytes += stat;
+ }
return stat;
}
+/* Unix */
bool is_bopen(BFILE *bfd)
{
return bfd->fid >= 0;
}
+/* Unix */
boffset_t blseek(BFILE *bfd, boffset_t offset, int whence)
{
boffset_t pos;
projects / bacula / bacula / blobdiff