private void Read(UDPServer myUDPServer, int numberOfBytesReceived)
{
// byte[] rbytes = new byte[numberOfBytesReceived];
if (numberOfBytesReceived > 0)
{
//Array.Copy(myUDPServer.IncomingDataBuffer, rbytes, numberOfBytesReceived);
OnDataReceived(Encoding.GetEncoding(28591).GetString(myUDPServer.IncomingDataBuffer, 0, numberOfBytesReceived));
}
// CrestronConsole.PrintLine("Recv:" + ILiveUtil.ToHexString(rbytes));
SocketErrorCodes code = myUDPServer.ReceiveDataAsync(this.Read);
Thread.Sleep(500);
}
/// <summary>
/// Recursive method to receive data
/// </summary>
/// <param name="server"></param>
/// <param name="numBytes"></param>
void Receive(UDPServer server, int numBytes)
{
Debug.Console(2, this, "Received {0} bytes", numBytes);
if (numBytes > 0)
{
var sourceIp = Server.IPAddressLastMessageReceivedFrom;
var sourcePort = Server.IPPortLastMessageReceivedFrom;
var bytes = server.IncomingDataBuffer.Take(numBytes).ToArray();
var str = Encoding.GetEncoding(28591).GetString(bytes, 0, bytes.Length);
MessageQueue.TryToEnqueue(new GenericUdpReceiveTextExtraArgs(str, sourceIp, sourcePort, bytes));
Debug.Console(2, this, "Bytes: {0}", bytes.ToString());
var bytesHandler = BytesReceived;
if (bytesHandler != null)
{
bytesHandler(this, new GenericCommMethodReceiveBytesArgs(bytes));
}
else
{
Debug.Console(2, this, "bytesHandler is null");
}
var textHandler = TextReceived;
if (textHandler != null)
{
if (StreamDebugging.RxStreamDebuggingIsEnabled)
{
Debug.Console(0, this, "Recevied: '{0}'", str);
}
textHandler(this, new GenericCommMethodReceiveTextArgs(str));
}
else
{
Debug.Console(2, this, "textHandler is null");
}
}
server.ReceiveDataAsync(Receive);
// Attempt to enter the CCritical Secion and if we can, start the dequeue thread
var gotLock = DequeueLock.TryEnter();
if (gotLock)
{
CrestronInvoke.BeginInvoke((o) => DequeueEvent());
}
}
public void Disconnect()
{
Logger.Log("Disconnect()");
if (client != null)
{
stateRequestTimer.Stop();
Alive = false;
DisconnectRequest();
client.DisableUDPServer();
Pacer.ClearTx();
client = null;
if (OnDisconnect != null)
{
OnDisconnect();
}
}
}
private void btnStart_Click(object sender, EventArgs e)
{
//parse_command(null);
//new_message();
try
{
int port = int.Parse(this.txtPort.Text);
UDPServer.startUDPListening(port);
this.btnStart.Enabled = false;
//this.btnStart.Text = "停止监听(&S)";
}
catch (System.Exception ex)
{
MessageBox.Show("串口填写错误！", "提示");
return;
}
}
static void Main(string[] args)
{
bool quit = false;
server = new UDPServer(2048);
System.Console.Write("Hosting nat on: ");
System.Console.Write(BeardedManStudios.Forge.Networking.Nat.NatHolePunch.DEFAULT_NAT_SERVER_PORT);
System.Console.Write(System.Environment.NewLine);
server.Connect("0.0.0.0", BeardedManStudios.Forge.Networking.Nat.NatHolePunch.DEFAULT_NAT_SERVER_PORT);
server.textMessageReceived += TextMessageReceived;
while (!quit)
{
;
}
}
public void Host()
{
NetWorker server;
server = new UDPServer(64);
((UDPServer)server).Connect(ipAddress.text, ushort.Parse(portNumber.text));
server.playerTimeout += (player, sender) =>
{
Debug.Log("Player " + player.NetworkId + " timed out");
};
NetworkManager.Instance.Initialize(server);
Connected(server);
SpeechManager.instance.Hosting();
}
public override void LoadContent()
{
entityFactory = new EntityFactory(new NormalBodyFactory(world));
var entitySet = EntitySets.GameStateSet(entityFactory);
var User = Chat.ChatRoom.users.Where(x => x.Value.Admin).FirstOrDefault();
var enemyUser = Chat.ChatRoom.users.Where(x => !x.Value.Admin).FirstOrDefault();
ball = entityFactory.CreateDynamicCircle(520, 435, 15f, "Ball", true);
player = entityFactory.CreateDynamicPlayer(917, 752, 30, $"{User.Key},{User.Value.Skin}", true);
enemyPlayer = entityFactory.CreateDynamicPlayer(112, 752, 30, $"{enemyUser.Key},{enemyUser.Value.Skin}", true);
foot = entityFactory.CreateDynamicBox(250, 350, new Vector2(35, 10), "rfoot", true);
enemyFoot = entityFactory.CreateDynamicBox(250, 350, new Vector2(60, 10), "foot", true);
legJoint = entityFactory.CreateRevoluteJointJoint(player, foot);
enemyLegJoint = entityFactory.CreateRevoluteJointJoint(enemyPlayer, enemyFoot, true);
playerFootSpeed = legJoint.MotorSpeed;
enemyFootSpeed = enemyLegJoint.MotorSpeed;
ballPosition = ball.body.Position;
playerPosition = player.body.Position;
enemyPlayerPosition = enemyPlayer.body.Position;
entitySet.Add(ball);
entitySet.Add(enemyPlayer);
entitySet.Add(player);
entitySet.Add(foot);
entitySet.Add(enemyFoot);
Game.Game.Entities = entitySet;
var inputHandler = new InputHandler();
inputHandler.ReciveHandler = handleInput;
if (UDPServer is null)
{
UDPServer = new UDPServer <Frame>(1337);
}
MyContactListener.playerScore += PlayerScore;
MyContactListener.enemyScore += EnemyScore;
Game.Game.IsLive = true;
isLoaded = true;
}
public void StartCommunication(bool realTransmitter)
{
server = new UDPServer(serverPort);
serverTeambots = new UDPServer(serverTeambotsPort);
Thread UDPServerThread = new Thread(server.Execute);
UDPServerThread.Start();
while (!UDPServerThread.IsAlive) ;
Thread.Sleep(1);
Thread UDPServerTeambotsThread = new Thread(serverTeambots.Execute);
UDPServerTeambotsThread.Start();
while (!UDPServerTeambotsThread.IsAlive) ;
Thread.Sleep(1);
if (realTransmitter)
{
transmitter = new LR.TransmissorRFM12USB();
transmitter.Inicializar("VIVATxRx", "IME");
sendTimer = new System.Timers.Timer(50);
sendTimer.Elapsed += new ElapsedEventHandler(TxSendReceive);
sendTimer.Enabled = true;
string blah = "";
while (blah != "quit")
{
blah = Console.ReadLine();
}
}
else
{
this.simulationClient = new UdpClient("127.0.0.1", clientPort);
sendTimer = new System.Timers.Timer(70);
sendTimer.Elapsed += new ElapsedEventHandler(UDPSend);
sendTimer.Enabled = true;
string blah = "";
while (blah != "quit")
{
blah = Console.ReadLine();
}
}
}
static void Main(string[] args)
{
string serverMode = System.Configuration.ConfigurationSettings.AppSettings["Server_Mode"];
if (serverMode.ToLower() == "tcp")
{
TCPServer serve = new TCPServer();
}
else if (serverMode.ToLower() == "udp")
{
UDPServer serv = new UDPServer();
}
else
{
Utilities.writeLine("Config does not specify mode! Defaulting to TCP");
TCPServer serve = new TCPServer();
}
}
internal void HandleRegionHandleRequest(Message m)
{
var req = (Viewer.Messages.Region.RegionHandleRequest)m;
Viewer.Messages.Region.RegionIDAndHandleReply res;
RegionInfo ri;
if (GridService.TryGetValue(req.RegionID, out ri))
{
res = new Viewer.Messages.Region.RegionIDAndHandleReply
{
RegionPosition = ri.Location,
RegionID = req.RegionID
};
UDPServer.SendMessageToAgent(req.CircuitAgentID, res);
}
}
private void Read(UDPServer myUDPServer, int numberOfBytesReceived)
{
byte[] rbytes = new byte[numberOfBytesReceived];
if (numberOfBytesReceived > 0)
{
string messageReceived = Encoding.GetEncoding(28591).GetString(myUDPServer.IncomingDataBuffer, 0, numberOfBytesReceived);
OnDataReceived(messageReceived);
}
try
{
SocketErrorCodes code = myUDPServer.ReceiveDataAsync(this.Read);
Thread.Sleep(300);
}
catch (Exception)
{
}
}
static void Main(string[] args)
{
Console.WriteLine("server?y/n:");
string isServer = Console.ReadLine();
if (isServer.Equals("y"))
{
UDPBase udp = new UDPServer(2001);
while (true)
{
}
}
else
{
Console.WriteLine("input usePort:");
string myPortText = Console.ReadLine();
Console.WriteLine("input name:");
string name = Console.ReadLine();
UDPClient udp = new UDPClient(int.Parse(myPortText), 2001, name);
while (true)
{
Console.WriteLine("送信する文字列を入力してください。");
string sendMsg = Console.ReadLine();
if (sendMsg.Equals("test001"))
{
udp.Test001();
}
else if (sendMsg.Equals("test002"))
{
udp.Test002();
}
else
{
byte[] sendBytes = System.Text.Encoding.UTF8.GetBytes(sendMsg);
udp.Send(sendBytes);
}
}
}
}
static void Main(string[] args)
{
Console.WriteLine("SERVER");
Program program = new Program();
IPEndPoint localEP = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 3000);
IPEndPoint remoteEP = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 3001);
server = new UDPServer(program);
server.Start(localEP);
while (true)
{
string line = Console.ReadLine();
server.Send(line, remoteEP);
}
}
public void OnToggleServer(UILabel buttonText)
{
isServerStart = !isServerStart;
if (isServerStart)
{
broadcaster = new UDPServer(2333, maxCount);
broadcaster.Start();
client = new UDPClient(2333);
broadcaster.DataReceived += Broadcaster_DataReceived;
connectThread = Loom.StartSingleThread(BroadCastConnect, System.Threading.ThreadPriority.Normal, true);
buttonText.text = "停止监听";
}
else
{
buttonText.text = "开始监听";
CloseServer();
client.Dispose();
}
}
private void HMQManagerThreadProc()
{
Log.GetLogger().InfoFormat("HMQManagerThreadProc begin.");
//初始化数据库
if (!InitDatabase())
{
return;
}
//获取摄像头配置信息
if (!GetCameraConf())
{
return;
}
//获取扣分规则
if (!GetJudgementRule())
{
return;
}
//初始化设备和通道
if (!InitDevices())
{
return;
}
//开始运行
if (!RunMap())
{
return;
}
//开始监听车载数据
tcpServer = new TCPServer(dicCars, dicCameras, dicJudgementRule, dicExamProcedures, sqlDataProvider);
tcpServer.StartServer();
udpServer = new UDPServer(dicCars, dicExamProcedures);
udpServer.StartServer();
Log.GetLogger().InfoFormat("HMQManagerThreadProc end.");
}
private void EnableSimCircuit(RegionInfo destinationInfo, out UUID sessionID, out uint circuitCode)
{
var reqmap = new Map
{
["to_region_id"] = destinationInfo.ID,
["from_region_id"] = ID
};
byte[] reqdata;
using (var ms = new MemoryStream())
{
LlsdXml.Serialize(reqmap, ms);
reqdata = ms.ToArray();
}
/* try DNS lookup before triggering add circuit code */
IPAddress[] addresses = Dns.GetHostAddresses(destinationInfo.ServerIP);
var ep = new IPEndPoint(addresses[0], (int)destinationInfo.ServerPort);
Map resmap;
using (var responseStream = new HttpClient.Post(
destinationInfo.ServerURI + "circuit",
"application/llsd+xml",
reqdata.Length,
(Stream s) => s.Write(reqdata, 0, reqdata.Length)).ExecuteStreamRequest())
{
resmap = (Map)LlsdXml.Deserialize(responseStream);
}
circuitCode = resmap["circuit_code"].AsUInt;
sessionID = resmap["session_id"].AsUUID;
Neighbors[destinationInfo.ID].RemoteCircuit = UDPServer.UseSimCircuit(
ep,
sessionID,
this,
destinationInfo.ID,
circuitCode,
destinationInfo.Location,
destinationInfo.Location - GridPosition);
CheckAgentsForNeighbors();
}
/// <summary>
/// udp接收消息的线程
/// </summary>
/// <param name="parameter"></param>
public static void ServerUdpServerThread(object parameter)
{
UDPServer server = parameter as UDPServer;
IPEndPoint _endPoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 0);
while (!CloseServer)
{
Debug.Log($"监听udp消息");
//阻塞接收udp数据
byte[] data = server.Receive(ref _endPoint);
int offset = 0;
uint cmd = 0;
offset += Utils.ikcp_decode32u(data, offset, ref cmd);
#region cmd = 0 是 客户端请求conv , 除此之外 都是kcp通讯的消息
if (cmd == 0)
{
byte[] buffer = new byte[8];
offset = 4;
uint conv = ConvManager.GenerateConv();
offset += Utils.ikcp_encode32u(buffer, offset, conv);
Debug.Log($"分配 conv= {conv}");
EventSystem.DispatchEvent(EventID.new_conv, conv);
EventSystem.DispatchEvent(EventID.update_conv_ipendpoint, 0, _endPoint);
EventSystem.DispatchEvent(EventID.send_udp_buffer, buffer);
}
else
#endregion
{
uint conv = cmd;
EventSystem.DispatchEvent(EventID.update_conv_ipendpoint, conv, _endPoint);
EventSystem.DispatchEvent(EventID.receive_udp_buffer, conv, data);
Debug.Log($"收到消息 leng= {data.Length}");
}
}
}
public static void Run()
{
UDPSetting setting = new UDPSetting("127.0.0.1", 50666, KCPSetting.Defaut);
server = new UDPServer();
server.Listen(setting);
server.onReceiveCallback = (message) =>
{
byte[] rev = message.GetRawMessage();
string s = System.Text.Encoding.Default.GetString(rev);
Util.Debug.ServerLog("REV {0}：{1}", message.remote, s);
server.Send(message.remote, rev);
};
int counter = 0;
client = new KCPConnection();
client.Connect(setting);
client.Start();
client.onReceiveCallback = (message) =>
{
byte[] rev = message.GetRawMessage();
string s = System.Text.Encoding.Default.GetString(rev);
Util.Debug.ClientLog("REV {0}：{1}", message.remote, s);
Thread.Sleep(500);
counter++;
byte[] sd = System.Text.Encoding.Default.GetBytes(counter.ToString());
client.Send(sd);
};
byte[] data = System.Text.Encoding.Default.GetBytes(counter.ToString());
client.Send(data);
Thread runThread = new Thread(RunThread);
runThread.Start();
}
public void Connect(SimplSharpString Address, int Port)
{
try
{
if (socket != null)
{
Disconnect();
}
uniqueToken = (uint)System.DateTime.Now.TimeOfDay.Milliseconds;
socket = new UDPServer(Address.ToString(), Port, MAX_PACKET_SIZE);
if (socket.EnableUDPServer() != SocketErrorCodes.SOCKET_OK)
{
ErrorLog.Error("Socket enable error Kodi SIMPL#: {0}", socket.EnableUDPServer());
}
}
catch (Exception e)
{
ErrorLog.Exception("Exception Kodi SIMPL#: {0}", e);
}
}
public AirlockServer(int port)
{
Server = new UDPServer(port);
Server.IncomingConnectionLimit = MaxPlayers;
Clients = new List <AirlockHostedClient>();
NetDefs = new NetDefinitions();
NetDefs.LoadEntityTypes();
WorldContent = new OutgoingSyncPool(NetDefs, (ushort)SyncPoolID.WorldContent);
Entities = new List <Entity>();
Grid = MapGrid.StartingMap();
AddEntity(new DroppedItem(new Vector2(200, -200)));
foreach (MapRoom room in Grid.Rooms)
{
WorldContent.AddEntity(room);
}
}
void Start()
{
if (IsServer)
{
m_Server = new UDPServer(2);
m_Server.binaryMessageReceived += ServerOnBinaryMessageReceived;
NetworkManager.Instance.Initialize(m_Server);
m_Server.Connect(m_Ip, m_Port);
}
else
{
m_Client = new UDPClient();
m_Client.binaryMessageReceived += ClientOnBinaryMessageReceived;
NetworkManager.Instance.Initialize(m_Client);
m_Client.Connect(m_Ip, m_Port);
}
m_Player1 = GameObject.Find("p1");
m_Player1PrevPosition = m_Player1.transform.position;
}
public void ServerBehaviorReceiving(double packetLoss)
{
UDPSocket.PACKET_LOSS = packetLoss;
UDPServer <TestBehavior> server = GetServer <TestBehavior>();
server.Start();
UDPClient client = GetClient();
client.Connect();
for (uint i = 0; i < 10000; i++)
{
byte[] data = BitConverter.GetBytes(i);
client.Send(data);
}
Thread.Sleep(1000);
}
private void DataReceived(UDPServer server, int numberOfBytesReceived)
{
try
{
if (server.DataAvailable)
{
String buffer = Encoding.ASCII.GetString(server.IncomingDataBuffer, 0, numberOfBytesReceived);
OnDataReceived(this, new OnDataReceivedArgs(buffer, server.IPAddressLastMessageReceivedFrom));
}
SocketErrorCodes errorRx = udpServer.ReceiveDataAsync(DataReceived);
if (errorRx != SocketErrorCodes.SOCKET_OK)
{
throw new ApplicationException(SocketError.Text(errorRx));
}
}
catch (Exception e)
{
ErrorLog.Error("UDPSocket receive error {0}", e.Message);
OnError(this, new OnErrorArgs(e));
}
}
private List <DeviceModel> GetDeviceList(List <DeviceModel> currList)
{
List <DeviceModel> list = new List <DeviceModel>();
List <HeadInfo.机头信息> headList = HeadInfo.GetAllHead();
foreach (var item in currList)
{
HeadInfo.机头信息 head = headList.FirstOrDefault(t => t.令牌 == item.DeviceToken);
DeviceModel info = new DeviceModel();
info.RouterToken = item.RouterToken;
info.DeviceId = item.DeviceId;
info.DeviceToken = item.DeviceToken;
info.DeviceName = item.DeviceName;
info.DeviceType = item.DeviceType;
info.State = UDPServer.GetDeviceState(head);
info.SN = item.SN;
info.HeadAddress = item.HeadAddress;
list.Add(info);
}
return(list);
}
public AlarmContentViewModel()
{
//填充端口号
InitPortNames();
//填充波特率
InitBaudRates();
//填充数据位
InitDataBits();
//填充校验位
InitParity();
//填充停止位
InitStopBits();
//读取配置文件
//串口
SerialComm comm = new SerialComm();
this.PortName = PortList.SingleOrDefault(p => p.Value.ToString() == comm.PortName);
this.BaudRate = BaudRateList.SingleOrDefault(b => (int)b.Value == comm.BaudRate);
this.Parity = ParityList.SingleOrDefault(p => (Parity)p.Value == comm.Parity);
this.DataBits = DataBitList.SingleOrDefault(d => (int)d.Value == comm.DataBits);
this.StopBits = StopBitList.SingleOrDefault(s => (StopBits)s.Value == comm.StopBits);
//CopyImagePath
XDocument doc = XDocument.Load("Application.config");
var path = doc.Descendants("copyImagePath").Single();
this.CopyImagePath = path.Attribute("path").Value;
//UDP
this.UDPServer = UDPServer.GetServerFromConfig();
//Clients
this.Clients = UDPHost.GetClients();
this.ChangeSerialPortParamsCommand = new DelegateCommand <ExCommandParameter>(ChangeSerialPortsParam);
this.ChangeUDPServerParamsCommand = new DelegateCommand <ExCommandParameter>(ChangeUDPServerParams);
this.BeginningEditCommand = new DelegateCommand <ExCommandParameter>(BeginningEdit);
this.RowEditEndingCommand = new DelegateCommand <ExCommandParameter>(RowEditEnding);
this.DeleteClientCommand = new DelegateCommand <ExCommandParameter>(DeleteClient);
this.AddNewClientCommand = new DelegateCommand(AddNewClient);
this.BrowseDirCommand = new DelegateCommand(BrowseDir);
this.ChangeCopyImagePathCommand = new DelegateCommand <ExCommandParameter>(ChangeCopyImagePath);
}
void DataReceivedCallback(UDPServer client, int numberOfBytesReceived)
{
if (numberOfBytesReceived == 0)
{
return;
}
try
{
if (client.IPAddressLastMessageReceivedFrom == _ip)
{
byte[] bytes = new byte[numberOfBytesReceived];
Array.Copy(_client.IncomingDataBuffer, bytes, numberOfBytesReceived);
if (Debug)
{
CrestronConsole.PrintLine("Sennheiser - {0} - Received command: {1}",
client.IPAddressLastMessageReceivedFrom,
new string(bytes.Select(b => (char)b).ToArray()).TrimEnd('\0'));
}
var index = -1;
while ((index = Array.IndexOf(bytes, _delimiter, index + 1)) >= 0)
{
var cmdBytes = bytes.Take(index + 1);
var cmd = new string(cmdBytes.Select(b => (char)b).ToArray());
_commandReceivedAction(cmd);
}
}
}
catch (Exception ex)
{
ErrorLog.Exception("Sennheiser - " + client.IPAddressLastMessageReceivedFrom + " - Exception when receiving data.", ex);
}
if (_client != null)
{
_client.ReceiveDataAsync(DataReceivedCallback);
}
}
public void SetState(bool state)
{
if (state == currentState)
{
return;
}
if (state)
{
clientConnected = -1;
tunnelSettings = new TunnelSettings();
tunnelSettings.Load("TunnelSettings.txt");
guiData.statistics = new Statistics();
udpServer = new UDPServer(tunnelSettings, guiData.statistics);
if (tunnelSettings.tunnelServer == "")
{
tunnelServer = new TunnelServer(tunnelSettings, udpServer);
}
else
{
tunnelClient = new TunnelClient(tunnelSettings, udpServer);
}
currentState = state;
}
else
{
currentState = state;
if (tunnelClient != null)
{
tunnelClient.Stop();
tunnelClient = null;
}
tunnelServer = null;
udpServer.Stop();
udpServer = null;
tunnelSettings = null;
guiData.labelText = "Disconnected";
guiData.iconName = "gtk-no";
UpdateGUI();
}
}
protected void Host()
{
NetWorker server;
if (useTCP)
{
server = new TCPServer(64);
((TCPServer)server).Connect();
}
else
{
server = new UDPServer(64);
((UDPServer)server).Connect(ConnectionInfo.IpAddress, ushort.Parse(ConnectionInfo.ServerPort));
}
server.playerTimeout += (player, sender) =>
{
Debug.Log("Player " + player.NetworkId + " timed out");
};
Connected(server);
}
public static void Receiver(int port, UDPServer server)
{
UdpClient UdpClient = new UdpClient(port);
IPEndPoint RemoteIpEndPoint = new IPEndPoint(IPAddress.Any, 0);
Debug.Log("Receiver started successfully");
Debug.Log($"Listening on port {port}");
try
{
byte[] receiveBytes = UdpClient.Receive(ref RemoteIpEndPoint);
string receivedMessage = Encoding.ASCII.GetString(receiveBytes);
server.ReceivedMessageParse(receivedMessage, RemoteIpEndPoint.ToString());
UdpClient.Close();
server.Init();
}
catch (Exception e)
{
Debug.Log($"ERROR ON INCOMING STRING: {e.ToString()}");
UdpClient.Close();
server.Init();
}
}
public static void ListenForUpdateServers()
{
if (_udpServer != null)
{
return;
}
_udpServer = new UDPServer(IPAddress.Any, 15000, 1000);
_udpServer.EnableUDPServer();
CrestronEnvironment.ProgramStatusEventHandler += type =>
{
_programStopping = type == eProgramStatusEventType.Stopping;
if (!_programStopping)
{
return;
}
try
{
_udpServer.DisableUDPServer();
_udpServer.Dispose();
}
catch (Exception e)
{
CloudLog.Exception(e);
}
if (_listenThread.ThreadState == Thread.eThreadStates.ThreadRunning)
{
_listenThread.Abort();
}
};
_listenThread = new Thread(ProcessUdpData, null)
{
Name = "Software Update Listener"
};
}
//called when data for any output pin is requested
public void Evaluate(int SpreadMax)
{
//set server and port
if (FPort.IsChanged)
{
if (FServer == null)
{
FServer = (FIsClient[0] || FHost.IsBoygroupClient) ? new UDPServer(FPort[0] + 1) : new UDPServer(FPort[0]);
FServer.MessageReceived += FServer_MessageReceived;
FServer.Start();
}
else
{
FServer.Port = (FIsClient[0] || FHost.IsBoygroupClient) ? FPort[0] + 1 : FPort[0];
}
if (FIsClient[0] || FHost.IsBoygroupClient)
{
FRemoteServer = new IPEndPoint(IPAddress.Parse(FIsClient[0] ? FServerIP[0] : FHost.BoygroupServerIP), FPort[0]);
}
}
//read stream time
lock (FLock)
{
FStreamTime = FTime[0];
FTimeStamp = FHost.RealTime;
}
//do the evaluation for client or server
if (FIsClient[0] || FHost.IsBoygroupClient)
{
ClientEvaluate();
}
else
{
ServerEvaluate();
}
}
void StartUdpThread(object _)
{
CrestronConsole.PrintLine("UDP Read Thread Started");
IPAddress ipa;
ipa = new IPAddress(new byte[] { 0, 0, 0, 0 });
UDPServer UdpServer;
UdpServer = new UDPServer(ipa, 5568, 65534);
UdpServer.EnableUDPServer();
//server.EthernetAdapterToBindTo = EthernetAdapterType.EthernetUnknownAdapter;
//server.SocketSendOrReceiveTimeOutInMs = 3000;
// receive data
while(true)
{
int bytesRead = UdpServer.ReceiveData();
if (bytesRead > 0)
{
CrestronConsole.PrintLine("Read: " + CrestronEnvironment.TickCount.ToString());
byte[] data = new byte[RxData.Length + bytesRead];
Buffer.BlockCopy(RxData, 0, data, 0, RxData.Length);
Buffer.BlockCopy(UdpServer.IncomingDataBuffer, 0, data, RxData.Length, bytesRead);
// gathered data large enough to be a valid sacn packet.
if (data.Length >= 638)
{
CrestronConsole.PrintLine("Gathered: " + CrestronEnvironment.TickCount.ToString());
//ErrorLog.Notice("\n data at least a packet size \n");
byte[] pattern = new byte[22];
Buffer.BlockCopy(Root.RootLayerPacket, 0, pattern, 0, 22);
int? index = IndexOfPatternMatch(data, pattern, 0);
if (index != null)
{
//ErrorLog.Notice("\n found root \n");
// trim off dead bytes
if ((int)index > 0)
{
//ErrorLog.Notice("\n" + index.ToString() + " dead bytes trimed \n");
Buffer.BlockCopy(data, (int)index, data, 0, data.Length - (int)index);
Array.Resize(ref data, data.Length - (int)index);
}
// enough for one full packet?
if (data.Length < 638) // no, continue to gather
{
//ErrorLog.Notice("\n packet too small \n");
Array.Resize(ref RxData, data.Length);
RxData = data;
}
else // yes
{
// short circuit for universe, then frame, then dmp
if (CommonE1_31.CompareUShortInByteArray(new byte[] { data[113], data[114] }, Universe))
{
pattern = new byte[6];
Buffer.BlockCopy(Frame.FramingLayerPacket, 0, pattern, 0, pattern.Length);
index = IndexOfPatternMatch(data, pattern, Root.RootLayerPacket.Length);
if (index != null && index == Root.RootLayerPacket.Length)
{
pattern = new byte[10];
Buffer.BlockCopy(Dmp.DmpLayerPacket, 0, pattern, 0, pattern.Length);
index = IndexOfPatternMatch(data, pattern, Root.RootLayerPacket.Length + Frame.FramingLayerPacket.Length);
if (index != null && index == Root.RootLayerPacket.Length + Frame.FramingLayerPacket.Length)
{
Array.Resize(ref RxData, data.Length - 638);
Buffer.BlockCopy(data, 638, RxData, 0, data.Length - 638); // should handle a no MOD buffers
Array.Resize(ref data, 638);
//CrestronInvoke.BeginInvoke(ProcessSacnAsString, data);
CrestronConsole.PrintLine("Verified: " + CrestronEnvironment.TickCount.ToString());
//CrestronInvoke.BeginInvoke(ProcessSacnAsInt, data);
ProcessInline(data);
}
}
}
}
}
}
}
else
{ }
}
}
public override void init(MsgConsumer consumer)
{
for (int i = 0; i < serverCount;i++ )
{
udpServers[i] = new UDPServer(local[i], this);
}
for (int i=0; i< clientCount;i++)
{
udpClients[i] = new UDPClient(remote[i]);
}
if (clientCount > 1)
{
deliveryThreads = new SplitThread[clientCount];
for (int i=0; i < clientCount; i++)
{
deliveryThreads[i] = new SplitThread(i, udpClients[i], msgID);
}
}
base.init(consumer);
}
public void Disconnect()
{
try
{
if (socket != null)
{
socket.DisableUDPServer();
socket = null;
}
}
catch (Exception e)
{
ErrorLog.Exception("Exception Kodi SIMPL#: {0}", e);
}
}
public void Connect(SimplSharpString Address, int Port)
{
try
{
if (socket != null) Disconnect();
uniqueToken = (uint)System.DateTime.Now.TimeOfDay.Milliseconds;
socket = new UDPServer(Address.ToString(), Port, MAX_PACKET_SIZE);
if (socket.EnableUDPServer() != SocketErrorCodes.SOCKET_OK)
{
ErrorLog.Error("Socket enable error Kodi SIMPL#: {0}", socket.EnableUDPServer());
}
}
catch (Exception e)
{
ErrorLog.Exception("Exception Kodi SIMPL#: {0}", e);
}
}
public Connection(string ipAddress)
{
byte[] ip = new byte[4];
if (!string.IsNullOrEmpty(ipAddress))
{
char[] separator = new char[] { '.', ':' };
string[] sa = ipAddress.Split(separator);
if (sa.Length == 4)
{
try
{
for (uint u = 0; u <= 3; u++)
ip[u] = byte.Parse(sa[u]);
//UdpClient = new UdpClient(System.Net.Sockets.AddressFamily.InterNetwork);
//IpAddress = new System.Net.IPAddress(ip);
IPAddress ipa = new IPAddress(ip);
UdpClient = new UDPServer(ipa, 5568, 65534);
UdpClient.EnableUDPServer();
}
catch { ErrorLog.Warn("Invalid sACN channel address: " + ipAddress); }
}
}
}
/// <summary>
/// Main.
/// </summary>
/// <param name="myArgs">The arguments.</param>
public static void Main(String[] myArgs)
{
#region Start TCPServers
//var _TCPServer1 = new TCPServer(new IPv4Address(new Byte[] { 192, 168, 178, 31 }), new IPPort(2001), NewConnection =>
// {
// NewConnection.WriteToResponseStream("Hello world!" + Environment.NewLine + Environment.NewLine);
// NewConnection.Close();
// }, true);
//Console.WriteLine(_TCPServer1);
// The first line of the repose will be served from the CustomTCPConnection handler.
var _TCPServer2 = new TCPServer<CustomTCPConnection>(IPv4Address.Any, new IPPort(2002), NewConnection =>
{
NewConnection.WriteToResponseStream("...world!" + Environment.NewLine + Environment.NewLine);
NewConnection.Close();
}, true);
Console.WriteLine(_TCPServer2);
#endregion
#region Start HTTPServers
// Although the socket listens on IPv4Address.Any the service is
// configured to serve clients only on http://localhost:8181
// More details within DefaultHTTPService.cs
var _HTTPServer1 = new HTTPServer(IPv4Address.Any, new IPPort(8181), Autostart: true)
{
ServerName = "Default Hermod Demo"
};
Console.WriteLine(_HTTPServer1);
// This service uses a custom HTTPService defined within IRESTService.cs
var _HTTPServer2 = new HTTPServer<IRESTService>(IPv4Address.Any, IPPort.HTTP, Autostart: true)
{
ServerName = "Customized Hermod Demo"
};
Console.WriteLine(_HTTPServer2);
#endregion
#region UDP Servers
var _UDPServer1 = new UDPServer(new IPPort(5555), NewPacket =>
{
//NewPacket.Data = new Byte[10];
// NewPacket.Close();
}, true);
#endregion
var _client1 = new HTTPClient(IPv4Address.Localhost, IPPort.HTTP);
var _request0 = _client1.GET("/HelloWorld").
SetHost("localhorst").
AddAccept(HTTPContentType.TEXT_UTF8, 1);
var _request1 = _client1.GET("/HelloWorld").
SetHost("localhorst").
AddAccept(HTTPContentType.HTML_UTF8, 1);
//WriteRequest(_request0.EntireRequestHeader);
//_client1.Execute(_request0, response => WriteResponse(response.Content.ToUTF8String())).
// ContinueWith(HTTPClient => { WriteRequest(_request1.EntireRequestHeader); return HTTPClient.Result; }).
// ContinueWith(HTTPClient => HTTPClient.Result.Execute(_request1, response => WriteResponse(response.Content.ToUTF8String()))).
// Wait();
var _client2 = new HTTPClient(IPv4Address.Parse("188.40.47.229"), IPPort.HTTP);
var _requestA = _client2.GET("/").
SetProtocolVersion(HTTPVersion.HTTP_1_1).
SetHost("www.ahzf.de").
SetUserAgent("Hermod HTTP Client v0.1").
SetConnection("keep-alive").
AddAccept(HTTPContentType.HTML_UTF8, 1);
var _requestB = _client2.GET("/nfgj").
SetProtocolVersion(HTTPVersion.HTTP_1_1).
SetHost("www.ahzf.de").
SetUserAgent("Hermod HTTP Client v0.1").
SetConnection("keep-alive").
AddAccept(HTTPContentType.HTML_UTF8, 1);
WriteRequest(_requestA);
_client2.Execute(_requestA, response => WriteResponse(response)).
ContinueWith(Client => Client.Result.Execute(_requestB, response => WriteResponse(response)));
var _req23a = new HTTPRequestBuilder().
SetHTTPMethod (HTTPMethod.GET).
SetProtocolName ("µHTTP").
SetProtocolVersion (new HTTPVersion(2, 0)).
SetHost ("localhorst").
SetUserAgent ("Hermod µHTTP Client").
SetContent ("This the HTTP content...");
_req23a.QueryString.Add("name", "alice").
Add("friend", "bob").
Add("friend", "carol");
var _req23b = new HTTPRequestBuilder() {
HTTPMethod = HTTPMethod.GET,
ProtocolName = "µHTTP",
ProtocolVersion = new HTTPVersion(2, 0),
Host = "localhorst",
UserAgent = "Hermod µHTTP Client",
Content = "This the HTTP content...".ToUTF8Bytes()
};
// var Response = new TCPClientRequest("localhost", 80).Send("GETTT / HTTP/1.1").FinishCurrentRequest().Response;
Console.ReadLine();
Console.WriteLine("done!");
}
