From: Thorsten Engel Date: Mon, 2 May 2005 14:37:22 +0000 (+0000) Subject: UTF-8 support for win32 finished X-Git-Tag: Release-1.38.0~521 X-Git-Url: https://git.sur5r.net/?a=commitdiff_plain;h=c48c940a088f2bfe2c60e63e549f4d6b694805ec;p=bacula%2Fbacula UTF-8 support for win32 finished git-svn-id: https://bacula.svn.sourceforge.net/svnroot/bacula/trunk@1977 91ce42f0-d328-0410-95d8-f526ca767f89 --- diff --git a/bacula/src/filed/status.c b/bacula/src/filed/status.c index 8e8f40bb17..7fa0829aa0 100755 --- a/bacula/src/filed/status.c +++ b/bacula/src/filed/status.c @@ -70,20 +70,53 @@ static void do_status(void sendit(const char *msg, int len, void *sarg), void *a dt, num_jobs_run, num_jobs_run == 1 ? "" : "s"); sendit(msg, len, arg); #if defined(HAVE_CYGWIN) || defined(HAVE_WIN32) - if (debug_level > 0) { + if (/*debug_level > 0*/ true) { if (!privs) { privs = enable_backup_privileges(NULL, 1); } len = Mmsg(msg, - _(" Priv 0x%x APIs=%sOPT,%sATP,%sLPV,%sGFAEA,%sGFAEW,%sBR,%sBW,%sSPSP\n"), privs, + _(" Priv 0x%x\n APIs=%sOPT,%sATP,%sLPV,%sCFA,%sCFW,\n" + " %sWUL,%sWMKD,%sWOP,%sGFAA,%sGFAW,%sGFAEA,%sGFAEW,%sSFAA,%sSFAW,%sBR,%sBW,%sSPSP,\n" + " %sWC2MB,%sMB2WC,%sFFFA,%sFFFW,%sFNFA,%sFNFW,%sSCDA,%sSCDW,\n" + " %sGCDA,%sGCDW\n"), + privs, p_OpenProcessToken?"":"!", p_AdjustTokenPrivileges?"":"!", p_LookupPrivilegeValue?"":"!", - p_GetFileAttributesExA?"":"!", + + p_CreateFileA?"":"!", + p_CreateFileW?"":"!", + + p_wunlink?"":"!", + p_wmkdir?"":"!", + p_wopen?"":"!", + + p_GetFileAttributesA?"":"!", + p_GetFileAttributesW?"":"!", + + p_GetFileAttributesExA?"":"!", p_GetFileAttributesExW?"":"!", + + p_SetFileAttributesA?"":"!", + p_SetFileAttributesW?"":"!", p_BackupRead?"":"!", p_BackupWrite?"":"!", - p_SetProcessShutdownParameters?"":"!"); + p_SetProcessShutdownParameters?"":"!", + + p_WideCharToMultiByte?"":"!", + p_MultiByteToWideChar?"":"!", + + p_FindFirstFileA?"":"!", + p_FindFirstFileW?"":"!", + + p_FindNextFileA?"":"!", + p_FindNextFileW?"":"!", + + p_SetCurrentDirectoryA?"":"!", + p_SetCurrentDirectoryW?"":"!", + + p_GetCurrentDirectoryA?"":"!", + p_GetCurrentDirectoryW?"":"!"); sendit(msg, len, arg); } #endif diff --git a/bacula/src/filed/win32/winmain.cpp b/bacula/src/filed/win32/winmain.cpp index 5e21221733..95b843da62 100755 --- a/bacula/src/filed/win32/winmain.cpp +++ b/bacula/src/filed/win32/winmain.cpp @@ -299,23 +299,82 @@ void *Main_Msg_Loop(LPVOID lpwThreadParam) */ int BaculaAppMain() { -/* DWORD dwThreadID; */ + /* DWORD dwThreadID; */ pthread_t tid; - WSA_Init(); - HINSTANCE hLib = LoadLibrary("KERNEL32.DLL"); + + HMODULE hLib = LoadLibrary("KERNEL32.DLL"); if (hLib) { + /* create file calls */ + p_CreateFileA = (t_CreateFileA) + GetProcAddress(hLib, "CreateFileA"); + p_CreateFileW = (t_CreateFileW) + GetProcAddress(hLib, "CreateFileW"); + + /* attribute calls */ + p_GetFileAttributesA = (t_GetFileAttributesA) + GetProcAddress(hLib, "GetFileAttributesA"); + p_GetFileAttributesW = (t_GetFileAttributesW) + GetProcAddress(hLib, "GetFileAttributesW"); p_GetFileAttributesExA = (t_GetFileAttributesExA) GetProcAddress(hLib, "GetFileAttributesExA"); - p_GetFileAttributesExW = (t_GetFileAttributesExW) + p_GetFileAttributesExW = (t_GetFileAttributesExW) GetProcAddress(hLib, "GetFileAttributesExW"); + p_SetFileAttributesA = (t_SetFileAttributesA) + GetProcAddress(hLib, "SetFileAttributesA"); + p_SetFileAttributesW = (t_SetFileAttributesW) + GetProcAddress(hLib, "SetFileAttributesW"); + /* process calls */ p_SetProcessShutdownParameters = (t_SetProcessShutdownParameters) GetProcAddress(hLib, "SetProcessShutdownParameters"); + /* backup calls */ p_BackupRead = (t_BackupRead) GetProcAddress(hLib, "BackupRead"); p_BackupWrite = (t_BackupWrite) GetProcAddress(hLib, "BackupWrite"); + /* char conversion calls */ + p_WideCharToMultiByte = (t_WideCharToMultiByte) + GetProcAddress(hLib, "WideCharToMultiByte"); + p_MultiByteToWideChar = (t_MultiByteToWideChar) + GetProcAddress(hLib, "MultiByteToWideChar"); + + /* find files */ + p_FindFirstFileA = (t_FindFirstFileA) + GetProcAddress(hLib, "FindFirstFileA"); + p_FindFirstFileW = (t_FindFirstFileW) + GetProcAddress(hLib, "FindFirstFileW"); + p_FindNextFileA = (t_FindNextFileA) + GetProcAddress(hLib, "FindNextFileA"); + p_FindNextFileW = (t_FindNextFileW) + GetProcAddress(hLib, "FindNextFileW"); + /* set and get directory */ + p_SetCurrentDirectoryA = (t_SetCurrentDirectoryA) + GetProcAddress(hLib, "SetCurrentDirectoryA"); + p_SetCurrentDirectoryW = (t_SetCurrentDirectoryW) + GetProcAddress(hLib, "SetCurrentDirectoryW"); + p_GetCurrentDirectoryA = (t_GetCurrentDirectoryA) + GetProcAddress(hLib, "GetCurrentDirectoryA"); + p_GetCurrentDirectoryW = (t_GetCurrentDirectoryW) + GetProcAddress(hLib, "GetCurrentDirectoryW"); + FreeLibrary(hLib); + } + + + hLib = LoadLibrary("MSVCRT.DLL"); + if (hLib) { + /* unlink */ + p_wunlink = (t_wunlink) + GetProcAddress(hLib, "_wunlink"); + /* wmkdir */ + p_wmkdir = (t_wmkdir) + GetProcAddress(hLib, "_wmkdir"); + /* wopen */ + p_wopen = (t_wopen) + GetProcAddress(hLib, "_wopen"); + FreeLibrary(hLib); } + + hLib = LoadLibrary("ADVAPI32.DLL"); if (hLib) { p_OpenProcessToken = (t_OpenProcessToken) @@ -326,6 +385,8 @@ int BaculaAppMain() GetProcAddress(hLib, "LookupPrivilegeValueA"); FreeLibrary(hLib); } + + WSA_Init(); /* * Even if these are defined, don't use on old * platforms. @@ -333,6 +394,21 @@ int BaculaAppMain() if (bacService::IsWin95()) { p_BackupRead = NULL; p_BackupWrite = NULL; + + p_CreateFileW = NULL; + p_GetFileAttributesW = NULL; + p_GetFileAttributesExW = NULL; + + p_SetFileAttributesW = NULL; + + p_FindFirstFileW = NULL; + p_FindNextFileW = NULL; + p_SetCurrentDirectoryW = NULL; + p_GetCurrentDirectoryW = NULL; + + p_wunlink = NULL; + p_wmkdir = NULL; + p_wopen = NULL; } /* Set this process to be the last application to be shut down. */ @@ -347,6 +423,7 @@ int BaculaAppMain() _exit(0); } + /* Create a thread to handle the Windows messages */ // (void)CreateThread(NULL, 0, Main_Msg_Loop, NULL, 0, &dwThreadID); pthread_create(&tid, NULL, Main_Msg_Loop, (void *)0); diff --git a/bacula/src/findlib/attribs.c b/bacula/src/findlib/attribs.c index 7fde03798f..3079d00cc4 100755 --- a/bacula/src/findlib/attribs.c +++ b/bacula/src/findlib/attribs.c @@ -48,9 +48,9 @@ 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 *** */ +/* */ /*=============================================================*/ /* @@ -72,11 +72,11 @@ int select_data_stream(FF_PKT *ff_pkt) #ifdef HAVE_LIBZ if (ff_pkt->flags & FO_GZIP) { if (stream == STREAM_WIN32_DATA) { - stream = STREAM_WIN32_GZIP_DATA; + stream = STREAM_WIN32_GZIP_DATA; } else if (stream == STREAM_FILE_DATA) { - stream = STREAM_GZIP_DATA; + stream = STREAM_GZIP_DATA; } else { - stream = STREAM_SPARSE_GZIP_DATA; + stream = STREAM_SPARSE_GZIP_DATA; } } #endif @@ -101,7 +101,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 */ @@ -154,7 +154,7 @@ 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 */ +#define plug(st, val) st = val /* brain damaged compiler */ #else template void plug(T &st, uint64_t val) { st = static_cast(val); } @@ -252,32 +252,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) == ' ')) { @@ -295,7 +295,7 @@ int32_t decode_LinkFI(char *buf, struct stat *statp) * 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) { @@ -308,7 +308,7 @@ bool set_attributes(JCR *jcr, ATTR *attr, BFILE *ofd) 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*"); return true; @@ -316,7 +316,7 @@ bool set_attributes(JCR *jcr, ATTR *attr, BFILE *ofd) 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*"); return true; @@ -334,11 +334,11 @@ bool set_attributes(JCR *jcr, ATTR *attr, BFILE *ofd) if (is_bopen(ofd)) { char ec1[50], ec2[50]; fsize = blseek(ofd, 0, SEEK_CUR); - bclose(ofd); /* first close file */ - if (fsize > 0 && fsize != (off_t)attr->statp.st_size) { + bclose(ofd); /* first close file */ + if (fsize > 0 && fsize != 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)); + attr->ofname, edit_uint64(attr->statp.st_size, ec1), + edit_uint64(fsize, ec2)); } } @@ -348,38 +348,38 @@ bool set_attributes(JCR *jcr, ATTR *attr, BFILE *ofd) /* ***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 /* @@ -390,10 +390,10 @@ 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 } @@ -404,9 +404,9 @@ bool set_attributes(JCR *jcr, ATTR *attr, BFILE *ofd) /*=============================================================*/ -/* */ -/* * * * U n i x * * * * */ -/* */ +/* */ +/* * * * U n i x * * * * */ +/* */ /*=============================================================*/ #if !defined(HAVE_CYGWIN) && !defined(HAVE_WIN32) @@ -417,7 +417,7 @@ bool set_attributes(JCR *jcr, ATTR *attr, BFILE *ofd) * 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) @@ -434,7 +434,7 @@ int encode_attribsEx(JCR *jcr, char *attribsEx, FF_PKT *ff_pkt) } *p = 0; #else - *attribsEx = 0; /* no extended attributes */ + *attribsEx = 0; /* no extended attributes */ #endif return STREAM_UNIX_ATTRIBUTES; } @@ -444,9 +444,9 @@ 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) @@ -457,34 +457,33 @@ 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 */ + attribsEx[0] = 0; /* no extended attributes */ -#if USE_WIN32_UNICODE - if (!p_GetFileAttributesExW) - return STREAM_UNIX_ATTRIBUTES; + // try unicode version + if (p_GetFileAttributesExW) { + unix_name_to_win32(&ff_pkt->sys_fname, ff_pkt->fname); - unix_name_to_win32(&ff_pkt->sys_fname, ff_pkt->fname); + WCHAR szBuf[MAX_PATH_UNICODE]; + UTF8_2_wchar(szBuf, ff_pkt->sys_fname, MAX_PATH_UNICODE); - WCHAR szBuf[MAX_PATH_UNICODE]; - UTF8_2_wchar(szBuf, ff_pkt->sys_fname, MAX_PATH_UNICODE); - - if (!p_GetFileAttributesExW(szBuf, GetFileExInfoStandard, - (LPVOID)&atts)) { - win_error(jcr, "GetFileAttributesExW:", ff_pkt->sys_fname); - return STREAM_UNIX_ATTRIBUTES; + if (!p_GetFileAttributesExW(szBuf, GetFileExInfoStandard, + (LPVOID)&atts)) { + win_error(jcr, "GetFileAttributesExW:", ff_pkt->sys_fname); + return STREAM_UNIX_ATTRIBUTES; + } } -#else - if (!p_GetFileAttributesExA) - return STREAM_UNIX_ATTRIBUTES; + else { + if (!p_GetFileAttributesExA) + return STREAM_UNIX_ATTRIBUTES; - unix_name_to_win32(&ff_pkt->sys_fname, ff_pkt->fname); + unix_name_to_win32(&ff_pkt->sys_fname, ff_pkt->fname); - if (!p_GetFileAttributesExA(ff_pkt->sys_fname, GetFileExInfoStandard, - (LPVOID)&atts)) { - win_error(jcr, "GetFileAttributesExA:", ff_pkt->sys_fname); - 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; + } } -#endif p += to_base64((uint64_t)atts.dwFileAttributes, p); *p++ = ' '; /* separate fields with a space */ @@ -516,7 +515,7 @@ 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) /* @@ -526,7 +525,7 @@ int encode_attribsEx(JCR *jcr, char *attribsEx, FF_PKT *ff_pkt) * 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) { @@ -536,19 +535,14 @@ static bool set_win32_attributes(JCR *jcr, ATTR *attr, BFILE *ofd) ULARGE_INTEGER li; POOLMEM *win32_ofile; -#if USE_WIN32_UNICODE - if (!p_GetFileAttributesExW) + // if we have neither ansi nor wchar version, we leave + if (!(p_SetFileAttributesW || p_SetFileAttributesA)) return false; -#else - if (!p_GetFileAttributesExA) - return false; -#endif - - 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 { @@ -557,17 +551,17 @@ 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; @@ -589,15 +583,15 @@ static bool set_win32_attributes(JCR *jcr, ATTR *attr, BFILE *ofd) 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); @@ -606,16 +600,18 @@ static bool set_win32_attributes(JCR *jcr, ATTR *attr, BFILE *ofd) Dmsg1(100, "SetFileAtts %s\n", attr->ofname); if (!(atts.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) { -#if USE_WIN32_UNICODE + if (p_SetFileAttributesW) { WCHAR szBuf[MAX_PATH_UNICODE]; UTF8_2_wchar(szBuf, win32_ofile, MAX_PATH_UNICODE); if (!SetFileAttributesW(szBuf, atts.dwFileAttributes & SET_ATTRS)) { win_error(jcr, "SetFileAttributesW:", win32_ofile); -#else + } + } + else { if (!SetFileAttributes(win32_ofile, atts.dwFileAttributes & SET_ATTRS)) { win_error(jcr, "SetFileAttributesA:", win32_ofile); -#endif + } } } free_pool_memory(win32_ofile); @@ -627,13 +623,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); @@ -644,13 +640,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); @@ -671,4 +667,4 @@ void unix_name_to_win32(POOLMEM **win32_name, char *name) cygwin_conv_to_win32_path(name, *win32_name); } -#endif /* HAVE_CYGWIN */ +#endif /* HAVE_CYGWIN */ diff --git a/bacula/src/findlib/bfile.c b/bacula/src/findlib/bfile.c index 2e2ae4f608..b89d77698e 100644 --- a/bacula/src/findlib/bfile.c +++ b/bacula/src/findlib/bfile.c @@ -212,15 +212,18 @@ int bopen(BFILE *bfd, const char *fname, int flags, mode_t mode) { POOLMEM *win32_fname; DWORD dwaccess, dwflags, dwshare; + WCHAR win32_fname_wchar[MAX_PATH_UNICODE]; /* Convert to Windows path format */ win32_fname = get_pool_memory(PM_FNAME); unix_name_to_win32(&win32_fname, (char *)fname); -#if USE_WIN32_UNICODE - WCHAR win32_fname_wchar[MAX_PATH_UNICODE]; + if (!(p_CreateFileA || p_CreateFileW)) + return 0; + + if (p_CreateFileW){ UTF8_2_wchar(win32_fname_wchar, win32_fname, MAX_PATH_UNICODE); -#endif + } if (flags & O_CREAT) { /* Create */ if (bfd->use_backup_api) { @@ -231,18 +234,27 @@ int bopen(BFILE *bfd, const char *fname, int flags, mode_t mode) dwflags = 0; } - -#if USE_WIN32_UNICODE - bfd->fh = CreateFileW(win32_fname_wchar, -#else - bfd->fh = CreateFile(win32_fname, -#endif + // unicode or ansii open for create write + if (p_CreateFileW) { + bfd->fh = p_CreateFileW(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; } else if (flags & O_WRONLY) { /* Open existing for write */ @@ -254,17 +266,27 @@ int bopen(BFILE *bfd, const char *fname, int flags, mode_t mode) dwflags = 0; } -#if USE_WIN32_UNICODE - bfd->fh = CreateFileW(win32_fname_wchar, -#else - bfd->fh = CreateFile(win32_fname, -#endif + // unicode or ansii open for open existing write + if (p_CreateFileW) { + bfd->fh = p_CreateFileW(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; } else { /* Read */ @@ -278,17 +300,26 @@ int bopen(BFILE *bfd, const char *fname, int flags, mode_t mode) dwshare = FILE_SHARE_READ|FILE_SHARE_WRITE; } -#if USE_WIN32_UNICODE - bfd->fh = CreateFileW(win32_fname_wchar, -#else - bfd->fh = CreateFile(win32_fname, -#endif + // unicode or ansii open for open existing read + if (p_CreateFileW) { + bfd->fh = p_CreateFileW(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; } diff --git a/bacula/src/findlib/create_file.c b/bacula/src/findlib/create_file.c index b44fb5194e..0022bb8bd9 100644 --- a/bacula/src/findlib/create_file.c +++ b/bacula/src/findlib/create_file.c @@ -118,15 +118,19 @@ int create_file(JCR *jcr, ATTR *attr, BFILE *bfd, int replace) case FT_REG: /* regular file */ if (exists) { /* Get rid of old copy */ + int nRetCode; - -#if USE_WIN32_UNICODE + if (p_wunlink) + { WCHAR szBuf[MAX_PATH_UNICODE]; UTF8_2_wchar(szBuf, attr->ofname, MAX_PATH_UNICODE); - if (_wunlink(szBuf) == -1) { -#else - if (unlink(attr->ofname) == -1) { -#endif + + nRetCode = _wunlink(szBuf); + } + else + nRetCode = unlink(attr->ofname); + + if (nRetCode == -1) { berrno be; Jmsg(jcr, M_ERROR, 0, _("File %s already exists and could not be replaced. ERR=%s.\n"), attr->ofname, be.strerror()); diff --git a/bacula/src/findlib/winapi.c b/bacula/src/findlib/winapi.c index 212196b317..e5d3483351 100644 --- a/bacula/src/findlib/winapi.c +++ b/bacula/src/findlib/winapi.c @@ -36,10 +36,36 @@ t_OpenProcessToken p_OpenProcessToken = NULL; t_AdjustTokenPrivileges p_AdjustTokenPrivileges = NULL; t_LookupPrivilegeValue p_LookupPrivilegeValue = NULL; +t_SetProcessShutdownParameters p_SetProcessShutdownParameters = NULL; + +t_CreateFileA p_CreateFileA = NULL; +t_CreateFileW p_CreateFileW = NULL; + +t_wunlink p_wunlink = NULL; +t_wmkdir p_wmkdir = NULL; +t_wopen p_wopen = NULL; +t_GetFileAttributesA p_GetFileAttributesA = NULL; +t_GetFileAttributesW p_GetFileAttributesW = NULL; + t_GetFileAttributesExA p_GetFileAttributesExA = NULL; t_GetFileAttributesExW p_GetFileAttributesExW = NULL; + +t_SetFileAttributesA p_SetFileAttributesA = NULL; +t_SetFileAttributesW p_SetFileAttributesW = NULL; t_BackupRead p_BackupRead = NULL; t_BackupWrite p_BackupWrite = NULL; -t_SetProcessShutdownParameters p_SetProcessShutdownParameters = NULL; +t_WideCharToMultiByte p_WideCharToMultiByte = NULL; +t_MultiByteToWideChar p_MultiByteToWideChar = NULL; + +t_FindFirstFileA p_FindFirstFileA = NULL; +t_FindFirstFileW p_FindFirstFileW = NULL; + +t_FindNextFileA p_FindNextFileA = NULL; +t_FindNextFileW p_FindNextFileW = NULL; + +t_SetCurrentDirectoryA p_SetCurrentDirectoryA = NULL; +t_SetCurrentDirectoryW p_SetCurrentDirectoryW = NULL; +t_GetCurrentDirectoryA p_GetCurrentDirectoryA = NULL; +t_GetCurrentDirectoryW p_GetCurrentDirectoryW = NULL; #endif diff --git a/bacula/src/findlib/winapi.h b/bacula/src/findlib/winapi.h index e4e331ea6e..69194e75d6 100644 --- a/bacula/src/findlib/winapi.h +++ b/bacula/src/findlib/winapi.h @@ -47,22 +47,80 @@ extern t_OpenProcessToken p_OpenProcessToken; extern t_AdjustTokenPrivileges p_AdjustTokenPrivileges; extern t_LookupPrivilegeValue p_LookupPrivilegeValue; +/* In MSVCRT.DLL */ +typedef int (__cdecl * t_wunlink) (const wchar_t *); +typedef int (__cdecl * t_wmkdir) (const wchar_t *); +typedef int (__cdecl * t_wopen) (const wchar_t *, int, ...); + +extern t_wunlink p_wunlink; +extern t_wmkdir p_wmkdir; +extern t_wopen p_wopen; /* In KERNEL32.DLL */ typedef BOOL (WINAPI * t_GetFileAttributesExA)(LPCSTR, GET_FILEEX_INFO_LEVELS, LPVOID); typedef BOOL (WINAPI * t_GetFileAttributesExW)(LPCWSTR, GET_FILEEX_INFO_LEVELS, LPVOID); + +typedef DWORD (WINAPI * t_GetFileAttributesA)(LPCSTR); +typedef DWORD (WINAPI * t_GetFileAttributesW)(LPCWSTR); +typedef BOOL (WINAPI * t_SetFileAttributesA)(LPCSTR, DWORD); +typedef BOOL (WINAPI * t_SetFileAttributesW)(LPCWSTR, DWORD); + +typedef HANDLE (WINAPI * t_CreateFileA) (LPCSTR, DWORD ,DWORD, LPSECURITY_ATTRIBUTES, + DWORD , DWORD, HANDLE); +typedef HANDLE (WINAPI * t_CreateFileW) (LPCWSTR, DWORD ,DWORD, LPSECURITY_ATTRIBUTES, + DWORD , DWORD, HANDLE); + typedef BOOL (WINAPI * t_SetProcessShutdownParameters)(DWORD, DWORD); typedef BOOL (WINAPI * t_BackupRead)(HANDLE,LPBYTE,DWORD,LPDWORD,BOOL,BOOL,LPVOID*); typedef BOOL (WINAPI * t_BackupWrite)(HANDLE,LPBYTE,DWORD,LPDWORD,BOOL,BOOL,LPVOID*); +typedef int (WINAPI * t_WideCharToMultiByte) (UINT CodePage, DWORD , LPCWSTR, int, + LPSTR, int, LPCSTR, LPBOOL); + +typedef int (WINAPI * t_MultiByteToWideChar) (UINT, DWORD, LPCSTR, int, LPWSTR, int); + +typedef HANDLE (WINAPI * t_FindFirstFileA) (LPCSTR, LPWIN32_FIND_DATAA); +typedef HANDLE (WINAPI * t_FindFirstFileW) (LPCWSTR, LPWIN32_FIND_DATAW); + +typedef BOOL (WINAPI * t_FindNextFileA) (HANDLE, LPWIN32_FIND_DATAA); +typedef BOOL (WINAPI * t_FindNextFileW) (HANDLE, LPWIN32_FIND_DATAW); + +typedef BOOL (WINAPI * t_SetCurrentDirectoryA) (LPCSTR); +typedef BOOL (WINAPI * t_SetCurrentDirectoryW) (LPCWSTR); + +typedef DWORD (WINAPI * t_GetCurrentDirectoryA) (DWORD, LPSTR); +typedef DWORD (WINAPI * t_GetCurrentDirectoryW) (DWORD, LPWSTR); + +extern t_GetFileAttributesA p_GetFileAttributesA; +extern t_GetFileAttributesW p_GetFileAttributesW; + extern t_GetFileAttributesExA p_GetFileAttributesExA; extern t_GetFileAttributesExW p_GetFileAttributesExW; + +extern t_SetFileAttributesA p_SetFileAttributesA; +extern t_SetFileAttributesW p_SetFileAttributesW; + +extern t_CreateFileA p_CreateFileA; +extern t_CreateFileW p_CreateFileW; extern t_SetProcessShutdownParameters p_SetProcessShutdownParameters; extern t_BackupRead p_BackupRead; extern t_BackupWrite p_BackupWrite; +extern t_WideCharToMultiByte p_WideCharToMultiByte; +extern t_MultiByteToWideChar p_MultiByteToWideChar; + +extern t_FindFirstFileA p_FindFirstFileA; +extern t_FindFirstFileW p_FindFirstFileW; + +extern t_FindNextFileA p_FindNextFileA; +extern t_FindNextFileW p_FindNextFileW; + +extern t_SetCurrentDirectoryA p_SetCurrentDirectoryA; +extern t_SetCurrentDirectoryW p_SetCurrentDirectoryW; +extern t_GetCurrentDirectoryA p_GetCurrentDirectoryA; +extern t_GetCurrentDirectoryW p_GetCurrentDirectoryW; #endif #endif /* __WINAPI_H */ diff --git a/bacula/src/win32/compat/compat.cpp b/bacula/src/win32/compat/compat.cpp index 01e89040f7..887fe4438c 100644 --- a/bacula/src/win32/compat/compat.cpp +++ b/bacula/src/win32/compat/compat.cpp @@ -30,6 +30,7 @@ #include "compat.h" #include "pthread.h" +#include "../../findlib/winapi.h" #define b_errno_win32 (1<<29) @@ -72,26 +73,29 @@ cygwin_conv_to_win32_path(const char *name, char *win32_name) } } -#if USE_WIN32_UNICODE - int wchar_2_UTF8(char *pszUTF, const WCHAR *pszUCS, int cchChar) { - /* the return value is the number of bytes written to the buffer. - The number includes the byte for the null terminator. */ + /* the return value is the number of bytes written to the buffer. + The number includes the byte for the null terminator. */ - return WideCharToMultiByte (CP_UTF8,0,pszUCS,-1,pszUTF,cchChar,NULL,NULL); + if (p_WideCharToMultiByte) + return p_WideCharToMultiByte(CP_UTF8,0,pszUCS,-1,pszUTF,cchChar,NULL,NULL); + else + return NULL; } int UTF8_2_wchar(WCHAR *pszUCS, const char *pszUTF, int cchWideChar) { - /* the return value is the number of wide characters written to the buffer. */ - /* convert null terminated string from utf-8 to ucs2*/ - return MultiByteToWideChar(CP_UTF8, 0, pszUTF, -1, pszUCS,cchWideChar); -} + /* the return value is the number of wide characters written to the buffer. */ + /* convert null terminated string from utf-8 to ucs2*/ -#endif + if (p_MultiByteToWideChar) + return p_MultiByteToWideChar(CP_UTF8, 0, pszUTF, -1, pszUCS,cchWideChar); + else + return NULL; +} void @@ -212,13 +216,18 @@ errorString(void) static int statDir(const char *file, struct stat *sb) { -#if USE_WIN32_UNICODE - WIN32_FIND_DATAW info; // window's file info -#else - WIN32_FIND_DATA info; // window's file info -#endif + WIN32_FIND_DATAW info_w; // window's file info + WIN32_FIND_DATA info_a; // window's file info + + // cache some common vars to make code more transparent + DWORD* pdwFileAttributes; + DWORD* pnFileSizeHigh; + DWORD* pnFileSizeLow; + FILETIME* pftLastAccessTime; + FILETIME* pftLastWriteTime; + FILETIME* pftCreationTime; - if (file[1] == ':' && file[2] == 0) { + if (file[1] == ':' && file[2] == 0) { d_msg(__FILE__, __LINE__, 99, "faking ROOT attrs(%s).\n", file); sb->st_mode = S_IFDIR; sb->st_mode |= S_IREAD|S_IEXEC|S_IWRITE; @@ -228,14 +237,32 @@ statDir(const char *file, struct stat *sb) return 0; } -#if USE_WIN32_UNICODE - WCHAR szBuf[MAX_PATH_UNICODE]; - UTF8_2_wchar(szBuf, file, MAX_PATH_UNICODE); - - HANDLE h = FindFirstFileW(szBuf, &info); -#else - HANDLE h = FindFirstFile(file, &info); -#endif + HANDLE h = INVALID_HANDLE_VALUE; + + // use unicode or ascii + if (p_FindFirstFileW) { + WCHAR szBuf[MAX_PATH_UNICODE]; + UTF8_2_wchar(szBuf, file, MAX_PATH_UNICODE); + + h = p_FindFirstFileW(szBuf, &info_w); + + pdwFileAttributes = &info_w.dwFileAttributes; + pnFileSizeHigh = &info_w.nFileSizeHigh; + pnFileSizeLow = &info_w.nFileSizeLow; + pftLastAccessTime = &info_w.ftLastAccessTime; + pftLastWriteTime = &info_w.ftLastWriteTime; + pftCreationTime = &info_w.ftCreationTime; + } + else if (p_FindFirstFileA) { + h = p_FindFirstFileA(file, &info_a); + + pdwFileAttributes = &info_a.dwFileAttributes; + pnFileSizeHigh = &info_a.nFileSizeHigh; + pnFileSizeLow = &info_a.nFileSizeLow; + pftLastAccessTime = &info_a.ftLastAccessTime; + pftLastWriteTime = &info_a.ftLastWriteTime; + pftCreationTime = &info_a.ftCreationTime; + } if (h == INVALID_HANDLE_VALUE) { const char *err = errorString(); @@ -246,23 +273,23 @@ statDir(const char *file, struct stat *sb) } sb->st_mode = 0777; /* start with everything */ - if (info.dwFileAttributes & FILE_ATTRIBUTE_READONLY) + if (*pdwFileAttributes & FILE_ATTRIBUTE_READONLY) sb->st_mode &= ~(S_IRUSR|S_IRGRP|S_IROTH); - if (info.dwFileAttributes & FILE_ATTRIBUTE_SYSTEM) + if (*pdwFileAttributes & FILE_ATTRIBUTE_SYSTEM) sb->st_mode &= ~S_IRWXO; /* remove everything for other */ - if (info.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN) + if (*pdwFileAttributes & FILE_ATTRIBUTE_HIDDEN) sb->st_mode |= S_ISVTX; /* use sticky bit -> hidden */ sb->st_mode |= S_IFDIR; - sb->st_size = info.nFileSizeHigh; + sb->st_size = *pnFileSizeHigh; sb->st_size <<= 32; - sb->st_size |= info.nFileSizeLow; + sb->st_size |= *pnFileSizeLow; sb->st_blksize = 4096; sb->st_blocks = (uint32_t)(sb->st_size + 4095)/4096; - sb->st_atime = cvt_ftime_to_utime(info.ftLastAccessTime); - sb->st_mtime = cvt_ftime_to_utime(info.ftLastWriteTime); - sb->st_ctime = cvt_ftime_to_utime(info.ftCreationTime); + sb->st_atime = cvt_ftime_to_utime(*pftLastAccessTime); + sb->st_mtime = cvt_ftime_to_utime(*pftLastWriteTime); + sb->st_ctime = cvt_ftime_to_utime(*pftCreationTime); FindClose(h); return 0; @@ -277,14 +304,17 @@ stat2(const char *file, struct stat *sb) char tmpbuf[1024]; cygwin_conv_to_win32_path(file, tmpbuf); -#if USE_WIN32_UNICODE - WCHAR szBuf[MAX_PATH_UNICODE]; - UTF8_2_wchar(szBuf, tmpbuf, MAX_PATH_UNICODE); - - DWORD attr = GetFileAttributesW(szBuf); -#else - DWORD attr = GetFileAttributes(tmpbuf); -#endif + DWORD attr = -1; + + if (p_GetFileAttributesW) { + WCHAR szBuf[MAX_PATH_UNICODE]; + UTF8_2_wchar(szBuf, tmpbuf, MAX_PATH_UNICODE); + + attr = p_GetFileAttributesW(szBuf); + } + else if (p_GetFileAttributesA) { + attr = p_GetFileAttributesA(tmpbuf); + } if (attr == -1) { const char *err = errorString(); @@ -378,15 +408,19 @@ stat(const char *file, struct stat *sb) if (!GetFileAttributesExW((WCHAR *)buf, GetFileExInfoStandard, &data)) return stat2(file, sb); #else -#if USE_WIN32_UNICODE - WCHAR buf[MAX_PATH_UNICODE]; - UTF8_2_wchar(buf, file, MAX_PATH_UNICODE); - if (!GetFileAttributesExW(buf, GetFileExInfoStandard, &data)) - return stat2(file, sb); -#else - if (!GetFileAttributesEx(file, GetFileExInfoStandard, &data)) - return stat2(file, sb); -#endif + + if (p_GetFileAttributesExW) { + WCHAR buf[MAX_PATH_UNICODE]; + UTF8_2_wchar(buf, file, MAX_PATH_UNICODE); + if (!p_GetFileAttributesExW(buf, GetFileExInfoStandard, &data)) + return stat2(file, sb); + } else if (p_GetFileAttributesExA) { + if (!p_GetFileAttributesExA(file, GetFileExInfoStandard, &data)) + return stat2(file, sb); + } + else + return stat2(file, sb); + #endif sb->st_mode = 0777; /* start with everything */ @@ -566,16 +600,15 @@ getgrgid(uid_t) } // implement opendir/readdir/closedir on top of window's API + typedef struct _dir { -#if USE_WIN32_UNICODE - WIN32_FIND_DATAW data; // window's file info -#else - WIN32_FIND_DATA data; // window's file info -#endif + WIN32_FIND_DATA data_a; // window's file info (ansii version) + WIN32_FIND_DATAW data_w; // window's file info (wchar version) const char *spec; // the directory we're traversing HANDLE dirh; // the search handle - BOOL valid; // the info in data field is valid + BOOL valid_a; // the info in data_a field is valid + BOOL valid_w; // the info in data_w field is valid UINT32 offset; // pseudo offset for d_off } _dir; @@ -590,6 +623,7 @@ opendir(const char *path) } rval = (_dir *)malloc(sizeof(_dir)); + memset (rval, 0, sizeof (_dir)); if (rval == NULL) return NULL; char *tspec = (char *)malloc(max_len); if (tspec == NULL) return NULL; @@ -609,14 +643,21 @@ opendir(const char *path) strncat(tspec, "\\*", max_len); rval->spec = tspec; - // convert to WCHAR -#if USE_WIN32_UNICODE - WCHAR wcBuf[MAX_PATH_UNICODE]; - UTF8_2_wchar(wcBuf,rval->spec, MAX_PATH_UNICODE); - rval->dirh = FindFirstFileW(wcBuf, &rval->data); -#else - rval->dirh = FindFirstFile(rval->spec, &rval->data); -#endif + // convert to WCHAR + if (p_FindFirstFileW) { + WCHAR wcBuf[MAX_PATH_UNICODE]; + UTF8_2_wchar(wcBuf,rval->spec, MAX_PATH_UNICODE); + rval->dirh = p_FindFirstFileW(wcBuf, &rval->data_w); + + if (rval->dirh != INVALID_HANDLE_VALUE) + rval->valid_w = 1; + } else if (p_FindFirstFileA) { + rval->dirh = p_FindFirstFileA(rval->spec, &rval->data_a); + + if (rval->dirh != INVALID_HANDLE_VALUE) + rval->valid_a = 1; + } else goto err; + d_msg(__FILE__, __LINE__, 99, "opendir(%s)\n\tspec=%s,\n\tFindFirstFile returns %d\n", @@ -625,9 +666,15 @@ opendir(const char *path) rval->offset = 0; if (rval->dirh == INVALID_HANDLE_VALUE) goto err; - rval->valid = 1; - d_msg(__FILE__, __LINE__, - 99, "\tFirstFile=%s\n", rval->data.cFileName); + + if (rval->valid_w) + d_msg(__FILE__, __LINE__, + 99, "\tFirstFile=%s\n", rval->data_w.cFileName); + + if (rval->valid_a) + d_msg(__FILE__, __LINE__, + 99, "\tFirstFile=%s\n", rval->data_a.cFileName); + return (DIR *)rval; err: @@ -680,33 +727,38 @@ int readdir_r(DIR *dirp, struct dirent *entry, struct dirent **result) { _dir *dp = (_dir *)dirp; - if (dp->valid) { - entry->d_off = dp->offset; + if (dp->valid_w || dp->valid_a) { + entry->d_off = dp->offset; -#if USE_WIN32_UNICODE - char szBuf[MAX_PATH_UTF8]; - wchar_2_UTF8(szBuf,dp->data.cFileName); - dp->offset += copyin(*entry, szBuf); -#else - dp->offset += copyin(*entry, dp->data.cFileName); -#endif + // copy unicode + if (dp->valid_w) { + char szBuf[MAX_PATH_UTF8]; + wchar_2_UTF8(szBuf,dp->data_w.cFileName); + dp->offset += copyin(*entry, szBuf); + } else if (dp->valid_a) { // copy ansi (only 1 will be valid) + dp->offset += copyin(*entry, dp->data_a.cFileName); + } - *result = entry; /* return entry address */ - d_msg(__FILE__, __LINE__, - 99, "readdir_r(%p, { d_name=\"%s\", d_reclen=%d, d_off=%d\n", - dirp, entry->d_name, entry->d_reclen, entry->d_off); + *result = entry; /* return entry address */ + d_msg(__FILE__, __LINE__, + 99, "readdir_r(%p, { d_name=\"%s\", d_reclen=%d, d_off=%d\n", + dirp, entry->d_name, entry->d_reclen, entry->d_off); } else { // d_msg(__FILE__, __LINE__, 99, "readdir_r !valid\n"); errno = b_errno_win32; return -1; } -#if USE_WIN32_UNICODE - dp->valid = FindNextFileW(dp->dirh, &dp->data); -#else - dp->valid = FindNextFileA(dp->dirh, &dp->data); -#endif - + // get next file, try unicode first + if (p_FindNextFileW) + dp->valid_w = p_FindNextFileW(dp->dirh, &dp->data_w); + else if (p_FindNextFileA) + dp->valid_a = p_FindNextFileA(dp->dirh, &dp->data_a); + else { + dp->valid_a = FALSE; + dp->valid_w = FALSE; + } + return 0; } @@ -805,48 +857,50 @@ WSA_Init(void) int win32_chdir(const char *dir) { -#if USE_WIN32_UNICODE - WCHAR szBuf[MAX_PATH_UNICODE]; - UTF8_2_wchar(szBuf, dir, MAX_PATH_UNICODE); + if (p_SetCurrentDirectoryW) { + WCHAR szBuf[MAX_PATH_UNICODE]; + UTF8_2_wchar(szBuf, dir, MAX_PATH_UNICODE); - if (0 == SetCurrentDirectoryW(szBuf)) { - errno = b_errno_win32; - return -1; - } -#else - if (0 == SetCurrentDirectoryA(dir)) { - errno = b_errno_win32; - return -1; - } -#endif + if (0 == p_SetCurrentDirectoryW(szBuf)) { + errno = b_errno_win32; + return -1; + } + } + else if (p_SetCurrentDirectoryA) { + if (0 == p_SetCurrentDirectoryA(dir)) { + errno = b_errno_win32; + return -1; + } + } + else return -1; - return 0; + return 0; } int win32_mkdir(const char *dir) { -#if USE_WIN32_UNICODE - WCHAR szBuf[MAX_PATH_UNICODE]; - UTF8_2_wchar(szBuf, dir, MAX_PATH_UNICODE); + if (p_wmkdir){ + WCHAR szBuf[MAX_PATH_UNICODE]; + UTF8_2_wchar(szBuf, dir, MAX_PATH_UNICODE); + return p_wmkdir(szBuf); + } - return _wmkdir(szBuf); -#else - return _mkdir(dir); -#endif + return _mkdir(dir); } char * win32_getcwd(char *buf, int maxlen) { -#if USE_WIN32_UNICODE - WCHAR szBuf[MAX_PATH_UNICODE]; - int n = GetCurrentDirectoryW(maxlen, szBuf); - n = wchar_2_UTF8 (buf, szBuf, maxlen)-1; -#else - int n = GetCurrentDirectory(maxlen, buf); -#endif + int n=0; + + if (p_GetCurrentDirectoryW) { + WCHAR szBuf[MAX_PATH_UNICODE]; + n = p_GetCurrentDirectoryW(maxlen, szBuf); + n = wchar_2_UTF8 (buf, szBuf, maxlen)-1; + } else if (p_GetCurrentDirectoryA) + n = p_GetCurrentDirectoryA(maxlen, buf); if (n == 0 || n > maxlen) return NULL; @@ -1279,29 +1333,28 @@ utime(const char *fname, struct utimbuf *times) cvt_utime_to_ftime(times->actime, acc); cvt_utime_to_ftime(times->modtime, mod); - -#if USE_WIN32_UNICODE - WCHAR szBuf[MAX_PATH_UNICODE]; - UTF8_2_wchar(szBuf, tmpbuf, MAX_PATH_UNICODE); - - HANDLE h = CreateFileW(szBuf, - FILE_WRITE_ATTRIBUTES, - FILE_SHARE_WRITE, - NULL, - OPEN_EXISTING, - 0, - NULL); -#else - HANDLE h = CreateFile(tmpbuf, - FILE_WRITE_ATTRIBUTES, - FILE_SHARE_WRITE, - NULL, - OPEN_EXISTING, - 0, - NULL); - -#endif - + HANDLE h = INVALID_HANDLE_VALUE; + + if (p_CreateFileW) { + WCHAR szBuf[MAX_PATH_UNICODE]; + UTF8_2_wchar(szBuf, tmpbuf, MAX_PATH_UNICODE); + + h = p_CreateFileW(szBuf, + FILE_WRITE_ATTRIBUTES, + FILE_SHARE_WRITE, + NULL, + OPEN_EXISTING, + 0, + NULL); + } else if (p_CreateFileA) { + h = CreateFile(tmpbuf, + FILE_WRITE_ATTRIBUTES, + FILE_SHARE_WRITE, + NULL, + OPEN_EXISTING, + 0, + NULL); + } if (h == INVALID_HANDLE_VALUE) { const char *err = errorString(); @@ -1325,14 +1378,14 @@ utime(const char *fname, struct utimbuf *times) int open(const char *file, int flags, int mode) { -#if USE_WIN32_UNICODE - WCHAR szBuf[MAX_PATH_UNICODE]; - UTF8_2_wchar(szBuf, file, MAX_PATH_UNICODE); + if (p_wopen) { + WCHAR szBuf[MAX_PATH_UNICODE]; + UTF8_2_wchar(szBuf, file, MAX_PATH_UNICODE); - return _wopen(szBuf, flags|_O_BINARY, mode); -#else - return _open(file, flags|_O_BINARY, mode); -#endif + return p_wopen(szBuf, flags|_O_BINARY, mode); + } + + return _open(file, flags|_O_BINARY, mode); } /* @@ -1380,7 +1433,7 @@ open(const char *file, int flags, int mode) DWORD shareMode = 0; DWORD create = 0; DWORD msflags = 0; - HANDLE foo; + HANDLE foo = INVALID_HANDLE_VALUE; const char *remap = file; if (flags & O_WRONLY) access = GENERIC_WRITE; @@ -1400,16 +1453,14 @@ open(const char *file, int flags, int mode) exit(-1); } - -#if USE_WIN32_UNICODE + if (p_CreateFileW) { WCHAR szBuf[MAX_PATH_UNICODE]; UTF8_2_wchar(szBuf, file, MAX_PATH_UNICODE); - foo = CreateFileW(szBuf, access, shareMode, NULL, create, msflags, NULL); -#else - foo = CreateFile(file, access, shareMode, NULL, create, msflags, NULL); -#endif - + foo = p_CreateFileW(szBuf, access, shareMode, NULL, create, msflags, NULL); + } + else if (p_CreateFileA) + foo = CreateFile(file, access, shareMode, NULL, create, msflags, NULL); if (INVALID_HANDLE_VALUE == foo) { errno = b_errno_win32; diff --git a/bacula/src/win32/compat/compat.h b/bacula/src/win32/compat/compat.h index 4ffb836b51..6c3a8dc5db 100644 --- a/bacula/src/win32/compat/compat.h +++ b/bacula/src/win32/compat/compat.h @@ -78,14 +78,9 @@ // unicode enabling of win 32 needs some defines and functions #define MAX_PATH_UNICODE 32767 #define MAX_PATH_UTF8 MAX_PATH*3 -#define USE_WIN32_UNICODE 1 -#if USE_WIN32_UNICODE int wchar_2_UTF8(char *pszUTF, const WCHAR *pszUCS, int cchChar = MAX_PATH_UTF8); int UTF8_2_wchar(WCHAR *pszUCS, const char *pszUTF, int cchWideChar = MAX_PATH); -#endif - - #ifndef HAVE_MINGW #ifdef HAVE_CYGWIN