X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=bacula%2Fsrc%2Ffindlib%2Fattribs.c;h=ab9a87f51d61de352d0041bde277d872bd33c411;hb=09c8c88482741e8f3e906be9159fa68015a9e3ec;hp=a24f147497a5a280ea17cb3b579c0cef727ea0fa;hpb=4fdf53e67e489beef502bab24a989cff20e7d255;p=bacula%2Fbacula diff --git a/bacula/src/findlib/attribs.c b/bacula/src/findlib/attribs.c index a24f147497..ab9a87f51d 100755 --- a/bacula/src/findlib/attribs.c +++ b/bacula/src/findlib/attribs.c @@ -9,36 +9,30 @@ * */ /* - Copyright (C) 2002-2004 Kern Sibbald and John Walker + Copyright (C) 2000-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 as - published by the Free Software Foundation; either version 2 of - the License, or (at your option) any later version. + 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 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., 59 Temple Place - Suite 330, Boston, - MA 02111-1307, USA. + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + the file LICENSE for additional details. */ #include "bacula.h" #include "find.h" -#if defined(HAVE_CYGWIN) || defined(HAVE_WIN32) - +#if defined(HAVE_WIN32) /* Forward referenced subroutines */ static bool set_win32_attributes(JCR *jcr, ATTR *attr, BFILE *ofd); void unix_name_to_win32(POOLMEM **win32_name, char *name); void win_error(JCR *jcr, char *prefix, POOLMEM *ofile); HANDLE bget_handle(BFILE *bfd); -#endif +#endif /* HAVE_WIN32 */ /* For old systems that don't have lchown() use chown() */ #ifndef HAVE_LCHOWN @@ -46,18 +40,27 @@ HANDLE bget_handle(BFILE *bfd); #endif /*=============================================================*/ -/* */ -/* *** A l l S y s t e m s *** */ -/* */ +/* */ +/* *** A l l S y s t e m s *** */ +/* */ /*=============================================================*/ /* - * Return the data stream that will be used + * Return the data stream that will be used */ int select_data_stream(FF_PKT *ff_pkt) { int stream; + /* + * Fix all incompatible options + */ + + /* No sparse option for encrypted data */ + if (ff_pkt->flags & FO_ENCRYPT) { + ff_pkt->flags &= ~FO_SPARSE; + } + /* Note, no sparse option for win32_data */ if (!is_portable_backup(&ff_pkt->bfd)) { stream = STREAM_WIN32_DATA; @@ -67,23 +70,71 @@ int select_data_stream(FF_PKT *ff_pkt) } else { stream = STREAM_FILE_DATA; } + + /* Encryption is only supported for file data */ + if (stream != STREAM_FILE_DATA && stream != STREAM_WIN32_DATA && + stream != STREAM_MACOS_FORK_DATA) { + ff_pkt->flags &= ~FO_ENCRYPT; + } + + /* Compression is not supported for Mac fork data */ + if (stream == STREAM_MACOS_FORK_DATA) { + ff_pkt->flags &= ~FO_GZIP; + } + + /* + * Handle compression and encryption options + */ #ifdef HAVE_LIBZ if (ff_pkt->flags & FO_GZIP) { - if (stream == STREAM_WIN32_DATA) { - stream = STREAM_WIN32_GZIP_DATA; - } else if (stream == STREAM_FILE_DATA) { - stream = STREAM_GZIP_DATA; - } else { - stream = STREAM_SPARSE_GZIP_DATA; + switch (stream) { + case STREAM_WIN32_DATA: + stream = STREAM_WIN32_GZIP_DATA; + break; + case STREAM_SPARSE_DATA: + stream = STREAM_SPARSE_GZIP_DATA; + break; + case STREAM_FILE_DATA: + stream = STREAM_GZIP_DATA; + break; + default: + /* All stream types that do not support gzip should clear out + * FO_GZIP above, and this code block should be unreachable. */ + ASSERT(!(ff_pkt->flags & FO_GZIP)); + return STREAM_NONE; + } + } +#endif +#ifdef HAVE_CRYPTO + if (ff_pkt->flags & FO_ENCRYPT) { + switch (stream) { + case STREAM_WIN32_DATA: + stream = STREAM_ENCRYPTED_WIN32_DATA; + break; + case STREAM_WIN32_GZIP_DATA: + stream = STREAM_ENCRYPTED_WIN32_GZIP_DATA; + break; + case STREAM_FILE_DATA: + stream = STREAM_ENCRYPTED_FILE_DATA; + break; + case STREAM_GZIP_DATA: + stream = STREAM_ENCRYPTED_FILE_GZIP_DATA; + break; + default: + /* All stream types that do not support encryption should clear out + * FO_ENCRYPT above, and this code block should be unreachable. */ + ASSERT(!ff_pkt->flags & FO_ENCRYPT); + return STREAM_NONE; } } #endif + return stream; } -/* - * Encode a stat structure into a base64 character string +/* + * Encode a stat structure into a base64 character string * All systems must create such a structure. * In addition, we tack on the LinkFI, which is non-zero in * the case of a hard linked file that has no data. This @@ -99,7 +150,7 @@ void encode_stat(char *buf, FF_PKT *ff_pkt, int data_stream) struct stat *statp = &ff_pkt->statp; /* * Encode a stat packet. I should have done this more intelligently - * with a length so that it could be easily expanded. + * with a length so that it could be easily expanded. */ p += to_base64((int64_t)statp->st_dev, p); *p++ = ' '; /* separate fields with a space */ @@ -151,16 +202,22 @@ void encode_stat(char *buf, FF_PKT *ff_pkt, int data_stream) /* Do casting according to unknown type to keep compiler happy */ -#if !HAVE_GCC & HAVE_SUN_OS -#define plug(st, val) st = val /* brain damaged compiler */ +#ifdef HAVE_TYPEOF + #define plug(st, val) st = (typeof st)val #else -template void plug(T &st, uint64_t val) - { st = static_cast(val); } + #if !HAVE_GCC & HAVE_SUN_OS + /* Sun compiler does not handle templates correctly */ + #define plug(st, val) st = val + #else + /* Use templates to do the casting */ + template void plug(T &st, uint64_t val) + { st = static_cast(val); } + #endif #endif /* Decode a stat packet from base64 characters */ -int decode_stat(char *buf, struct stat *statp, int32_t *LinkFI) +int decode_stat(char *buf, struct stat *statp, int32_t *LinkFI) { char *p = buf; int64_t val; @@ -233,7 +290,7 @@ int decode_stat(char *buf, struct stat *statp, int32_t *LinkFI) statp->st_flags = 0; #endif } - + /* Look for data stream id */ if (*p == ' ' || (*p != 0 && *(p+1) == ' ')) { p++; @@ -250,32 +307,32 @@ int32_t decode_LinkFI(char *buf, struct stat *statp) char *p = buf; int64_t val; - skip_nonspaces(&p); /* st_dev */ - p++; /* skip space */ - skip_nonspaces(&p); /* st_ino */ + skip_nonspaces(&p); /* st_dev */ + p++; /* skip space */ + skip_nonspaces(&p); /* st_ino */ p++; p += from_base64(&val, p); - plug(statp->st_mode, val); /* st_mode */ + plug(statp->st_mode, val); /* st_mode */ p++; - skip_nonspaces(&p); /* st_nlink */ + skip_nonspaces(&p); /* st_nlink */ p++; - skip_nonspaces(&p); /* st_uid */ + skip_nonspaces(&p); /* st_uid */ p++; - skip_nonspaces(&p); /* st_gid */ + skip_nonspaces(&p); /* st_gid */ p++; - skip_nonspaces(&p); /* st_rdev */ + skip_nonspaces(&p); /* st_rdev */ p++; - skip_nonspaces(&p); /* st_size */ + skip_nonspaces(&p); /* st_size */ p++; - skip_nonspaces(&p); /* st_blksize */ + skip_nonspaces(&p); /* st_blksize */ p++; - skip_nonspaces(&p); /* st_blocks */ + skip_nonspaces(&p); /* st_blocks */ p++; - skip_nonspaces(&p); /* st_atime */ + skip_nonspaces(&p); /* st_atime */ p++; - skip_nonspaces(&p); /* st_mtime */ + skip_nonspaces(&p); /* st_mtime */ p++; - skip_nonspaces(&p); /* st_ctime */ + skip_nonspaces(&p); /* st_ctime */ /* Optional FileIndex of hard linked file data */ if (*p == ' ' || (*p != 0 && *(p+1) == ' ')) { @@ -289,87 +346,95 @@ int32_t decode_LinkFI(char *buf, struct stat *statp) /* * Set file modes, permissions and times * - * fname is the original filename + * fname is the original filename * ofile is the output filename (may be in a different directory) * * Returns: true on success - * false on failure + * false on failure */ bool set_attributes(JCR *jcr, ATTR *attr, BFILE *ofd) { - struct utimbuf ut; + struct utimbuf ut; mode_t old_mask; bool ok = true; + off_t fsize; -#if defined(HAVE_CYGWIN) || defined(HAVE_WIN32) +#if defined(HAVE_WIN32) if (attr->stream == STREAM_UNIX_ATTRIBUTES_EX && set_win32_attributes(jcr, attr, ofd)) { if (is_bopen(ofd)) { - bclose(ofd); + bclose(ofd); } - pm_strcpy(&attr->ofname, "*none*"); + pm_strcpy(attr->ofname, "*none*"); return true; } if (attr->data_stream == STREAM_WIN32_DATA || attr->data_stream == STREAM_WIN32_GZIP_DATA) { if (is_bopen(ofd)) { - bclose(ofd); + bclose(ofd); } - pm_strcpy(&attr->ofname, "*none*"); + pm_strcpy(attr->ofname, "*none*"); return true; } /* * If Windows stuff failed, e.g. attempt to restore Unix file - * to Windows, simply fall through and we will do it the + * to Windows, simply fall through and we will do it the * universal way. */ #endif old_mask = umask(0); if (is_bopen(ofd)) { - bclose(ofd); /* first close file */ + char ec1[50], ec2[50]; + fsize = blseek(ofd, 0, SEEK_END); + bclose(ofd); /* first close file */ + if (fsize > 0 && fsize != (off_t)attr->statp.st_size) { + Jmsg3(jcr, M_ERROR, 0, _("File size of restored file %s not correct. Original %s, restored %s.\n"), + attr->ofname, edit_uint64(attr->statp.st_size, ec1), + edit_uint64(fsize, ec2)); + } } ut.actime = attr->statp.st_atime; ut.modtime = attr->statp.st_mtime; /* ***FIXME**** optimize -- don't do if already correct */ - /* + /* * For link, change owner of link using lchown, but don't - * try to do a chmod as that will update the file behind it. + * try to do a chmod as that will update the file behind it. */ if (attr->type == FT_LNK) { /* Change owner of link, not of real file */ if (lchown(attr->ofname, attr->statp.st_uid, attr->statp.st_gid) < 0) { - berrno be; + berrno be; Jmsg2(jcr, M_ERROR, 0, _("Unable to set file owner %s: ERR=%s\n"), - attr->ofname, be.strerror()); - ok = false; + attr->ofname, be.strerror()); + ok = false; } } else { if (chown(attr->ofname, attr->statp.st_uid, attr->statp.st_gid) < 0) { - berrno be; + berrno be; Jmsg2(jcr, M_ERROR, 0, _("Unable to set file owner %s: ERR=%s\n"), - attr->ofname, be.strerror()); - ok = false; + attr->ofname, be.strerror()); + ok = false; } if (chmod(attr->ofname, attr->statp.st_mode) < 0) { - berrno be; + berrno be; Jmsg2(jcr, M_ERROR, 0, _("Unable to set file modes %s: ERR=%s\n"), - attr->ofname, be.strerror()); - ok = false; + attr->ofname, be.strerror()); + ok = false; } /* * Reset file times. */ if (utime(attr->ofname, &ut) < 0) { - berrno be; + berrno be; Jmsg2(jcr, M_ERROR, 0, _("Unable to set file times %s: ERR=%s\n"), - attr->ofname, be.strerror()); - ok = false; + attr->ofname, be.strerror()); + ok = false; } #ifdef HAVE_CHFLAGS /* @@ -380,39 +445,52 @@ bool set_attributes(JCR *jcr, ATTR *attr, BFILE *ofd) * fail. */ if (chflags(attr->ofname, attr->statp.st_flags) < 0) { - berrno be; + berrno be; Jmsg2(jcr, M_ERROR, 0, _("Unable to set file flags %s: ERR=%s\n"), - attr->ofname, be.strerror()); - ok = false; + attr->ofname, be.strerror()); + ok = false; } #endif } - pm_strcpy(&attr->ofname, "*none*"); + pm_strcpy(attr->ofname, "*none*"); umask(old_mask); return ok; } /*=============================================================*/ -/* */ -/* * * * U n i x * * * * */ -/* */ +/* */ +/* * * * U n i x * * * * */ +/* */ /*=============================================================*/ -#if !defined(HAVE_CYGWIN) && !defined(HAVE_WIN32) - +#if !defined(HAVE_WIN32) + /* * It is possible to piggyback additional data e.g. ACLs on * the encode_stat() data by returning the extended attributes * here. They must be "self-contained" (i.e. you keep track * of your own length), and they must be in ASCII string * format. Using this feature is not recommended. - * The code below shows how to return nothing. See the Win32 + * The code below shows how to return nothing. See the Win32 * code below for returning something in the attributes. */ int encode_attribsEx(JCR *jcr, char *attribsEx, FF_PKT *ff_pkt) { - *attribsEx = 0; /* no extended attributes */ +#ifdef HAVE_DARWIN_OS + /* + * We save the Mac resource fork length so that on a + * restore, we can be sure we put back the whole resource. + */ + char *p; + p = attribsEx; + if (ff_pkt->flags & FO_HFSPLUS) { + p += to_base64((uint64_t)(ff_pkt->hfsinfo.rsrclength), p); + } + *p = 0; +#else + *attribsEx = 0; /* no extended attributes */ +#endif return STREAM_UNIX_ATTRIBUTES; } @@ -421,12 +499,12 @@ int encode_attribsEx(JCR *jcr, char *attribsEx, FF_PKT *ff_pkt) /*=============================================================*/ -/* */ -/* * * * W i n 3 2 * * * * */ -/* */ +/* */ +/* * * * W i n 3 2 * * * * */ +/* */ /*=============================================================*/ -#if defined(HAVE_CYGWIN) || defined(HAVE_WIN32) +#if defined(HAVE_WIN32) int encode_attribsEx(JCR *jcr, char *attribsEx, FF_PKT *ff_pkt) { @@ -434,17 +512,32 @@ int encode_attribsEx(JCR *jcr, char *attribsEx, FF_PKT *ff_pkt) WIN32_FILE_ATTRIBUTE_DATA atts; ULARGE_INTEGER li; - attribsEx[0] = 0; /* no extended attributes */ - - if (!p_GetFileAttributesEx) { - return STREAM_UNIX_ATTRIBUTES; - } + attribsEx[0] = 0; /* no extended attributes */ unix_name_to_win32(&ff_pkt->sys_fname, ff_pkt->fname); - if (!p_GetFileAttributesEx(ff_pkt->sys_fname, GetFileExInfoStandard, - (LPVOID)&atts)) { - win_error(jcr, "GetFileAttributesEx:", ff_pkt->sys_fname); - return STREAM_UNIX_ATTRIBUTES; + + // try unicode version + if (p_GetFileAttributesExW) { + POOLMEM* pwszBuf = get_pool_memory (PM_FNAME); + make_win32_path_UTF8_2_wchar(&pwszBuf, ff_pkt->fname); + + BOOL b=p_GetFileAttributesExW((LPCWSTR) pwszBuf, GetFileExInfoStandard, (LPVOID)&atts); + free_pool_memory(pwszBuf); + + if (!b) { + win_error(jcr, "GetFileAttributesExW:", ff_pkt->sys_fname); + return STREAM_UNIX_ATTRIBUTES; + } + } + else { + if (!p_GetFileAttributesExA) + return STREAM_UNIX_ATTRIBUTES; + + if (!p_GetFileAttributesExA(ff_pkt->sys_fname, GetFileExInfoStandard, + (LPVOID)&atts)) { + win_error(jcr, "GetFileAttributesExA:", ff_pkt->sys_fname); + return STREAM_UNIX_ATTRIBUTES; + } } p += to_base64((uint64_t)atts.dwFileAttributes, p); @@ -477,17 +570,17 @@ int encode_attribsEx(JCR *jcr, char *attribsEx, FF_PKT *ff_pkt) FILE_ATTRIBUTE_OFFLINE| \ FILE_ATTRIBUTE_READONLY| \ FILE_ATTRIBUTE_SYSTEM| \ - FILE_ATTRIBUTE_TEMPORARY) + FILE_ATTRIBUTE_TEMPORARY) /* * Set Extended File Attributes for Win32 * - * fname is the original filename + * fname is the original filename * ofile is the output filename (may be in a different directory) * * Returns: true on success - * false on failure + * false on failure */ static bool set_win32_attributes(JCR *jcr, ATTR *attr, BFILE *ofd) { @@ -497,14 +590,14 @@ static bool set_win32_attributes(JCR *jcr, ATTR *attr, BFILE *ofd) ULARGE_INTEGER li; POOLMEM *win32_ofile; - if (!p_GetFileAttributesEx) { + // if we have neither ansi nor wchar version, we leave + if (!(p_SetFileAttributesW || p_SetFileAttributesA)) return false; - } - if (!p || !*p) { /* we should have attributes */ + if (!p || !*p) { /* we should have attributes */ Dmsg2(100, "Attributes missing. of=%s ofd=%d\n", attr->ofname, ofd->fid); if (is_bopen(ofd)) { - bclose(ofd); + bclose(ofd); } return false; } else { @@ -513,22 +606,22 @@ static bool set_win32_attributes(JCR *jcr, ATTR *attr, BFILE *ofd) p += from_base64(&val, p); plug(atts.dwFileAttributes, val); - p++; /* skip space */ + p++; /* skip space */ p += from_base64(&val, p); li.QuadPart = val; atts.ftCreationTime.dwLowDateTime = li.LowPart; atts.ftCreationTime.dwHighDateTime = li.HighPart; - p++; /* skip space */ + p++; /* skip space */ p += from_base64(&val, p); li.QuadPart = val; atts.ftLastAccessTime.dwLowDateTime = li.LowPart; atts.ftLastAccessTime.dwHighDateTime = li.HighPart; - p++; /* skip space */ + p++; /* skip space */ p += from_base64(&val, p); li.QuadPart = val; atts.ftLastWriteTime.dwLowDateTime = li.LowPart; atts.ftLastWriteTime.dwHighDateTime = li.HighPart; - p++; + p++; p += from_base64(&val, p); plug(atts.nFileSizeHigh, val); p++; @@ -539,30 +632,41 @@ static bool set_win32_attributes(JCR *jcr, ATTR *attr, BFILE *ofd) win32_ofile = get_pool_memory(PM_FNAME); unix_name_to_win32(&win32_ofile, attr->ofname); - - /* At this point, we have reconstructed the WIN32_FILE_ATTRIBUTE_DATA pkt */ if (!is_bopen(ofd)) { Dmsg1(100, "File not open: %s\n", attr->ofname); - bopen(ofd, attr->ofname, O_WRONLY|O_BINARY, 0); /* attempt to open the file */ + bopen(ofd, attr->ofname, O_WRONLY|O_BINARY, 0); /* attempt to open the file */ } if (is_bopen(ofd)) { Dmsg1(100, "SetFileTime %s\n", attr->ofname); if (!SetFileTime(bget_handle(ofd), - &atts.ftCreationTime, - &atts.ftLastAccessTime, - &atts.ftLastWriteTime)) { + &atts.ftCreationTime, + &atts.ftLastAccessTime, + &atts.ftLastWriteTime)) { win_error(jcr, "SetFileTime:", win32_ofile); } bclose(ofd); } Dmsg1(100, "SetFileAtts %s\n", attr->ofname); - if (!(atts.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) { - if (!SetFileAttributes(win32_ofile, atts.dwFileAttributes & SET_ATTRS)) { - win_error(jcr, "SetFileAttributes:", win32_ofile); + if (!(atts.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) + { + if (p_SetFileAttributesW) { + POOLMEM* pwszBuf = get_pool_memory (PM_FNAME); + make_win32_path_UTF8_2_wchar(&pwszBuf, attr->ofname); + + BOOL b=p_SetFileAttributesW((LPCWSTR)pwszBuf, atts.dwFileAttributes & SET_ATTRS); + free_pool_memory(pwszBuf); + + if (!b) + win_error(jcr, "SetFileAttributesW:", win32_ofile); + } + else { + if (!p_SetFileAttributesA(win32_ofile, atts.dwFileAttributes & SET_ATTRS)) { + win_error(jcr, "SetFileAttributesA:", win32_ofile); + } } } free_pool_memory(win32_ofile); @@ -574,13 +678,13 @@ void win_error(JCR *jcr, char *prefix, POOLMEM *win32_ofile) DWORD lerror = GetLastError(); LPTSTR msg; FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER| - FORMAT_MESSAGE_FROM_SYSTEM, - NULL, - lerror, - 0, - (LPTSTR)&msg, - 0, - NULL); + FORMAT_MESSAGE_FROM_SYSTEM, + NULL, + lerror, + 0, + (LPTSTR)&msg, + 0, + NULL); Dmsg3(100, "Error in %s on file %s: ERR=%s\n", prefix, win32_ofile, msg); strip_trailing_junk(msg); Jmsg(jcr, M_ERROR, 0, _("Error in %s file %s: ERR=%s\n"), prefix, win32_ofile, msg); @@ -591,13 +695,13 @@ void win_error(JCR *jcr, char *prefix, DWORD lerror) { LPTSTR msg; FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER| - FORMAT_MESSAGE_FROM_SYSTEM, - NULL, - lerror, - 0, - (LPTSTR)&msg, - 0, - NULL); + FORMAT_MESSAGE_FROM_SYSTEM, + NULL, + lerror, + 0, + (LPTSTR)&msg, + 0, + NULL); strip_trailing_junk(msg); if (jcr) { Jmsg2(jcr, M_ERROR, 0, _("Error in %s: ERR=%s\n"), prefix, msg); @@ -606,16 +710,4 @@ void win_error(JCR *jcr, char *prefix, DWORD lerror) } LocalFree(msg); } - - -/* Cygwin API definition */ -extern "C" void cygwin_conv_to_win32_path(const char *path, char *win32_path); - -void unix_name_to_win32(POOLMEM **win32_name, char *name) -{ - /* One extra byte should suffice, but we double it */ - *win32_name = check_pool_memory_size(*win32_name, 2*strlen(name)+1); - cygwin_conv_to_win32_path(name, *win32_name); -} - -#endif /* HAVE_CYGWIN */ +#endif /* HAVE_WIN32 */