+ public class ExtendedServiceDeviceTest
+ {
+ ExtendedServiceDevice myDevice;
+
+ //The user should start up the extended service as soon as the module initialization is done.
+ public void StartUpExtendedService(uint paramID)
+ {
+ //Instantiate the extended service device with the proper IP ID.
+ myDevice = new ExtendedServiceDevice(paramID);
+ //Subscribe to the receive event handler.
+ myDevice.ReceiveEvent += ReceiveEventHandler;
+ //Connect to a supported service.
+ myDevice.Connect(eCrestronExtendedService.CRPCPacketToUserModule);
+ }
+ //Once receive device online event, the user should start the next phase operation like
+ //CRPC registration..
+ public void SendCRPCRegistrationPacketToDevice()
+ {
+ string CRPCPacketString = "This is a CRPC registration packet in required format";
+ uint channelNoToUse = 1;
+
+ if(myDevice.IsOnline)
+ myDevice.SendString(channelNoToUse,CRPCPacketString,CrestronStringEncoding.eEncodingUTF16);
+ }
+ //Receive Event Handler
+ void ReceiveEventHandler(object sender, ExtendedServiceEventArgs args)
+ {
+ switch (args.Type)
+ {
+ case eExtendedServiceEventType.Online:
+ ErrorLog.Notice(String.Format("Extended service device online status {0}.\r\n",myDevice.IsOnline));
+ break;
+ case eExtendedServiceEventType.String:
+ ErrorLog.Notice(String.Format("Ex-service device gets incoming string in format {0}: {1}.\r\n", args.IncomingStringEncoding.ToString(),args.StringValue));
+ break;
+ default:
+ break;
+ }
+ }
+ }
+
+
+ // Send a DELETE request to the specified URL
+ public void SendDelete(string urlString)
+ {
+ try
+ {
+ HttpClient client = new HttpClient();
+ HttpClientRequest req = new HttpClientRequest();
+ UrlParser url = new UrlParser(urlString);
+ req.Url = url;
+ req.RequestType = RequestType.Delete;
+
+ HttpClientResponse res = client.Dispatch(req);
+
+ if (res.Code == 204) // Expecting a "Not Found" response to show that the DELETE succeeded
+ {
+ CrestronConsole.PrintLine("DELETE request succeeded");
+ }
+ else
+ {
+ CrestronConsole.PrintLine("DELETE request returned unexpected response code: {0}", res.Code);
+ }
+ res.Dispose();
+ client.Dispose();
+ }
+ catch (Exception e)
+ {
+ CrestronConsole.PrintLine("Error in SendDelete(): " + e);
+ }
+ }
+
+
+ // Example Response Handler CallBack
+ private static void GetResponseCallback(HttpClientRequest asynchronousResult,HTTP_CALLBACK_ERROR error, object status)
+ {
+ StreamReader streamRead;
+ string responseString;
+ Stream streamResponse;
+ HttpClientRequest request = asynchronousResult;
+
+ // End the response
+ HttpClientResponse response = request.ThisClient.EndGetResponseStream(request);
+ if (response.HasContentLength)
+ {
+ streamResponse = response.ContentStream;
+ streamRead = new StreamReader(streamResponse);
+ responseString = streamRead.ReadToEnd();
+ Console.WriteLine(responseString);
+ // Close the stream object
+ streamResponse.Close();
+ streamRead.Close();
+ }
+ // Release the HttpResponse
+ response.Dispose();
+ }
+
+ +
+ G(x) = x^4 + (a+1/a)x^3 + ax^2 + (a+1/a)x + 1 ++ where a = primitive root of field generator 0x14D + +
+ // Initialize the critical section
+ CCriticalSection tempCS = new CCriticalSection();
+ // Enter the critical section
+ tempCs.Enter();
+ // Do anything critical in here
+ // ..
+ // ..
+ // Leave the critical section
+ tempCs.Leave();
+
+
+ using System;
+ using System.Text; // for ASCIIEncoding
+ using Crestron.SimplSharp; // for CrestronConsole
+ using Crestron.SimplSharp.CrestronSockets;
+
+ /* ...Startup code for a SecureTCPServer... */
+
+ int port = 8000;
+ int bufsize = 100;
+ int max_connections = 10;
+
+ SecureTCPServer server = new SecureTCPServer(port, bufsize, EthernetAdapterType.EthernetUnknownAdapter, max_connections);
+ server.SocketStatusChange += new SecureTCPServerSocketStatusChangeEventHandler(ServerSocketStatusChanged);
+
+ // ServerConnectedCallback will get invoked once a client either
+ // connects successfully or if the connection encounters an error
+ SocketErrorCodes err = server.WaitForConnectionAsync(ServerConnectedCallback);
+ CrestronConsole.PrintLine("WaitForConnectionAsync returned: " + err);
+
+ /* ...Callback methods... */
+
+ public void ServerSocketStatusChanged(SecureTCPServer server, uint clientIndex, SocketStatus status)
+ {
+ // A single SecureTCPServer may be handling many different sockets (up to server.MaxNumberOfClientSupported) at once.
+ // This event handler is called whenever the status of any one of these sockets changes. clientIndex
+ // uniquely identifies which socket has received a new status.
+
+ if (status == SocketStatus.SOCKET_STATUS_CONNECTED)
+ {
+ CrestronConsole.PrintLine("ServerSocketStatusChanged: Client " + clientIndex + " connected.");
+ }
+ else
+ {
+ CrestronConsole.PrintLine("ServerSocketStatusChange for client " + clientIndex + ": " + status + ".");
+ }
+ }
+
+ public void ServerConnectedCallback(SecureTCPServer server, uint clientIndex)
+ {
+ if (clientIndex != 0)
+ {
+ CrestronConsole.PrintLine("Server listening on port " + server.PortNumber + " has connected with a client (client #"+ clientIndex + ")");
+ server.ReceiveDataAsync(clientIndex, ServerDataReceivedCallback);
+ if (server.MaxNumberOfClientSupported == server.NumberOfClientsConnected)
+ {
+ CrestronConsole.PrintLine("Client limit reached.");
+ // This call to Stop() causes the server.State flag, SERVER_NOT_LISTENING, to be set
+ server.Stop();
+ CrestronConsole.PrintLine("After calling server.Stop(), the server state is: " + server.State);
+ }
+ // If the client limit is reached, WaitForConnectionAsync will return SOCKET_MAX_CONNECTIONS_REACHED
+ // and the ServerConnectedCallback will not be registered. Otherwise, the call to WaitForConnectionAsync
+ // causes the server to keep listening for more clients.
+ SocketErrorCodes err = server.WaitForConnectionAsync(ServerConnectedCallback);
+ CrestronConsole.PrintLine("WaitForConnectionAsync returned: " + err);
+ }
+ // A clientIndex of 0 could mean that the server is no longer listening, or that the TLS handshake failed when a client tried to connect.
+ // In the case of a TLS handshake failure, wait for another connection so that other clients can still connect
+ else
+ {
+ CrestronConsole.Print("Error in ServerConnectedCallback: ");
+ if ((server.State & ServerState.SERVER_NOT_LISTENING) > 0)
+ {
+ CrestronConsole.PrintLine("Server is no longer listening.");
+ }
+ else
+ {
+ CrestronConsole.PrintLine("Unable to make connection with client.");
+ // This connection failed, but keep waiting for another
+ server.WaitForConnectionAsync(ServerConnectedCallback);
+ }
+ }
+ }
+
+ public void ServerDataReceivedCallback(SecureTCPServer server, uint clientIndex, int bytesReceived)
+ {
+ if (bytesReceived <= 0) {
+ CrestronConsole.PrintLine("ServerDataReceivedCallback error: server's connection with client " + clientIndex + " has been closed.");
+ server.Disconnect(clientIndex);
+ // A connection has closed, so another client may connect if the server stopped listening
+ // due to the maximum number of clients connecting
+ if ((server.State & ServerState.SERVER_NOT_LISTENING) > 0)
+ server.WaitForConnectionAsync(ServerConnectedCallback);
+ }
+ else {
+ CrestronConsole.PrintLine("\n------ incoming message -----------");
+ byte[] recvd_bytes = new byte[bytesReceived];
+
+ // Copy the received bytes into a local buffer so that they can be echoed back.
+ // Do not pass the reference to the incoming data buffer itself to the SendDataAsync method
+ Array.Copy(server.GetIncomingDataBufferForSpecificClient(clientIndex), recvd_bytes, bytesReceived);
+
+ // The server in this example expects ASCII text from the client, but any other encoding is possible
+ string recvd_msg = ASCIIEncoding.ASCII.GetString(recvd_bytes, 0, bytesReceived);
+ CrestronConsole.PrintLine("Client " + clientIndex + " says: " + recvd_msg + "\r\nEchoing back to client " + clientIndex + "...");
+
+ // echo the received message back to the client who sent it
+ server.SendDataAsync(clientIndex, recvd_bytes, recvd_bytes.Length, ServerDataSentCallback);
+
+ // Begin waiting for another message from that same client
+ server.ReceiveDataAsync(clientIndex, ServerDataReceivedCallback);
+
+ CrestronConsole.PrintLine("---------- end of message ----------");
+ }
+ }
+
+ public void ServerDataSentCallback(SecureTCPServer server, uint clientIndex, int bytesSent)
+ {
+ if (bytesSent <= 0)
+ {
+ CrestronConsole.PrintLine("Error sending message. Connection has been closed");
+ }
+ else
+ {
+ CrestronConsole.PrintLine("Echoed message to client " + clientIndex + " (" + bytesSent + " byte(s))");
+ }
+ }
+
+
+ using System;
+ using System.Text; // for ASCIIEncoding
+ using Crestron.SimplSharp; // for CrestronConsole
+ using Crestron.SimplSharp.CrestronSockets; // for SecureTCPClient
+
+ /* ...Startup code for a SecureTCPClient... */
+
+ SecureTCPClient client = new SecureTCPClient("localhost", 8000, 100); // provide hostname, port, and size of the incoming data buffer
+ client.SocketStatusChange += new SecureTCPClientSocketStatusChangeEventHandler(clientSocketStatusChange);
+
+ SocketErrorCodes err;
+
+ ErrorLog.Notice("Trying to connect with server...");
+ try
+ {
+ // clientConnectCallback gets invoked once client either
+ // connects successfully or encounters an error
+ err = client.ConnectToServerAsync(clientConnectCallback);
+ CrestronConsole.PrintLine("ConnectToServerAsync returned: " + err);
+ }
+ catch (Exception e)
+ {
+ CrestronConsole.PrintLine("Error connecting to server: " + e.Message);
+ }
+
+ /* ...Callback methods... */
+
+ public void clientSocketStatusChange(SecureTCPClient client, SocketStatus clientSocketStatus)
+ {
+ CrestronConsole.PrintLine("Client Socket Status Change - Socket State is now " + clientSocketStatus);
+ }
+
+ public void clientConnectCallback(SecureTCPClient client)
+ {
+ CrestronConsole.PrintLine("clientConnectCallback: ClientStatus is: " + client.ClientStatus);
+ if (client.ClientStatus == SocketStatus.SOCKET_STATUS_CONNECTED)
+ {
+ CrestronConsole.PrintLine("clientConnectCallback: Connected to " + client.AddressClientConnectedTo + " on port " + client.PortNumber);
+ // Once connected, begin waiting for packets from the server.
+ // This call to ReceiveDataAsync is necessary to receive the FIN packet from the server in the event
+ // that the TLS handshake fails and the connection cannot be made. If you do not call ReceiveDataAsync here,
+ // the client will remain "connected" from its perspective, though no connection has been made.
+ client.ReceiveDataAsync(clientReceiveCallback);
+ }
+ else
+ {
+ CrestronConsole.PrintLine("clientConnectCallback: No connection could be made with the server.");
+ }
+ }
+
+ public void clientReceiveCallback(SecureTCPClient client, int bytes_recvd)
+ {
+ if (bytes_recvd <= 0) // 0 or negative byte count indicates the connection has been closed
+ {
+ CrestronConsole.PrintLine("clientReceiveCallback: Could not receive message- connection closed");
+ }
+ else
+ {
+ try
+ {
+ CrestronConsole.PrintLine("Received " + bytes_recvd + " bytes from " + client.AddressClientConnectedTo + " port " + client.PortNumber);
+ string received = ASCIIEncoding.ASCII.GetString(client.IncomingDataBuffer, 0, client.IncomingDataBuffer.Length);
+ CrestronConsole.PrintLine("Server says: " + received);
+ }
+ catch (Exception e)
+ {
+ CrestronConsole.PrintLine("Exception in clientReceiveCallback: " + e.Message);
+ }
+ // Wait for another message
+ client.ReceiveDataAsync(clientReceiveCallback);
+ }
+ }
+
+
+ using System;
+ using System.Collections.Generic;
+ using Crestron.SimplSharp; // For Basic SIMPL# Classes
+ using Crestron.SimplSharpPro; // For Basic SIMPL#Pro classes
+ using Crestron.SimplSharp.CrestronAuthentication;
+
+ public class ControlSystem : CrestronControlSystem
+ {
+ Authentication.UserToken adminToken;
+ bool hasToken;
+
+ public ControlSystem()
+ {
+ try
+ {
+ CrestronConsole.AddNewConsoleCommand(CreateToken, "createtoken", "usage: createtoken username password", ConsoleAccessLevelEnum.AccessAdministrator);
+ }
+ catch (Exception e)
+ {
+ ErrorLog.Error("Error in the constructor: {0}", e.Message);
+ }
+ }
+
+ // Create a token for an admin user, or print an error message if the credentials of an existing admin are not provided
+ public void CreateToken(string args)
+ {
+ try
+ {
+ string userName = args.Split(' ')[0];
+ string password = args.Split(' ')[1];
+ if (hasToken)
+ {
+ Authentication.ReleaseAuthenticationToken(adminToken);
+ hasToken = false;
+ }
+ adminToken = Authentication.GetAuthenticationToken(userName, password);
+ if (adminToken.Valid)
+ {
+ if ((adminToken.Access & Authentication.UserAuthenticationLevelEnum.Administrator)
+ == Authentication.UserAuthenticationLevelEnum.Administrator)
+ {
+ CrestronConsole.ConsoleCommandResponse("Admin Token created\r\n");
+ CrestronConsole.AddNewConsoleCommand(SeeAllUsers, "SeeAllU", "See all the users on the control system", ConsoleAccessLevelEnum.AccessAdministrator);
+ hasToken = true;
+ }
+ else
+ {
+ CrestronConsole.ConsoleCommandResponse("Inputted credentials are not for an admin account");
+ Authentication.ReleaseAuthenticationToken(adminToken);
+ }
+ }
+ else
+ {
+ CrestronConsole.ConsoleCommandResponse("The specified username/password pair is incorrect");
+ }
+
+ }
+ catch (Exception e)
+ {
+ CrestronConsole.ConsoleCommandResponse("Error in CreateToken: {0}", e);
+ }
+ }
+
+ public void SeeAllUsers(string args)
+ {
+ try
+ {
+ if (adminToken.Valid &&
+ (adminToken.Access & Authentication.UserAuthenticationLevelEnum.Administrator)
+ == Authentication.UserAuthenticationLevelEnum.Administrator)
+ {
+ List<string> users = Authentication.GetUsers(adminToken);
+ CrestronConsole.ConsoleCommandResponse("User List:\r\n\r\n");
+ if (users == null)
+ {
+ CrestronConsole.ConsoleCommandResponse("Error encountered in GetUsers()");
+ }
+ else if (users.Count == 0)
+ {
+ CrestronConsole.PrintLine("No Users");
+ }
+ else
+ {
+ CrestronConsole.ConsoleCommandResponse("User\t\t\t\tAccess Level\r\n");
+ foreach (var user in users)
+ {
+ CrestronConsole.ConsoleCommandResponse("{0}", user);
+ CrestronConsole.ConsoleCommandResponse("\t\t\t{0}\r\n", Authentication.GetAccessLevelForSpecifiedUser(adminToken, user));
+ }
+ }
+ }
+ else
+ {
+ CrestronConsole.ConsoleCommandResponse("Invalid adminToken provided");
+ }
+ }
+ catch (Exception e)
+ {
+ CrestronConsole.ConsoleCommandResponse("Error in SeeAllUsers(): {0}", e);
+ }
+ }
+ }
+
+ Requires minimum firmware version 1.502.0009
+Requires minimum firmware version 1.601.0017
+Requires minimum firmware version 1.601.0017
+Requires minimum firmware version 1.601.0017
+ User token obtained using "GetAuthenticationToken" method passed as refernce that is needed to logout from active directory server. +