aboutsummaryrefslogtreecommitdiffstatshomepage
path: root/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs
diff options
context:
space:
mode:
Diffstat (limited to 'OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs')
-rw-r--r--OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs1557
1 files changed, 1537 insertions, 20 deletions
diff --git a/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs b/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs
index 222fb1b..07466e2 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs
+++ b/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs
@@ -4424,11 +4424,62 @@ namespace OpenSim.Region.ClientStack.LindenUDP
4424 AddLocalPacketHandler(PacketType.GetScriptRunning, HandleGetScriptRunning); 4424 AddLocalPacketHandler(PacketType.GetScriptRunning, HandleGetScriptRunning);
4425 AddLocalPacketHandler(PacketType.SetScriptRunning, HandleSetScriptRunning); 4425 AddLocalPacketHandler(PacketType.SetScriptRunning, HandleSetScriptRunning);
4426 AddLocalPacketHandler(PacketType.ScriptReset, HandleScriptReset); 4426 AddLocalPacketHandler(PacketType.ScriptReset, HandleScriptReset);
4427 //AddLocalPacketHandler(PacketType.ChatFromViewer, HandleChatFromViewer); 4427 AddLocalPacketHandler(PacketType.ActivateGestures, HandleActivateGestures);
4428 //AddLocalPacketHandler(PacketType.ChatFromViewer, HandleChatFromViewer); 4428 AddLocalPacketHandler(PacketType.DeactivateGestures, HandleDeactivateGestures);
4429 //AddLocalPacketHandler(PacketType.ChatFromViewer, HandleChatFromViewer); 4429 AddLocalPacketHandler(PacketType.ObjectOwner, HandleObjectOwner);
4430 //AddLocalPacketHandler(PacketType.ChatFromViewer, HandleChatFromViewer); 4430 AddLocalPacketHandler(PacketType.AgentFOV, HandleAgentFOV);
4431 4431 AddLocalPacketHandler(PacketType.ViewerStats, HandleViewerStats);
4432 AddLocalPacketHandler(PacketType.MapItemRequest, HandleMapItemRequest);
4433 AddLocalPacketHandler(PacketType.TransferAbort, HandleTransferAbort);
4434 AddLocalPacketHandler(PacketType.MuteListRequest, HandleMuteListRequest);
4435 AddLocalPacketHandler(PacketType.UseCircuitCode, HandleUseCircuitCode);
4436 AddLocalPacketHandler(PacketType.AgentHeightWidth, HandleAgentHeightWidth);
4437 AddLocalPacketHandler(PacketType.InventoryDescendents, HandleInventoryDescendents);
4438 AddLocalPacketHandler(PacketType.DirPlacesQuery, HandleDirPlacesQuery);
4439 AddLocalPacketHandler(PacketType.DirFindQuery, HandleDirFindQuery);
4440 AddLocalPacketHandler(PacketType.DirLandQuery, HandleDirLandQuery);
4441 AddLocalPacketHandler(PacketType.DirPopularQuery, HandleDirPopularQuery);
4442 AddLocalPacketHandler(PacketType.DirClassifiedQuery, HandleDirClassifiedQuery);
4443 AddLocalPacketHandler(PacketType.EventInfoRequest, HandleEventInfoRequest);
4444 AddLocalPacketHandler(PacketType.OfferCallingCard, HandleOfferCallingCard);
4445 AddLocalPacketHandler(PacketType.AcceptCallingCard, HandleAcceptCallingCard);
4446 AddLocalPacketHandler(PacketType.DeclineCallingCard, HandleDeclineCallingCard);
4447 AddLocalPacketHandler(PacketType.ActivateGroup, HandleActivateGroup);
4448 AddLocalPacketHandler(PacketType.GroupTitlesRequest, HandleGroupTitlesRequest);
4449 AddLocalPacketHandler(PacketType.GroupProfileRequest, HandleGroupProfileRequest);
4450 AddLocalPacketHandler(PacketType.GroupMembersRequest, HandleGroupMembersRequest);
4451 AddLocalPacketHandler(PacketType.GroupRoleDataRequest, HandleGroupRoleDataRequest);
4452 AddLocalPacketHandler(PacketType.GroupRoleMembersRequest, HandleGroupRoleMembersRequest);
4453 AddLocalPacketHandler(PacketType.CreateGroupRequest, HandleCreateGroupRequest);
4454 AddLocalPacketHandler(PacketType.UpdateGroupInfo, HandleUpdateGroupInfo);
4455 AddLocalPacketHandler(PacketType.SetGroupAcceptNotices, HandleSetGroupAcceptNotices);
4456 AddLocalPacketHandler(PacketType.GroupTitleUpdate, HandleGroupTitleUpdate);
4457 AddLocalPacketHandler(PacketType.ParcelDeedToGroup, HandleParcelDeedToGroup);
4458 AddLocalPacketHandler(PacketType.GroupNoticesListRequest, HandleGroupNoticesListRequest);
4459 AddLocalPacketHandler(PacketType.GroupNoticeRequest, HandleGroupNoticeRequest);
4460 AddLocalPacketHandler(PacketType.GroupRoleUpdate, HandleGroupRoleUpdate);
4461 AddLocalPacketHandler(PacketType.GroupRoleChanges, HandleGroupRoleChanges);
4462 AddLocalPacketHandler(PacketType.JoinGroupRequest, HandleJoinGroupRequest);
4463 AddLocalPacketHandler(PacketType.LeaveGroupRequest, HandleLeaveGroupRequest);
4464 AddLocalPacketHandler(PacketType.EjectGroupMemberRequest, HandleEjectGroupMemberRequest);
4465 AddLocalPacketHandler(PacketType.InviteGroupRequest, HandleInviteGroupRequest);
4466 AddLocalPacketHandler(PacketType.StartLure, HandleStartLure);
4467 AddLocalPacketHandler(PacketType.TeleportLureRequest, HandleTeleportLureRequest);
4468 AddLocalPacketHandler(PacketType.ClassifiedInfoRequest, HandleClassifiedInfoRequest);
4469 AddLocalPacketHandler(PacketType.ClassifiedInfoUpdate, HandleClassifiedInfoUpdate);
4470 AddLocalPacketHandler(PacketType.ClassifiedDelete, HandleClassifiedDelete);
4471 AddLocalPacketHandler(PacketType.ClassifiedGodDelete, HandleClassifiedGodDelete);
4472 AddLocalPacketHandler(PacketType.EventGodDelete, HandleEventGodDelete);
4473 AddLocalPacketHandler(PacketType.EventNotificationAddRequest, HandleEventNotificationAddRequest);
4474 AddLocalPacketHandler(PacketType.EventNotificationRemoveRequest, HandleEventNotificationRemoveRequest);
4475 AddLocalPacketHandler(PacketType.RetrieveInstantMessages, HandleRetrieveInstantMessages);
4476 AddLocalPacketHandler(PacketType.PickDelete, HandlePickDelete);
4477 AddLocalPacketHandler(PacketType.PickGodDelete, HandlePickGodDelete);
4478 AddLocalPacketHandler(PacketType.PickInfoUpdate, HandlePickInfoUpdate);
4479 AddLocalPacketHandler(PacketType.AvatarNotesUpdate, HandleAvatarNotesUpdate);
4480 AddLocalPacketHandler(PacketType.AvatarInterestsUpdate, HandleAvatarInterestsUpdate);
4481 AddLocalPacketHandler(PacketType.GrantUserRights, HandleGrantUserRights);
4482 AddLocalPacketHandler(PacketType.PlacesQuery, HandlePlacesQuery);
4432 } 4483 }
4433 4484
4434 #region Packet Handlers 4485 #region Packet Handlers
@@ -7868,7 +7919,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
7868 return true; 7919 return true;
7869 case "texturecommit": 7920 case "texturecommit":
7870 OnCommitEstateTerrainTextureRequest(this); 7921 OnCommitEstateTerrainTextureRequest(this);
7871 break; 7922 return true;
7872 case "setregionterrain": 7923 case "setregionterrain":
7873 if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false)) 7924 if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false))
7874 { 7925 {
@@ -7954,7 +8005,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
7954 if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false)) 8005 if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false))
7955 { 8006 {
7956 if (messagePacket.ParamList.Length < 5) 8007 if (messagePacket.ParamList.Length < 5)
7957 break; 8008 return true;
7958 UUID invoice = messagePacket.MethodData.Invoice; 8009 UUID invoice = messagePacket.MethodData.Invoice;
7959 UUID SenderID = new UUID(Utils.BytesToString(messagePacket.ParamList[2].Parameter)); 8010 UUID SenderID = new UUID(Utils.BytesToString(messagePacket.ParamList[2].Parameter));
7960 string SenderName = Utils.BytesToString(messagePacket.ParamList[3].Parameter); 8011 string SenderName = Utils.BytesToString(messagePacket.ParamList[3].Parameter);
@@ -8333,7 +8384,1459 @@ namespace OpenSim.Region.ClientStack.LindenUDP
8333 8384
8334 #endregion Script Packets 8385 #endregion Script Packets
8335 8386
8387 #region Gesture Managment
8388
8389 private bool HandleActivateGestures(IClientAPI sender, Packet Pack)
8390 {
8391 ActivateGesturesPacket activateGesturePacket = (ActivateGesturesPacket)Pack;
8392
8393 #region Packet Session and User Check
8394 if (m_checkPackets)
8395 {
8396 if (activateGesturePacket.AgentData.SessionID != SessionId ||
8397 activateGesturePacket.AgentData.AgentID != AgentId)
8398 return true;
8399 }
8400 #endregion
8401
8402 ActivateGesture handlerActivateGesture = OnActivateGesture;
8403 if (handlerActivateGesture != null)
8404 {
8405 handlerActivateGesture(this,
8406 activateGesturePacket.Data[0].AssetID,
8407 activateGesturePacket.Data[0].ItemID);
8408 }
8409 else m_log.Error("Null pointer for activateGesture");
8410
8411 return true;
8412 }
8413 private bool HandleDeactivateGestures(IClientAPI sender, Packet Pack)
8414 {
8415 DeactivateGesturesPacket deactivateGesturePacket = (DeactivateGesturesPacket)Pack;
8416
8417 #region Packet Session and User Check
8418 if (m_checkPackets)
8419 {
8420 if (deactivateGesturePacket.AgentData.SessionID != SessionId ||
8421 deactivateGesturePacket.AgentData.AgentID != AgentId)
8422 return true;
8423 }
8424 #endregion
8425
8426 DeactivateGesture handlerDeactivateGesture = OnDeactivateGesture;
8427 if (handlerDeactivateGesture != null)
8428 {
8429 handlerDeactivateGesture(this, deactivateGesturePacket.Data[0].ItemID);
8430 }
8431 return true;
8432 }
8433 private bool HandleObjectOwner(IClientAPI sender, Packet Pack)
8434 {
8435 ObjectOwnerPacket objectOwnerPacket = (ObjectOwnerPacket)Pack;
8436
8437 #region Packet Session and User Check
8438 if (m_checkPackets)
8439 {
8440 if (objectOwnerPacket.AgentData.SessionID != SessionId ||
8441 objectOwnerPacket.AgentData.AgentID != AgentId)
8442 return true;
8443 }
8444 #endregion
8445
8446 List<uint> localIDs = new List<uint>();
8447
8448 foreach (ObjectOwnerPacket.ObjectDataBlock d in objectOwnerPacket.ObjectData)
8449 localIDs.Add(d.ObjectLocalID);
8450
8451 ObjectOwner handlerObjectOwner = OnObjectOwner;
8452 if (handlerObjectOwner != null)
8453 {
8454 handlerObjectOwner(this, objectOwnerPacket.HeaderData.OwnerID, objectOwnerPacket.HeaderData.GroupID, localIDs);
8455 }
8456 return true;
8457 }
8458
8459 #endregion Gesture Managment
8460
8461 private bool HandleAgentFOV(IClientAPI sender, Packet Pack)
8462 {
8463 AgentFOVPacket fovPacket = (AgentFOVPacket)Pack;
8464
8465 if (fovPacket.FOVBlock.GenCounter > m_agentFOVCounter)
8466 {
8467 m_agentFOVCounter = fovPacket.FOVBlock.GenCounter;
8468 AgentFOV handlerAgentFOV = OnAgentFOV;
8469 if (handlerAgentFOV != null)
8470 {
8471 handlerAgentFOV(this, fovPacket.FOVBlock.VerticalAngle);
8472 }
8473 }
8474 return true;
8475 }
8476
8477 #region unimplemented handlers
8478
8479 private bool HandleViewerStats(IClientAPI sender, Packet Pack)
8480 {
8481 // TODO: handle this packet
8482 //m_log.Warn("[CLIENT]: unhandled ViewerStats packet");
8483 return true;
8484 }
8485
8486 private bool HandleMapItemRequest(IClientAPI sender, Packet Pack)
8487 {
8488 MapItemRequestPacket mirpk = (MapItemRequestPacket)Pack;
8489
8490 #region Packet Session and User Check
8491 if (m_checkPackets)
8492 {
8493 if (mirpk.AgentData.SessionID != SessionId ||
8494 mirpk.AgentData.AgentID != AgentId)
8495 return true;
8496 }
8497 #endregion
8498
8499 //m_log.Debug(mirpk.ToString());
8500 MapItemRequest handlerMapItemRequest = OnMapItemRequest;
8501 if (handlerMapItemRequest != null)
8502 {
8503 handlerMapItemRequest(this, mirpk.AgentData.Flags, mirpk.AgentData.EstateID,
8504 mirpk.AgentData.Godlike, mirpk.RequestData.ItemType,
8505 mirpk.RequestData.RegionHandle);
8506
8507 }
8508 return true;
8509 }
8510
8511 private bool HandleTransferAbort(IClientAPI sender, Packet Pack)
8512 {
8513 return true;
8514 }
8515
8516 private bool HandleMuteListRequest(IClientAPI sender, Packet Pack)
8517 {
8518 MuteListRequestPacket muteListRequest =
8519 (MuteListRequestPacket)Pack;
8520
8521 #region Packet Session and User Check
8522 if (m_checkPackets)
8523 {
8524 if (muteListRequest.AgentData.SessionID != SessionId ||
8525 muteListRequest.AgentData.AgentID != AgentId)
8526 return true;
8527 }
8528 #endregion
8529
8530 MuteListRequest handlerMuteListRequest = OnMuteListRequest;
8531 if (handlerMuteListRequest != null)
8532 {
8533 handlerMuteListRequest(this, muteListRequest.MuteData.MuteCRC);
8534 }
8535 else
8536 {
8537 SendUseCachedMuteList();
8538 }
8539 return true;
8540 }
8541
8542 private bool HandleUseCircuitCode(IClientAPI sender, Packet Pack)
8543 {
8544 return true;
8545 }
8546
8547 private bool HandleAgentHeightWidth(IClientAPI sender, Packet Pack)
8548 {
8549 return true;
8550 }
8551
8552 private bool HandleInventoryDescendents(IClientAPI sender, Packet Pack)
8553 {
8554 return true;
8555 }
8556
8557 #endregion unimplemented handlers
8558
8559 #region Dir handlers
8560
8561 private bool HandleDirPlacesQuery(IClientAPI sender, Packet Pack)
8562 {
8563 DirPlacesQueryPacket dirPlacesQueryPacket = (DirPlacesQueryPacket)Pack;
8564 //m_log.Debug(dirPlacesQueryPacket.ToString());
8565
8566 #region Packet Session and User Check
8567 if (m_checkPackets)
8568 {
8569 if (dirPlacesQueryPacket.AgentData.SessionID != SessionId ||
8570 dirPlacesQueryPacket.AgentData.AgentID != AgentId)
8571 return true;
8572 }
8573 #endregion
8574
8575 DirPlacesQuery handlerDirPlacesQuery = OnDirPlacesQuery;
8576 if (handlerDirPlacesQuery != null)
8577 {
8578 handlerDirPlacesQuery(this,
8579 dirPlacesQueryPacket.QueryData.QueryID,
8580 Utils.BytesToString(
8581 dirPlacesQueryPacket.QueryData.QueryText),
8582 (int)dirPlacesQueryPacket.QueryData.QueryFlags,
8583 (int)dirPlacesQueryPacket.QueryData.Category,
8584 Utils.BytesToString(
8585 dirPlacesQueryPacket.QueryData.SimName),
8586 dirPlacesQueryPacket.QueryData.QueryStart);
8587 }
8588 return true;
8589 }
8590
8591 private bool HandleDirFindQuery(IClientAPI sender, Packet Pack)
8592 {
8593 DirFindQueryPacket dirFindQueryPacket = (DirFindQueryPacket)Pack;
8594
8595 #region Packet Session and User Check
8596 if (m_checkPackets)
8597 {
8598 if (dirFindQueryPacket.AgentData.SessionID != SessionId ||
8599 dirFindQueryPacket.AgentData.AgentID != AgentId)
8600 return true;
8601 }
8602 #endregion
8603
8604 DirFindQuery handlerDirFindQuery = OnDirFindQuery;
8605 if (handlerDirFindQuery != null)
8606 {
8607 handlerDirFindQuery(this,
8608 dirFindQueryPacket.QueryData.QueryID,
8609 Utils.BytesToString(
8610 dirFindQueryPacket.QueryData.QueryText),
8611 dirFindQueryPacket.QueryData.QueryFlags,
8612 dirFindQueryPacket.QueryData.QueryStart);
8613 }
8614 return true;
8615 }
8616
8617 private bool HandleDirLandQuery(IClientAPI sender, Packet Pack)
8618 {
8619 DirLandQueryPacket dirLandQueryPacket = (DirLandQueryPacket)Pack;
8620
8621 #region Packet Session and User Check
8622 if (m_checkPackets)
8623 {
8624 if (dirLandQueryPacket.AgentData.SessionID != SessionId ||
8625 dirLandQueryPacket.AgentData.AgentID != AgentId)
8626 return true;
8627 }
8628 #endregion
8629
8630 DirLandQuery handlerDirLandQuery = OnDirLandQuery;
8631 if (handlerDirLandQuery != null)
8632 {
8633 handlerDirLandQuery(this,
8634 dirLandQueryPacket.QueryData.QueryID,
8635 dirLandQueryPacket.QueryData.QueryFlags,
8636 dirLandQueryPacket.QueryData.SearchType,
8637 dirLandQueryPacket.QueryData.Price,
8638 dirLandQueryPacket.QueryData.Area,
8639 dirLandQueryPacket.QueryData.QueryStart);
8640 }
8641 return true;
8642 }
8643
8644 private bool HandleDirPopularQuery(IClientAPI sender, Packet Pack)
8645 {
8646 DirPopularQueryPacket dirPopularQueryPacket = (DirPopularQueryPacket)Pack;
8647
8648 #region Packet Session and User Check
8649 if (m_checkPackets)
8650 {
8651 if (dirPopularQueryPacket.AgentData.SessionID != SessionId ||
8652 dirPopularQueryPacket.AgentData.AgentID != AgentId)
8653 return true;
8654 }
8655 #endregion
8656
8657 DirPopularQuery handlerDirPopularQuery = OnDirPopularQuery;
8658 if (handlerDirPopularQuery != null)
8659 {
8660 handlerDirPopularQuery(this,
8661 dirPopularQueryPacket.QueryData.QueryID,
8662 dirPopularQueryPacket.QueryData.QueryFlags);
8663 }
8664 return true;
8665 }
8666
8667 private bool HandleDirClassifiedQuery(IClientAPI sender, Packet Pack)
8668 {
8669 DirClassifiedQueryPacket dirClassifiedQueryPacket = (DirClassifiedQueryPacket)Pack;
8670
8671 #region Packet Session and User Check
8672 if (m_checkPackets)
8673 {
8674 if (dirClassifiedQueryPacket.AgentData.SessionID != SessionId ||
8675 dirClassifiedQueryPacket.AgentData.AgentID != AgentId)
8676 return true;
8677 }
8678 #endregion
8679
8680 DirClassifiedQuery handlerDirClassifiedQuery = OnDirClassifiedQuery;
8681 if (handlerDirClassifiedQuery != null)
8682 {
8683 handlerDirClassifiedQuery(this,
8684 dirClassifiedQueryPacket.QueryData.QueryID,
8685 Utils.BytesToString(
8686 dirClassifiedQueryPacket.QueryData.QueryText),
8687 dirClassifiedQueryPacket.QueryData.QueryFlags,
8688 dirClassifiedQueryPacket.QueryData.Category,
8689 dirClassifiedQueryPacket.QueryData.QueryStart);
8690 }
8691 return true;
8692 }
8693
8694 private bool HandleEventInfoRequest(IClientAPI sender, Packet Pack)
8695 {
8696 EventInfoRequestPacket eventInfoRequestPacket = (EventInfoRequestPacket)Pack;
8697
8698 #region Packet Session and User Check
8699 if (m_checkPackets)
8700 {
8701 if (eventInfoRequestPacket.AgentData.SessionID != SessionId ||
8702 eventInfoRequestPacket.AgentData.AgentID != AgentId)
8703 return true;
8704 }
8705 #endregion
8706
8707 if (OnEventInfoRequest != null)
8708 {
8709 OnEventInfoRequest(this, eventInfoRequestPacket.EventData.EventID);
8710 }
8711 return true;
8712 }
8713
8714 #endregion
8715
8716 #region Calling Card
8336 8717
8718 private bool HandleOfferCallingCard(IClientAPI sender, Packet Pack)
8719 {
8720 OfferCallingCardPacket offerCallingCardPacket = (OfferCallingCardPacket)Pack;
8721
8722 #region Packet Session and User Check
8723 if (m_checkPackets)
8724 {
8725 if (offerCallingCardPacket.AgentData.SessionID != SessionId ||
8726 offerCallingCardPacket.AgentData.AgentID != AgentId)
8727 return true;
8728 }
8729 #endregion
8730
8731 if (OnOfferCallingCard != null)
8732 {
8733 OnOfferCallingCard(this,
8734 offerCallingCardPacket.AgentBlock.DestID,
8735 offerCallingCardPacket.AgentBlock.TransactionID);
8736 }
8737 return true;
8738 }
8739
8740 private bool HandleAcceptCallingCard(IClientAPI sender, Packet Pack)
8741 {
8742 AcceptCallingCardPacket acceptCallingCardPacket = (AcceptCallingCardPacket)Pack;
8743
8744 #region Packet Session and User Check
8745 if (m_checkPackets)
8746 {
8747 if (acceptCallingCardPacket.AgentData.SessionID != SessionId ||
8748 acceptCallingCardPacket.AgentData.AgentID != AgentId)
8749 return true;
8750 }
8751 #endregion
8752
8753 // according to http://wiki.secondlife.com/wiki/AcceptCallingCard FolderData should
8754 // contain exactly one entry
8755 if (OnAcceptCallingCard != null && acceptCallingCardPacket.FolderData.Length > 0)
8756 {
8757 OnAcceptCallingCard(this,
8758 acceptCallingCardPacket.TransactionBlock.TransactionID,
8759 acceptCallingCardPacket.FolderData[0].FolderID);
8760 }
8761 return true;
8762 }
8763
8764 private bool HandleDeclineCallingCard(IClientAPI sender, Packet Pack)
8765 {
8766 DeclineCallingCardPacket declineCallingCardPacket = (DeclineCallingCardPacket)Pack;
8767
8768 #region Packet Session and User Check
8769 if (m_checkPackets)
8770 {
8771 if (declineCallingCardPacket.AgentData.SessionID != SessionId ||
8772 declineCallingCardPacket.AgentData.AgentID != AgentId)
8773 return true;
8774 }
8775 #endregion
8776
8777 if (OnDeclineCallingCard != null)
8778 {
8779 OnDeclineCallingCard(this,
8780 declineCallingCardPacket.TransactionBlock.TransactionID);
8781 }
8782 return true;
8783 }
8784
8785 #endregion Calling Card
8786
8787 #region Groups
8788
8789 private bool HandleActivateGroup(IClientAPI sender, Packet Pack)
8790 {
8791 ActivateGroupPacket activateGroupPacket = (ActivateGroupPacket)Pack;
8792
8793 #region Packet Session and User Check
8794 if (m_checkPackets)
8795 {
8796 if (activateGroupPacket.AgentData.SessionID != SessionId ||
8797 activateGroupPacket.AgentData.AgentID != AgentId)
8798 return true;
8799 }
8800 #endregion
8801
8802 if (m_GroupsModule != null)
8803 {
8804 m_GroupsModule.ActivateGroup(this, activateGroupPacket.AgentData.GroupID);
8805 m_GroupsModule.SendAgentGroupDataUpdate(this);
8806 }
8807 return true;
8808
8809 }
8810
8811 private bool HandleGroupTitlesRequest(IClientAPI sender, Packet Pack)
8812 {
8813 GroupTitlesRequestPacket groupTitlesRequest =
8814 (GroupTitlesRequestPacket)Pack;
8815
8816 #region Packet Session and User Check
8817 if (m_checkPackets)
8818 {
8819 if (groupTitlesRequest.AgentData.SessionID != SessionId ||
8820 groupTitlesRequest.AgentData.AgentID != AgentId)
8821 return true;
8822 }
8823 #endregion
8824
8825 if (m_GroupsModule != null)
8826 {
8827 GroupTitlesReplyPacket groupTitlesReply = (GroupTitlesReplyPacket)PacketPool.Instance.GetPacket(PacketType.GroupTitlesReply);
8828
8829 groupTitlesReply.AgentData =
8830 new GroupTitlesReplyPacket.AgentDataBlock();
8831
8832 groupTitlesReply.AgentData.AgentID = AgentId;
8833 groupTitlesReply.AgentData.GroupID =
8834 groupTitlesRequest.AgentData.GroupID;
8835
8836 groupTitlesReply.AgentData.RequestID =
8837 groupTitlesRequest.AgentData.RequestID;
8838
8839 List<GroupTitlesData> titles =
8840 m_GroupsModule.GroupTitlesRequest(this,
8841 groupTitlesRequest.AgentData.GroupID);
8842
8843 groupTitlesReply.GroupData =
8844 new GroupTitlesReplyPacket.GroupDataBlock[titles.Count];
8845
8846 int i = 0;
8847 foreach (GroupTitlesData d in titles)
8848 {
8849 groupTitlesReply.GroupData[i] =
8850 new GroupTitlesReplyPacket.GroupDataBlock();
8851
8852 groupTitlesReply.GroupData[i].Title =
8853 Util.StringToBytes256(d.Name);
8854 groupTitlesReply.GroupData[i].RoleID =
8855 d.UUID;
8856 groupTitlesReply.GroupData[i].Selected =
8857 d.Selected;
8858 i++;
8859 }
8860
8861 OutPacket(groupTitlesReply, ThrottleOutPacketType.Task);
8862 }
8863 return true;
8864 }
8865 private bool HandleGroupProfileRequest(IClientAPI sender, Packet Pack)
8866 {
8867 GroupProfileRequestPacket groupProfileRequest =
8868 (GroupProfileRequestPacket)Pack;
8869
8870 #region Packet Session and User Check
8871 if (m_checkPackets)
8872 {
8873 if (groupProfileRequest.AgentData.SessionID != SessionId ||
8874 groupProfileRequest.AgentData.AgentID != AgentId)
8875 return true;
8876 }
8877 #endregion
8878
8879 if (m_GroupsModule != null)
8880 {
8881 GroupProfileReplyPacket groupProfileReply = (GroupProfileReplyPacket)PacketPool.Instance.GetPacket(PacketType.GroupProfileReply);
8882
8883 groupProfileReply.AgentData = new GroupProfileReplyPacket.AgentDataBlock();
8884 groupProfileReply.GroupData = new GroupProfileReplyPacket.GroupDataBlock();
8885 groupProfileReply.AgentData.AgentID = AgentId;
8886
8887 GroupProfileData d = m_GroupsModule.GroupProfileRequest(this,
8888 groupProfileRequest.GroupData.GroupID);
8889
8890 groupProfileReply.GroupData.GroupID = d.GroupID;
8891 groupProfileReply.GroupData.Name = Util.StringToBytes256(d.Name);
8892 groupProfileReply.GroupData.Charter = Util.StringToBytes1024(d.Charter);
8893 groupProfileReply.GroupData.ShowInList = d.ShowInList;
8894 groupProfileReply.GroupData.MemberTitle = Util.StringToBytes256(d.MemberTitle);
8895 groupProfileReply.GroupData.PowersMask = d.PowersMask;
8896 groupProfileReply.GroupData.InsigniaID = d.InsigniaID;
8897 groupProfileReply.GroupData.FounderID = d.FounderID;
8898 groupProfileReply.GroupData.MembershipFee = d.MembershipFee;
8899 groupProfileReply.GroupData.OpenEnrollment = d.OpenEnrollment;
8900 groupProfileReply.GroupData.Money = d.Money;
8901 groupProfileReply.GroupData.GroupMembershipCount = d.GroupMembershipCount;
8902 groupProfileReply.GroupData.GroupRolesCount = d.GroupRolesCount;
8903 groupProfileReply.GroupData.AllowPublish = d.AllowPublish;
8904 groupProfileReply.GroupData.MaturePublish = d.MaturePublish;
8905 groupProfileReply.GroupData.OwnerRole = d.OwnerRole;
8906
8907 OutPacket(groupProfileReply, ThrottleOutPacketType.Task);
8908 }
8909 return true;
8910 }
8911 private bool HandleGroupMembersRequest(IClientAPI sender, Packet Pack)
8912 {
8913 GroupMembersRequestPacket groupMembersRequestPacket =
8914 (GroupMembersRequestPacket)Pack;
8915
8916 #region Packet Session and User Check
8917 if (m_checkPackets)
8918 {
8919 if (groupMembersRequestPacket.AgentData.SessionID != SessionId ||
8920 groupMembersRequestPacket.AgentData.AgentID != AgentId)
8921 return true;
8922 }
8923 #endregion
8924
8925 if (m_GroupsModule != null)
8926 {
8927 List<GroupMembersData> members =
8928 m_GroupsModule.GroupMembersRequest(this, groupMembersRequestPacket.GroupData.GroupID);
8929
8930 int memberCount = members.Count;
8931
8932 while (true)
8933 {
8934 int blockCount = members.Count;
8935 if (blockCount > 40)
8936 blockCount = 40;
8937
8938 GroupMembersReplyPacket groupMembersReply = (GroupMembersReplyPacket)PacketPool.Instance.GetPacket(PacketType.GroupMembersReply);
8939
8940 groupMembersReply.AgentData =
8941 new GroupMembersReplyPacket.AgentDataBlock();
8942 groupMembersReply.GroupData =
8943 new GroupMembersReplyPacket.GroupDataBlock();
8944 groupMembersReply.MemberData =
8945 new GroupMembersReplyPacket.MemberDataBlock[
8946 blockCount];
8947
8948 groupMembersReply.AgentData.AgentID = AgentId;
8949 groupMembersReply.GroupData.GroupID =
8950 groupMembersRequestPacket.GroupData.GroupID;
8951 groupMembersReply.GroupData.RequestID =
8952 groupMembersRequestPacket.GroupData.RequestID;
8953 groupMembersReply.GroupData.MemberCount = memberCount;
8954
8955 for (int i = 0; i < blockCount; i++)
8956 {
8957 GroupMembersData m = members[0];
8958 members.RemoveAt(0);
8959
8960 groupMembersReply.MemberData[i] =
8961 new GroupMembersReplyPacket.MemberDataBlock();
8962 groupMembersReply.MemberData[i].AgentID =
8963 m.AgentID;
8964 groupMembersReply.MemberData[i].Contribution =
8965 m.Contribution;
8966 groupMembersReply.MemberData[i].OnlineStatus =
8967 Util.StringToBytes256(m.OnlineStatus);
8968 groupMembersReply.MemberData[i].AgentPowers =
8969 m.AgentPowers;
8970 groupMembersReply.MemberData[i].Title =
8971 Util.StringToBytes256(m.Title);
8972 groupMembersReply.MemberData[i].IsOwner =
8973 m.IsOwner;
8974 }
8975 OutPacket(groupMembersReply, ThrottleOutPacketType.Task);
8976 if (members.Count == 0)
8977 return true;
8978 }
8979 }
8980 return true;
8981 }
8982 private bool HandleGroupRoleDataRequest(IClientAPI sender, Packet Pack)
8983 {
8984 GroupRoleDataRequestPacket groupRolesRequest =
8985 (GroupRoleDataRequestPacket)Pack;
8986
8987 #region Packet Session and User Check
8988 if (m_checkPackets)
8989 {
8990 if (groupRolesRequest.AgentData.SessionID != SessionId ||
8991 groupRolesRequest.AgentData.AgentID != AgentId)
8992 return true;
8993 }
8994 #endregion
8995
8996 if (m_GroupsModule != null)
8997 {
8998 GroupRoleDataReplyPacket groupRolesReply = (GroupRoleDataReplyPacket)PacketPool.Instance.GetPacket(PacketType.GroupRoleDataReply);
8999
9000 groupRolesReply.AgentData =
9001 new GroupRoleDataReplyPacket.AgentDataBlock();
9002
9003 groupRolesReply.AgentData.AgentID = AgentId;
9004
9005 groupRolesReply.GroupData =
9006 new GroupRoleDataReplyPacket.GroupDataBlock();
9007
9008 groupRolesReply.GroupData.GroupID =
9009 groupRolesRequest.GroupData.GroupID;
9010
9011 groupRolesReply.GroupData.RequestID =
9012 groupRolesRequest.GroupData.RequestID;
9013
9014 List<GroupRolesData> titles =
9015 m_GroupsModule.GroupRoleDataRequest(this,
9016 groupRolesRequest.GroupData.GroupID);
9017
9018 groupRolesReply.GroupData.RoleCount =
9019 titles.Count;
9020
9021 groupRolesReply.RoleData =
9022 new GroupRoleDataReplyPacket.RoleDataBlock[titles.Count];
9023
9024 int i = 0;
9025 foreach (GroupRolesData d in titles)
9026 {
9027 groupRolesReply.RoleData[i] =
9028 new GroupRoleDataReplyPacket.RoleDataBlock();
9029
9030 groupRolesReply.RoleData[i].RoleID =
9031 d.RoleID;
9032 groupRolesReply.RoleData[i].Name =
9033 Util.StringToBytes256(d.Name);
9034 groupRolesReply.RoleData[i].Title =
9035 Util.StringToBytes256(d.Title);
9036 groupRolesReply.RoleData[i].Description =
9037 Util.StringToBytes1024(d.Description);
9038 groupRolesReply.RoleData[i].Powers =
9039 d.Powers;
9040 groupRolesReply.RoleData[i].Members =
9041 (uint)d.Members;
9042
9043 i++;
9044 }
9045
9046 OutPacket(groupRolesReply, ThrottleOutPacketType.Task);
9047 }
9048 return true;
9049 }
9050 private bool HandleGroupRoleMembersRequest(IClientAPI sender, Packet Pack)
9051 {
9052 GroupRoleMembersRequestPacket groupRoleMembersRequest =
9053 (GroupRoleMembersRequestPacket)Pack;
9054
9055 #region Packet Session and User Check
9056 if (m_checkPackets)
9057 {
9058 if (groupRoleMembersRequest.AgentData.SessionID != SessionId ||
9059 groupRoleMembersRequest.AgentData.AgentID != AgentId)
9060 return true;
9061 }
9062 #endregion
9063
9064 if (m_GroupsModule != null)
9065 {
9066 List<GroupRoleMembersData> mappings =
9067 m_GroupsModule.GroupRoleMembersRequest(this,
9068 groupRoleMembersRequest.GroupData.GroupID);
9069
9070 int mappingsCount = mappings.Count;
9071
9072 while (mappings.Count > 0)
9073 {
9074 int pairs = mappings.Count;
9075 if (pairs > 32)
9076 pairs = 32;
9077
9078 GroupRoleMembersReplyPacket groupRoleMembersReply = (GroupRoleMembersReplyPacket)PacketPool.Instance.GetPacket(PacketType.GroupRoleMembersReply);
9079 groupRoleMembersReply.AgentData =
9080 new GroupRoleMembersReplyPacket.AgentDataBlock();
9081 groupRoleMembersReply.AgentData.AgentID =
9082 AgentId;
9083 groupRoleMembersReply.AgentData.GroupID =
9084 groupRoleMembersRequest.GroupData.GroupID;
9085 groupRoleMembersReply.AgentData.RequestID =
9086 groupRoleMembersRequest.GroupData.RequestID;
9087
9088 groupRoleMembersReply.AgentData.TotalPairs =
9089 (uint)mappingsCount;
9090
9091 groupRoleMembersReply.MemberData =
9092 new GroupRoleMembersReplyPacket.MemberDataBlock[pairs];
9093
9094 for (int i = 0; i < pairs; i++)
9095 {
9096 GroupRoleMembersData d = mappings[0];
9097 mappings.RemoveAt(0);
9098
9099 groupRoleMembersReply.MemberData[i] =
9100 new GroupRoleMembersReplyPacket.MemberDataBlock();
9101
9102 groupRoleMembersReply.MemberData[i].RoleID =
9103 d.RoleID;
9104 groupRoleMembersReply.MemberData[i].MemberID =
9105 d.MemberID;
9106 }
9107
9108 OutPacket(groupRoleMembersReply, ThrottleOutPacketType.Task);
9109 }
9110 }
9111 return true;
9112 }
9113 private bool HandleCreateGroupRequest(IClientAPI sender, Packet Pack)
9114 {
9115 CreateGroupRequestPacket createGroupRequest =
9116 (CreateGroupRequestPacket)Pack;
9117
9118 #region Packet Session and User Check
9119 if (m_checkPackets)
9120 {
9121 if (createGroupRequest.AgentData.SessionID != SessionId ||
9122 createGroupRequest.AgentData.AgentID != AgentId)
9123 return true;
9124 }
9125 #endregion
9126
9127 if (m_GroupsModule != null)
9128 {
9129 m_GroupsModule.CreateGroup(this,
9130 Utils.BytesToString(createGroupRequest.GroupData.Name),
9131 Utils.BytesToString(createGroupRequest.GroupData.Charter),
9132 createGroupRequest.GroupData.ShowInList,
9133 createGroupRequest.GroupData.InsigniaID,
9134 createGroupRequest.GroupData.MembershipFee,
9135 createGroupRequest.GroupData.OpenEnrollment,
9136 createGroupRequest.GroupData.AllowPublish,
9137 createGroupRequest.GroupData.MaturePublish);
9138 }
9139 return true;
9140 }
9141 private bool HandleUpdateGroupInfo(IClientAPI sender, Packet Pack)
9142 {
9143 UpdateGroupInfoPacket updateGroupInfo =
9144 (UpdateGroupInfoPacket)Pack;
9145
9146 #region Packet Session and User Check
9147 if (m_checkPackets)
9148 {
9149 if (updateGroupInfo.AgentData.SessionID != SessionId ||
9150 updateGroupInfo.AgentData.AgentID != AgentId)
9151 return true;
9152 }
9153 #endregion
9154
9155 if (m_GroupsModule != null)
9156 {
9157 m_GroupsModule.UpdateGroupInfo(this,
9158 updateGroupInfo.GroupData.GroupID,
9159 Utils.BytesToString(updateGroupInfo.GroupData.Charter),
9160 updateGroupInfo.GroupData.ShowInList,
9161 updateGroupInfo.GroupData.InsigniaID,
9162 updateGroupInfo.GroupData.MembershipFee,
9163 updateGroupInfo.GroupData.OpenEnrollment,
9164 updateGroupInfo.GroupData.AllowPublish,
9165 updateGroupInfo.GroupData.MaturePublish);
9166 }
9167
9168 return true;
9169 }
9170 private bool HandleSetGroupAcceptNotices(IClientAPI sender, Packet Pack)
9171 {
9172 SetGroupAcceptNoticesPacket setGroupAcceptNotices =
9173 (SetGroupAcceptNoticesPacket)Pack;
9174
9175 #region Packet Session and User Check
9176 if (m_checkPackets)
9177 {
9178 if (setGroupAcceptNotices.AgentData.SessionID != SessionId ||
9179 setGroupAcceptNotices.AgentData.AgentID != AgentId)
9180 return true;
9181 }
9182 #endregion
9183
9184 if (m_GroupsModule != null)
9185 {
9186 m_GroupsModule.SetGroupAcceptNotices(this,
9187 setGroupAcceptNotices.Data.GroupID,
9188 setGroupAcceptNotices.Data.AcceptNotices,
9189 setGroupAcceptNotices.NewData.ListInProfile);
9190 }
9191
9192 return true;
9193 }
9194 private bool HandleGroupTitleUpdate(IClientAPI sender, Packet Pack)
9195 {
9196 GroupTitleUpdatePacket groupTitleUpdate =
9197 (GroupTitleUpdatePacket)Pack;
9198
9199 #region Packet Session and User Check
9200 if (m_checkPackets)
9201 {
9202 if (groupTitleUpdate.AgentData.SessionID != SessionId ||
9203 groupTitleUpdate.AgentData.AgentID != AgentId)
9204 return true;
9205 }
9206 #endregion
9207
9208 if (m_GroupsModule != null)
9209 {
9210 m_GroupsModule.GroupTitleUpdate(this,
9211 groupTitleUpdate.AgentData.GroupID,
9212 groupTitleUpdate.AgentData.TitleRoleID);
9213 }
9214
9215 return true;
9216 }
9217 private bool HandleParcelDeedToGroup(IClientAPI sender, Packet Pack)
9218 {
9219 ParcelDeedToGroupPacket parcelDeedToGroup = (ParcelDeedToGroupPacket)Pack;
9220 if (m_GroupsModule != null)
9221 {
9222 ParcelDeedToGroup handlerParcelDeedToGroup = OnParcelDeedToGroup;
9223 if (handlerParcelDeedToGroup != null)
9224 {
9225 handlerParcelDeedToGroup(parcelDeedToGroup.Data.LocalID, parcelDeedToGroup.Data.GroupID, this);
9226
9227 }
9228 }
9229
9230 return true;
9231 }
9232 private bool HandleGroupNoticesListRequest(IClientAPI sender, Packet Pack)
9233 {
9234 GroupNoticesListRequestPacket groupNoticesListRequest =
9235 (GroupNoticesListRequestPacket)Pack;
9236
9237 #region Packet Session and User Check
9238 if (m_checkPackets)
9239 {
9240 if (groupNoticesListRequest.AgentData.SessionID != SessionId ||
9241 groupNoticesListRequest.AgentData.AgentID != AgentId)
9242 return true;
9243 }
9244 #endregion
9245
9246 if (m_GroupsModule != null)
9247 {
9248 GroupNoticeData[] gn =
9249 m_GroupsModule.GroupNoticesListRequest(this,
9250 groupNoticesListRequest.Data.GroupID);
9251
9252 GroupNoticesListReplyPacket groupNoticesListReply = (GroupNoticesListReplyPacket)PacketPool.Instance.GetPacket(PacketType.GroupNoticesListReply);
9253 groupNoticesListReply.AgentData =
9254 new GroupNoticesListReplyPacket.AgentDataBlock();
9255 groupNoticesListReply.AgentData.AgentID = AgentId;
9256 groupNoticesListReply.AgentData.GroupID = groupNoticesListRequest.Data.GroupID;
9257
9258 groupNoticesListReply.Data = new GroupNoticesListReplyPacket.DataBlock[gn.Length];
9259
9260 int i = 0;
9261 foreach (GroupNoticeData g in gn)
9262 {
9263 groupNoticesListReply.Data[i] = new GroupNoticesListReplyPacket.DataBlock();
9264 groupNoticesListReply.Data[i].NoticeID =
9265 g.NoticeID;
9266 groupNoticesListReply.Data[i].Timestamp =
9267 g.Timestamp;
9268 groupNoticesListReply.Data[i].FromName =
9269 Util.StringToBytes256(g.FromName);
9270 groupNoticesListReply.Data[i].Subject =
9271 Util.StringToBytes256(g.Subject);
9272 groupNoticesListReply.Data[i].HasAttachment =
9273 g.HasAttachment;
9274 groupNoticesListReply.Data[i].AssetType =
9275 g.AssetType;
9276 i++;
9277 }
9278
9279 OutPacket(groupNoticesListReply, ThrottleOutPacketType.Task);
9280 }
9281
9282 return true;
9283 }
9284 private bool HandleGroupNoticeRequest(IClientAPI sender, Packet Pack)
9285 {
9286 GroupNoticeRequestPacket groupNoticeRequest =
9287 (GroupNoticeRequestPacket)Pack;
9288
9289 #region Packet Session and User Check
9290 if (m_checkPackets)
9291 {
9292 if (groupNoticeRequest.AgentData.SessionID != SessionId ||
9293 groupNoticeRequest.AgentData.AgentID != AgentId)
9294 return true;
9295 }
9296 #endregion
9297
9298 if (m_GroupsModule != null)
9299 {
9300 m_GroupsModule.GroupNoticeRequest(this,
9301 groupNoticeRequest.Data.GroupNoticeID);
9302 }
9303 return true;
9304 }
9305 private bool HandleGroupRoleUpdate(IClientAPI sender, Packet Pack)
9306 {
9307 GroupRoleUpdatePacket groupRoleUpdate =
9308 (GroupRoleUpdatePacket)Pack;
9309
9310 #region Packet Session and User Check
9311 if (m_checkPackets)
9312 {
9313 if (groupRoleUpdate.AgentData.SessionID != SessionId ||
9314 groupRoleUpdate.AgentData.AgentID != AgentId)
9315 return true;
9316 }
9317 #endregion
9318
9319 if (m_GroupsModule != null)
9320 {
9321 foreach (GroupRoleUpdatePacket.RoleDataBlock d in
9322 groupRoleUpdate.RoleData)
9323 {
9324 m_GroupsModule.GroupRoleUpdate(this,
9325 groupRoleUpdate.AgentData.GroupID,
9326 d.RoleID,
9327 Utils.BytesToString(d.Name),
9328 Utils.BytesToString(d.Description),
9329 Utils.BytesToString(d.Title),
9330 d.Powers,
9331 d.UpdateType);
9332 }
9333 m_GroupsModule.NotifyChange(groupRoleUpdate.AgentData.GroupID);
9334 }
9335 return true;
9336 }
9337 private bool HandleGroupRoleChanges(IClientAPI sender, Packet Pack)
9338 {
9339 GroupRoleChangesPacket groupRoleChanges =
9340 (GroupRoleChangesPacket)Pack;
9341
9342 #region Packet Session and User Check
9343 if (m_checkPackets)
9344 {
9345 if (groupRoleChanges.AgentData.SessionID != SessionId ||
9346 groupRoleChanges.AgentData.AgentID != AgentId)
9347 return true;
9348 }
9349 #endregion
9350
9351 if (m_GroupsModule != null)
9352 {
9353 foreach (GroupRoleChangesPacket.RoleChangeBlock d in
9354 groupRoleChanges.RoleChange)
9355 {
9356 m_GroupsModule.GroupRoleChanges(this,
9357 groupRoleChanges.AgentData.GroupID,
9358 d.RoleID,
9359 d.MemberID,
9360 d.Change);
9361 }
9362 m_GroupsModule.NotifyChange(groupRoleChanges.AgentData.GroupID);
9363 }
9364 return true;
9365 }
9366 private bool HandleJoinGroupRequest(IClientAPI sender, Packet Pack)
9367 {
9368 JoinGroupRequestPacket joinGroupRequest =
9369 (JoinGroupRequestPacket)Pack;
9370
9371 #region Packet Session and User Check
9372 if (m_checkPackets)
9373 {
9374 if (joinGroupRequest.AgentData.SessionID != SessionId ||
9375 joinGroupRequest.AgentData.AgentID != AgentId)
9376 return true;
9377 }
9378 #endregion
9379
9380 if (m_GroupsModule != null)
9381 {
9382 m_GroupsModule.JoinGroupRequest(this,
9383 joinGroupRequest.GroupData.GroupID);
9384 }
9385 return true;
9386 }
9387 private bool HandleLeaveGroupRequest(IClientAPI sender, Packet Pack)
9388 {
9389 LeaveGroupRequestPacket leaveGroupRequest =
9390 (LeaveGroupRequestPacket)Pack;
9391
9392 #region Packet Session and User Check
9393 if (m_checkPackets)
9394 {
9395 if (leaveGroupRequest.AgentData.SessionID != SessionId ||
9396 leaveGroupRequest.AgentData.AgentID != AgentId)
9397 return true;
9398 }
9399 #endregion
9400
9401 if (m_GroupsModule != null)
9402 {
9403 m_GroupsModule.LeaveGroupRequest(this,
9404 leaveGroupRequest.GroupData.GroupID);
9405 }
9406 return true;
9407 }
9408 private bool HandleEjectGroupMemberRequest(IClientAPI sender, Packet Pack)
9409 {
9410 EjectGroupMemberRequestPacket ejectGroupMemberRequest =
9411 (EjectGroupMemberRequestPacket)Pack;
9412
9413 #region Packet Session and User Check
9414 if (m_checkPackets)
9415 {
9416 if (ejectGroupMemberRequest.AgentData.SessionID != SessionId ||
9417 ejectGroupMemberRequest.AgentData.AgentID != AgentId)
9418 return true;
9419 }
9420 #endregion
9421
9422 if (m_GroupsModule != null)
9423 {
9424 foreach (EjectGroupMemberRequestPacket.EjectDataBlock e
9425 in ejectGroupMemberRequest.EjectData)
9426 {
9427 m_GroupsModule.EjectGroupMemberRequest(this,
9428 ejectGroupMemberRequest.GroupData.GroupID,
9429 e.EjecteeID);
9430 }
9431 }
9432 return true;
9433 }
9434 private bool HandleInviteGroupRequest(IClientAPI sender, Packet Pack)
9435 {
9436 InviteGroupRequestPacket inviteGroupRequest =
9437 (InviteGroupRequestPacket)Pack;
9438
9439 #region Packet Session and User Check
9440 if (m_checkPackets)
9441 {
9442 if (inviteGroupRequest.AgentData.SessionID != SessionId ||
9443 inviteGroupRequest.AgentData.AgentID != AgentId)
9444 return true;
9445 }
9446 #endregion
9447
9448 if (m_GroupsModule != null)
9449 {
9450 foreach (InviteGroupRequestPacket.InviteDataBlock b in
9451 inviteGroupRequest.InviteData)
9452 {
9453 m_GroupsModule.InviteGroupRequest(this,
9454 inviteGroupRequest.GroupData.GroupID,
9455 b.InviteeID,
9456 b.RoleID);
9457 }
9458 }
9459 return true;
9460 }
9461
9462 #endregion Groups
9463
9464 private bool HandleStartLure(IClientAPI sender, Packet Pack)
9465 {
9466 StartLurePacket startLureRequest = (StartLurePacket)Pack;
9467
9468 #region Packet Session and User Check
9469 if (m_checkPackets)
9470 {
9471 if (startLureRequest.AgentData.SessionID != SessionId ||
9472 startLureRequest.AgentData.AgentID != AgentId)
9473 return true;
9474 }
9475 #endregion
9476
9477 StartLure handlerStartLure = OnStartLure;
9478 if (handlerStartLure != null)
9479 handlerStartLure(startLureRequest.Info.LureType,
9480 Utils.BytesToString(
9481 startLureRequest.Info.Message),
9482 startLureRequest.TargetData[0].TargetID,
9483 this);
9484 return true;
9485 }
9486 private bool HandleTeleportLureRequest(IClientAPI sender, Packet Pack)
9487 {
9488 TeleportLureRequestPacket teleportLureRequest =
9489 (TeleportLureRequestPacket)Pack;
9490
9491 #region Packet Session and User Check
9492 if (m_checkPackets)
9493 {
9494 if (teleportLureRequest.Info.SessionID != SessionId ||
9495 teleportLureRequest.Info.AgentID != AgentId)
9496 return true;
9497 }
9498 #endregion
9499
9500 TeleportLureRequest handlerTeleportLureRequest = OnTeleportLureRequest;
9501 if (handlerTeleportLureRequest != null)
9502 handlerTeleportLureRequest(
9503 teleportLureRequest.Info.LureID,
9504 teleportLureRequest.Info.TeleportFlags,
9505 this);
9506 return true;
9507 }
9508 private bool HandleClassifiedInfoRequest(IClientAPI sender, Packet Pack)
9509 {
9510 ClassifiedInfoRequestPacket classifiedInfoRequest =
9511 (ClassifiedInfoRequestPacket)Pack;
9512
9513 #region Packet Session and User Check
9514 if (m_checkPackets)
9515 {
9516 if (classifiedInfoRequest.AgentData.SessionID != SessionId ||
9517 classifiedInfoRequest.AgentData.AgentID != AgentId)
9518 return true;
9519 }
9520 #endregion
9521
9522 ClassifiedInfoRequest handlerClassifiedInfoRequest = OnClassifiedInfoRequest;
9523 if (handlerClassifiedInfoRequest != null)
9524 handlerClassifiedInfoRequest(
9525 classifiedInfoRequest.Data.ClassifiedID,
9526 this);
9527 return true;
9528 }
9529 private bool HandleClassifiedInfoUpdate(IClientAPI sender, Packet Pack)
9530 {
9531 ClassifiedInfoUpdatePacket classifiedInfoUpdate =
9532 (ClassifiedInfoUpdatePacket)Pack;
9533
9534 #region Packet Session and User Check
9535 if (m_checkPackets)
9536 {
9537 if (classifiedInfoUpdate.AgentData.SessionID != SessionId ||
9538 classifiedInfoUpdate.AgentData.AgentID != AgentId)
9539 return true;
9540 }
9541 #endregion
9542
9543 ClassifiedInfoUpdate handlerClassifiedInfoUpdate = OnClassifiedInfoUpdate;
9544 if (handlerClassifiedInfoUpdate != null)
9545 handlerClassifiedInfoUpdate(
9546 classifiedInfoUpdate.Data.ClassifiedID,
9547 classifiedInfoUpdate.Data.Category,
9548 Utils.BytesToString(
9549 classifiedInfoUpdate.Data.Name),
9550 Utils.BytesToString(
9551 classifiedInfoUpdate.Data.Desc),
9552 classifiedInfoUpdate.Data.ParcelID,
9553 classifiedInfoUpdate.Data.ParentEstate,
9554 classifiedInfoUpdate.Data.SnapshotID,
9555 new Vector3(
9556 classifiedInfoUpdate.Data.PosGlobal),
9557 classifiedInfoUpdate.Data.ClassifiedFlags,
9558 classifiedInfoUpdate.Data.PriceForListing,
9559 this);
9560 return true;
9561 }
9562 private bool HandleClassifiedDelete(IClientAPI sender, Packet Pack)
9563 {
9564 ClassifiedDeletePacket classifiedDelete =
9565 (ClassifiedDeletePacket)Pack;
9566
9567 #region Packet Session and User Check
9568 if (m_checkPackets)
9569 {
9570 if (classifiedDelete.AgentData.SessionID != SessionId ||
9571 classifiedDelete.AgentData.AgentID != AgentId)
9572 return true;
9573 }
9574 #endregion
9575
9576 ClassifiedDelete handlerClassifiedDelete = OnClassifiedDelete;
9577 if (handlerClassifiedDelete != null)
9578 handlerClassifiedDelete(
9579 classifiedDelete.Data.ClassifiedID,
9580 this);
9581 return true;
9582 }
9583 private bool HandleClassifiedGodDelete(IClientAPI sender, Packet Pack)
9584 {
9585 ClassifiedGodDeletePacket classifiedGodDelete =
9586 (ClassifiedGodDeletePacket)Pack;
9587
9588 #region Packet Session and User Check
9589 if (m_checkPackets)
9590 {
9591 if (classifiedGodDelete.AgentData.SessionID != SessionId ||
9592 classifiedGodDelete.AgentData.AgentID != AgentId)
9593 return true;
9594 }
9595 #endregion
9596
9597 ClassifiedDelete handlerClassifiedGodDelete = OnClassifiedGodDelete;
9598 if (handlerClassifiedGodDelete != null)
9599 handlerClassifiedGodDelete(
9600 classifiedGodDelete.Data.ClassifiedID,
9601 this);
9602 return true;
9603 }
9604 private bool HandleEventGodDelete(IClientAPI sender, Packet Pack)
9605 {
9606 EventGodDeletePacket eventGodDelete =
9607 (EventGodDeletePacket)Pack;
9608
9609 #region Packet Session and User Check
9610 if (m_checkPackets)
9611 {
9612 if (eventGodDelete.AgentData.SessionID != SessionId ||
9613 eventGodDelete.AgentData.AgentID != AgentId)
9614 return true;
9615 }
9616 #endregion
9617
9618 EventGodDelete handlerEventGodDelete = OnEventGodDelete;
9619 if (handlerEventGodDelete != null)
9620 handlerEventGodDelete(
9621 eventGodDelete.EventData.EventID,
9622 eventGodDelete.QueryData.QueryID,
9623 Utils.BytesToString(
9624 eventGodDelete.QueryData.QueryText),
9625 eventGodDelete.QueryData.QueryFlags,
9626 eventGodDelete.QueryData.QueryStart,
9627 this);
9628 return true;
9629 }
9630 private bool HandleEventNotificationAddRequest(IClientAPI sender, Packet Pack)
9631 {
9632 EventNotificationAddRequestPacket eventNotificationAdd =
9633 (EventNotificationAddRequestPacket)Pack;
9634
9635 #region Packet Session and User Check
9636 if (m_checkPackets)
9637 {
9638 if (eventNotificationAdd.AgentData.SessionID != SessionId ||
9639 eventNotificationAdd.AgentData.AgentID != AgentId)
9640 return true;
9641 }
9642 #endregion
9643
9644 EventNotificationAddRequest handlerEventNotificationAddRequest = OnEventNotificationAddRequest;
9645 if (handlerEventNotificationAddRequest != null)
9646 handlerEventNotificationAddRequest(
9647 eventNotificationAdd.EventData.EventID, this);
9648 return true;
9649 }
9650 private bool HandleEventNotificationRemoveRequest(IClientAPI sender, Packet Pack)
9651 {
9652 EventNotificationRemoveRequestPacket eventNotificationRemove =
9653 (EventNotificationRemoveRequestPacket)Pack;
9654
9655 #region Packet Session and User Check
9656 if (m_checkPackets)
9657 {
9658 if (eventNotificationRemove.AgentData.SessionID != SessionId ||
9659 eventNotificationRemove.AgentData.AgentID != AgentId)
9660 return true;
9661 }
9662 #endregion
9663
9664 EventNotificationRemoveRequest handlerEventNotificationRemoveRequest = OnEventNotificationRemoveRequest;
9665 if (handlerEventNotificationRemoveRequest != null)
9666 handlerEventNotificationRemoveRequest(
9667 eventNotificationRemove.EventData.EventID, this);
9668 return true;
9669 }
9670 private bool HandleRetrieveInstantMessages(IClientAPI sender, Packet Pack)
9671 {
9672 RetrieveInstantMessagesPacket rimpInstantMessagePack = (RetrieveInstantMessagesPacket)Pack;
9673
9674 #region Packet Session and User Check
9675 if (m_checkPackets)
9676 {
9677 if (rimpInstantMessagePack.AgentData.SessionID != SessionId ||
9678 rimpInstantMessagePack.AgentData.AgentID != AgentId)
9679 return true;
9680 }
9681 #endregion
9682
9683 RetrieveInstantMessages handlerRetrieveInstantMessages = OnRetrieveInstantMessages;
9684 if (handlerRetrieveInstantMessages != null)
9685 handlerRetrieveInstantMessages(this);
9686 return true;
9687 }
9688 private bool HandlePickDelete(IClientAPI sender, Packet Pack)
9689 {
9690 PickDeletePacket pickDelete =
9691 (PickDeletePacket)Pack;
9692
9693 #region Packet Session and User Check
9694 if (m_checkPackets)
9695 {
9696 if (pickDelete.AgentData.SessionID != SessionId ||
9697 pickDelete.AgentData.AgentID != AgentId)
9698 return true;
9699 }
9700 #endregion
9701
9702 PickDelete handlerPickDelete = OnPickDelete;
9703 if (handlerPickDelete != null)
9704 handlerPickDelete(this, pickDelete.Data.PickID);
9705 return true;
9706 }
9707 private bool HandlePickGodDelete(IClientAPI sender, Packet Pack)
9708 {
9709 PickGodDeletePacket pickGodDelete =
9710 (PickGodDeletePacket)Pack;
9711
9712 #region Packet Session and User Check
9713 if (m_checkPackets)
9714 {
9715 if (pickGodDelete.AgentData.SessionID != SessionId ||
9716 pickGodDelete.AgentData.AgentID != AgentId)
9717 return true;
9718 }
9719 #endregion
9720
9721 PickGodDelete handlerPickGodDelete = OnPickGodDelete;
9722 if (handlerPickGodDelete != null)
9723 handlerPickGodDelete(this,
9724 pickGodDelete.AgentData.AgentID,
9725 pickGodDelete.Data.PickID,
9726 pickGodDelete.Data.QueryID);
9727 return true;
9728 }
9729 private bool HandlePickInfoUpdate(IClientAPI sender, Packet Pack)
9730 {
9731 PickInfoUpdatePacket pickInfoUpdate =
9732 (PickInfoUpdatePacket)Pack;
9733
9734 #region Packet Session and User Check
9735 if (m_checkPackets)
9736 {
9737 if (pickInfoUpdate.AgentData.SessionID != SessionId ||
9738 pickInfoUpdate.AgentData.AgentID != AgentId)
9739 return true;
9740 }
9741 #endregion
9742
9743 PickInfoUpdate handlerPickInfoUpdate = OnPickInfoUpdate;
9744 if (handlerPickInfoUpdate != null)
9745 handlerPickInfoUpdate(this,
9746 pickInfoUpdate.Data.PickID,
9747 pickInfoUpdate.Data.CreatorID,
9748 pickInfoUpdate.Data.TopPick,
9749 Utils.BytesToString(pickInfoUpdate.Data.Name),
9750 Utils.BytesToString(pickInfoUpdate.Data.Desc),
9751 pickInfoUpdate.Data.SnapshotID,
9752 pickInfoUpdate.Data.SortOrder,
9753 pickInfoUpdate.Data.Enabled);
9754 return true;
9755 }
9756 private bool HandleAvatarNotesUpdate(IClientAPI sender, Packet Pack)
9757 {
9758 AvatarNotesUpdatePacket avatarNotesUpdate =
9759 (AvatarNotesUpdatePacket)Pack;
9760
9761 #region Packet Session and User Check
9762 if (m_checkPackets)
9763 {
9764 if (avatarNotesUpdate.AgentData.SessionID != SessionId ||
9765 avatarNotesUpdate.AgentData.AgentID != AgentId)
9766 return true;
9767 }
9768 #endregion
9769
9770 AvatarNotesUpdate handlerAvatarNotesUpdate = OnAvatarNotesUpdate;
9771 if (handlerAvatarNotesUpdate != null)
9772 handlerAvatarNotesUpdate(this,
9773 avatarNotesUpdate.Data.TargetID,
9774 Utils.BytesToString(avatarNotesUpdate.Data.Notes));
9775 return true;
9776 }
9777 private bool HandleAvatarInterestsUpdate(IClientAPI sender, Packet Pack)
9778 {
9779 AvatarInterestsUpdatePacket avatarInterestUpdate =
9780 (AvatarInterestsUpdatePacket)Pack;
9781
9782 #region Packet Session and User Check
9783 if (m_checkPackets)
9784 {
9785 if (avatarInterestUpdate.AgentData.SessionID != SessionId ||
9786 avatarInterestUpdate.AgentData.AgentID != AgentId)
9787 return true;
9788 }
9789 #endregion
9790
9791 AvatarInterestUpdate handlerAvatarInterestUpdate = OnAvatarInterestUpdate;
9792 if (handlerAvatarInterestUpdate != null)
9793 handlerAvatarInterestUpdate(this,
9794 avatarInterestUpdate.PropertiesData.WantToMask,
9795 Utils.BytesToString(avatarInterestUpdate.PropertiesData.WantToText),
9796 avatarInterestUpdate.PropertiesData.SkillsMask,
9797 Utils.BytesToString(avatarInterestUpdate.PropertiesData.SkillsText),
9798 Utils.BytesToString(avatarInterestUpdate.PropertiesData.LanguagesText));
9799 return true;
9800 }
9801 private bool HandleGrantUserRights(IClientAPI sender, Packet Pack)
9802 {
9803 GrantUserRightsPacket GrantUserRights =
9804 (GrantUserRightsPacket)Pack;
9805 #region Packet Session and User Check
9806 if (m_checkPackets)
9807 {
9808 if (GrantUserRights.AgentData.SessionID != SessionId ||
9809 GrantUserRights.AgentData.AgentID != AgentId)
9810 return true;
9811 }
9812 #endregion
9813 GrantUserFriendRights GrantUserRightsHandler = OnGrantUserRights;
9814 if (GrantUserRightsHandler != null)
9815 GrantUserRightsHandler(this,
9816 GrantUserRights.AgentData.AgentID,
9817 GrantUserRights.Rights[0].AgentRelated,
9818 GrantUserRights.Rights[0].RelatedRights);
9819 return true;
9820 }
9821 private bool HandlePlacesQuery(IClientAPI sender, Packet Pack)
9822 {
9823 PlacesQueryPacket placesQueryPacket =
9824 (PlacesQueryPacket)Pack;
9825
9826 PlacesQuery handlerPlacesQuery = OnPlacesQuery;
9827
9828 if (handlerPlacesQuery != null)
9829 handlerPlacesQuery(placesQueryPacket.AgentData.QueryID,
9830 placesQueryPacket.TransactionData.TransactionID,
9831 Utils.BytesToString(
9832 placesQueryPacket.QueryData.QueryText),
9833 placesQueryPacket.QueryData.QueryFlags,
9834 (byte)placesQueryPacket.QueryData.Category,
9835 Utils.BytesToString(
9836 placesQueryPacket.QueryData.SimName),
9837 this);
9838 return true;
9839 }
8337 9840
8338 #endregion Packet Handlers 9841 #endregion Packet Handlers
8339 9842
@@ -8823,6 +10326,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
8823 10326
8824 if (ProcessPacketMethod(Pack)) 10327 if (ProcessPacketMethod(Pack))
8825 { 10328 {
10329 PacketPool.Instance.ReturnPacket(Pack);
8826 return; 10330 return;
8827 } 10331 }
8828 10332
@@ -12281,9 +13785,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP
12281 break; 13785 break;
12282 13786
12283 //#endregion 13787 //#endregion
12284 */ 13788
12285 #endregion 13789 //#region Gesture Managment
12286 #region Gesture Managment
12287 13790
12288 case PacketType.ActivateGestures: 13791 case PacketType.ActivateGestures:
12289 ActivateGesturesPacket activateGesturePacket = (ActivateGesturesPacket)Pack; 13792 ActivateGesturesPacket activateGesturePacket = (ActivateGesturesPacket)Pack;
@@ -12350,7 +13853,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
12350 } 13853 }
12351 break; 13854 break;
12352 13855
12353 #endregion 13856 //#endregion
12354 13857
12355 case PacketType.AgentFOV: 13858 case PacketType.AgentFOV:
12356 AgentFOVPacket fovPacket = (AgentFOVPacket)Pack; 13859 AgentFOVPacket fovPacket = (AgentFOVPacket)Pack;
@@ -12366,7 +13869,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
12366 } 13869 }
12367 break; 13870 break;
12368 13871
12369 #region unimplemented handlers 13872 //#region unimplemented handlers
12370 13873
12371 case PacketType.ViewerStats: 13874 case PacketType.ViewerStats:
12372 // TODO: handle this packet 13875 // TODO: handle this packet
@@ -12400,6 +13903,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
12400 // TODO: handle this packet 13903 // TODO: handle this packet
12401 //m_log.Warn("[CLIENT]: unhandled TransferAbort packet"); 13904 //m_log.Warn("[CLIENT]: unhandled TransferAbort packet");
12402 break; 13905 break;
13906
12403 case PacketType.MuteListRequest: 13907 case PacketType.MuteListRequest:
12404 MuteListRequestPacket muteListRequest = 13908 MuteListRequestPacket muteListRequest =
12405 (MuteListRequestPacket)Pack; 13909 (MuteListRequestPacket)Pack;
@@ -12423,6 +13927,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
12423 SendUseCachedMuteList(); 13927 SendUseCachedMuteList();
12424 } 13928 }
12425 break; 13929 break;
13930
12426 case PacketType.UseCircuitCode: 13931 case PacketType.UseCircuitCode:
12427 // Don't display this one, we handle it at a lower level 13932 // Don't display this one, we handle it at a lower level
12428 break; 13933 break;
@@ -12437,6 +13942,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
12437 //m_log.Warn("[CLIENT]: unhandled InventoryDescent packet"); 13942 //m_log.Warn("[CLIENT]: unhandled InventoryDescent packet");
12438 13943
12439 break; 13944 break;
13945
12440 case PacketType.DirPlacesQuery: 13946 case PacketType.DirPlacesQuery:
12441 DirPlacesQueryPacket dirPlacesQueryPacket = (DirPlacesQueryPacket)Pack; 13947 DirPlacesQueryPacket dirPlacesQueryPacket = (DirPlacesQueryPacket)Pack;
12442 //m_log.Debug(dirPlacesQueryPacket.ToString()); 13948 //m_log.Debug(dirPlacesQueryPacket.ToString());
@@ -12464,6 +13970,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
12464 dirPlacesQueryPacket.QueryData.QueryStart); 13970 dirPlacesQueryPacket.QueryData.QueryStart);
12465 } 13971 }
12466 break; 13972 break;
13973
12467 case PacketType.DirFindQuery: 13974 case PacketType.DirFindQuery:
12468 DirFindQueryPacket dirFindQueryPacket = (DirFindQueryPacket)Pack; 13975 DirFindQueryPacket dirFindQueryPacket = (DirFindQueryPacket)Pack;
12469 13976
@@ -12487,6 +13994,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
12487 dirFindQueryPacket.QueryData.QueryStart); 13994 dirFindQueryPacket.QueryData.QueryStart);
12488 } 13995 }
12489 break; 13996 break;
13997
12490 case PacketType.DirLandQuery: 13998 case PacketType.DirLandQuery:
12491 DirLandQueryPacket dirLandQueryPacket = (DirLandQueryPacket)Pack; 13999 DirLandQueryPacket dirLandQueryPacket = (DirLandQueryPacket)Pack;
12492 14000
@@ -12511,6 +14019,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
12511 dirLandQueryPacket.QueryData.QueryStart); 14019 dirLandQueryPacket.QueryData.QueryStart);
12512 } 14020 }
12513 break; 14021 break;
14022
12514 case PacketType.DirPopularQuery: 14023 case PacketType.DirPopularQuery:
12515 DirPopularQueryPacket dirPopularQueryPacket = (DirPopularQueryPacket)Pack; 14024 DirPopularQueryPacket dirPopularQueryPacket = (DirPopularQueryPacket)Pack;
12516 14025
@@ -12531,6 +14040,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
12531 dirPopularQueryPacket.QueryData.QueryFlags); 14040 dirPopularQueryPacket.QueryData.QueryFlags);
12532 } 14041 }
12533 break; 14042 break;
14043
12534 case PacketType.DirClassifiedQuery: 14044 case PacketType.DirClassifiedQuery:
12535 DirClassifiedQueryPacket dirClassifiedQueryPacket = (DirClassifiedQueryPacket)Pack; 14045 DirClassifiedQueryPacket dirClassifiedQueryPacket = (DirClassifiedQueryPacket)Pack;
12536 14046
@@ -12555,6 +14065,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
12555 dirClassifiedQueryPacket.QueryData.QueryStart); 14065 dirClassifiedQueryPacket.QueryData.QueryStart);
12556 } 14066 }
12557 break; 14067 break;
14068
12558 case PacketType.EventInfoRequest: 14069 case PacketType.EventInfoRequest:
12559 EventInfoRequestPacket eventInfoRequestPacket = (EventInfoRequestPacket)Pack; 14070 EventInfoRequestPacket eventInfoRequestPacket = (EventInfoRequestPacket)Pack;
12560 14071
@@ -12573,7 +14084,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
12573 } 14084 }
12574 break; 14085 break;
12575 14086
12576 #region Calling Card 14087 //#region Calling Card
12577 14088
12578 case PacketType.OfferCallingCard: 14089 case PacketType.OfferCallingCard:
12579 OfferCallingCardPacket offerCallingCardPacket = (OfferCallingCardPacket)Pack; 14090 OfferCallingCardPacket offerCallingCardPacket = (OfferCallingCardPacket)Pack;
@@ -12635,9 +14146,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
12635 declineCallingCardPacket.TransactionBlock.TransactionID); 14146 declineCallingCardPacket.TransactionBlock.TransactionID);
12636 } 14147 }
12637 break; 14148 break;
12638 #endregion 14149 //#endregion
12639 14150
12640 #region Groups 14151 //#region Groups
12641 case PacketType.ActivateGroup: 14152 case PacketType.ActivateGroup:
12642 ActivateGroupPacket activateGroupPacket = (ActivateGroupPacket)Pack; 14153 ActivateGroupPacket activateGroupPacket = (ActivateGroupPacket)Pack;
12643 14154
@@ -12657,6 +14168,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
12657 } 14168 }
12658 break; 14169 break;
12659 14170
14171
12660 case PacketType.GroupTitlesRequest: 14172 case PacketType.GroupTitlesRequest:
12661 GroupTitlesRequestPacket groupTitlesRequest = 14173 GroupTitlesRequestPacket groupTitlesRequest =
12662 (GroupTitlesRequestPacket)Pack; 14174 (GroupTitlesRequestPacket)Pack;
@@ -13118,8 +14630,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
13118 14630
13119 OutPacket(groupNoticesListReply, ThrottleOutPacketType.Task); 14631 OutPacket(groupNoticesListReply, ThrottleOutPacketType.Task);
13120 } 14632 }
13121 14633
13122 break; 14634 break;
14635
13123 case PacketType.GroupNoticeRequest: 14636 case PacketType.GroupNoticeRequest:
13124 GroupNoticeRequestPacket groupNoticeRequest = 14637 GroupNoticeRequestPacket groupNoticeRequest =
13125 (GroupNoticeRequestPacket)Pack; 14638 (GroupNoticeRequestPacket)Pack;
@@ -13290,7 +14803,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP
13290 } 14803 }
13291 break; 14804 break;
13292 14805
13293 #endregion 14806 //#endregion
14807
13294 case PacketType.StartLure: 14808 case PacketType.StartLure:
13295 StartLurePacket startLureRequest = (StartLurePacket)Pack; 14809 StartLurePacket startLureRequest = (StartLurePacket)Pack;
13296 14810
@@ -13522,6 +15036,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
13522 if (handlerPickDelete != null) 15036 if (handlerPickDelete != null)
13523 handlerPickDelete(this, pickDelete.Data.PickID); 15037 handlerPickDelete(this, pickDelete.Data.PickID);
13524 break; 15038 break;
15039
13525 case PacketType.PickGodDelete: 15040 case PacketType.PickGodDelete:
13526 PickGodDeletePacket pickGodDelete = 15041 PickGodDeletePacket pickGodDelete =
13527 (PickGodDeletePacket)Pack; 15042 (PickGodDeletePacket)Pack;
@@ -13542,6 +15057,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
13542 pickGodDelete.Data.PickID, 15057 pickGodDelete.Data.PickID,
13543 pickGodDelete.Data.QueryID); 15058 pickGodDelete.Data.QueryID);
13544 break; 15059 break;
15060
13545 case PacketType.PickInfoUpdate: 15061 case PacketType.PickInfoUpdate:
13546 PickInfoUpdatePacket pickInfoUpdate = 15062 PickInfoUpdatePacket pickInfoUpdate =
13547 (PickInfoUpdatePacket)Pack; 15063 (PickInfoUpdatePacket)Pack;
@@ -13567,6 +15083,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
13567 pickInfoUpdate.Data.SortOrder, 15083 pickInfoUpdate.Data.SortOrder,
13568 pickInfoUpdate.Data.Enabled); 15084 pickInfoUpdate.Data.Enabled);
13569 break; 15085 break;
15086
13570 case PacketType.AvatarNotesUpdate: 15087 case PacketType.AvatarNotesUpdate:
13571 AvatarNotesUpdatePacket avatarNotesUpdate = 15088 AvatarNotesUpdatePacket avatarNotesUpdate =
13572 (AvatarNotesUpdatePacket)Pack; 15089 (AvatarNotesUpdatePacket)Pack;
@@ -13599,7 +15116,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
13599 break; 15116 break;
13600 } 15117 }
13601 #endregion 15118 #endregion
13602 15119
13603 AvatarInterestUpdate handlerAvatarInterestUpdate = OnAvatarInterestUpdate; 15120 AvatarInterestUpdate handlerAvatarInterestUpdate = OnAvatarInterestUpdate;
13604 if (handlerAvatarInterestUpdate != null) 15121 if (handlerAvatarInterestUpdate != null)
13605 handlerAvatarInterestUpdate(this, 15122 handlerAvatarInterestUpdate(this,
@@ -13646,11 +15163,11 @@ namespace OpenSim.Region.ClientStack.LindenUDP
13646 placesQueryPacket.QueryData.SimName), 15163 placesQueryPacket.QueryData.SimName),
13647 this); 15164 this);
13648 break; 15165 break;
15166 */
15167 #endregion
13649 default: 15168 default:
13650 m_log.Warn("[CLIENT]: unhandled packet " + Pack); 15169 m_log.Warn("[CLIENT]: unhandled packet " + Pack);
13651 break; 15170 break;
13652
13653 #endregion
13654 } 15171 }
13655 15172
13656 PacketPool.Instance.ReturnPacket(Pack); 15173 PacketPool.Instance.ReturnPacket(Pack);