OpenSim
/
OpenSimMirror
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Set svn:eol-style.

ThreadPoolClientBranch
Jeff Ames 2008-01-12 01:35:25 +00:00
parent c4684b2d14
commit 5d7e120d56
5 changed files with 489 additions and 489 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

248
OpenSim/Region/ScriptEngine/Common/TRPC/TCPClient.cs
View File

@ -1,125 +1,125 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Diagnostics; using System.Diagnostics;
using System.Net; using System.Net;
using System.Net.Sockets; using System.Net.Sockets;
using System.Text; using System.Text;
namespace OpenSim.Region.ScriptEngine.Common.TRPC namespace OpenSim.Region.ScriptEngine.Common.TRPC
{ {
public class TCPClient : TCPCommon.ClientInterface public class TCPClient : TCPCommon.ClientInterface
{ {
public TCPClient() public TCPClient()
{ {
} }
private readonly Dictionary<int, TCPSocket> Clients = new Dictionary<int, TCPSocket>(); private readonly Dictionary<int, TCPSocket> Clients = new Dictionary<int, TCPSocket>();
private int ClientCount = 0; private int ClientCount = 0;
public event TCPCommon.ClientConnectedDelegate ClientConnected; public event TCPCommon.ClientConnectedDelegate ClientConnected;
public event TCPCommon.DataReceivedDelegate DataReceived; public event TCPCommon.DataReceivedDelegate DataReceived;
public event TCPCommon.DataSentDelegate DataSent; public event TCPCommon.DataSentDelegate DataSent;
public event TCPCommon.CloseDelegate Close; public event TCPCommon.CloseDelegate Close;
public event TCPCommon.ConnectErrorDelegate ConnectError; public event TCPCommon.ConnectErrorDelegate ConnectError;
/// <summary> /// <summary>
/// Creates client connection /// Creates client connection
/// </summary> /// </summary>
public void Connect(string RemoteHost, int RemotePort) public void Connect(string RemoteHost, int RemotePort)
{ {
Socket newsock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); Socket newsock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
IPEndPoint ipe = new IPEndPoint(IPAddress.Parse(RemoteHost), RemotePort); IPEndPoint ipe = new IPEndPoint(IPAddress.Parse(RemoteHost), RemotePort);
//newsock.BeginConnect(ipe, new AsyncCallback(asyncConnected), newsock); //newsock.BeginConnect(ipe, new AsyncCallback(asyncConnected), newsock);
newsock.Connect(ipe); newsock.Connect(ipe);
} }
public int ConnectAndReturnID(string RemoteHost, int RemotePort) public int ConnectAndReturnID(string RemoteHost, int RemotePort)
{ {
Socket newsock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); Socket newsock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
IPEndPoint ipe = new IPEndPoint(IPAddress.Parse(RemoteHost), RemotePort); IPEndPoint ipe = new IPEndPoint(IPAddress.Parse(RemoteHost), RemotePort);
//newsock.BeginConnect(ipe, new AsyncCallback(asyncConnected), newsock); //newsock.BeginConnect(ipe, new AsyncCallback(asyncConnected), newsock);
newsock.Connect(ipe); newsock.Connect(ipe);
return ProcessConnection(newsock); return ProcessConnection(newsock);
} }
public void Disconnect(int ID) public void Disconnect(int ID)
{ {
Clients[ID].Disconnect(); Clients[ID].Disconnect();
} }
void asyncConnected(IAsyncResult iar) void asyncConnected(IAsyncResult iar)
{ {
Socket client = (Socket)iar.AsyncState; Socket client = (Socket)iar.AsyncState;
client.EndConnect(iar); client.EndConnect(iar);
ProcessConnection(client); ProcessConnection(client);
} }
private int ProcessConnection(Socket client) private int ProcessConnection(Socket client)
{ {
try try
{ {
int id = ClientCount++; int id = ClientCount++;
TCPSocket S = new TCPSocket(id, client); TCPSocket S = new TCPSocket(id, client);
// Add to dictionary // Add to dictionary
Clients.Add(id, S); Clients.Add(id, S);
// Add event handlers // Add event handlers
S.Close += new TCPSocket.CloseDelegate(S_Close); S.Close += new TCPSocket.CloseDelegate(S_Close);
S.DataReceived += new TCPSocket.DataReceivedDelegate(S_DataReceived); S.DataReceived += new TCPSocket.DataReceivedDelegate(S_DataReceived);
S.DataSent += new TCPSocket.DataSentDelegate(S_DataSent); S.DataSent += new TCPSocket.DataSentDelegate(S_DataSent);
// Start it // Start it
S.Start(); S.Start();
Debug.WriteLine("Connection established: " + client.RemoteEndPoint.ToString()); Debug.WriteLine("Connection established: " + client.RemoteEndPoint.ToString());
// Fire Connected-event // Fire Connected-event
if (ClientConnected != null) if (ClientConnected != null)
ClientConnected(id, client.RemoteEndPoint); ClientConnected(id, client.RemoteEndPoint);
return id; return id;
} }
catch (SocketException sex) catch (SocketException sex)
{ {
if (ConnectError != null) if (ConnectError != null)
ConnectError(sex.Message); ConnectError(sex.Message);
} }
return -1; return -1;
} }
void S_DataSent(int ID, int length) void S_DataSent(int ID, int length)
{ {
if (DataSent != null) if (DataSent != null)
DataSent(ID, length); DataSent(ID, length);
} }
void S_DataReceived(int ID, byte[] data, int offset, int length) void S_DataReceived(int ID, byte[] data, int offset, int length)
{ {
if (DataReceived != null) if (DataReceived != null)
DataReceived(ID, data, offset, length); DataReceived(ID, data, offset, length);
} }
void S_Close(int ID) void S_Close(int ID)
{ {
if (Close != null) if (Close != null)
Close(ID); Close(ID);
Clients.Remove(ID); Clients.Remove(ID);
} }
public void Send(int clientID, byte[] data, int offset, int len) public void Send(int clientID, byte[] data, int offset, int len)
{ {
Clients[clientID].Send(clientID, data, offset, len); Clients[clientID].Send(clientID, data, offset, len);
} }
} }
} }

