public override void f_INIT()
{
Tracer.WriteLine("J{0}_{1} {2} -> INIT", this.f_getId(), this.Type, this.GetType().Name);
try
{
//// Add an endpoint so the client can connect, this is local-host only:
server.AddProtocol(RpcProtseq.ncalrpc, codeAPI, 100);
//// If you want to use TCP/IP uncomment the following, make sure your client authenticates or allowAnonTcp is true
server.AddProtocol(RpcProtseq.ncacn_np, @"\pipe\" + codeAPI, 25);
////// If you want to use TCP/IP uncomment the following, make sure your client authenticates or allowAnonTcp is true
server.AddProtocol(RpcProtseq.ncacn_ip_tcp, @"18081", 25);
// Add the types of authentication we will accept
server.AddAuthentication(RpcAuthentication.RPC_C_AUTHN_GSS_NEGOTIATE);
server.AddAuthentication(RpcAuthentication.RPC_C_AUTHN_WINNT);
server.AddAuthentication(RpcAuthentication.RPC_C_AUTHN_NONE);
// Subscribe the code to handle requests on this event:
server.OnExecute += f_server_OnExecute;
//_server.OnExecute += delegate (IRpcClientInfo client, byte[] bytes) { return new byte[0]; };
// Start Listening
server.StartListening();
}
catch (Exception ex)
{
Console.Error.WriteLine(ex);
}
}
public void active(string endpoint)
{
// The client and server must agree on the interface id to use:
var iid = new Guid("{78323803-786f-4f7b-908d-b2e89c41d45f}");
// Create the server instance, adjust the defaults to your needs.
source = new RpcServerApi(iid, 100, ushort.MaxValue, allowAnonTcp: false);
try
{
// Add an endpoint so the client can connect, this is local-host only:
source.AddProtocol(RpcProtseq.ncalrpc, endpoint, 100);
// If you want to use TCP/IP uncomment the following, make sure your client authenticates or allowAnonTcp is true
// server.AddProtocol(RpcProtseq.ncacn_ip_tcp, @"8080", 25);
// Add the types of authentication we will accept
source.AddAuthentication(RpcAuthentication.RPC_C_AUTHN_GSS_NEGOTIATE);
source.AddAuthentication(RpcAuthentication.RPC_C_AUTHN_WINNT);
source.AddAuthentication(RpcAuthentication.RPC_C_AUTHN_NONE);
source.OnExecute += executeDispatch;
source.OnExecuteAsync += executeAsyncDispatch;
source.StartListening();
}
catch (Exception e)
{
throw;
}
}
private static void Main()
{
// The client and server must agree on the interface id to use:
var iid = new Guid("{1B617C4B-BF68-4B8C-AE2B-A77E6A3ECEC5}");
// Create the server instance, adjust the defaults to your needs.
using (var server = new RpcServerApi(iid, 100, ushort.MaxValue, allowAnonTcp: false))
{
try
{
// Add an endpoint so the client can connect, this is local-host only:
server.AddProtocol(RpcProtseq.ncalrpc, "RpcExampleClientServer", 100);
// If you want to use TCP/IP uncomment the following, make sure your client authenticates or allowAnonTcp is true
// server.AddProtocol(RpcProtseq.ncacn_ip_tcp, @"8080", 25);
// Add the types of authentication we will accept
server.AddAuthentication(RpcAuthentication.RPC_C_AUTHN_GSS_NEGOTIATE);
server.AddAuthentication(RpcAuthentication.RPC_C_AUTHN_WINNT);
server.AddAuthentication(RpcAuthentication.RPC_C_AUTHN_NONE);
// Subscribe the code to handle requests on this event:
server.OnExecute += (IRpcClientInfo client, byte[] bytes) =>
{
//Impersonate the caller:
using (client.Impersonate())
{
var reqBody = Encoding.UTF8.GetString(bytes);
Console.WriteLine("Received '{0}' from {1}", reqBody, client.ClientUser.Name);
return(Encoding.UTF8.GetBytes(
string.Format(
"Hello {0}, I received your message '{1}'.",
client.ClientUser.Name,
reqBody
)
));
}
};
// Start Listening
server.StartListening();
}
catch (Exception ex)
{
Console.ForegroundColor = ConsoleColor.Yellow;
Console.Error.WriteLine(ex);
Console.ResetColor();
}
// Wait until you are done...
Console.WriteLine("Server is listening. Press [Enter] to exit.");
Console.ReadLine();
}
}
public void TestPerformanceOnLocalRpc()
{
Guid iid = Guid.NewGuid();
using (RpcServerApi server = new RpcServerApi(iid))
{
server.AddProtocol(RpcProtseq.ncalrpc, "lrpctest", 5);
server.AddAuthentication(RpcAuthentication.RPC_C_AUTHN_WINNT);
server.StartListening();
server.OnExecute +=
delegate(IRpcClientInfo client, byte[] arg)
{ return arg; };
using (RpcClientApi client = new RpcClientApi(iid, RpcProtseq.ncalrpc, null, "lrpctest"))
{
client.AuthenticateAs(null, RpcClientApi.Self, RpcProtectionLevel.RPC_C_PROTECT_LEVEL_PKT_PRIVACY, RpcAuthentication.RPC_C_AUTHN_WINNT);
client.Execute(new byte[0]);
byte[] bytes = new byte[512];
new Random().NextBytes(bytes);
Stopwatch timer = new Stopwatch();
timer.Start();
for (int i = 0; i < 10000; i++)
client.Execute(bytes);
timer.Stop();
Trace.WriteLine(timer.ElapsedMilliseconds.ToString(), "ncalrpc-timming");
}
}
}
public void TestClientAbandon()
{
var iid = Guid.NewGuid();
using (RpcServerApi server = new RpcServerApi(iid))
{
server.AddProtocol(RpcProtseq.ncalrpc, "lrpctest", 5);
server.AddAuthentication(RpcAuthentication.RPC_C_AUTHN_WINNT);
server.StartListening();
server.OnExecute +=
delegate(IRpcClientInfo client, byte[] arg)
{ return(arg); };
{
RpcClientApi client = new RpcClientApi(iid, RpcProtseq.ncalrpc, null, "lrpctest");
client.AuthenticateAs(null, RpcClientApi.Self, RpcProtectionLevel.RPC_C_PROTECT_LEVEL_PKT_PRIVACY, RpcAuthentication.RPC_C_AUTHN_WINNT);
client.Execute(new byte[0]);
client = null;
}
GC.Collect(0, GCCollectionMode.Forced);
GC.WaitForPendingFinalizers();
server.StopListening();
}
}
public void TestUnregisterListener()
{
Guid iid = Guid.NewGuid();
using (RpcServerApi server = new RpcServerApi(iid))
{
server.AddProtocol(RpcProtseq.ncalrpc, "lrpctest", 5);
server.AddAuthentication(RpcAuthentication.RPC_C_AUTHN_WINNT);
server.StartListening();
RpcServerApi.RpcExecuteHandler handler =
delegate(IRpcClientInfo client, byte[] arg)
{ return arg; };
using (RpcClientApi client = new RpcClientApi(iid, RpcProtseq.ncalrpc, null, "lrpctest"))
{
client.AuthenticateAs(null, RpcClientApi.Self, RpcProtectionLevel.RPC_C_PROTECT_LEVEL_PKT_PRIVACY, RpcAuthentication.RPC_C_AUTHN_WINNT);
server.OnExecute += handler;
client.Execute(new byte[0]);
server.OnExecute -= handler;
try
{
client.Execute(new byte[0]);
Assert.Fail();
}
catch (RpcException)
{ }
}
}
}
public void TestPerformanceOnLocalRpc()
{
Guid iid = Guid.NewGuid();
using (RpcServerApi server = new RpcServerApi(iid))
{
server.AddProtocol(RpcProtseq.ncalrpc, "lrpctest", 5);
server.AddAuthentication(RpcAuthentication.RPC_C_AUTHN_WINNT);
server.StartListening();
server.OnExecute +=
delegate(IRpcClientInfo client, byte[] arg)
{ return(arg); };
using (RpcClientApi client = new RpcClientApi(iid, RpcProtseq.ncalrpc, null, "lrpctest"))
{
client.AuthenticateAs(null, RpcClientApi.Self, RpcProtectionLevel.RPC_C_PROTECT_LEVEL_PKT_PRIVACY, RpcAuthentication.RPC_C_AUTHN_WINNT);
client.Execute(new byte[0]);
byte[] bytes = new byte[512];
new Random().NextBytes(bytes);
Stopwatch timer = new Stopwatch();
timer.Start();
for (int i = 0; i < 10000; i++)
{
client.Execute(bytes);
}
timer.Stop();
Trace.WriteLine(timer.ElapsedMilliseconds.ToString(), "ncalrpc-timming");
}
}
}
public void TestNestedClientImpersonate()
{
Guid iid = Guid.NewGuid();
using (RpcServerApi server = new RpcServerApi(iid))
{
server.AddProtocol(RpcProtseq.ncacn_np, @"\pipe\testpipename", 5);
server.AddAuthentication(RpcAuthentication.RPC_C_AUTHN_WINNT);
server.StartListening();
server.OnExecute +=
delegate(IRpcClientInfo client, byte[] arg)
{
Assert.AreEqual(false, client.IsImpersonating);
using (client.Impersonate())
{
Assert.AreEqual(true, client.IsImpersonating);
using (client.Impersonate())
Assert.AreEqual(true, client.IsImpersonating);
//does not dispose, we are still impersonating
Assert.AreEqual(true, client.IsImpersonating);
}
Assert.AreEqual(false, client.IsImpersonating);
return(arg);
};
using (RpcClientApi client = new RpcClientApi(iid, RpcProtseq.ncacn_np, null, @"\pipe\testpipename"))
{
client.AuthenticateAs(RpcClientApi.Self);
client.Execute(new byte[0]);
}
}
}
public void TestUnregisterListener()
{
Guid iid = Guid.NewGuid();
using (RpcServerApi server = new RpcServerApi(iid))
{
server.AddProtocol(RpcProtseq.ncalrpc, "lrpctest", 5);
server.AddAuthentication(RpcAuthentication.RPC_C_AUTHN_WINNT);
server.StartListening();
RpcServerApi.RpcExecuteHandler handler =
delegate(IRpcClientInfo client, byte[] arg)
{ return(arg); };
using (RpcClientApi client = new RpcClientApi(iid, RpcProtseq.ncalrpc, null, "lrpctest"))
{
client.AuthenticateAs(null, RpcClientApi.Self, RpcProtectionLevel.RPC_C_PROTECT_LEVEL_PKT_PRIVACY, RpcAuthentication.RPC_C_AUTHN_WINNT);
server.OnExecute += handler;
client.Execute(new byte[0]);
server.OnExecute -= handler;
try
{
client.Execute(new byte[0]);
Assert.Fail();
}
catch (RpcException)
{ }
}
}
}
public void TestClientAbandon()
{
Guid iid = Guid.NewGuid();
using (RpcServerApi server = new RpcServerApi(iid))
{
server.AddProtocol(RpcProtseq.ncalrpc, "lrpctest", 5);
server.AddAuthentication(RpcAuthentication.RPC_C_AUTHN_WINNT);
server.StartListening();
server.OnExecute +=
delegate(IRpcClientInfo client, byte[] arg)
{ return arg; };
{
RpcClientApi client = new RpcClientApi(iid, RpcProtseq.ncalrpc, null, "lrpctest");
client.AuthenticateAs(null, RpcClientApi.Self, RpcProtectionLevel.RPC_C_PROTECT_LEVEL_PKT_PRIVACY, RpcAuthentication.RPC_C_AUTHN_WINNT);
client.Execute(new byte[0]);
client = null;
}
GC.Collect(0, GCCollectionMode.Forced);
GC.WaitForPendingFinalizers();
server.StopListening();
}
}
public void TestClientOnNamedPipe()
{
Guid iid = Guid.NewGuid();
using (RpcServerApi server = new RpcServerApi(iid))
{
server.AddProtocol(RpcProtseq.ncacn_np, @"\pipe\testpipename", 5);
server.AddAuthentication(RpcAuthentication.RPC_C_AUTHN_WINNT);
server.StartListening();
server.OnExecute +=
delegate(IRpcClientInfo client, byte[] arg)
{
Assert.AreEqual(0, arg.Length);
Assert.AreEqual(RpcAuthentication.RPC_C_AUTHN_WINNT, client.AuthenticationLevel);
Assert.AreEqual(RpcProtectionLevel.RPC_C_PROTECT_LEVEL_PKT_PRIVACY, client.ProtectionLevel);
Assert.AreEqual(RpcProtoseqType.NMP, client.ProtocolType);
Assert.AreEqual(new byte[0], client.ClientAddress);
Assert.AreEqual(0, client.ClientPid.ToInt32());
Assert.AreEqual(String.Empty, client.ClientPrincipalName);
Assert.AreEqual(System.Security.Principal.WindowsIdentity.GetCurrent().Name, client.ClientUser.Name);
Assert.AreEqual(true, client.IsClientLocal);
Assert.AreEqual(true, client.IsAuthenticated);
Assert.AreEqual(false, client.IsImpersonating);
using (client.Impersonate())
Assert.AreEqual(true, client.IsImpersonating);
Assert.AreEqual(false, client.IsImpersonating);
return arg;
};
using (RpcClientApi client = new RpcClientApi(iid, RpcProtseq.ncacn_np, null, @"\pipe\testpipename"))
{
client.AuthenticateAs(RpcClientApi.Self);
client.Execute(new byte[0]);
}
}
}
private void ServerLoop()
{
Guid iid = new Guid(Constants.ACWatchDogInteropId);
using (RpcServerApi server = new RpcServerApi(iid, 100, ushort.MaxValue, allowAnonTcp: false))
{
// Add an endpoint so the client can connect, this is local-host only:
server.AddProtocol(RpcProtseq.ncalrpc, Constants.ACWatchDogInteropEndpoint, 100);
// Add the types of authentication we will accept
server.AddAuthentication(RpcAuthentication.RPC_C_AUTHN_GSS_NEGOTIATE);
// Subscribe the code to handle requests on this event:
server.OnExecute += Server_OnExecute;
// Start Listening
server.StartListening();
@continue = true;
while (@continue)
{
Thread.Sleep(100);
}
server.StopListening();
}
}
public void TestClientOnAnonymousPipe()
{
Guid iid = Guid.NewGuid();
using (RpcServerApi server = new RpcServerApi(iid))
{
server.AddProtocol(RpcProtseq.ncacn_np, @"\pipe\testpipename", 5);
server.AddAuthentication(RpcAuthentication.RPC_C_AUTHN_NONE);
server.StartListening();
server.OnExecute +=
delegate(IRpcClientInfo client, byte[] arg)
{
Assert.AreEqual(0, arg.Length);
Assert.AreEqual(RpcAuthentication.RPC_C_AUTHN_NONE, client.AuthenticationLevel);
Assert.AreEqual(RpcProtectionLevel.RPC_C_PROTECT_LEVEL_NONE, client.ProtectionLevel);
Assert.AreEqual(RpcProtoseqType.NMP, client.ProtocolType);
Assert.AreEqual(new byte[0], client.ClientAddress);
Assert.AreEqual(0, client.ClientPid.ToInt32());
Assert.AreEqual(null, client.ClientPrincipalName);
Assert.AreEqual(System.Security.Principal.WindowsIdentity.GetAnonymous().Name, client.ClientUser.Name);
Assert.AreEqual(true, client.IsClientLocal);
Assert.AreEqual(false, client.IsAuthenticated);
Assert.AreEqual(false, client.IsImpersonating);
bool failed = false;
try { client.Impersonate().Dispose(); }
catch (UnauthorizedAccessException) { failed = true; }
Assert.AreEqual(true, failed);
return(arg);
};
using (RpcClientApi client = new RpcClientApi(iid, RpcProtseq.ncacn_np, null, @"\pipe\testpipename"))
{
client.AuthenticateAs(RpcClientApi.Anonymous);
client.Execute(new byte[0]);
}
}
}
static void ReversePingTest(RpcProtseq protocol, string[] hostNames, string endpoint, RpcAuthentication auth)
{
Guid iid = Guid.NewGuid();
using (RpcServerApi server = new RpcServerApi(iid))
{
server.OnExecute +=
delegate(IRpcClientInfo client, byte[] arg)
{
Array.Reverse(arg);
return(arg);
};
server.AddProtocol(protocol, endpoint, 5);
server.AddAuthentication(auth);
server.StartListening();
byte[] input = Encoding.ASCII.GetBytes("abc");
byte[] expect = Encoding.ASCII.GetBytes("cba");
foreach (string hostName in hostNames)
{
using (RpcClientApi client = new RpcClientApi(iid, protocol, hostName, endpoint))
{
client.AuthenticateAs(null, auth == RpcAuthentication.RPC_C_AUTHN_NONE
? RpcClientApi.Anonymous
: RpcClientApi.Self,
auth == RpcAuthentication.RPC_C_AUTHN_NONE
? RpcProtectionLevel.RPC_C_PROTECT_LEVEL_NONE
: RpcProtectionLevel.RPC_C_PROTECT_LEVEL_PKT_PRIVACY,
auth);
Assert.AreEqual(expect, client.Execute(input));
}
}
}
}
static void ReversePingTest(RpcProtseq protocol, string[] hostNames, string endpoint, RpcAuthentication auth)
{
Guid iid = Guid.NewGuid();
using (RpcServerApi server = new RpcServerApi(iid))
{
server.OnExecute +=
delegate(IRpcClientInfo client, byte[] arg)
{
Array.Reverse(arg);
return arg;
};
server.AddProtocol(protocol, endpoint, 5);
server.AddAuthentication(auth);
server.StartListening();
byte[] input = Encoding.ASCII.GetBytes("abc");
byte[] expect = Encoding.ASCII.GetBytes("cba");
foreach (string hostName in hostNames)
{
using (RpcClientApi client = new RpcClientApi(iid, protocol, hostName, endpoint))
{
client.AuthenticateAs(null, auth == RpcAuthentication.RPC_C_AUTHN_NONE
? RpcClientApi.Anonymous
: RpcClientApi.Self,
auth == RpcAuthentication.RPC_C_AUTHN_NONE
? RpcProtectionLevel.RPC_C_PROTECT_LEVEL_NONE
: RpcProtectionLevel.RPC_C_PROTECT_LEVEL_PKT_PRIVACY,
auth);
Assert.AreEqual(expect, client.Execute(input));
}
}
}
}
public void TestClientOnNamedPipe()
{
Guid iid = Guid.NewGuid();
using (RpcServerApi server = new RpcServerApi(iid))
{
server.AddProtocol(RpcProtseq.ncacn_np, @"\pipe\testpipename", 5);
server.AddAuthentication(RpcAuthentication.RPC_C_AUTHN_WINNT);
server.StartListening();
server.OnExecute +=
delegate(IRpcClientInfo client, byte[] arg)
{
Assert.AreEqual(0, arg.Length);
Assert.AreEqual(RpcAuthentication.RPC_C_AUTHN_WINNT, client.AuthenticationLevel);
Assert.AreEqual(RpcProtectionLevel.RPC_C_PROTECT_LEVEL_PKT_PRIVACY, client.ProtectionLevel);
Assert.AreEqual(RpcProtoseqType.NMP, client.ProtocolType);
Assert.AreEqual(new byte[0], client.ClientAddress);
Assert.AreEqual(0, client.ClientPid.ToInt32());
Assert.AreEqual(String.Empty, client.ClientPrincipalName);
Assert.AreEqual(System.Security.Principal.WindowsIdentity.GetCurrent().Name, client.ClientUser.Name);
Assert.AreEqual(true, client.IsClientLocal);
Assert.AreEqual(true, client.IsAuthenticated);
Assert.AreEqual(false, client.IsImpersonating);
using (client.Impersonate())
Assert.AreEqual(true, client.IsImpersonating);
Assert.AreEqual(false, client.IsImpersonating);
return(arg);
};
using (RpcClientApi client = new RpcClientApi(iid, RpcProtseq.ncacn_np, null, @"\pipe\testpipename"))
{
client.AuthenticateAs(RpcClientApi.Self);
client.Execute(new byte[0]);
}
}
}
static void Main(string[] args)
{
// The client and server must agree on the interface id to use:
var iid = new Guid("{f4db45dc-0dcb-4003-b680-56c40f6cb6a8}");
// Create the server instance, adjust the defaults to your needs.
using (var server = new RpcServerApi(iid, 100, ushort.MaxValue, allowAnonTcp: false))
{
try
{
// Add an endpoint so the client can connect, this is local-host only:
server.AddProtocol(RpcProtseq.ncalrpc, "1234", 100);
// If you want to use TCP/IP uncomment the following, make sure your client authenticates or allowAnonTcp is true
// server.AddProtocol(RpcProtseq.ncacn_ip_tcp, @"8080", 25);
// Add the types of authentication we will accept
server.AddAuthentication(RpcAuthentication.RPC_C_AUTHN_GSS_NEGOTIATE);
server.AddAuthentication(RpcAuthentication.RPC_C_AUTHN_WINNT);
server.AddAuthentication(RpcAuthentication.RPC_C_AUTHN_NONE);
// Subscribe the code to handle requests on this event:
server.OnExecute +=
delegate(IRpcClientInfo client, byte[] bytes)
{
//Impersonate the caller:
using (client.Impersonate())
{
var reqBody = Encoding.UTF8.GetString(bytes);
Console.WriteLine("Received '{0}' from {1}", reqBody, client.ClientUser.Name);
return(Encoding.UTF8.GetBytes(
String.Format(
"Hello {0}, I received your message '{1}'.",
client.ClientUser.Name,
reqBody
)
));
}
};
server.OnExecuteAsync +=
delegate(IRpcClientInfo client, IntPtr pAsyncState, byte[] bytes)
{
//Impersonate the caller:
using (client.Impersonate())
{
var reqBody = Encoding.UTF8.GetString(bytes);
Console.Write("Received (async) '{0}' from {1} ...", reqBody, client.ClientUser.Name);
Thread.Sleep(3 * 1000);
Console.WriteLine("Wake up!");
return(Encoding.UTF8.GetBytes(
String.Format(
"Hello {0}, I received your message '{1}'.",
client.ClientUser.Name,
reqBody
)
));
}
};
// Start Listening
server.StartListening();
}
catch (Exception ex)
{
Console.Error.WriteLine(ex);
}
// Wait until you are done...
Console.WriteLine("Press [Enter] to exit...");
Console.ReadLine();
}
}
static void Main(string[] args)
{
// The client and server must agree on the interface id to use:
//var iid = new Guid("{0092F74D-0EA7-4667-A89F-A04C64244031}");
var iid = new Guid("{78323803-786f-4f7b-908d-b2e89c41d45f}");
// Create the server instance, adjust the defaults to your needs.
using (var server = new RpcServerApi(iid, 100, ushort.MaxValue, allowAnonTcp: false))
{
try
{
// Add an endpoint so the client can connect, this is local-host only:
server.AddProtocol(RpcProtseq.ncalrpc, "12345", 100);
// If you want to use TCP/IP uncomment the following, make sure your client authenticates or allowAnonTcp is true
// server.AddProtocol(RpcProtseq.ncacn_ip_tcp, @"8080", 25);
// Add the types of authentication we will accept
server.AddAuthentication(RpcAuthentication.RPC_C_AUTHN_GSS_NEGOTIATE);
server.AddAuthentication(RpcAuthentication.RPC_C_AUTHN_WINNT);
server.AddAuthentication(RpcAuthentication.RPC_C_AUTHN_NONE);
// Subscribe the code to handle requests on this event:
server.OnExecute +=
delegate(IRpcClientInfo client, byte[] bytes)
{
//Impersonate the caller:
using (client.Impersonate())
{
Console.WriteLine("Received'{0}' from {1} ...", bytes.Length, client.ClientUser.Name);
byte[] response;
var memoryStream = new MemoryStream(bytes);
RpcProto.Request message;
try
{
message = ProtoBuf.Serializer.Deserialize <RpcProto.Request>(memoryStream);
}
catch (Exception e)
{
Console.WriteLine(e);
throw e;
}
switch (message.method)
{
case RpcProto.RequestType.GetCustomers:
var r = message.post;
Console.WriteLine("Received '{0}'", r);
var rpn = new RpcProto.GetCustomerResponse()
{
result = 0,
};
response = toBytes(rpn);
break;
default:
response = new byte[0];
break;
}
return(response);
}
};
server.OnExecuteAsync +=
delegate(IRpcClientInfo client, IntPtr pAsyncState, byte[] bytes)
{
//Impersonate the caller:
using (client.Impersonate())
{
Console.WriteLine("Received'{0}' from {1} ...", bytes.Length, client.ClientUser.Name);
byte[] response;
var memoryStream = new MemoryStream(bytes);
RpcProto.Request message;
try
{
message = ProtoBuf.Serializer.Deserialize <RpcProto.Request>(memoryStream);
}
catch (Exception e)
{
Console.WriteLine(e);
throw e;
}
switch (message.method)
{
case RpcProto.RequestType.PostCustomer:
var r1 = message.post;
Console.WriteLine("Received '{0}'", r1);
var rpn1 = new RpcProto.PostCustomerResponse()
{
result = 0
};
response = toBytes(rpn1);
break;
case RpcProto.RequestType.DeleteCustomer: { }
var r2 = message.delete;
Console.WriteLine("Received '{0}'", r2);
var rpn2 = new RpcProto.DeleteCustomerResponse()
{
result = 0
};
response = toBytes(rpn2);
break;
default:
response = new byte[0];
break;
}
return(response);
}
};
// Start Listening
server.StartListening();
}
catch (Exception ex)
{
Console.Error.WriteLine(ex);
}
// Wait until you are done...
Console.WriteLine("Press [Enter] to exit...");
Console.ReadLine();
}
}
public void TestClientOnAnonymousPipe()
{
Guid iid = Guid.NewGuid();
using (RpcServerApi server = new RpcServerApi(iid))
{
server.AddProtocol(RpcProtseq.ncacn_np, @"\pipe\testpipename", 5);
server.AddAuthentication(RpcAuthentication.RPC_C_AUTHN_NONE);
server.StartListening();
server.OnExecute +=
delegate(IRpcClientInfo client, byte[] arg)
{
Assert.AreEqual(0, arg.Length);
Assert.AreEqual(RpcAuthentication.RPC_C_AUTHN_NONE, client.AuthenticationLevel);
Assert.AreEqual(RpcProtectionLevel.RPC_C_PROTECT_LEVEL_NONE, client.ProtectionLevel);
Assert.AreEqual(RpcProtoseqType.NMP, client.ProtocolType);
Assert.AreEqual(new byte[0], client.ClientAddress);
Assert.AreEqual(0, client.ClientPid.ToInt32());
Assert.AreEqual(null, client.ClientPrincipalName);
Assert.AreEqual(System.Security.Principal.WindowsIdentity.GetAnonymous().Name, client.ClientUser.Name);
Assert.AreEqual(true, client.IsClientLocal);
Assert.AreEqual(false, client.IsAuthenticated);
Assert.AreEqual(false, client.IsImpersonating);
bool failed = false;
try { client.Impersonate().Dispose(); }
catch (UnauthorizedAccessException) { failed = true; }
Assert.AreEqual(true, failed);
return arg;
};
using (RpcClientApi client = new RpcClientApi(iid, RpcProtseq.ncacn_np, null, @"\pipe\testpipename"))
{
client.AuthenticateAs(RpcClientApi.Anonymous);
client.Execute(new byte[0]);
}
}
}
public Win32RpcServer AddAuthentication(RpcAuthentication auth)
{
_server.AddAuthentication(auth, ServerPrincipalName);
return(this);
}
public void TestNestedClientImpersonate()
{
Guid iid = Guid.NewGuid();
using (RpcServerApi server = new RpcServerApi(iid))
{
server.AddProtocol(RpcProtseq.ncacn_np, @"\pipe\testpipename", 5);
server.AddAuthentication(RpcAuthentication.RPC_C_AUTHN_WINNT);
server.StartListening();
server.OnExecute +=
delegate(IRpcClientInfo client, byte[] arg)
{
Assert.AreEqual(false, client.IsImpersonating);
using (client.Impersonate())
{
Assert.AreEqual(true, client.IsImpersonating);
using (client.Impersonate())
Assert.AreEqual(true, client.IsImpersonating);
//does not dispose, we are still impersonating
Assert.AreEqual(true, client.IsImpersonating);
}
Assert.AreEqual(false, client.IsImpersonating);
return arg;
};
using (RpcClientApi client = new RpcClientApi(iid, RpcProtseq.ncacn_np, null, @"\pipe\testpipename"))
{
client.AuthenticateAs(RpcClientApi.Self);
client.Execute(new byte[0]);
}
}
}
