static void InitializeGeneralDriveDialog(HWND hwndDlg, WCHAR * szDrive) { WCHAR szVolumeName[MAX_PATH+1] = {0}; DWORD MaxComponentLength = 0; DWORD FileSystemFlags = 0; WCHAR FileSystemName[MAX_PATH+1] = {0}; WCHAR szFormat[50]; WCHAR szBuffer[128]; BOOL ret; UINT DriveType; ULARGE_INTEGER FreeBytesAvailable; LARGE_INTEGER TotalNumberOfFreeBytes; LARGE_INTEGER TotalNumberOfBytes; ret = GetVolumeInformationW(szDrive, szVolumeName, MAX_PATH+1, NULL, &MaxComponentLength, &FileSystemFlags, FileSystemName, MAX_PATH+1); if (ret) { /* set volume label */ SendDlgItemMessageW(hwndDlg, 14000, WM_SETTEXT, (WPARAM)NULL, (LPARAM)szVolumeName); /* set filesystem type */ SendDlgItemMessageW(hwndDlg, 14002, WM_SETTEXT, (WPARAM)NULL, (LPARAM)FileSystemName); } DriveType = GetDriveTypeW(szDrive); if (DriveType == DRIVE_FIXED || DriveType == DRIVE_CDROM) { if(GetDiskFreeSpaceExW(szDrive, &FreeBytesAvailable, (PULARGE_INTEGER)&TotalNumberOfBytes, (PULARGE_INTEGER)&TotalNumberOfFreeBytes)) { WCHAR szResult[128]; LONGLONG Result; HANDLE hVolume; DWORD BytesReturned = 0; swprintf(szResult, L"\\\\.\\%c:", towupper(szDrive[0])); hVolume = CreateFileW(szResult, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL); if (hVolume != INVALID_HANDLE_VALUE) { ret = DeviceIoControl(hVolume, IOCTL_DISK_GET_LENGTH_INFO, NULL, 0, (LPVOID)&TotalNumberOfBytes, sizeof(ULARGE_INTEGER), &BytesReturned, NULL); if (ret && StrFormatByteSizeW(TotalNumberOfBytes.QuadPart, szResult, sizeof(szResult) / sizeof(WCHAR))) SendDlgItemMessageW(hwndDlg, 14007, WM_SETTEXT, (WPARAM)NULL, (LPARAM)szResult); CloseHandle(hVolume); } TRACE("szResult %s hVOlume %p ret %d LengthInformation %ul Bytesreturned %d\n", debugstr_w(szResult), hVolume, ret, TotalNumberOfBytes.QuadPart, BytesReturned); if (StrFormatByteSizeW(TotalNumberOfBytes.QuadPart - FreeBytesAvailable.QuadPart, szResult, sizeof(szResult) / sizeof(WCHAR))) SendDlgItemMessageW(hwndDlg, 14003, WM_SETTEXT, (WPARAM)NULL, (LPARAM)szResult); if (StrFormatByteSizeW(FreeBytesAvailable.QuadPart, szResult, sizeof(szResult) / sizeof(WCHAR))) SendDlgItemMessageW(hwndDlg, 14005, WM_SETTEXT, (WPARAM)NULL, (LPARAM)szResult); Result = GetFreeBytesShare(TotalNumberOfFreeBytes.QuadPart, TotalNumberOfBytes.QuadPart); /* set free bytes percentage */ swprintf(szResult, L"%02d%%", Result); SendDlgItemMessageW(hwndDlg, 14006, WM_SETTEXT, (WPARAM)0, (LPARAM)szResult); /* store used share amount */ Result = 100 - Result; swprintf(szResult, L"%02d%%", Result); SendDlgItemMessageW(hwndDlg, 14004, WM_SETTEXT, (WPARAM)0, (LPARAM)szResult); if (DriveType == DRIVE_FIXED) { if (LoadStringW(shell32_hInstance, IDS_DRIVE_FIXED, szBuffer, sizeof(szBuffer) / sizeof(WCHAR))) SendDlgItemMessageW(hwndDlg, 14001, WM_SETTEXT, (WPARAM)0, (LPARAM)szBuffer); } else /* DriveType == DRIVE_CDROM) */ { if (LoadStringW(shell32_hInstance, IDS_DRIVE_CDROM, szBuffer, sizeof(szBuffer) / sizeof(WCHAR))) SendDlgItemMessageW(hwndDlg, 14001, WM_SETTEXT, (WPARAM)0, (LPARAM)szBuffer); } } } /* set drive description */ SendDlgItemMessageW(hwndDlg, 14009, WM_GETTEXT, (WPARAM)50, (LPARAM)szFormat); swprintf(szBuffer, szFormat, szDrive); SendDlgItemMessageW(hwndDlg, 14009, WM_SETTEXT, (WPARAM)NULL, (LPARAM)szBuffer); }
extern void __declspec(dllexport) Open(PLUGINDATA *pd) { INT_PTR res; DWORD_PTR* param; EDITINFO ei; BOOL bInsert = FALSE; pd->dwSupport |= PDS_NOANSI|PDS_NOAUTOLOAD; if(pd->dwSupport & PDS_GETSUPPORT) return; if(pd->bOldWindows) { pd->nUnload = UD_UNLOAD; return; } if(!g_bLoaded) { LoadPlugin(pd); if(!g_bLoaded) { pd->nUnload = UD_UNLOAD; return; } } g_nLock++; ei.hWndEdit = NULL; if(SendMessageW(g_hMainWnd,AKD_GETEDITINFO,0,(LPARAM)&ei)) { if(ei.hWndEdit && ei.wszFile) bInsert = !ei.bReadOnly; } param = (DWORD_PTR*)pd->lParam; if( param && (param[0]==3*sizeof(DWORD_PTR)) && (param[1]==OPEN_FUNCTION_OPEN || param[1]==OPEN_FUNCTION_EDIT || param[1]==OPEN_FUNCTION_INSERT) && param[2]) { LPCWSTR p = (LPCWSTR)param[2]; res = (param[1]==OPEN_FUNCTION_OPEN) ?(IDOK) :((param[1]==OPEN_FUNCTION_EDIT) ?IDC_EDIT: IDC_INSERT); if(p[0]) { lstrcpyW(g_szTemplate,g_szAkelPath); lstrcatW(g_szTemplate,TEMPLATES_PATH); lstrcatW(g_szTemplate,L"\\"); lstrcatW(g_szTemplate,p); } else g_szTemplate[0] = 0; if(res==IDC_EDIT) { HANDLE h = CreateFileW(g_szTemplate,GENERIC_READ,FILE_SHARE_READ,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,0); if(h == INVALID_HANDLE_VALUE) { res = IDCANCEL; } else { CloseHandle(h); } } else if((res == IDC_INSERT) && (!bInsert)) { res = IDCANCEL; } } else { res = DialogBoxParamW(g_hDll,MAKEINTRESOURCEW(IDD_TEMPLATE),g_hMainWnd,(DLGPROC)TemplateDlg,(LPARAM)DCP_ALLOWEDIT|(bInsert?DCP_ALLOWINSERT:0)); } if(IDOK == res || IDC_EDIT == res || IDC_INSERT == res) { if(g_bMainReady) { g_bInternalNew = TRUE; } if(res == IDC_EDIT) { EditTemplate(FALSE); } else if(res == IDOK) { ei.hWndEdit = NULL; if(SendMessageW(g_hMainWnd,AKD_GETEDITINFO,0,(LPARAM)&ei)) { if(!ei.hWndEdit || ei.bModified || ei.wszFile[0]) { if(SendMessageW(g_hMainWnd,WM_COMMAND,MAKEWPARAM(IDM_FILE_NEW,0),TRUE)) { SendMessageW(g_hMainWnd,AKD_GETEDITINFO,0,(LPARAM)&ei); } } } else if(g_nMDI == WMD_MDI) { if(SendMessageW(g_hMainWnd,WM_COMMAND,MAKEWPARAM(IDM_FILE_NEW,0),TRUE)) { SendMessageW(g_hMainWnd,AKD_GETEDITINFO,0,(LPARAM)&ei); } } if(ei.hWndEdit && !((g_nMDI == WMD_SDI)&&(ei.bModified))) { OpenTemplate(ei.hWndEdit,FALSE); } } else if(res == IDC_INSERT) { if(SendMessageW(g_hMainWnd,AKD_GETEDITINFO,0,(LPARAM)&ei)) { if(ei.hWndEdit) { OpenTemplate(ei.hWndEdit,TRUE); } } } if(g_bMainReady) { g_bInternalNew = FALSE; } } g_nLock--; pd->nUnload = (g_nLock)?UD_NONUNLOAD_NONACTIVE:UD_UNLOAD; if(!g_nLock) UnloadPlugin(pd); }
static void CALLCONV OpenTemplate(HWND hWnd, BOOL bInsert) { LRESULT res = 0; LRESULT pos = 0; TEXTFINDW tf = {FRF_BEGINNING|FRF_DOWN|FRF_MATCHCASE,CARETPOSMARKER,-1}; TEXTREPLACEW tr = {FRF_BEGINNING|FRF_DOWN|FRF_MATCHCASE,CARETPOSMARKER,-1,L"",0,TRUE,0}; DETECTFILEW dc = {g_szTemplate,1024,ADT_BINARY_ERROR|ADT_DETECT_BOM|ADT_DETECT_CODEPAGE,0,FALSE}; if(g_szTemplate[0]/*!<EMPTY>*/ && (EDT_SUCCESS == SendMessageW(g_hMainWnd, AKD_DETECTFILEW,0,(LPARAM)&dc))) { HANDLE hFile = CreateFileW(g_szTemplate, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING,FILE_FLAG_SEQUENTIAL_SCAN,NULL); if(hFile != INVALID_HANDLE_VALUE/*always TRUE if we are here*/) { FILECONTENT fc; LRESULT lSize = 0; PLG_CHARRANGE cursel = {0,0}; fc.hFile = hFile; fc.dwMax = (UINT_PTR)-1; fc.nCodePage = dc.nCodePage; fc.bBOM = dc.bBOM; fc.wpContent = NULL; if(lSize = SendMessageW(g_hMainWnd,AKD_READFILECONTENT,0,(LPARAM)&fc)) { LPCWSTR pText = SplitTemplate(fc.wpContent); tf.pFindIt = fc.wpContent; tr.pFindIt = fc.wpContent; lSize -= pText - fc.wpContent; if(*pText) { if(!bInsert) { SendMessageW(hWnd,EM_SETSEL,(WPARAM)0,(LPARAM)-1); } else if(g_bRemoveMarker) { //! Store selection for future SendMessageW(hWnd, PEM_EXGETSEL,0,(LPARAM)&cursel); } //! Insert text SendMessageW(hWnd,EM_REPLACESEL,(WPARAM)FALSE,(LPARAM)pText); if(!bInsert) { //! Find first cursor position res = SendMessageW(g_hMainWnd, AKD_TEXTFINDW, (WPARAM)hWnd, (LPARAM)&tf); if(res != -1) pos = res; if(g_bRemoveMarker) { //! Remove all caret markers SendMessageW(g_hMainWnd, AKD_TEXTREPLACEW, (WPARAM)hWnd, (LPARAM)&tr); } //! Put caret there SendMessageW(hWnd,EM_SETSEL,(WPARAM)pos,(LPARAM)pos); if(g_bCPFT) { SAVEDOCUMENTW sd = {L"",fc.nCodePage,fc.bBOM,SD_UPDATE}; SendMessageW(g_hMainWnd,AKD_SAVEDOCUMENTW,(WPARAM)hWnd,(LPARAM)&sd); } //! Reset modification flag SendMessageW(g_hMainWnd, AKD_SETMODIFY,(WPARAM)hWnd,(LPARAM)FALSE); } else if(bInsert && g_bRemoveMarker) //! User requested to remove markers { //! Mark newly inserted text cursel.cpMax = cursel.cpMin + lSize; SendMessageW(hWnd,PEM_EXSETSEL,0,(LPARAM)&cursel); tr.dwFlags = FRF_SELECTION|FRF_DOWN|FRF_MATCHCASE; //! Remove all markers SendMessageW(g_hMainWnd,AKD_TEXTREPLACEW,(WPARAM)hWnd,(LPARAM)&tr); //! Put caret after inserted text SendMessageW(hWnd, PEM_EXGETSEL,0,(LPARAM)&cursel); cursel.cpMin = cursel.cpMax; SendMessageW(hWnd, PEM_EXSETSEL,0,(LPARAM)&cursel); } } else { //! Empty template - do "nothing" i.e. only insert text, do not try to deal with markers SendMessageW(hWnd,EM_REPLACESEL,(WPARAM)FALSE,(LPARAM)pText); } //! Call Coder only on creation and on insertion if no theme assigned yet if((!bInsert) || (g_bHighLightAtInsert && IsHighLightThemeAssigned(hWnd))) { CallCoder(g_szTemplate); } SendMessageW(g_hMainWnd, AKD_FREETEXT,0,(LPARAM)fc.wpContent); if(bInsert) { SendMessageW(g_hMainWnd, AKD_SETMODIFY,(WPARAM)hWnd,(LPARAM)TRUE); } } CloseHandle(hFile); } } }
static DWORD WINAPI ThreadFunc(LPVOID Context) { CComPtr<IBindStatusCallback> dl; WCHAR path[MAX_PATH]; PWSTR p, q; HWND Dlg = (HWND) Context; ULONG dwContentLen, dwBytesWritten, dwBytesRead, dwStatus; ULONG dwCurrentBytesRead = 0; ULONG dwStatusLen = sizeof(dwStatus); BOOL bCancelled = FALSE; BOOL bTempfile = FALSE; BOOL bCab = FALSE; HINTERNET hOpen = NULL; HINTERNET hFile = NULL; HANDLE hOut = INVALID_HANDLE_VALUE; unsigned char lpBuffer[4096]; PCWSTR lpszAgent = L"RApps/1.0"; URL_COMPONENTS urlComponents; size_t urlLength, filenameLength; /* build the path for the download */ p = wcsrchr(AppInfo->szUrlDownload, L'/'); q = wcsrchr(AppInfo->szUrlDownload, L'?'); /* do we have a final slash separator? */ if (!p) goto end; /* prepare the tentative length of the filename, maybe we've to remove part of it later on */ filenameLength = wcslen(p) * sizeof(WCHAR); /* do we have query arguments in the target URL after the filename? account for them (e.g. https://example.org/myfile.exe?no_adware_plz) */ if (q && q > p && (q - p) > 0) filenameLength -= wcslen(q - 1) * sizeof(WCHAR); /* is this URL an update package for RAPPS? if so store it in a different place */ if (wcscmp(AppInfo->szUrlDownload, APPLICATION_DATABASE_URL) == 0) { bCab = TRUE; if (!GetStorageDirectory(path, _countof(path))) goto end; } else { if (FAILED(StringCbCopyW(path, sizeof(path), SettingsInfo.szDownloadDir))) goto end; } /* is the path valid? can we access it? */ if (GetFileAttributesW(path) == INVALID_FILE_ATTRIBUTES) { if (!CreateDirectoryW(path, NULL)) goto end; } /* append a \ to the provided file system path, and the filename portion from the URL after that */ if (FAILED(StringCbCatW(path, sizeof(path), L"\\"))) goto end; if (FAILED(StringCbCatNW(path, sizeof(path), p + 1, filenameLength))) goto end; if (!bCab && AppInfo->szSHA1[0] != 0 && GetFileAttributesW(path) != INVALID_FILE_ATTRIBUTES) { /* only open it in case of total correctness */ if (VerifyInteg(AppInfo->szSHA1, path)) goto run; } /* download it */ bTempfile = TRUE; CDownloadDialog_Constructor(Dlg, &bCancelled, IID_PPV_ARG(IBindStatusCallback, &dl)); if (dl == NULL) goto end; /* FIXME: this should just be using the system-wide proxy settings */ switch(SettingsInfo.Proxy) { case 0: /* preconfig */ hOpen = InternetOpenW(lpszAgent, INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, 0); break; case 1: /* direct (no proxy) */ hOpen = InternetOpenW(lpszAgent, INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0); break; case 2: /* use proxy */ hOpen = InternetOpenW(lpszAgent, INTERNET_OPEN_TYPE_PROXY, SettingsInfo.szProxyServer, SettingsInfo.szNoProxyFor, 0); break; default: /* preconfig */ hOpen = InternetOpenW(lpszAgent, INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, 0); break; } if (!hOpen) goto end; hFile = InternetOpenUrlW(hOpen, AppInfo->szUrlDownload, NULL, 0, INTERNET_FLAG_PRAGMA_NOCACHE|INTERNET_FLAG_KEEP_CONNECTION, 0); if (!hFile) goto end; if (!HttpQueryInfoW(hFile, HTTP_QUERY_STATUS_CODE | HTTP_QUERY_FLAG_NUMBER, &dwStatus, &dwStatusLen, NULL)) goto end; if(dwStatus != HTTP_STATUS_OK) { WCHAR szMsgText[MAX_STR_LEN]; if (!LoadStringW(hInst, IDS_UNABLE_TO_DOWNLOAD, szMsgText, sizeof(szMsgText) / sizeof(WCHAR))) goto end; MessageBoxW(hMainWnd, szMsgText, NULL, MB_OK | MB_ICONERROR); goto end; } dwStatusLen = sizeof(dwStatus); memset(&urlComponents, 0, sizeof(urlComponents)); urlComponents.dwStructSize = sizeof(urlComponents); if(FAILED(StringCbLengthW(AppInfo->szUrlDownload, sizeof(AppInfo->szUrlDownload), &urlLength))) goto end; urlLength /= sizeof(WCHAR); urlComponents.dwSchemeLength = urlLength + 1; urlComponents.lpszScheme = (LPWSTR)malloc(urlComponents.dwSchemeLength * sizeof(WCHAR)); urlComponents.dwHostNameLength = urlLength + 1; urlComponents.lpszHostName = (LPWSTR)malloc(urlComponents.dwHostNameLength * sizeof(WCHAR)); if(!InternetCrackUrlW(AppInfo->szUrlDownload, urlLength+1, ICU_DECODE | ICU_ESCAPE, &urlComponents)) goto end; if(urlComponents.nScheme == INTERNET_SCHEME_HTTP || urlComponents.nScheme == INTERNET_SCHEME_HTTPS) HttpQueryInfo(hFile, HTTP_QUERY_CONTENT_LENGTH | HTTP_QUERY_FLAG_NUMBER, &dwContentLen, &dwStatus, 0); if(urlComponents.nScheme == INTERNET_SCHEME_FTP) dwContentLen = FtpGetFileSize(hFile, &dwStatus); #ifdef USE_CERT_PINNING /* are we using HTTPS to download the RAPPS update package? check if the certificate is original */ if ((urlComponents.nScheme == INTERNET_SCHEME_HTTPS) && (wcscmp(AppInfo->szUrlDownload, APPLICATION_DATABASE_URL) == 0) && (!CertIsValid(hOpen, urlComponents.lpszHostName))) { WCHAR szMsgText[MAX_STR_LEN]; if (!LoadStringW(hInst, IDS_CERT_DOES_NOT_MATCH, szMsgText, sizeof(szMsgText) / sizeof(WCHAR))) goto end; MessageBoxW(Dlg, szMsgText, NULL, MB_OK | MB_ICONERROR); goto end; } #endif free(urlComponents.lpszScheme); free(urlComponents.lpszHostName); hOut = CreateFileW(path, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, 0, NULL); if (hOut == INVALID_HANDLE_VALUE) goto end; do { if (!InternetReadFile(hFile, lpBuffer, _countof(lpBuffer), &dwBytesRead)) { WCHAR szMsgText[MAX_STR_LEN]; if (!LoadStringW(hInst, IDS_INTERRUPTED_DOWNLOAD, szMsgText, _countof(szMsgText))) goto end; MessageBoxW(hMainWnd, szMsgText, NULL, MB_OK | MB_ICONERROR); goto end; } if (!WriteFile(hOut, &lpBuffer[0], dwBytesRead, &dwBytesWritten, NULL)) { WCHAR szMsgText[MAX_STR_LEN]; if (!LoadStringW(hInst, IDS_UNABLE_TO_WRITE, szMsgText, _countof(szMsgText))) goto end; MessageBoxW(hMainWnd, szMsgText, NULL, MB_OK | MB_ICONERROR); goto end; } dwCurrentBytesRead += dwBytesRead; dl->OnProgress(dwCurrentBytesRead, dwContentLen, 0, AppInfo->szUrlDownload); } while (dwBytesRead && !bCancelled); CloseHandle(hOut); hOut = INVALID_HANDLE_VALUE; if (bCancelled) goto end; /* if this thing isn't a RAPPS update and it has a SHA-1 checksum verify its integrity by using the native advapi32.A_SHA1 functions */ if (!bCab && AppInfo->szSHA1[0] != 0) { WCHAR szMsgText[MAX_STR_LEN]; /* change a few strings in the download dialog to reflect the verification process */ LoadStringW(hInst, IDS_INTEG_CHECK_TITLE, szMsgText, _countof(szMsgText)); SetWindowText(Dlg, szMsgText); SendMessageW(GetDlgItem(Dlg, IDC_DOWNLOAD_STATUS), WM_SETTEXT, 0, (LPARAM)path); /* this may take a while, depending on the file size */ if (!VerifyInteg(AppInfo->szSHA1, path)) { if (!LoadStringW(hInst, IDS_INTEG_CHECK_FAIL, szMsgText, _countof(szMsgText))) goto end; MessageBoxW(Dlg, szMsgText, NULL, MB_OK | MB_ICONERROR); goto end; } } ShowWindow(Dlg, SW_HIDE); run: /* run it */ if (!bCab) ShellExecuteW( NULL, L"open", path, NULL, NULL, SW_SHOWNORMAL ); end: if (hOut != INVALID_HANDLE_VALUE) CloseHandle(hOut); InternetCloseHandle(hFile); InternetCloseHandle(hOpen); if (bTempfile) { if (bCancelled || (SettingsInfo.bDelInstaller && !bCab)) DeleteFileW(path); } EndDialog(Dlg, 0); return 0; }
/* * __win_open_file -- * Open a file handle. */ static int __win_open_file(WT_FILE_SYSTEM *file_system, WT_SESSION *wt_session, const char *name, WT_FS_OPEN_FILE_TYPE file_type, uint32_t flags, WT_FILE_HANDLE **file_handlep) { DWORD dwCreationDisposition, windows_error; WT_CONNECTION_IMPL *conn; WT_DECL_RET; WT_DECL_ITEM(name_wide); WT_FILE_HANDLE *file_handle; WT_FILE_HANDLE_WIN *win_fh; WT_SESSION_IMPL *session; int desired_access, f; WT_UNUSED(file_system); session = (WT_SESSION_IMPL *)wt_session; conn = S2C(session); *file_handlep = NULL; WT_RET(__wt_calloc_one(session, &win_fh)); win_fh->direct_io = false; /* Set up error handling. */ win_fh->filehandle = win_fh->filehandle_secondary = INVALID_HANDLE_VALUE; WT_ERR(__wt_to_utf16_string(session, name, &name_wide)); /* * Opening a file handle on a directory is only to support filesystems * that require a directory sync for durability, and Windows doesn't * require that functionality: create an empty WT_FH structure with * invalid handles. */ if (file_type == WT_FS_OPEN_FILE_TYPE_DIRECTORY) goto directory_open; desired_access = GENERIC_READ; if (!LF_ISSET(WT_FS_OPEN_READONLY)) desired_access |= GENERIC_WRITE; /* * Security: * The application may spawn a new process, and we don't want another * process to have access to our file handles. * * TODO: Set tighter file permissions but set bInheritHandle to false * to prevent inheritance */ f = FILE_ATTRIBUTE_NORMAL; dwCreationDisposition = 0; if (LF_ISSET(WT_FS_OPEN_CREATE)) { dwCreationDisposition = CREATE_NEW; if (LF_ISSET(WT_FS_OPEN_EXCLUSIVE)) dwCreationDisposition = CREATE_ALWAYS; } else dwCreationDisposition = OPEN_EXISTING; /* Direct I/O. */ if (LF_ISSET(WT_FS_OPEN_DIRECTIO)) { f |= FILE_FLAG_NO_BUFFERING; win_fh->direct_io = true; } /* FILE_FLAG_WRITE_THROUGH does not require aligned buffers */ if (FLD_ISSET(conn->write_through, file_type)) f |= FILE_FLAG_WRITE_THROUGH; if (file_type == WT_FS_OPEN_FILE_TYPE_LOG && FLD_ISSET(conn->txn_logsync, WT_LOG_DSYNC)) f |= FILE_FLAG_WRITE_THROUGH; /* Disable read-ahead on trees: it slows down random read workloads. */ if (file_type == WT_FS_OPEN_FILE_TYPE_DATA) f |= FILE_FLAG_RANDOM_ACCESS; win_fh->filehandle = CreateFileW(name_wide->data, desired_access, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, dwCreationDisposition, f, NULL); if (win_fh->filehandle == INVALID_HANDLE_VALUE) { if (LF_ISSET(WT_FS_OPEN_CREATE) && GetLastError() == ERROR_FILE_EXISTS) win_fh->filehandle = CreateFileW(name_wide->data, desired_access, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, f, NULL); if (win_fh->filehandle == INVALID_HANDLE_VALUE) { windows_error = __wt_getlasterror(); __wt_errx(session, win_fh->direct_io ? "%s: handle-open: CreateFileW: failed with direct " "I/O configured, some filesystem types do not " "support direct I/O: %s" : "%s: handle-open: CreateFileW: %s", name, __wt_formatmessage(session, windows_error)); WT_ERR(__wt_map_windows_error(windows_error)); } } /* * Open a second handle to file to support file extension/truncation * concurrently with reads on the file. Writes would also move the * file pointer. */ if (!LF_ISSET(WT_FS_OPEN_READONLY)) { win_fh->filehandle_secondary = CreateFileW(name_wide->data, desired_access, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, f, NULL); if (win_fh->filehandle_secondary == INVALID_HANDLE_VALUE) { windows_error = __wt_getlasterror(); __wt_errx(session, "%s: handle-open: Creatively: secondary: %s", name, __wt_formatmessage(session, windows_error)); WT_ERR(__wt_map_windows_error(windows_error)); } } directory_open: /* Initialize public information. */ file_handle = (WT_FILE_HANDLE *)win_fh; WT_ERR(__wt_strdup(session, name, &file_handle->name)); file_handle->close = __win_file_close; file_handle->fh_lock = __win_file_lock; #ifdef WORDS_BIGENDIAN /* * The underlying objects are little-endian, mapping objects isn't * currently supported on big-endian systems. */ #else file_handle->fh_map = __wt_win_map; file_handle->fh_unmap = __wt_win_unmap; #endif file_handle->fh_read = __win_file_read; file_handle->fh_size = __win_file_size; file_handle->fh_sync = __win_file_sync; /* Extend and truncate share the same implementation. */ file_handle->fh_extend = __win_file_set_end; file_handle->fh_truncate = __win_file_set_end; file_handle->fh_write = __win_file_write; *file_handlep = file_handle; __wt_scr_free(session, &name_wide); return (0); err: __wt_scr_free(session, &name_wide); WT_TRET(__win_file_close((WT_FILE_HANDLE *)win_fh, wt_session)); return (ret); }
bool LocateConverter::LocateUpdate(const wchar_t *locate, const wchar_t *patch, const wchar_t *path, bool compress/* = false */, OnProgress progress/* = NULL */) { LocateReader loc(locate); if ( !loc.IsAvailable() ) return false; const uint8_t *diff_buffer = 0; PDIFFHEADER diff_header = 0; HANDLE hfile = CreateFileW(patch, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); if(hfile!=INVALID_HANDLE_VALUE) { uint32_t file_length = GetFileSize(hfile, NULL); HANDLE hfilemap = CreateFileMapping(hfile, NULL, PAGE_READONLY, 0, 0, NULL); CloseHandle(hfile); diff_buffer = (const uint8_t*) MapViewOfFile(hfilemap, FILE_MAP_READ, 0, 0, 0); CloseHandle(hfilemap); diff_header = (PDIFFHEADER)diff_buffer; int data_size = file_length - sizeof(DIFFHEADER) - LZMA_PROPS_SIZE; if( data_size<0 || diff_header->magic != DIFF_MAGIC || CRC32_MEM(diff_buffer, sizeof(DIFFHEADER) - 4)!=diff_header->crc32 ) { UnmapViewOfFile((void*)diff_buffer); return false; } else { uint32_t lzma_buffer_len = diff_header->size; uint8_t *lzma_buffer = (uint8_t *)malloc(sizeof(DIFFHEADER) + lzma_buffer_len); if( LzmaUncompress(lzma_buffer + sizeof(DIFFHEADER), &lzma_buffer_len, (unsigned char*)diff_header->data + LZMA_PROPS_SIZE, (uint32_t*)&data_size, (unsigned char*)diff_header->data, LZMA_PROPS_SIZE)==SZ_OK ) { memcpy(lzma_buffer, diff_buffer, sizeof(DIFFHEADER)); UnmapViewOfFile((void*)diff_buffer); diff_buffer = lzma_buffer; diff_header = (PDIFFHEADER)diff_buffer; diff_header->table1 += (uint32_t)diff_buffer; diff_header->table2 += (uint32_t)diff_buffer; } else { free(lzma_buffer); UnmapViewOfFile((void*)diff_buffer); return false; } } } else { return false; } if ( loc.GetInfo()->count!=diff_header->total1 || loc.GetInfo()->time!=diff_header->time1 ) return false; PDIFFITEM diffitem = diff_header->data; LocateItem *Locate = (LocateItem *)malloc( diff_header->total2 * sizeof(LocateItem) ); uint32_t last_diff = ( diff_header->table1 - sizeof(DIFFHEADER) - (uint32_t)diff_buffer ) / sizeof(DIFFITEM) - 1; uint32_t last_line = diff_header->total2 - 1; uint32_t i = loc.GetInfo()->count; for(; i>0; i--) { LocateItem *item = loc.GetItem(i); if(i!=diffitem[last_diff].line) { Locate[last_line].begin_ip = item->begin_ip; Locate[last_line].region = item->region; Locate[last_line].address = item->address; last_line--; } else { switch(diffitem[last_diff].method) { case INSERT: //printf("INSERT %d %d\n", i, diffitem[last_diff-1].line); Locate[last_line].begin_ip = diffitem[last_diff].begin_ip; Locate[last_line].region = (const char*)( diffitem[last_diff].table1 + diff_header->table1 ); Locate[last_line].address = (const char*)( diffitem[last_diff].table2 + diff_header->table2 ); last_line--; i++; break; case REMOVE: //printf("REMOVE %d %d %d\n", i, diffitem[last_diff-1].line, diffitem[last_diff-2].line); break; case MODIFY: Locate[last_line].begin_ip = item->begin_ip; Locate[last_line].region = (const char*)( diffitem[last_diff].table1 + diff_header->table1 ); Locate[last_line].address = (const char*)( diffitem[last_diff].table2 + diff_header->table2 ); //printf("MODIFY %d %s %s\n", last_line+1, Locate[last_line].region, Locate[last_line].address); //getchar(); last_line--; break; } last_diff--; } } //printf("%d %d\n",last_diff,last_line); if ( last_diff!=-1 || last_line!=-1 ) return false; StringTable string_table1; StringTable string_table2; RecordTable record_table; Buffer buffer; uint32_t last_begin_ip = 0; for(i=last_line+1; i<diff_header->total2; i++) { LocateItem *item = &Locate[i]; LOCATE record; record.begin_ip = item->begin_ip; record.table1 = string_table1.Append(item->region); record.table2 = string_table2.Append(item->address); if ( i > 0 ) { uint32_t diff = record.begin_ip - last_begin_ip; if ( compress && isPowerOf2(diff) ) { record.begin_ip = LogBase2(diff); } } record_table.Append(&record); last_begin_ip = item->begin_ip; } free(Locate); //合并数据区 Buffer *record_table_buffer = record_table; Buffer *string_table1_buffer = string_table1; Buffer *string_table2_buffer = string_table2; std::copy(record_table_buffer->begin(), record_table_buffer->end(), std::back_inserter(buffer)); std::copy(string_table1_buffer->begin(), string_table1_buffer->end(), std::back_inserter(buffer)); std::copy(string_table2_buffer->begin(), string_table2_buffer->end(), std::back_inserter(buffer)); //生成文件头 HEADER header; header.magic = LOCATE_MAGIC; header.version = LOCATE_VERISON; header.compress = compress?1:0; header.total = diff_header->total2; header.time = diff_header->time2; header.table1 = sizeof(header) + record_table_buffer->size(); // 这里不加LZMA_PROPS_SIZE的原因是解压后,抛弃props信息 header.table2 = header.table1 + string_table1_buffer->size(); header.size = buffer.size(); header.crc32 = CRC32_MEM((uint8_t*)&header, sizeof(header) - 4); uint32_t lzma_buffer_len = buffer.size(); uint8_t *lzma_buffer = 0; size_t prop_size = LZMA_PROPS_SIZE; BYTE outProps[LZMA_PROPS_SIZE]; //准备压缩 if(compress) { lzma_buffer = (uint8_t *)malloc(lzma_buffer_len); ProgressCallback LzmaCompressProgress; LzmaCompressProgress.Progress = LzmaOnProgress; LzmaCompressProgress.totalInSize = buffer.size(); LzmaCompressProgress.progress = progress; LzmaCompress(lzma_buffer, &lzma_buffer_len, &buffer[0], buffer.size(), (ICompressProgress*)&LzmaCompressProgress, outProps, &prop_size, 5, 1<<27, 8, 0, 2, 64, 4); } //保存文件 FILE * out = _wfopen(path, L"wb"); fwrite(&header, 1, sizeof(header), out); if(compress) { fwrite(outProps, 1, sizeof(outProps), out); fwrite(lzma_buffer, 1, lzma_buffer_len, out); } else { fwrite(&buffer[0], 1, buffer.size(), out); } fclose(out); if(compress) { free(lzma_buffer); } free((void*)diff_buffer); return true; }
void* MemoryMappedFile::map(const char *filenameIn, unsigned long long &length, int options) { verify( fd == 0 && len == 0 ); // can't open more than once setFilename(filenameIn); FileAllocator::get()->allocateAsap( filenameIn, length ); /* big hack here: Babble uses db names with colons. doesn't seem to work on windows. temporary perhaps. */ char filename[256]; strncpy(filename, filenameIn, 255); filename[255] = 0; { size_t len = strlen( filename ); for ( size_t i=len-1; i>=0; i-- ) { if ( filename[i] == '/' || filename[i] == '\\' ) break; if ( filename[i] == ':' ) filename[i] = '_'; } } updateLength( filename, length ); { DWORD createOptions = FILE_ATTRIBUTE_NORMAL; if ( options & SEQUENTIAL ) createOptions |= FILE_FLAG_SEQUENTIAL_SCAN; DWORD rw = GENERIC_READ | GENERIC_WRITE; fd = CreateFileW( toWideString(filename).c_str(), rw, // desired access FILE_SHARE_WRITE | FILE_SHARE_READ, // share mode NULL, // security OPEN_ALWAYS, // create disposition createOptions , // flags NULL); // hTempl if ( fd == INVALID_HANDLE_VALUE ) { DWORD dosError = GetLastError(); log() << "CreateFileW for " << filename << " failed with " << errnoWithDescription( dosError ) << " (file size is " << length << ")" << " in MemoryMappedFile::map" << endl; return 0; } } mapped += length; { DWORD flProtect = PAGE_READWRITE; //(options & READONLY)?PAGE_READONLY:PAGE_READWRITE; maphandle = CreateFileMappingW(fd, NULL, flProtect, length >> 32 /*maxsizehigh*/, (unsigned) length /*maxsizelow*/, NULL/*lpName*/); if ( maphandle == NULL ) { DWORD dosError = GetLastError(); log() << "CreateFileMappingW for " << filename << " failed with " << errnoWithDescription( dosError ) << " (file size is " << length << ")" << " in MemoryMappedFile::map" << endl; close(); fassertFailed( 16225 ); } } void *view = 0; { stdx::lock_guard<stdx::mutex> lk(mapViewMutex); DWORD access = ( options & READONLY ) ? FILE_MAP_READ : FILE_MAP_ALL_ACCESS; int current_retry = 0; while (true) { LPVOID thisAddress = getNextMemoryMappedFileLocation(length); view = MapViewOfFileEx( maphandle, // file mapping handle access, // access 0, 0, // file offset, high and low 0, // bytes to map, 0 == all thisAddress); // address to place file if (view == 0) { DWORD dosError = GetLastError(); ++current_retry; // If we failed to allocate a memory mapped file, try again in case we picked // an address that Windows is also trying to use for some other VM allocations if (dosError == ERROR_INVALID_ADDRESS && current_retry < 5) { continue; } #ifndef _WIN64 // Warn user that if they are running a 32-bit app on 64-bit Windows if (dosError == ERROR_NOT_ENOUGH_MEMORY) { BOOL wow64Process; BOOL retWow64 = IsWow64Process(GetCurrentProcess(), &wow64Process); if (retWow64 && wow64Process) { log() << "This is a 32-bit MongoDB binary running on a 64-bit" " operating system that has run out of virtual memory for" " databases. Switch to a 64-bit build of MongoDB to open" " the databases."; } } #endif log() << "MapViewOfFileEx for " << filename << " at address " << thisAddress << " failed with " << errnoWithDescription(dosError) << " (file size is " << length << ")" << " in MemoryMappedFile::map" << endl; close(); fassertFailed(16166); } break; } } views.push_back(view); len = length; return view; }
void bad() { wchar_t * data; wchar_t * *dataPtr1 = &data; wchar_t * *dataPtr2 = &data; wchar_t dataBuffer[FILENAME_MAX] = L""; data = dataBuffer; { wchar_t * data = *dataPtr1; { #ifdef _WIN32 WSADATA wsaData; int wsaDataInit = 0; #endif int recvResult; struct sockaddr_in service; wchar_t *replace; SOCKET listenSocket = INVALID_SOCKET; SOCKET acceptSocket = INVALID_SOCKET; size_t dataLen = wcslen(data); do { #ifdef _WIN32 if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR) { break; } wsaDataInit = 1; #endif /* POTENTIAL FLAW: Read data using a listen socket */ listenSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); if (listenSocket == INVALID_SOCKET) { break; } memset(&service, 0, sizeof(service)); service.sin_family = AF_INET; service.sin_addr.s_addr = INADDR_ANY; service.sin_port = htons(TCP_PORT); if (bind(listenSocket, (struct sockaddr*)&service, sizeof(service)) == SOCKET_ERROR) { break; } if (listen(listenSocket, LISTEN_BACKLOG) == SOCKET_ERROR) { break; } acceptSocket = accept(listenSocket, NULL, NULL); if (acceptSocket == SOCKET_ERROR) { break; } /* Abort on error or the connection was closed */ recvResult = recv(acceptSocket, (char *)(data + dataLen), sizeof(wchar_t) * (FILENAME_MAX - dataLen - 1), 0); if (recvResult == SOCKET_ERROR || recvResult == 0) { break; } /* Append null terminator */ data[dataLen + recvResult / sizeof(wchar_t)] = L'\0'; /* Eliminate CRLF */ replace = wcschr(data, L'\r'); if (replace) { *replace = L'\0'; } replace = wcschr(data, L'\n'); if (replace) { *replace = L'\0'; } } while (0); if (listenSocket != INVALID_SOCKET) { CLOSE_SOCKET(listenSocket); } if (acceptSocket != INVALID_SOCKET) { CLOSE_SOCKET(acceptSocket); } #ifdef _WIN32 if (wsaDataInit) { WSACleanup(); } #endif } *dataPtr1 = data; } { wchar_t * data = *dataPtr2; { HANDLE hFile; /* POTENTIAL FLAW: Possibly creating and opening a file without validating the file name or path */ hFile = CreateFileW(data, (GENERIC_WRITE|GENERIC_READ), 0, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); if (hFile != INVALID_HANDLE_VALUE) { CloseHandle(hFile); } } } }
HRESULT CFileWatcher::WatchFile(PCWSTR fileName, FileModifiedCallback callback, void* data) { HRESULT hr; WatchedFile* file; WatchedDirectory* directory; WatchedDirectory* newDirectory; WCHAR fileOnly[_MAX_FNAME]; WCHAR ext[_MAX_EXT]; WCHAR* directoryName = NULL; DWORD fileNameLength; DWORD fileNameOnlyLength; DWORD directoryLength; WIN32_FILE_ATTRIBUTE_DATA attributes; CheckNull(callback); CheckNull(fileName); fileNameLength = wcslen(fileName); // allocate new WatchedFile, get snapshot of the last write time ErrorIf(NULL == (file = new WatchedFile), ERROR_NOT_ENOUGH_MEMORY); RtlZeroMemory(file, sizeof WatchedFile); file->callback = callback; file->data = data; ErrorIf(!GetFileAttributesExW(fileName, GetFileExInfoStandard, &attributes), GetLastError()); memcpy(&file->lastWrite, &attributes.ftLastWriteTime, sizeof attributes.ftLastWriteTime); // create and normalize a copy of directory name and file name ErrorIf(0 != _wsplitpath_s(fileName, NULL, 0, NULL, 0, fileOnly, _MAX_FNAME, ext, _MAX_EXT), ERROR_INVALID_PARAMETER); fileNameOnlyLength = wcslen(fileOnly) + wcslen(ext); directoryLength = fileNameLength - fileNameOnlyLength; ErrorIf(NULL == (directoryName = new WCHAR[directoryLength + 8]), ERROR_NOT_ENOUGH_MEMORY); // pessimistic length after normalization with prefix \\?\UNC\ ErrorIf(NULL == (file->fileName = new WCHAR[fileNameLength + 1]), ERROR_NOT_ENOUGH_MEMORY); wcscpy(file->fileName, fileName); if (fileNameLength > 8 && 0 == memcmp(fileName, L"\\\\?\\UNC\\", 8 * sizeof WCHAR)) { // normalized UNC path file->unc = TRUE; memcpy(directoryName, fileName, directoryLength * sizeof WCHAR); directoryName[directoryLength] = L'\0'; } else if (fileNameLength > 4 && 0 == memcmp(fileName, L"\\\\?\\", 4 * sizeof WCHAR)) { // normalized local file file->unc = FALSE; memcpy(directoryName, fileName, directoryLength * sizeof WCHAR); directoryName[directoryLength] = L'\0'; } else if (fileNameLength > 2 && 0 == memcmp(fileName, L"\\\\", 2 * sizeof(WCHAR))) { // not normalized UNC path file->unc = TRUE; wcscpy(directoryName, L"\\\\?\\UNC\\"); memcpy(directoryName + 8, fileName + 2, (directoryLength - 2) * sizeof WCHAR); directoryName[8 + directoryLength - 2] = L'\0'; } else { // not normalized local file file->unc = FALSE; wcscpy(directoryName, L"\\\\?\\"); memcpy(directoryName + 4, fileName, directoryLength * sizeof WCHAR); directoryName[4 + directoryLength] = L'\0'; } // find matching directory watcher entry directory = this->directories; while (NULL != directory) { if (0 == wcscmp(directory->directoryName, directoryName)) { delete [] directoryName; directoryName = NULL; break; } directory = directory->next; } // if directory watcher not found, create one if (NULL == directory) { ErrorIf(NULL == (newDirectory = new WatchedDirectory), ERROR_NOT_ENOUGH_MEMORY); RtlZeroMemory(newDirectory, sizeof WatchedDirectory); newDirectory->directoryName = directoryName; directoryName = NULL; newDirectory->files = file; ErrorIf(INVALID_HANDLE_VALUE == (newDirectory->watchHandle = CreateFileW( newDirectory->directoryName, FILE_LIST_DIRECTORY, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OVERLAPPED, NULL)), GetLastError()); ErrorIf(NULL == CreateIoCompletionPort(newDirectory->watchHandle, this->completionPort, (ULONG_PTR)newDirectory, 0), GetLastError()); ErrorIf(0 == ReadDirectoryChangesW( newDirectory->watchHandle, &newDirectory->info, sizeof newDirectory->info, FALSE, FILE_NOTIFY_CHANGE_LAST_WRITE, NULL, &newDirectory->overlapped, NULL), GetLastError()); if (NULL == this->directories) { // no watchers exist yet, start the watcher thread ErrorIf(NULL == (this->worker = (HANDLE)_beginthreadex( NULL, 4096, CFileWatcher::Worker, this, 0, NULL)), ERROR_NOT_ENOUGH_MEMORY); } newDirectory->next = this->directories; this->directories = newDirectory; newDirectory = NULL; } else { file->next = directory->files; directory->files = file; file = NULL; } return S_OK; Error: if (NULL != newDirectory) { if (NULL != newDirectory->directoryName) { delete [] newDirectory->directoryName; } if (NULL != newDirectory->watchHandle) { CloseHandle(newDirectory->watchHandle); } delete newDirectory; } if (NULL != file) { delete [] file->fileName; delete file; } if (NULL != directoryName) { delete [] directoryName; } return hr; }
bool FileSystem::openAndSeekFileSharedRead(QFile *file, QString *errorOrNull, qint64 seek) { QString errorDummy; // avoid many if (errorOrNull) later. QString &error = errorOrNull ? *errorOrNull : errorDummy; error.clear(); #ifdef Q_OS_WIN // // The following code is adapted from Qt's QFSFileEnginePrivate::nativeOpen() // by including the FILE_SHARE_DELETE share mode. // // Enable full sharing. DWORD shareMode = FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE; int accessRights = GENERIC_READ; DWORD creationDisp = OPEN_EXISTING; // Create the file handle. SECURITY_ATTRIBUTES securityAtts = { sizeof(SECURITY_ATTRIBUTES), NULL, FALSE }; QString fName = longWinPath(file->fileName()); HANDLE fileHandle = CreateFileW( (const wchar_t *)fName.utf16(), accessRights, shareMode, &securityAtts, creationDisp, FILE_ATTRIBUTE_NORMAL, NULL); // Bail out on error. if (fileHandle == INVALID_HANDLE_VALUE) { error = qt_error_string(); return false; } // Convert the HANDLE to an fd and pass it to QFile's foreign-open // function. The fd owns the handle, so when QFile later closes // the fd the handle will be closed too. int fd = _open_osfhandle((intptr_t)fileHandle, _O_RDONLY); if (fd == -1) { error = "could not make fd from handle"; return false; } if (!file->open(fd, QIODevice::ReadOnly, QFile::AutoCloseHandle)) { error = file->errorString(); return false; } // Seek to the right spot LARGE_INTEGER *li = reinterpret_cast<LARGE_INTEGER *>(&seek); DWORD newFilePointer = SetFilePointer(fileHandle, li->LowPart, &li->HighPart, FILE_BEGIN); if (newFilePointer == 0xFFFFFFFF && GetLastError() != NO_ERROR) { error = qt_error_string(); return false; } return true; #else if (!file->open(QFile::ReadOnly)) { error = file->errorString(); return false; } if (!file->seek(seek)) { error = file->errorString(); return false; } return true; #endif }
bool create_bob_txt() { wchar_t *buf = NULL; uint32_t buflen = 0; buflen = GetCurrentDirectoryW(buflen, buf); if (buflen == 0) { printf("[error] GetCurrentDirectoryW() failed!!! gle = 0x%08x\n", GetLastError()); return false; } buf = (PWSTR)malloc(sizeof(WCHAR)*buflen); if (GetCurrentDirectoryW(buflen, buf) == 0) { printf("[error] GetCurrentDirectoryW() failed!!! gle = 0x%08x\n", GetLastError()); free(buf); return false; } // current directory\\bob.txt 생성 wchar_t file_name[260]; if (!SUCCEEDED(StringCbPrintfW( file_name, sizeof(file_name), L"%ws\\bob.txt", buf))) { printf("[error] can not create bob.txt\n"); free(buf); return false; } free(buf); buf = NULL; if (is_file_existsW(file_name)) { DeleteFileW(file_name); } // 파일 생성 HANDLE file_handle = CreateFileW( file_name, GENERIC_WRITE, FILE_SHARE_READ, NULL, CREATE_NEW, FILE_ATTRIBUTE_NORMAL, NULL); ///////////////////////////////////////////////////////// DWORD numberOfBytesWritten; int result; unsigned char mark[3]; mark[0] = 0xEF; mark[1] = 0xBB; // UTF-8 mark[2] = 0xBF; wchar_t strUnicode[256] = L"안녕하세요 굳 굳굳 HelloWorld"; char strUtf8[256] = { 0, }; if (file_handle == INVALID_HANDLE_VALUE) { printf("[error] can not CreateFile, gle=0x%08x\n", GetLastError()); return false; } int nlen = WideCharToMultiByte(CP_UTF8, 0, strUnicode, lstrlenW(strUnicode), NULL, 0, NULL, NULL); WideCharToMultiByte(CP_UTF8, 0, strUnicode, lstrlenW(strUnicode), strUtf8, nlen, NULL, NULL); result = WriteFile(file_handle, &mark, 3, &numberOfBytesWritten, NULL); result = WriteFile(file_handle, strUtf8, strlen(strUtf8), &numberOfBytesWritten, NULL); // bob.txt -> bob2.txt 파일 복사 LPCWSTR file_name2 = L"C:\\Users\\kahissa\\Documents\\Visual Studio 2013\\Projects\\Console_test1\\bob2.txt"; CopyFile(file_name, file_name2, false); // bob2.txt 파일 내용 읽기 char readBuf[256] = { 0, }; DWORD dwRead = 0; BOOL readOK; HANDLE file_handle2 = CreateFileW(file_name2, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); if (file_handle2 == INVALID_HANDLE_VALUE) { printf("[error] can not file open, gle=0x%08x\n", GetLastError()); } readOK = ReadFile(file_handle2, readBuf, 256, &dwRead, NULL); // 파일 내용 읽어서 rBuf에 저장 if (readOK && dwRead == 0) printf("[error] can not read file, gle=0x%08x\n", GetLastError()); //readBuf에 UTF8 적용 int len = MultiByteToWideChar(CP_UTF8, 0, readBuf, strlen(readBuf), NULL, NULL); wchar_t MultiByte[256] = { 0, }; // UTF8 -> 유니코드 MultiByteToWideChar(CP_UTF8, 0, readBuf, strlen(readBuf), MultiByte, len); char MultiByte2[256] = { 0, }; /// 유니코드 -> 멀티바이트 len = WideCharToMultiByte(CP_ACP, 0, MultiByte, -1, NULL, 0, NULL, NULL); WideCharToMultiByte(CP_ACP, 0, MultiByte, -1, MultiByte2, len, NULL, NULL); printf("%s\n", MultiByte2 + 1); // header 다음부터 출력 CloseHandle(file_handle); CloseHandle(file_handle2); DeleteFile(file_name); DeleteFile(file_name2); return true; }
RTR3DECL(int) RTPathSetTimesEx(const char *pszPath, PCRTTIMESPEC pAccessTime, PCRTTIMESPEC pModificationTime, PCRTTIMESPEC pChangeTime, PCRTTIMESPEC pBirthTime, uint32_t fFlags) { /* * Validate input. */ AssertPtrReturn(pszPath, VERR_INVALID_POINTER); AssertReturn(*pszPath, VERR_INVALID_PARAMETER); AssertPtrNullReturn(pAccessTime, VERR_INVALID_POINTER); AssertPtrNullReturn(pModificationTime, VERR_INVALID_POINTER); AssertPtrNullReturn(pChangeTime, VERR_INVALID_POINTER); AssertPtrNullReturn(pBirthTime, VERR_INVALID_POINTER); AssertMsgReturn(RTPATH_F_IS_VALID(fFlags, 0), ("%#x\n", fFlags), VERR_INVALID_PARAMETER); /* * Convert the path. */ PRTUTF16 pwszPath; int rc = RTStrToUtf16(pszPath, &pwszPath); if (RT_SUCCESS(rc)) { HANDLE hFile; if (fFlags & RTPATH_F_FOLLOW_LINK) hFile = CreateFileW(pwszPath, FILE_WRITE_ATTRIBUTES, /* dwDesiredAccess */ FILE_SHARE_WRITE | FILE_SHARE_READ | FILE_SHARE_DELETE, /* dwShareMode */ NULL, /* security attribs */ OPEN_EXISTING, /* dwCreationDisposition */ FILE_FLAG_BACKUP_SEMANTICS | FILE_ATTRIBUTE_NORMAL, NULL); else { /** @todo Symlink: Test RTPathSetTimesEx on Windows. (The code is disabled * because it's not tested yet.) */ #if 0 //def FILE_FLAG_OPEN_REPARSE_POINT hFile = CreateFileW(pwszPath, FILE_WRITE_ATTRIBUTES, /* dwDesiredAccess */ FILE_SHARE_WRITE | FILE_SHARE_READ | FILE_SHARE_DELETE, /* dwShareMode */ NULL, /* security attribs */ OPEN_EXISTING, /* dwCreationDisposition */ FILE_FLAG_BACKUP_SEMANTICS | FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OPEN_REPARSE_POINT, NULL); if (hFile == INVALID_HANDLE_VALUE && GetLastError() == ERROR_INVALID_PARAMETER) #endif hFile = CreateFileW(pwszPath, FILE_WRITE_ATTRIBUTES, /* dwDesiredAccess */ FILE_SHARE_WRITE | FILE_SHARE_READ | FILE_SHARE_DELETE, /* dwShareMode */ NULL, /* security attribs */ OPEN_EXISTING, /* dwCreationDisposition */ FILE_FLAG_BACKUP_SEMANTICS | FILE_ATTRIBUTE_NORMAL, NULL); } if (hFile != INVALID_HANDLE_VALUE) { /* * Check if it's a no-op. */ if (!pAccessTime && !pModificationTime && !pBirthTime) rc = VINF_SUCCESS; /* NOP */ else { /* * Convert the input and call the API. */ FILETIME CreationTimeFT; PFILETIME pCreationTimeFT = NULL; if (pBirthTime) pCreationTimeFT = RTTimeSpecGetNtFileTime(pBirthTime, &CreationTimeFT); FILETIME LastAccessTimeFT; PFILETIME pLastAccessTimeFT = NULL; if (pAccessTime) pLastAccessTimeFT = RTTimeSpecGetNtFileTime(pAccessTime, &LastAccessTimeFT); FILETIME LastWriteTimeFT; PFILETIME pLastWriteTimeFT = NULL; if (pModificationTime) pLastWriteTimeFT = RTTimeSpecGetNtFileTime(pModificationTime, &LastWriteTimeFT); if (SetFileTime(hFile, pCreationTimeFT, pLastAccessTimeFT, pLastWriteTimeFT)) rc = VINF_SUCCESS; else { DWORD Err = GetLastError(); rc = RTErrConvertFromWin32(Err); Log(("RTPathSetTimes('%s', %p, %p, %p, %p): SetFileTime failed with lasterr %d (%Rrc)\n", pszPath, pAccessTime, pModificationTime, pChangeTime, pBirthTime, Err, rc)); } } BOOL fRc = CloseHandle(hFile); Assert(fRc); NOREF(fRc); } else { DWORD Err = GetLastError(); rc = RTErrConvertFromWin32(Err); Log(("RTPathSetTimes('%s',,,,): failed with %Rrc and lasterr=%u\n", pszPath, rc, Err)); } RTUtf16Free(pwszPath); } LogFlow(("RTPathSetTimes(%p:{%s}, %p:{%RDtimespec}, %p:{%RDtimespec}, %p:{%RDtimespec}, %p:{%RDtimespec}): return %Rrc\n", pszPath, pszPath, pAccessTime, pAccessTime, pModificationTime, pModificationTime, pChangeTime, pChangeTime, pBirthTime, pBirthTime)); return rc; }
/* * Code based off of code located here * http://www.codeproject.com/gdi/fontnamefromfile.asp */ static WCHAR *load_ttf_name_id( const WCHAR *filename, DWORD id ) { TT_TABLE_DIRECTORY tblDir; BOOL bFound = FALSE; TT_OFFSET_TABLE ttOffsetTable; TT_NAME_TABLE_HEADER ttNTHeader; TT_NAME_RECORD ttRecord; DWORD dwRead; HANDLE handle; LPWSTR ret = NULL; int i; handle = CreateFileW(filename ,GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0 ); if (handle == INVALID_HANDLE_VALUE) { ERR("Unable to open font file %s\n", debugstr_w(filename)); return NULL; } if (!ReadFile(handle,&ttOffsetTable, sizeof(TT_OFFSET_TABLE),&dwRead,NULL)) goto end; ttOffsetTable.uNumOfTables = SWAPWORD(ttOffsetTable.uNumOfTables); ttOffsetTable.uMajorVersion = SWAPWORD(ttOffsetTable.uMajorVersion); ttOffsetTable.uMinorVersion = SWAPWORD(ttOffsetTable.uMinorVersion); if ((ttOffsetTable.uMajorVersion != 1 || ttOffsetTable.uMinorVersion != 0) && (ttOffsetTable.uMajorVersion != 0x4f54 || ttOffsetTable.uMinorVersion != 0x544f)) goto end; for (i=0; i< ttOffsetTable.uNumOfTables; i++) { if (!ReadFile(handle,&tblDir, sizeof(TT_TABLE_DIRECTORY),&dwRead,NULL)) break; if (memcmp(tblDir.szTag,"name",4)==0) { bFound = TRUE; tblDir.uLength = SWAPLONG(tblDir.uLength); tblDir.uOffset = SWAPLONG(tblDir.uOffset); break; } } if (!bFound) goto end; SetFilePointer(handle, tblDir.uOffset, NULL, FILE_BEGIN); if (!ReadFile(handle,&ttNTHeader, sizeof(TT_NAME_TABLE_HEADER), &dwRead,NULL)) goto end; ttNTHeader.uNRCount = SWAPWORD(ttNTHeader.uNRCount); ttNTHeader.uStorageOffset = SWAPWORD(ttNTHeader.uStorageOffset); for(i=0; i<ttNTHeader.uNRCount; i++) { if (!ReadFile(handle,&ttRecord, sizeof(TT_NAME_RECORD),&dwRead,NULL)) break; ttRecord.uNameID = SWAPWORD(ttRecord.uNameID); ttRecord.uPlatformID = SWAPWORD(ttRecord.uPlatformID); ttRecord.uEncodingID = SWAPWORD(ttRecord.uEncodingID); if (ttRecord.uNameID == id && ttRecord.uPlatformID == 3 && (ttRecord.uEncodingID == 0 || ttRecord.uEncodingID == 1)) { WCHAR *buf; unsigned int i; ttRecord.uStringLength = SWAPWORD(ttRecord.uStringLength); ttRecord.uStringOffset = SWAPWORD(ttRecord.uStringOffset); SetFilePointer(handle, tblDir.uOffset + ttRecord.uStringOffset + ttNTHeader.uStorageOffset, NULL, FILE_BEGIN); if (!(buf = msi_alloc_zero( ttRecord.uStringLength + sizeof(WCHAR) ))) goto end; dwRead = 0; ReadFile(handle, buf, ttRecord.uStringLength, &dwRead, NULL); if (dwRead % sizeof(WCHAR)) { msi_free(buf); goto end; } for (i = 0; i < dwRead / sizeof(WCHAR); i++) buf[i] = SWAPWORD(buf[i]); ret = strdupW(buf); msi_free(buf); break; } } end: CloseHandle(handle); return ret; }
bool create_bob_txt() { // current directory 를 구한다. wchar_t *buf=NULL; uint32_t buflen = 0; buflen = GetCurrentDirectoryW(buflen, buf); if (0 == buflen) { print("err, GetCurrentDirectoryW() failed. gle = 0x%08x", GetLastError()); return false; } buf = (PWSTR) malloc(sizeof(WCHAR) * buflen); if (0 == GetCurrentDirectoryW(buflen, buf)) { print("err, GetCurrentDirectoryW() failed. gle = 0x%08x", GetLastError()); free(buf); return false; } // current dir \\ bob.txt 파일명 생성 wchar_t file_name[260]; if (!SUCCEEDED(StringCbPrintfW( file_name, sizeof(file_name), L"%ws\\bob.txt", buf))) { print("err, can not create file name"); free(buf); return false; } free(buf); buf = NULL; if (true == is_file_existsW(file_name)) { ::DeleteFileW(file_name); } // 파일 생성 HANDLE file_handle = CreateFileW( file_name, GENERIC_WRITE, FILE_SHARE_READ, NULL, CREATE_NEW, FILE_ATTRIBUTE_NORMAL, NULL); if(file_handle == INVALID_HANDLE_VALUE) { print("err, CreateFile(path=%ws), gle=0x%08x", file_name, GetLastError()); return false; } // 파일에 데이터 쓰기 DWORD bytes_written = 0; wchar_t string_buf[1024]; if (!SUCCEEDED(StringCbPrintfW( string_buf, sizeof(string_buf), L"동해물과 백두산이 마르고 닳도록 하느님이 보우하사 우리나라만세"))) { print("err, can not create data to write."); CloseHandle(file_handle); return false; } if (!WriteFile(file_handle, string_buf, wcslen(string_buf), &bytes_written, NULL)) { print("err, WriteFile() failed. gle = 0x%08x", GetLastError()); CloseHandle(file_handle); return false; } // 영어로 쓰기 if (!SUCCEEDED(StringCbPrintfW( string_buf, sizeof(string_buf), L"All work and no play makes jack a dull boy."))) { print("err, can not create data to write."); CloseHandle(file_handle); return false; } if (!WriteFile(file_handle, string_buf, wcslen(string_buf), &bytes_written, NULL)) { print("err, WriteFile() failed. gle = 0x%08x", GetLastError()); CloseHandle(file_handle); return false; } char string_bufa[1024]; if (!SUCCEEDED(StringCbPrintfA( string_bufa, sizeof(string_bufa), "동해물과 백두산이 마르고 닳도록 하느님이 보우하사 우리나라만세"))) { print("err, can not create data to write."); CloseHandle(file_handle); return false; } if (!WriteFile(file_handle, string_bufa, strlen(string_bufa), &bytes_written, NULL)) { print("err, WriteFile() failed. gle = 0x%08x", GetLastError()); CloseHandle(file_handle); return false; } // 영어로 쓰기 if (!SUCCEEDED(StringCbPrintfA( string_bufa, sizeof(string_bufa), "All work and no play makes jack a dull boy."))) { print("err, can not create data to write."); CloseHandle(file_handle); return false; } if (!WriteFile(file_handle, string_bufa, strlen(string_bufa), &bytes_written, NULL)) { print("err, WriteFile() failed. gle = 0x%08x", GetLastError()); CloseHandle(file_handle); return false; } // 파일 닫기 CloseHandle(file_handle); return true; }
void uv_pipe_connect(uv_connect_t* req, uv_pipe_t* handle, const char* name, uv_connect_cb cb) { uv_loop_t* loop = handle->loop; int errno, nameSize; HANDLE pipeHandle; handle->handle = INVALID_HANDLE_VALUE; uv_req_init(loop, (uv_req_t*) req); req->type = UV_CONNECT; req->handle = (uv_stream_t*) handle; req->cb = cb; /* Convert name to UTF16. */ nameSize = uv_utf8_to_utf16(name, NULL, 0) * sizeof(wchar_t); handle->name = (wchar_t*)malloc(nameSize); if (!handle->name) { uv_fatal_error(ERROR_OUTOFMEMORY, "malloc"); } if (!uv_utf8_to_utf16(name, handle->name, nameSize / sizeof(wchar_t))) { errno = GetLastError(); goto error; } pipeHandle = CreateFileW(handle->name, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL); if (pipeHandle == INVALID_HANDLE_VALUE) { if (GetLastError() == ERROR_PIPE_BUSY) { /* Wait for the server to make a pipe instance available. */ if (!QueueUserWorkItem(&pipe_connect_thread_proc, req, WT_EXECUTELONGFUNCTION)) { errno = GetLastError(); goto error; } handle->reqs_pending++; return; } errno = GetLastError(); goto error; } if (uv_set_pipe_handle(loop, (uv_pipe_t*)req->handle, pipeHandle)) { errno = GetLastError(); goto error; } handle->handle = pipeHandle; SET_REQ_SUCCESS(req); uv_insert_pending_req(loop, (uv_req_t*) req); handle->reqs_pending++; return; error: if (handle->name) { free(handle->name); handle->name = NULL; } if (pipeHandle != INVALID_HANDLE_VALUE) { CloseHandle(pipeHandle); } /* Make this req pending reporting an error. */ SET_REQ_ERROR(req, errno); uv_insert_pending_req(loop, (uv_req_t*) req); handle->reqs_pending++; return; }
int cop_filemap_open(struct cop_filemap *map, const char *filename, unsigned flags) { DWORD faccess; DWORD mapprotect; DWORD mapaccess; LARGE_INTEGER fsz; LPWSTR wfn; int fnlen; if ((flags & COP_FILEMAP_FLAG_W) == 0) { /* read only access */ faccess = GENERIC_READ; mapprotect = PAGE_READONLY; mapaccess = FILE_MAP_READ; } else if ((flags & COP_FILEMAP_SHARED)) { /* shared write access */ faccess = GENERIC_READ | GENERIC_WRITE; mapprotect = PAGE_READWRITE; mapaccess = FILE_MAP_WRITE; } else { /* unshared write access */ faccess = GENERIC_READ; mapprotect = PAGE_READONLY; mapaccess = FILE_MAP_COPY; } fnlen = MultiByteToWideChar(CP_UTF8, 0, filename, -1, NULL, 0); if (fnlen == 0) return -1; wfn = malloc(sizeof(*wfn) * fnlen); if (wfn == NULL) return -1; if (MultiByteToWideChar(CP_UTF8, 0, filename, -1, wfn, fnlen) != fnlen) { free(wfn); return -1; } map->filehandle = CreateFileW(wfn, faccess, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); if (map->filehandle == INVALID_HANDLE_VALUE) { free(wfn); return -1; } free(wfn); if (!GetFileSizeEx(map->filehandle, &fsz)) { CloseHandle(map->filehandle); return -1; } if (fsz.QuadPart > SIZE_MAX) { CloseHandle(map->filehandle); return -1; } map->size = (size_t)fsz.QuadPart; map->maphandle = CreateFileMapping(map->filehandle, NULL, mapprotect, 0, 0, NULL); if (map->maphandle == INVALID_HANDLE_VALUE) { CloseHandle(map->filehandle); return -1; } map->ptr = MapViewOfFile(map->maphandle, mapaccess, 0, 0, 0); if (map->ptr == NULL) { CloseHandle(map->maphandle); CloseHandle(map->filehandle); return -1; } return 0; }
int __cdecl main(int argc, char *argv[]) { DWORD dwRc = 0; WCHAR szReturnedPath[_MAX_DIR+1]; WCHAR szFullFileName[_MAX_DIR+1]; WCHAR szDirectory[256]; WCHAR szCreatedDir[] = {'t','e','s','t','_','d','i','r','\0'}; LPWSTR pPathPtr; HANDLE hFile = NULL; BOOL bRetVal = FAIL; /* Initialize the PAL. */ if (0 != PAL_Initialize(argc,argv)) { return (FAIL); } /* Initialize the buffer. */ memset(szDirectory, '\0', 256); /* Create the path to the next level of directory to create. */ wcscat(szDirectory, szDotDot); /* .. */ wcscat(szDirectory, szSeperator); /* ../ */ wcscat(szDirectory, szCreatedDir); /* ../test_directory */ /* Create a test directory. */ if (!CreateDirectoryW(szDirectory, NULL)) { Fail("ERROR:%u: Unable to create directories \"%S\".\n", GetLastError(), szDirectory); } /* Initialize the receiving char buffers. */ memset(szReturnedPath, 0, _MAX_DIR+1); memset(szFullFileName, 0, _MAX_DIR+1); /* Create Full filename to pass, will include '..\' * in the middle of the path. */ wcscat( szFullFileName, szDotDot ); /* .. */ wcscat( szFullFileName, szSeperator ); /* ../ */ wcscat( szFullFileName, szCreatedDir ); /* ../test_directory */ wcscat( szFullFileName, szSeperator ); /* ../test_directory/ */ wcscat( szFullFileName, szFileName ); /* ../test_directory/testing.tmp */ /* Get the full path to the filename. */ dwRc = GetFullPathNameW(szFullFileName, _MAX_DIR, szReturnedPath, &pPathPtr); if (dwRc == 0) { Trace("ERROR :%ld: GetFullPathName failed to " "retrieve the path of \"%S\".\n", GetLastError(), szFileName); bRetVal = FAIL; goto cleanUpOne; } /* The returned value should be the parent directory with the * file name appended. */ hFile = CreateFileW(szReturnedPath, GENERIC_READ, FILE_SHARE_READ, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); if (hFile == INVALID_HANDLE_VALUE) { Trace("ERROR :%ld: CreateFileA failed to create \"%S\".\n", GetLastError(), szReturnedPath); bRetVal = FAIL; goto cleanUpOne; } /* Close the handle to the created file. */ if (CloseHandle(hFile) != TRUE) { Trace("ERROR :%ld: CloseHandle failed close hFile=0x%lx.\n", GetLastError()); bRetVal = FAIL; goto cleanUpTwo; } /* Verify that the file was created, attempt to create * the file again. */ hFile = CreateFileW(szReturnedPath, GENERIC_READ, FILE_SHARE_READ, NULL, CREATE_NEW, FILE_ATTRIBUTE_NORMAL, NULL); if ((hFile != INVALID_HANDLE_VALUE) && (GetLastError() != ERROR_ALREADY_EXISTS)) { Trace("ERROR :%ld: CreateFileA succeeded to create file " "\"%S\", that already existed.\n", GetLastError(), szFullFileName); bRetVal = FAIL; goto cleanUpTwo; } /* Verify that the returned filename is the same as the supplied. */ if (wcscmp(pPathPtr, szFileName) != 0) { Trace("ERROR : Returned filename \"%S\" is not equal to " "supplied filename \"%S\".\n", pPathPtr, szFileName); bRetVal = FAIL; goto cleanUpTwo; } /* Successful test. */ bRetVal = PASS; cleanUpTwo: /* Delete the create file. */ if (DeleteFileW(szReturnedPath) != TRUE) { Fail("ERROR :%ld: DeleteFileA failed to delete \"%S\".\n", GetLastError(), szFileName); } cleanUpOne: /* Remove the empty directory. */ if (!RemoveDirectoryW(szDirectory)) { Fail("ERROR:%u: Unable to remove directory \"%s\".\n", GetLastError(), szCreatedDir); } /* Terminate the PAL.*/ PAL_Terminate(); return bRetVal; }
CPipe::CPipe(char *szName, DWORD dWait){ int iTemp; int iFlag = 1; WCHAR wbuffer[MAX_PATH+1]; dTHX; hPipe = 0; dBufferSize = BUFFER_SIZE; dBytes = 0; char szPipeName[PIPE_NAME_SIZE + 1]; dwOpenMode = PIPE_ACCESS_DUPLEX; dwPipeMode = PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT; nMaxInstances = PIPE_UNLIMITED_INSTANCES; nOutBufferSize = dBufferSize; nInBufferSize = dBufferSize; nDefaultTimeOut = PIPE_TIMEOUT; lpSecurityAttributes= NULL; iError = 0; strcpy((char *)szError, ""); cBuffer = new char [dBufferSize]; if (! cBuffer){ dBufferSize = 0; } memset((void *)szError, 0, ERROR_TEXT_SIZE); memset((void *)szPipeName, 0, PIPE_NAME_SIZE + 1); if (strncmp((char *)szName, "\\\\", 2) == 0){ iPipeType = CLIENT; iTemp = 0; }else{ iPipeType = SERVER; strcpy(szPipeName, PIPE_NAME_PREFIX); iTemp = strlen(PIPE_NAME_PREFIX); } strncat(szPipeName, szName, PIPE_NAME_SIZE - iTemp); if (USING_WIDE()) { A2WHELPER(szPipeName, wbuffer, sizeof(wbuffer)); } if(iPipeType == SERVER){ if (USING_WIDE()) { hPipe = CreateNamedPipeW(wbuffer, dwOpenMode, dwPipeMode, nMaxInstances, nOutBufferSize, nInBufferSize, nDefaultTimeOut, lpSecurityAttributes); } else { hPipe = CreateNamedPipeA(szPipeName, dwOpenMode, dwPipeMode, nMaxInstances, nOutBufferSize, nInBufferSize, nDefaultTimeOut, lpSecurityAttributes); } }else{ while(iFlag){ if (USING_WIDE()) { hPipe = CreateFileW(wbuffer, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_WRITE_THROUGH, NULL); } else { hPipe = CreateFileA(szPipeName, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_WRITE_THROUGH, NULL); } if (GetLastError() == ERROR_PIPE_BUSY){ if (USING_WIDE()) iFlag = WaitNamedPipeW(wbuffer, dWait); else iFlag = WaitNamedPipeA(szPipeName, dWait); }else{ iFlag = 0; } } } if (cBuffer == 0){ iError = 998; strcpy((char *)szError, "Could not allocate a buffer for the pipe connection"); } if (hPipe == INVALID_HANDLE_VALUE){ iError = 999; strcpy((char *)szError, "Could not connect"); delete this; } }
void* MemoryMappedFile::map(const char *filenameIn, unsigned long long &length, int options) { verify( fd == 0 && len == 0 ); // can't open more than once setFilename(filenameIn); FileAllocator::get()->allocateAsap( filenameIn, length ); /* big hack here: Babble uses db names with colons. doesn't seem to work on windows. temporary perhaps. */ char filename[256]; strncpy(filename, filenameIn, 255); filename[255] = 0; { size_t len = strlen( filename ); for ( size_t i=len-1; i>=0; i-- ) { if ( filename[i] == '/' || filename[i] == '\\' ) break; if ( filename[i] == ':' ) filename[i] = '_'; } } updateLength( filename, length ); { DWORD createOptions = FILE_ATTRIBUTE_NORMAL; if ( options & SEQUENTIAL ) createOptions |= FILE_FLAG_SEQUENTIAL_SCAN; DWORD rw = GENERIC_READ | GENERIC_WRITE; fd = CreateFileW( toWideString(filename).c_str(), rw, // desired access FILE_SHARE_WRITE | FILE_SHARE_READ, // share mode NULL, // security OPEN_ALWAYS, // create disposition createOptions , // flags NULL); // hTempl if ( fd == INVALID_HANDLE_VALUE ) { DWORD dosError = GetLastError(); log() << "CreateFileW for " << filename << " failed with " << errnoWithDescription( dosError ) << " (file size is " << length << ")" << " in MemoryMappedFile::map" << endl; return 0; } } mapped += length; { DWORD flProtect = PAGE_READWRITE; //(options & READONLY)?PAGE_READONLY:PAGE_READWRITE; maphandle = CreateFileMappingW(fd, NULL, flProtect, length >> 32 /*maxsizehigh*/, (unsigned) length /*maxsizelow*/, NULL/*lpName*/); if ( maphandle == NULL ) { DWORD dosError = GetLastError(); log() << "CreateFileMappingW for " << filename << " failed with " << errnoWithDescription( dosError ) << " (file size is " << length << ")" << " in MemoryMappedFile::map" << endl; close(); fassertFailed( 16225 ); } } void *view = 0; { scoped_lock lk(mapViewMutex); DWORD access = ( options & READONLY ) ? FILE_MAP_READ : FILE_MAP_ALL_ACCESS; LPVOID thisAddress = getNextMemoryMappedFileLocation( length ); view = MapViewOfFileEx( maphandle, // file mapping handle access, // access 0, 0, // file offset, high and low 0, // bytes to map, 0 == all thisAddress ); // address to place file if ( view == 0 ) { DWORD dosError = GetLastError(); log() << "MapViewOfFileEx for " << filename << " failed with " << errnoWithDescription( dosError ) << " (file size is " << length << ")" << " in MemoryMappedFile::map" << endl; close(); fassertFailed( 16166 ); } } views.push_back(view); memconcept::is(view, memconcept::concept::memorymappedfile, this->filename(), (unsigned) length); len = length; return view; }
/* * Parts of the The p_readlink function are heavily inspired by the php * readlink function in link_win32.c * * Copyright (c) 1999 - 2012 The PHP Group. All rights reserved. * * For details of the PHP license see http://www.php.net/license/3_01.txt */ int p_readlink(const char *link, char *target, size_t target_len) { typedef DWORD (WINAPI *fpath_func)(HANDLE, LPWSTR, DWORD, DWORD); static fpath_func pGetFinalPath = NULL; HANDLE hFile; DWORD dwRet; git_win32_path link_w; wchar_t* target_w; int error = 0; assert(link && target && target_len > 0); /* * Try to load the pointer to pGetFinalPath dynamically, because * it is not available in platforms older than Vista */ if (pGetFinalPath == NULL) { HMODULE module = GetModuleHandle("kernel32"); if (module != NULL) pGetFinalPath = (fpath_func)GetProcAddress(module, "GetFinalPathNameByHandleW"); if (pGetFinalPath == NULL) { giterr_set(GITERR_OS, "'GetFinalPathNameByHandleW' is not available in this platform"); return -1; } } git_win32_path_from_c(link_w, link); hFile = CreateFileW(link_w, // file to open GENERIC_READ, // open for reading FILE_SHARE_READ, // share for reading NULL, // default security OPEN_EXISTING, // existing file only FILE_FLAG_BACKUP_SEMANTICS, // normal file NULL); // no attr. template if (hFile == INVALID_HANDLE_VALUE) { giterr_set(GITERR_OS, "Cannot open '%s' for reading", link); return -1; } target_w = (wchar_t*)git__malloc(target_len * sizeof(wchar_t)); GITERR_CHECK_ALLOC(target_w); dwRet = pGetFinalPath(hFile, target_w, (DWORD)target_len, 0x0); if (dwRet == 0 || dwRet >= target_len || !WideCharToMultiByte(CP_UTF8, 0, target_w, -1, target, (int)(target_len * sizeof(char)), NULL, NULL)) error = -1; git__free(target_w); CloseHandle(hFile); if (error) return error; /* Skip first 4 characters if they are "\\?\" */ if (dwRet > 4 && target[0] == '\\' && target[1] == '\\' && target[2] == '?' && target[3] == '\\') { unsigned int offset = 4; dwRet -= 4; /* \??\UNC\ */ if (dwRet > 7 && target[4] == 'U' && target[5] == 'N' && target[6] == 'C') { offset += 2; dwRet -= 2; target[offset] = '\\'; } memmove(target, target + offset, dwRet); } target[dwRet] = '\0'; return dwRet; }
BOOL GetCatSignSubject(LPCWSTR FileFullPath, std::vector<std::string>& subInfo) { BOOL fRetval = FALSE; LPBYTE Hash = NULL; DWORD HashSize; CATALOG_INFO CatInfo; HANDLE hFile = NULL; HCATADMIN hCatAdmin; HCATINFO hCatInfo; HCATINFO PrevCat; DWORD Err; WINTRUST_DATA WintrustData; WINTRUST_CATALOG_INFO WintrustCatalogInfo; LPWSTR CatalogFullPath; WCHAR UnicodeKey[MAX_PATH]; GUID DriverVerifyGuid = DRIVER_ACTION_VERIFY; PWCHAR Key = NULL; if (NULL == m_pWinVerifyTrust) { return FALSE; } StringCchCopyW( UnicodeKey, MAX_PATH, FileFullPath ); Key = MyGetFileTitle( UnicodeKey ); if (!m_pCryptCATAdminAcquireContext( &hCatAdmin, &DriverVerifyGuid, 0 )) { goto clean0; } hFile = CreateFileW( FileFullPath, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE |FILE_SHARE_DELETE, NULL, OPEN_EXISTING, 0, NULL ); if (INVALID_HANDLE_VALUE == hFile) { goto clean0; } ZeroMemory(&WintrustData, sizeof(WINTRUST_DATA)); WintrustData.cbStruct = sizeof(WINTRUST_DATA); WintrustData.dwUIChoice = WTD_UI_NONE; WintrustData.fdwRevocationChecks = WTD_REVOKE_NONE; WintrustData.dwStateAction = WTD_STATEACTION_AUTO_CACHE; WintrustData.dwProvFlags = WTD_REVOCATION_CHECK_NONE; HashSize = 100; Hash = new BYTE[HashSize]; if(NULL == Hash) { goto clean0; } if (!m_pCryptCATAdminCalcHashFromFileHandle( hFile, &HashSize, Hash, 0 )) { goto clean0; } WintrustData.dwUnionChoice = WTD_CHOICE_CATALOG; WintrustData.pCatalog = &WintrustCatalogInfo; ZeroMemory(&WintrustCatalogInfo, sizeof(WINTRUST_CATALOG_INFO)); WintrustCatalogInfo.cbStruct = sizeof(WINTRUST_CATALOG_INFO); WintrustCatalogInfo.pbCalculatedFileHash = Hash; WintrustCatalogInfo.cbCalculatedFileHash = HashSize; StringCchCopyW( UnicodeKey, MAX_PATH, Key); CharLowerW( UnicodeKey ); WintrustCatalogInfo.pcwszMemberTag = UnicodeKey; PrevCat = NULL; hCatInfo = m_pCryptCATAdminEnumCatalogFromHash( hCatAdmin, Hash, HashSize, 0, &PrevCat ); while (hCatInfo) { CatInfo.cbStruct = sizeof(CATALOG_INFO); if (m_pCryptCATCatalogInfoFromContext( hCatInfo, &CatInfo, 0 )) { CatalogFullPath = CatInfo.wszCatalogFile; WintrustCatalogInfo.pcwszCatalogFilePath = CatInfo.wszCatalogFile; Err = (DWORD)m_pWinVerifyTrust(NULL, &DriverVerifyGuid, &WintrustData ); if (NO_ERROR == Err) { if (GetEmbedSignSubject(CatInfo.wszCatalogFile, subInfo)) { CHAR szInfo[1024] = {0}; WideCharToMultiByte( CP_ACP, 0, CatInfo.wszCatalogFile, -1, szInfo, 1024, NULL, NULL ); subInfo.push_back(std::string(szInfo)); // m_pCryptCATAdminReleaseCatalogContext( hCatAdmin, hCatInfo, 0 ); fRetval = TRUE; break; } } } PrevCat = hCatInfo; hCatInfo = m_pCryptCATAdminEnumCatalogFromHash( hCatAdmin, Hash, HashSize, 0, &PrevCat ); } clean0: if (Hash) { delete[] Hash; Hash = NULL; } if (hCatAdmin) { m_pCryptCATAdminReleaseContext( hCatAdmin, 0 ); } if (hFile) { ::CloseHandle( hFile ); hFile = NULL; } return fRetval; }
static DWORD shgfi_get_exe_type(LPCWSTR szFullPath) { BOOL status = FALSE; HANDLE hfile; DWORD BinaryType; IMAGE_DOS_HEADER mz_header; IMAGE_NT_HEADERS nt; DWORD len; char magic[4]; status = GetBinaryTypeW (szFullPath, &BinaryType); if (!status) return 0; if (BinaryType == SCS_DOS_BINARY || BinaryType == SCS_PIF_BINARY) return 0x4d5a; hfile = CreateFileW( szFullPath, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0 ); if ( hfile == INVALID_HANDLE_VALUE ) return 0; /* * The next section is adapted from MODULE_GetBinaryType, as we need * to examine the image header to get OS and version information. We * know from calling GetBinaryTypeA that the image is valid and either * an NE or PE, so much error handling can be omitted. * Seek to the start of the file and read the header information. */ SetFilePointer( hfile, 0, NULL, SEEK_SET ); ReadFile( hfile, &mz_header, sizeof(mz_header), &len, NULL ); SetFilePointer( hfile, mz_header.e_lfanew, NULL, SEEK_SET ); ReadFile( hfile, magic, sizeof(magic), &len, NULL ); if ( *(DWORD*)magic == IMAGE_NT_SIGNATURE ) { SetFilePointer( hfile, mz_header.e_lfanew, NULL, SEEK_SET ); ReadFile( hfile, &nt, sizeof(nt), &len, NULL ); CloseHandle( hfile ); /* DLL files are not executable and should return 0 */ if (nt.FileHeader.Characteristics & IMAGE_FILE_DLL) return 0; if (nt.OptionalHeader.Subsystem == IMAGE_SUBSYSTEM_WINDOWS_GUI) { return IMAGE_NT_SIGNATURE | (nt.OptionalHeader.MajorSubsystemVersion << 24) | (nt.OptionalHeader.MinorSubsystemVersion << 16); } return IMAGE_NT_SIGNATURE; } else if ( *(WORD*)magic == IMAGE_OS2_SIGNATURE ) { IMAGE_OS2_HEADER ne; SetFilePointer( hfile, mz_header.e_lfanew, NULL, SEEK_SET ); ReadFile( hfile, &ne, sizeof(ne), &len, NULL ); CloseHandle( hfile ); if (ne.ne_exetyp == 2) return IMAGE_OS2_SIGNATURE | (ne.ne_expver << 16); return 0; } CloseHandle( hfile ); return 0; }
int process_start(char *name, char *part, process_info_t *p, int is_helper) { HANDLE file = INVALID_HANDLE_VALUE; HANDLE nul = INVALID_HANDLE_VALUE; WCHAR path[MAX_PATH], filename[MAX_PATH]; WCHAR image[MAX_PATH + 1]; WCHAR args[MAX_PATH * 2]; STARTUPINFOW si; PROCESS_INFORMATION pi; DWORD result; if (GetTempPathW(sizeof(path) / sizeof(WCHAR), (WCHAR*)&path) == 0) goto error; if (GetTempFileNameW((WCHAR*)&path, L"uv", 0, (WCHAR*)&filename) == 0) goto error; file = CreateFileW((WCHAR*)filename, GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_TEMPORARY | FILE_FLAG_DELETE_ON_CLOSE, NULL); if (file == INVALID_HANDLE_VALUE) goto error; if (!SetHandleInformation(file, HANDLE_FLAG_INHERIT, HANDLE_FLAG_INHERIT)) goto error; nul = CreateFileA("nul", GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); if (nul == INVALID_HANDLE_VALUE) goto error; if (!SetHandleInformation(nul, HANDLE_FLAG_INHERIT, HANDLE_FLAG_INHERIT)) goto error; result = GetModuleFileNameW(NULL, (WCHAR*) &image, sizeof(image) / sizeof(WCHAR)); if (result == 0 || result == sizeof(image)) goto error; if (part) { if (_snwprintf((WCHAR*)args, sizeof(args) / sizeof(WCHAR), L"\"%s\" %S %S", image, name, part) < 0) { goto error; } } else { if (_snwprintf((WCHAR*)args, sizeof(args) / sizeof(WCHAR), L"\"%s\" %S", image, name) < 0) { goto error; } } memset((void*)&si, 0, sizeof(si)); si.cb = sizeof(si); si.dwFlags = STARTF_USESTDHANDLES; si.hStdInput = nul; si.hStdOutput = file; si.hStdError = file; if (!CreateProcessW(image, args, NULL, NULL, TRUE, 0, NULL, NULL, &si, &pi)) goto error; CloseHandle(pi.hThread); SetHandleInformation(nul, HANDLE_FLAG_INHERIT, 0); SetHandleInformation(file, HANDLE_FLAG_INHERIT, 0); p->stdio_in = nul; p->stdio_out = file; p->process = pi.hProcess; p->name = part; return 0; error: if (file != INVALID_HANDLE_VALUE) CloseHandle(file); if (nul != INVALID_HANDLE_VALUE) CloseHandle(nul); return -1; }
/*********************************************************************** * CryptCATOpen (WINTRUST.@) */ HANDLE WINAPI CryptCATOpen(LPWSTR pwszFileName, DWORD fdwOpenFlags, HCRYPTPROV hProv, DWORD dwPublicVersion, DWORD dwEncodingType) { HANDLE file, hmsg; BYTE *buffer = NULL; DWORD size, flags = OPEN_EXISTING; struct cryptcat *cc; TRACE("%s, %x, %lx, %x, %x\n", debugstr_w(pwszFileName), fdwOpenFlags, hProv, dwPublicVersion, dwEncodingType); if (!pwszFileName) { SetLastError(ERROR_INVALID_PARAMETER); return INVALID_HANDLE_VALUE; } if (!dwEncodingType) dwEncodingType = X509_ASN_ENCODING | PKCS_7_ASN_ENCODING; if (fdwOpenFlags & CRYPTCAT_OPEN_ALWAYS) flags |= OPEN_ALWAYS; if (fdwOpenFlags & CRYPTCAT_OPEN_CREATENEW) flags |= CREATE_NEW; file = CreateFileW(pwszFileName, GENERIC_READ, FILE_SHARE_READ, NULL, flags, 0, NULL); if (file == INVALID_HANDLE_VALUE) return INVALID_HANDLE_VALUE; size = GetFileSize(file, NULL); if (!(buffer = HeapAlloc(GetProcessHeap(), 0, size))) { CloseHandle(file); SetLastError(ERROR_OUTOFMEMORY); return INVALID_HANDLE_VALUE; } if (!(hmsg = CryptMsgOpenToDecode(dwEncodingType, 0, 0, hProv, NULL, NULL))) { CloseHandle(file); HeapFree(GetProcessHeap(), 0, buffer); return INVALID_HANDLE_VALUE; } if (!ReadFile(file, buffer, size, &size, NULL) || !CryptMsgUpdate(hmsg, buffer, size, TRUE)) { CloseHandle(file); HeapFree(GetProcessHeap(), 0, buffer); CryptMsgClose(hmsg); return INVALID_HANDLE_VALUE; } HeapFree(GetProcessHeap(), 0, buffer); CloseHandle(file); size = sizeof(DWORD); if (!(cc = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*cc)))) { CryptMsgClose(hmsg); SetLastError(ERROR_OUTOFMEMORY); return INVALID_HANDLE_VALUE; } cc->msg = hmsg; cc->encoding = dwEncodingType; if (CryptMsgGetParam(hmsg, CMSG_ATTR_CERT_COUNT_PARAM, 0, &cc->attr_count, &size)) { DWORD i, sum = 0; BYTE *p; for (i = 0; i < cc->attr_count; i++) { if (!CryptMsgGetParam(hmsg, CMSG_ATTR_CERT_PARAM, i, NULL, &size)) { CryptMsgClose(hmsg); return INVALID_HANDLE_VALUE; } sum += size; } if (!(cc->attr = HeapAlloc(GetProcessHeap(), 0, sizeof(*cc->attr) * cc->attr_count + sum))) { CryptMsgClose(hmsg); SetLastError(ERROR_OUTOFMEMORY); return INVALID_HANDLE_VALUE; } p = (BYTE *)(cc->attr + cc->attr_count); for (i = 0; i < cc->attr_count; i++) { if (!CryptMsgGetParam(hmsg, CMSG_ATTR_CERT_PARAM, i, NULL, &size)) { CryptMsgClose(hmsg); HeapFree(GetProcessHeap(), 0, cc->attr); return INVALID_HANDLE_VALUE; } if (!CryptMsgGetParam(hmsg, CMSG_ATTR_CERT_PARAM, i, p, &size)) { CryptMsgClose(hmsg); HeapFree(GetProcessHeap(), 0, cc->attr); return INVALID_HANDLE_VALUE; } p += size; } cc->inner = decode_inner_content(hmsg, dwEncodingType, &cc->inner_len); if (!cc->inner || !CryptSIPRetrieveSubjectGuid(pwszFileName, NULL, &cc->subject)) { CryptMsgClose(hmsg); HeapFree(GetProcessHeap(), 0, cc->attr); HeapFree(GetProcessHeap(), 0, cc->inner); HeapFree(GetProcessHeap(), 0, cc); return INVALID_HANDLE_VALUE; } cc->magic = CRYPTCAT_MAGIC; return cc; } return INVALID_HANDLE_VALUE; }
// Entry point where control comes on an unhandled exception static LONG WINAPI TopLevelExceptionFilter(PEXCEPTION_POINTERS pExceptionInfo) { static bool bBeenHere = FALSE; if(!bBeenHere) { UINT fuOldErrorMode; bBeenHere = TRUE; fuOldErrorMode = SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX | SEM_NOOPENFILEERRORBOX); hReportFile = CreateFileW( szLogFileName, GENERIC_WRITE, 0, 0, OPEN_ALWAYS, FILE_FLAG_WRITE_THROUGH, 0 ); if (hReportFile == INVALID_HANDLE_VALUE) { // Retrieve the system error message for the last-error code LPVOID lpMsgBuf; DWORD dw = GetLastError(); TCHAR szBuffer[4196]; FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, dw, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR) &lpMsgBuf, 0, NULL ); wsprintf(szBuffer, _T("Exception handler failed with error %d: %s\n"), dw, lpMsgBuf); MessageBox((HWND)MB_ICONEXCLAMATION, szBuffer, _T("Error"), MB_OK); LocalFree(lpMsgBuf); debug(LOG_ERROR, "Exception handler failed to create file!"); } #ifdef HAVE_BFD bfd_set_error_handler((bfd_error_handler_type) rprintf); #endif /* HAVE_BFD */ if (hReportFile) { wchar_t szBuffer[4196]; int err; SetFilePointer(hReportFile, 0, 0, FILE_END); // FIXME: We don't return from the below function call GenerateExceptionReport(pExceptionInfo); CloseHandle(hReportFile); wsprintfW(szBuffer, L"Warzone has crashed.\r\nSee %s for more details\r\n", szLogFileName); err = MessageBoxW((HWND)MB_ICONERROR, szBuffer, L"Warzone Crashed!", MB_OK | MB_ICONERROR); if (err == 0) { LPVOID lpMsgBuf; DWORD dw = GetLastError(); wchar_t szBuffer[4196]; FormatMessageW( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, dw, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPWSTR) &lpMsgBuf, 0, NULL ); wsprintfW(szBuffer, L"Exception handler failed with error %d: %s\n", dw, lpMsgBuf); MessageBoxW((HWND)MB_ICONEXCLAMATION, szBuffer, L"Error", MB_OK); LocalFree(lpMsgBuf); debug(LOG_ERROR, "Exception handler failed to create file!"); } hReportFile = 0; } SetErrorMode(fuOldErrorMode); } if(prevExceptionFilter) return prevExceptionFilter(pExceptionInfo); else return EXCEPTION_CONTINUE_SEARCH; }
static BOOL WINTRUST_GetSignedMsgFromPEFile(SIP_SUBJECTINFO *pSubjectInfo, DWORD *pdwEncodingType, DWORD dwIndex, DWORD *pcbSignedDataMsg, BYTE *pbSignedDataMsg) { BOOL ret; WIN_CERTIFICATE *pCert = NULL; HANDLE file; TRACE("(%p %p %d %p %p)\n", pSubjectInfo, pdwEncodingType, dwIndex, pcbSignedDataMsg, pbSignedDataMsg); if(pSubjectInfo->hFile && pSubjectInfo->hFile!=INVALID_HANDLE_VALUE) file = pSubjectInfo->hFile; else { file = CreateFileW(pSubjectInfo->pwsFileName, GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL); if(file == INVALID_HANDLE_VALUE) return FALSE; } if (!pbSignedDataMsg) { WIN_CERTIFICATE cert; /* app hasn't passed buffer, just get the length */ ret = ImageGetCertificateHeader(file, dwIndex, &cert); if (ret) { switch (cert.wCertificateType) { case WIN_CERT_TYPE_X509: case WIN_CERT_TYPE_PKCS_SIGNED_DATA: *pcbSignedDataMsg = cert.dwLength; break; default: WARN("unknown certificate type %d\n", cert.wCertificateType); ret = FALSE; } } } else { DWORD len = 0; ret = ImageGetCertificateData(file, dwIndex, NULL, &len); if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) goto error; pCert = HeapAlloc(GetProcessHeap(), 0, len); if (!pCert) { ret = FALSE; goto error; } ret = ImageGetCertificateData(file, dwIndex, pCert, &len); if (!ret) goto error; pCert->dwLength -= FIELD_OFFSET(WIN_CERTIFICATE, bCertificate); if (*pcbSignedDataMsg < pCert->dwLength) { *pcbSignedDataMsg = pCert->dwLength; SetLastError(ERROR_INSUFFICIENT_BUFFER); ret = FALSE; } else { memcpy(pbSignedDataMsg, pCert->bCertificate, pCert->dwLength); *pcbSignedDataMsg = pCert->dwLength; switch (pCert->wCertificateType) { case WIN_CERT_TYPE_X509: *pdwEncodingType = X509_ASN_ENCODING; break; case WIN_CERT_TYPE_PKCS_SIGNED_DATA: *pdwEncodingType = X509_ASN_ENCODING | PKCS_7_ASN_ENCODING; break; default: WARN("don't know what to do for encoding type %d\n", pCert->wCertificateType); *pdwEncodingType = 0; ret = FALSE; } } } error: if(pSubjectInfo->hFile != file) CloseHandle(file); HeapFree(GetProcessHeap(), 0, pCert); return ret; }
/** * Processes a software update command * * @param argc The number of arguments in argv * @param argv The arguments normally passed to updater.exe * argv[0] must be the path to updater.exe * @return TRUE if the update was successful. */ BOOL ProcessSoftwareUpdateCommand(DWORD argc, LPWSTR *argv) { BOOL result = TRUE; if (argc < 3) { LOG_WARN(("Not enough command line parameters specified. " "Updating update.status.")); // We can only update update.status if argv[1] exists. argv[1] is // the directory where the update.status file exists. if (argc < 2 || !WriteStatusFailure(argv[1], SERVICE_NOT_ENOUGH_COMMAND_LINE_ARGS)) { LOG_WARN(("Could not write update.status service update failure. (%d)", GetLastError())); } return FALSE; } WCHAR installDir[MAX_PATH] = {L'\0'}; if (!GetInstallationDir(argc, argv, installDir)) { LOG_WARN(("Could not get the installation directory")); if (!WriteStatusFailure(argv[1], SERVICE_INSTALLDIR_ERROR)) { LOG_WARN(("Could not write update.status for GetInstallationDir failure.")); } return FALSE; } // Make sure the path to the updater to use for the update is local. // We do this check to make sure that file locking is available for // race condition security checks. BOOL isLocal = FALSE; if (!IsLocalFile(argv[0], isLocal) || !isLocal) { LOG_WARN(("Filesystem in path %ls is not supported (%d)", argv[0], GetLastError())); if (!WriteStatusFailure(argv[1], SERVICE_UPDATER_NOT_FIXED_DRIVE)) { LOG_WARN(("Could not write update.status service update failure. (%d)", GetLastError())); } return FALSE; } nsAutoHandle noWriteLock(CreateFileW(argv[0], GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL)); if (INVALID_HANDLE_VALUE == noWriteLock) { LOG_WARN(("Could not set no write sharing access on file. (%d)", GetLastError())); if (!WriteStatusFailure(argv[1], SERVICE_COULD_NOT_LOCK_UPDATER)) { LOG_WARN(("Could not write update.status service update failure. (%d)", GetLastError())); } return FALSE; } // Verify that the updater.exe that we are executing is the same // as the one in the installation directory which we are updating. // The installation dir that we are installing to is installDir. WCHAR installDirUpdater[MAX_PATH + 1] = {L'\0'}; wcsncpy(installDirUpdater, installDir, MAX_PATH); if (!PathAppendSafe(installDirUpdater, L"updater.exe")) { LOG_WARN(("Install directory updater could not be determined.")); result = FALSE; } BOOL updaterIsCorrect; if (result && !VerifySameFiles(argv[0], installDirUpdater, updaterIsCorrect)) { LOG_WARN(("Error checking if the updaters are the same.\n" "Path 1: %ls\nPath 2: %ls", argv[0], installDirUpdater)); result = FALSE; } if (result && !updaterIsCorrect) { LOG_WARN(("The updaters do not match, udpater will not run.")); result = FALSE; } if (result) { LOG(("updater.exe was compared successfully to the installation directory" " updater.exe.")); } else { if (!WriteStatusFailure(argv[1], SERVICE_UPDATER_COMPARE_ERROR)) { LOG_WARN(("Could not write update.status updater compare failure.")); } return FALSE; } // Check to make sure the udpater.exe module has the unique updater identity. // This is a security measure to make sure that the signed executable that // we will run is actually an updater. HMODULE updaterModule = LoadLibraryEx(argv[0], NULL, LOAD_LIBRARY_AS_DATAFILE); if (!updaterModule) { LOG_WARN(("updater.exe module could not be loaded. (%d)", GetLastError())); result = FALSE; } else { char updaterIdentity[64]; if (!LoadStringA(updaterModule, IDS_UPDATER_IDENTITY, updaterIdentity, sizeof(updaterIdentity))) { LOG_WARN(("The updater.exe application does not contain the Mozilla" " updater identity.")); result = FALSE; } if (strcmp(updaterIdentity, UPDATER_IDENTITY_STRING)) { LOG_WARN(("The updater.exe identity string is not valid.")); result = FALSE; } FreeLibrary(updaterModule); } if (result) { LOG(("The updater.exe application contains the Mozilla" " updater identity.")); } else { if (!WriteStatusFailure(argv[1], SERVICE_UPDATER_IDENTITY_ERROR)) { LOG_WARN(("Could not write update.status no updater identity.")); } return TRUE; } // Check for updater.exe sign problems BOOL updaterSignProblem = FALSE; #ifndef DISABLE_UPDATER_AUTHENTICODE_CHECK updaterSignProblem = !DoesBinaryMatchAllowedCertificates(installDir, argv[0]); #endif // Only proceed with the update if we have no signing problems if (!updaterSignProblem) { BOOL updateProcessWasStarted = FALSE; if (StartUpdateProcess(argc, argv, installDir, updateProcessWasStarted)) { LOG(("updater.exe was launched and run successfully!")); LogFlush(); // Don't attempt to update the service when the update is being staged. if (!IsUpdateBeingStaged(argc, argv)) { // We might not execute code after StartServiceUpdate because // the service installer will stop the service if it is running. StartServiceUpdate(installDir); } } else { result = FALSE; LOG_WARN(("Error running update process. Updating update.status (%d)", GetLastError())); LogFlush(); // If the update process was started, then updater.exe is responsible for // setting the failure code. If it could not be started then we do the // work. We set an error instead of directly setting status pending // so that the app.update.service.errors pref can be updated when // the callback app restarts. if (!updateProcessWasStarted) { if (!WriteStatusFailure(argv[1], SERVICE_UPDATER_COULD_NOT_BE_STARTED)) { LOG_WARN(("Could not write update.status service update failure. (%d)", GetLastError())); } } } } else { result = FALSE; LOG_WARN(("Could not start process due to certificate check error on " "updater.exe. Updating update.status. (%d)", GetLastError())); // When there is a certificate check error on the updater.exe application, // we want to write out the error. if (!WriteStatusFailure(argv[1], SERVICE_UPDATER_SIGN_ERROR)) { LOG_WARN(("Could not write pending state to update.status. (%d)", GetLastError())); } } return result; }
oslPipe SAL_CALL osl_createPipe(rtl_uString *strPipeName, oslPipeOptions Options, oslSecurity Security) { rtl_uString* name = NULL; rtl_uString* path = NULL; rtl_uString* temp = NULL; oslPipe pPipe; PSECURITY_ATTRIBUTES pSecAttr = NULL; rtl_uString_newFromAscii(&path, PIPESYSTEM); rtl_uString_newFromAscii(&name, PIPEPREFIX); if ( Security) { rtl_uString *Ident = NULL; rtl_uString *Delim = NULL; OSL_VERIFY(osl_getUserIdent(Security, &Ident)); rtl_uString_newFromAscii(&Delim, "_"); rtl_uString_newConcat(&temp, name, Ident); rtl_uString_newConcat(&name, temp, Delim); rtl_uString_release(Ident); rtl_uString_release(Delim); } else { if (Options & osl_Pipe_CREATE) { PSECURITY_DESCRIPTOR pSecDesc; pSecDesc = (PSECURITY_DESCRIPTOR) rtl_allocateMemory(SECURITY_DESCRIPTOR_MIN_LENGTH); /* add a NULL disc. ACL to the security descriptor */ OSL_VERIFY(InitializeSecurityDescriptor(pSecDesc, SECURITY_DESCRIPTOR_REVISION)); OSL_VERIFY(SetSecurityDescriptorDacl(pSecDesc, TRUE, (PACL) NULL, FALSE)); pSecAttr = rtl_allocateMemory(sizeof(SECURITY_ATTRIBUTES)); pSecAttr->nLength = sizeof(SECURITY_ATTRIBUTES); pSecAttr->lpSecurityDescriptor = pSecDesc; pSecAttr->bInheritHandle = TRUE; } } rtl_uString_assign(&temp, name); rtl_uString_newConcat(&name, temp, strPipeName); /* alloc memory */ pPipe= __osl_createPipeImpl(); osl_atomic_increment(&(pPipe->m_Reference)); /* build system pipe name */ rtl_uString_assign(&temp, path); rtl_uString_newConcat(&path, temp, name); rtl_uString_release(temp); temp = NULL; if (Options & osl_Pipe_CREATE) { SetLastError( ERROR_SUCCESS ); pPipe->m_NamedObject = CreateMutexW( NULL, FALSE, name->buffer ); if ( pPipe->m_NamedObject != INVALID_HANDLE_VALUE && pPipe->m_NamedObject != NULL ) { if ( GetLastError() != ERROR_ALREADY_EXISTS ) { pPipe->m_Security = pSecAttr; rtl_uString_assign(&pPipe->m_Name, name); /* try to open system pipe */ pPipe->m_File = CreateNamedPipeW( path->buffer, PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED, PIPE_WAIT | PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE, PIPE_UNLIMITED_INSTANCES, 4096, 4096, NMPWAIT_WAIT_FOREVER, pPipe->m_Security); if (pPipe->m_File != INVALID_HANDLE_VALUE) { rtl_uString_release( name ); rtl_uString_release( path ); return pPipe; } } else { CloseHandle( pPipe->m_NamedObject ); pPipe->m_NamedObject = INVALID_HANDLE_VALUE; } } } else { BOOL fPipeAvailable; do { /* free instance should be available first */ fPipeAvailable = WaitNamedPipeW(path->buffer, NMPWAIT_WAIT_FOREVER); /* first try to open system pipe */ if ( fPipeAvailable ) { pPipe->m_File = CreateFileW( path->buffer, GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, NULL); if ( pPipe->m_File != INVALID_HANDLE_VALUE ) { // We got it ! rtl_uString_release( name ); rtl_uString_release( path ); return (pPipe); } else { // Pipe instance maybe catched by another client -> try again } } } while ( fPipeAvailable ); } /* if we reach here something went wrong */ __osl_destroyPipeImpl(pPipe); return NULL; }
int __cdecl main(int argc, char *argv[]) { BOOL testPass = TRUE; BOOL bRc = TRUE; HANDLE hFile; const char* sBadFilePath = "bad/badPath.tmp"; const char* sBadFileName = "badName.tmp"; const char* sDest = "dest.tmp"; const WCHAR wBadFilePath[] = {'w','b','a','d','/','b','a', 'd','.','t','m','p','\0'}; const WCHAR wBadFileName[] = {'w','B','a','d','.','t','m','p','\0'}; const WCHAR wDest[] = {'w','d','e','s','t','.','t','m','p','\0'}; if (0 != PAL_Initialize(argc,argv)) { return FAIL; } /*...................Test CopyFileW.............................*/ /* test with an invalid path */ bRc = CopyFileW(wBadFilePath,wDest,TRUE); if(!bRc) { if(GetLastError()!= ERROR_PATH_NOT_FOUND) { Trace("CopyFileW: calling GetLastError() after copying a file" " with wrong path returned [%u] while it should return [%u]\n" ,GetLastError(), ERROR_PATH_NOT_FOUND); testPass = FALSE; } } else { testPass = FALSE; } /* test with invalid file name */ bRc = CopyFileW(wBadFileName,wDest,TRUE); if(!bRc) { if(GetLastError()!= ERROR_FILE_NOT_FOUND) { Trace("CopyFileW: calling GetLastError() after copying a file" " with wrong name returned [%u] while it should return [%u]\n" ,GetLastError(), ERROR_FILE_NOT_FOUND); testPass = FALSE; } } else { Trace("CopyFileW: managed to copy a file with wrong name\n"); testPass = FALSE; } /*..................CopyFileA...................................*/ /* test with an invalid path */ bRc = CopyFileA(sBadFilePath,sDest,TRUE); if(! bRc) { if(GetLastError()!= ERROR_PATH_NOT_FOUND) { Trace("CopyFileA: calling GetLastError() after copying a file" " with wrong path returned [%u] while it should return [%u]\n" ,GetLastError(), ERROR_PATH_NOT_FOUND); testPass = FALSE; } } else { Trace("CopyFileA: managed to copy a file with wrong path\n"); testPass = FALSE; } /* test with an invalid file name */ bRc = CopyFileA(sBadFileName,sDest,TRUE); if(! bRc) { if(GetLastError()!= ERROR_FILE_NOT_FOUND) { Trace("CopyFileA: calling GetLastError() after copying a file" " with wrong name returned [%u] while it should return [%u]\n" ,GetLastError(), ERROR_FILE_NOT_FOUND); testPass = FALSE; } } else { Trace("CopyFileA: managed to copy a file with wrong name\n"); testPass = FALSE; } /*............. Test CreateFileA..................................*/ /* test with an invalid file name */ hFile = CreateFileA(sBadFileName, GENERIC_READ, /* open for reading */ FILE_SHARE_READ, /* share for reading */ NULL, /* no security */ OPEN_EXISTING, /* existing file only */ FILE_ATTRIBUTE_NORMAL, /* normal file */ NULL); /* no attr. template */ if (hFile == INVALID_HANDLE_VALUE) { if(GetLastError() != ERROR_FILE_NOT_FOUND) { Trace("CreateFileA: calling GetLastError() returned [%u] " "while it should return [%u] for a bad File Name\n", GetLastError(),ERROR_FILE_NOT_FOUND); testPass = FALSE; } } else { Trace("CreateFileA: managed to create a file with an incorrect " "filename\n"); testPass = FALSE; if(!CloseHandle(hFile)) { Trace("CreateFileA: Call to CloseHandle failed with ErrorCode " "[%u]\n", GetLastError()); } if(!DeleteFile(sBadFileName)) { Trace("CreateFileA: Call to DeleteFile failed with ErrorCode " "[%u]\n", GetLastError()); } } /* test with an invalid path */ hFile = CreateFileA(sBadFilePath, GENERIC_READ, /* open for reading */ FILE_SHARE_READ, /* share for reading */ NULL, /* no security */ OPEN_EXISTING, /* existing file only */ FILE_ATTRIBUTE_NORMAL, /* normal file */ NULL); /* no attr. template */ if (hFile == INVALID_HANDLE_VALUE) { if(GetLastError() != ERROR_PATH_NOT_FOUND) { Trace("CreateFileA: calling GetLastError() returned [%u] " "while it should return [%u] for a bad file path name\n", GetLastError(), ERROR_PATH_NOT_FOUND); testPass = FALSE; } } else { Trace("CreateFileA: managed to create a file with an incorrect " "filename\n"); testPass = FALSE; /*this should not happen*/ if(!CloseHandle(hFile)) { Trace("CreateFileA: Call to CloseHandle Failed with ErrorCode " "[%u]\n", GetLastError()); } if(!DeleteFile(sBadFilePath)) { Trace("CreateFileA: Call to DeleteFile Failed with ErrorCode " "[%u]\n", GetLastError()); } } /*............. Test CreateFileW..................................*/ /* test with an invalid file name */ hFile = CreateFileW(wBadFileName, GENERIC_READ, /* open for reading */ FILE_SHARE_READ, /* share for reading */ NULL, /* no security */ OPEN_EXISTING, /* existing file only */ FILE_ATTRIBUTE_NORMAL, /* normal file */ NULL); /* no attr. template */ if (hFile == INVALID_HANDLE_VALUE) { if(GetLastError() != ERROR_FILE_NOT_FOUND) { Trace("CreateFileW: calling GetLastError() returned [%u] " "while it should return [%u] for a bad filename\n", GetLastError(), ERROR_FILE_NOT_FOUND); testPass = FALSE; } } else { Trace("CreateFileW: managed to create a file with an incorrect " "filename\n"); testPass = FALSE; if(!CloseHandle(hFile)) { Trace("CreateFileW: Call to CloseHandle Failed with ErrorCode " "[%u]\n", GetLastError()); } if(!DeleteFileW(wBadFileName)) { Trace("CreateFileW: Call to DeleteFile Failed with ErrorCode " "[%u]\n", GetLastError()); } } /* test with an invalid path */ hFile = CreateFileW(wBadFilePath, GENERIC_READ, /* open for reading */ FILE_SHARE_READ, /* share for reading */ NULL, /* no security */ OPEN_EXISTING, /* existing file only */ FILE_ATTRIBUTE_NORMAL, /* normal file */ NULL); /* no attr. template */ if (hFile == INVALID_HANDLE_VALUE) { if(GetLastError() != ERROR_PATH_NOT_FOUND) { Trace("CreateFileW: calling GetLastError() returned [%u] " "while it should return [%u] for a bad file path \n", GetLastError(), ERROR_FILE_NOT_FOUND); testPass = FALSE; } } else { Trace("CreateFileW: managed to create a file with an incorrect " "filename\n"); testPass = FALSE; if(!CloseHandle(hFile)) { Trace("CreateFileW: Call to CloseHandle Failed with ErrorCode " "[%u]\n", GetLastError()); } if(!DeleteFileW(wBadFilePath)) { Trace("CreateFileW: Call to DeleteFile Failed with ErrorCode " "[%u]\n", GetLastError()); } } /* ............. DeleteFileW..................................*/ /* test with an invalid path */ if(DeleteFileW(wBadFilePath)) { Trace("DeleteFileW: Call to DeleteFileW to delete a file" " that does not exist succeeded\n"); testPass = FALSE; } else { if(GetLastError() != ERROR_PATH_NOT_FOUND) { Trace("DeleteFileW: Call GetLastError()returned " "[%u] while it should return ERROR_PATH_NOT_FOUND [%u]\n", GetLastError(),ERROR_FILE_NOT_FOUND); testPass = FALSE; } } /* test with an invalid file name */ if(DeleteFileW(wBadFileName)) { Trace("DeleteFileW: Call to DeleteFileW to delete a file" " that does not exist succeeded\n"); testPass = FALSE; } else { if(GetLastError() != ERROR_FILE_NOT_FOUND) { Trace("DeleteFileW: Call GetLastError()returned [%u]" " while it should return ERROR_FILE_NOT_FOUND [%u]\n", GetLastError(),ERROR_FILE_NOT_FOUND); testPass = FALSE; } } /* ............. DeleteFileA..................................*/ /* test with an invalid path */ if(DeleteFileA(sBadFilePath)) { Trace("DeleteFileA: Call to DeleteFileA to delete a file" " that does not exist succeeded\n"); testPass = FALSE; } else { if(GetLastError() != ERROR_PATH_NOT_FOUND) { Trace("DeleteFileA: Call GetLastError() returned [%u]" " while it should return ERROR_PATH_NOT_FOUND [%u]\n", GetLastError(),ERROR_FILE_NOT_FOUND); testPass = FALSE; } } /* test with an invalid file name */ if(DeleteFileA(sBadFileName)) { Trace("DeleteFileA: Call to DeleteFileA to delete a file" " that does not exist succeeded\n"); testPass = FALSE; } else { if(GetLastError() != ERROR_FILE_NOT_FOUND) { Trace("DeleteFileA: Call GetLastError() returned [%u]" " while it should return ERROR_FILE_NOT_FOUND [%u]\n", GetLastError(),ERROR_FILE_NOT_FOUND); testPass = FALSE; } } if(! testPass) { Fail(""); } PAL_Terminate(); return PASS; }
RTR3DECL(int) RTPathQueryInfoEx(const char *pszPath, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAdditionalAttribs, uint32_t fFlags) { /* * Validate input. */ AssertPtrReturn(pszPath, VERR_INVALID_POINTER); AssertReturn(*pszPath, VERR_INVALID_PARAMETER); AssertPtrReturn(pObjInfo, VERR_INVALID_POINTER); AssertMsgReturn( enmAdditionalAttribs >= RTFSOBJATTRADD_NOTHING && enmAdditionalAttribs <= RTFSOBJATTRADD_LAST, ("Invalid enmAdditionalAttribs=%p\n", enmAdditionalAttribs), VERR_INVALID_PARAMETER); AssertMsgReturn(RTPATH_F_IS_VALID(fFlags, 0), ("%#x\n", fFlags), VERR_INVALID_PARAMETER); /* * Query file info. */ WIN32_FILE_ATTRIBUTE_DATA Data; PRTUTF16 pwszPath; int rc = RTStrToUtf16(pszPath, &pwszPath); if (RT_FAILURE(rc)) return rc; if (!GetFileAttributesExW(pwszPath, GetFileExInfoStandard, &Data)) { /* Fallback to FindFileFirst in case of sharing violation. */ if (GetLastError() == ERROR_SHARING_VIOLATION) { WIN32_FIND_DATAW FindData; HANDLE hDir = FindFirstFileW(pwszPath, &FindData); if (hDir == INVALID_HANDLE_VALUE) { rc = RTErrConvertFromWin32(GetLastError()); RTUtf16Free(pwszPath); return rc; } FindClose(hDir); Data.dwFileAttributes = FindData.dwFileAttributes; Data.ftCreationTime = FindData.ftCreationTime; Data.ftLastAccessTime = FindData.ftLastAccessTime; Data.ftLastWriteTime = FindData.ftLastWriteTime; Data.nFileSizeHigh = FindData.nFileSizeHigh; Data.nFileSizeLow = FindData.nFileSizeLow; } else { rc = RTErrConvertFromWin32(GetLastError()); RTUtf16Free(pwszPath); return rc; } } /* * Getting the information for the link target is a bit annoying and * subject to the same access violation mess as above.. :/ */ /** @todo we're too lazy wrt to error paths here... */ if ( (fFlags & RTPATH_F_FOLLOW_LINK) && (Data.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT)) { HANDLE hFinal = CreateFileW(pwszPath, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL); if (hFinal != INVALID_HANDLE_VALUE) { BY_HANDLE_FILE_INFORMATION FileData; if (GetFileInformationByHandle(hFinal, &FileData)) { Data.dwFileAttributes = FileData.dwFileAttributes; Data.ftCreationTime = FileData.ftCreationTime; Data.ftLastAccessTime = FileData.ftLastAccessTime; Data.ftLastWriteTime = FileData.ftLastWriteTime; Data.nFileSizeHigh = FileData.nFileSizeHigh; Data.nFileSizeLow = FileData.nFileSizeLow; } CloseHandle(hFinal); } else if (GetLastError() != ERROR_SHARING_VIOLATION) { rc = RTErrConvertFromWin32(GetLastError()); RTUtf16Free(pwszPath); return rc; } } RTUtf16Free(pwszPath); /* * Setup the returned data. */ pObjInfo->cbObject = ((uint64_t)Data.nFileSizeHigh << 32) | (uint64_t)Data.nFileSizeLow; pObjInfo->cbAllocated = pObjInfo->cbObject; Assert(sizeof(uint64_t) == sizeof(Data.ftCreationTime)); RTTimeSpecSetNtTime(&pObjInfo->BirthTime, *(uint64_t *)&Data.ftCreationTime); RTTimeSpecSetNtTime(&pObjInfo->AccessTime, *(uint64_t *)&Data.ftLastAccessTime); RTTimeSpecSetNtTime(&pObjInfo->ModificationTime, *(uint64_t *)&Data.ftLastWriteTime); pObjInfo->ChangeTime = pObjInfo->ModificationTime; pObjInfo->Attr.fMode = rtFsModeFromDos((Data.dwFileAttributes << RTFS_DOS_SHIFT) & RTFS_DOS_MASK_NT, pszPath, strlen(pszPath)); /* * Requested attributes (we cannot provide anything actually). */ switch (enmAdditionalAttribs) { case RTFSOBJATTRADD_NOTHING: pObjInfo->Attr.enmAdditional = RTFSOBJATTRADD_NOTHING; break; case RTFSOBJATTRADD_UNIX: pObjInfo->Attr.enmAdditional = RTFSOBJATTRADD_UNIX; pObjInfo->Attr.u.Unix.uid = ~0U; pObjInfo->Attr.u.Unix.gid = ~0U; pObjInfo->Attr.u.Unix.cHardlinks = 1; pObjInfo->Attr.u.Unix.INodeIdDevice = 0; /** @todo use volume serial number */ pObjInfo->Attr.u.Unix.INodeId = 0; /** @todo use fileid (see GetFileInformationByHandle). */ pObjInfo->Attr.u.Unix.fFlags = 0; pObjInfo->Attr.u.Unix.GenerationId = 0; pObjInfo->Attr.u.Unix.Device = 0; break; case RTFSOBJATTRADD_UNIX_OWNER: pObjInfo->Attr.enmAdditional = RTFSOBJATTRADD_UNIX_OWNER; pObjInfo->Attr.u.UnixOwner.uid = ~0U; pObjInfo->Attr.u.UnixOwner.szName[0] = '\0'; /** @todo return something sensible here. */ break; case RTFSOBJATTRADD_UNIX_GROUP: pObjInfo->Attr.enmAdditional = RTFSOBJATTRADD_UNIX_GROUP; pObjInfo->Attr.u.UnixGroup.gid = ~0U; pObjInfo->Attr.u.UnixGroup.szName[0] = '\0'; break; case RTFSOBJATTRADD_EASIZE: pObjInfo->Attr.enmAdditional = RTFSOBJATTRADD_EASIZE; pObjInfo->Attr.u.EASize.cb = 0; break; default: AssertMsgFailed(("Impossible!\n")); return VERR_INTERNAL_ERROR; } return VINF_SUCCESS; }