64
OpenSim/Region/ScriptEngine/Common/TRPC/TCPCommon.cs
View File

@ -1,33 +1,33 @@
namespace OpenSim.Region.ScriptEngine.Common.TRPC namespace OpenSim.Region.ScriptEngine.Common.TRPC
{ {
public class TCPCommon public class TCPCommon
{ {
public delegate void ClientConnectedDelegate(int ID, System.Net.EndPoint Remote); public delegate void ClientConnectedDelegate(int ID, System.Net.EndPoint Remote);
public delegate void DataReceivedDelegate(int ID, byte[] data, int offset, int length); public delegate void DataReceivedDelegate(int ID, byte[] data, int offset, int length);
public delegate void DataSentDelegate(int ID, int length); public delegate void DataSentDelegate(int ID, int length);
public delegate void CloseDelegate(int ID); public delegate void CloseDelegate(int ID);
public delegate void ConnectErrorDelegate(string Reason); public delegate void ConnectErrorDelegate(string Reason);
public interface ServerAndClientInterface public interface ServerAndClientInterface
{ {
void Send(int clientID, byte[] data, int offset, int len); void Send(int clientID, byte[] data, int offset, int len);
event ClientConnectedDelegate ClientConnected; event ClientConnectedDelegate ClientConnected;
event DataReceivedDelegate DataReceived; event DataReceivedDelegate DataReceived;
event DataSentDelegate DataSent; event DataSentDelegate DataSent;
event CloseDelegate Close; event CloseDelegate Close;
} }
public interface ClientInterface : ServerAndClientInterface public interface ClientInterface : ServerAndClientInterface
{ {
event TCPCommon.ConnectErrorDelegate ConnectError; event TCPCommon.ConnectErrorDelegate ConnectError;
void Connect(string RemoteHost, int RemotePort); void Connect(string RemoteHost, int RemotePort);
void Disconnect(int ID); void Disconnect(int ID);
} }
public interface ServerInterface : ServerAndClientInterface public interface ServerInterface : ServerAndClientInterface
{ {
void StartListen(); void StartListen();
void StopListen(); void StopListen();
} }
} }
} }

210
OpenSim/Region/ScriptEngine/Common/TRPC/TCPServer.cs
View File

