private static extern SafeFileHandle CreateFile(
string lpFileName, // ファイル名
DesiredAccess dwDesiredAccess, // アクセスモード
ShareMode dwShareMode, // 共有モード
int lpSecurityAttributes, // セキュリティ記述子
CreationDisposition dwCreationDisposition, // 作成方法
FlagsAndAttributes dwFlagsAndAttributes, // ファイル属性
IntPtr hTemplateFile // テンプレートファイルのハンドル
);
private static extern IntPtr CreateFile(
string lpFileName, // ファイル名
DesiredAccess dwDesiredAccess, // アクセスモード
ShareMode dwShareMode, // 共有モード
int lpSecurityAttributes, // セキュリティ記述子
CreationDisposition dwCreationDisposition, // 作成方法
FlagsAndAttributes dwFlagsAndAttributes, // ファイル属性
IntPtr hTemplateFile // テンプレートファイルのハンドル
);
public static ReportedFileAccess Create(
ReportedFileOperation operation,
ReportedProcess process,
RequestedAccess requestedAccess,
FileAccessStatus status,
bool explicitlyReported,
uint error,
Usn usn,
DesiredAccess desiredAccess,
ShareMode shareMode,
CreationDisposition creationDisposition,
FlagsAndAttributes flagsAndAttributes,
PathTable pathTable,
string path,
string enumeratePattern = null)
{
Contract.Requires(process != null);
Contract.Requires(pathTable != null);
Contract.Requires(path != null);
AbsolutePath absolutePath;
if (AbsolutePath.TryGet(pathTable, (StringSegment)path, out absolutePath))
{
return(new ReportedFileAccess(
operation,
process,
requestedAccess,
status,
explicitlyReported,
error,
usn,
desiredAccess,
shareMode,
creationDisposition,
flagsAndAttributes,
absolutePath,
null,
enumeratePattern));
}
return(new ReportedFileAccess(
operation,
process,
requestedAccess,
status,
explicitlyReported,
error,
usn,
desiredAccess,
shareMode,
creationDisposition,
flagsAndAttributes,
AbsolutePath.Invalid,
path,
enumeratePattern));
}
public static extern IntPtr CreateFile(
string lpFileName,
FileAccess dwDesiredAccess,
ShareMode dwShareMode,
IntPtr lpSecurityAttributes,
CreationDisposition dwCreationDisposition,
uint dwFlagsAndAttributes,
IntPtr hTemplateFile
);
// lazy get - create only if not existing
public static void InitBitmap(String word, ShareMode mode, String path)
{
if (!File.Exists(Path.Combine(Config.SaveFolder, GetFilename(word, mode))))
{
WebPageBitmap wpb = new WebPageBitmap(word, mode, path);
wpb.SaveBitmap();
}
return;
}
public static extern IntPtr CreateFile(
[MarshalAs(UnmanagedType.LPWStr)] String lpFileName,
FileAccess dwDesiredAccess,
ShareMode dwShareMode,
IntPtr lpSecurityAttributes,
CreationDisposition dwCreationDisposition,
CreateFileAttributes dwFlagsAndAttributes,
IntPtr hTemplateFile
);
private void DoReportAccess(
ReportedFileOperation reportedFileOperation,
RequestedAccess requestedAccess,
FileAccessStatus fileAccessStatus,
uint errorCode,
Usn usn,
DesiredAccess desiredAccess,
ShareMode shareMode,
CreationDisposition creationDisposition,
FlagsAndAttributes flagsAndAttributes,
FlagsAndAttributes openedFileOrDirectoryAttributes,
string path,
string enumeratePattern,
string processArgs)
{
var process = Process.GetCurrentProcess();
Contract.Requires(!string.IsNullOrEmpty(path));
Contract.Requires(Path.IsPathRooted(path), $"Provided path is expected to be rooted, but found '{path}'.");
// The given path may not be canonicalized (e.g. it may contain '..')
string fullPath;
try
{
fullPath = FileUtilities.GetFullPath(path);
}
catch (BuildXLException)
{
// If getting the full path fails, we follow a behavior similar to what detours does, where the access is ignored
return;
}
string access = FileAccessReportLine.GetReportLineForAugmentedFileAccess(
reportedFileOperation,
(uint)process.Id,
requestedAccess,
fileAccessStatus,
errorCode,
usn,
desiredAccess,
shareMode,
creationDisposition,
flagsAndAttributes,
openedFileOrDirectoryAttributes,
fullPath,
enumeratePattern,
processArgs);
if (!FileUtilities.TryWriteFileSync(m_detoursReportHandle, m_encoding.GetBytes(access), out int nativeErrorCode))
{
// Something didn't go as expected. We cannot let the process continue if we failed at reporting an access
throw new NativeWin32Exception(nativeErrorCode, $"Writing augmented file access report failed. Line: {access}");
}
}
public extern static System.IntPtr CreateFileTransactedW(
[System.Runtime.InteropServices.MarshalAs(System.Runtime.InteropServices.UnmanagedType.LPWStr)] string lpFileName,
DesiredAccess dwDesiredAccess,
ShareMode dwShareMode,
LPSECURITY_ATTRIBUTES lpSecurityAttributes,
CreationDisposition dwCreationDisposition,
FlagsAndAttributes dwFlagsAndAttributes,
System.IntPtr hTemplateFile,
System.IntPtr hTransaction,
[System.Runtime.InteropServices.MarshalAs(System.Runtime.InteropServices.UnmanagedType.LPWStr)] System.Text.StringBuilder pusMiniVersion,
System.IntPtr lpExtendedParameter);
public void NotifyReconnect(ICardChannel cardChannel, ShareMode shareMode, Protocol preferedProtocol, Disposition initialization, ErrorCode errorCode)
{
if (errorCode == ErrorCode.Success)
{
gui.guiDetailedLogs.AppendText(String.Format(header + ">> Error: {0}\n", errorCode));
}
else
{
gui.guiDetailedLogs.AppendText(String.Format(header + ">> Error: {0}\n", errorCode));
}
}
public static File Open(
string fileName,
AccessMode accessMode,
CreationDisposition disposition = CreationDisposition.OpenAlways,
ShareMode shareMode = ShareMode.NoShare,
FileAttributes attributes = FileAttributes.Normal)
{
return(new File(
WinApiFileFunctions.CreateFile(fileName, (uint)accessMode, (uint)shareMode, (IntPtr)null, (uint)disposition, (uint)attributes, (IntPtr)null),
accessMode));
}
public HidDeviceMode(DeviceMode readMode, DeviceMode writeMode, ShareMode shareMode)
{
if (!_needChangeStatus) return;
/*
If the flag is "false", then we have the previous values of the attributes.
Update the values is not required.
*/
ReadMode = readMode;
WriteMode = writeMode;
ShareMode = shareMode;
_needChangeStatus = false;
}
public WebPageBitmap(String word, ShareMode mode, String path, int width = 400, int height = 209, int wait = 0)
{
// url = "http://pearson.lexicum.net/"
// url = "images/" + word;
this.word = word;
//this.url = "http://localhost:37829/Render/Q?id=" + word;
//this.url = "http://192.168.10.38/SocialWords.Web/Render/Q?id=" + word;
//this.url = "http://localhost/test/";
if (Config.TestMode)
{
this.url = path + "/Render/T?id=" + word;
}
else
{
this.url = path + "/Render/Q?id=" + word;
}
this.webroot = path;
this.width = width;
this.height = height;
this.mode = mode;
try
// needed as the script throws an exeception if the host is not found
{
HttpWebRequest req = (HttpWebRequest)WebRequest.Create(this.url);
req.AllowAutoRedirect = true;
req.UserAgent = "Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 6.0; SLCC1; .NET CLR 2.0.50727; .NET CLR 3.0.04506; .NET CLR 3.5.21022; .NET CLR 1.0.3705; .NET CLR 1.1.4322)";
req.Referer = "http://lexicum.net";
req.ContentType = "text/html";
req.Accept = "*/*";
req.KeepAlive = false;
using (HttpWebResponse resp = (HttpWebResponse)req.GetResponse())
{
string x = resp.StatusDescription;
}
}
catch (Exception ex)
{
errorMessage = ex.Message;
isOk = false;
return;
}
isOk = true; // public, to check in program.cs if the domain is found, so the image can be saved
webBrowser = new WebBrowser();
webBrowser.DocumentCompleted +=
new WebBrowserDocumentCompletedEventHandler(documentCompletedEventHandler);
webBrowser.Size = new Size(width, height);
webBrowser.ScrollBarsEnabled = false;
}
/// <summary>
/// Returns a detours report line representing an augmented file access.
/// </summary>
/// <remarks>
/// The line format is compatible with a regular file access report line. This is not a hard requirement (since <see cref="ReportType.AugmentedFileAccess"/>
/// is used to distinguish this line from regular lines), but is convenient to use the same report line parser for all cases. So future changes
/// can happen here as long as they are kept in sync with <see cref="SandboxedProcessReports.TryParseAugmentedFileAccess"/>
/// </remarks>
internal static string GetReportLineForAugmentedFileAccess(
ReportedFileOperation reportedFileOperation,
uint processId,
RequestedAccess requestedAccess,
FileAccessStatus fileAccessStatus,
uint errorCode,
Usn usn,
DesiredAccess desiredAccess,
ShareMode shareMode,
CreationDisposition creationDisposition,
FlagsAndAttributes flagsAndAttributes,
FlagsAndAttributes openedFileOrDirectoryAttributes,
string absolutePath,
[CanBeNull] string enumeratePattern,
[CanBeNull] string processArgs)
{
var result = new System.Text.StringBuilder();
result.Append($"{(int)ReportType.AugmentedFileAccess},{reportedFileOperation}:");
result.Append($"{processId:x}|");
result.Append($"{SandboxedProcessReports.FileAccessNoId:x}|"); // no id.
result.Append($"{SandboxedProcessReports.FileAccessNoId:x}|"); // no correlation id.
result.Append($"{(byte)requestedAccess:x}|");
result.Append($"{(byte)fileAccessStatus:x}|");
// '1' makes the access look as explicitly reported, but this actually doesn't matter since it will get
// set based on the manifest policy upon reception
result.Append("1|");
result.Append($"{errorCode:x}|");
result.Append($"{usn.Value:x}|");
result.Append($"{(uint)desiredAccess:x}|");
result.Append($"{(uint)shareMode:x}|");
result.Append($"{(uint)creationDisposition:x}|");
result.Append($"{(uint)flagsAndAttributes:x}|");
result.Append($"{(uint)openedFileOrDirectoryAttributes:x}|");
// The manifest path is always written as invalid
result.Append($"{AbsolutePath.Invalid.Value.Value:x}|");
result.Append(absolutePath);
if (!string.IsNullOrEmpty(enumeratePattern))
{
Contract.Assert(requestedAccess == RequestedAccess.Enumerate);
result.Append($"|{enumeratePattern}");
}
if (!string.IsNullOrEmpty(processArgs))
{
Contract.Assert(reportedFileOperation == ReportedFileOperation.Process);
result.Append($"|{processArgs}");
}
return(result.Append("\r\n").ToString());
}
/// <summary>
/// Initializes the Audio Client
/// </summary>
/// <param name="shareMode">Share Mode</param>
/// <param name="streamFlags">Stream Flags</param>
/// <param name="bufferDuration">Buffer Duration</param>
/// <param name="periodicity">Periodicity</param>
/// <param name="waveFormat">Wave Format</param>
/// <param name="audioSessionGuid">Audio Session GUID (can be null)</param>
public int Initialize(ShareMode shareMode,
StreamFlags streamFlags,
long bufferDuration,
long periodicity,
WaveFormat waveFormat,
Guid audioSessionGuid)
{
this.shareMode = shareMode;
int hret = audioClientInterface.Initialize(shareMode, streamFlags, bufferDuration, periodicity, waveFormat, ref audioSessionGuid);
mixFormat = null;
return(hret);
}
public static bool TryCreateFile(
string fileName,
ShareMode shareMode,
CreateDisposition creationDisposition,
out IntPtr handle,
DesiredAccess desiredAccess = DesiredAccess.None,
IntPtr securityAttributes = default,
uint flagsAndAttributes = 0,
IntPtr templateFile = default)
{
handle = CreateFileCore(fileName, desiredAccess, shareMode, securityAttributes, creationDisposition, flagsAndAttributes, templateFile);
return(handle != new IntPtr(-1));
}
/// <inheritdoc />
public ErrorCode Connect(ShareMode shareMode, Protocol preferedProtocol)
{
BeforeConnectEvent.Raise(this, new BeforeConnectEventArgs {
ShareMode = shareMode, PreferedProtocol = preferedProtocol
});
var ret = channel.Connect(shareMode, preferedProtocol);
AfterConnectEvent.Raise(this, new AfterConnectEventArgs {
ShareMode = shareMode, PreferedProtocol = preferedProtocol, ReturnValue = ret
});
return(ret);
}
public static String GetFilename(String word, ShareMode mode)
{
switch (mode)// word has to be clean
{
case ShareMode.Definition:
return("d-" + word + ".png");
case ShareMode.Question:
return("q-" + word + ".png");
default:
throw new ApplicationException("Operation not definied");
}
}
/// <inheritdoc />
public ErrorCode Reconnect(ShareMode shareMode, Protocol preferedProtocol, Disposition initialization)
{
BeforeReconnectEvent.Raise(this, new BeforeReconnectEventArgs {
ShareMode = shareMode, PreferedProtocol = preferedProtocol, Initialization = initialization
});
var ret = channel.Reconnect(shareMode, preferedProtocol, initialization);
AfterReconnectEvent.Raise(this, new AfterReconnectEventArgs {
ShareMode = shareMode, PreferedProtocol = preferedProtocol, Initialization = initialization, ReturnValue = ret
});
return(ret);
}
private async void ShareUnicornButton_Click(object sender, RoutedEventArgs e)
{
this.EnsureDataTransferManager();
if (filesToShare == null)
{
filesToShare = new List<IStorageItem>();
StorageFile unicornFile = await StorageFile.GetFileFromPathAsync(AppDomain.CurrentDomain.BaseDirectory + "Images\\WindowsUnicorn.jpg");
filesToShare.Add(unicornFile);
}
this.currentShareMode = ShareMode.StorageItem;
this.dtmHelper.ShowShareUI();
}
/// <summary>
/// Called to handle FileAccess message.
/// </summary>
/// <param name="pipId">The pip id</param>
/// <param name="pipDescription">The pip descruption</param>
/// <param name="operation">The operation</param>
/// <param name="requestedAccess">The requested access</param>
/// <param name="status">The status of the access request</param>
/// <param name="explicitlyReported">Is it an explicit report</param>
/// <param name="processId">The process ID that made the access.</param>
/// <param name="error">Error code of the operation</param>
/// <param name="desiredAccess">The desired access</param>
/// <param name="shareMode">The share mode</param>
/// <param name="creationDisposition">The creation disposition</param>
/// <param name="flagsAndAttributes">The flags and attributes</param>
/// <param name="path">The path being accessed</param>
/// <param name="processArgs">The process arguments</param>
public abstract void HandleFileAccess(
long pipId,
string pipDescription,
ReportedFileOperation operation,
RequestedAccess requestedAccess,
FileAccessStatus status,
bool explicitlyReported,
uint processId,
uint error,
DesiredAccess desiredAccess,
ShareMode shareMode,
CreationDisposition creationDisposition,
FlagsAndAttributes flagsAndAttributes,
string path,
string processArgs);
public void Open(DesiredAccess fDesiredAccess, ShareMode fShareMode,
CreationDisposition fCreationDisposition, FlagsAndAttributes fFlagsAndAttributes)
{
if (_sFileName.Length == 0)
{
throw new ArgumentNullException("FileName");
}
_hFile = CreateFile(_sFileName, fDesiredAccess, fShareMode, IntPtr.Zero,
fCreationDisposition, fFlagsAndAttributes, IntPtr.Zero);
if (_hFile.IsInvalid)
{
_hFile = null;
Marshal.ThrowExceptionForHR(Marshal.GetHRForLastWin32Error());
}
}
private async void ShareUnicornButton_Click(object sender, RoutedEventArgs e)
{
this.EnsureDataTransferManager();
if (filesToShare == null)
{
filesToShare = new List <IStorageItem>();
StorageFile unicornFile = await StorageFile.GetFileFromPathAsync(AppDomain.CurrentDomain.BaseDirectory + "Images\\WindowsUnicorn.jpg");
filesToShare.Add(unicornFile);
}
this.currentShareMode = ShareMode.StorageItem;
this.dtmHelper.ShowShareUI();
}
public static SafeFileHandle GetVolumeHandle(string path, FileAccess access, ShareMode shareMode)
{
string fileName;
if (path.Contains(@"\\?\"))
{
fileName = path;
}
else
{
path = path.TrimEnd('\\');
fileName = String.Format(@"\\.\{0}", path);
}
return(GetFileHandle(fileName, access, shareMode, true));
}
/// <summary>
/// Returns a detours report line representing an augmented file access.
/// </summary>
/// <remarks>
/// The line format is compatible with a regular file access report line. This is not a hard requirement (since <see cref="ReportType.AugmentedFileAccess"/>
/// is used to distinguish this line from regular lines), but is convenient to use the same report line parser for all cases. So future changes
/// can happen here as long as they are kept in sync with <see cref="SandboxedProcessReports.TryParseAugmentedFileAccess"/>
/// </remarks>
internal static string GetReportLineForAugmentedFileAccess(
ReportedFileOperation reportedFileOperation,
uint processId,
RequestedAccess requestedAccess,
FileAccessStatus fileAccessStatus,
uint errorCode,
Usn usn,
DesiredAccess desiredAccess,
ShareMode shareMode,
CreationDisposition creationDisposition,
FlagsAndAttributes flagsAndAttributes,
string absolutePath,
[CanBeNull] string enumeratePattern,
[CanBeNull] string processArgs)
{
var result = new System.Text.StringBuilder();
result.Append($"{(int)ReportType.AugmentedFileAccess},{reportedFileOperation}:");
result.Append($"{processId.ToString("x")}|");
result.Append($"{((byte)requestedAccess).ToString("x")}|");
result.Append($"{((byte)fileAccessStatus).ToString("x")}|");
// '1' makes the access look as explicitly reported
result.Append("1|");
result.Append($"{errorCode.ToString("x")}|");
result.Append($"{usn.Value.ToString("x")}|");
result.Append($"{((uint)desiredAccess).ToString("x")}|");
result.Append($"{((uint)shareMode).ToString("x")}|");
result.Append($"{((uint)creationDisposition).ToString("x")}|");
result.Append($"{((uint)flagsAndAttributes).ToString("x")}|");
// The manifest path is always written as invalid
result.Append($"{AbsolutePath.Invalid.Value.Value.ToString("x")}|");
result.Append(absolutePath);
if (!string.IsNullOrEmpty(enumeratePattern))
{
Contract.Assert(requestedAccess == RequestedAccess.Enumerate);
result.Append($"|{enumeratePattern}");
}
if (!string.IsNullOrEmpty(processArgs))
{
Contract.Assert(reportedFileOperation == ReportedFileOperation.Process);
result.Append($"|{processArgs}");
}
return(result.Append("\r\n").ToString());
}
public void OpenDevice(DeviceMode readMode, DeviceMode writeMode, ShareMode shareMode)
{
if (IsOpen)
{
return;
}
//HidSharp.OpenConfiguration config = new HidSharp.OpenConfiguration();
//config.SetOption(HidSharp.OpenOption.Priority, HidSharp.OpenOption.Priority.)
stream = internalDevice.Open();
//_deviceReadMode = readMode;
//_deviceWriteMode = writeMode;
//_deviceShareMode = shareMode;
IsOpen = true;
}
/// <summary>
/// Creates and returns a new SafeFileHandle
/// </summary>
/// <returns></returns>
public static SafeFileHandle NewSFH()
{
String lpFileName = "A.txt";
DesiredAccess dwDesiredAccess = DesiredAccess.GENERIC_WRITE;
ShareMode dwShareMode = ShareMode.FILE_SHARE_WRITE;
IntPtr lpSecurityAttributes = IntPtr.Zero;
CreationDisposition dwCreationDisposition = CreationDisposition.CREATE_ALWAYS;
FlagsAndAttributes dwFlagsAndAttributes = FlagsAndAttributes.None;
IntPtr hTemplateFile = IntPtr.Zero;
//create the handle
SafeFileHandle hnd = SafeFileHandle.CreateFile(lpFileName, dwDesiredAccess, dwShareMode,
lpSecurityAttributes, dwCreationDisposition,
dwFlagsAndAttributes, hTemplateFile);
return(hnd);
}
public static IntPtr CreateFile(
string fileName,
ShareMode shareMode,
CreateDisposition creationDisposition,
DesiredAccess desiredAccess = DesiredAccess.None,
IntPtr securityAttributes = default,
uint flagsAndAttributes = 0,
IntPtr templateFile = default)
{
var handle = CreateFileCore(fileName, desiredAccess, shareMode, securityAttributes, creationDisposition, flagsAndAttributes, templateFile);
if (handle == new IntPtr(-1))
{
throw new Win32ErrorException();
}
return(handle);
}
/// <summary>
/// Get a stream for the specified file.
/// </summary>
public static System.IO.Stream CreateFileStream(
string path,
DesiredAccess desiredAccess,
ShareMode shareMode,
CreationDisposition creationDisposition,
FileAttributes fileAttributes = FileAttributes.NONE,
FileFlags fileFlags = FileFlags.NONE,
SecurityQosFlags securityQosFlags = SecurityQosFlags.NONE)
{
var fileHandle = CreateFile(path, desiredAccess, shareMode, creationDisposition, fileAttributes, fileFlags, securityQosFlags);
// FileStream will own the lifetime of the handle
return(new System.IO.FileStream(
handle: fileHandle,
access: Conversion.DesiredAccessToFileAccess(desiredAccess),
bufferSize: 4096,
isAsync: (fileFlags & FileFlags.FILE_FLAG_OVERLAPPED) != 0));
}
public Wasapi(MMDevice device, StreamFlags streamFlags, ShareMode shareMode, bool eventSync, int durationMillisecond)
{
audioClient = device.AudioClient;
if (shareMode == ShareMode.Exclusive)
{
eventSync = true;
}
this.streamFlags = streamFlags;
this.device = device;
this.shareMode = shareMode;
this.eventSync = eventSync;
this.durationMillisecond = durationMillisecond;
if (eventSync)
{
this.streamFlags |= StreamFlags.StreamFlagsEventCallback;
}
}
/// <inheritdoc />
public ErrorCode SCardReconnect(IntPtr card, ShareMode shareMode, Protocol preferedProtocol, Disposition initialisation, ref Protocol activeProtocol)
{
ErrorCode err;
unsafe
{
var protocol = (uint)activeProtocol;
err = UnsafePrimitives.SCardReconnect(
(void *)card,
(uint)shareMode,
(uint)preferedProtocol,
(uint)initialisation,
&protocol
);
activeProtocol = (Protocol)protocol;
}
return(err);
}
public void OpenDevice(DeviceMode readMode, DeviceMode writeMode, ShareMode shareMode)
{
if (IsOpen) return;
_deviceReadMode = readMode;
_deviceWriteMode = writeMode;
try
{
Handle = OpenDeviceIO(_devicePath, readMode, NativeMethods.GENERIC_READ | NativeMethods.GENERIC_WRITE, shareMode);
}
catch (Exception exception)
{
IsOpen = false;
throw new Exception("Error opening HID device.", exception);
}
IsOpen = Handle.ToInt32() != NativeMethods.INVALID_HANDLE_VALUE;
}
public void Open(
DesiredAccess fDesiredAccess,
ShareMode fShareMode,
CreationDisposition fCreationDisposition,
FlagsAndAttributes fFlagsAndAttributes)
{
if (_sFileName.Length == 0)
{
throw new ArgumentNullException("FileName");
}
Handle = CreateFile(_sFileName, fDesiredAccess, fShareMode,
IntPtr.Zero, fCreationDisposition, fFlagsAndAttributes,
IntPtr.Zero);
if (Handle.IsInvalid)
{
Handle = null;
ThrowLastWin32Err();
}
_fDisposed = false;
}
/// <summary>
/// CreateFile wrapper. Desktop only. Prefer FileManagement.CreateFile() as it will handle all supported platforms.
/// </summary>
/// <remarks>Not available in Windows Store applications.</remarks>
public static SafeFileHandle CreateFile(
string path,
DesiredAccess desiredAccess,
ShareMode shareMode,
CreationDisposition creationDisposition,
FileAttributes fileAttributes = FileAttributes.NONE,
FileFlags fileFlags = FileFlags.NONE,
SecurityQosFlags securityQosFlags = SecurityQosFlags.NONE)
{
uint flags = (uint)fileAttributes | (uint)fileFlags | (uint)securityQosFlags;
unsafe
{
SafeFileHandle handle = Direct.CreateFileW(path, desiredAccess, shareMode, null, creationDisposition, flags, IntPtr.Zero);
if (handle.IsInvalid)
{
throw ErrorHelper.GetIoExceptionForLastError(path);
}
return(handle);
}
}
public void OpenDevice(DeviceMode readMode, DeviceMode writeMode, ShareMode shareMode)
{
if (IsOpen)
{
return;
}
_deviceReadMode = readMode;
_deviceWriteMode = writeMode;
try
{
Handle = OpenDeviceIO(_devicePath, readMode, NativeMethods.GENERIC_READ | NativeMethods.GENERIC_WRITE, shareMode);
}
catch (Exception exception)
{
IsOpen = false;
throw new Exception("Error opening HID device.", exception);
}
IsOpen = Handle.ToInt32() != NativeMethods.INVALID_HANDLE_VALUE;
}
/// <summary>
/// Attempts to report a file access to BuildXL without actually performing any IO
/// </summary>
/// <remarks>
/// Failure means this method was invoked from a process that was not configured to breakaway from the sandbox.
/// The provided path is required to be non-null and rooted
/// </remarks>
public bool TryReportAugmentedFileAccess(
ReportedFileOperation reportedFileOperation,
RequestedAccess requestedAccess,
FileAccessStatus fileAccessStatus,
uint errorCode,
Usn usn,
DesiredAccess desiredAccess,
ShareMode shareMode,
CreationDisposition creationDisposition,
FlagsAndAttributes flagsAndAttributes,
FlagsAndAttributes openedFileOrDirectoryAttributes,
string path,
[CanBeNull] string enumeratePattern = null,
[CanBeNull] string processArgs = null)
{
Contract.Requires(!string.IsNullOrEmpty(path));
if (m_detoursReportHandle == null)
{
return(false);
}
DoReportAccess(
reportedFileOperation,
requestedAccess,
fileAccessStatus,
errorCode,
usn,
desiredAccess,
shareMode,
creationDisposition,
flagsAndAttributes,
openedFileOrDirectoryAttributes,
path,
enumeratePattern,
processArgs);
return(true);
}
private void ShareWeblinkButton_Click_1(object sender, RoutedEventArgs e)
{
this.EnsureDataTransferManager();
this.currentShareMode = ShareMode.Weblink;
this.dtmHelper.ShowShareUI();
}
internal static extern int SCardConnect(IntPtr context, string reader, ShareMode shareMode, Protocol preferedProtocols, ref IntPtr card, ref uint activeProtocol);
public static extern IntPtr CreateFile(string FileName, DesiredAccess da, ShareMode sm, IntPtr SecurityAttributesZero, CreateDisposition cd, FlagsAndAttributes fa, IntPtr TemplateFileZero);
/// <summary>
/// Function to change the operating mode of the device
/// </summary>
/// <returns>void</returns>
public void ChangeDeviceMod(DeviceMode readMode, DeviceMode writeMode, ShareMode shareMode)
{
this.ReadMode = readMode;
this.WriteMode = writeMode;
this.ShareMode = shareMode;
}
public int Setup(int deviceId, DeviceType t, StreamType streamType,
int sampleRate, SampleFormatType format, int numChannels,
MMCSSCallType mmcssCall, MMThreadPriorityType threadPriority,
SchedulerTaskType schedulerTask, ShareMode shareMode, DataFeedMode dataFeedMode,
int latencyMillisec, int zeroFlushMillisec, int timePeriodHandredNanosec)
{
var args = new SetupArgs();
args.deviceType = (int)t;
args.streamType = (int)streamType;
args.sampleRate = sampleRate;
args.sampleFormat = (int)format;
args.numChannels = numChannels;
args.mmcssCall = (int)mmcssCall;
args.mmThreadPriority = (int)threadPriority;
args.schedulerTask = (int)schedulerTask;
args.shareMode = (int)shareMode;
args.dataFeedMode = (int)dataFeedMode;
args.latencyMillisec = latencyMillisec;
args.timePeriodHandledNanosec = timePeriodHandredNanosec;
args.zeroFlushMillisec = zeroFlushMillisec;
return WasapiIO_Setup(mId, deviceId, ref args);
}
public static extern IntPtr CreateFile(string fileName, AccessMode desiredAccess, ShareMode shareMode, IntPtr securityAttributes, CreationMode creationDisposition, FileAttribute flagsAndAttributes, IntPtr templateFilehandle);
private static extern SafeFileHandle CreateFile(string lpFileName, DesiredAccess dwDesiredAccess, ShareMode dwShareMode, IntPtr lpSecurityAttributes, CreationDisposition dwCreationDisposition, FlagsAndAttributes dwFlagsAndAttributes, IntPtr hTemplateFile);
private static IntPtr OpenDeviceIO(string devicePath, DeviceMode deviceMode, uint deviceAccess, ShareMode shareMode)
{
var security = new NativeMethods.SECURITY_ATTRIBUTES();
var flags = 0;
if (deviceMode == DeviceMode.Overlapped) flags = NativeMethods.FILE_FLAG_OVERLAPPED;
security.lpSecurityDescriptor = IntPtr.Zero;
security.bInheritHandle = true;
security.nLength = Marshal.SizeOf(security);
return NativeMethods.CreateFile(devicePath, deviceAccess, (int)shareMode, ref security, NativeMethods.OPEN_EXISTING, flags, 0);
}
/* ---------------------------------------------------------
* Open and Close
* ------------------------------------------------------ */
// [PrincipalPermission(SecurityAction.Demand, Role = @"BUILTIN\Administrators")]
private static void Open(string sFileName,
DesiredAccess fDesiredAccess,
ShareMode fShareMode,
CreationDisposition fCreationDisposition,
FlagsAndAttributes fFlagsAndAttributes)
{
//System.Security.Principal.WindowsIdentity.Impersonate( x=new System.Security.Principal.WindowsIdentity(
if (sFileName.Length == 0)
throw new ArgumentNullException("FileName");
_hFile = CreateFile(sFileName, fDesiredAccess, fShareMode,
IntPtr.Zero, fCreationDisposition, fFlagsAndAttributes,
IntPtr.Zero);
if (_hFile.IsInvalid)
{
_hFile = null;
ThrowLastWin32Err();
}
//_fDisposed = false;
}
public void OpenDevice(DeviceMode readMode, DeviceMode writeMode, ShareMode shareMode)
{
//BUG FIX
if (IsOpen) return;
_prevDeviceMode = _prevDeviceMode == null ? //We check whether we have the previous attributes to connect
new HidDeviceMode() : new HidDeviceMode(readMode,writeMode,shareMode); //write attributes
_deviceReadMode = readMode;
_deviceWriteMode = writeMode;
try
{
Handle = OpenDeviceIO(_devicePath, readMode, NativeMethods.GENERIC_READ | NativeMethods.GENERIC_WRITE, ShareMode.Exclusive);
}
catch (Exception exception)
{
IsOpen = false;
throw new Exception("Error opening HID device.", exception);
}
IsOpen = Handle.ToInt32() != NativeMethods.INVALID_HANDLE_VALUE;
}
