X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=bacula%2Fsrc%2Ffindlib%2Fattribs.c;h=d747543e188cc62c3b76bc82c4afbf9930c4ad21;hb=fb023b61aa95fdf2763963be726e18b896d6c01f;hp=c35aaed4c4fd864b3b5005586a352a0d6d76264c;hpb=d426510f6e1cc6d56d6acfd579d5361c5720bdcc;p=bacula%2Fbacula diff --git a/bacula/src/findlib/attribs.c b/bacula/src/findlib/attribs.c old mode 100755 new mode 100644 index c35aaed4c4..d747543e18 --- a/bacula/src/findlib/attribs.c +++ b/bacula/src/findlib/attribs.c @@ -1,3 +1,30 @@ +/* + Bacula® - The Network Backup Solution + + Copyright (C) 2002-2007 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. +*/ /* * Encode and decode standard Unix attributes and * Extended attributes for Win32 and @@ -8,61 +35,135 @@ * Version $Id$ * */ -/* - Copyright (C) 2000, 2001, 2002 Kern Sibbald and John Walker - 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. +#include "bacula.h" +#include "find.h" - 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. +#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 /* HAVE_WIN32 */ + +/* For old systems that don't have lchown() use chown() */ +#ifndef HAVE_LCHOWN +#define lchown chown +#endif - 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. +/*=============================================================*/ +/* */ +/* *** A l l S y s t e m s *** */ +/* */ +/*=============================================================*/ +/* + * Return the data stream that will be used */ +int select_data_stream(FF_PKT *ff_pkt) +{ + int stream; -#include "bacula.h" -#include "find.h" -#include "jcr.h" + /* + * Fix all incompatible options + */ -#ifdef HAVE_CYGWIN -#include + /* No sparse option for encrypted data */ + if (ff_pkt->flags & FO_ENCRYPT) { + ff_pkt->flags &= ~FO_SPARSE; + } -/* Forward referenced subroutines */ -static -int set_win32_attributes(void *jcr, char *fname, char *ofile, char *lname, - int type, int stream, struct stat *statp, - char *attribsEx, int *ofd); -void unix_name_to_win32(char *name); -extern "C" HANDLE get_osfhandle(int fd); -void win_error(void *jcr, char *prefix, char *ofile); -#endif + /* Note, no sparse option for win32_data */ + if (!is_portable_backup(&ff_pkt->bfd)) { + stream = STREAM_WIN32_DATA; + ff_pkt->flags &= ~FO_SPARSE; + } else if (ff_pkt->flags & FO_SPARSE) { + stream = STREAM_SPARSE_DATA; + } 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; + } -/*=============================================================*/ -/* */ -/* *** A l l S y s t e m s *** */ -/* */ -/*=============================================================*/ + /* 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) { + 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 */ -void encode_stat(char *buf, struct stat *statp) +/* + * 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 + * is a File Index pointing to the link that does have the + * data (always the first one encountered in a save). + * You may piggyback attributes on this packet by encoding + * them in the encode_attribsEx() subroutine, but this is + * not recommended. + */ +void encode_stat(char *buf, FF_PKT *ff_pkt, int data_stream) { char *p = buf; + struct stat *statp = &ff_pkt->statp; /* - * NOTE: we should use rdev as major and minor device if - * it is a block or char device (S_ISCHR(statp->st_mode) - * or S_ISBLK(statp->st_mode)). In all other cases, - * it is not used. - * + * Encode a stat packet. I should have done this more intelligently + * 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 */ @@ -80,150 +181,339 @@ void encode_stat(char *buf, struct stat *statp) *p++ = ' '; p += to_base64((int64_t)statp->st_size, p); *p++ = ' '; +#ifndef HAVE_MINGW p += to_base64((int64_t)statp->st_blksize, p); *p++ = ' '; p += to_base64((int64_t)statp->st_blocks, p); *p++ = ' '; +#else + p += to_base64((int64_t)0, p); /* output place holder */ + *p++ = ' '; + p += to_base64((int64_t)0, p); /* output place holder */ + *p++ = ' '; +#endif p += to_base64((int64_t)statp->st_atime, p); *p++ = ' '; p += to_base64((int64_t)statp->st_mtime, p); *p++ = ' '; p += to_base64((int64_t)statp->st_ctime, p); + *p++ = ' '; + p += to_base64((int64_t)ff_pkt->LinkFI, p); + *p++ = ' '; + +#ifdef HAVE_CHFLAGS + /* FreeBSD function */ + p += to_base64((int64_t)statp->st_flags, p); /* output st_flags */ +#else + p += to_base64((int64_t)0, p); /* output place holder */ +#endif + *p++ = ' '; + p += to_base64((int64_t)data_stream, p); *p = 0; return; } +/* Do casting according to unknown type to keep compiler happy */ +#ifdef HAVE_TYPEOF + #define plug(st, val) st = (typeof st)val +#else + #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 */ -void -decode_stat(char *buf, struct stat *statp) +int decode_stat(char *buf, struct stat *statp, int32_t *LinkFI) { char *p = buf; int64_t val; p += from_base64(&val, p); - statp->st_dev = val; - p++; /* skip space */ + plug(statp->st_dev, val); + p++; p += from_base64(&val, p); - statp->st_ino = val; + plug(statp->st_ino, val); p++; p += from_base64(&val, p); - statp->st_mode = val; + plug(statp->st_mode, val); p++; p += from_base64(&val, p); - statp->st_nlink = val; + plug(statp->st_nlink, val); p++; p += from_base64(&val, p); - statp->st_uid = val; + plug(statp->st_uid, val); p++; p += from_base64(&val, p); - statp->st_gid = val; + plug(statp->st_gid, val); p++; p += from_base64(&val, p); - statp->st_rdev = val; + plug(statp->st_rdev, val); p++; p += from_base64(&val, p); - statp->st_size = val; + plug(statp->st_size, val); p++; +#ifndef HAVE_MINGW p += from_base64(&val, p); - statp->st_blksize = val; + plug(statp->st_blksize, val); p++; p += from_base64(&val, p); - statp->st_blocks = val; + plug(statp->st_blocks, val); p++; +#else p += from_base64(&val, p); - statp->st_atime = val; +// plug(statp->st_blksize, val); p++; p += from_base64(&val, p); - statp->st_mtime = val; +// plug(statp->st_blocks, val); + p++; +#endif + p += from_base64(&val, p); + plug(statp->st_atime, val); p++; p += from_base64(&val, p); - statp->st_ctime = val; + plug(statp->st_mtime, val); + p++; + p += from_base64(&val, p); + plug(statp->st_ctime, val); + + /* Optional FileIndex of hard linked file data */ + if (*p == ' ' || (*p != 0 && *(p+1) == ' ')) { + p++; + p += from_base64(&val, p); + *LinkFI = (uint32_t)val; + } else { + *LinkFI = 0; + return 0; + } + + /* FreeBSD user flags */ + if (*p == ' ' || (*p != 0 && *(p+1) == ' ')) { + p++; + p += from_base64(&val, p); +#ifdef HAVE_CHFLAGS + plug(statp->st_flags, val); + } else { + statp->st_flags = 0; +#endif + } + + /* Look for data stream id */ + if (*p == ' ' || (*p != 0 && *(p+1) == ' ')) { + p++; + p += from_base64(&val, p); + } else { + val = 0; + } + return (int)val; +} + +/* Decode a LinkFI field of encoded stat packet */ +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 */ + p++; + p += from_base64(&val, p); + plug(statp->st_mode, val); /* st_mode */ + p++; + skip_nonspaces(&p); /* st_nlink */ + p++; + skip_nonspaces(&p); /* st_uid */ + p++; + skip_nonspaces(&p); /* st_gid */ + p++; + skip_nonspaces(&p); /* st_rdev */ + p++; + skip_nonspaces(&p); /* st_size */ + p++; + skip_nonspaces(&p); /* st_blksize */ + p++; + skip_nonspaces(&p); /* st_blocks */ + p++; + skip_nonspaces(&p); /* st_atime */ + p++; + skip_nonspaces(&p); /* st_mtime */ + p++; + skip_nonspaces(&p); /* st_ctime */ + + /* Optional FileIndex of hard linked file data */ + if (*p == ' ' || (*p != 0 && *(p+1) == ' ')) { + p++; + p += from_base64(&val, p); + return (int32_t)val; + } + return 0; } /* * 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: 1 on success - * 0 on failure + * Returns: true on success + * false on failure */ -int set_attributes(void *jcr, char *fname, char *ofile, char *lname, - int type, int stream, struct stat *statp, - char *attribsEx, int *ofd) +bool set_attributes(JCR *jcr, ATTR *attr, BFILE *ofd) { - struct utimbuf ut; - -#ifdef HAVE_CYGWIN - if (set_win32_attributes(jcr, fname, ofile, lname, type, stream, - statp, attribsEx, ofd)) { - return 1; + struct utimbuf ut; + mode_t old_mask; + bool ok = true; + boffset_t fsize; + +#if defined(HAVE_WIN32) + if (attr->stream == STREAM_UNIX_ATTRIBUTES_EX && + set_win32_attributes(jcr, attr, ofd)) { + if (is_bopen(ofd)) { + bclose(ofd); + } + 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); + } + 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 - if (*ofd != -1) { - close(*ofd); /* first close file */ - *ofd = -1; + old_mask = umask(0); + if (is_bopen(ofd)) { + char ec1[50], ec2[50]; + fsize = blseek(ofd, 0, SEEK_END); + bclose(ofd); /* first close file */ + if (attr->type == FT_REG && fsize > 0 && fsize != (boffset_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)); + } + } + + /* + * We do not restore sockets, so skip trying to restore their + * attributes. + */ + if (attr->type == FT_SPEC && S_ISSOCK(attr->statp.st_mode)) { + goto bail_out; } - ut.actime = statp->st_atime; - ut.modtime = statp->st_mtime; + ut.actime = attr->statp.st_atime; + ut.modtime = attr->statp.st_mtime; /* ***FIXME**** optimize -- don't do if already correct */ - if (type == FT_LNK) { - if (lchown(ofile, statp->st_uid, statp->st_gid) < 0) { - Jmsg2(jcr, M_ERROR, 0, "Unable to set file owner %s: ERR=%s\n", - ofile, strerror(errno)); - return 0; + /* + * For link, change owner of link using lchown, but don't + * 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; + Jmsg2(jcr, M_ERROR, 0, _("Unable to set file owner %s: ERR=%s\n"), + attr->ofname, be.strerror()); + ok = false; } } else { - if (chown(ofile, statp->st_uid, statp->st_gid) < 0) { - Jmsg2(jcr, M_ERROR, 0, "Unable to set file owner %s: ERR=%s\n", - ofile, strerror(errno)); - return 0; + if (chown(attr->ofname, attr->statp.st_uid, attr->statp.st_gid) < 0) { + berrno be; + Jmsg2(jcr, M_ERROR, 0, _("Unable to set file owner %s: ERR=%s\n"), + attr->ofname, be.strerror()); + ok = false; + } + if (chmod(attr->ofname, attr->statp.st_mode) < 0) { + berrno be; + Jmsg2(jcr, M_ERROR, 0, _("Unable to set file modes %s: ERR=%s\n"), + attr->ofname, be.strerror()); + ok = false; } - } - if (chmod(ofile, statp->st_mode) < 0) { - Jmsg2(jcr, M_ERROR, 0, "Unable to set file modes %s: ERR=%s\n", - ofile, strerror(errno)); - return 0; - } - /* - * Update file times. - */ - if (utime(ofile, &ut) < 0) { - Jmsg2(jcr, M_ERROR, 0, "Unable to set file times %s: ERR=%s\n", - ofile, strerror(errno)); - return 0; + /* + * Reset file times. + */ + if (utime(attr->ofname, &ut) < 0) { + berrno be; + Jmsg2(jcr, M_ERROR, 0, _("Unable to set file times %s: ERR=%s\n"), + attr->ofname, be.strerror()); + ok = false; + } +#ifdef HAVE_CHFLAGS + /* + * FreeBSD user flags + * + * Note, this should really be done before the utime() above, + * but if the immutable bit is set, it will make the utimes() + * fail. + */ + if (chflags(attr->ofname, attr->statp.st_flags) < 0) { + berrno be; + Jmsg2(jcr, M_ERROR, 0, _("Unable to set file flags %s: ERR=%s\n"), + attr->ofname, be.strerror()); + ok = false; + } +#endif } - return 1; + +bail_out: + pm_strcpy(attr->ofname, "*none*"); + umask(old_mask); + return ok; } /*=============================================================*/ -/* */ -/* * * * U n i x * * * * */ -/* */ +/* */ +/* * * * U n i x * * * * */ +/* */ /*=============================================================*/ -#ifndef HAVE_CYGWIN - +#if !defined(HAVE_WIN32) + /* - * If you have a Unix system with extended attributes (e.g. - * ACLs for Solaris, do it here. + * 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 + * code below for returning something in the attributes. */ -int encode_attribsEx(void *jcr, char *attribsEx, FF_PKT *ff_pkt) +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; } @@ -232,27 +522,45 @@ int encode_attribsEx(void *jcr, char *attribsEx, FF_PKT *ff_pkt) /*=============================================================*/ -/* */ -/* * * * W i n 3 2 * * * * */ -/* */ +/* */ +/* * * * W i n 3 2 * * * * */ +/* */ /*=============================================================*/ -#ifdef HAVE_CYGWIN +#if defined(HAVE_WIN32) -int encode_attribsEx(void *jcr, char *attribsEx, FF_PKT *ff_pkt) +int encode_attribsEx(JCR *jcr, char *attribsEx, FF_PKT *ff_pkt) { char *p = attribsEx; WIN32_FILE_ATTRIBUTE_DATA atts; ULARGE_INTEGER li; - attribsEx[0] = 0; /* no extended attributes */ + attribsEx[0] = 0; /* no extended attributes */ - pm_strcpy(&ff_pkt->sys_fname, ff_pkt->fname); - unix_name_to_win32(ff_pkt->sys_fname); - if (!GetFileAttributesEx(ff_pkt->sys_fname, GetFileExInfoStandard, - (LPVOID)&atts)) { - win_error(jcr, "GetFileAttributesEx:", ff_pkt->sys_fname); - return STREAM_WIN32_ATTRIBUTES; + unix_name_to_win32(&ff_pkt->sys_fname, ff_pkt->fname); + + // 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); @@ -273,7 +581,7 @@ int encode_attribsEx(void *jcr, char *attribsEx, FF_PKT *ff_pkt) *p++ = ' '; p += to_base64((uint64_t)atts.nFileSizeLow, p); *p = 0; - return STREAM_WIN32_ATTRIBUTES; + return STREAM_UNIX_ATTRIBUTES_EX; } /* Define attributes that are legal to set with SetFileAttributes() */ @@ -285,123 +593,144 @@ int encode_attribsEx(void *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: 1 on success - * 0 on failure + * Returns: true on success + * false on failure */ -static -int set_win32_attributes(void *jcr, char *fname, char *ofile, char *lname, - int type, int stream, struct stat *statp, - char *attribsEx, int *ofd) +static bool set_win32_attributes(JCR *jcr, ATTR *attr, BFILE *ofd) { - char *p = attribsEx; + char *p = attr->attrEx; int64_t val; WIN32_FILE_ATTRIBUTE_DATA atts; ULARGE_INTEGER li; - int fid, stat; + POOLMEM *win32_ofile; - if (!p || !*p) { /* we should have attributes */ - Dmsg2(100, "Attributes missing. of=%s ofd=%d\n", ofile, *ofd); - if (*ofd != -1) { - close(*ofd); - *ofd = -1; + // if we have neither ansi nor wchar version, we leave + if (!(p_SetFileAttributesW || p_SetFileAttributesA)) + return false; + + 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); } - return 0; + return false; } else { - Dmsg2(100, "Attribs %s = %s\n", ofile, attribsEx); + Dmsg2(100, "Attribs %s = %s\n", attr->ofname, attr->attrEx); } p += from_base64(&val, p); - atts.dwFileAttributes = val; - p++; /* skip space */ + plug(atts.dwFileAttributes, val); + 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); - atts.nFileSizeHigh = val; + plug(atts.nFileSizeHigh, val); p++; p += from_base64(&val, p); - atts.nFileSizeLow = val; + plug(atts.nFileSizeLow, val); + + /* Convert to Windows path format */ + 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 (*ofd == -1) { - Dmsg1(100, "File not open: %s\n", ofile); - fid = open(ofile, O_RDWR|O_BINARY); /* attempt to open the file */ - if (fid >= 0) { - *ofd = fid; - } + 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 */ } - if (*ofd != -1) { - Dmsg1(100, "SetFileTime %s\n", ofile); - stat = SetFileTime(get_osfhandle(*ofd), - &atts.ftCreationTime, - &atts.ftLastAccessTime, - &atts.ftLastWriteTime); - if (stat != 1) { - win_error(jcr, "SetFileTime:", ofile); + if (is_bopen(ofd)) { + Dmsg1(100, "SetFileTime %s\n", attr->ofname); + if (!SetFileTime(bget_handle(ofd), + &atts.ftCreationTime, + &atts.ftLastAccessTime, + &atts.ftLastWriteTime)) { + win_error(jcr, "SetFileTime:", win32_ofile); } - close(*ofd); - *ofd = -1; + bclose(ofd); } - /* Bash name to Windows format */ - unix_name_to_win32(ofile); - Dmsg1(100, "SetFileAtts %s\n", ofile); - stat = SetFileAttributes(ofile, atts.dwFileAttributes & SET_ATTRS); - if (stat != 1) { - win_error(jcr, "SetFileAttributes:", ofile); + Dmsg1(100, "SetFileAtts %s\n", attr->ofname); + 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); + } + } } - return 1; + free_pool_memory(win32_ofile); + return true; } -void win_error(void *vjcr, char *prefix, char *ofile) +void win_error(JCR *jcr, char *prefix, POOLMEM *win32_ofile) { - JCR *jcr = (JCR *)vjcr; DWORD lerror = GetLastError(); LPTSTR msg; FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER| - FORMAT_MESSAGE_FROM_SYSTEM, - NULL, - lerror, - 0, - (LPTSTR)&msg, - 0, - NULL); - Dmsg3(100, "Error in %s on file %s: ERR=%s\n", prefix, ofile, msg); - Jmsg3(jcr, M_INFO, 0, "Error in %s file %s: ERR=%s\n", prefix, ofile, msg); + 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); LocalFree(msg); } -void unix_name_to_win32(char *name) +void win_error(JCR *jcr, char *prefix, DWORD lerror) { - char *p; - for (p=name; *p; p++) { - if (*p == '/') { - *p = '\\'; - } + LPTSTR msg; + FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER| + 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); + } else { + MessageBox(NULL, msg, prefix, MB_OK); } + LocalFree(msg); } - -#endif /* HAVE_CYGWIN */ +#endif /* HAVE_WIN32 */