@ -1,106 +1,106 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Diagnostics; using System.Diagnostics;
using System.Net; using System.Net;
using System.Net.Sockets; using System.Net.Sockets;
using TCPCommon=OpenSim.Region.ScriptEngine.Common.TRPC.TCPCommon; using TCPCommon=OpenSim.Region.ScriptEngine.Common.TRPC.TCPCommon;
namespace OpenSim.Region.ScriptEngine.Common.TRPC namespace OpenSim.Region.ScriptEngine.Common.TRPC
{ {
public class TCPServer: TCPCommon.ServerInterface public class TCPServer: TCPCommon.ServerInterface
{ {
public readonly int LocalPort; public readonly int LocalPort;
public TCPServer(int localPort) public TCPServer(int localPort)
{ {
LocalPort = localPort; LocalPort = localPort;
} }
private Socket server; private Socket server;
/// <summary> /// <summary>
/// Starts listening for new connections /// Starts listening for new connections
/// </summary> /// </summary>
public void StartListen() public void StartListen()
{ {
server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
IPEndPoint ipe = new IPEndPoint(IPAddress.Any, LocalPort); IPEndPoint ipe = new IPEndPoint(IPAddress.Any, LocalPort);
server.Bind(ipe); server.Bind(ipe);
server.Listen(10); server.Listen(10);
server.BeginAccept(new AsyncCallback(AsyncAcceptConnections), server); server.BeginAccept(new AsyncCallback(AsyncAcceptConnections), server);
} }
/// <summary> /// <summary>
/// Stops listening for new connections /// Stops listening for new connections
/// </summary> /// </summary>
public void StopListen() public void StopListen()
{ {
server.Close(); server.Close();
server = null; server = null;
} }
private readonly Dictionary<int, TCPSocket> Clients = new Dictionary<int, TCPSocket>(); private readonly Dictionary<int, TCPSocket> Clients = new Dictionary<int, TCPSocket>();
private int ClientCount = 0; private int ClientCount = 0;
public event TCPCommon.ClientConnectedDelegate ClientConnected; public event TCPCommon.ClientConnectedDelegate ClientConnected;
public event TCPCommon.DataReceivedDelegate DataReceived; public event TCPCommon.DataReceivedDelegate DataReceived;
public event TCPCommon.DataSentDelegate DataSent; public event TCPCommon.DataSentDelegate DataSent;
public event TCPCommon.CloseDelegate Close; public event TCPCommon.CloseDelegate Close;
/// <summary> /// <summary>
/// Async callback for new connections /// Async callback for new connections
/// </summary> /// </summary>
/// <param name="ar"></param> /// <param name="ar"></param>
private void AsyncAcceptConnections(IAsyncResult ar) private void AsyncAcceptConnections(IAsyncResult ar)
{ {
int id = ClientCount++; int id = ClientCount++;
Socket oldserver = (Socket)ar.AsyncState; Socket oldserver = (Socket)ar.AsyncState;
Socket client = oldserver.EndAccept(ar); Socket client = oldserver.EndAccept(ar);
TCPSocket S = new TCPSocket(id, client); TCPSocket S = new TCPSocket(id, client);
// Add to dictionary // Add to dictionary
Clients.Add(id, S); Clients.Add(id, S);
// Add event handlers // Add event handlers
S.Close += new TCPSocket.CloseDelegate(S_Close); S.Close += new TCPSocket.CloseDelegate(S_Close);
S.DataReceived += new TCPSocket.DataReceivedDelegate(S_DataReceived); S.DataReceived += new TCPSocket.DataReceivedDelegate(S_DataReceived);
S.DataSent += new TCPSocket.DataSentDelegate(S_DataSent); S.DataSent += new TCPSocket.DataSentDelegate(S_DataSent);
// Start it // Start it
S.Start(); S.Start();
Debug.WriteLine("Connection received: " + client.RemoteEndPoint.ToString()); Debug.WriteLine("Connection received: " + client.RemoteEndPoint.ToString());
// Fire Connected-event // Fire Connected-event
if (ClientConnected != null) if (ClientConnected != null)
ClientConnected(id, client.RemoteEndPoint); ClientConnected(id, client.RemoteEndPoint);
} }
void S_DataSent(int ID, int length) void S_DataSent(int ID, int length)
{ {
if (DataSent != null) if (DataSent != null)
DataSent(ID, length); DataSent(ID, length);
} }
void S_DataReceived(int ID, byte[] data, int offset, int length) void S_DataReceived(int ID, byte[] data, int offset, int length)
{ {
if (DataReceived != null) if (DataReceived != null)
DataReceived(ID, data, offset, length); DataReceived(ID, data, offset, length);
} }
void S_Close(int ID) void S_Close(int ID)
{ {
if (Close != null) if (Close != null)
Close(ID); Close(ID);
Clients.Remove(ID); Clients.Remove(ID);
} }
public void Send(int clientID, byte[] data, int offset, int len) public void Send(int clientID, byte[] data, int offset, int len)
{ {
Clients[clientID].Send(clientID, data, offset, len); Clients[clientID].Send(clientID, data, offset, len);
} }
} }
} }

