public static NT_FILE_STANDARD_INFORMATION GetFileInfo_standard(string file_name) { var file_handle = IntPtr.Zero; try { file_handle = WinApiFS.CreateFile_intptr (file_name, Win32FileAccess.GENERIC_READ, FileShare.ReadWrite, IntPtr.Zero, FileMode.Open, CreateFileOptions.None, IntPtr.Zero); if (file_handle.ToInt64() == WinApiFS.INVALID_HANDLE_VALUE) { var win_err = Marshal.GetLastWin32Error(); Exception ex = new Win32Exception(win_err); throw ex; } var ret = GetFileInfo_standard(file_handle); return(ret); } finally { if ((file_handle != IntPtr.Zero) && (file_handle.ToInt64() != WinApiFS.INVALID_HANDLE_VALUE)) { WinApiFS.CloseHandle(file_handle); } } }
private void fill_basic_info() { IntPtr h_file = IntPtr.Zero; try { h_file = WinAPiFSwrapper.CreateFileHandle (FileName, Win32FileAccess.READ_ATTRIBUTES | Win32FileAccess.READ_EA, FileShare.ReadWrite | FileShare.Delete, FileMode.Open, is_directory ? CreateFileOptions.BACKUP_SEMANTICS : CreateFileOptions.None); NT_FILE_BASIC_INFO b_info = ntApiFSwrapper.GetFileInfo_basic(h_file); textBoxAccess.Text = string.Format (Options.GetLiteral(Options.LANG_DATE_TIME_LONG_FORMAT), b_info.LastAccessTime.ToShortDateString(), b_info.LastAccessTime.ToLongTimeString()); textBoxAccessFT.Text = string.Format ("{0:N0}", b_info.LastAccessFileTime); textBoxChange.Text = string.Format (Options.GetLiteral(Options.LANG_DATE_TIME_LONG_FORMAT), b_info.ChangeTime.ToShortDateString(), b_info.ChangeTime.ToLongTimeString()); textBoxChangeFT.Text = string.Format ("{0:N0}", b_info.ChangeFileTime); textBoxCreation.Text = string.Format (Options.GetLiteral(Options.LANG_DATE_TIME_LONG_FORMAT), b_info.CreationTime.ToShortDateString(), b_info.CreationTime.ToLongTimeString()); textBoxCreationFT.Text = string.Format ("{0:N0}", b_info.CreationFileTime); textBoxWrite.Text = string.Format (Options.GetLiteral(Options.LANG_DATE_TIME_LONG_FORMAT), b_info.LastWriteTime.ToShortDateString(), b_info.LastWriteTime.ToLongTimeString()); textBoxWriteFT.Text = string.Format ("{0:N0}", b_info.LastWriteFileTime); } catch (Exception ex) { textBoxAccess.Text = ex.Message; } finally { if ((h_file.ToInt32() != WinApiFS.INVALID_HANDLE_VALUE) && (h_file != IntPtr.Zero)) { WinApiFS.CloseHandle(h_file); } } }
public static NT_FILE_BASIC_INFO GetFileInfo_basic(string file_name) { IntPtr file_handle = IntPtr.Zero; try { //open file file_handle = WinApiFS.CreateFile_intptr (file_name, Win32FileAccess.GENERIC_READ, FileShare.ReadWrite, IntPtr.Zero, FileMode.Open, CreateFileOptions.BACKUP_SEMANTICS, IntPtr.Zero); if (file_handle.ToInt32() == WinApiFS.INVALID_HANDLE_VALUE) { int win_err = Marshal.GetLastWin32Error(); Exception ex = new Win32Exception(win_err); throw ex; } NT_FILE_BASIC_INFO ret = GetFileInfo_basic(file_handle); return(ret); } finally { if ((file_handle != IntPtr.Zero) && (file_handle.ToInt32() != WinApiFS.INVALID_HANDLE_VALUE)) { WinApiFS.CloseHandle(file_handle); } } }
public static FILE_FS_VOLUME_INFORMATION GetFileVolumeInfo(string file_name) { IntPtr file_handle = IntPtr.Zero; try { file_handle = WinApiFS.CreateFile_intptr (file_name, Win32FileAccess.GENERIC_READ, FileShare.ReadWrite, IntPtr.Zero, FileMode.Open, CreateFileOptions.None, IntPtr.Zero); if (file_handle.ToInt32() == WinApiFS.INVALID_HANDLE_VALUE) { int win_err = Marshal.GetLastWin32Error(); Win32Exception win_ex = new Win32Exception(win_err); throw win_ex; } return(GetFileVolumeInfo(file_handle)); } finally { if ((file_handle != IntPtr.Zero) && (file_handle.ToInt32() != WinApiFS.INVALID_HANDLE_VALUE)) { WinApiFS.CloseHandle(file_handle); } } }
public static NT_FILE_STREAM_INFORMATION[] GetFileInfo_stream(string file_name) { IntPtr file_handle = IntPtr.Zero; try { file_handle = WinApiFS.CreateFile_intptr (file_name, Win32FileAccess.GENERIC_READ, FileShare.ReadWrite, IntPtr.Zero, FileMode.Open, CreateFileOptions.BACKUP_SEMANTICS, //need for retrieve info about directory IntPtr.Zero); if (file_handle.ToInt32() == WinApiFS.INVALID_HANDLE_VALUE) { int win_err = Marshal.GetLastWin32Error(); Exception ex = new Win32Exception(win_err); throw ex; } return(GetFileInfo_stream(file_handle, IntPtr.Zero, 0)); } finally { if ((file_handle != IntPtr.Zero) && (file_handle.ToInt32() != WinApiFS.INVALID_HANDLE_VALUE)) { WinApiFS.CloseHandle(file_handle); } } }
public void Dispose() { if (mount_point_buffer != IntPtr.Zero) { Marshal.FreeHGlobal(mount_point_buffer); } WinApiFS.FindVolumeMountPointClose(search_handle); }
public void Dispose() { if (volume_guid_buffer != IntPtr.Zero) { Marshal.FreeHGlobal(volume_guid_buffer); } WinApiFS.FindVolumeClose(search_handle); }
public void FillContents(string file_name) { //directory or file? FileName = file_name; var file_hanle = IntPtr.Zero; var win_err = 0; Win32Exception win_ex = null; try { if (IOhelper.IsDirectory(file_name)) { file_hanle = WinApiFS.CreateFile_intptr (file_name, Win32FileAccess.GENERIC_READ, FileShare.ReadWrite, IntPtr.Zero, FileMode.Open, CreateFileOptions.BACKUP_SEMANTICS, IntPtr.Zero); } else { file_hanle = WinApiFS.CreateFile_intptr (file_name, Win32FileAccess.GENERIC_READ, FileShare.ReadWrite, IntPtr.Zero, FileMode.Open, CreateFileOptions.None, IntPtr.Zero); } if (file_hanle.ToInt64() == WinApiFS.INVALID_HANDLE_VALUE) { win_err = Marshal.GetLastWin32Error(); win_ex = new Win32Exception(win_err); return; } FillContents(file_hanle); } finally { if ((file_hanle != IntPtr.Zero) && (file_hanle.ToInt64() != WinApiFS.INVALID_HANDLE_VALUE)) { WinApiFS.CloseHandle(file_hanle); } if (win_ex != null) { var fake_info = new NT_FILE_STREAM_INFORMATION(); fake_info.StreamName = win_ex.Message; listViewStreams.Items.Add(new InternalListViewItem(fake_info)); } } }
private void calc_size_count(FileInfoEx dir_info, ref long size, ref long allocation, ref long file_count, ref long dir_count) { FileInfoExEnumerable dir_enum = new FileInfoExEnumerable (Path.Combine(dir_info.FullName, "*"), true, true, true, true); foreach (FileInfoEx info in dir_enum) { IntPtr h_file = IntPtr.Zero; try { h_file = WinAPiFSwrapper.CreateFileHandle (info.FullName, Win32FileAccess.READ_ATTRIBUTES | Win32FileAccess.READ_EA, FileShare.ReadWrite | FileShare.Delete, FileMode.Open, info.Directory ? CreateFileOptions.BACKUP_SEMANTICS : CreateFileOptions.None); NT_FILE_STANDARD_INFORMATION s_info = ntApiFSwrapper.GetFileInfo_standard(h_file); size += s_info.EndOfFile; allocation += s_info.AllocationSize; //if (s_info.AllocationSize < s_info.EndOfFile) //{ // /*DEBUG*/ // long delta = s_info.EndOfFile - s_info.AllocationSize; //} } catch (Exception) { //Messages.ShowException // (ex, // string.Format // (Options.GetLiteral(Options.LANG_CANNOT_READ_ATTRIBUTES_0), // info.FullName)); break; } finally { if ((h_file.ToInt32() != WinApiFS.INVALID_HANDLE_VALUE) && (h_file != IntPtr.Zero)) { WinApiFS.CloseHandle(h_file); } } if (info.Directory) { calc_size_count(info, ref size, ref allocation, ref file_count, ref dir_count); dir_count++; } else { file_count++; } } }
private void FillStandardPage(string file_name) { IntPtr file_handle = IntPtr.Zero; string nt_file_name = IOhelper.GetUnicodePath(file_name); try { textBoxName.Text = string.Format ("{0}", Path.GetFileName(file_name)); // find data -------------------------------------- WIN32_FIND_DATA f_data = new WIN32_FIND_DATA(); WinAPiFSwrapper.GetFileInfo(file_name, ref f_data); textBoxAttributes.Text = f_data.dwFileAttributes.ToString(); textBoxAltname.Text = f_data.cAlternateFileName; textBoxReaprseTag.Text = f_data.ReparseTag.ToString(); //-------------------------------------------------- fileSystemSecurityViewer1.FillContains(file_name); try { fill_basic_info(); //fill_device(); fill_standard_info(); //fill_volume_attr(); //fill_volume_info(); fill_links(f_data.ReparseTag); fill_dir_size(); } catch (Exception ex) { Messages.ShowException(ex); } try { streamViewer1.FillContents(file_name); } catch (Exception) { } } catch (Exception ex) { Messages.ShowException(ex); } finally { if ((file_handle != IntPtr.Zero) && (file_handle.ToInt32() != WinApiFS.INVALID_HANDLE_VALUE)) { WinApiFS.CloseHandle(file_handle); } } }
public bool MoveNext() { int err_code = 0; int res = 0; if (search_handle == IntPtr.Zero) { search_handle = WinApiFS.FindFirstVolumeMountPoint(volume_guid, mount_point_buffer, mount_point_buffer_len_tchars); if (search_handle.ToInt32() == WinApiFS.INVALID_HANDLE_VALUE) { err_code = Marshal.GetLastWin32Error(); if (err_code == 18) { //no more files return(false); } else if (err_code == 21) { //device not ready return(false); } else { throw new Win32Exception(err_code); } } else { return(true); } } else { res = WinApiFS.FindNextVolumeMountPoint(search_handle, mount_point_buffer, mount_point_buffer_len_tchars); if (res == 0) { err_code = Marshal.GetLastWin32Error(); if (err_code == 18) { //no more files return(false); } else { throw new Win32Exception(err_code); } } else { return(true); } } }
public static VolumeSpaceInfo GetInfo(string directory) { var ret = new VolumeSpaceInfo(); var res = WinApiFS.GetDiskFreeSpaceEx(directory, ref ret.FreeBytesAvailable, ref ret.TotalNumberOfBytes, ref ret.TotalNumberOfFreeBytes); if (res == 0) { var winErr = Marshal.GetLastWin32Error(); throw new System.ComponentModel.Win32Exception(winErr); } return(ret); }
private void internal_delete_selected() { if (listViewStreams.SelectedItems.Count == 0) { return; } if (Messages.ShowQuestionYesNo (Options.GetLiteral(Options.LANG_DELETE_PROMPT), Options.GetLiteral(Options.LANG_DELETE)) != DialogResult.Yes) { return; } var stream_info = new NT_FILE_STREAM_INFORMATION(); foreach (InternalListViewItem item in listViewStreams.SelectedItems) { try { stream_info = item.InternalData; if (stream_info.StreamName.StartsWith("::$")) { Messages.ShowMessage(Options.GetLiteral(Options.LANG_CANNOT_DELETE_DEFAULT_DATA_STREAM)); } else { var del_name = string.Format("{0}{1}", FileName, stream_info.StreamName); var res = WinApiFS.DeleteFile(del_name); if (res == 0) { throw new Win32Exception(Marshal.GetLastWin32Error()); } } } catch (Exception ex) { Messages.ShowException (ex, string.Format (Options.GetLiteral(Options.LANG_CANNOT_DELETE_DEFAULT_DATA_STREAM), stream_info.StreamName)); } } //update list FillContents(FileName); }
public bool MoveNext() { var err_code = 0; var res = 0; if (search_handle == IntPtr.Zero) { search_handle = WinApiFS.FindFirstVolume(volume_guid_buffer, volume_guid_buffer_len_tchars); if (search_handle.ToInt64() == WinApiFS.INVALID_HANDLE_VALUE) { err_code = Marshal.GetLastWin32Error(); if (err_code == 18) { //no more files return(false); } else { throw new Win32Exception(err_code); } } else { return(true); } } else { res = WinApiFS.FindNextVolume(search_handle, volume_guid_buffer, volume_guid_buffer_len_tchars); if (res == 0) { err_code = Marshal.GetLastWin32Error(); if (err_code == 18) { //no more files return(false); } else { throw new Win32Exception(err_code); } } else { return(true); } } }
public void Dispose() { if (need_free_buffer_h) { if (buffer_h != IntPtr.Zero) { Marshal.FreeHGlobal(buffer_h); } } if (need_free_file_h) { if ((file_h != IntPtr.Zero) || (file_h.ToInt32() != WinApiFS.INVALID_HANDLE_VALUE)) { WinApiFS.CloseHandle(file_h); } } }
} //end of proc /// <summary> /// work only if source and destination on one volume /// </summary> /// <param name="source">can be file or dir</param> /// <param name="destination">file or dir</param> private void move_one_item(FileInfoEx source, string destination) { //prepare callback buffer if (callback_data != IntPtr.Zero) { Marshal.FreeHGlobal(callback_data); } callback_data = IOhelper.strings_to_buffer(source.FullName, destination); //prepare uni names var source_uni = IOhelper.GetUnicodePath(source.FullName); var destination_uni = IOhelper.GetUnicodePath(destination); //call update dialog before... var e_begin_move = new UpdateProgressArgs(); e_begin_move.DestinationFile = destination; e_begin_move.EnableTotalProgress = false; e_begin_move.Reason = UpdateProgressReason.StreamSwitch; e_begin_move.SourceFile = source.FullName; update_progress_safe(e_begin_move); //and call MoveFileWithProgress var res = WinApiFS.MoveFileWithProgress (source_uni, destination_uni, move_progress_delegate_holder, callback_data, options_api); if (res == 0) { var win_err = Marshal.GetLastWin32Error(); var win_ex = new Win32Exception(win_err); AbortJobSafe = !process_errors (string.Format (Options.GetLiteral(Options.LANG_CANNOT_MOVE_0_ARROW_1), source, destination), win_ex); return; } //success move //notify item done - not needed, source item deleted }
private void fill_standard_info() { IntPtr h_file = IntPtr.Zero; try { h_file = WinAPiFSwrapper.CreateFileHandle (FileName, Win32FileAccess.READ_ATTRIBUTES | Win32FileAccess.READ_EA, FileShare.ReadWrite | FileShare.Delete, FileMode.Open, is_directory ? CreateFileOptions.BACKUP_SEMANTICS : CreateFileOptions.None); NT_FILE_STANDARD_INFORMATION s_info = ntApiFSwrapper.GetFileInfo_standard(h_file); textBoxSize.Text = string.Format (Options.GetLiteral(Options.LANG_0_BYTES), s_info.EndOfFile); textBoxAllocationSize.Text = string.Format (Options.GetLiteral(Options.LANG_0_BYTES), s_info.AllocationSize); textBoxHardLinks.Text = s_info.NumberOfLinks.ToString(); } catch (Exception ex) { textBoxSize.Text = ex.Message; } finally { if ((h_file.ToInt32() != WinApiFS.INVALID_HANDLE_VALUE) && (h_file != IntPtr.Zero)) { WinApiFS.CloseHandle(h_file); } } }
public InternalEnumerator(string file_name) { file_h = WinApiFS.CreateFile_intptr (file_name, Win32FileAccess.GENERIC_READ, FileShare.ReadWrite, IntPtr.Zero, FileMode.Open, CreateFileOptions.BACKUP_SEMANTICS, //need for retrieve info about directory IntPtr.Zero); if (file_h.ToInt32() == WinApiFS.INVALID_HANDLE_VALUE) { int win_err = Marshal.GetLastWin32Error(); Exception ex = new Win32Exception(win_err); throw ex; } need_free_file_h = true; int buffer_size = STREAM_INFO_BUFFER_LEN; need_free_buffer_h = true; buffer_h = Marshal.AllocHGlobal(buffer_size); Marshal.WriteInt32(buffer_h, 4, 0); IO_STATUS_BLOCK status = new IO_STATUS_BLOCK(); uint res = ntApiFS.NtQueryInformationFile (file_h, ref status, buffer_h, buffer_size, FILE_INFORMATION_CLASS.FileStreamInformation); //check result NTSTATUS_helper.ThrowOnError(res, status, NTSTATUS_severity.Warning); }
private void internal_copy_to_file(NT_FILE_STREAM_INFORMATION fs_stream, string destination_file, bool fail_if_exists) { if (copy_buffer.Length == 0) { copy_buffer = new byte[1024 * 64]; } var source_name = string.Format("{0}{1}", FileName, fs_stream.StreamName); var source_handle = IntPtr.Zero; var destination_handle = IntPtr.Zero; source_handle = WinApiFS.CreateFile_intptr (source_name, Win32FileAccess.GENERIC_READ, FileShare.Read, IntPtr.Zero, FileMode.Open, CreateFileOptions.None, IntPtr.Zero); if (source_handle.ToInt64() == WinApiFS.INVALID_HANDLE_VALUE) { throw new Win32Exception(Marshal.GetLastWin32Error()); } destination_handle = WinApiFS.CreateFile_intptr (destination_file, Win32FileAccess.GENERIC_WRITE, FileShare.Read, IntPtr.Zero, fail_if_exists ? FileMode.CreateNew : FileMode.Create, CreateFileOptions.None, IntPtr.Zero); if (destination_handle.ToInt64() == WinApiFS.INVALID_HANDLE_VALUE) { WinApiFS.CloseHandle(source_handle); throw new Win32Exception(Marshal.GetLastWin32Error()); } FileStream source_stream = null; FileStream destination_stream = null; try { source_stream = new FileStream(source_handle, FileAccess.Read, true); destination_stream = new FileStream(destination_handle, FileAccess.Write, true); var bytes_readed = 0; do { bytes_readed = source_stream.Read(copy_buffer, 0, copy_buffer.Length); destination_stream.Write(copy_buffer, 0, bytes_readed); } while (bytes_readed != 0); } finally { destination_stream.Close(); source_stream.Close(); } }
private void copy_one_file(FileInfoEx source_info, string destination_file) { //check mask if (!Wildcard.Match(initial_mask, source_info.FileName)) { return; } var success = false; //now prepare callback buffer if (callback_data != IntPtr.Zero) { Marshal.FreeHGlobal(callback_data); } callback_data = IOhelper.strings_to_buffer(source_info.FullName, destination_file); //prepare uni names var source_uni = IOhelper.GetUnicodePath(source_info.FullName); var dest_uni = IOhelper.GetUnicodePath(destination_file); //string source_uni = source_info.FullName; //string dest_uni = destination_file; //and call CopyFileEx first time var res = WinApiFS.CopyFileEx (source_uni, dest_uni, copy_progress_routine_delegate_holder, callback_data, IntPtr.Zero, copyFileEx_options); if (res == 0) { var win_err = Marshal.GetLastWin32Error(); //process win_err and do second take if needed var temp_copy_options = copyFileEx_options; if (process_CopyFileEx_errors(source_info, destination_file, win_err, ref temp_copy_options)) { //second take res = WinApiFS.CopyFileEx (source_uni, dest_uni, copy_progress_routine_delegate_holder, callback_data, IntPtr.Zero, temp_copy_options); if (res == 0) { win_err = Marshal.GetLastWin32Error(); var win_ex_2 = new Win32Exception(win_err); if (!process_error (string.Format (Options.GetLiteral(Options.LANG_CANNOT_COPY_0_ARROW_1), source_info.FullName, destination_file), win_ex_2)) { stop(); } } else { success = true; } } }//end of res==0 brunch else { //copy success success = true; } if (success) { //update counts total_bytes_transferred += current_file_bytes_transferred; current_file_bytes_transferred = 0; total_files_copied++; //time to notify current panel -> unset selection var e_file_done = new ItemEventArs(source_info.FileName); OnCopyItemDone(e_file_done); //set sec attributes if needed if ((options & CopyEngineOptions.CopySecurityAttributes) == CopyEngineOptions.CopySecurityAttributes) { try { File.SetAccessControl(destination_file, File.GetAccessControl(source_info.FullName)); } catch (Exception ex) { if (!process_error (string.Format (Options.GetLiteral(Options.LANG_CANNOT_SET_SEC_ATTRIBUTES_0), destination_file), ex)) { stop(); } } } } }
private void delete_entry(FileInfoEx entry) { /* * We first try to delete directory (if set flag DeleteEmptyDirectories) * if it is link, DeleteFile finction deletes link, not target, even if target not empty * and return. * If flag DeleteEmptyDirectories not setted, we check LinkInformation and * if it not null (that is entry is soft link) -> return, else * remove its contains. */ int win_err = 0; int res = 0; if (abort) { return; } if (!check_readonly(entry)) { return; } if (entry.Directory) { if (!check_readonly(entry)) { return; } //first try to delete dir, assume it is empty if ((opts & DeleteFileOptions.DeleteEmptyDirectories) == DeleteFileOptions.DeleteEmptyDirectories) { res = WinApiFS.RemoveDirectory(entry.FullName); if (res == 0) { win_err = Marshal.GetLastWin32Error(); if (win_err == WinApiFS.ERROR_DIR_NOT_EMPTY) { //directory not empty if ((opts & DeleteFileOptions.RecursiveDeleteFiles) == DeleteFileOptions.RecursiveDeleteFiles) { //recursive delete needed FileInfoExEnumerable dir_enum = new FileInfoExEnumerable (Path.Combine(entry.FullName, "*"), false, false, false, true); try { foreach (FileInfoEx info in dir_enum) { delete_entry(info); } } catch (Exception ex) { abort = !process_errors (string.Format(Options.GetLiteral(Options.LANG_CANNOT_DELETE_0), entry.FullName), ex); } }//end of dir enum //now dir probably empty res = WinApiFS.RemoveDirectory(entry.FullName); if (res == 0) { //not success win_err = Marshal.GetLastWin32Error(); if (win_err != WinApiFS.ERROR_DIR_NOT_EMPTY) //supress -> when delete on mask, //dir may be not empty { abort = !process_errors (string.Format(Options.GetLiteral(Options.LANG_CANNOT_DELETE_0), entry.FullName), new Win32Exception(win_err)); } } }//end of dir not empty else { abort = !process_errors (string.Format(Options.GetLiteral(Options.LANG_CANNOT_DELETE_0), entry.FullName), new Win32Exception(win_err)); } }//end of error process } else { //not to delete empty dirs //recursive delete needed (if not link) but directory not will remove //check reparse tag if ((opts & DeleteFileOptions.RecursiveDeleteFiles) == DeleteFileOptions.RecursiveDeleteFiles) { if (entry.LinkInformation == null) { FileInfoExEnumerable dir_enum = new FileInfoExEnumerable (Path.Combine(entry.FullName, "*"), false, false, false, true); try { foreach (FileInfoEx info in dir_enum) { delete_entry(info); } } catch (Exception ex) { abort = !process_errors (string.Format(Options.GetLiteral(Options.LANG_CANNOT_DELETE_0), entry.FullName), ex); } } } } }//end of if(entry.Directory) else { //entry is file //check mask if (Wildcard.Match(delete_mask, entry.FileName, false)) { if (check_readonly(entry)) { if (main_window != null) { main_window.NotifyLongOperation (string.Format(Options.GetLiteral(Options.LANG_DELETE_NOW_0), entry.FullName), true); } res = WinApiFS.DeleteFile(entry.FullName); if (res == 0) { abort = !process_errors (string.Format(Options.GetLiteral(Options.LANG_CANNOT_DELETE_0), entry.FullName), new Win32Exception(Marshal.GetLastWin32Error())); } } } } }
private void initInfo() { if (ready) { return; } var root = RootPathName; var nameBufferSize = (WinApiFS.MAX_PATH + 1) * Marshal.SystemDefaultCharSize; var nameCharsCount = WinApiFS.MAX_PATH + 1; var ptVolumeNameBuffer = Marshal.AllocHGlobal(nameBufferSize); var ptVolumeSerialNumber = Marshal.AllocHGlobal(4); var ptMaximumComponentLength = Marshal.AllocHGlobal(4); var ptFileSystemFlags = Marshal.AllocHGlobal(4); var ptFileSystemName = Marshal.AllocHGlobal(nameBufferSize); try { var res = WinApiFS.GetVolumeInformation (root, ptVolumeNameBuffer, nameCharsCount, ptVolumeSerialNumber, ptMaximumComponentLength, ptFileSystemFlags, ptFileSystemName, nameCharsCount); if (res == 0) //not process 'device not ready (21)', 'network drive not found (53) 'path not found (3)' { var errCode = Marshal.GetLastWin32Error(); if (errCode == 21) { DeviceReady = false; ready = true; } else if (errCode == 53) { DeviceReady = false; ready = true; } else if (errCode == 3) { DeviceReady = false; ready = true; } else { Messages.ShowException (new Win32Exception(errCode), string.Format ("Failed get volume {0} properties.", root)); DeviceReady = false; ready = true; } } else { DeviceReady = true; RootPathName = root; VolumeName = Marshal.PtrToStringAuto(ptVolumeNameBuffer); MaximumComponentLength = Marshal.ReadInt32(ptMaximumComponentLength); FileSystemFlags = (VolumeCaps)Marshal.ReadInt32(ptFileSystemFlags); FileSystemName = Marshal.PtrToStringAuto(ptFileSystemName); var serialBytes = new byte[4]; Marshal.Copy(ptVolumeSerialNumber, serialBytes, 0, 4); SerialNumber = (uint)BitConverter.ToUInt64(serialBytes, 0); } if (DeviceReady) { VolumeSpaceInfo = VolumeSpaceInfo.GetInfo(RootPathName); } else { VolumeSpaceInfo = new VolumeSpaceInfo(); } DriveType = WinApiFS.GetDriveType(RootPathName); } finally { Marshal.FreeHGlobal(ptFileSystemFlags); Marshal.FreeHGlobal(ptFileSystemName); Marshal.FreeHGlobal(ptMaximumComponentLength); Marshal.FreeHGlobal(ptVolumeNameBuffer); Marshal.FreeHGlobal(ptVolumeSerialNumber); ready = true; } }
protected override void internal_command_proc() { var e_current = new QueryPanelInfoEventArgs(); var e_other = new QueryPanelInfoEventArgs(); OnQueryCurrentPanel(e_current); OnQueryOtherPanel(e_other); if (!(e_current.ItemCollection is DirectoryList)) { return; } if (!(e_other.ItemCollection is DirectoryList)) { Messages.ShowMessage(Options.GetLiteral(Options.LANG_WRONG_DESTINATION)); return; } if (e_current.FocusedIndex == -1) { return; } var dl_current = (DirectoryList)e_current.ItemCollection; var dl_other = (DirectoryList)e_other.ItemCollection; var group_mode = e_current.SelectedIndices.Length > 1; var link_type = Options.LinkType; var sels = new List <FileInfoEx>(); if (e_current.SelectedIndices.Length > 0) { for (var i = 0; i < e_current.SelectedIndices.Length; i++) { sels.Add(dl_current[e_current.SelectedIndices[i]]); } } else { sels.Add(dl_current[e_current.FocusedIndex]); } //show dialog var dialog = new CreateLinkDialog(); dialog.Text = Options.GetLiteral(Options.LANG_LINK_CREATE); dialog.LinkType = link_type; dialog.textBoxLinkname.Text = string.Empty; if (group_mode) { dialog.textBoxLinkname.ReadOnly = true; dialog.textBoxLinktarget.Text = string.Format ("{0} " + Options.GetLiteral(Options.LANG_ENTRIES), sels.Count); } else { dialog.textBoxLinktarget.Text = sels[0].FileName; } if (dialog.ShowDialog() != DialogResult.OK) { return; } link_type = dialog.LinkType; Options.LinkType = link_type; foreach (var entry in sels) { var link_handle = IntPtr.Zero; //combine link name var link_name = string.Empty; if (dialog.textBoxLinkname.Text == string.Empty) { //use target file name link_name = Path.Combine(dl_other.DirectoryPath, entry.FileName); } else { link_name = Path.Combine(dl_other.DirectoryPath, dialog.textBoxLinkname.Text); } try { if ((entry.Directory) && (link_type == NTFSlinkType.Hard)) { Messages.ShowMessage (string.Format (Options.GetLiteral(Options.LANG_CANNOT_CREATE_HARD_LINK_DIR_0), entry.FullName)); continue; } if (link_type == NTFSlinkType.Hard) { var res = WinApiFS.CreateHardLink (link_name, entry.FullName, IntPtr.Zero); if (res == 0) { Messages.ShowException (new Win32Exception(Marshal.GetLastWin32Error()), string.Format (Options.GetLiteral(Options.LANG_CANNOT_CREATE_LINK_0_ARROW_1), entry.FullName, link_name)); } else { OnItemProcessDone(new ItemEventArs(entry.FileName)); } continue; } if (link_type == NTFSlinkType.Symbolic) { try { WinAPiFSwrapper.CreateSymbolicLink(link_name, entry.FullName, entry.Directory); OnItemProcessDone(new ItemEventArs(entry.FileName)); } catch (Exception) { Messages.ShowException (new Win32Exception(Marshal.GetLastWin32Error()), string.Format (Options.GetLiteral(Options.LANG_CANNOT_CREATE_LINK_0_ARROW_1), entry.FullName, link_name)); } continue; } //link type is junction var link_data = new WIN32_FIND_DATA(); var link_exist = WinAPiFSwrapper.GetFileInfo(link_name, ref link_data); if (link_exist) { Messages.ShowMessage(string.Format(Options.GetLiteral(Options.LANG_DESTINATION_0_EXIST_OVERWRITING_PROHIBITED), link_name)); continue; } //jumction target must be directory, create directory Directory.CreateDirectory(link_name); //and retrieve handle link_handle = WinApiFS.CreateFile_intptr (link_name, Win32FileAccess.WRITE_ATTRIBUTES | Win32FileAccess.WRITE_EA, FileShare.ReadWrite, IntPtr.Zero, FileMode.Open, CreateFileOptions.OPEN_REPARSE_POINT | CreateFileOptions.BACKUP_SEMANTICS, IntPtr.Zero); if (link_handle.ToInt64() == WinApiFS.INVALID_HANDLE_VALUE) { var win_ex = new Win32Exception(Marshal.GetLastWin32Error()); Messages.ShowException (win_ex, string.Format (Options.GetLiteral(Options.LANG_CANNOT_CREATE_LINK_0_ARROW_1), link_name, entry.FullName)); if (Directory.Exists(link_name)) { Directory.Delete(link_name); } continue; } //now handle to link open WinAPiFSwrapper.SetMountpoint(link_handle, entry.FullName, entry.FullName); OnItemProcessDone(new ItemEventArs(entry.FileName)); }//end try catch (Exception ex) { Messages.ShowException (ex, string.Format (Options.GetLiteral(Options.LANG_CANNOT_CREATE_LINK_0_ARROW_1), entry.FullName, link_name)); } finally { //close handle if ((link_handle.ToInt64() != WinApiFS.INVALID_HANDLE_VALUE) && (link_handle != IntPtr.Zero)) { WinApiFS.CloseHandle(link_handle); } } }//end foreach }