public void GetMethodFromSecondSuperClass()
{
DefinedClass proto = new DefinedClass("proto");
DefinedClass super = new DefinedClass("object");
IFunction method = new NativeMethod(this.DummyMethod);
super.SetValue("foo", method);
DefinedClass klass = new DefinedClass("Spam", new IType[] { proto, super });
var result = klass.GetMethod("foo");
Assert.IsNotNull(result);
Assert.IsTrue(klass.HasMethod("foo"));
}
public void DefineMethodUsingSetValue()
{
DefinedClass klass = new DefinedClass("Spam");
IFunction method = new NativeMethod(this.DummyMethod);
klass.SetValue("foo", method);
var result = klass.GetMethod("foo");
Assert.IsNotNull(result);
Assert.AreEqual(method, result);
Assert.IsTrue(klass.HasMethod("foo"));
Assert.IsTrue(klass.HasValue("foo"));
}
public void GetMethodFromClass()
{
DefinedClass klass = new DefinedClass("Spam");
IFunction function = new NativeMethod(DummyMethod);
klass.SetMethod("foo", function);
DynamicObject dynobj = new DynamicObject(klass);
var result = dynobj.GetValue("foo");
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(IFunction));
Assert.AreEqual(function, result);
}
public void InvokeGetValueMethod()
{
DefinedClass klass = new DefinedClass("Spam");
IFunction function = new NativeMethod(GetValueMethod);
klass.SetMethod("foo", function);
DynamicObject dynobj = new DynamicObject(klass);
dynobj.SetValue("one", 1);
var result = dynobj.Invoke("foo", null, new object[] { "one" }, null);
Assert.IsNotNull(result);
Assert.AreEqual(1, result);
}
/// <summary>
/// Read the messages from a mailslot by using the mailslot handle in a call
/// to the ReadFile function.
/// </summary>
/// <param name="hMailslot">The handle of the mailslot</param>
/// <returns>
/// If the function succeeds, the return value is true.
/// </returns>
static bool ReadMailslot(SafeMailslotHandle hMailslot)
{
int cbMessageBytes = 0; // Size of the message in bytes
int cbBytesRead = 0; // Number of bytes read from the mailslot
int cMessages = 0; // Number of messages in the slot
int nMessageId = 0; // Message ID
bool succeeded = false;
// Check for the number of messages in the mailslot.
succeeded = NativeMethod.GetMailslotInfo(
hMailslot, // Handle of the mailslot
IntPtr.Zero, // No maximum message size
out cbMessageBytes, // Size of next message
out cMessages, // Number of messages
IntPtr.Zero // No read time-out
);
if (!succeeded)
{
Console.WriteLine("GetMailslotInfo failed w/err 0x{0:X}",
Marshal.GetLastWin32Error());
return(succeeded);
}
if (cbMessageBytes == MAILSLOT_NO_MESSAGE)
{
// There are no new messages in the mailslot at present
Console.WriteLine("No new messages.");
return(succeeded);
}
// Retrieve the messages one by one from the mailslot.
while (cMessages != 0)
{
nMessageId++;
// Declare a byte array to fetch the data
byte[] bBuffer = new byte[cbMessageBytes];
succeeded = NativeMethod.ReadFile(
hMailslot, // Handle of mailslot
bBuffer, // Buffer to receive data
cbMessageBytes, // Size of buffer in bytes
out cbBytesRead, // Number of bytes read from mailslot
IntPtr.Zero // Not overlapped I/O
);
if (!succeeded)
{
Console.WriteLine("ReadFile failed w/err 0x{0:X}",
Marshal.GetLastWin32Error());
break;
}
// Display the message.
Console.WriteLine("Message #{0}: {1}", nMessageId,
Encoding.Unicode.GetString(bBuffer));
// Get the current number of un-read messages in the slot. The number
// may not equal the initial message number because new messages may
// arrive while we are reading the items in the slot.
succeeded = NativeMethod.GetMailslotInfo(
hMailslot, // Handle of the mailslot
IntPtr.Zero, // No maximum message size
out cbMessageBytes, // Size of next message
out cMessages, // Number of messages
IntPtr.Zero // No read time-out
);
if (!succeeded)
{
Console.WriteLine("GetMailslotInfo failed w/err 0x{0:X}",
Marshal.GetLastWin32Error());
break;
}
}
return(succeeded);
}
/// <summary>Calls method <paramref name="method" /> in SuperMemo</summary>
/// <param name="method">The method to call</param>
/// <param name="parameters">The method's parameters to pass along with the call</param>
/// <returns>
/// The returned value (eax register) from the call to <paramref name="method" />
/// </returns>
protected int CallNativeMethod(NativeMethod method,
dynamic[] parameters)
{
SMA.Debug($"Executing native method {Enum.GetName(typeof(NativeMethod), method)}.");
if (parameters == null)
{
OnException(new ArgumentNullException(nameof(parameters), $"CallNativeMethod: Called with null 'parameters' for method {method}"));
return(-1);
}
// Possible null reference on parameters
var marshalledParameters = new IMarshalledValue[parameters.Length];
for (var i = 0; i < parameters.Length; i++)
{
var p = parameters[i];
var dynMarshalled = MarshalValue.Marshal(_smProcess, p);
if (dynMarshalled is IMarshalledValue marshalled)
{
marshalledParameters[i] = marshalled;
}
else
{
OnException(new ArgumentException($"CallNativeMethod: Parameter n°{i} '{p}' could not be marshalled for method {method}",
nameof(p)));
return(-1);
}
}
try
{
switch (method)
{
case NativeMethod.AppendAndAddElementFromText:
var elWdw = marshalledParameters[0].Reference.ToInt32();
var elType = marshalledParameters[1].Reference.ToInt32();
var elDesc = marshalledParameters[2].Reference.ToInt32();
// elWdw.AppendElement(elType, automatic: false);
int elemId = Delphi.registerCall3(_callTable[NativeMethod.ElWdw_AppendElement],
elWdw,
elType,
0);
if (elemId <= 0)
{
return(-1);
}
// elWdw.AddElementFromText(elDesc);
int res = Delphi.registerCall2(_callTable[NativeMethod.ElWdw_AddElementFromText],
elWdw,
elDesc);
return(res > 0 ? elemId : -1);
case NativeMethod.PostponeRepetition:
elWdw = marshalledParameters[0].Reference.ToInt32();
var interval = marshalledParameters[1].Reference.ToInt32();
// elWdw.ExecuteUncommittedRepetition(inclTopics: true, forceDisplay: false);
Delphi.registerCall3(_callTable[NativeMethod.ElWdw_ExecuteUncommittedRepetition],
elWdw,
1,
0);
// elWdw.ScheduleInInterval(interval);
Delphi.registerCall2(_callTable[NativeMethod.ElWdw_ScheduleInInterval],
elWdw,
interval);
// elWdw.SetElementState(DisplayState.Display);
//registerCall2(_callTable[NativeMethod.ElWdw_SetElementState],
// elWdw,
// 2);
// elWdw.NextElementInLearningQueue()
Delphi.registerCall1(_callTable[NativeMethod.ElWdw_NextElementInLearningQueue],
elWdw);
return(1);
case NativeMethod.ForceRepetitionAndResume:
elWdw = marshalledParameters[0].Reference.ToInt32();
interval = marshalledParameters[1].Reference.ToInt32();
var adjustPriority = marshalledParameters[2].Reference.ToInt32();
// elWdw.ForceRepetitionExt(interval, adjustPriority);
Delphi.registerCall3(_callTable[NativeMethod.ElWdw_ForceRepetitionExt],
elWdw,
interval,
adjustPriority);
// elWdw.NextElementInLearningQueue();
Delphi.registerCall1(_callTable[NativeMethod.ElWdw_NextElementInLearningQueue],
elWdw);
// elWdw.RestoreLearningMode();
Delphi.registerCall1(_callTable[NativeMethod.ElWdw_RestoreLearningMode],
elWdw);
return(1);
}
switch (parameters.Length)
{
case 1:
return(Delphi.registerCall1(_callTable[method],
marshalledParameters[0].Reference.ToInt32()));
case 2:
return(Delphi.registerCall2(_callTable[method],
marshalledParameters[0].Reference.ToInt32(),
marshalledParameters[1].Reference.ToInt32()));
case 3:
return(Delphi.registerCall3(_callTable[method],
marshalledParameters[0].Reference.ToInt32(),
marshalledParameters[1].Reference.ToInt32(),
marshalledParameters[2].Reference.ToInt32()));
case 4:
return(Delphi.registerCall4(_callTable[method],
marshalledParameters[0].Reference.ToInt32(),
marshalledParameters[1].Reference.ToInt32(),
marshalledParameters[2].Reference.ToInt32(),
marshalledParameters[3].Reference.ToInt32()));
case 5:
return(Delphi.registerCall5(_callTable[method],
marshalledParameters[0].Reference.ToInt32(),
marshalledParameters[1].Reference.ToInt32(),
marshalledParameters[2].Reference.ToInt32(),
marshalledParameters[3].Reference.ToInt32(),
marshalledParameters[4].Reference.ToInt32()));
case 6:
return(Delphi.registerCall6(_callTable[method],
marshalledParameters[0].Reference.ToInt32(),
marshalledParameters[1].Reference.ToInt32(),
marshalledParameters[2].Reference.ToInt32(),
marshalledParameters[3].Reference.ToInt32(),
marshalledParameters[4].Reference.ToInt32(),
marshalledParameters[5].Reference.ToInt32()));
default:
throw new NotImplementedException($"No execution path to handle {parameters.Length} parameters.");
}
}
finally
{
foreach (var param in marshalledParameters)
{
param.Dispose();
}
}
}
private Impersonation(string username, string domain, string password, LogonType logonType, BuiltinUser builtinUser)
{
switch (builtinUser)
{
case BuiltinUser.None:
if (string.IsNullOrEmpty(username))
{
return;
}
break;
case BuiltinUser.LocalService:
username = "******";
break;
case BuiltinUser.NetworkService:
username = "******";
break;
}
IntPtr userToken = IntPtr.Zero;
IntPtr userTokenDuplication = IntPtr.Zero;
// Logon with user and get token.
bool loggedOn = NativeMethod.LogonUser(username, domain, password, logonType, LogonProvider.Default, out userToken);
if (loggedOn)
{
try
{
// Create a duplication of the usertoken, this is a solution
// for the known bug that is published under KB article Q319615.
if (NativeMethod.DuplicateToken(userToken, 2, ref userTokenDuplication))
{
// Create windows identity from the token and impersonate the user.
WindowsIdentity identity = new WindowsIdentity(userTokenDuplication);
_impersonationContext = identity.Impersonate();
}
//else
//{
// // Token duplication failed!
// // Use the default ctor overload
// // that will use Mashal.GetLastWin32Error();
// // to create the exceptions details.
// throw new Win32Exception();
//}
}
finally
{
// Close usertoken handle duplication when created.
if (!userTokenDuplication.Equals(IntPtr.Zero))
{
// Closes the handle of the user.
NativeMethod.CloseHandle(userTokenDuplication);
userTokenDuplication = IntPtr.Zero;
}
// Close usertoken handle when created.
if (!userToken.Equals(IntPtr.Zero))
{
// Closes the handle of the user.
NativeMethod.CloseHandle(userToken);
userToken = IntPtr.Zero;
}
}
}
//else
//{
// // Logon failed!
// // Use the default ctor overload that
// // will use Mashal.GetLastWin32Error();
// // to create the exceptions details.
// throw new Win32Exception();
//}
}
public static bool RegisterTouchWindow(IntPtr hwnd)
{
return(NativeMethod.RegisterTouchWindow(hwnd, 0));
}
public MethodInfo(ObjectModel objects, NativeInterface ni, NativeMethod method)
{
Name = method.Name;
ResultType = new TypeInfo(objects, ni, method);
var argNames = new List<NameInfo>();
var argTypes = new List<ArgTypeInfo>();
for (int i = 0; i < method.ArgNames.Length; ++i)
{
argNames.Add(new NameInfo(method.ArgNames[i]));
argTypes.Add(new ArgTypeInfo(objects, method.ArgTypes[i]));
if (argTypes[argTypes.Count - 1].ManagedOut.Length > 0)
HasOutArgs = true;
}
ArgNames = argNames.ToArray();
ArgTypes = argTypes.ToArray();
}
private void Form1_Load(object sender, EventArgs e)
{
int i = NativeMethod.SetWindowsHookEx(HookID.WH_KEYBOARD_LL, kbproc, Marshal.GetHINSTANCE(Assembly.GetExecutingAssembly().GetModules()[0]), 0);
Text = i.ToString();
}
private void DoWriteCall(NativeMethod method, MethodInfo minfo)
{
string rtype = minfo.ResultType.Managed;
if (rtype == "void")
m_buffer.Append(" Unused.Value = ");
else
if (minfo.HasOutArgs)
m_buffer.Append(" " + rtype + " result_ = ");
else
m_buffer.Append(" return ");
if (rtype != "void")
{
m_buffer.Append("(");
m_buffer.Append(rtype == "bool" ? "sbyte" : rtype);
m_buffer.Append(") ");
}
if (m_interface.Category != null && !m_objects.EmittedType(m_interface.Name))
if (method.IsClass)
m_buffer.AppendFormat("{0}.Class.", m_interface.Name);
else
m_buffer.Append("_instance.");
else if (method.IsClass)
m_buffer.Append("ms_class.");
m_buffer.Append("Call(\"");
m_buffer.Append(method.Name);
m_buffer.Append("\"");
for (int i = 0; i < minfo.ArgNames.Length; ++i)
{
m_buffer.Append(", ");
if (minfo.ArgTypes[i].Native == "SEL")
{
string aname = minfo.ArgNames[i].Managed;
m_buffer.Append(aname + " != null ? new Selector(");
m_buffer.Append(aname);
m_buffer.Append(") : null");
}
else if (minfo.ArgTypes[i].ManagedOut.Length > 0)
{
m_buffer.Append(minfo.ArgNames[i].Managed);
m_buffer.Append("Ptr");
}
else
m_buffer.Append(minfo.ArgNames[i].Managed);
}
m_buffer.Append(")");
if (minfo.ResultType.Managed == "bool")
{
m_buffer.Append(" != 0");
}
m_buffer.AppendLine(";");
}
/// <summary>
/// P/Invoke the native APIs related to named pipe operations to create
/// the named pipe.
/// </summary>
public static void Run()
{
SafePipeHandle hNamedPipe = null;
try
{
// Prepare the security attributes (the securityAttributes
// parameter in CreateNamedPipe) for the pipe. This is optional.
// If securityAttributes of CreateNamedPipe is null, the named
// pipe gets a default security descriptor and the handle cannot
// be inherited. The ACLs in the default security descriptor of a
// pipe grant full control to the LocalSystem account, (elevated)
// administrators, and the creator owner. They also give only
// read access to members of the Everyone group and the anonymous
// account. However, if you want to customize the security
// permission of the pipe, (e.g. to allow Authenticated Users to
// read from and write to the pipe), you need to create a
// SECURITY_ATTRIBUTES object.
SECURITY_ATTRIBUTES sa = null;
sa = CreateNativePipeSecurity();
// Create the named pipe.
hNamedPipe = NativeMethod.CreateNamedPipe(
Program.FullPipeName, // The unique pipe name.
PipeOpenMode.PIPE_ACCESS_DUPLEX, // The pipe is duplex
PipeMode.PIPE_TYPE_MESSAGE | // Message type pipe
PipeMode.PIPE_READMODE_MESSAGE | // Message-read mode
PipeMode.PIPE_WAIT, // Blocking mode is on
PIPE_UNLIMITED_INSTANCES, // Max server instances
Program.BufferSize, // Output buffer size
Program.BufferSize, // Input buffer size
NMPWAIT_USE_DEFAULT_WAIT, // Time-out interval
sa // Pipe security attributes
);
if (hNamedPipe.IsInvalid)
{
throw new Win32Exception();
}
Console.WriteLine("The named pipe ({0}) is created.",
Program.FullPipeName);
// Wait for the client to connect.
Console.WriteLine("Waiting for the client's connection...");
if (!NativeMethod.ConnectNamedPipe(hNamedPipe, IntPtr.Zero))
{
if (Marshal.GetLastWin32Error() != ERROR_PIPE_CONNECTED)
{
throw new Win32Exception();
}
}
Console.WriteLine("Client is connected.");
//
// Receive a request from client.
//
string message;
bool finishRead = false;
do
{
byte[] bRequest = new byte[Program.BufferSize];
int cbRequest = bRequest.Length, cbRead;
finishRead = NativeMethod.ReadFile(
hNamedPipe, // Handle of the pipe
bRequest, // Buffer to receive data
cbRequest, // Size of buffer in bytes
out cbRead, // Number of bytes read
IntPtr.Zero // Not overlapped
);
if (!finishRead &&
Marshal.GetLastWin32Error() != ERROR_MORE_DATA)
{
throw new Win32Exception();
}
// Unicode-encode the received byte array and trim all the
// '\0' characters at the end.
message = Encoding.Unicode.GetString(bRequest).TrimEnd('\0');
Console.WriteLine("Receive {0} bytes from client: \"{1}\"",
cbRead, message);
}while (!finishRead); // Repeat loop if ERROR_MORE_DATA
//
// Send a response from server to client.
//
message = Program.ResponseMessage;
byte[] bResponse = Encoding.Unicode.GetBytes(message);
int cbResponse = bResponse.Length, cbWritten;
if (!NativeMethod.WriteFile(
hNamedPipe, // Handle of the pipe
bResponse, // Message to be written
cbResponse, // Number of bytes to write
out cbWritten, // Number of bytes written
IntPtr.Zero // Not overlapped
))
{
throw new Win32Exception();
}
Console.WriteLine("Send {0} bytes to client: \"{1}\"",
cbWritten, message.TrimEnd('\0'));
// Flush the pipe to allow the client to read the pipe's contents
// before disconnecting. Then disconnect the client's connection.
NativeMethod.FlushFileBuffers(hNamedPipe);
NativeMethod.DisconnectNamedPipe(hNamedPipe);
}
catch (Exception ex)
{
Console.WriteLine("The server throws the error: {0}", ex.Message);
}
finally
{
if (hNamedPipe != null)
{
hNamedPipe.Close();
hNamedPipe = null;
}
}
}
private bool DoTryFastCall(NativeMethod method, MethodInfo minfo)
{
if (!minfo.HasOutArgs)
{
if (minfo.ArgNames.Length == 0)
return DoTryFastCall0(method, minfo);
else if (minfo.ArgNames.Length == 1)
return DoTryFastCall1(method, minfo);
else if (minfo.ArgNames.Length == 2)
return DoTryFastCall2(method, minfo);
}
return false;
}
private bool DoTryFastCall2(NativeMethod method, MethodInfo minfo)
{
bool done = false;
string rtype = minfo.ResultType.Managed;
string rlabel, a0label, a1label;
string rkey = DoGetKey(minfo.ResultType);
string a0key = DoGetKey(minfo.ArgTypes[0]);
string a1key = DoGetKey(minfo.ArgTypes[1]);
if (m_labels.TryGetValue(rkey, out rlabel) && m_labels.TryGetValue(a0key, out a0label) && m_labels.TryGetValue(a1key, out a1label))
{
string thisPtr;
if (m_interface.Category != null && !m_objects.EmittedType(m_interface.Name))
if (method.IsClass)
thisPtr = string.Format("{0}.Class", m_interface.Name);
else
thisPtr = "_instance";
else if (method.IsClass)
thisPtr = "ms_class";
else
thisPtr = "this";
m_buffer.AppendLine(" IntPtr exception_ = IntPtr.Zero;");
DoAppendFastArgProlog(minfo, 0);
DoAppendFastArgProlog(minfo, 1);
m_buffer.Append(" ");
if (rkey != "void")
m_buffer.AppendFormat("{0} result_ = ", m_dtypes[rkey]);
m_buffer.AppendFormat("DirectCalls.Call{0}{1}{2}({3}, new Selector(\"{4}\"), ", rlabel, a0label, a1label, thisPtr, method.Name);
DoAppendFastArg(minfo, 0);
DoAppendFastArg(minfo, 1);
m_buffer.AppendLine("ref exception_);");
DoAppendFastArgEpilog(minfo, 0);
DoAppendFastArgEpilog(minfo, 1);
m_buffer.AppendLine(" if (exception_ != IntPtr.Zero)");
m_buffer.AppendLine(" CocoaException.Raise(exception_);");
DoAppendFastResult(rkey, rtype, minfo);
done = true;
}
return done;
}
private string DoGetMethodSuffix(NativeMethod method)
{
string suffix = string.Empty;
if (m_objects.EmittedType(m_interface.Name))
{
NativeInterface ri = m_objects.FindInterface(m_interface.Name);
List<NativeMethod> methods;
if (m_objects.TryGetMethods(ri, out methods))
{
if (method.IsClass)
{
if (DoBaseHasMethod(ri.Name, method.Name, false))
suffix = "_c";
}
else
{
if (DoBaseHasMethod(ri.BaseName, method.Name, true)) // only use _i if the base class has a static method of the same name
suffix = "_i";
}
}
}
return suffix;
}
private bool DoGenerateMethod(NativeMethod nm, bool writeBlank, NativeProtocol protocol)
{
bool wrote = false;
bool defined = false;
if (protocol != null)
{
defined = DoPriorProtocolHasMethod(protocol, nm.Name, nm.IsClass);
if (!defined)
defined = DoInterfaceHasMethod(nm.Name, nm.IsClass);
if (!defined)
defined = DoBaseHasMethod(m_interface.BaseName, nm.Name, nm.IsClass);
}
else if (m_interface.Category != null)
{
if (m_objects.EmittedType(m_interface.Name))
{
defined = DoInterfaceHasMethod(nm.Name, nm.IsClass);
if (!defined)
{
NativeInterface ri = m_objects.FindInterface(m_interface.Name);
defined = DoBaseHasMethod(ri.BaseName, nm.Name, nm.IsClass);
}
}
}
else
{
defined = DoBaseHasMethod(m_interface.BaseName, nm.Name, nm.IsClass);
}
if (!defined)
{
Blacklist black = m_blacklist.SingleOrDefault(b => b.Interface == m_interface.Name && b.Method == nm.Name);
if (black == null)
{
if (nm.ArgTypes.Length > 0 && nm.ArgTypes[nm.ArgTypes.Length - 1] == "...")
{
DoWrite(" // skipping variadic {0}", nm.Name);
Console.Error.WriteLine("Ignoring {0}::{1} (it's variadic)", m_interface.Name, nm.Name);
}
else if (nm.ArgTypes.Length > 0 && nm.ArgTypes.Any(t => t.Contains("( * )")))
{
DoWrite(" // skipping function pointer {0}", nm.Name);
Console.Error.WriteLine("Ignoring {0}::{1} (it uses a function pointer)", m_interface.Name, nm.Name);
}
else if (nm.ArgTypes.Length > 0 && (nm.ArgTypes.Any(t => t.Contains("( ^ )")) || nm.ArgTypes.Any(t => t.Contains("(^)"))))
{
DoWrite(" // skipping block {0}", nm.Name);
Console.Error.WriteLine("Ignoring {0}::{1} (it uses a block)", m_interface.Name, nm.Name);
}
else if (nm.ReturnType.Contains("( ^ )") || nm.ReturnType.Contains("(^)"))
{
DoWrite(" // skipping block {0}", nm.Name);
Console.Error.WriteLine("Ignoring {0}::{1} (it uses a block)", m_interface.Name, nm.Name);
}
else
{
if (writeBlank)
DoWrite("\t\t");
DoWrite(" \t/// <exclude/>");
DoWriteMethod(nm);
wrote = true;
}
}
else
{
DoWrite(" // skipping {0} {1}", black.Method, black.Reason);
}
}
else
DoWrite(" // skipping {0} (it's already defined)", nm.Name);
return wrote;
}
public TypeInfo(ObjectModel objects, NativeInterface ni, NativeMethod method)
{
Native = method.ReturnType;
string type = objects.MapResult(ni.Name, method.Name, method.ReturnType);
Managed = MapType(objects, type);
if (Managed == "IBAction")
Managed = "void";
}
/// <summary>
/// 実行関数
/// </summary>
/// <returns></returns>
public int Execute()
{
_ope_info.fFlags = _ope_detail.FlagsToBit();
return(NativeMethod.SHFileOperation(ref _ope_info));
}
protected override sealed void OnDispose()
{
NativeMethod.UnhookWindowsHookEx(hook);
AfterDispose();
}
public void RedefineMethodAsObjectValue()
{
DefinedClass klass = new DefinedClass("Spam");
IFunction function = new NativeMethod(GetValueMethod);
klass.SetMethod("foo", function);
DynamicObject dynobj = new DynamicObject(klass);
dynobj.SetValue("foo", 1);
Assert.AreEqual(1, dynobj.GetValue("foo"));
}
public void TestNullTypeAction()
{
var method = new NativeMethod(null, (_, __) => { });
}
public void InvokeMethodThatReturnsSelf()
{
DefinedClass klass = new DefinedClass("Spam");
IFunction function = new NativeMethod(SelfMethod);
klass.SetMethod("foo", function);
DynamicObject dynobj = new DynamicObject(klass);
var result = dynobj.Invoke("foo", null, null, null);
Assert.IsNotNull(result);
Assert.AreEqual(dynobj, result);
}
public void TestNullAction()
{
var method = new NativeMethod("foo", default(Action <InvokeCallback, JArray>));
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public static IntPtr GetForegroundWindowHandle()
{
return(NativeMethod.GetForegroundWindow());
}
private void DoWriteMethod(NativeMethod method)
{
MethodInfo minfo = new MethodInfo(m_objects, m_interface, method);
// pure attribute
string name = DoGetMethodName(method.Name, DoGetMethodSuffix(method));
if (PureMethods.IsPure(name))
m_buffer.AppendLine(" [Pure]");
// obsolete attribute
if (method.Obsolete != null)
{
m_buffer.Append(" [Obsolete(\"");
m_buffer.Append(method.Obsolete);
m_buffer.AppendLine("\")]");
}
// signature
m_buffer.Append(" public ");
if (method.IsClass || (m_interface.Category != null && !m_objects.EmittedType(m_interface.Name)))
m_buffer.Append("static ");
m_buffer.Append(minfo.ResultType.Managed);
m_buffer.Append(" ");
m_buffer.Append(name);
m_buffer.Append("(");
if (m_interface.Category != null && !m_objects.EmittedType(m_interface.Name) && !method.IsClass)
{
m_buffer.AppendFormat("this {0} _instance", m_interface.Name);
if (method.ArgNames.Length > 0)
m_buffer.Append(", ");
}
for (int i = 0; i < minfo.ArgNames.Length; ++i)
{
m_buffer.Append(minfo.ArgTypes[i].Managed);
m_buffer.Append(" ");
m_buffer.Append(minfo.ArgNames[i].Managed);
if (i + 1 < minfo.ArgNames.Length)
m_buffer.Append(", ");
}
m_buffer.AppendLine(")");
DoWrite(" {");
// body
DoWriteProlog(minfo);
if (DoTryFastCall(method, minfo))
{
++m_fastCalls;
}
else
{
++m_slowCalls;
DoWriteCall(method, minfo);
}
DoWriteEpilog(minfo);
// trailer
DoWrite(" }");
}
/// <summary>
/// A public method with two outputs: the current process Id and the
/// current thread Id.
/// </summary>
/// <param name="processId">[out] The current process Id</param>
/// <param name="threadId">[out] The current thread Id</param>
public void GetProcessThreadID(out uint processId, out uint threadId)
{
processId = NativeMethod.GetCurrentProcessId();
threadId = NativeMethod.GetCurrentThreadId();
}
protected override bool ReleaseHandle()
{
return(NativeMethod.DwmUnregisterThumbnail(this.handle) == 0);
}
public void TestNullTypeFunc()
{
var method = new NativeMethod(null, (_, __) => default(JToken));
}
public static UInt32 SetLong(IntPtr hWnd, GWL index, UInt32 newLong)
{
return(NativeMethod.SetWindowLong(hWnd, index, newLong));
}
public void TestNullFunc()
{
var method = new NativeMethod("foo", default(Func <InvokeCallback, JArray, JToken>));
}
public static UInt32 GetLong(IntPtr hWnd, GWL index)
{
return(NativeMethod.GetWindowLong(hWnd, index));
}
public void InitializeTouch()
{
NativeMethod.InitializeTouchInjection(10, TouchFeedback.None);
this._initialized = true;
}
/// <summary>获取注册表项权限</summary>
/// <remarks>将注册表项所有者改为当前管理员用户</remarks>
/// <param name="regPath">要获取权限的注册表完整路径</param>
public static void TakeRegKeyOwnerShip(string regPath)
{
if (regPath.IsNullOrWhiteSpace())
{
return;
}
RegistryKey key = null;
WindowsIdentity id = null;
//利用试错判断是否有写入权限
try { key = RegistryEx.GetRegistryKey(regPath, true); }
catch
{
try
{
//获取当前用户的ID
id = WindowsIdentity.GetCurrent();
//添加TakeOwnership特权
bool flag = NativeMethod.TrySetPrivilege(NativeMethod.TakeOwnership, true);
if (!flag)
{
throw new PrivilegeNotHeldException(NativeMethod.TakeOwnership);
}
//添加恢复特权(必须这样做才能更改所有者)
flag = NativeMethod.TrySetPrivilege(NativeMethod.Restore, true);
if (!flag)
{
throw new PrivilegeNotHeldException(NativeMethod.Restore);
}
//打开没有权限的注册表路径
key = RegistryEx.GetRegistryKey(regPath, RegistryKeyPermissionCheck.ReadWriteSubTree, RegistryRights.TakeOwnership);
RegistrySecurity security = key.GetAccessControl(AccessControlSections.All);
//得到真正所有者
//IdentityReference oldId = security.GetOwner(typeof(SecurityIdentifier));
//SecurityIdentifier siTrustedInstaller = new SecurityIdentifier(oldId.ToString());
//使进程用户成为所有者
security.SetOwner(id.User);
key.SetAccessControl(security);
//添加完全控制
RegistryAccessRule fullAccess = new RegistryAccessRule(id.User, RegistryRights.FullControl,
InheritanceFlags.ContainerInherit, PropagationFlags.None, AccessControlType.Allow);
security.AddAccessRule(fullAccess);
key.SetAccessControl(security);
//注册表操作（写入、删除）
//key.SetValue("temp", "");//示例
//恢复原有所有者
//security.SetOwner(siTrustedInstaller);
//key.SetAccessControl(security);
//收回原有权利
//security.RemoveAccessRule(fullAccess);
//key.SetAccessControl(security);
///得到真正所有者、注册表操作、恢复原有所有者、收回原有权利，这四部分在原文中没有被注释掉
///但是如果保留这四部分，会在恢复原有所有者这一步抛出异常，提示没有权限，
///不过我发现经过上面的操作，虽然无法还原所有者权限，但是已经获取了注册表权限
///即已经将TrustedInstaller权限更改为当前管理员用户权限，我要的目的已经达到了
}
catch { }
}
finally { key?.Close(); id?.Dispose(); }
}
private static void KillTimerProc(object stateInfo)
{
NativeMethod.PostThreadMessage((stateInfo as SingleComServer)._nMainThreadID,
NativeMethod.WM_QUIT, UIntPtr.Zero, IntPtr.Zero);
}
/// <summary>
/// P/Invoke the native APIs related to named pipe operations to connect
/// to the named pipe.
/// </summary>
public static void Run()
{
SafePipeHandle hNamedPipe = null;
try
{
// Try to open the named pipe identified by the pipe name.
while (true)
{
hNamedPipe = NativeMethod.CreateFile(
Program.FullPipeName, // Pipe name
FileDesiredAccess.GENERIC_READ | // Read access
FileDesiredAccess.GENERIC_WRITE, // Write access
FileShareMode.Zero, // No sharing
null, // Default security attributes
FileCreationDisposition.OPEN_EXISTING, // Opens existing pipe
0, // Default attributes
IntPtr.Zero // No template file
);
// If the pipe handle is opened successfully ...
if (!hNamedPipe.IsInvalid)
{
Console.WriteLine("The named pipe ({0}) is connected.",
Program.FullPipeName);
break;
}
// Exit if an error other than ERROR_PIPE_BUSY occurs.
if (Marshal.GetLastWin32Error() != ERROR_PIPE_BUSY)
{
throw new Win32Exception();
}
// All pipe instances are busy, so wait for 5 seconds.
if (!NativeMethod.WaitNamedPipe(Program.FullPipeName, 5000))
{
throw new Win32Exception();
}
}
// Set the read mode and the blocking mode of the named pipe. In
// this sample, we set data to be read from the pipe as a stream
// of messages.
PipeMode mode = PipeMode.PIPE_READMODE_MESSAGE;
if (!NativeMethod.SetNamedPipeHandleState(hNamedPipe, ref mode,
IntPtr.Zero, IntPtr.Zero))
{
throw new Win32Exception();
}
//
// Send a request from client to server.
//
string message = Program.RequestMessage;
byte[] bRequest = Encoding.Unicode.GetBytes(message);
int cbRequest = bRequest.Length, cbWritten;
if (!NativeMethod.WriteFile(
hNamedPipe, // Handle of the pipe
bRequest, // Message to be written
cbRequest, // Number of bytes to write
out cbWritten, // Number of bytes written
IntPtr.Zero // Not overlapped
))
{
throw new Win32Exception();
}
Console.WriteLine("Send {0} bytes to server: \"{1}\"",
cbWritten, message.TrimEnd('\0'));
//
// Receive a response from server.
//
bool finishRead = false;
do
{
byte[] bResponse = new byte[Program.BufferSize];
int cbResponse = bResponse.Length, cbRead;
finishRead = NativeMethod.ReadFile(
hNamedPipe, // Handle of the pipe
bResponse, // Buffer to receive data
cbResponse, // Size of buffer in bytes
out cbRead, // Number of bytes read
IntPtr.Zero // Not overlapped
);
if (!finishRead &&
Marshal.GetLastWin32Error() != ERROR_MORE_DATA)
{
throw new Win32Exception();
}
// Unicode-encode the received byte array and trim all the
// '\0' characters at the end.
message = Encoding.Unicode.GetString(bResponse).TrimEnd('\0');
Console.WriteLine("Receive {0} bytes from server: \"{1}\"",
cbRead, message);
}while (!finishRead); // Repeat loop if ERROR_MORE_DATA
}
catch (Exception ex)
{
Console.WriteLine("The client throws the error: {0}", ex.Message);
}
finally
{
if (hNamedPipe != null)
{
hNamedPipe.Close();
hNamedPipe = null;
}
}
}
public void Add(NativeMethod method)
{
m_methods.Add(method);
}
/// <summary>
/// Release handle
/// </summary>
protected override bool ReleaseHandle()
{
return(NativeMethod.FreeLibrary(handle));
}
static void Main(string[] args)
{
SafeMailslotHandle hMailslot = null;
try
{
// Prepare the security attributes (the lpSecurityAttributes parameter
// in CreateMailslot) for the mailslot. This is optional. If the
// lpSecurityAttributes parameter of CreateMailslot is NULL, the
// mailslot gets a default security descriptor and the handle cannot
// be inherited. The ACLs in the default security descriptor of a
// mailslot grant full control to the LocalSystem account, (elevated)
// administrators, and the creator owner. They also give only read
// access to members of the Everyone group and the anonymous account.
// However, if you want to customize the security permission of the
// mailslot, (e.g. to allow Authenticated Users to read from and
// write to the mailslot), you need to create a SECURITY_ATTRIBUTES
// structure.
SECURITY_ATTRIBUTES sa = null;
sa = CreateMailslotSecurity();
// Create the mailslot.
hMailslot = NativeMethod.CreateMailslot(
MailslotName, // The name of the mailslot
0, // No maximum message size
MAILSLOT_WAIT_FOREVER, // Waits forever for a message
sa // Mailslot security attributes
);
if (hMailslot.IsInvalid)
{
throw new Win32Exception();
}
Console.WriteLine("The mailslot ({0}) is created.", MailslotName);
// Check messages in the mailslot.
Console.Write("Press ENTER to check new messages or press Q to quit ...");
string cmd = Console.ReadLine();
while (!cmd.Equals("Q", StringComparison.OrdinalIgnoreCase))
{
Console.WriteLine("Checking new messages...");
ReadMailslot(hMailslot);
Console.Write("Press ENTER to check new messages or press Q to quit ...");
cmd = Console.ReadLine();
}
}
catch (Win32Exception ex)
{
Console.WriteLine("The server throws the error: {0}", ex.Message);
}
finally
{
if (hMailslot != null)
{
hMailslot.Close();
hMailslot = null;
}
}
}
// Method := ('-' / '+') S ParensType? (Parameter+ VarArgs? / Identifier) Deprecated? Availability? ';' S;
//
// Parameter := Identifier? ':' S ParensType? Identifier;
//
// VarArgs := ',' S '...' S ('NS_REQUIRES_NIL_TERMINATION' S)?;
//
// ParensType := '(' S Type ')' S;
private NativeMethod DoAnalyzeMethod(XmlNode node, string deprecated)
{
deprecated = deprecated ?? DoFindDeprecated(node);
var name = new System.Text.StringBuilder();
string rtype = node.ChildNodes[1].Name == "ParensType" ? node.ChildNodes[1].InnerText : "id";
var argNames = new List<string>();
var argTypes = new List<string>();
XmlNode identifier = DoFind(node, "Identifier");
if (identifier != null)
{
name.Append(identifier.InnerText);
}
else
{
for (int i = 1; i < node.ChildNodes.Count; ++i)
{
XmlNode p = node.ChildNodes[i];
if (p.Name == "Parameter")
{
if (p.ChildNodes[0].Name == "Identifier")
name.Append(p.ChildNodes[0].InnerText);
name.Append(':');
XmlNode parens = DoFind(p, "ParensType");
XmlNode aname = DoFindLast(p, "Identifier");
if (parens != null)
argTypes.Add(parens.InnerText);
else
argTypes.Add("id");
if (argNames.Contains(aname.InnerText))
argNames.Add(aname.InnerText + "2"); // clientAcceptedChangesForRecordWithIdentifier:formattedRecord:newRecordIdentifier: has duplicate argument names...
else
argNames.Add(aname.InnerText);
}
}
XmlNode varArgs = DoFind(node, "VarArgs");
if (varArgs != null)
{
argNames.Add(string.Empty);
argTypes.Add("...");
}
}
var result = new NativeMethod{
IsClass = node.ChildNodes[0].Value == "+",
Name = name.ToString(),
ReturnType = rtype,
ArgNames = argNames.ToArray(),
ArgTypes = argTypes.ToArray(),
Obsolete = deprecated};
return result;
}
public void RaiseWhenThereIsAValueInsteadOfAMethod()
{
DefinedClass klass = new DefinedClass("Spam");
IFunction function = new NativeMethod(GetValueMethod);
klass.SetMethod("foo", function);
DynamicObject dynobj = new DynamicObject(klass);
dynobj.SetValue("foo", 1);
try
{
dynobj.Invoke("foo", null, new object[] { "one" }, null);
Assert.Fail("Exception expected");
}
catch (Exception ex)
{
Assert.IsInstanceOfType(ex, typeof(TypeError));
Assert.AreEqual("'int' object is not callable", ex.Message);
}
}
/// <summary>
/// The function gets the integrity level of the current process. Integrity
/// level is only available on Windows Vista and newer operating systems, thus
/// GetProcessIntegrityLevel throws a C++ exception if it is called on systems
/// prior to Windows Vista.
/// </summary>
/// <returns>
/// Returns the integrity level of the current process. It is usually one of
/// these values:
///
/// SECURITY_MANDATORY_UNTRUSTED_RID - means untrusted level. It is used
/// by processes started by the Anonymous group. Blocks most write access.
/// (SID: S-1-16-0x0)
///
/// SECURITY_MANDATORY_LOW_RID - means low integrity level. It is used by
/// Protected Mode Internet Explorer. Blocks write acess to most objects
/// (such as files and registry keys) on the system. (SID: S-1-16-0x1000)
///
/// SECURITY_MANDATORY_MEDIUM_RID - means medium integrity level. It is
/// used by normal applications being launched while UAC is enabled.
/// (SID: S-1-16-0x2000)
///
/// SECURITY_MANDATORY_HIGH_RID - means high integrity level. It is used
/// by administrative applications launched through elevation when UAC is
/// enabled, or normal applications if UAC is disabled and the user is an
/// administrator. (SID: S-1-16-0x3000)
///
/// SECURITY_MANDATORY_SYSTEM_RID - means system integrity level. It is
/// used by services and other system-level applications (such as Wininit,
/// Winlogon, Smss, etc.) (SID: S-1-16-0x4000)
///
/// </returns>
/// <exception cref="System.ComponentModel.Win32Exception">
/// When any native Windows API call fails, the function throws a Win32Exception
/// with the last error code.
/// </exception>
public static int GetProcessIntegrityLevel()
{
int IL = -1;
SafeTokenHandle hToken = null;
int cbTokenIL = 0;
IntPtr pTokenIL = IntPtr.Zero;
try
{
// Open the access token of the current process with TOKEN_QUERY.
if (!NativeMethod.OpenProcessToken(Process.GetCurrentProcess().Handle,
NativeMethod.TOKEN_QUERY, out hToken))
{
throw new Win32Exception();
}
// Then we must query the size of the integrity level information
// associated with the token. Note that we expect GetTokenInformation
// to return false with the ERROR_INSUFFICIENT_BUFFER error code
// because we've given it a null buffer. On exit cbTokenIL will tell
// the size of the group information.
if (!NativeMethod.GetTokenInformation(hToken,
TOKEN_INFORMATION_CLASS.TokenIntegrityLevel, IntPtr.Zero, 0,
out cbTokenIL))
{
int error = Marshal.GetLastWin32Error();
if (error != NativeMethod.ERROR_INSUFFICIENT_BUFFER)
{
// When the process is run on operating systems prior to
// Windows Vista, GetTokenInformation returns false with the
// ERROR_INVALID_PARAMETER error code because
// TokenIntegrityLevel is not supported on those OS's.
throw new Win32Exception(error);
}
}
// Now we allocate a buffer for the integrity level information.
pTokenIL = Marshal.AllocHGlobal(cbTokenIL);
if (pTokenIL == IntPtr.Zero)
{
throw new Win32Exception();
}
// Now we ask for the integrity level information again. This may fail
// if an administrator has added this account to an additional group
// between our first call to GetTokenInformation and this one.
if (!NativeMethod.GetTokenInformation(hToken,
TOKEN_INFORMATION_CLASS.TokenIntegrityLevel, pTokenIL, cbTokenIL,
out cbTokenIL))
{
throw new Win32Exception();
}
// Marshal the TOKEN_MANDATORY_LABEL struct from native to .NET object.
TOKEN_MANDATORY_LABEL tokenIL = (TOKEN_MANDATORY_LABEL)
Marshal.PtrToStructure(pTokenIL, typeof(TOKEN_MANDATORY_LABEL));
// Integrity Level SIDs are in the form of S-1-16-0xXXXX. (e.g.
// S-1-16-0x1000 stands for low integrity level SID). There is one
// and only one subauthority.
IntPtr pIL = NativeMethod.GetSidSubAuthority(tokenIL.Label.Sid, 0);
IL = Marshal.ReadInt32(pIL);
}
finally
{
// Centralized cleanup for all allocated resources.
if (hToken != null)
{
hToken.Close();
hToken = null;
}
if (pTokenIL != IntPtr.Zero)
{
Marshal.FreeHGlobal(pTokenIL);
pTokenIL = IntPtr.Zero;
cbTokenIL = 0;
}
}
return(IL);
}
/// <summary>
/// The function launches an application at low integrity level.
/// </summary>
/// <param name="commandLine">
/// The command line to be executed. The maximum length of this string is 32K
/// characters.
/// </param>
/// <param name="selectedIntegrityLevel">
/// Numeric representation of integrity level with which process has to be started
/// </param>
/// <remarks>
/// To start a low-integrity process,
/// 1) Duplicate the handle of the current process, which is at medium
/// integrity level.
/// 2) Use SetTokenInformation to set the integrity level in the access token
/// to Low.
/// 3) Use CreateProcessAsUser to create a new process using the handle to
/// the low integrity access token.
/// </remarks>
public static void CreateSpecificIntegrityProcess(string commandLine, int selectedIntegrityLevel)
{
SafeTokenHandle hToken = null;
SafeTokenHandle hNewToken = null;
IntPtr pIntegritySid = IntPtr.Zero;
int cbTokenInfo = 0;
IntPtr pTokenInfo = IntPtr.Zero;
STARTUPINFO si = new STARTUPINFO();
PROCESS_INFORMATION pi = new PROCESS_INFORMATION();
try
{
// Open the primary access token of the process.
if (!NativeMethod.OpenProcessToken(Process.GetCurrentProcess().Handle,
NativeMethod.TOKEN_DUPLICATE | NativeMethod.TOKEN_ADJUST_DEFAULT |
NativeMethod.TOKEN_QUERY | NativeMethod.TOKEN_ASSIGN_PRIMARY,
out hToken))
{
throw new Win32Exception();
}
// Duplicate the primary token of the current process.
if (!NativeMethod.DuplicateTokenEx(hToken, 0, IntPtr.Zero,
SECURITY_IMPERSONATION_LEVEL.SecurityImpersonation,
TOKEN_TYPE.TokenPrimary, out hNewToken))
{
throw new Win32Exception();
}
// Create the low integrity SID.
if (!NativeMethod.AllocateAndInitializeSid(
ref NativeMethod.SECURITY_MANDATORY_LABEL_AUTHORITY, 1,
selectedIntegrityLevel,
0, 0, 0, 0, 0, 0, 0, out pIntegritySid))
{
throw new Win32Exception();
}
TOKEN_MANDATORY_LABEL tml;
tml.Label.Attributes = NativeMethod.SE_GROUP_INTEGRITY;
tml.Label.Sid = pIntegritySid;
// Marshal the TOKEN_MANDATORY_LABEL struct to the native memory.
cbTokenInfo = Marshal.SizeOf(tml);
pTokenInfo = Marshal.AllocHGlobal(cbTokenInfo);
Marshal.StructureToPtr(tml, pTokenInfo, false);
// Set the integrity level in the access token to low.
if (!NativeMethod.SetTokenInformation(hNewToken,
TOKEN_INFORMATION_CLASS.TokenIntegrityLevel, pTokenInfo,
cbTokenInfo + NativeMethod.GetLengthSid(pIntegritySid)))
{
throw new Win32Exception();
}
// Create the new process at the Low integrity level.
si.cb = Marshal.SizeOf(si);
if (!NativeMethod.CreateProcessAsUser(hNewToken, null, commandLine,
IntPtr.Zero, IntPtr.Zero, false, 0, IntPtr.Zero, null, ref si,
out pi))
{
throw new Win32Exception();
}
}
finally
{
// Centralized cleanup for all allocated resources.
if (hToken != null)
{
hToken.Close();
hToken = null;
}
if (hNewToken != null)
{
hNewToken.Close();
hNewToken = null;
}
if (pIntegritySid != IntPtr.Zero)
{
NativeMethod.FreeSid(pIntegritySid);
pIntegritySid = IntPtr.Zero;
}
if (pTokenInfo != IntPtr.Zero)
{
Marshal.FreeHGlobal(pTokenInfo);
pTokenInfo = IntPtr.Zero;
cbTokenInfo = 0;
}
if (pi.hProcess != IntPtr.Zero)
{
NativeMethod.CloseHandle(pi.hProcess);
pi.hProcess = IntPtr.Zero;
}
if (pi.hThread != IntPtr.Zero)
{
NativeMethod.CloseHandle(pi.hThread);
pi.hThread = IntPtr.Zero;
}
}
}
/// <summary> Send Message </summary>
/// <param name="hWnd">Target Handle</param>
/// <param name="uiMsg">Send Message</param>
/// <param name="wParam">wParam</param>
/// <param name="lParam">lParam</param>
/// <returns></returns>
public static Int64 Send(IntPtr hWnd, UInt32 uiMsg, IntPtr wParam, IntPtr lParam)
{
return(NativeMethod.SendMessage(hWnd, uiMsg, wParam, lParam));
}
public void InvokeMethodDefinedInClass()
{
DefinedClass klass = new DefinedClass("Spam");
IFunction function = new NativeMethod(DummyMethod);
klass.SetMethod("foo", function);
DynamicObject dynobj = new DynamicObject(klass);
var result = dynobj.Invoke("foo", null, null, null);
Assert.IsNull(result);
}
/// <summary> Post Message </summary>
/// <param name="hWnd">Target Handle</param>
/// <param name="uiMsg">Send Message</param>
/// <param name="wParam">wParam</param>
/// <param name="lParam">lParam</param>
/// <returns></returns>
public static Int64 Post(IntPtr hWnd, UInt32 uiMsg, UInt32 wParam, UInt32 lParam)
{
return(NativeMethod.PostMessage(hWnd, uiMsg, wParam, lParam));
}
static void Main(string[] args)
{
SafeFileMappingHandle hMapFile = null;
IntPtr pView = IntPtr.Zero;
try
{
// Try to open the named file mapping.
hMapFile = NativeMethod.OpenFileMapping(
FileMapAccess.FILE_MAP_READ, // Read access
false, // Do not inherit the name
FullMapName // File mapping name
);
if (hMapFile.IsInvalid)
{
throw new Win32Exception();
}
Console.WriteLine("The file mapping ({0}) is opened", FullMapName);
// Map a view of the file mapping into the address space of the
// current process.
pView = NativeMethod.MapViewOfFile(
hMapFile, // Handle of the map object
FileMapAccess.FILE_MAP_READ, // Read access
0, // High-order DWORD of file offset
ViewOffset, // Low-order DWORD of file offset
ViewSize // Byte# to map to view
);
if (pView == IntPtr.Zero)
{
throw new Win32Exception();
}
Console.WriteLine("The file view is mapped");
// Read and display the content in the view.
string message = Marshal.PtrToStringUni(pView);
Console.WriteLine("Read from the file mapping:\n\"{0}\"", message);
// Wait to clean up resources and stop the process.
Console.Write("Press ENTER to clean up resources and quit");
Console.ReadLine();
}
catch (Exception ex)
{
Console.WriteLine("The process throws the error: {0}", ex.Message);
}
finally
{
if (hMapFile != null)
{
if (pView != IntPtr.Zero)
{
// Unmap the file view.
NativeMethod.UnmapViewOfFile(pView);
pView = IntPtr.Zero;
}
// Close the file mapping object.
hMapFile.Close();
hMapFile = null;
}
}
}
/// <summary>
/// P/Invoke native APIs related to named pipe operations to create the named pipe.
/// System.IO.Pipes in Unity is missing crucial types/methods for performing reliable and
/// accurate transfers. Such as bytesSents/bytesReceived.
/// </summary>
public static void Run()
{
while (!KillServerRequested)
{
// ----------------------------------------------------------------------------------------------------------------
// Create the named pipe.
using (SafePipeHandle hNamedPipe = NativeMethod.CreateNamedPipe(
IPCServer.FullPipeName, // The unique pipe name.
PipeOpenMode.PIPE_ACCESS_DUPLEX, // The pipe is duplex
PipeMode.PIPE_TYPE_MESSAGE | // Message type pipe
PipeMode.PIPE_READMODE_MESSAGE | // Message-read mode
PipeMode.PIPE_WAIT, // Blocking mode is on
2, // Max server instances
IPCServer.BufferSize, // Output buffer size
IPCServer.BufferSize, // Input buffer size
NMPWAIT_USE_DEFAULT_WAIT // Time-out interval
))
{
try
{
if (hNamedPipe.IsInvalid)
{
throw new Win32Exception();
}
pipeHandle = hNamedPipe;
Console.WriteLine("[IPC Server Waiting for Connection] - \"{0}\"", IPCServer.FullPipeName);
// ----------------------------------------------------------------------------------------------------------------
// Wait for the connections. Runs on background thread.
if (!NativeMethod.ConnectNamedPipe(hNamedPipe, IntPtr.Zero))
{
if (Marshal.GetLastWin32Error() != ERROR_PIPE_CONNECTED)
{
throw new Win32Exception();
}
}
Console.WriteLine("[IPC Server Status] - Client Connected");
// ----------------------------------------------------------------------------------------------------------------
// Received a request from client.
string message;
bool finishRead = false;
do
{
byte[] bRequest = new byte[IPCServer.BufferSize];
int cbRequest = bRequest.Length, cbRead;
finishRead = NativeMethod.ReadFile(
hNamedPipe, // Handle of the pipe
bRequest, // Buffer to receive data
cbRequest, // Size of buffer in bytes
out cbRead, // Number of bytes read
IntPtr.Zero // Not overlapped
);
if (!finishRead && Marshal.GetLastWin32Error() != ERROR_MORE_DATA)
{
throw new Win32Exception();
}
// UTF8-encode the received byte array and trim all the '\0' characters at the end.
message = Encoding.UTF8.GetString(bRequest).Replace("\0", "");
Console.WriteLine("[IPC Server Received {0} bytes] Message: {1}\r\n", cbRead, message);
}while (!finishRead); // Repeat loop if ERROR_MORE_DATA
// If message is not KILL_SERVER, then process client request
if (message != "KILL_SERVER")
{
//Get our message header and data
string[] msgArray = message.Split(new string[] { "|:|" }, StringSplitOptions.None);
string header = msgArray[0];
string data = msgArray[1];
// Process Client Requests Here based off request header
Console.WriteLine(" Message Header: " + header);
Order order = JsonConvert.DeserializeObject <Order>(data);
Console.WriteLine(" Message Data: {0} ordered {1} {2}, delivery address: {3}\r\n", order.CustomerName, order.Quantity, order.ProductName, order.Address);
}
// ----------------------------------------------------------------------------------------------------------------
// Send a message received response to client.
string rmessage = IPCServer.ResponseMessage;
byte[] bResponse = Encoding.UTF8.GetBytes(rmessage);
int cbResponse = bResponse.Length, cbWritten;
if (!NativeMethod.WriteFile(
hNamedPipe, // Handle of the pipe
bResponse, // Message to be written
cbResponse, // Number of bytes to write
out cbWritten, // Number of bytes written
IntPtr.Zero // Not overlapped
))
{
throw new Win32Exception();
}
Console.WriteLine("[IPC Server Sent {0} bytes] Message: {1}", cbWritten, rmessage.Replace("\0", ""));
if (message == "KILL_SERVER")
{
KillServerRequested = true;
}
// ----------------------------------------------------------------------------------------------------------------
// Flush the pipe to allow the client to read the pipe's contents before disconnecting. Then disconnect the client's connection.
NativeMethod.FlushFileBuffers(hNamedPipe);
NativeMethod.DisconnectNamedPipe(hNamedPipe);
}
catch (Exception ex)
{
if (ex.Message != "Thread was being aborted")
{
Console.WriteLine("[IPC Server ERROR] - {0}", ex.Message);
}
hNamedPipe.Close();
hNamedPipe.Dispose();
NativeMethod.DisconnectNamedPipe(hNamedPipe);
}
finally
{
if (hNamedPipe != null)
{
hNamedPipe.Close();
hNamedPipe.Dispose();
NativeMethod.DisconnectNamedPipe(hNamedPipe);
}
}
}
}
if (KillServerRequested)
{
_ipcServer.StopServer();
}
}
public static byte[] CaptureRectangle(Rectangle r)
{
IntPtr wndHWND, wndHDC, capHDC, capBMP, prvHDC;
wndHWND = wndHDC = capHDC = capBMP = prvHDC = IntPtr.Zero;
byte[] buffer = null;
Point cursorPos = Point.Empty;
try
{
wndHWND = NativeMethod.GetDesktopWindow(); // window handle for desktop
int x, y, width, height;
x = r.X;
y = r.Y;
width = r.Width;
height = r.Height;
wndHDC = NativeMethod.GetDC(wndHWND); // get context for window
// create compatibile capture context and bitmap
capHDC = NativeMethod.CreateCompatibleDC(wndHDC);
capBMP = NativeMethod.CreateCompatibleBitmap(wndHDC, width, height);
// make sure bitmap non-zero
if (capBMP == IntPtr.Zero) // if no compatible bitmap
{
NativeMethod.ReleaseDC(wndHWND, wndHDC); // release window context
NativeMethod.DeleteDC(capHDC); // delete capture context
throw new Exception("Not create compatible bitmap.");
}
// select compatible bitmap in compatible context
// copy window context to compatible context
// select previous bitmap back into compatible context
prvHDC = (IntPtr)NativeMethod.SelectObject(capHDC, capBMP);
//NativeMethod.BitBlt(capHDC, 0, 0, width, height, wndHDC, x, y, RasterOp.SRCCOPY | RasterOp.CAPTUREBLT);
NativeMethod.BitBlt(capHDC, 0, 0, width, height, wndHDC, x, y, RasterOp.SRCCOPY);
NativeMethod.GetCursorPos(out cursorPos);
cursorPos.X -= r.Left;
cursorPos.Y -= r.Top;
// Draw the cursor
// Always wait cursor, why? So use arrow cursor forever.
//IntPtr hcur = GetCursor();
IntPtr hcur = NativeMethod.GetCurrentCursorHandle();
IconInfo iconInfo = new IconInfo();
int hr = NativeMethod.GetIconInfo(hcur, out iconInfo);
if (hr != 0)
{
cursorPos.X -= iconInfo.xHotspot;
cursorPos.Y -= iconInfo.yHotspot;
if (iconInfo.hbmMask != IntPtr.Zero)
{
NativeMethod.DeleteObject(iconInfo.hbmMask);
}
if (iconInfo.hbmColor != IntPtr.Zero)
{
NativeMethod.DeleteObject(iconInfo.hbmColor);
}
}
NativeMethod.DrawIcon(capHDC, cursorPos.X, cursorPos.Y, hcur);
NativeMethod.SelectObject(capHDC, prvHDC);
// create GDI+ bitmap for window
Bitmap bitmap = Image.FromHbitmap(capBMP);
Bitmap b = ImageUtil.AnyBitmapToBitmap24(bitmap);
bitmap.Dispose();
bitmap = b;
buffer = ImageUtil.BitmapToByte(bitmap);
//buffer = ImageUtil.BitmapToByteEx(bitmap);
bitmap.Dispose();
}
catch (Exception)
{
}
finally
{
// release window and capture resources
NativeMethod.DeleteObject(capBMP); // delete capture bitmap
NativeMethod.DeleteDC(capHDC); // delete capture context
NativeMethod.ReleaseDC(wndHWND, wndHDC); // release window context
}
return(buffer);
}
public void ReplaceMethodWithAttribute()
{
DefinedClass klass = new DefinedClass("Spam");
IFunction method = new NativeMethod(this.DummyMethod);
klass.SetMethod("foo", method);
klass.SetValue("foo", 1);
var result = klass.GetMethod("foo");
Assert.IsNull(result);
Assert.IsFalse(klass.HasMethod("foo"));
Assert.AreEqual(1, klass.GetValue("foo"));
Assert.IsTrue(klass.HasValue("foo"));
}