170
OpenSim/Region/ScriptEngine/Common/TRPC/TCPSocket.cs
View File

@ -1,86 +1,86 @@
using System; using System;
using System.Net.Sockets; using System.Net.Sockets;
namespace OpenSim.Region.ScriptEngine.Common.TRPC namespace OpenSim.Region.ScriptEngine.Common.TRPC
{ {
public class TCPSocket public class TCPSocket
{ {
public readonly Socket Client; public readonly Socket Client;
public readonly int ID; public readonly int ID;
public delegate void DataReceivedDelegate(int ID, byte[] data, int offset, int length); public delegate void DataReceivedDelegate(int ID, byte[] data, int offset, int length);
public delegate void DataSentDelegate(int ID, int length); public delegate void DataSentDelegate(int ID, int length);
public delegate void CloseDelegate(int ID); public delegate void CloseDelegate(int ID);
public event DataReceivedDelegate DataReceived; public event DataReceivedDelegate DataReceived;
public event DataSentDelegate DataSent; public event DataSentDelegate DataSent;
public event CloseDelegate Close; public event CloseDelegate Close;
private byte[] RecvQueue = new byte[4096]; private byte[] RecvQueue = new byte[4096];
private int RecvQueueSize = 4096; private int RecvQueueSize = 4096;
public TCPSocket(int id, Socket client) public TCPSocket(int id, Socket client)
{ {
ID = id; ID = id;
Client = client; Client = client;
} }
public void Start() public void Start()
{ {
// Start listening // Start listening
BeginReceive(); BeginReceive();
} }
private void BeginReceive() private void BeginReceive()
{ {
Client.BeginReceive(RecvQueue, 0, RecvQueueSize, SocketFlags.None, new AsyncCallback(asyncDataReceived), Client); Client.BeginReceive(RecvQueue, 0, RecvQueueSize, SocketFlags.None, new AsyncCallback(asyncDataReceived), Client);
} }
/// <summary> /// <summary>
/// Callback for successful receive (or connection close) /// Callback for successful receive (or connection close)
/// </summary> /// </summary>
/// <param name="ar"></param> /// <param name="ar"></param>
private void asyncDataReceived(IAsyncResult ar) private void asyncDataReceived(IAsyncResult ar)
{ {
Socket client = (Socket)ar.AsyncState; Socket client = (Socket)ar.AsyncState;
int recv = client.EndReceive(ar); int recv = client.EndReceive(ar);
// Is connection closed? // Is connection closed?
if (recv == 0) if (recv == 0)
{ {
client.Close(); client.Close();
Close(ID); Close(ID);
return; return;
} }
// Call receive event // Call receive event
DataReceived(ID, RecvQueue, 0, recv); DataReceived(ID, RecvQueue, 0, recv);
// Start new receive // Start new receive
BeginReceive(); BeginReceive();
} }
public void Send(int clientID, byte[] data, int offset, int len) public void Send(int clientID, byte[] data, int offset, int len)
{ {
Client.BeginSend(data, offset, len, SocketFlags.None, new AsyncCallback(asyncDataSent), Client); Client.BeginSend(data, offset, len, SocketFlags.None, new AsyncCallback(asyncDataSent), Client);
} }
/// <summary> /// <summary>
/// Callback for successful send /// Callback for successful send
/// </summary> /// </summary>
/// <param name="ar"></param> /// <param name="ar"></param>
void asyncDataSent(IAsyncResult ar) void asyncDataSent(IAsyncResult ar)
{ {
Socket client = (Socket)ar.AsyncState; Socket client = (Socket)ar.AsyncState;
int sent = client.EndSend(ar); int sent = client.EndSend(ar);
DataSent(ID, sent); DataSent(ID, sent);
} }
public void Disconnect() public void Disconnect()
{ {
Client.Close(); Client.Close();
Close(ID); Close(ID);
} }
} }
} }

