public PacketHandler(int packetID, string name, int length, PacketCallback callback) { this.m_Name = name; this.m_Callback = callback; this.m_PacketID = packetID; this.m_Length = length; }
void HandleReceivedBuffer(CClientSocket ClientSocket, int ConnectionIndex, EConnectionType ConnectionType, byte[] buffer) { byte packet = buffer[0]; byte[] arguments = null; if (buffer.Length > 1) { arguments = new byte[buffer.Length - 1]; Buffer.BlockCopy(buffer, 1, arguments, 0, arguments.Length); } foreach (SPacketCallback PacketCallback in PacketCallbacks) { if (PacketCallback.ConnectionType != ConnectionType) { continue; } if (PacketCallback.Packet != packet) { continue; } PacketCallback.OnPacketCallback(ClientSocket, ConnectionIndex, arguments); break; } }
/// <summary> /// </summary> /// <param name="client"></param> internal AssetManager(SecondLife client) { slClient = client; // Used to upload small assets, or as an initial start packet for large transfers PacketCallback AssetUploadCompleteCallback = new PacketCallback(AssetUploadCompleteCallbackHandler); slClient.Network.RegisterCallback(PacketType.AssetUploadComplete, AssetUploadCompleteCallback); // Transfer Packets for downloading large assets PacketCallback TransferInfoCallback = new PacketCallback(TransferInfoCallbackHandler); slClient.Network.RegisterCallback(PacketType.TransferInfo, TransferInfoCallback); PacketCallback TransferPacketCallback = new PacketCallback(TransferPacketCallbackHandler); slClient.Network.RegisterCallback(PacketType.TransferPacket, TransferPacketCallback); // XFer packets for uploading large assets PacketCallback ConfirmXferPacketCallback = new PacketCallback(ConfirmXferPacketCallbackHandler); slClient.Network.RegisterCallback(PacketType.ConfirmXferPacket, ConfirmXferPacketCallback); PacketCallback RequestXferCallback = new PacketCallback(RequestXferCallbackHandler); slClient.Network.RegisterCallback(PacketType.RequestXfer, RequestXferCallback); }
/// <summary> /// Unregister an event handler /// </summary> /// <param name="packetType">Packet type to unregister the handler for</param> /// <param name="eventHandler">Callback to be unregistered</param> public void UnregisterEvent(PacketType packetType, PacketCallback eventHandler) { lock (_EventTable) { if (_EventTable.ContainsKey(packetType) && _EventTable[packetType] != null) _EventTable[packetType] -= eventHandler; } }
private static void OutputDataReceived(PacketCallback callback, DataReceivedEventArgs e) { var parameters = e.Data.Split(';') .Where(parameter => !string.IsNullOrEmpty(parameter)) .Select(parameter => { var kvpRaw = parameter.Split('='); return(new KeyValuePair <string, string>(kvpRaw[0], kvpRaw[1])); }) .ToDictionary(kvp => kvp.Key, kvp => kvp.Value); var srcAddress = parameters["src_address"]; var dstAddress = parameters["dst_address"]; var packetHeader = new FfxivArrPacketHeader { Unknown0 = ulong.Parse(parameters["unknown_0"]), Unknown8 = ulong.Parse(parameters["unknown_8"]), Timestamp = ulong.Parse(parameters["timestamp"]), Size = uint.Parse(parameters["total_size"]), ConnectionType = ushort.Parse(parameters["connection_type"]), SegmentCount = ushort.Parse(parameters["segment_count"]), Unknown20 = byte.Parse(parameters["unknown_20"]), IsCompressed = parameters["is_compressed"] == "true", Unknown24 = ushort.Parse(parameters["unknown_24"]), }; var segmentHeader = new FfxivArrSegmentHeader { Size = uint.Parse(parameters["total_size"]), SourceActor = uint.Parse(parameters["source_actor"]), TargetActor = uint.Parse(parameters["target_actor"]), Type = (FfxivArrSegmentType)ushort.Parse(parameters["segment_type"]), Padding = 0, }; FfxivArrIpcHeader ipcHeader = null; if (segmentHeader.Type == FfxivArrSegmentType.Ipc) { ipcHeader = new FfxivArrIpcHeader { Reserved = 0x0014, Type = ushort.Parse(parameters["ipc_type"]), Padding = 0, ServerId = ushort.Parse(parameters["server_id"]), Timestamp = uint.Parse(parameters["ipc_timestamp"]), Padding1 = 0, }; } var remainder = parameters["remainder_data"].Split(' ') .Select(byte.Parse) .ToArray(); callback(srcAddress, dstAddress, packetHeader, segmentHeader, ipcHeader, remainder); }
/// <summary> /// Unregister an event handler /// </summary> /// <param name="packetType">Packet type to unregister the handler for</param> /// <param name="eventHandler">Callback to be unregistered</param> public void UnregisterEvent(PacketType packetType, PacketCallback eventHandler) { lock (_EventTable) { if (_EventTable.ContainsKey(packetType) && _EventTable[packetType] != null) { _EventTable[packetType] -= eventHandler; } } }
/// <summary> /// Register an event handler /// </summary> /// <remarks>Use PacketType.Default to fire this event on every /// incoming packet</remarks> /// <param name="packetType">Packet type to register the handler for</param> /// <param name="eventHandler">Callback to be fired</param> public void RegisterEvent(PacketType packetType, PacketCallback eventHandler) { lock (_EventTable) { if (_EventTable.ContainsKey(packetType)) _EventTable[packetType] += eventHandler; else _EventTable[packetType] = eventHandler; } }
public void AddCallback <T>(PacketCallback <T> callback) where T : struct, IServerPacket { byte type = (new T().Type); #if DEBUG if (callbacks[type] != null) { throw new InvalidOperationException("Packet callback with this type was already registered"); } #endif callbacks[type] = (msg) => ProcessCallback(msg, callback); }
private static void ProcessCallback <T>(NetIncomingMessage msg, PacketCallback <T> callback) where T : struct, IServerPacket { T packet = default(T); #if NETWORK_DEBUG__ Console.WriteLine(" - Packet<" + typeof(T).Name + ">"); #endif packet.SenderConnection = msg.SenderConnection; packet.Read(msg); callback(ref packet); }
/// <summary> /// Register an event handler /// </summary> /// <remarks>Use PacketType.Default to fire this event on every /// incoming packet</remarks> /// <param name="packetType">Packet type to register the handler for</param> /// <param name="eventHandler">Callback to be fired</param> public void RegisterEvent(PacketType packetType, PacketCallback eventHandler) { lock (_EventTable) { if (_EventTable.ContainsKey(packetType)) { _EventTable[packetType] += eventHandler; } else { _EventTable[packetType] = eventHandler; } } }
public override void Reply(PacketCallback packet) { //Usually you would send your network reply here, but for this example we will just deserialize our buffer //And display its contents. var response = new Message(packet.Response); var tree = response.Deserialize <TreeResponse>(); foreach (var folder in tree.Tree.RootFolder.ChildFolders) { foreach (var file in folder.Files) { Console.WriteLine(file.Path); } } }
/// <summary> /// Register an event handler /// </summary> /// <remarks>Use PacketType.Default to fire this event on every /// incoming packet</remarks> /// <param name="packetType">Packet type to register the handler for</param> /// <param name="eventHandler">Callback to be fired</param> public void RegisterEvent(PacketType packetType, PacketCallback eventHandler) { lock (m_eventTable) { PacketCallback callback; if (m_eventTable.TryGetValue(packetType, out callback)) { callback += eventHandler; } else { m_eventTable.Add(packetType, eventHandler); } } }
public override void HandlePacket(Consumer consumer, Packet packet) { _consumer = consumer; _packet = packet; _message = _packet.Message; _callback = new PacketCallback { Endpoint = _message.Header.Endpoint }; switch (_message.Header.Endpoint) { case "RequestFileTree": RequestFileTree(); break; } }
public NetWrapper(string directory, string netDllPath, string host, ushort port) { string idFile = Path.Join(directory, "id"); Directory.SetCurrentDirectory(directory); packetInterceptorDelegate = PacketInterceptor; int result = InitNetWrapper(netDllPath, idFile, host, port, 1024, "C# server", packetInterceptorDelegate); if (result != 0) { throw new Exception($"Unable to start net wrapper. Error code {result}"); } Debug.WriteLine($"Net wrapper initialized: {result}"); }
public Status ObserveOutputStream <T, U>(string streamName, PacketCallback <T, U> packetCallback, bool observeTimestampBounds, out GCHandle callbackHandle) where T : Packet <U> { NativePacketCallback nativePacketCallback = (IntPtr _graphPtr, IntPtr packetPtr) => { Status status = null; try { T packet = (T)Activator.CreateInstance(typeof(T), packetPtr, false); status = packetCallback(packet); } catch (Exception e) { status = Status.FailedPrecondition(e.ToString()); } return(status.mpPtr); }; callbackHandle = GCHandle.Alloc(nativePacketCallback, GCHandleType.Pinned); return(ObserveOutputStream(streamName, nativePacketCallback, observeTimestampBounds)); }
public NetWrapper(string directory, string netDllPath, string host, ushort port) { string idFile = Path.Join(directory, "id"); Directory.SetCurrentDirectory(directory); this.packetInterceptorDelegate = PacketInterceptor; int result = InitNetWrapper(Path.Join(directory, netDllPath), idFile, host, port, 1024, "C# server", this.packetInterceptorDelegate); if (result < 0) { throw new Exception($"Unable to start net wrapper. Error code: {result} ({((NetWrapperErrorCode)result)})"); } this.id = (ushort)result; Debug.WriteLine($"Net wrapper initialized: {result}"); }
/// <summary> /// Register an event handler /// </summary> /// <remarks>Use PacketType.Default to fire this event on every /// incoming packet</remarks> /// <param name="packetType">Packet type to register the handler for</param> /// <param name="eventHandler">Callback to be fired</param> /// <param name="isAsync">True if this callback should be ran /// asynchronously, false to run it synchronous</param> public void RegisterEvent(PacketType packetType, EventHandler <PacketReceivedEventArgs> eventHandler, bool isAsync) { lock (_EventTable) { PacketCallback callback; if (_EventTable.TryGetValue(packetType, out callback)) { callback.Callback += eventHandler; callback.IsAsync = callback.IsAsync || isAsync; } else { callback = new PacketCallback(eventHandler, isAsync); _EventTable[packetType] = callback; } } }
public AvatarManager(SecondLife client) { Client = client; Avatars = new Dictionary <LLUUID, Avatar>(); //Callback Dictionaries AvatarPropertiesCallbacks = new Dictionary <LLUUID, AvatarPropertiesCallback>(); AvatarStatisticsCallbacks = new Dictionary <LLUUID, AvatarStatisticsCallback>(); AvatarIntrestsCallbacks = new Dictionary <LLUUID, AvatarIntrestsCallback>(); // Friend notification callback PacketCallback callback = new PacketCallback(FriendNotificationHandler); Client.Network.RegisterCallback(PacketType.OnlineNotification, callback); Client.Network.RegisterCallback(PacketType.OfflineNotification, callback); Client.Network.RegisterCallback(PacketType.UUIDNameReply, new PacketCallback(GetAgentNameHandler)); Client.Network.RegisterCallback(PacketType.AvatarPropertiesReply, new PacketCallback(AvatarPropertiesHandler)); Client.Network.RegisterCallback(PacketType.AvatarStatisticsReply, new PacketCallback(AvatarStatisticsHandler)); Client.Network.RegisterCallback(PacketType.AvatarInterestsReply, new PacketCallback(AvatarIntrestsHandler)); }
/// <summary> /// Constructor, aka 'CallBack Central' - Setup callbacks for packets related to our avatar /// </summary> /// <param name="client"></param> public MainAvatar(SecondLife client) { PacketCallback callback; Client = client; TeleportMessage = ""; // Create emtpy vectors for now HomeLookAt = HomePosition = Position = LookAt = new LLVector3(); Rotation = new LLQuaternion(); // Coarse location callback Client.Network.RegisterCallback(PacketType.CoarseLocationUpdate, new PacketCallback(CoarseLocationHandler)); // Teleport callbacks callback = new PacketCallback(TeleportHandler); Client.Network.RegisterCallback(PacketType.TeleportStart, callback); Client.Network.RegisterCallback(PacketType.TeleportProgress, callback); Client.Network.RegisterCallback(PacketType.TeleportFailed, callback); Client.Network.RegisterCallback(PacketType.TeleportFinish, callback); // Instant Message callback Client.Network.RegisterCallback(PacketType.ImprovedInstantMessage, new PacketCallback(InstantMessageHandler)); // Chat callback Client.Network.RegisterCallback(PacketType.ChatFromSimulator, new PacketCallback(ChatHandler)); TeleportTimer = new Timer(18000); TeleportTimer.Elapsed += new ElapsedEventHandler(TeleportTimerEvent); TeleportTimeout = false; // Movement complete callback Client.Network.RegisterCallback(PacketType.AgentMovementComplete, new PacketCallback(MovementCompleteHandler)); // Health callback Client.Network.RegisterCallback(PacketType.HealthMessage, new PacketCallback(HealthHandler)); // Money callbacks callback = new PacketCallback(BalanceHandler); Client.Network.RegisterCallback(PacketType.MoneyBalanceReply, callback); Client.Network.RegisterCallback(PacketType.MoneySummaryReply, callback); Client.Network.RegisterCallback(PacketType.AdjustBalance, callback); }
/// <summary> /// Unregister an event handler /// </summary> /// <param name="packetType">Packet type to unregister the handler for</param> /// <param name="eventHandler">Callback to be unregistered</param> public void UnregisterEvent(PacketType packetType, PacketCallback eventHandler) { lock (m_eventTable) { PacketCallback callback; if (m_eventTable.TryGetValue(packetType, out callback)) { if (callback != null) { callback -= eventHandler; } if (callback == null || callback.GetInvocationList().Length == 0) { m_eventTable.Remove(packetType); } } } }
public void BeginSniffingFromFile(PacketCallback callback, string fileName) { if (this.readFileProcess == null) { return; } this.readFileProcess = Process.Start(new ProcessStartInfo { FileName = this.tempExePath, Arguments = !string.IsNullOrEmpty(fileName) ? $"-f {fileName}" : "", CreateNoWindow = true, UseShellExecute = false, RedirectStandardOutput = true, }); this.readFileProcess.OutputDataReceived += (sender, e) => OutputDataReceived(callback, e); this.readFileProcess.BeginOutputReadLine(); this.job.AddProcess(this.readFileProcess.Handle); }
public Status ObserveOutputStream <T, U>(string streamName, PacketCallback <T, U> packetCallback, out GCHandle callbackHandle) where T : Packet <U> { NativePacketCallback nativePacketCallback = (IntPtr packetPtr) => { Status status = null; try { T packet = (T)Activator.CreateInstance(typeof(T), packetPtr, false); status = packetCallback(packet); } catch (Exception e) { status = Status.FailedPrecondition(e.ToString()); } return(status.mpPtr); }; callbackHandle = GCHandle.Alloc(nativePacketCallback, GCHandleType.Pinned); UnsafeNativeMethods.mp_CalculatorGraph__ObserveOutputStream__PKc_PF(mpPtr, streamName, nativePacketCallback, out var statusPtr).Assert(); GC.KeepAlive(this); return(new Status(statusPtr)); }
private void ProcessCallback <T>(NetIncomingMessage msg, bool isUnconnected, PacketCallback <T> callback) where T : struct, IClientPacket { T packet = default(T); if (isUnconnected && !packet.SupportsUnconnected) { #if NETWORK_DEBUG__ Console.WriteLine(" - Packet<" + typeof(T).Name + "> not allowed for unconnected clients!"); #endif return; } #if NETWORK_DEBUG__ Console.WriteLine(" - Packet<" + typeof(T).Name + ">"); #endif packet.SenderConnection = msg.SenderConnection; packet.Read(msg); callback(ref packet); }
public Status ObserveOutputStream <TPacket, TValue>(string streamName, PacketCallback <TPacket, TValue> packetCallback, bool observeTimestampBounds, out GCHandle callbackHandle) where TPacket : Packet <TValue>, new() { NativePacketCallback nativePacketCallback = (IntPtr graphPtr, int streamId, IntPtr packetPtr) => { try { var packet = Packet <TValue> .Create <TPacket>(packetPtr, false); packetCallback(packet); return(Status.StatusArgs.Ok()); } catch (Exception e) { return(Status.StatusArgs.Internal(e.ToString())); } }; callbackHandle = GCHandle.Alloc(nativePacketCallback, GCHandleType.Pinned); return(ObserveOutputStream(streamName, 0, nativePacketCallback, observeTimestampBounds)); }
/// <summary> /// Start the serial communication. /// </summary> private void serialportForm_FormClosing(object sender, FormClosingEventArgs e) { SerialportForm spf = sender as SerialportForm; serialSession = new SerialComm(spf.serialPort.PortName, spf.serialPort.BaudRate, (byte)ModuleId_t.Api_e); serialSession.MaxSendRepetition = 3; // Register all handler methods for the various comm events. serialSession.RegisterPacketReceivedHandler(telegramReceivedCallback); serialSession.RegisterPacketSentHandler(telegramSentCallback); serialSession.RegisterAckTimeoutHandler(ackTimeoutCallback); serialSession.RegisterNackFailHandler(nackFailCallback); serialSession.RegisterResponseTimeoutHandler(responseTimeoutCallback); serialSession.ackNackReceived += new SerialComm.PacketEvent(ackNackReceivedHandler); ApiDataReceived += new PacketCallback(API_ReceiveData); serialSession.Start(); // Comm Labels lblPort.Text = "Portname: " + spf.serialPort.PortName; lblBaud.Text = "Baudrate: " + spf.serialPort.BaudRate; }
// Each InventorySystem needs to be initialized with a client and root folder. public InventoryManager(SecondLife client, LLUUID rootFolder) { slClient = client; if (slAssetManager == null) { slAssetManager = new AssetManager(slClient); } InvPacketHelper = new InventoryPacketHelper(slClient.Network.AgentID, slClient.Network.SessionID); uuidRootFolder = rootFolder; resetFoldersByUUID(); // Setup the callback for Inventory Downloads PacketCallback InventoryDescendentsCallback = new PacketCallback(InventoryDescendentsHandler); slClient.Network.RegisterCallback(PacketType.InventoryDescendents, InventoryDescendentsCallback); // Setup the callback for Inventory Creation Update PacketCallback UpdateCreateInventoryItemCallback = new PacketCallback(UpdateCreateInventoryItemHandler); slClient.Network.RegisterCallback(PacketType.UpdateCreateInventoryItem, UpdateCreateInventoryItemCallback); }
/// <summary> /// Unregister an event handler /// </summary> /// <param name="packetType">Packet type to unregister the handler for</param> /// <param name="eventHandler">Callback to be unregistered</param> public void UnregisterEvent(PacketType packetType, PacketCallback eventHandler) { lock (m_eventTable) { PacketCallback callback; if (m_eventTable.TryGetValue(packetType, out callback)) { if (callback != null) callback -= eventHandler; if (callback == null || callback.GetInvocationList().Length == 0) m_eventTable.Remove(packetType); } } }
public Status ObserveOutputStream <T, U>(string streamName, PacketCallback <T, U> packetCallback, out GCHandle callbackHandle) where T : Packet <U> { return(ObserveOutputStream(streamName, packetCallback, false, out callbackHandle)); }
public PacketHandler(int packetID, int length, PacketCallback callback) { this.m_Callback = callback; this.m_PacketID = packetID; this.m_Length = length; }
/// <summary> /// Register an event handler /// </summary> /// <remarks>Use PacketType.Default to fire this event on every /// incoming packet</remarks> /// <param name="packetType">Packet type to register the handler for</param> /// <param name="eventHandler">Callback to be fired</param> /// <param name="isAsync">True if this callback should be ran /// asynchronously, false to run it synchronous</param> public void RegisterEvent(PacketType packetType, EventHandler<PacketReceivedEventArgs> eventHandler, bool isAsync) { lock (_EventTable) { PacketCallback callback; if (_EventTable.TryGetValue(packetType, out callback)) { callback.Callback += eventHandler; callback.IsAsync = callback.IsAsync || isAsync; } else { callback = new PacketCallback(eventHandler, isAsync); _EventTable[packetType] = callback; } } }
public void AddPacketHandler(PacketType packetType, PacketCallback eventHandler) { m_udpServer.PacketEvents.RegisterEvent(packetType, eventHandler); }
private static void Register(int packetID, string name, int length, PacketCallback callback) { if (m_Handlers[packetID] != null) { Debug.Trace("Warning: Duplicate packet handlers registered. (packetID=0x{0:X2})", packetID); } m_Handlers[packetID] = new PacketHandler(packetID, name, length, callback); }
/// <summary> /// Unregister an event handler for a packet. This is a low level event /// interface and should only be used if you are doing something not /// supported in libsecondlife /// </summary> /// <param name="type">Packet type this callback is registered with</param> /// <param name="callback">Callback to stop firing events for</param> public void UnregisterCallback(PacketType type, PacketCallback callback) { PacketEvents.UnregisterEvent(type, callback); }
private static extern int InitNetWrapper(string path, string idFile, string ip, ushort port, uint playerCount, string serverName, PacketCallback callback);
public AvatarManager(SecondLife client) { Client = client; Avatars = new Dictionary<LLUUID, Avatar>(); //Callback Dictionaries AvatarPropertiesCallbacks = new Dictionary<LLUUID, AvatarPropertiesCallback>(); AvatarStatisticsCallbacks = new Dictionary<LLUUID, AvatarStatisticsCallback>(); AvatarIntrestsCallbacks = new Dictionary<LLUUID, AvatarIntrestsCallback>(); // Friend notification callback PacketCallback callback = new PacketCallback(FriendNotificationHandler); Client.Network.RegisterCallback(PacketType.OnlineNotification, callback); Client.Network.RegisterCallback(PacketType.OfflineNotification, callback); Client.Network.RegisterCallback(PacketType.UUIDNameReply, new PacketCallback(GetAgentNameHandler)); Client.Network.RegisterCallback(PacketType.AvatarPropertiesReply, new PacketCallback(AvatarPropertiesHandler)); Client.Network.RegisterCallback(PacketType.AvatarStatisticsReply, new PacketCallback(AvatarStatisticsHandler)); Client.Network.RegisterCallback(PacketType.AvatarInterestsReply, new PacketCallback(AvatarIntrestsHandler)); }
public void RegisterCallback <T>(PacketCallback <T> callback) where T : struct, IServerPacket { byte type = (new T().Type); callbacks[type] = (msg) => ProcessCallback(msg, callback); }
/// <summary> /// Register an event handler /// </summary> /// <remarks>Use PacketType.Default to fire this event on every /// incoming packet</remarks> /// <param name="packetType">Packet type to register the handler for</param> /// <param name="eventHandler">Callback to be fired</param> public void RegisterEvent(PacketType packetType, PacketCallback eventHandler) { lock (m_eventTable) { PacketCallback callback; if (m_eventTable.TryGetValue(packetType, out callback)) callback += eventHandler; else m_eventTable.Add(packetType, eventHandler); } }
public void RegisterPacketCallback(PacketType type, PacketCallback callback) { packetEvents.RegisterEvent(type, callback); }
public void Subscribe(Packet id, PacketCallback func) { if (!_subscriptions.ContainsKey(id)) { _subscriptions[id] = null; } _subscriptions[id] += func; }
/// <summary> /// /// </summary> /// <param name="type"></param> /// <param name="callback"></param> public void RegisterCallback(PacketType type, PacketCallback callback) { if (!Callbacks.ContainsKey(type)) { Callbacks[type] = new List<PacketCallback>(); } List<PacketCallback> callbackArray = Callbacks[type]; callbackArray.Add(callback); }
/// <summary> /// The Reply function is used to handle completed messages. /// If the message has come over wire, then you can use the SyncObject to set to send replies to a pre-defined object. /// See the example application for more details. /// </summary> public abstract void Reply(PacketCallback packet);
/// <summary> /// /// </summary> /// <param name="type"></param> /// <param name="callback"></param> public void UnregisterCallback(PacketType type, PacketCallback callback) { if (!Callbacks.ContainsKey(type)) { Client.Log("Trying to unregister a callback for packet " + type.ToString() + " when no callbacks are setup for that packet", Helpers.LogLevel.Info); return; } List<PacketCallback> callbackArray = Callbacks[type]; if (callbackArray.Contains(callback)) { callbackArray.Remove(callback); } else { Client.Log("Trying to unregister a non-existant callback for packet " + type.ToString(), Helpers.LogLevel.Info); } }
public void RemovePacketHandler(PacketType packetType, PacketCallback eventHandler) { m_udpServer.PacketEvents.UnregisterEvent(packetType, eventHandler); }