*
*/
/*
- Copyright (C) 2003-2005 Kern Sibbald
-
- This program is free software; you can redistribute it and/or
- modify it under the terms of the GNU General Public License
- version 2 as amended with additional clauses defined in the
- file LICENSE in the main source directory.
-
- 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
- the file LICENSE for additional details.
-
- */
+ Bacula® - The Network Backup Solution
+
+ Copyright (C) 2003-2006 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
+ License as published by the Free Software Foundation plus additions
+ that are listed 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 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.
+ The licensor of Bacula is the Free Software Foundation Europe
+ (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
+ Switzerland, email:ftf@fsfeurope.org.
+*/
#include "bacula.h"
#include "find.h"
switch (stream) {
case STREAM_WIN32_DATA:
case STREAM_WIN32_GZIP_DATA:
+ case STREAM_ENCRYPTED_WIN32_DATA:
+ case STREAM_ENCRYPTED_WIN32_GZIP_DATA:
return true;
}
return false;
return _("File attributes");
case STREAM_FILE_DATA:
return _("File data");
- case STREAM_MD5_SIGNATURE:
- return _("MD5 signature");
+ case STREAM_MD5_DIGEST:
+ return _("MD5 digest");
case STREAM_UNIX_ATTRIBUTES_EX:
return _("Extended attributes");
case STREAM_SPARSE_DATA:
return _("Program names");
case STREAM_PROGRAM_DATA:
return _("Program data");
- case STREAM_SHA1_SIGNATURE:
- return _("SHA1 signature");
+ case STREAM_SHA1_DIGEST:
+ return _("SHA1 digest");
case STREAM_MACOS_FORK_DATA:
return _("HFS+ resource fork");
case STREAM_HFSPLUS_ATTRIBUTES:
return _("HFS+ Finder Info");
+ 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_FILE_GZIP_DATA:
+ return _("Encrypted GZIP data");
+ case STREAM_ENCRYPTED_WIN32_DATA:
+ return _("Encrypted Win32 data");
+ case STREAM_ENCRYPTED_WIN32_GZIP_DATA:
+ return _("Encrypted Win32 GZIP data");
+ case STREAM_ENCRYPTED_MACOS_FORK_DATA:
+ return _("Encrypted HFS+ resource fork");
default:
sprintf(buf, "%d", stream);
return (const char *)buf;
}
}
-#ifdef USE_WIN32STREAMEXTRACTION
-BOOL processWin32BackupAPIBlock (BFILE *bfd, void *pBuffer, size_t dwSize)
-{
+
+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));
+ } 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));
+ }
+}
+
+
+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));
+ } 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));
+ }
+}
+
+
+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. */
+ 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;
- LONGLONG dwDataOffset = 0;
- LONGLONG dwDataLen;
+ bool bContinue = false;
+ int64_t dwDataOffset = 0;
+ int64_t dwDataLen;
/* Win32 Stream Header size without name of stream.
* = sizeof (WIN32_STREAM_ID)- sizeof(WCHAR*);
*/
- DWORD dwSizeHeader = 20;
+ int32_t dwSizeHeader = 20;
- do {
- if (pContext->liNextHeader >= dwSize) {
+ do {
+ if (pContext->liNextHeader >= dwSize) {
dwDataLen = dwSize-dwDataOffset;
- bContinue = FALSE; /* 1 iteration is enough */
- }
- else {
+ bContinue = false; /* 1 iteration is enough */
+ } else {
dwDataLen = pContext->liNextHeader-dwDataOffset;
- bContinue = TRUE; /* multiple iterations may be necessary */
+ bContinue = true; /* multiple iterations may be necessary */
}
/* flush */
/* copy block of real DATA */
if (pContext->bIsInData) {
- if (bwrite(bfd, ((LPBYTE)pBuffer)+dwDataOffset, dwDataLen) != (ssize_t)dwDataLen)
- return FALSE;
+ if (bwrite(bfd, ((char *)pBuffer)+dwDataOffset, dwDataLen) != (ssize_t)dwDataLen)
+ return false;
}
if (pContext->liNextHeader < dwSize) {/* is a header in this block ? */
- DWORD dwOffsetTarget;
- DWORD dwOffsetSource;
-
+ 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 = abs (pContext->liNextHeader);
- dwOffsetSource = 0;
- }
- else {
+ /* 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;
+ dwOffsetSource = pContext->liNextHeader;
}
- DWORD dwHeaderPartLen = dwSizeHeader-dwOffsetTarget;
- BOOL bHeaderIsComplete;
+ 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 {
+ 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;
+ bHeaderIsComplete = false;
dwHeaderPartLen = dwSize-dwOffsetSource;
}
/* copy the available portion of header to persistent copy */
- memcpy (((LPBYTE) &pContext->header_stream)+dwOffsetTarget, ((LPBYTE) pBuffer)+dwOffsetSource, dwHeaderPartLen);
+ memcpy(((char *)&pContext->header_stream)+dwOffsetTarget, ((char *)pBuffer)+dwOffsetSource, dwHeaderPartLen);
/* recalculate position of next header */
if (bHeaderIsComplete) {
- dwDataOffset = pContext->liNextHeader+dwSizeHeader+pContext->header_stream.dwStreamNameSize;
- pContext->liNextHeader = dwDataOffset+pContext->header_stream.Size.QuadPart;
- pContext->bIsInData = pContext->header_stream.dwStreamId == BACKUP_DATA;
+ /* 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 {
+ bContinue = false;
+ } else {
/* stop and continue with next block */
- bContinue = FALSE;
- pContext->bIsInData = FALSE;
+ bContinue = false;
+ pContext->bIsInData = false;
}
- }
- } while (bContinue);
+ }
+ } while (bContinue);
/* set "NextHeader" relative to the beginning of the next block */
pContext->liNextHeader-= dwSize;
return TRUE;
}
-#endif
* ===============================================================
*/
-#if defined(HAVE_CYGWIN) || defined(HAVE_WIN32)
+#if defined(HAVE_WIN32)
void unix_name_to_win32(POOLMEM **win32_name, char *name);
extern "C" HANDLE get_osfhandle(int fd);
-
void binit(BFILE *bfd)
{
memset(bfd, 0, sizeof(BFILE));
}
-
/*
- * Return 1 if we support the stream
- * 0 if we do not support the stream
+ * Return true if we support the stream
+ * false if we do not support the stream
+ *
+ * This code is running under Win32, so we
+ * do not need #ifdef on MACOS ...
*/
-bool is_stream_supported(int stream)
+bool is_restore_stream_supported(int stream)
{
- /* No Win32 backup on this machine */
switch (stream) {
-/*#ifndef HAVE_LIBZ
+
+/* Streams known not to be supported */
+#ifndef HAVE_LIBZ
case STREAM_GZIP_DATA:
case STREAM_SPARSE_GZIP_DATA:
- return 0;
-#endif*/
- case STREAM_WIN32_DATA:
case STREAM_WIN32_GZIP_DATA:
-#ifdef USE_WIN32STREAMEXTRACTION
- return true;
-#else
- return have_win32_api();
#endif
-
-/*
case STREAM_MACOS_FORK_DATA:
case STREAM_HFSPLUS_ATTRIBUTES:
+ case STREAM_ENCRYPTED_MACOS_FORK_DATA:
return false;
-*/
+
/* Known streams */
#ifdef HAVE_LIBZ
case STREAM_GZIP_DATA:
case STREAM_SPARSE_GZIP_DATA:
+ case STREAM_WIN32_GZIP_DATA:
#endif
+ case STREAM_WIN32_DATA:
case STREAM_UNIX_ATTRIBUTES:
case STREAM_FILE_DATA:
- case STREAM_MD5_SIGNATURE:
+ case STREAM_MD5_DIGEST:
case STREAM_UNIX_ATTRIBUTES_EX:
case STREAM_SPARSE_DATA:
case STREAM_PROGRAM_NAMES:
case STREAM_PROGRAM_DATA:
- case STREAM_SHA1_SIGNATURE:
+ case STREAM_SHA1_DIGEST:
+#ifdef HAVE_SHA2
+ case STREAM_SHA256_DIGEST:
+ case STREAM_SHA512_DIGEST:
+#endif
+#ifdef HAVE_CRYPTO
+ case STREAM_SIGNED_DIGEST:
+ case STREAM_ENCRYPTED_FILE_DATA:
+ case STREAM_ENCRYPTED_FILE_GZIP_DATA:
+ case STREAM_ENCRYPTED_WIN32_DATA:
+ case STREAM_ENCRYPTED_WIN32_GZIP_DATA:
+#endif
case 0: /* compatibility with old tapes */
return true;
}
if (!(p_CreateFileA || p_CreateFileW))
return 0;
- if (p_CreateFileW && p_MultiByteToWideChar)
- UTF8_2_wchar(&win32_fname_wchar, win32_fname);
+ 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) {
dwflags = 0;
}
- // unicode or ansii open for create write
- if (p_CreateFileW && p_MultiByteToWideChar) {
- bfd->fh = p_CreateFileW((LPCWSTR)win32_fname_wchar,
- dwaccess, /* Requested access */
- 0, /* Shared mode */
- NULL, /* SecurityAttributes */
- CREATE_ALWAYS, /* CreationDisposition */
- dwflags, /* Flags and attributes */
- NULL); /* TemplateFile */
- }
- else {
- bfd->fh = p_CreateFileA(win32_fname,
- dwaccess, /* Requested access */
- 0, /* Shared mode */
- NULL, /* SecurityAttributes */
- CREATE_ALWAYS, /* CreationDisposition */
- dwflags, /* Flags and attributes */
- NULL); /* TemplateFile */
- }
-
+ // unicode or ansii open for create write
+ if (p_CreateFileW && p_MultiByteToWideChar) {
+ bfd->fh = p_CreateFileW((LPCWSTR)win32_fname_wchar,
+ dwaccess, /* Requested access */
+ 0, /* Shared mode */
+ NULL, /* SecurityAttributes */
+ CREATE_ALWAYS, /* CreationDisposition */
+ dwflags, /* Flags and attributes */
+ NULL); /* TemplateFile */
+ } else {
+ bfd->fh = p_CreateFileA(win32_fname,
+ dwaccess, /* Requested access */
+ 0, /* Shared mode */
+ NULL, /* SecurityAttributes */
+ CREATE_ALWAYS, /* CreationDisposition */
+ dwflags, /* Flags and attributes */
+ NULL); /* TemplateFile */
+ }
bfd->mode = BF_WRITE;
dwflags = 0;
}
- // unicode or ansii open for open existing write
- if (p_CreateFileW && p_MultiByteToWideChar) {
- bfd->fh = p_CreateFileW((LPCWSTR)win32_fname_wchar,
- dwaccess, /* Requested access */
- 0, /* Shared mode */
- NULL, /* SecurityAttributes */
- OPEN_EXISTING, /* CreationDisposition */
- dwflags, /* Flags and attributes */
- NULL); /* TemplateFile */
- }
- else {
- bfd->fh = p_CreateFileA(win32_fname,
- dwaccess, /* Requested access */
- 0, /* Shared mode */
- NULL, /* SecurityAttributes */
- OPEN_EXISTING, /* CreationDisposition */
- dwflags, /* Flags and attributes */
- NULL); /* TemplateFile */
+ // unicode or ansii open for open existing write
+ if (p_CreateFileW && p_MultiByteToWideChar) {
+ bfd->fh = p_CreateFileW((LPCWSTR)win32_fname_wchar,
+ dwaccess, /* Requested access */
+ 0, /* Shared mode */
+ NULL, /* SecurityAttributes */
+ OPEN_EXISTING, /* CreationDisposition */
+ dwflags, /* Flags and attributes */
+ NULL); /* TemplateFile */
+ } else {
+ bfd->fh = p_CreateFileA(win32_fname,
+ dwaccess, /* Requested access */
+ 0, /* Shared mode */
+ NULL, /* SecurityAttributes */
+ OPEN_EXISTING, /* CreationDisposition */
+ dwflags, /* Flags and attributes */
+ NULL); /* TemplateFile */
- }
+ }
bfd->mode = BF_WRITE;
}
// unicode or ansii open for open existing read
- if (p_CreateFileW && p_MultiByteToWideChar) {
- bfd->fh = p_CreateFileW((LPCWSTR)win32_fname_wchar,
- dwaccess, /* Requested access */
- dwshare, /* Share modes */
- NULL, /* SecurityAttributes */
- OPEN_EXISTING, /* CreationDisposition */
- dwflags, /* Flags and attributes */
- NULL); /* TemplateFile */
- }
- else {
- bfd->fh = p_CreateFileA(win32_fname,
- dwaccess, /* Requested access */
- dwshare, /* Share modes */
- NULL, /* SecurityAttributes */
- OPEN_EXISTING, /* CreationDisposition */
- dwflags, /* Flags and attributes */
- NULL); /* TemplateFile */
- }
+ if (p_CreateFileW && p_MultiByteToWideChar) {
+ bfd->fh = p_CreateFileW((LPCWSTR)win32_fname_wchar,
+ dwaccess, /* Requested access */
+ dwshare, /* Share modes */
+ NULL, /* SecurityAttributes */
+ OPEN_EXISTING, /* CreationDisposition */
+ dwflags, /* Flags and attributes */
+ NULL); /* TemplateFile */
+ } else {
+ bfd->fh = p_CreateFileA(win32_fname,
+ dwaccess, /* Requested access */
+ dwshare, /* Share modes */
+ NULL, /* SecurityAttributes */
+ OPEN_EXISTING, /* CreationDisposition */
+ dwflags, /* Flags and attributes */
+ NULL); /* TemplateFile */
+ }
bfd->mode = BF_READ;
}
}
bfd->errmsg = NULL;
bfd->lpContext = NULL;
-#ifdef USE_WIN32STREAMEXTRACTION
- bfd->win32DecompContext.bIsInData = FALSE;
+ bfd->win32DecompContext.bIsInData = false;
bfd->win32DecompContext.liNextHeader = 0;
-#endif
free_pool_memory(win32_fname_wchar);
free_pool_memory(win32_fname);
return bfd->mode == BF_CLOSED ? -1 : 1;
return bfd->mode != BF_CLOSED;
}
-off_t blseek(BFILE *bfd, off_t offset, int whence)
+boffset_t blseek(BFILE *bfd, boffset_t offset, int whence)
{
- /* ****FIXME**** this must be implemented if we want to read Win32 Archives */
- return -1;
+ LONG offset_low = (LONG)offset;
+ LONG offset_high = (LONG)(offset >> 32);
+ DWORD dwResult;
+
+ dwResult = SetFilePointer(bfd->fh, offset_low, &offset_high, whence);
+
+ if (dwResult == INVALID_SET_FILE_POINTER && GetLastError() != NO_ERROR) {
+ return (boffset_t)-1;
+ }
+
+ return ((boffset_t)offset_high << 32) | dwResult;
}
#else /* Unix systems */
}
-
-bool is_stream_supported(int stream)
+/*
+ * This code is running on a non-Win32 machine
+ */
+bool is_restore_stream_supported(int stream)
{
/* No Win32 backup on this machine */
-/* switch (stream) {
+ switch (stream) {
#ifndef HAVE_LIBZ
case STREAM_GZIP_DATA:
case STREAM_SPARSE_GZIP_DATA:
case STREAM_WIN32_GZIP_DATA:
#endif
-#ifndef USE_WIN32STREAMEXTRACTION
- case STREAM_WIN32_DATA:
-#endif
#ifndef HAVE_DARWIN_OS
case STREAM_MACOS_FORK_DATA:
case STREAM_HFSPLUS_ATTRIBUTES:
#endif
return false;
-*/
/* Known streams */
#ifdef HAVE_LIBZ
case STREAM_GZIP_DATA:
case STREAM_SPARSE_GZIP_DATA:
-#endif
-#ifdef USE_WIN32STREAMEXTRACTION
- case STREAM_WIN32_DATA:
-# ifdef HAVE_LIBZ
case STREAM_WIN32_GZIP_DATA:
-# endif
#endif
+ case STREAM_WIN32_DATA:
case STREAM_UNIX_ATTRIBUTES:
case STREAM_FILE_DATA:
- case STREAM_MD5_SIGNATURE:
+ case STREAM_MD5_DIGEST:
case STREAM_UNIX_ATTRIBUTES_EX:
case STREAM_SPARSE_DATA:
case STREAM_PROGRAM_NAMES:
case STREAM_PROGRAM_DATA:
- case STREAM_SHA1_SIGNATURE:
+ case STREAM_SHA1_DIGEST:
+#ifdef HAVE_SHA2
+ case STREAM_SHA256_DIGEST:
+ case STREAM_SHA512_DIGEST:
+#endif
+#ifdef HAVE_CRYPTO
+ case STREAM_SIGNED_DIGEST:
+ case STREAM_ENCRYPTED_FILE_DATA:
+ case STREAM_ENCRYPTED_FILE_GZIP_DATA:
+ case STREAM_ENCRYPTED_WIN32_DATA:
+ case STREAM_ENCRYPTED_WIN32_GZIP_DATA:
+#endif
#ifdef HAVE_DARWIN_OS
case STREAM_MACOS_FORK_DATA:
case STREAM_HFSPLUS_ATTRIBUTES:
-#endif
+#ifdef HAVE_CRYPTO
+ case STREAM_ENCRYPTED_MACOS_FORK_DATA:
+#endif /* HAVE_CRYPTO */
+#endif /* HAVE_DARWIN_OS */
case 0: /* compatibility with old tapes */
return true;
}
/* Normal file open */
- bfd->fid = open(fname, flags, mode);
+ Dmsg1(400, "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);
+ if (oldflags == -1) {
+ bfd->berrno = errno;
+ close(bfd->fid);
+ bfd->fid = -1;
+ } else {
+ int ret = fcntl(bfd->fid, F_SETFL, oldflags | O_NOATIME);
+ /* EPERM means setting O_NOATIME was not allowed */
+ if (ret == -1 && errno != EPERM) {
+ bfd->berrno = errno;
+ close(bfd->fid);
+ bfd->fid = -1;
+ }
+ }
+ }
bfd->berrno = errno;
Dmsg1(400, "Open file %d\n", bfd->fid);
errno = bfd->berrno;
-#ifdef USE_WIN32STREAMEXTRACTION
- bfd->win32DecompContext.bIsInData = FALSE;
+ bfd->win32DecompContext.bIsInData = false;
bfd->win32DecompContext.liNextHeader = 0;
-#endif
return bfd->fid;
}
int bopen_rsrc(BFILE *bfd, const char *fname, int flags, mode_t mode)
{
POOLMEM *rsrc_fname;
- size_t fname_len;
- fname_len = strlen(fname);
rsrc_fname = get_pool_memory(PM_FNAME);
- bstrncpy(rsrc_fname, fname, fname_len + 1);
- bstrncpy(rsrc_fname + fname_len, _PATH_RSRCFORKSPEC,
- strlen(_PATH_RSRCFORKSPEC) + 1);
+ pm_strcpy(rsrc_fname, fname);
+ pm_strcat(rsrc_fname, _PATH_RSRCFORKSPEC);
bopen(bfd, rsrc_fname, flags, mode);
free_pool_memory(rsrc_fname);
return bfd->fid;
return bfd->fid >= 0;
}
-off_t blseek(BFILE *bfd, off_t offset, int whence)
+boffset_t blseek(BFILE *bfd, boffset_t offset, int whence)
{
- off_t pos;
- pos = lseek(bfd->fid, offset, whence);
+ boffset_t pos;
+ pos = (boffset_t)lseek(bfd->fid, (off_t)offset, whence);
bfd->berrno = errno;
return pos;
}
projects / bacula / bacula / blobdiff