286
OpenSim/Region/ScriptEngine/Common/TRPC_Remote.cs
View File

@ -1,144 +1,144 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Diagnostics; using System.Diagnostics;
using System.Text; using System.Text;
using OpenSim.Region.ScriptEngine.Common.TRPC; using OpenSim.Region.ScriptEngine.Common.TRPC;
namespace OpenSim.Region.ScriptEngine.Common namespace OpenSim.Region.ScriptEngine.Common
{ {
public class TRPC_Remote public class TRPC_Remote
{ {
public readonly int MaxQueueSize = 1024 * 10; public readonly int MaxQueueSize = 1024 * 10;
public readonly TCPCommon.ServerAndClientInterface TCPS; public readonly TCPCommon.ServerAndClientInterface TCPS;
public delegate void ReceiveCommandDelegate(int ID, string Command, params object[] p); public delegate void ReceiveCommandDelegate(int ID, string Command, params object[] p);
public event ReceiveCommandDelegate ReceiveCommand; public event ReceiveCommandDelegate ReceiveCommand;
// TODO: Maybe we should move queue into TCPSocket so we won't have to keep one queue instance per connection // TODO: Maybe we should move queue into TCPSocket so we won't have to keep one queue instance per connection
private System.Collections.Generic.Dictionary<int, InQueueStruct> InQueue = new Dictionary<int, InQueueStruct>(); private System.Collections.Generic.Dictionary<int, InQueueStruct> InQueue = new Dictionary<int, InQueueStruct>();
private class InQueueStruct private class InQueueStruct
{ {
public byte[] Queue; public byte[] Queue;
public int QueueSize; public int QueueSize;
public object QueueLockObject = new object(); public object QueueLockObject = new object();
} }
public TRPC_Remote(TCPCommon.ServerAndClientInterface TCPClientOrServer) public TRPC_Remote(TCPCommon.ServerAndClientInterface TCPClientOrServer)
{ {
TCPS = TCPClientOrServer; TCPS = TCPClientOrServer;
TCPS.Close += new TCPCommon.CloseDelegate(TCPS_Close); TCPS.Close += new TCPCommon.CloseDelegate(TCPS_Close);
TCPS.ClientConnected += new TCPCommon.ClientConnectedDelegate(TCPS_ClientConnected); TCPS.ClientConnected += new TCPCommon.ClientConnectedDelegate(TCPS_ClientConnected);
TCPS.DataReceived += new TCPCommon.DataReceivedDelegate(TCPS_DataReceived); TCPS.DataReceived += new TCPCommon.DataReceivedDelegate(TCPS_DataReceived);
//TCPS.StartListen(); //TCPS.StartListen();
} }
void TCPS_ClientConnected(int ID, System.Net.EndPoint Remote) void TCPS_ClientConnected(int ID, System.Net.EndPoint Remote)
{ {
// Create a incoming queue for this connection // Create a incoming queue for this connection
InQueueStruct iq = new InQueueStruct(); InQueueStruct iq = new InQueueStruct();
iq.Queue = new byte[MaxQueueSize]; iq.Queue = new byte[MaxQueueSize];
iq.QueueSize = 0; iq.QueueSize = 0;
InQueue.Add(ID, iq); InQueue.Add(ID, iq);
} }
void TCPS_Close(int ID) void TCPS_Close(int ID)
{ {
// Remove queue // Remove queue
InQueue.Remove(ID); InQueue.Remove(ID);
} }
void TCPS_DataReceived(int ID, byte[] data, int offset, int length) void TCPS_DataReceived(int ID, byte[] data, int offset, int length)
{ {
// Copy new data to incoming queue // Copy new data to incoming queue
lock (InQueue[ID].QueueLockObject) lock (InQueue[ID].QueueLockObject)
{ {
Array.Copy(data, offset, InQueue[ID].Queue, InQueue[ID].QueueSize, length); Array.Copy(data, offset, InQueue[ID].Queue, InQueue[ID].QueueSize, length);
InQueue[ID].QueueSize += length; InQueue[ID].QueueSize += length;
// Process incoming queue // Process incoming queue
ProcessQueue(ID); ProcessQueue(ID);
} }
} }
private void ProcessQueue(int ID) private void ProcessQueue(int ID)
{ {
// This is just a temp implementation -- not so fast :) // This is just a temp implementation -- not so fast :)
InQueueStruct myIQS = InQueue[ID]; InQueueStruct myIQS = InQueue[ID];
if (myIQS.QueueSize == 0) if (myIQS.QueueSize == 0)
return; return;
string receivedData = Encoding.ASCII.GetString(myIQS.Queue, 0, myIQS.QueueSize); string receivedData = Encoding.ASCII.GetString(myIQS.Queue, 0, myIQS.QueueSize);
Debug.WriteLine("RAW: " + receivedData); Debug.WriteLine("RAW: " + receivedData);
byte newLine = 10; byte newLine = 10;
while (true) while (true)
{ {
bool ShouldProcess = false; bool ShouldProcess = false;
int lineEndPos = 0; int lineEndPos = 0;
// Look for newline // Look for newline
for (int i = 0; i < myIQS.QueueSize; i++) for (int i = 0; i < myIQS.QueueSize; i++)
{ {
if (myIQS.Queue[i] == newLine) if (myIQS.Queue[i] == newLine)
{ {
ShouldProcess = true; ShouldProcess = true;
lineEndPos = i; lineEndPos = i;
break; break;
} }
} }
// Process it? // Process it?
if (!ShouldProcess) if (!ShouldProcess)
return; return;
// Yes // Yes
string cmdLine = Encoding.ASCII.GetString(myIQS.Queue, 0, lineEndPos); string cmdLine = Encoding.ASCII.GetString(myIQS.Queue, 0, lineEndPos);
Debug.WriteLine("Command: " + cmdLine); Debug.WriteLine("Command: " + cmdLine);
// Fix remaining queue in an inefficient way // Fix remaining queue in an inefficient way
byte[] newQueue = new byte[MaxQueueSize]; byte[] newQueue = new byte[MaxQueueSize];
Array.Copy(myIQS.Queue, lineEndPos, newQueue, 0, myIQS.QueueSize - lineEndPos); Array.Copy(myIQS.Queue, lineEndPos, newQueue, 0, myIQS.QueueSize - lineEndPos);
myIQS.Queue = newQueue; myIQS.Queue = newQueue;
myIQS.QueueSize -= (lineEndPos + 1); myIQS.QueueSize -= (lineEndPos + 1);
// Now back to the command // Now back to the command
string[] parts = cmdLine.Split(','); string[] parts = cmdLine.Split(',');
if (parts.Length > 0) if (parts.Length > 0)
{ {
string cmd = parts[0]; string cmd = parts[0];
int paramCount = parts.Length - 1; int paramCount = parts.Length - 1;
string[] param = null; string[] param = null;
if (paramCount > 0) if (paramCount > 0)
{ {
// Process all parameters (decoding them from URL encoding) // Process all parameters (decoding them from URL encoding)
param = new string[paramCount]; param = new string[paramCount];
for (int i = 1; i < parts.Length; i++) for (int i = 1; i < parts.Length; i++)
{ {
param[i - 1] = System.Web.HttpUtility.UrlDecode(parts[i]); param[i - 1] = System.Web.HttpUtility.UrlDecode(parts[i]);
} }
} }
ReceiveCommand(ID, cmd, param); ReceiveCommand(ID, cmd, param);
} }
} }
} }
public void SendCommand(int ID, string Command, params object[] p) public void SendCommand(int ID, string Command, params object[] p)
{ {
// Call PacketFactory to have it create a packet for us // Call PacketFactory to have it create a packet for us
//string[] tmpP = new string[p.Length]; //string[] tmpP = new string[p.Length];
string tmpStr = Command; string tmpStr = Command;
for (int i = 0; i < p.Length; i++) for (int i = 0; i < p.Length; i++)
{ {
tmpStr += "," + System.Web.HttpUtility.UrlEncode(p[i].ToString()); // .Replace(",", "%44") tmpStr += "," + System.Web.HttpUtility.UrlEncode(p[i].ToString()); // .Replace(",", "%44")
} }
tmpStr += "\n"; tmpStr += "\n";
byte[] byteData = Encoding.ASCII.GetBytes(tmpStr); byte[] byteData = Encoding.ASCII.GetBytes(tmpStr);
TCPS.Send(ID, byteData, 0, byteData.Length); TCPS.Send(ID, byteData, 0, byteData.Length);
} }
} }
} }