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.
#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
#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
/* ===============================================================
*
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_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 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 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));
}
}
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;
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) {
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 */
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 */
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 */
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 */
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 */
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 */
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 */
}
} 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 */
stat = -1;
errno = b_errno_win32;
}
+
+all_done:
bfd->mode = BF_CLOSED;
bfd->lpContext = NULL;
bfd->cmd_plugin = false;
{
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,
{
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,
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) {
int bopen(BFILE *bfd, const char *fname, int flags, mode_t mode)
{
if (bfd->cmd_plugin && plugin_bopen) {
- Dmsg1(000, "call plugin_bopen fname=%s\n", fname);
- 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(100, "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);
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) {
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);
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;
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