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 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"); } } }
void f_sendData() { client.Execute(new byte[1] { 0xEC }); // Send the request and get a response try { for (int i = 0; i < 3; i++) { var response = client.Execute(Encoding.UTF8.GetBytes(Guid.NewGuid().ToString())); Console.WriteLine("Server response: {0}", Encoding.UTF8.GetString(response)); } //client.Execute(new byte[0]); //byte[] bytes = new byte[1 * 1024 * 1024]; //1mb in/out //new Random().NextBytes(bytes); //Stopwatch stopWatch = new Stopwatch(); //stopWatch.Start(); //for (int i = 0; i < 2; i++) // client.Execute(bytes); //stopWatch.Stop(); //TimeSpan ts = stopWatch.Elapsed; //string elapsedTime = String.Format("{0:00}:{1:00}:{2:00}.{3:00}", ts.Hours, ts.Minutes, ts.Seconds, ts.Milliseconds / 10); //Console.WriteLine(elapsedTime + " ncalrpc-large-timming"); } catch (RpcException rx) { if (rx.RpcError == RpcError.RPC_S_SERVER_UNAVAILABLE || rx.RpcError == RpcError.RPC_S_SERVER_TOO_BUSY) { //Use a wait handle if your on the same box... Console.Error.WriteLine("Waiting for server..."); Thread.Sleep(1000); } else { Console.Error.WriteLine(rx); } } catch (Exception ex) { Console.Error.WriteLine(ex); } }
private void button1_Click(object sender, EventArgs e) { subscribeEvent(); var request = new Rpc.Event.Protocol.Request() { value = ++number }; try { client.Execute(request.toByteArray()); } catch (RpcException ex) { if (RpcError.RPC_S_SERVER_UNAVAILABLE == ex.RpcError || RpcError.RPC_S_SERVER_TOO_BUSY == ex.RpcError) { textBox1.AppendText(String.Format("RPC Server Unavailable, Error={0}\r\n", ex)); } else { throw; } } }
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 TestClientOnLocalRpc() { 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) { 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.LRPC, client.ProtocolType); Assert.AreEqual(new byte[0], client.ClientAddress); Assert.AreEqual(System.Diagnostics.Process.GetCurrentProcess().Id, client.ClientPid.ToInt32()); Assert.AreEqual(System.Security.Principal.WindowsIdentity.GetCurrent().Name, 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.ncalrpc, null, "lrpctest")) { client.AuthenticateAs(RpcClientApi.Self); client.Execute(new byte[0]); } } }
static void Main(string[] args) { var iid = Guid.NewGuid(); using (var server = new RpcServerApi(iid, 1234, -1, true)) { server.AddProtocol(RpcProtseq.ncacn_np, @"\pipe\testpipename", 5); server.StartListening(); Console.WriteLine("Is listening"); server.OnExecute += delegate(IRpcClientInfo client, byte[] arg) { string tmp = ""; return(new byte[0]); }; using (RpcClientApi client = new RpcClientApi(iid, RpcProtseq.ncacn_np, null, @"\pipe\testpipename")) { // client.AuthenticateAs(RpcClientApi.Self); byte[] response = client.Execute(new byte[0]); } Console.ReadLine(); string s = ""; } }
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 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]); } } }
static void Main(string[] args) { RpcLibrary.Log.VerboseEnabled = true; // The client and server must agree on the interface id to use: var iid = new Guid("{f4db45dc-0dcb-4003-b680-56c40f6cb6a8}"); bool attempt = true; while (attempt) { attempt = false; // Open the connection based on the endpoint information and interface IID using (var client = new RpcClientApi(iid, RpcProtseq.ncalrpc, null, "1234")) //using (var client = new RpcClientApi(iid, RpcProtseq.ncacn_ip_tcp, null, @"18081")) { // Provide authentication information (not nessessary for LRPC) client.AuthenticateAs(RpcClientApi.Self); // Send the request and get a response try { var response = client.Execute(Encoding.UTF8.GetBytes(args.Length == 0 ? "Greetings" : args[0])); Console.WriteLine("Server response: {0}", Encoding.UTF8.GetString(response)); var task = client.ExecuteAsync(Encoding.UTF8.GetBytes(args.Length == 0 ? "Greetines" : args[0])). ContinueWith <String>(r => { return(Encoding.UTF8.GetString(r.Result.response)); }); task.Wait(); Console.WriteLine("Server response by async way: {0}", task.Result); } catch (RpcException rx) { if (rx.RpcError == RpcError.RPC_S_SERVER_UNAVAILABLE || rx.RpcError == RpcError.RPC_S_SERVER_TOO_BUSY) { //Use a wait handle if your on the same box... Console.Error.WriteLine("Waiting for server..."); System.Threading.Thread.Sleep(1000); attempt = true; } else { Console.Error.WriteLine(rx); } } catch (Exception ex) { Console.Error.WriteLine(ex); } } } // done... Console.WriteLine("Press [Enter] to exit..."); Console.ReadLine(); }
static byte[] Execute(RpcClientApi client, Stream stream) { byte[] buffer = new byte[stream.Length]; stream.Seek(0, SeekOrigin.Begin); stream.Read(buffer, 0, buffer.Length); return(client.Execute(buffer)); }
public override void Initialize(IEventSource eventSource) { if (eventSource == null) { return; } var p = Parameters.Split(';'); if (p.Length < 2) { throw new Exception("Requires at least pipeName and guid"); } var pipeName = p[0]; var iid = new Guid(p[1]); _client = new RpcClientApi(iid, RpcProtseq.ncacn_np, null, pipeName); messagePump = Task.Factory.StartNew(() => { try { BuildMessage msg; while (!stop || _messages.Count > 0) { if (_messages.TryDequeue(out msg)) { var result = _client.Execute(msg.ToByteArray()); if (result.Length > 0 && result[1] == 0x01) { // we've been asked to kill ourselves. stop = true; } continue; } Thread.Sleep(5); } } finally { stop = true; } }, TaskCreationOptions.LongRunning); eventSource.BuildFinished += eventSource_BuildFinished; eventSource.BuildStarted += eventSource_BuildStarted; eventSource.CustomEventRaised += eventSource_CustomEventRaised; eventSource.ErrorRaised += eventSource_ErrorRaised; eventSource.MessageRaised += eventSource_MessageRaised; eventSource.ProjectFinished += eventSource_ProjectFinished; eventSource.ProjectStarted += eventSource_ProjectStarted; //eventSource.StatusEventRaised += eventSource_StatusEventRaised; eventSource.TargetFinished += eventSource_TargetFinished; eventSource.TargetStarted += eventSource_TargetStarted; eventSource.TaskFinished += eventSource_TaskFinished; eventSource.TaskStarted += eventSource_TaskStarted; eventSource.WarningRaised += eventSource_WarningRaised; }
private void button1_Click(object sender, EventArgs e) { RpcLibrary.Log.VerboseEnabled = true; var iid = new Guid("{78323803-786f-4f7b-908d-b2e89c41d45f}"); var client = new RpcClientApi(iid, RpcProtseq.ncalrpc, null, "11111"); client.AuthenticateAs(RpcClientApi.Self); byte[] response = client.Execute(new byte[] { 1 }); }
static void Test() { //An id to identify the endpoint interface Guid iid = Guid.Parse("430436ab-8786-4b19-905f-2e5cc11edda2"); //For the client, we specify the protocol, endpoint, and interface id to connect using (RpcClientApi client = new RpcClientApi(iid, RpcProtseq.ncalrpc, null, "4747")) { client.AuthenticateAs(RpcClientApi.Self); byte[] response = client.Execute(new byte[0]); } }
private static void Main(string[] args) { // The client and server must agree on the interface id to use: var iid = new Guid("{1B617C4B-BF68-4B8C-AE2B-A77E6A3ECEC5}"); bool attempt = true; while (attempt) { attempt = false; // Open the connection based on the endpoint information and interface IID using (var client = new RpcClientApi(iid, RpcProtseq.ncalrpc, null, "RpcExampleClientServer")) //using (var client = new RpcClientApi(iid, RpcProtseq.ncacn_ip_tcp, null, @"18081")) { // Provide authentication information (not nessessary for LRPC) client.AuthenticateAs(RpcClientApi.Self); try { var response = client.Execute(Encoding.UTF8.GetBytes(args.Length == 0 ? "Greetings" : args[0])); Console.WriteLine("Server response: {0}", Encoding.UTF8.GetString(response)); } catch (RpcException rx) { if (rx.RpcError == RpcError.RPC_S_SERVER_UNAVAILABLE || rx.RpcError == RpcError.RPC_S_SERVER_TOO_BUSY) { // HINT: Use a wait handle if your on the same box... Console.Error.WriteLine("Waiting for server..."); System.Threading.Thread.Sleep(1000); attempt = true; } else { Console.Error.WriteLine(rx); } } catch (Exception ex) { Console.ForegroundColor = ConsoleColor.Yellow; Console.Error.WriteLine(ex); Console.ResetColor(); } } } Console.WriteLine("Client is done. Press [Enter] to exit."); Console.ReadLine(); }
public static AppMessage Send(AppMessage message) { try { Guid iid = new Guid(Constants.ACWatchDogInteropId); using (RpcClientApi client = new RpcClientApi(iid, RpcProtseq.ncalrpc, null, Constants.ACWatchDogInteropEndpoint)) //using (var client = new RpcClientApi(iid, RpcProtseq.ncacn_ip_tcp, null, @"18081")) { // Provide authentication information (not nessessary for LRPC) client.AuthenticateAs(RpcClientApi.Self); // Send the request and get a response return(AppMessage.FromBytes(client.Execute(message.ToBytes()))); } } catch (Exception) { return(null); } }
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)); } } } }
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]); } } }
public void TestClientCannotConnect() { using (RpcClientApi client = new RpcClientApi(Guid.NewGuid(), RpcProtseq.ncalrpc, null, "lrpc-endpoint-doesnt-exist")) client.Execute(new byte[0]); }
protected override Stream Execute(byte[] requestBytes) { return(new MemoryStream(_client.Execute(requestBytes), false)); }
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 IEnumerable <byte> Execute(byte[] input) { return(_client.Execute(input)); }
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 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 void TestClientCannotConnect() { using (RpcClientApi client = new RpcClientApi(Guid.NewGuid(), RpcProtseq.ncalrpc, null, "lrpc-endpoint-doesnt-exist")) client.Execute(new byte[0]); }
public void demo1() { Thread.Sleep(3000); // The client and server must agree on the interface id to use: var iid = new Guid("{1B617C4B-BF68-4B8C-AE2B-A77E6A3ECEC5}"); bool attempt = true; while (attempt) { attempt = false; // Open the connection based on the endpoint information and interface IID //using (var client = new RpcClientApi(iid, RpcProtseq.ncalrpc, null, "RpcExampleClientServer")) using (var client = new RpcClientApi(iid, RpcProtseq.ncacn_ip_tcp, null, @"18081")) { // Provide authentication information (not nessessary for LRPC) client.AuthenticateAs(RpcClientApi.Self); client.Execute(new byte[1] { 0xEC }); // Send the request and get a response try { for (int i = 0; i < 3; i++) { var response = client.Execute(Encoding.UTF8.GetBytes(Guid.NewGuid().ToString())); Console.WriteLine("Server response: {0}", Encoding.UTF8.GetString(response)); } //client.Execute(new byte[0]); //byte[] bytes = new byte[1 * 1024 * 1024]; //1mb in/out //new Random().NextBytes(bytes); //Stopwatch stopWatch = new Stopwatch(); //stopWatch.Start(); //for (int i = 0; i < 2; i++) // client.Execute(bytes); //stopWatch.Stop(); //TimeSpan ts = stopWatch.Elapsed; //string elapsedTime = String.Format("{0:00}:{1:00}:{2:00}.{3:00}", ts.Hours, ts.Minutes, ts.Seconds, ts.Milliseconds / 10); //Console.WriteLine(elapsedTime + " ncalrpc-large-timming"); } catch (RpcException rx) { if (rx.RpcError == RpcError.RPC_S_SERVER_UNAVAILABLE || rx.RpcError == RpcError.RPC_S_SERVER_TOO_BUSY) { //Use a wait handle if your on the same box... Console.Error.WriteLine("Waiting for server..."); System.Threading.Thread.Sleep(1000); attempt = true; } else { Console.Error.WriteLine(rx); } } catch (Exception ex) { Console.Error.WriteLine(ex); } } } }