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);
}
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;
}
/// <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>
/// </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>
/// 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);
}
/// <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>
/// 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>
/// 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);
}
}
// 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);
}
public void RemovePacketHandler(PacketType packetType, PacketCallback eventHandler)
{
m_udpServer.PacketEvents.UnregisterEvent(packetType, eventHandler);
}
