public void udp_OnDeactive(UDPConnection uc)
{
buttonUdpStart.Enabled = true;
buttonUdpStop.Enabled = false;
if(FormMain.LOG_MSG)
logger.AddMsg("UDP����ֹͣ");
}
protected NetworkInterface(UDPConnection udpConnection, Logger logger)
{
Logger = logger;
ClientConnections = new NetworkConnectionPool();
In = new NetworkInput(ClientConnections);
Out = new NetworkOutput(ClientConnections);
ErrorHandling = new NetworkErrorHandling(ClientConnections, this);
UdpConnection = udpConnection;
UdpConnection.Logger = logger;
UdpConnection.OnReceiveError += ErrorHandling.HandleUDPReceiveError;
UdpConnection.OnSendError += ErrorHandling.HandleUDPSendError;
UdpConnection.InitializeReceiving();
KeepAliveInterval = 1000;
m_keepAlive = true;
HolePunchingInterval = 1000;
m_holePunching = false;
Thread keepAliveThread = new Thread(KeepAliveLoop);
keepAliveThread.Name = "Keep alive";
keepAliveThread.Start();
}
public void SetUDPConnection(UDPConnection udpConnection)
{
UdpData = new SingleBuffer <DataWrapper <byte[]> >();
UdpConnection = udpConnection;
UdpConnection.DataReceivedEvent += ReceiveUDP;
}
void Update()
{
if (Input.GetKeyDown("p"))
{
UDPConnection.Send(new Ping());
}
}
private static async void PingHandler(PacketHeader packetHeader, Connection connection, string incomingObject)
{
var ip = (IPEndPoint)connection.ConnectionInfo.RemoteEndPoint;
var localEPs = Connection.AllExistingLocalListenEndPoints();
var lep = "";
foreach (var localEP in localEPs[ConnectionType.UDP])
{
var lEp = (IPEndPoint)localEP;
if (!ip.Address.IsInSameSubnet(lEp.Address))
{
continue;
}
lep = lEp.Address.ToString();
break;
}
var sent = false;
while (!sent)
{
try
{
UDPConnection.SendObject($"PONG{lep}", "https://github.com/awooo-ph", ip, NetworkComms.DefaultSendReceiveOptions,
ApplicationLayerProtocolStatus.Enabled);
sent = true;
break;
}
catch (Exception)
{
await TaskEx.Delay(100);
}
}
}
protected override void OnStart(string[] args)
{
Common.InitialiseLogFolder();
Log.Info("OnStart");
try
{
Log.Debug("Starting UDP listener");
NetworkComms.AppendGlobalIncomingPacketHandler <string>("Plugin", PluginMessageReceived);
NetworkComms.AppendGlobalIncomingPacketHandler <string>("Commmand", MethodMessageReceived);
NetworkComms.AppendGlobalIncomingPacketHandler <string>("Method", MethodMessageReceived);
//Start listening for incoming UDP data
UDPConnection.StartListening(new IPEndPoint(IPAddress.Any, 10051));
Log.Debug("UPD Listener started");
}
catch (Exception ex)
{ Log.Error("Error starting listener", ex); }
Common.CheckComputerObject(serviceObject);
Thread loadPluginsThread = new Thread(() => LoadPlugins(serviceObject));
loadPluginsThread.Start();
// Thread loadPluginsThread = new Thread(new ThreadStart(LoadPlugins));
// loadPluginsThread.Start();
//Clock.Interval = 5000;
//Clock.Start();
//Clock.Elapsed += new System.Timers.ElapsedEventHandler(checkConnection);
Log.Info("OnStart Completed");
OSAEObjectStateManager.ObjectStateSet(serviceObject, "ON", serviceObject);
}
public static void RunExample()
{
//Ensure we use the null serializer for unmanaged connections
SendReceiveOptions options = new SendReceiveOptions <NullSerializer>();
//Setup listening for incoming unmanaged UDP broadcasts
UDPConnectionListener listener = new UDPConnectionListener(options, ApplicationLayerProtocolStatus.Disabled, UDPOptions.None);
Connection.StartListening(listener, new IPEndPoint(IPAddress.Any, 10000));
//Add a packet handler for unmanaged connections
NetworkComms.AppendGlobalIncomingUnmanagedPacketHandler((packetHeader, connection, incomingBytes) => {
Console.WriteLine("Received {0} bytes from {1}", incomingBytes.Length, connection.ConnectionInfo.RemoteEndPoint);
});
//Generate some test data to broadcast
byte[] dataToSend = new byte[] { 1, 2, 3, 4 };
//Create an unmanaged packet manually and broadcast the test data
//In future this part of the API could potentially be improved to make it clearer
using (Packet sendPacket = new Packet("Unmanaged", dataToSend, options))
UDPConnection.SendObject <byte[]>(sendPacket, new IPEndPoint(IPAddress.Broadcast, 10000), options, ApplicationLayerProtocolStatus.Disabled);
Console.WriteLine("Client done!");
Console.ReadKey();
}
private void Form1_Load(object sender, EventArgs e)
{
Connection.StartListening(ConnectionType.UDP, new IPEndPoint(IPAddress.Any, 10000));
NetworkComms.AppendGlobalIncomingPacketHandler <string>("RegisterServerAddress", (packetHeader, connection, incomingString) =>
{
try
{
if (ServerEndPoint == null)
{
var serverEndPoint = (IPEndPoint)connection.ConnectionInfo.RemoteEndPoint;
var clientEndPoint = (IPEndPoint)connection.ConnectionInfo.LocalEndPoint;
//此端口tcp用
ServerEndPoint = new IPEndPoint(serverEndPoint.Address, 10012);
button1.Enabled = true;
button1.Text = $"TCP:{ServerEndPoint}";
textBox1.Text += $"{DateTime.Now}>> server {ServerEndPoint} request connect.\r\n>";
textBox1.Text += $"{DateTime.Now}>> {clientEndPoint.Address} to {ServerEndPoint.Address} port:10001.\r\n>";
//connection.SendObject<long>("SendClientAddress", clientip);
UDPConnection.SendObject("RegisterClientAddress", clientEndPoint.Address.Address, new IPEndPoint(ServerEndPoint.Address, 10001));
}
}
catch (Exception ex)
{
textBox1.Text += $"client error:{ex.Message}";
}
});
}
void udpConnection_OnStop(UDPConnection uc)
{
try
{
this.BeginInvoke(new udp_OnDeactiveCallback(udp_OnDeactive), new object[] { uc });
}
catch { }
}
public void Datasend(byte[] buff)
{
// NetworkComms.SendObject("VOICE", buff, newUDPConn);
//newUDPConn.SendObject<byte[]>("icecream", buff);
//UDPConnection.SendObject<byte[]>("icecream", buff, new IPEndPoint(IPAddress.Parse("127.0.0.1"), 10000));
UDPConnection.SendObject("icecream", buff, new IPEndPoint(IPAddress.Parse(ip), 10000));
//Debug.WriteLine("sent");
}
IEnumerator Auth()
{
yield return(new WaitUntil(() => UDPConnection.init));
string playerName = NameGenerator.GenerateName(4, 10);
UDPConnection.Send(new AuthMessage(playerName));
}
/// <summary>
/// Processes bytes received from client
/// </summary>
/// <param name="bytes">Bytes to process and react to.</param>
/// <returns>Returns true on success, false on failure (with error in Error property)</returns>
public bool Process(MemoryStream stream, NetworkStream connection)
{
if (State == SOCKS5States.Disconnected)
{
// SOCKS5 HANDSHAKE
var packet = new SOCKS5.PacketHandshake(stream);
if (packet.METHODS != 0x0)
{
throw new UDProxyException("Authentication is not yet supported!", new NotImplementedException());
}
UDProxy.DebugInfo("SOCKS5", "Responding to handshake request");
if (Respond(new PacketReplyHandshake(), connection))
{
State = SOCKS5States.Connected;
return(true);
}
}
else if (State == SOCKS5States.Connected)
{
// SOCKS5 Connection Requests
// We're connected, so we're dealing with requests
var packet = new SOCKS5.PacketRequest(stream);
PacketReplyRequest reply = new PacketReplyRequest(packet);
// Set our client's remote endpoint expected port to the one it's given us
// Weird type casting is nessecary for safe translation
MyClient.Port = (int)BitConverter.ToUInt16(packet.PORT, 0);
// It's not ok :(
if (reply.REP != SOCKS5Protocol.REP.OK)
{
Respond(reply, connection);
return(false);
}
switch (packet.CMD)
{
case SOCKS5Protocol.CMD.BIND:
throw new UDProxyException("CMD BIND not yet supported!");
case SOCKS5Protocol.CMD.CONNECT:
throw new UDProxyException("CMD CONNECT not yet supported!");
case SOCKS5Protocol.CMD.UDP_ASSOC:
UDPConnection.TryBegin(ref reply, MyClient);
Respond(reply, connection);
break;
}
}
else
{
throw new UDProxyException("Unknown error (unimplemented function?)");
}
return(false);
}
public ClientApplication(UDPConnection connection, SynchronizationData synchronizationData) : base(connection, new NetworkLogger(true))
{
_synchronizationData = synchronizationData;
_synchronizationData.myMeditation.valueChanged += OnMeditationChanged;
SetMessageHandler <Ping>(OnPing);
SetMessageHandler <ConnectionResponse>(OnConnectionResponse);
SetMessageHandler <PlayerData>(OnOpponentUpdate);
}
private void Awake()
{
connection = new UDPConnection(port);
connection.Listen(DataReceived, 5000);
serializer = new MessageSerializer();
messageFactory = new MessageFactory();
RegisterMessageHandlers();
}
public void udp_OnDeactive(UDPConnection uc)
{
buttonUdpStart.Enabled = true;
buttonUdpStop.Enabled = false;
if (FormMain.LOG_MSG)
{
logger.AddMsg("UDP服务停止");
}
}
void Awake()
{
_connection = new UDPConnection(port);
_connection.Listen(CommandReceived, 5000);
_serializer = new MessageSerializer();
_messageFactory = new MessageFactory();
RegisterMessageHandlers();
}
new void Start()
{
base.Start();
_messageHandler = GetComponentInChildren <MatchMessageHandler>();
_matchTcp = GetComponent <MatchTCPConnection>();
_matchUdp = GetComponent <UDPConnection>();
_messageHandler.NewMatch();
}
public UDPTraversal(string udpServerIP, int udpServerPort, Action <string, IPEndPoint> connected)
{
_serverIP = IPAddress.Parse(udpServerIP);
_serverPort = udpServerPort;
_connected = connected;
_connection = CreateUDPConnection();
NetworkComms.AppendGlobalIncomingPacketHandler <string>(PacketType.REQ_UDPP2PConnect, Connected);
}
void Start()
{
GameObject matchHandler = GameObject.Find("MatchHandler");
if (matchHandler != null)
{
_matchTcp = matchHandler.GetComponent <MatchTCPConnection>();
_matchUdp = matchHandler.GetComponent <UDPConnection>();
}
}
public void CloseChannelUDP()
{
_comm.SendCommand(PepperlCmd.ScanStop,
PepperlConst.ParamUdpHandle, _handle);
_udp?.Close();
_udp = null;
_handle = null;
}
public ServerApplication(UDPConnection connection, bool registerFakeClient) : base(connection, new NetworkLogger(false))
{
if (registerFakeClient)
{
RegisterFakeClient();
}
SetMessageHandler <ConnectionRequest>(OnConnectionRequest);
SetMessageHandler <MeditationMessage>(OnMeditationMessage);
SetMessageHandler <ReadyNotification>(OnReadyNotification);
}
public void SendBroadcast <T>(Node baseNode, T request)
{
var nodesInRange = _baseNodeRepository.GetAllInRange(baseNode);
foreach (var node in nodesInRange)
{
var endPoint = new IPEndPoint(IPAddress.Broadcast, node.Id);
// typeof(T).Name -> pobiera nazwe klasy
UDPConnection.SendObject(typeof(T).Name, request, endPoint, new SendReceiveOptions <ProtobufSerializer>());
}
}
static void Main(string[] args)
{
string messageToSend = "This is a message To Send";
string messageFromServer = UDPConnection.GetConnection(new ConnectionInfo("127.0.0.1", 10000), UDPOptions.None).SendReceiveObject <string>("Message", "Message", 2000, messageToSend);
Console.WriteLine("Server said '{0}'.", messageFromServer);
Console.WriteLine("Press any key to exit.");
Console.ReadKey(true);
NetworkComms.Shutdown();
}
public void Start()
{
listener = new TCPConnectionListener(tcpPort);
listener.ClientConnected += listener_ClientConnected;
listener.Listening = true;
udpConnection = new UDPConnection();
udpConnection.PacketRecievedAsync +=
new BaseConnection.PacketRecievedAsyncEventHandler(udpConnection_PacketRecievedAsync);
udpConnection.Bind(new IPEndPoint(IPAddress.Any, udpPort));
udpConnection.Receiving = true;
}
/// <summary>
/// Ajoute une connexion UDP aux connexions suivies
/// </summary>
/// <param name="board">Carte associée à la connexion</param>
/// <param name="ip">Adresse IP de la connexion</param>
/// <param name="inPort">Port d'entrée pour le PC</param>
/// <param name="outPort">Port de sortie pour le PC</param>
/// <returns>La connexion créée</returns>
private static UDPConnection AddUDPConnection(Board board, IPAddress ip, int inPort, int outPort)
{
UDPConnection output = new UDPConnection();
output.Connect(ip, inPort, outPort);
UDPBoardConnection.Add(board, output);
EnableConnection.Add(board, true);
AllConnections.Add(output);
output.ConnectionChecker.SendConnectionTest += ConnexionCheck_SendConnectionTestUDP;
return(output);
}
public static bool To(string ip, int timeout = 10000)
{
var conn = UDPConnection.GetConnection(new ConnectionInfo(ip, Port), UDPOptions.Handshake, true, false);
try {
conn.EstablishConnection();
} catch (Exception e) {
return(false);
}
conn.CloseConnection(false);
return(true);
}
public Window1()
{
InitializeGameObserver();
InitializeUI();
InitializeComponent();
// TODO this connections are only hardcoded for testing purpose
var connection = new UDPConnection(new IPEndPoint(IPAddress.Parse("192.168.178.22"), 1337));
var connection2 = new UDPConnection(new IPEndPoint(IPAddress.Parse("192.168.178.24"), 1337));
connections.Add(connection);
connections.Add(connection2);
}
static void Main(string[] args)
{
NetworkComms.AppendGlobalIncomingPacketHandler <string>("Message", (packetHeader, connection, incomingString) =>
{
Console.WriteLine("This is the message you received " + incomingString);
connection.SendObject("Message", incomingString + " relayed by server.");
});
UDPConnection.StartListening(true);
Console.WriteLine("Server ready. Press any key to shutdown server.");
Console.ReadKey(true);
NetworkComms.Shutdown();
}
/// <summary>
/// Stops a plugin based on a method
/// </summary>
/// <param name="method">The method containing the information of the plugin to stop</param>
private void StopPlugin(OSAEMethod method)
{
foreach (Plugin p in plugins)
{
if (p.PluginName == method.Parameter1)
{
OSAEObject obj = OSAEObjectManager.GetObjectByName(p.PluginName);
if (obj != null)
{
disablePlugin(p);
UDPConnection.SendObject("Plugin", p.PluginName + " | " + p.Enabled.ToString() + " | " + p.PluginVersion + " | Stopped | " + p.LatestAvailableVersion + " | " + p.PluginType + " | " + Common.ComputerName, new IPEndPoint(IPAddress.Broadcast, 10051));
}
}
}
}
private UDPConnection CreateUDPConnection()
{
try
{
var connectionInfo = new ConnectionInfo(ConnectionType.UDP, ShortGuid.NewGuid(), new IPEndPoint(IPAddress.Any, 0), true);
var connection = UDPConnection.GetConnection(connectionInfo, UDPOptions.None);
return(connection);
}
catch (Exception ex)
{
Trace.TraceError("[ UDP ] CreateLocalUDPConnection, Error = {0}", ex.Message);
}
return(null);
}
public void udp_OnActive(UDPConnection uc, bool suc)
{
if(suc)
{
buttonUdpStart.Enabled = false;
buttonUdpStop.Enabled = true;
if(FormMain.LOG_MSG)
logger.AddMsg("UDP�������");
}
else
{
buttonUdpStart.Enabled = true;
buttonUdpStop.Enabled = false;
MessageBox.Show(StrConst.ERR_PORT_UDP);
}
}
// Use this for initialization
void Start()
{
//Start UDP Connection part
UDPConnection udpConnection = new UDPConnection(port);
//End UDP Connection part
skullPrefab = Resources.Load("Skull Prefabs/skullCT"); // Assets/Resources/Skull Prefabs/skullCT.FBX
skullObject = (GameObject)Instantiate(skullPrefab, new Vector3(0, 0, 0), Quaternion.identity);
skullCachedTransform = GetComponent <Transform>();
if (skullObject.transform)
{
skullCachedPosition = skullObject.transform.position;
}
}
/// <inheritdoc />
internal override void StartListening(EndPoint desiredLocalListenEndPoint, bool useRandomPortFailOver)
{
if (desiredLocalListenEndPoint.GetType() != typeof(IPEndPoint)) throw new ArgumentException("Invalid desiredLocalListenEndPoint type provided.", "desiredLocalListenEndPoint");
if (IsListening) throw new InvalidOperationException("Attempted to call StartListening when already listening.");
IPEndPoint desiredLocalListenIPEndPoint = (IPEndPoint)desiredLocalListenEndPoint;
try
{
UDPConnection = new UDPConnection(new ConnectionInfo(ConnectionType.UDP, new IPEndPoint(IPAddress.Any, 0), desiredLocalListenIPEndPoint, ApplicationLayerProtocol, this), ListenerDefaultSendReceiveOptions, UDPOptions, true);
}
catch (SocketException)
{
if (useRandomPortFailOver)
{
try
{
UDPConnection = new UDPConnection(new ConnectionInfo(ConnectionType.UDP, new IPEndPoint(IPAddress.Any, 0), new IPEndPoint(desiredLocalListenIPEndPoint.Address, 0), ApplicationLayerProtocol, this), ListenerDefaultSendReceiveOptions, UDPOptions, true);
}
catch (SocketException)
{
//If we get another socket exception this appears to be a bad IP. We will just ignore this IP
if (NetworkComms.LoggingEnabled) NetworkComms.Logger.Error("It was not possible to open a random port on " + desiredLocalListenIPEndPoint.Address + ". This endPoint may not support listening or possibly try again using a different port.");
throw new CommsSetupShutdownException("It was not possible to open a random port on " + desiredLocalListenIPEndPoint.Address + ". This endPoint may not support listening or possibly try again using a different port.");
}
}
else
{
if (NetworkComms.LoggingEnabled) NetworkComms.Logger.Error("It was not possible to open port #" + desiredLocalListenIPEndPoint.Port.ToString() + " on " + desiredLocalListenIPEndPoint.Address + ". This endPoint may not support listening or possibly try again using a different port.");
throw new CommsSetupShutdownException("It was not possible to open port #" + desiredLocalListenIPEndPoint.Port.ToString() + " on " + desiredLocalListenIPEndPoint.Address + ". This endPoint may not support listening or possibly try again using a different port.");
}
}
#if WINDOWS_PHONE || NETFX_CORE
this.LocalListenEndPoint = new IPEndPoint(IPAddress.Parse(UDPConnection.socket.Information.LocalAddress.DisplayName.ToString()), int.Parse(UDPConnection.socket.Information.LocalPort));
#else
this.LocalListenEndPoint = (IPEndPoint)UDPConnection.udpClient.LocalIPEndPoint;
#endif
this.IsListening = true;
}
void udpConnection_OnStop(UDPConnection uc)
{
try
{
this.BeginInvoke(new udp_OnDeactiveCallback(udp_OnDeactive), new object[] { uc });
}
catch { }
}
