diff options
Diffstat (limited to 'OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs')
| -rw-r--r-- | OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs | 2076 |
1 files changed, 2055 insertions, 21 deletions
diff --git a/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs b/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs index 7f7b820..222fb1b 100644 --- a/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs +++ b/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs | |||
| @@ -4363,11 +4363,71 @@ namespace OpenSim.Region.ClientStack.LindenUDP | |||
| 4363 | AddLocalPacketHandler(PacketType.ScriptAnswerYes, HandleScriptAnswerYes); | 4363 | AddLocalPacketHandler(PacketType.ScriptAnswerYes, HandleScriptAnswerYes); |
| 4364 | AddLocalPacketHandler(PacketType.ObjectClickAction, HandleObjectClickAction); | 4364 | AddLocalPacketHandler(PacketType.ObjectClickAction, HandleObjectClickAction); |
| 4365 | AddLocalPacketHandler(PacketType.ObjectMaterial, HandleObjectMaterial); | 4365 | AddLocalPacketHandler(PacketType.ObjectMaterial, HandleObjectMaterial); |
| 4366 | AddLocalPacketHandler(PacketType.RequestImage, HandleRequestImage); | ||
| 4367 | AddLocalPacketHandler(PacketType.TransferRequest, HandleTransferRequest); | ||
| 4368 | AddLocalPacketHandler(PacketType.AssetUploadRequest, HandleAssetUploadRequest); | ||
| 4369 | AddLocalPacketHandler(PacketType.RequestXfer, HandleRequestXfer); | ||
| 4370 | AddLocalPacketHandler(PacketType.SendXferPacket, HandleSendXferPacket); | ||
| 4371 | AddLocalPacketHandler(PacketType.ConfirmXferPacket, HandleConfirmXferPacket); | ||
| 4372 | AddLocalPacketHandler(PacketType.AbortXfer, HandleAbortXfer); | ||
| 4373 | AddLocalPacketHandler(PacketType.CreateInventoryFolder, HandleCreateInventoryFolder); | ||
| 4374 | AddLocalPacketHandler(PacketType.UpdateInventoryFolder, HandleUpdateInventoryFolder); | ||
| 4375 | AddLocalPacketHandler(PacketType.MoveInventoryFolder, HandleMoveInventoryFolder); | ||
| 4376 | AddLocalPacketHandler(PacketType.CreateInventoryItem, HandleCreateInventoryItem); | ||
| 4377 | AddLocalPacketHandler(PacketType.FetchInventory, HandleFetchInventory); | ||
| 4378 | AddLocalPacketHandler(PacketType.FetchInventoryDescendents, HandleFetchInventoryDescendents); | ||
| 4379 | AddLocalPacketHandler(PacketType.PurgeInventoryDescendents, HandlePurgeInventoryDescendents); | ||
| 4380 | AddLocalPacketHandler(PacketType.UpdateInventoryItem, HandleUpdateInventoryItem); | ||
| 4381 | AddLocalPacketHandler(PacketType.CopyInventoryItem, HandleCopyInventoryItem); | ||
| 4382 | AddLocalPacketHandler(PacketType.MoveInventoryItem, HandleMoveInventoryItem); | ||
| 4383 | AddLocalPacketHandler(PacketType.RemoveInventoryItem, HandleRemoveInventoryItem); | ||
| 4384 | AddLocalPacketHandler(PacketType.RemoveInventoryFolder, HandleRemoveInventoryFolder); | ||
| 4385 | AddLocalPacketHandler(PacketType.RemoveInventoryObjects, HandleRemoveInventoryObjects); | ||
| 4386 | AddLocalPacketHandler(PacketType.RequestTaskInventory, HandleRequestTaskInventory); | ||
| 4387 | AddLocalPacketHandler(PacketType.UpdateTaskInventory, HandleUpdateTaskInventory); | ||
| 4388 | AddLocalPacketHandler(PacketType.RemoveTaskInventory, HandleRemoveTaskInventory); | ||
| 4389 | AddLocalPacketHandler(PacketType.MoveTaskInventory, HandleMoveTaskInventory); | ||
| 4390 | AddLocalPacketHandler(PacketType.RezScript, HandleRezScript); | ||
| 4391 | AddLocalPacketHandler(PacketType.MapLayerRequest, HandleMapLayerRequest); | ||
| 4392 | AddLocalPacketHandler(PacketType.MapBlockRequest, HandleMapBlockRequest); | ||
| 4393 | AddLocalPacketHandler(PacketType.MapNameRequest, HandleMapNameRequest); | ||
| 4394 | AddLocalPacketHandler(PacketType.TeleportLandmarkRequest, HandleTeleportLandmarkRequest); | ||
| 4395 | AddLocalPacketHandler(PacketType.TeleportLocationRequest, HandleTeleportLocationRequest); | ||
| 4396 | AddLocalPacketHandler(PacketType.UUIDNameRequest, HandleUUIDNameRequest); | ||
| 4397 | AddLocalPacketHandler(PacketType.RegionHandleRequest, HandleRegionHandleRequest); | ||
| 4398 | AddLocalPacketHandler(PacketType.ParcelInfoRequest, HandleParcelInfoRequest); | ||
| 4399 | AddLocalPacketHandler(PacketType.ParcelAccessListRequest, HandleParcelAccessListRequest); | ||
| 4400 | AddLocalPacketHandler(PacketType.ParcelAccessListUpdate, HandleParcelAccessListUpdate); | ||
| 4401 | AddLocalPacketHandler(PacketType.ParcelPropertiesRequest, HandleParcelPropertiesRequest); | ||
| 4402 | AddLocalPacketHandler(PacketType.ParcelDivide, HandleParcelDivide); | ||
| 4403 | AddLocalPacketHandler(PacketType.ParcelJoin, HandleParcelJoin); | ||
| 4404 | AddLocalPacketHandler(PacketType.ParcelPropertiesUpdate, HandleParcelPropertiesUpdate); | ||
| 4405 | AddLocalPacketHandler(PacketType.ParcelSelectObjects, HandleParcelSelectObjects); | ||
| 4406 | AddLocalPacketHandler(PacketType.ParcelObjectOwnersRequest, HandleParcelObjectOwnersRequest); | ||
| 4407 | AddLocalPacketHandler(PacketType.ParcelGodForceOwner, HandleParcelGodForceOwner); | ||
| 4408 | AddLocalPacketHandler(PacketType.ParcelRelease, HandleParcelRelease); | ||
| 4409 | AddLocalPacketHandler(PacketType.ParcelReclaim, HandleParcelReclaim); | ||
| 4410 | AddLocalPacketHandler(PacketType.ParcelReturnObjects, HandleParcelReturnObjects); | ||
| 4411 | AddLocalPacketHandler(PacketType.ParcelSetOtherCleanTime, HandleParcelSetOtherCleanTime); | ||
| 4412 | AddLocalPacketHandler(PacketType.LandStatRequest, HandleLandStatRequest); | ||
| 4413 | AddLocalPacketHandler(PacketType.ParcelDwellRequest, HandleParcelDwellRequest); | ||
| 4414 | AddLocalPacketHandler(PacketType.EstateOwnerMessage, HandleEstateOwnerMessage); | ||
| 4415 | AddLocalPacketHandler(PacketType.RequestRegionInfo, HandleRequestRegionInfo); | ||
| 4416 | AddLocalPacketHandler(PacketType.EstateCovenantRequest, HandleEstateCovenantRequest); | ||
| 4417 | AddLocalPacketHandler(PacketType.RequestGodlikePowers, HandleRequestGodlikePowers); | ||
| 4418 | AddLocalPacketHandler(PacketType.GodKickUser, HandleGodKickUser); | ||
| 4419 | AddLocalPacketHandler(PacketType.MoneyBalanceRequest, HandleMoneyBalanceRequest); | ||
| 4420 | AddLocalPacketHandler(PacketType.EconomyDataRequest, HandleEconomyDataRequest); | ||
| 4421 | AddLocalPacketHandler(PacketType.RequestPayPrice, HandleRequestPayPrice); | ||
| 4422 | AddLocalPacketHandler(PacketType.ObjectSaleInfo, HandleObjectSaleInfo); | ||
| 4423 | AddLocalPacketHandler(PacketType.ObjectBuy, HandleObjectBuy); | ||
| 4424 | AddLocalPacketHandler(PacketType.GetScriptRunning, HandleGetScriptRunning); | ||
| 4425 | AddLocalPacketHandler(PacketType.SetScriptRunning, HandleSetScriptRunning); | ||
| 4426 | AddLocalPacketHandler(PacketType.ScriptReset, HandleScriptReset); | ||
| 4366 | //AddLocalPacketHandler(PacketType.ChatFromViewer, HandleChatFromViewer); | 4427 | //AddLocalPacketHandler(PacketType.ChatFromViewer, HandleChatFromViewer); |
| 4367 | //AddLocalPacketHandler(PacketType.ChatFromViewer, HandleChatFromViewer); | 4428 | //AddLocalPacketHandler(PacketType.ChatFromViewer, HandleChatFromViewer); |
| 4368 | //AddLocalPacketHandler(PacketType.ChatFromViewer, HandleChatFromViewer); | 4429 | //AddLocalPacketHandler(PacketType.ChatFromViewer, HandleChatFromViewer); |
| 4369 | //AddLocalPacketHandler(PacketType.ChatFromViewer, HandleChatFromViewer); | 4430 | //AddLocalPacketHandler(PacketType.ChatFromViewer, HandleChatFromViewer); |
| 4370 | |||
| 4371 | 4431 | ||
| 4372 | } | 4432 | } |
| 4373 | 4433 | ||
| @@ -6338,6 +6398,1943 @@ namespace OpenSim.Region.ClientStack.LindenUDP | |||
| 6338 | 6398 | ||
| 6339 | #endregion Objects/m_sceneObjects | 6399 | #endregion Objects/m_sceneObjects |
| 6340 | 6400 | ||
| 6401 | #region Inventory/Asset/Other related packets | ||
| 6402 | |||
| 6403 | private bool HandleRequestImage(IClientAPI sender, Packet Pack) | ||
| 6404 | { | ||
| 6405 | RequestImagePacket imageRequest = (RequestImagePacket)Pack; | ||
| 6406 | //m_log.Debug("image request: " + Pack.ToString()); | ||
| 6407 | |||
| 6408 | #region Packet Session and User Check | ||
| 6409 | if (m_checkPackets) | ||
| 6410 | { | ||
| 6411 | if (imageRequest.AgentData.SessionID != SessionId || | ||
| 6412 | imageRequest.AgentData.AgentID != AgentId) | ||
| 6413 | return true; | ||
| 6414 | } | ||
| 6415 | #endregion | ||
| 6416 | |||
| 6417 | //handlerTextureRequest = null; | ||
| 6418 | for (int i = 0; i < imageRequest.RequestImage.Length; i++) | ||
| 6419 | { | ||
| 6420 | if (OnRequestTexture != null) | ||
| 6421 | { | ||
| 6422 | TextureRequestArgs args = new TextureRequestArgs(); | ||
| 6423 | |||
| 6424 | RequestImagePacket.RequestImageBlock block = imageRequest.RequestImage[i]; | ||
| 6425 | |||
| 6426 | args.RequestedAssetID = block.Image; | ||
| 6427 | args.DiscardLevel = block.DiscardLevel; | ||
| 6428 | args.PacketNumber = block.Packet; | ||
| 6429 | args.Priority = block.DownloadPriority; | ||
| 6430 | args.requestSequence = imageRequest.Header.Sequence; | ||
| 6431 | |||
| 6432 | // NOTE: This is not a built in part of the LLUDP protocol, but we double the | ||
| 6433 | // priority of avatar textures to get avatars rezzing in faster than the | ||
| 6434 | // surrounding scene | ||
| 6435 | if ((ImageType)block.Type == ImageType.Baked) | ||
| 6436 | args.Priority *= 2.0f; | ||
| 6437 | |||
| 6438 | //handlerTextureRequest = OnRequestTexture; | ||
| 6439 | |||
| 6440 | //if (handlerTextureRequest != null) | ||
| 6441 | //OnRequestTexture(this, args); | ||
| 6442 | |||
| 6443 | // in the end, we null this, so we have to check if it's null | ||
| 6444 | if (m_imageManager != null) | ||
| 6445 | { | ||
| 6446 | m_imageManager.EnqueueReq(args); | ||
| 6447 | } | ||
| 6448 | } | ||
| 6449 | } | ||
| 6450 | return true; | ||
| 6451 | } | ||
| 6452 | |||
| 6453 | private bool HandleTransferRequest(IClientAPI sender, Packet Pack) | ||
| 6454 | { | ||
| 6455 | //m_log.Debug("ClientView.ProcessPackets.cs:ProcessInPacket() - Got transfer request"); | ||
| 6456 | |||
| 6457 | TransferRequestPacket transfer = (TransferRequestPacket)Pack; | ||
| 6458 | //m_log.Debug("Transfer Request: " + transfer.ToString()); | ||
| 6459 | // Validate inventory transfers | ||
| 6460 | // Has to be done here, because AssetCache can't do it | ||
| 6461 | // | ||
| 6462 | UUID taskID = UUID.Zero; | ||
| 6463 | if (transfer.TransferInfo.SourceType == 3) | ||
| 6464 | { | ||
| 6465 | taskID = new UUID(transfer.TransferInfo.Params, 48); | ||
| 6466 | UUID itemID = new UUID(transfer.TransferInfo.Params, 64); | ||
| 6467 | UUID requestID = new UUID(transfer.TransferInfo.Params, 80); | ||
| 6468 | if (!(((Scene)m_scene).Permissions.BypassPermissions())) | ||
| 6469 | { | ||
| 6470 | if (taskID != UUID.Zero) // Prim | ||
| 6471 | { | ||
| 6472 | SceneObjectPart part = ((Scene)m_scene).GetSceneObjectPart(taskID); | ||
| 6473 | if (part == null) | ||
| 6474 | return true; | ||
| 6475 | |||
| 6476 | if (part.OwnerID != AgentId) | ||
| 6477 | return true; | ||
| 6478 | |||
| 6479 | if ((part.OwnerMask & (uint)PermissionMask.Modify) == 0) | ||
| 6480 | return true; | ||
| 6481 | |||
| 6482 | TaskInventoryItem ti = part.Inventory.GetInventoryItem(itemID); | ||
| 6483 | if (ti == null) | ||
| 6484 | return true; | ||
| 6485 | |||
| 6486 | if (ti.OwnerID != AgentId) | ||
| 6487 | return true; | ||
| 6488 | |||
| 6489 | if ((ti.CurrentPermissions & ((uint)PermissionMask.Modify | (uint)PermissionMask.Copy | (uint)PermissionMask.Transfer)) != ((uint)PermissionMask.Modify | (uint)PermissionMask.Copy | (uint)PermissionMask.Transfer)) | ||
| 6490 | return true; | ||
| 6491 | |||
| 6492 | if (ti.AssetID != requestID) | ||
| 6493 | return true; | ||
| 6494 | } | ||
| 6495 | else // Agent | ||
| 6496 | { | ||
| 6497 | IInventoryService invService = m_scene.RequestModuleInterface<IInventoryService>(); | ||
| 6498 | InventoryItemBase assetRequestItem = new InventoryItemBase(itemID, AgentId); | ||
| 6499 | assetRequestItem = invService.GetItem(assetRequestItem); | ||
| 6500 | if (assetRequestItem == null) | ||
| 6501 | { | ||
| 6502 | assetRequestItem = ((Scene)m_scene).CommsManager.UserProfileCacheService.LibraryRoot.FindItem(itemID); | ||
| 6503 | if (assetRequestItem == null) | ||
| 6504 | return true; | ||
| 6505 | } | ||
| 6506 | |||
| 6507 | // At this point, we need to apply perms | ||
| 6508 | // only to notecards and scripts. All | ||
| 6509 | // other asset types are always available | ||
| 6510 | // | ||
| 6511 | if (assetRequestItem.AssetType == 10) | ||
| 6512 | { | ||
| 6513 | if (!((Scene)m_scene).Permissions.CanViewScript(itemID, UUID.Zero, AgentId)) | ||
| 6514 | { | ||
| 6515 | SendAgentAlertMessage("Insufficient permissions to view script", false); | ||
| 6516 | return true; | ||
| 6517 | } | ||
| 6518 | } | ||
| 6519 | else if (assetRequestItem.AssetType == 7) | ||
| 6520 | { | ||
| 6521 | if (!((Scene)m_scene).Permissions.CanViewNotecard(itemID, UUID.Zero, AgentId)) | ||
| 6522 | { | ||
| 6523 | SendAgentAlertMessage("Insufficient permissions to view notecard", false); | ||
| 6524 | return true; | ||
| 6525 | } | ||
| 6526 | } | ||
| 6527 | |||
| 6528 | if (assetRequestItem.AssetID != requestID) | ||
| 6529 | return true; | ||
| 6530 | } | ||
| 6531 | } | ||
| 6532 | } | ||
| 6533 | |||
| 6534 | //m_assetCache.AddAssetRequest(this, transfer); | ||
| 6535 | |||
| 6536 | MakeAssetRequest(transfer, taskID); | ||
| 6537 | |||
| 6538 | /* RequestAsset = OnRequestAsset; | ||
| 6539 | if (RequestAsset != null) | ||
| 6540 | { | ||
| 6541 | RequestAsset(this, transfer); | ||
| 6542 | }*/ | ||
| 6543 | return true; | ||
| 6544 | } | ||
| 6545 | |||
| 6546 | private bool HandleAssetUploadRequest(IClientAPI sender, Packet Pack) | ||
| 6547 | { | ||
| 6548 | AssetUploadRequestPacket request = (AssetUploadRequestPacket)Pack; | ||
| 6549 | |||
| 6550 | |||
| 6551 | // m_log.Debug("upload request " + request.ToString()); | ||
| 6552 | // m_log.Debug("upload request was for assetid: " + request.AssetBlock.TransactionID.Combine(this.SecureSessionId).ToString()); | ||
| 6553 | UUID temp = UUID.Combine(request.AssetBlock.TransactionID, SecureSessionId); | ||
| 6554 | |||
| 6555 | UDPAssetUploadRequest handlerAssetUploadRequest = OnAssetUploadRequest; | ||
| 6556 | |||
| 6557 | if (handlerAssetUploadRequest != null) | ||
| 6558 | { | ||
| 6559 | handlerAssetUploadRequest(this, temp, | ||
| 6560 | request.AssetBlock.TransactionID, request.AssetBlock.Type, | ||
| 6561 | request.AssetBlock.AssetData, request.AssetBlock.StoreLocal, | ||
| 6562 | request.AssetBlock.Tempfile); | ||
| 6563 | } | ||
| 6564 | return true; | ||
| 6565 | } | ||
| 6566 | |||
| 6567 | private bool HandleRequestXfer(IClientAPI sender, Packet Pack) | ||
| 6568 | { | ||
| 6569 | RequestXferPacket xferReq = (RequestXferPacket)Pack; | ||
| 6570 | |||
| 6571 | RequestXfer handlerRequestXfer = OnRequestXfer; | ||
| 6572 | |||
| 6573 | if (handlerRequestXfer != null) | ||
| 6574 | { | ||
| 6575 | handlerRequestXfer(this, xferReq.XferID.ID, Util.FieldToString(xferReq.XferID.Filename)); | ||
| 6576 | } | ||
| 6577 | return true; | ||
| 6578 | } | ||
| 6579 | |||
| 6580 | private bool HandleSendXferPacket(IClientAPI sender, Packet Pack) | ||
| 6581 | { | ||
| 6582 | SendXferPacketPacket xferRec = (SendXferPacketPacket)Pack; | ||
| 6583 | |||
| 6584 | XferReceive handlerXferReceive = OnXferReceive; | ||
| 6585 | if (handlerXferReceive != null) | ||
| 6586 | { | ||
| 6587 | handlerXferReceive(this, xferRec.XferID.ID, xferRec.XferID.Packet, xferRec.DataPacket.Data); | ||
| 6588 | } | ||
| 6589 | return true; | ||
| 6590 | } | ||
| 6591 | |||
| 6592 | private bool HandleConfirmXferPacket(IClientAPI sender, Packet Pack) | ||
| 6593 | { | ||
| 6594 | ConfirmXferPacketPacket confirmXfer = (ConfirmXferPacketPacket)Pack; | ||
| 6595 | |||
| 6596 | ConfirmXfer handlerConfirmXfer = OnConfirmXfer; | ||
| 6597 | if (handlerConfirmXfer != null) | ||
| 6598 | { | ||
| 6599 | handlerConfirmXfer(this, confirmXfer.XferID.ID, confirmXfer.XferID.Packet); | ||
| 6600 | } | ||
| 6601 | return true; | ||
| 6602 | } | ||
| 6603 | |||
| 6604 | private bool HandleAbortXfer(IClientAPI sender, Packet Pack) | ||
| 6605 | { | ||
| 6606 | AbortXferPacket abortXfer = (AbortXferPacket)Pack; | ||
| 6607 | AbortXfer handlerAbortXfer = OnAbortXfer; | ||
| 6608 | if (handlerAbortXfer != null) | ||
| 6609 | { | ||
| 6610 | handlerAbortXfer(this, abortXfer.XferID.ID); | ||
| 6611 | } | ||
| 6612 | |||
| 6613 | return true; | ||
| 6614 | } | ||
| 6615 | |||
| 6616 | private bool HandleCreateInventoryFolder(IClientAPI sender, Packet Pack) | ||
| 6617 | { | ||
| 6618 | CreateInventoryFolderPacket invFolder = (CreateInventoryFolderPacket)Pack; | ||
| 6619 | |||
| 6620 | #region Packet Session and User Check | ||
| 6621 | if (m_checkPackets) | ||
| 6622 | { | ||
| 6623 | if (invFolder.AgentData.SessionID != SessionId || | ||
| 6624 | invFolder.AgentData.AgentID != AgentId) | ||
| 6625 | return true; | ||
| 6626 | } | ||
| 6627 | #endregion | ||
| 6628 | |||
| 6629 | CreateInventoryFolder handlerCreateInventoryFolder = OnCreateNewInventoryFolder; | ||
| 6630 | if (handlerCreateInventoryFolder != null) | ||
| 6631 | { | ||
| 6632 | handlerCreateInventoryFolder(this, invFolder.FolderData.FolderID, | ||
| 6633 | (ushort)invFolder.FolderData.Type, | ||
| 6634 | Util.FieldToString(invFolder.FolderData.Name), | ||
| 6635 | invFolder.FolderData.ParentID); | ||
| 6636 | } | ||
| 6637 | return true; | ||
| 6638 | } | ||
| 6639 | |||
| 6640 | private bool HandleUpdateInventoryFolder(IClientAPI sender, Packet Pack) | ||
| 6641 | { | ||
| 6642 | if (OnUpdateInventoryFolder != null) | ||
| 6643 | { | ||
| 6644 | UpdateInventoryFolderPacket invFolderx = (UpdateInventoryFolderPacket)Pack; | ||
| 6645 | |||
| 6646 | #region Packet Session and User Check | ||
| 6647 | if (m_checkPackets) | ||
| 6648 | { | ||
| 6649 | if (invFolderx.AgentData.SessionID != SessionId || | ||
| 6650 | invFolderx.AgentData.AgentID != AgentId) | ||
| 6651 | return true; | ||
| 6652 | } | ||
| 6653 | #endregion | ||
| 6654 | |||
| 6655 | UpdateInventoryFolder handlerUpdateInventoryFolder = null; | ||
| 6656 | |||
| 6657 | for (int i = 0; i < invFolderx.FolderData.Length; i++) | ||
| 6658 | { | ||
| 6659 | handlerUpdateInventoryFolder = OnUpdateInventoryFolder; | ||
| 6660 | if (handlerUpdateInventoryFolder != null) | ||
| 6661 | { | ||
| 6662 | OnUpdateInventoryFolder(this, invFolderx.FolderData[i].FolderID, | ||
| 6663 | (ushort)invFolderx.FolderData[i].Type, | ||
| 6664 | Util.FieldToString(invFolderx.FolderData[i].Name), | ||
| 6665 | invFolderx.FolderData[i].ParentID); | ||
| 6666 | } | ||
| 6667 | } | ||
| 6668 | } | ||
| 6669 | return true; | ||
| 6670 | } | ||
| 6671 | |||
| 6672 | private bool HandleMoveInventoryFolder(IClientAPI sender, Packet Pack) | ||
| 6673 | { | ||
| 6674 | if (OnMoveInventoryFolder != null) | ||
| 6675 | { | ||
| 6676 | MoveInventoryFolderPacket invFoldery = (MoveInventoryFolderPacket)Pack; | ||
| 6677 | |||
| 6678 | #region Packet Session and User Check | ||
| 6679 | if (m_checkPackets) | ||
| 6680 | { | ||
| 6681 | if (invFoldery.AgentData.SessionID != SessionId || | ||
| 6682 | invFoldery.AgentData.AgentID != AgentId) | ||
| 6683 | return true; | ||
| 6684 | } | ||
| 6685 | #endregion | ||
| 6686 | |||
| 6687 | MoveInventoryFolder handlerMoveInventoryFolder = null; | ||
| 6688 | |||
| 6689 | for (int i = 0; i < invFoldery.InventoryData.Length; i++) | ||
| 6690 | { | ||
| 6691 | handlerMoveInventoryFolder = OnMoveInventoryFolder; | ||
| 6692 | if (handlerMoveInventoryFolder != null) | ||
| 6693 | { | ||
| 6694 | OnMoveInventoryFolder(this, invFoldery.InventoryData[i].FolderID, | ||
| 6695 | invFoldery.InventoryData[i].ParentID); | ||
| 6696 | } | ||
| 6697 | } | ||
| 6698 | } | ||
| 6699 | return true; | ||
| 6700 | } | ||
| 6701 | |||
| 6702 | private bool HandleCreateInventoryItem(IClientAPI sender, Packet Pack) | ||
| 6703 | { | ||
| 6704 | CreateInventoryItemPacket createItem = (CreateInventoryItemPacket)Pack; | ||
| 6705 | |||
| 6706 | #region Packet Session and User Check | ||
| 6707 | if (m_checkPackets) | ||
| 6708 | { | ||
| 6709 | if (createItem.AgentData.SessionID != SessionId || | ||
| 6710 | createItem.AgentData.AgentID != AgentId) | ||
| 6711 | return true; | ||
| 6712 | } | ||
| 6713 | #endregion | ||
| 6714 | |||
| 6715 | CreateNewInventoryItem handlerCreateNewInventoryItem = OnCreateNewInventoryItem; | ||
| 6716 | if (handlerCreateNewInventoryItem != null) | ||
| 6717 | { | ||
| 6718 | handlerCreateNewInventoryItem(this, createItem.InventoryBlock.TransactionID, | ||
| 6719 | createItem.InventoryBlock.FolderID, | ||
| 6720 | createItem.InventoryBlock.CallbackID, | ||
| 6721 | Util.FieldToString(createItem.InventoryBlock.Description), | ||
| 6722 | Util.FieldToString(createItem.InventoryBlock.Name), | ||
| 6723 | createItem.InventoryBlock.InvType, | ||
| 6724 | createItem.InventoryBlock.Type, | ||
| 6725 | createItem.InventoryBlock.WearableType, | ||
| 6726 | createItem.InventoryBlock.NextOwnerMask, | ||
| 6727 | Util.UnixTimeSinceEpoch()); | ||
| 6728 | } | ||
| 6729 | return true; | ||
| 6730 | } | ||
| 6731 | |||
| 6732 | private bool HandleFetchInventory(IClientAPI sender, Packet Pack) | ||
| 6733 | { | ||
| 6734 | if (OnFetchInventory != null) | ||
| 6735 | { | ||
| 6736 | FetchInventoryPacket FetchInventoryx = (FetchInventoryPacket)Pack; | ||
| 6737 | |||
| 6738 | #region Packet Session and User Check | ||
| 6739 | if (m_checkPackets) | ||
| 6740 | { | ||
| 6741 | if (FetchInventoryx.AgentData.SessionID != SessionId || | ||
| 6742 | FetchInventoryx.AgentData.AgentID != AgentId) | ||
| 6743 | return true; | ||
| 6744 | } | ||
| 6745 | #endregion | ||
| 6746 | |||
| 6747 | FetchInventory handlerFetchInventory = null; | ||
| 6748 | |||
| 6749 | for (int i = 0; i < FetchInventoryx.InventoryData.Length; i++) | ||
| 6750 | { | ||
| 6751 | handlerFetchInventory = OnFetchInventory; | ||
| 6752 | |||
| 6753 | if (handlerFetchInventory != null) | ||
| 6754 | { | ||
| 6755 | OnFetchInventory(this, FetchInventoryx.InventoryData[i].ItemID, | ||
| 6756 | FetchInventoryx.InventoryData[i].OwnerID); | ||
| 6757 | } | ||
| 6758 | } | ||
| 6759 | } | ||
| 6760 | return true; | ||
| 6761 | } | ||
| 6762 | |||
| 6763 | private bool HandleFetchInventoryDescendents(IClientAPI sender, Packet Pack) | ||
| 6764 | { | ||
| 6765 | FetchInventoryDescendentsPacket Fetch = (FetchInventoryDescendentsPacket)Pack; | ||
| 6766 | |||
| 6767 | #region Packet Session and User Check | ||
| 6768 | if (m_checkPackets) | ||
| 6769 | { | ||
| 6770 | if (Fetch.AgentData.SessionID != SessionId || | ||
| 6771 | Fetch.AgentData.AgentID != AgentId) | ||
| 6772 | return true; | ||
| 6773 | } | ||
| 6774 | #endregion | ||
| 6775 | |||
| 6776 | FetchInventoryDescendents handlerFetchInventoryDescendents = OnFetchInventoryDescendents; | ||
| 6777 | if (handlerFetchInventoryDescendents != null) | ||
| 6778 | { | ||
| 6779 | handlerFetchInventoryDescendents(this, Fetch.InventoryData.FolderID, Fetch.InventoryData.OwnerID, | ||
| 6780 | Fetch.InventoryData.FetchFolders, Fetch.InventoryData.FetchItems, | ||
| 6781 | Fetch.InventoryData.SortOrder); | ||
| 6782 | } | ||
| 6783 | return true; | ||
| 6784 | } | ||
| 6785 | |||
| 6786 | private bool HandlePurgeInventoryDescendents(IClientAPI sender, Packet Pack) | ||
| 6787 | { | ||
| 6788 | PurgeInventoryDescendentsPacket Purge = (PurgeInventoryDescendentsPacket)Pack; | ||
| 6789 | |||
| 6790 | #region Packet Session and User Check | ||
| 6791 | if (m_checkPackets) | ||
| 6792 | { | ||
| 6793 | if (Purge.AgentData.SessionID != SessionId || | ||
| 6794 | Purge.AgentData.AgentID != AgentId) | ||
| 6795 | return true; | ||
| 6796 | } | ||
| 6797 | #endregion | ||
| 6798 | |||
| 6799 | PurgeInventoryDescendents handlerPurgeInventoryDescendents = OnPurgeInventoryDescendents; | ||
| 6800 | if (handlerPurgeInventoryDescendents != null) | ||
| 6801 | { | ||
| 6802 | handlerPurgeInventoryDescendents(this, Purge.InventoryData.FolderID); | ||
| 6803 | } | ||
| 6804 | return true; | ||
| 6805 | } | ||
| 6806 | |||
| 6807 | private bool HandleUpdateInventoryItem(IClientAPI sender, Packet Pack) | ||
| 6808 | { | ||
| 6809 | UpdateInventoryItemPacket inventoryItemUpdate = (UpdateInventoryItemPacket)Pack; | ||
| 6810 | |||
| 6811 | #region Packet Session and User Check | ||
| 6812 | if (m_checkPackets) | ||
| 6813 | { | ||
| 6814 | if (inventoryItemUpdate.AgentData.SessionID != SessionId || | ||
| 6815 | inventoryItemUpdate.AgentData.AgentID != AgentId) | ||
| 6816 | return true; | ||
| 6817 | } | ||
| 6818 | #endregion | ||
| 6819 | |||
| 6820 | if (OnUpdateInventoryItem != null) | ||
| 6821 | { | ||
| 6822 | UpdateInventoryItem handlerUpdateInventoryItem = null; | ||
| 6823 | for (int i = 0; i < inventoryItemUpdate.InventoryData.Length; i++) | ||
| 6824 | { | ||
| 6825 | handlerUpdateInventoryItem = OnUpdateInventoryItem; | ||
| 6826 | |||
| 6827 | if (handlerUpdateInventoryItem != null) | ||
| 6828 | { | ||
| 6829 | InventoryItemBase itemUpd = new InventoryItemBase(); | ||
| 6830 | itemUpd.ID = inventoryItemUpdate.InventoryData[i].ItemID; | ||
| 6831 | itemUpd.Name = Util.FieldToString(inventoryItemUpdate.InventoryData[i].Name); | ||
| 6832 | itemUpd.Description = Util.FieldToString(inventoryItemUpdate.InventoryData[i].Description); | ||
| 6833 | itemUpd.GroupID = inventoryItemUpdate.InventoryData[i].GroupID; | ||
| 6834 | itemUpd.GroupOwned = inventoryItemUpdate.InventoryData[i].GroupOwned; | ||
| 6835 | itemUpd.GroupPermissions = inventoryItemUpdate.InventoryData[i].GroupMask; | ||
| 6836 | itemUpd.NextPermissions = inventoryItemUpdate.InventoryData[i].NextOwnerMask; | ||
| 6837 | itemUpd.EveryOnePermissions = inventoryItemUpdate.InventoryData[i].EveryoneMask; | ||
| 6838 | itemUpd.CreationDate = inventoryItemUpdate.InventoryData[i].CreationDate; | ||
| 6839 | itemUpd.Folder = inventoryItemUpdate.InventoryData[i].FolderID; | ||
| 6840 | itemUpd.InvType = inventoryItemUpdate.InventoryData[i].InvType; | ||
| 6841 | itemUpd.SalePrice = inventoryItemUpdate.InventoryData[i].SalePrice; | ||
| 6842 | itemUpd.SaleType = inventoryItemUpdate.InventoryData[i].SaleType; | ||
| 6843 | itemUpd.Flags = inventoryItemUpdate.InventoryData[i].Flags; | ||
| 6844 | |||
| 6845 | OnUpdateInventoryItem(this, inventoryItemUpdate.InventoryData[i].TransactionID, | ||
| 6846 | inventoryItemUpdate.InventoryData[i].ItemID, | ||
| 6847 | itemUpd); | ||
| 6848 | } | ||
| 6849 | } | ||
| 6850 | } | ||
| 6851 | return true; | ||
| 6852 | } | ||
| 6853 | |||
| 6854 | private bool HandleCopyInventoryItem(IClientAPI sender, Packet Pack) | ||
| 6855 | { | ||
| 6856 | CopyInventoryItemPacket copyitem = (CopyInventoryItemPacket)Pack; | ||
| 6857 | |||
| 6858 | #region Packet Session and User Check | ||
| 6859 | if (m_checkPackets) | ||
| 6860 | { | ||
| 6861 | if (copyitem.AgentData.SessionID != SessionId || | ||
| 6862 | copyitem.AgentData.AgentID != AgentId) | ||
| 6863 | return true; | ||
| 6864 | } | ||
| 6865 | #endregion | ||
| 6866 | |||
| 6867 | CopyInventoryItem handlerCopyInventoryItem = null; | ||
| 6868 | if (OnCopyInventoryItem != null) | ||
| 6869 | { | ||
| 6870 | foreach (CopyInventoryItemPacket.InventoryDataBlock datablock in copyitem.InventoryData) | ||
| 6871 | { | ||
| 6872 | handlerCopyInventoryItem = OnCopyInventoryItem; | ||
| 6873 | if (handlerCopyInventoryItem != null) | ||
| 6874 | { | ||
| 6875 | handlerCopyInventoryItem(this, datablock.CallbackID, datablock.OldAgentID, | ||
| 6876 | datablock.OldItemID, datablock.NewFolderID, | ||
| 6877 | Util.FieldToString(datablock.NewName)); | ||
| 6878 | } | ||
| 6879 | } | ||
| 6880 | } | ||
| 6881 | return true; | ||
| 6882 | } | ||
| 6883 | |||
| 6884 | private bool HandleMoveInventoryItem(IClientAPI sender, Packet Pack) | ||
| 6885 | { | ||
| 6886 | MoveInventoryItemPacket moveitem = (MoveInventoryItemPacket)Pack; | ||
| 6887 | |||
| 6888 | #region Packet Session and User Check | ||
| 6889 | if (m_checkPackets) | ||
| 6890 | { | ||
| 6891 | if (moveitem.AgentData.SessionID != SessionId || | ||
| 6892 | moveitem.AgentData.AgentID != AgentId) | ||
| 6893 | return true; | ||
| 6894 | } | ||
| 6895 | #endregion | ||
| 6896 | |||
| 6897 | if (OnMoveInventoryItem != null) | ||
| 6898 | { | ||
| 6899 | MoveInventoryItem handlerMoveInventoryItem = null; | ||
| 6900 | InventoryItemBase itm = null; | ||
| 6901 | List<InventoryItemBase> items = new List<InventoryItemBase>(); | ||
| 6902 | foreach (MoveInventoryItemPacket.InventoryDataBlock datablock in moveitem.InventoryData) | ||
| 6903 | { | ||
| 6904 | itm = new InventoryItemBase(datablock.ItemID, AgentId); | ||
| 6905 | itm.Folder = datablock.FolderID; | ||
| 6906 | itm.Name = Util.FieldToString(datablock.NewName); | ||
| 6907 | // weird, comes out as empty string | ||
| 6908 | //m_log.DebugFormat("[XXX] new name: {0}", itm.Name); | ||
| 6909 | items.Add(itm); | ||
| 6910 | } | ||
| 6911 | handlerMoveInventoryItem = OnMoveInventoryItem; | ||
| 6912 | if (handlerMoveInventoryItem != null) | ||
| 6913 | { | ||
| 6914 | handlerMoveInventoryItem(this, items); | ||
| 6915 | } | ||
| 6916 | } | ||
| 6917 | return true; | ||
| 6918 | } | ||
| 6919 | |||
| 6920 | private bool HandleRemoveInventoryItem(IClientAPI sender, Packet Pack) | ||
| 6921 | { | ||
| 6922 | RemoveInventoryItemPacket removeItem = (RemoveInventoryItemPacket)Pack; | ||
| 6923 | |||
| 6924 | #region Packet Session and User Check | ||
| 6925 | if (m_checkPackets) | ||
| 6926 | { | ||
| 6927 | if (removeItem.AgentData.SessionID != SessionId || | ||
| 6928 | removeItem.AgentData.AgentID != AgentId) | ||
| 6929 | return true; | ||
| 6930 | } | ||
| 6931 | #endregion | ||
| 6932 | |||
| 6933 | if (OnRemoveInventoryItem != null) | ||
| 6934 | { | ||
| 6935 | RemoveInventoryItem handlerRemoveInventoryItem = null; | ||
| 6936 | List<UUID> uuids = new List<UUID>(); | ||
| 6937 | foreach (RemoveInventoryItemPacket.InventoryDataBlock datablock in removeItem.InventoryData) | ||
| 6938 | { | ||
| 6939 | uuids.Add(datablock.ItemID); | ||
| 6940 | } | ||
| 6941 | handlerRemoveInventoryItem = OnRemoveInventoryItem; | ||
| 6942 | if (handlerRemoveInventoryItem != null) | ||
| 6943 | { | ||
| 6944 | handlerRemoveInventoryItem(this, uuids); | ||
| 6945 | } | ||
| 6946 | |||
| 6947 | } | ||
| 6948 | return true; | ||
| 6949 | } | ||
| 6950 | |||
| 6951 | private bool HandleRemoveInventoryFolder(IClientAPI sender, Packet Pack) | ||
| 6952 | { | ||
| 6953 | RemoveInventoryFolderPacket removeFolder = (RemoveInventoryFolderPacket)Pack; | ||
| 6954 | |||
| 6955 | #region Packet Session and User Check | ||
| 6956 | if (m_checkPackets) | ||
| 6957 | { | ||
| 6958 | if (removeFolder.AgentData.SessionID != SessionId || | ||
| 6959 | removeFolder.AgentData.AgentID != AgentId) | ||
| 6960 | return true; | ||
| 6961 | } | ||
| 6962 | #endregion | ||
| 6963 | |||
| 6964 | if (OnRemoveInventoryFolder != null) | ||
| 6965 | { | ||
| 6966 | RemoveInventoryFolder handlerRemoveInventoryFolder = null; | ||
| 6967 | List<UUID> uuids = new List<UUID>(); | ||
| 6968 | foreach (RemoveInventoryFolderPacket.FolderDataBlock datablock in removeFolder.FolderData) | ||
| 6969 | { | ||
| 6970 | uuids.Add(datablock.FolderID); | ||
| 6971 | } | ||
| 6972 | handlerRemoveInventoryFolder = OnRemoveInventoryFolder; | ||
| 6973 | if (handlerRemoveInventoryFolder != null) | ||
| 6974 | { | ||
| 6975 | handlerRemoveInventoryFolder(this, uuids); | ||
| 6976 | } | ||
| 6977 | } | ||
| 6978 | return true; | ||
| 6979 | } | ||
| 6980 | |||
| 6981 | private bool HandleRemoveInventoryObjects(IClientAPI sender, Packet Pack) | ||
| 6982 | { | ||
| 6983 | RemoveInventoryObjectsPacket removeObject = (RemoveInventoryObjectsPacket)Pack; | ||
| 6984 | #region Packet Session and User Check | ||
| 6985 | if (m_checkPackets) | ||
| 6986 | { | ||
| 6987 | if (removeObject.AgentData.SessionID != SessionId || | ||
| 6988 | removeObject.AgentData.AgentID != AgentId) | ||
| 6989 | return true; | ||
| 6990 | } | ||
| 6991 | #endregion | ||
| 6992 | if (OnRemoveInventoryFolder != null) | ||
| 6993 | { | ||
| 6994 | RemoveInventoryFolder handlerRemoveInventoryFolder = null; | ||
| 6995 | List<UUID> uuids = new List<UUID>(); | ||
| 6996 | foreach (RemoveInventoryObjectsPacket.FolderDataBlock datablock in removeObject.FolderData) | ||
| 6997 | { | ||
| 6998 | uuids.Add(datablock.FolderID); | ||
| 6999 | } | ||
| 7000 | handlerRemoveInventoryFolder = OnRemoveInventoryFolder; | ||
| 7001 | if (handlerRemoveInventoryFolder != null) | ||
| 7002 | { | ||
| 7003 | handlerRemoveInventoryFolder(this, uuids); | ||
| 7004 | } | ||
| 7005 | } | ||
| 7006 | |||
| 7007 | if (OnRemoveInventoryItem != null) | ||
| 7008 | { | ||
| 7009 | RemoveInventoryItem handlerRemoveInventoryItem = null; | ||
| 7010 | List<UUID> uuids = new List<UUID>(); | ||
| 7011 | foreach (RemoveInventoryObjectsPacket.ItemDataBlock datablock in removeObject.ItemData) | ||
| 7012 | { | ||
| 7013 | uuids.Add(datablock.ItemID); | ||
| 7014 | } | ||
| 7015 | handlerRemoveInventoryItem = OnRemoveInventoryItem; | ||
| 7016 | if (handlerRemoveInventoryItem != null) | ||
| 7017 | { | ||
| 7018 | handlerRemoveInventoryItem(this, uuids); | ||
| 7019 | } | ||
| 7020 | } | ||
| 7021 | return true; | ||
| 7022 | } | ||
| 7023 | |||
| 7024 | private bool HandleRequestTaskInventory(IClientAPI sender, Packet Pack) | ||
| 7025 | { | ||
| 7026 | RequestTaskInventoryPacket requesttask = (RequestTaskInventoryPacket)Pack; | ||
| 7027 | |||
| 7028 | #region Packet Session and User Check | ||
| 7029 | if (m_checkPackets) | ||
| 7030 | { | ||
| 7031 | if (requesttask.AgentData.SessionID != SessionId || | ||
| 7032 | requesttask.AgentData.AgentID != AgentId) | ||
| 7033 | return true; | ||
| 7034 | } | ||
| 7035 | #endregion | ||
| 7036 | |||
| 7037 | RequestTaskInventory handlerRequestTaskInventory = OnRequestTaskInventory; | ||
| 7038 | if (handlerRequestTaskInventory != null) | ||
| 7039 | { | ||
| 7040 | handlerRequestTaskInventory(this, requesttask.InventoryData.LocalID); | ||
| 7041 | } | ||
| 7042 | return true; | ||
| 7043 | } | ||
| 7044 | |||
| 7045 | private bool HandleUpdateTaskInventory(IClientAPI sender, Packet Pack) | ||
| 7046 | { | ||
| 7047 | UpdateTaskInventoryPacket updatetask = (UpdateTaskInventoryPacket)Pack; | ||
| 7048 | |||
| 7049 | #region Packet Session and User Check | ||
| 7050 | if (m_checkPackets) | ||
| 7051 | { | ||
| 7052 | if (updatetask.AgentData.SessionID != SessionId || | ||
| 7053 | updatetask.AgentData.AgentID != AgentId) | ||
| 7054 | return true; | ||
| 7055 | } | ||
| 7056 | #endregion | ||
| 7057 | |||
| 7058 | if (OnUpdateTaskInventory != null) | ||
| 7059 | { | ||
| 7060 | if (updatetask.UpdateData.Key == 0) | ||
| 7061 | { | ||
| 7062 | UpdateTaskInventory handlerUpdateTaskInventory = OnUpdateTaskInventory; | ||
| 7063 | if (handlerUpdateTaskInventory != null) | ||
| 7064 | { | ||
| 7065 | TaskInventoryItem newTaskItem = new TaskInventoryItem(); | ||
| 7066 | newTaskItem.ItemID = updatetask.InventoryData.ItemID; | ||
| 7067 | newTaskItem.ParentID = updatetask.InventoryData.FolderID; | ||
| 7068 | newTaskItem.CreatorID = updatetask.InventoryData.CreatorID; | ||
| 7069 | newTaskItem.OwnerID = updatetask.InventoryData.OwnerID; | ||
| 7070 | newTaskItem.GroupID = updatetask.InventoryData.GroupID; | ||
| 7071 | newTaskItem.BasePermissions = updatetask.InventoryData.BaseMask; | ||
| 7072 | newTaskItem.CurrentPermissions = updatetask.InventoryData.OwnerMask; | ||
| 7073 | newTaskItem.GroupPermissions = updatetask.InventoryData.GroupMask; | ||
| 7074 | newTaskItem.EveryonePermissions = updatetask.InventoryData.EveryoneMask; | ||
| 7075 | newTaskItem.NextPermissions = updatetask.InventoryData.NextOwnerMask; | ||
| 7076 | //newTaskItem.GroupOwned=updatetask.InventoryData.GroupOwned; | ||
| 7077 | newTaskItem.Type = updatetask.InventoryData.Type; | ||
| 7078 | newTaskItem.InvType = updatetask.InventoryData.InvType; | ||
| 7079 | newTaskItem.Flags = updatetask.InventoryData.Flags; | ||
| 7080 | //newTaskItem.SaleType=updatetask.InventoryData.SaleType; | ||
| 7081 | //newTaskItem.SalePrice=updatetask.InventoryData.SalePrice;; | ||
| 7082 | newTaskItem.Name = Util.FieldToString(updatetask.InventoryData.Name); | ||
| 7083 | newTaskItem.Description = Util.FieldToString(updatetask.InventoryData.Description); | ||
| 7084 | newTaskItem.CreationDate = (uint)updatetask.InventoryData.CreationDate; | ||
| 7085 | handlerUpdateTaskInventory(this, updatetask.InventoryData.TransactionID, | ||
| 7086 | newTaskItem, updatetask.UpdateData.LocalID); | ||
| 7087 | } | ||
| 7088 | } | ||
| 7089 | } | ||
| 7090 | |||
| 7091 | return true; | ||
| 7092 | } | ||
| 7093 | |||
| 7094 | private bool HandleRemoveTaskInventory(IClientAPI sender, Packet Pack) | ||
| 7095 | { | ||
| 7096 | RemoveTaskInventoryPacket removeTask = (RemoveTaskInventoryPacket)Pack; | ||
| 7097 | |||
| 7098 | #region Packet Session and User Check | ||
| 7099 | if (m_checkPackets) | ||
| 7100 | { | ||
| 7101 | if (removeTask.AgentData.SessionID != SessionId || | ||
| 7102 | removeTask.AgentData.AgentID != AgentId) | ||
| 7103 | return true; | ||
| 7104 | } | ||
| 7105 | #endregion | ||
| 7106 | |||
| 7107 | RemoveTaskInventory handlerRemoveTaskItem = OnRemoveTaskItem; | ||
| 7108 | |||
| 7109 | if (handlerRemoveTaskItem != null) | ||
| 7110 | { | ||
| 7111 | handlerRemoveTaskItem(this, removeTask.InventoryData.ItemID, removeTask.InventoryData.LocalID); | ||
| 7112 | } | ||
| 7113 | |||
| 7114 | return true; | ||
| 7115 | } | ||
| 7116 | |||
| 7117 | private bool HandleMoveTaskInventory(IClientAPI sender, Packet Pack) | ||
| 7118 | { | ||
| 7119 | MoveTaskInventoryPacket moveTaskInventoryPacket = (MoveTaskInventoryPacket)Pack; | ||
| 7120 | |||
| 7121 | #region Packet Session and User Check | ||
| 7122 | if (m_checkPackets) | ||
| 7123 | { | ||
| 7124 | if (moveTaskInventoryPacket.AgentData.SessionID != SessionId || | ||
| 7125 | moveTaskInventoryPacket.AgentData.AgentID != AgentId) | ||
| 7126 | return true; | ||
| 7127 | } | ||
| 7128 | #endregion | ||
| 7129 | |||
| 7130 | MoveTaskInventory handlerMoveTaskItem = OnMoveTaskItem; | ||
| 7131 | |||
| 7132 | if (handlerMoveTaskItem != null) | ||
| 7133 | { | ||
| 7134 | handlerMoveTaskItem( | ||
| 7135 | this, moveTaskInventoryPacket.AgentData.FolderID, | ||
| 7136 | moveTaskInventoryPacket.InventoryData.LocalID, | ||
| 7137 | moveTaskInventoryPacket.InventoryData.ItemID); | ||
| 7138 | } | ||
| 7139 | |||
| 7140 | return true; | ||
| 7141 | } | ||
| 7142 | |||
| 7143 | private bool HandleRezScript(IClientAPI sender, Packet Pack) | ||
| 7144 | { | ||
| 7145 | //m_log.Debug(Pack.ToString()); | ||
| 7146 | RezScriptPacket rezScriptx = (RezScriptPacket)Pack; | ||
| 7147 | |||
| 7148 | #region Packet Session and User Check | ||
| 7149 | if (m_checkPackets) | ||
| 7150 | { | ||
| 7151 | if (rezScriptx.AgentData.SessionID != SessionId || | ||
| 7152 | rezScriptx.AgentData.AgentID != AgentId) | ||
| 7153 | return true; | ||
| 7154 | } | ||
| 7155 | #endregion | ||
| 7156 | |||
| 7157 | RezScript handlerRezScript = OnRezScript; | ||
| 7158 | InventoryItemBase item = new InventoryItemBase(); | ||
| 7159 | item.ID = rezScriptx.InventoryBlock.ItemID; | ||
| 7160 | item.Folder = rezScriptx.InventoryBlock.FolderID; | ||
| 7161 | item.CreatorId = rezScriptx.InventoryBlock.CreatorID.ToString(); | ||
| 7162 | item.Owner = rezScriptx.InventoryBlock.OwnerID; | ||
| 7163 | item.BasePermissions = rezScriptx.InventoryBlock.BaseMask; | ||
| 7164 | item.CurrentPermissions = rezScriptx.InventoryBlock.OwnerMask; | ||
| 7165 | item.EveryOnePermissions = rezScriptx.InventoryBlock.EveryoneMask; | ||
| 7166 | item.NextPermissions = rezScriptx.InventoryBlock.NextOwnerMask; | ||
| 7167 | item.GroupPermissions = rezScriptx.InventoryBlock.GroupMask; | ||
| 7168 | item.GroupOwned = rezScriptx.InventoryBlock.GroupOwned; | ||
| 7169 | item.GroupID = rezScriptx.InventoryBlock.GroupID; | ||
| 7170 | item.AssetType = rezScriptx.InventoryBlock.Type; | ||
| 7171 | item.InvType = rezScriptx.InventoryBlock.InvType; | ||
| 7172 | item.Flags = rezScriptx.InventoryBlock.Flags; | ||
| 7173 | item.SaleType = rezScriptx.InventoryBlock.SaleType; | ||
| 7174 | item.SalePrice = rezScriptx.InventoryBlock.SalePrice; | ||
| 7175 | item.Name = Util.FieldToString(rezScriptx.InventoryBlock.Name); | ||
| 7176 | item.Description = Util.FieldToString(rezScriptx.InventoryBlock.Description); | ||
| 7177 | item.CreationDate = rezScriptx.InventoryBlock.CreationDate; | ||
| 7178 | |||
| 7179 | if (handlerRezScript != null) | ||
| 7180 | { | ||
| 7181 | handlerRezScript(this, item, rezScriptx.InventoryBlock.TransactionID, rezScriptx.UpdateBlock.ObjectLocalID); | ||
| 7182 | } | ||
| 7183 | return true; | ||
| 7184 | } | ||
| 7185 | |||
| 7186 | private bool HandleMapLayerRequest(IClientAPI sender, Packet Pack) | ||
| 7187 | { | ||
| 7188 | RequestMapLayer(); | ||
| 7189 | return true; | ||
| 7190 | } | ||
| 7191 | |||
| 7192 | private bool HandleMapBlockRequest(IClientAPI sender, Packet Pack) | ||
| 7193 | { | ||
| 7194 | MapBlockRequestPacket MapRequest = (MapBlockRequestPacket)Pack; | ||
| 7195 | |||
| 7196 | #region Packet Session and User Check | ||
| 7197 | if (m_checkPackets) | ||
| 7198 | { | ||
| 7199 | if (MapRequest.AgentData.SessionID != SessionId || | ||
| 7200 | MapRequest.AgentData.AgentID != AgentId) | ||
| 7201 | return true; | ||
| 7202 | } | ||
| 7203 | #endregion | ||
| 7204 | |||
| 7205 | RequestMapBlocks handlerRequestMapBlocks = OnRequestMapBlocks; | ||
| 7206 | if (handlerRequestMapBlocks != null) | ||
| 7207 | { | ||
| 7208 | handlerRequestMapBlocks(this, MapRequest.PositionData.MinX, MapRequest.PositionData.MinY, | ||
| 7209 | MapRequest.PositionData.MaxX, MapRequest.PositionData.MaxY, MapRequest.AgentData.Flags); | ||
| 7210 | } | ||
| 7211 | return true; | ||
| 7212 | } | ||
| 7213 | |||
| 7214 | private bool HandleMapNameRequest(IClientAPI sender, Packet Pack) | ||
| 7215 | { | ||
| 7216 | MapNameRequestPacket map = (MapNameRequestPacket)Pack; | ||
| 7217 | |||
| 7218 | #region Packet Session and User Check | ||
| 7219 | if (m_checkPackets) | ||
| 7220 | { | ||
| 7221 | if (map.AgentData.SessionID != SessionId || | ||
| 7222 | map.AgentData.AgentID != AgentId) | ||
| 7223 | return true; | ||
| 7224 | } | ||
| 7225 | #endregion | ||
| 7226 | |||
| 7227 | string mapName = Util.UTF8.GetString(map.NameData.Name, 0, | ||
| 7228 | map.NameData.Name.Length - 1); | ||
| 7229 | RequestMapName handlerMapNameRequest = OnMapNameRequest; | ||
| 7230 | if (handlerMapNameRequest != null) | ||
| 7231 | { | ||
| 7232 | handlerMapNameRequest(this, mapName); | ||
| 7233 | } | ||
| 7234 | return true; | ||
| 7235 | } | ||
| 7236 | |||
| 7237 | private bool HandleTeleportLandmarkRequest(IClientAPI sender, Packet Pack) | ||
| 7238 | { | ||
| 7239 | TeleportLandmarkRequestPacket tpReq = (TeleportLandmarkRequestPacket)Pack; | ||
| 7240 | |||
| 7241 | #region Packet Session and User Check | ||
| 7242 | if (m_checkPackets) | ||
| 7243 | { | ||
| 7244 | if (tpReq.Info.SessionID != SessionId || | ||
| 7245 | tpReq.Info.AgentID != AgentId) | ||
| 7246 | return true; | ||
| 7247 | } | ||
| 7248 | #endregion | ||
| 7249 | |||
| 7250 | UUID lmid = tpReq.Info.LandmarkID; | ||
| 7251 | AssetLandmark lm; | ||
| 7252 | if (lmid != UUID.Zero) | ||
| 7253 | { | ||
| 7254 | //AssetBase lma = m_assetCache.GetAsset(lmid, false); | ||
| 7255 | AssetBase lma = m_assetService.Get(lmid.ToString()); | ||
| 7256 | |||
| 7257 | if (lma == null) | ||
| 7258 | { | ||
| 7259 | // Failed to find landmark | ||
| 7260 | TeleportCancelPacket tpCancel = (TeleportCancelPacket)PacketPool.Instance.GetPacket(PacketType.TeleportCancel); | ||
| 7261 | tpCancel.Info.SessionID = tpReq.Info.SessionID; | ||
| 7262 | tpCancel.Info.AgentID = tpReq.Info.AgentID; | ||
| 7263 | OutPacket(tpCancel, ThrottleOutPacketType.Task); | ||
| 7264 | } | ||
| 7265 | |||
| 7266 | try | ||
| 7267 | { | ||
| 7268 | lm = new AssetLandmark(lma); | ||
| 7269 | } | ||
| 7270 | catch (NullReferenceException) | ||
| 7271 | { | ||
| 7272 | // asset not found generates null ref inside the assetlandmark constructor. | ||
| 7273 | TeleportCancelPacket tpCancel = (TeleportCancelPacket)PacketPool.Instance.GetPacket(PacketType.TeleportCancel); | ||
| 7274 | tpCancel.Info.SessionID = tpReq.Info.SessionID; | ||
| 7275 | tpCancel.Info.AgentID = tpReq.Info.AgentID; | ||
| 7276 | OutPacket(tpCancel, ThrottleOutPacketType.Task); | ||
| 7277 | return true; | ||
| 7278 | } | ||
| 7279 | } | ||
| 7280 | else | ||
| 7281 | { | ||
| 7282 | // Teleport home request | ||
| 7283 | UUIDNameRequest handlerTeleportHomeRequest = OnTeleportHomeRequest; | ||
| 7284 | if (handlerTeleportHomeRequest != null) | ||
| 7285 | { | ||
| 7286 | handlerTeleportHomeRequest(AgentId, this); | ||
| 7287 | } | ||
| 7288 | return true; | ||
| 7289 | } | ||
| 7290 | |||
| 7291 | TeleportLandmarkRequest handlerTeleportLandmarkRequest = OnTeleportLandmarkRequest; | ||
| 7292 | if (handlerTeleportLandmarkRequest != null) | ||
| 7293 | { | ||
| 7294 | handlerTeleportLandmarkRequest(this, lm.RegionID, lm.Position); | ||
| 7295 | } | ||
| 7296 | else | ||
| 7297 | { | ||
| 7298 | //no event handler so cancel request | ||
| 7299 | |||
| 7300 | |||
| 7301 | TeleportCancelPacket tpCancel = (TeleportCancelPacket)PacketPool.Instance.GetPacket(PacketType.TeleportCancel); | ||
| 7302 | tpCancel.Info.AgentID = tpReq.Info.AgentID; | ||
| 7303 | tpCancel.Info.SessionID = tpReq.Info.SessionID; | ||
| 7304 | OutPacket(tpCancel, ThrottleOutPacketType.Task); | ||
| 7305 | |||
| 7306 | } | ||
| 7307 | return true; | ||
| 7308 | } | ||
| 7309 | |||
| 7310 | private bool HandleTeleportLocationRequest(IClientAPI sender, Packet Pack) | ||
| 7311 | { | ||
| 7312 | TeleportLocationRequestPacket tpLocReq = (TeleportLocationRequestPacket)Pack; | ||
| 7313 | // m_log.Debug(tpLocReq.ToString()); | ||
| 7314 | |||
| 7315 | #region Packet Session and User Check | ||
| 7316 | if (m_checkPackets) | ||
| 7317 | { | ||
| 7318 | if (tpLocReq.AgentData.SessionID != SessionId || | ||
| 7319 | tpLocReq.AgentData.AgentID != AgentId) | ||
| 7320 | return true; | ||
| 7321 | } | ||
| 7322 | #endregion | ||
| 7323 | |||
| 7324 | TeleportLocationRequest handlerTeleportLocationRequest = OnTeleportLocationRequest; | ||
| 7325 | if (handlerTeleportLocationRequest != null) | ||
| 7326 | { | ||
| 7327 | handlerTeleportLocationRequest(this, tpLocReq.Info.RegionHandle, tpLocReq.Info.Position, | ||
| 7328 | tpLocReq.Info.LookAt, 16); | ||
| 7329 | } | ||
| 7330 | else | ||
| 7331 | { | ||
| 7332 | //no event handler so cancel request | ||
| 7333 | TeleportCancelPacket tpCancel = (TeleportCancelPacket)PacketPool.Instance.GetPacket(PacketType.TeleportCancel); | ||
| 7334 | tpCancel.Info.SessionID = tpLocReq.AgentData.SessionID; | ||
| 7335 | tpCancel.Info.AgentID = tpLocReq.AgentData.AgentID; | ||
| 7336 | OutPacket(tpCancel, ThrottleOutPacketType.Task); | ||
| 7337 | } | ||
| 7338 | return true; | ||
| 7339 | } | ||
| 7340 | |||
| 7341 | #endregion Inventory/Asset/Other related packets | ||
| 7342 | |||
| 7343 | private bool HandleUUIDNameRequest(IClientAPI sender, Packet Pack) | ||
| 7344 | { | ||
| 7345 | UUIDNameRequestPacket incoming = (UUIDNameRequestPacket)Pack; | ||
| 7346 | |||
| 7347 | foreach (UUIDNameRequestPacket.UUIDNameBlockBlock UUIDBlock in incoming.UUIDNameBlock) | ||
| 7348 | { | ||
| 7349 | UUIDNameRequest handlerNameRequest = OnNameFromUUIDRequest; | ||
| 7350 | if (handlerNameRequest != null) | ||
| 7351 | { | ||
| 7352 | handlerNameRequest(UUIDBlock.ID, this); | ||
| 7353 | } | ||
| 7354 | } | ||
| 7355 | return true; | ||
| 7356 | } | ||
| 7357 | |||
| 7358 | #region Parcel related packets | ||
| 7359 | |||
| 7360 | private bool HandleRegionHandleRequest(IClientAPI sender, Packet Pack) | ||
| 7361 | { | ||
| 7362 | RegionHandleRequestPacket rhrPack = (RegionHandleRequestPacket)Pack; | ||
| 7363 | |||
| 7364 | RegionHandleRequest handlerRegionHandleRequest = OnRegionHandleRequest; | ||
| 7365 | if (handlerRegionHandleRequest != null) | ||
| 7366 | { | ||
| 7367 | handlerRegionHandleRequest(this, rhrPack.RequestBlock.RegionID); | ||
| 7368 | } | ||
| 7369 | return true; | ||
| 7370 | } | ||
| 7371 | |||
| 7372 | private bool HandleParcelInfoRequest(IClientAPI sender, Packet Pack) | ||
| 7373 | { | ||
| 7374 | ParcelInfoRequestPacket pirPack = (ParcelInfoRequestPacket)Pack; | ||
| 7375 | |||
| 7376 | #region Packet Session and User Check | ||
| 7377 | if (m_checkPackets) | ||
| 7378 | { | ||
| 7379 | if (pirPack.AgentData.SessionID != SessionId || | ||
| 7380 | pirPack.AgentData.AgentID != AgentId) | ||
| 7381 | return true; | ||
| 7382 | } | ||
| 7383 | #endregion | ||
| 7384 | |||
| 7385 | ParcelInfoRequest handlerParcelInfoRequest = OnParcelInfoRequest; | ||
| 7386 | if (handlerParcelInfoRequest != null) | ||
| 7387 | { | ||
| 7388 | handlerParcelInfoRequest(this, pirPack.Data.ParcelID); | ||
| 7389 | } | ||
| 7390 | return true; | ||
| 7391 | } | ||
| 7392 | |||
| 7393 | private bool HandleParcelAccessListRequest(IClientAPI sender, Packet Pack) | ||
| 7394 | { | ||
| 7395 | ParcelAccessListRequestPacket requestPacket = (ParcelAccessListRequestPacket)Pack; | ||
| 7396 | |||
| 7397 | #region Packet Session and User Check | ||
| 7398 | if (m_checkPackets) | ||
| 7399 | { | ||
| 7400 | if (requestPacket.AgentData.SessionID != SessionId || | ||
| 7401 | requestPacket.AgentData.AgentID != AgentId) | ||
| 7402 | return true; | ||
| 7403 | } | ||
| 7404 | #endregion | ||
| 7405 | |||
| 7406 | ParcelAccessListRequest handlerParcelAccessListRequest = OnParcelAccessListRequest; | ||
| 7407 | |||
| 7408 | if (handlerParcelAccessListRequest != null) | ||
| 7409 | { | ||
| 7410 | handlerParcelAccessListRequest(requestPacket.AgentData.AgentID, requestPacket.AgentData.SessionID, | ||
| 7411 | requestPacket.Data.Flags, requestPacket.Data.SequenceID, | ||
| 7412 | requestPacket.Data.LocalID, this); | ||
| 7413 | } | ||
| 7414 | return true; | ||
| 7415 | } | ||
| 7416 | |||
| 7417 | private bool HandleParcelAccessListUpdate(IClientAPI sender, Packet Pack) | ||
| 7418 | { | ||
| 7419 | ParcelAccessListUpdatePacket updatePacket = (ParcelAccessListUpdatePacket)Pack; | ||
| 7420 | |||
| 7421 | #region Packet Session and User Check | ||
| 7422 | if (m_checkPackets) | ||
| 7423 | { | ||
| 7424 | if (updatePacket.AgentData.SessionID != SessionId || | ||
| 7425 | updatePacket.AgentData.AgentID != AgentId) | ||
| 7426 | return true; | ||
| 7427 | } | ||
| 7428 | #endregion | ||
| 7429 | |||
| 7430 | List<ParcelManager.ParcelAccessEntry> entries = new List<ParcelManager.ParcelAccessEntry>(); | ||
| 7431 | foreach (ParcelAccessListUpdatePacket.ListBlock block in updatePacket.List) | ||
| 7432 | { | ||
| 7433 | ParcelManager.ParcelAccessEntry entry = new ParcelManager.ParcelAccessEntry(); | ||
| 7434 | entry.AgentID = block.ID; | ||
| 7435 | entry.Flags = (AccessList)block.Flags; | ||
| 7436 | entry.Time = new DateTime(); | ||
| 7437 | entries.Add(entry); | ||
| 7438 | } | ||
| 7439 | |||
| 7440 | ParcelAccessListUpdateRequest handlerParcelAccessListUpdateRequest = OnParcelAccessListUpdateRequest; | ||
| 7441 | if (handlerParcelAccessListUpdateRequest != null) | ||
| 7442 | { | ||
| 7443 | handlerParcelAccessListUpdateRequest(updatePacket.AgentData.AgentID, | ||
| 7444 | updatePacket.AgentData.SessionID, updatePacket.Data.Flags, | ||
| 7445 | updatePacket.Data.LocalID, entries, this); | ||
| 7446 | } | ||
| 7447 | return true; | ||
| 7448 | } | ||
| 7449 | |||
| 7450 | private bool HandleParcelPropertiesRequest(IClientAPI sender, Packet Pack) | ||
| 7451 | { | ||
| 7452 | ParcelPropertiesRequestPacket propertiesRequest = (ParcelPropertiesRequestPacket)Pack; | ||
| 7453 | |||
| 7454 | #region Packet Session and User Check | ||
| 7455 | if (m_checkPackets) | ||
| 7456 | { | ||
| 7457 | if (propertiesRequest.AgentData.SessionID != SessionId || | ||
| 7458 | propertiesRequest.AgentData.AgentID != AgentId) | ||
| 7459 | return true; | ||
| 7460 | } | ||
| 7461 | #endregion | ||
| 7462 | |||
| 7463 | ParcelPropertiesRequest handlerParcelPropertiesRequest = OnParcelPropertiesRequest; | ||
| 7464 | if (handlerParcelPropertiesRequest != null) | ||
| 7465 | { | ||
| 7466 | handlerParcelPropertiesRequest((int)Math.Round(propertiesRequest.ParcelData.West), | ||
| 7467 | (int)Math.Round(propertiesRequest.ParcelData.South), | ||
| 7468 | (int)Math.Round(propertiesRequest.ParcelData.East), | ||
| 7469 | (int)Math.Round(propertiesRequest.ParcelData.North), | ||
| 7470 | propertiesRequest.ParcelData.SequenceID, | ||
| 7471 | propertiesRequest.ParcelData.SnapSelection, this); | ||
| 7472 | } | ||
| 7473 | return true; | ||
| 7474 | } | ||
| 7475 | |||
| 7476 | private bool HandleParcelDivide(IClientAPI sender, Packet Pack) | ||
| 7477 | { | ||
| 7478 | ParcelDividePacket landDivide = (ParcelDividePacket)Pack; | ||
| 7479 | |||
| 7480 | #region Packet Session and User Check | ||
| 7481 | if (m_checkPackets) | ||
| 7482 | { | ||
| 7483 | if (landDivide.AgentData.SessionID != SessionId || | ||
| 7484 | landDivide.AgentData.AgentID != AgentId) | ||
| 7485 | return true; | ||
| 7486 | } | ||
| 7487 | #endregion | ||
| 7488 | |||
| 7489 | ParcelDivideRequest handlerParcelDivideRequest = OnParcelDivideRequest; | ||
| 7490 | if (handlerParcelDivideRequest != null) | ||
| 7491 | { | ||
| 7492 | handlerParcelDivideRequest((int)Math.Round(landDivide.ParcelData.West), | ||
| 7493 | (int)Math.Round(landDivide.ParcelData.South), | ||
| 7494 | (int)Math.Round(landDivide.ParcelData.East), | ||
| 7495 | (int)Math.Round(landDivide.ParcelData.North), this); | ||
| 7496 | } | ||
| 7497 | return true; | ||
| 7498 | } | ||
| 7499 | |||
| 7500 | private bool HandleParcelJoin(IClientAPI sender, Packet Pack) | ||
| 7501 | { | ||
| 7502 | ParcelJoinPacket landJoin = (ParcelJoinPacket)Pack; | ||
| 7503 | |||
| 7504 | #region Packet Session and User Check | ||
| 7505 | if (m_checkPackets) | ||
| 7506 | { | ||
| 7507 | if (landJoin.AgentData.SessionID != SessionId || | ||
| 7508 | landJoin.AgentData.AgentID != AgentId) | ||
| 7509 | return true; | ||
| 7510 | } | ||
| 7511 | #endregion | ||
| 7512 | |||
| 7513 | ParcelJoinRequest handlerParcelJoinRequest = OnParcelJoinRequest; | ||
| 7514 | |||
| 7515 | if (handlerParcelJoinRequest != null) | ||
| 7516 | { | ||
| 7517 | handlerParcelJoinRequest((int)Math.Round(landJoin.ParcelData.West), | ||
| 7518 | (int)Math.Round(landJoin.ParcelData.South), | ||
| 7519 | (int)Math.Round(landJoin.ParcelData.East), | ||
| 7520 | (int)Math.Round(landJoin.ParcelData.North), this); | ||
| 7521 | } | ||
| 7522 | return true; | ||
| 7523 | } | ||
| 7524 | |||
| 7525 | private bool HandleParcelPropertiesUpdate(IClientAPI sender, Packet Pack) | ||
| 7526 | { | ||
| 7527 | ParcelPropertiesUpdatePacket parcelPropertiesPacket = (ParcelPropertiesUpdatePacket)Pack; | ||
| 7528 | |||
| 7529 | #region Packet Session and User Check | ||
| 7530 | if (m_checkPackets) | ||
| 7531 | { | ||
| 7532 | if (parcelPropertiesPacket.AgentData.SessionID != SessionId || | ||
| 7533 | parcelPropertiesPacket.AgentData.AgentID != AgentId) | ||
| 7534 | return true; | ||
| 7535 | } | ||
| 7536 | #endregion | ||
| 7537 | |||
| 7538 | ParcelPropertiesUpdateRequest handlerParcelPropertiesUpdateRequest = OnParcelPropertiesUpdateRequest; | ||
| 7539 | |||
| 7540 | if (handlerParcelPropertiesUpdateRequest != null) | ||
| 7541 | { | ||
| 7542 | LandUpdateArgs args = new LandUpdateArgs(); | ||
| 7543 | |||
| 7544 | args.AuthBuyerID = parcelPropertiesPacket.ParcelData.AuthBuyerID; | ||
| 7545 | args.Category = (ParcelCategory)parcelPropertiesPacket.ParcelData.Category; | ||
| 7546 | args.Desc = Utils.BytesToString(parcelPropertiesPacket.ParcelData.Desc); | ||
| 7547 | args.GroupID = parcelPropertiesPacket.ParcelData.GroupID; | ||
| 7548 | args.LandingType = parcelPropertiesPacket.ParcelData.LandingType; | ||
| 7549 | args.MediaAutoScale = parcelPropertiesPacket.ParcelData.MediaAutoScale; | ||
| 7550 | args.MediaID = parcelPropertiesPacket.ParcelData.MediaID; | ||
| 7551 | args.MediaURL = Utils.BytesToString(parcelPropertiesPacket.ParcelData.MediaURL); | ||
| 7552 | args.MusicURL = Utils.BytesToString(parcelPropertiesPacket.ParcelData.MusicURL); | ||
| 7553 | args.Name = Utils.BytesToString(parcelPropertiesPacket.ParcelData.Name); | ||
| 7554 | args.ParcelFlags = parcelPropertiesPacket.ParcelData.ParcelFlags; | ||
| 7555 | args.PassHours = parcelPropertiesPacket.ParcelData.PassHours; | ||
| 7556 | args.PassPrice = parcelPropertiesPacket.ParcelData.PassPrice; | ||
| 7557 | args.SalePrice = parcelPropertiesPacket.ParcelData.SalePrice; | ||
| 7558 | args.SnapshotID = parcelPropertiesPacket.ParcelData.SnapshotID; | ||
| 7559 | args.UserLocation = parcelPropertiesPacket.ParcelData.UserLocation; | ||
| 7560 | args.UserLookAt = parcelPropertiesPacket.ParcelData.UserLookAt; | ||
| 7561 | handlerParcelPropertiesUpdateRequest(args, parcelPropertiesPacket.ParcelData.LocalID, this); | ||
| 7562 | } | ||
| 7563 | return true; | ||
| 7564 | } | ||
| 7565 | |||
| 7566 | private bool HandleParcelSelectObjects(IClientAPI sender, Packet Pack) | ||
| 7567 | { | ||
| 7568 | ParcelSelectObjectsPacket selectPacket = (ParcelSelectObjectsPacket)Pack; | ||
| 7569 | |||
| 7570 | #region Packet Session and User Check | ||
| 7571 | if (m_checkPackets) | ||
| 7572 | { | ||
| 7573 | if (selectPacket.AgentData.SessionID != SessionId || | ||
| 7574 | selectPacket.AgentData.AgentID != AgentId) | ||
| 7575 | return true; | ||
| 7576 | } | ||
| 7577 | #endregion | ||
| 7578 | |||
| 7579 | List<UUID> returnIDs = new List<UUID>(); | ||
| 7580 | |||
| 7581 | foreach (ParcelSelectObjectsPacket.ReturnIDsBlock rb in | ||
| 7582 | selectPacket.ReturnIDs) | ||
| 7583 | { | ||
| 7584 | returnIDs.Add(rb.ReturnID); | ||
| 7585 | } | ||
| 7586 | |||
| 7587 | ParcelSelectObjects handlerParcelSelectObjects = OnParcelSelectObjects; | ||
| 7588 | |||
| 7589 | if (handlerParcelSelectObjects != null) | ||
| 7590 | { | ||
| 7591 | handlerParcelSelectObjects(selectPacket.ParcelData.LocalID, | ||
| 7592 | Convert.ToInt32(selectPacket.ParcelData.ReturnType), returnIDs, this); | ||
| 7593 | } | ||
| 7594 | return true; | ||
| 7595 | } | ||
| 7596 | |||
| 7597 | private bool HandleParcelObjectOwnersRequest(IClientAPI sender, Packet Pack) | ||
| 7598 | { | ||
| 7599 | ParcelObjectOwnersRequestPacket reqPacket = (ParcelObjectOwnersRequestPacket)Pack; | ||
| 7600 | |||
| 7601 | #region Packet Session and User Check | ||
| 7602 | if (m_checkPackets) | ||
| 7603 | { | ||
| 7604 | if (reqPacket.AgentData.SessionID != SessionId || | ||
| 7605 | reqPacket.AgentData.AgentID != AgentId) | ||
| 7606 | return true; | ||
| 7607 | } | ||
| 7608 | #endregion | ||
| 7609 | |||
| 7610 | ParcelObjectOwnerRequest handlerParcelObjectOwnerRequest = OnParcelObjectOwnerRequest; | ||
| 7611 | |||
| 7612 | if (handlerParcelObjectOwnerRequest != null) | ||
| 7613 | { | ||
| 7614 | handlerParcelObjectOwnerRequest(reqPacket.ParcelData.LocalID, this); | ||
| 7615 | } | ||
| 7616 | return true; | ||
| 7617 | |||
| 7618 | } | ||
| 7619 | |||
| 7620 | private bool HandleParcelGodForceOwner(IClientAPI sender, Packet Pack) | ||
| 7621 | { | ||
| 7622 | ParcelGodForceOwnerPacket godForceOwnerPacket = (ParcelGodForceOwnerPacket)Pack; | ||
| 7623 | |||
| 7624 | #region Packet Session and User Check | ||
| 7625 | if (m_checkPackets) | ||
| 7626 | { | ||
| 7627 | if (godForceOwnerPacket.AgentData.SessionID != SessionId || | ||
| 7628 | godForceOwnerPacket.AgentData.AgentID != AgentId) | ||
| 7629 | return true; | ||
| 7630 | } | ||
| 7631 | #endregion | ||
| 7632 | |||
| 7633 | ParcelGodForceOwner handlerParcelGodForceOwner = OnParcelGodForceOwner; | ||
| 7634 | if (handlerParcelGodForceOwner != null) | ||
| 7635 | { | ||
| 7636 | handlerParcelGodForceOwner(godForceOwnerPacket.Data.LocalID, godForceOwnerPacket.Data.OwnerID, this); | ||
| 7637 | } | ||
| 7638 | return true; | ||
| 7639 | } | ||
| 7640 | |||
| 7641 | private bool HandleParcelRelease(IClientAPI sender, Packet Pack) | ||
| 7642 | { | ||
| 7643 | ParcelReleasePacket releasePacket = (ParcelReleasePacket)Pack; | ||
| 7644 | |||
| 7645 | #region Packet Session and User Check | ||
| 7646 | if (m_checkPackets) | ||
| 7647 | { | ||
| 7648 | if (releasePacket.AgentData.SessionID != SessionId || | ||
| 7649 | releasePacket.AgentData.AgentID != AgentId) | ||
| 7650 | return true; | ||
| 7651 | } | ||
| 7652 | #endregion | ||
| 7653 | |||
| 7654 | ParcelAbandonRequest handlerParcelAbandonRequest = OnParcelAbandonRequest; | ||
| 7655 | if (handlerParcelAbandonRequest != null) | ||
| 7656 | { | ||
| 7657 | handlerParcelAbandonRequest(releasePacket.Data.LocalID, this); | ||
| 7658 | } | ||
| 7659 | return true; | ||
| 7660 | } | ||
| 7661 | |||
| 7662 | private bool HandleParcelReclaim(IClientAPI sender, Packet Pack) | ||
| 7663 | { | ||
| 7664 | ParcelReclaimPacket reclaimPacket = (ParcelReclaimPacket)Pack; | ||
| 7665 | |||
| 7666 | #region Packet Session and User Check | ||
| 7667 | if (m_checkPackets) | ||
| 7668 | { | ||
| 7669 | if (reclaimPacket.AgentData.SessionID != SessionId || | ||
| 7670 | reclaimPacket.AgentData.AgentID != AgentId) | ||
| 7671 | return true; | ||
| 7672 | } | ||
| 7673 | #endregion | ||
| 7674 | |||
| 7675 | ParcelReclaim handlerParcelReclaim = OnParcelReclaim; | ||
| 7676 | if (handlerParcelReclaim != null) | ||
| 7677 | { | ||
| 7678 | handlerParcelReclaim(reclaimPacket.Data.LocalID, this); | ||
| 7679 | } | ||
| 7680 | return true; | ||
| 7681 | } | ||
| 7682 | |||
| 7683 | private bool HandleParcelReturnObjects(IClientAPI sender, Packet Pack) | ||
| 7684 | { | ||
| 7685 | ParcelReturnObjectsPacket parcelReturnObjects = (ParcelReturnObjectsPacket)Pack; | ||
| 7686 | |||
| 7687 | #region Packet Session and User Check | ||
| 7688 | if (m_checkPackets) | ||
| 7689 | { | ||
| 7690 | if (parcelReturnObjects.AgentData.SessionID != SessionId || | ||
| 7691 | parcelReturnObjects.AgentData.AgentID != AgentId) | ||
| 7692 | return true; | ||
| 7693 | } | ||
| 7694 | #endregion | ||
| 7695 | |||
| 7696 | UUID[] puserselectedOwnerIDs = new UUID[parcelReturnObjects.OwnerIDs.Length]; | ||
| 7697 | for (int parceliterator = 0; parceliterator < parcelReturnObjects.OwnerIDs.Length; parceliterator++) | ||
| 7698 | puserselectedOwnerIDs[parceliterator] = parcelReturnObjects.OwnerIDs[parceliterator].OwnerID; | ||
| 7699 | |||
| 7700 | UUID[] puserselectedTaskIDs = new UUID[parcelReturnObjects.TaskIDs.Length]; | ||
| 7701 | |||
| 7702 | for (int parceliterator = 0; parceliterator < parcelReturnObjects.TaskIDs.Length; parceliterator++) | ||
| 7703 | puserselectedTaskIDs[parceliterator] = parcelReturnObjects.TaskIDs[parceliterator].TaskID; | ||
| 7704 | |||
| 7705 | ParcelReturnObjectsRequest handlerParcelReturnObjectsRequest = OnParcelReturnObjectsRequest; | ||
| 7706 | if (handlerParcelReturnObjectsRequest != null) | ||
| 7707 | { | ||
| 7708 | handlerParcelReturnObjectsRequest(parcelReturnObjects.ParcelData.LocalID, parcelReturnObjects.ParcelData.ReturnType, puserselectedOwnerIDs, puserselectedTaskIDs, this); | ||
| 7709 | |||
| 7710 | } | ||
| 7711 | return true; | ||
| 7712 | } | ||
| 7713 | |||
| 7714 | private bool HandleParcelSetOtherCleanTime(IClientAPI sender, Packet Pack) | ||
| 7715 | { | ||
| 7716 | ParcelSetOtherCleanTimePacket parcelSetOtherCleanTimePacket = (ParcelSetOtherCleanTimePacket)Pack; | ||
| 7717 | |||
| 7718 | #region Packet Session and User Check | ||
| 7719 | if (m_checkPackets) | ||
| 7720 | { | ||
| 7721 | if (parcelSetOtherCleanTimePacket.AgentData.SessionID != SessionId || | ||
| 7722 | parcelSetOtherCleanTimePacket.AgentData.AgentID != AgentId) | ||
| 7723 | return true; | ||
| 7724 | } | ||
| 7725 | #endregion | ||
| 7726 | |||
| 7727 | ParcelSetOtherCleanTime handlerParcelSetOtherCleanTime = OnParcelSetOtherCleanTime; | ||
| 7728 | if (handlerParcelSetOtherCleanTime != null) | ||
| 7729 | { | ||
| 7730 | handlerParcelSetOtherCleanTime(this, | ||
| 7731 | parcelSetOtherCleanTimePacket.ParcelData.LocalID, | ||
| 7732 | parcelSetOtherCleanTimePacket.ParcelData.OtherCleanTime); | ||
| 7733 | } | ||
| 7734 | return true; | ||
| 7735 | } | ||
| 7736 | |||
| 7737 | private bool HandleLandStatRequest(IClientAPI sender, Packet Pack) | ||
| 7738 | { | ||
| 7739 | LandStatRequestPacket lsrp = (LandStatRequestPacket)Pack; | ||
| 7740 | |||
| 7741 | #region Packet Session and User Check | ||
| 7742 | if (m_checkPackets) | ||
| 7743 | { | ||
| 7744 | if (lsrp.AgentData.SessionID != SessionId || | ||
| 7745 | lsrp.AgentData.AgentID != AgentId) | ||
| 7746 | return true; | ||
| 7747 | } | ||
| 7748 | #endregion | ||
| 7749 | |||
| 7750 | GodLandStatRequest handlerLandStatRequest = OnLandStatRequest; | ||
| 7751 | if (handlerLandStatRequest != null) | ||
| 7752 | { | ||
| 7753 | handlerLandStatRequest(lsrp.RequestData.ParcelLocalID, lsrp.RequestData.ReportType, lsrp.RequestData.RequestFlags, Utils.BytesToString(lsrp.RequestData.Filter), this); | ||
| 7754 | } | ||
| 7755 | return true; | ||
| 7756 | } | ||
| 7757 | |||
| 7758 | private bool HandleParcelDwellRequest(IClientAPI sender, Packet Pack) | ||
| 7759 | { | ||
| 7760 | ParcelDwellRequestPacket dwellrq = | ||
| 7761 | (ParcelDwellRequestPacket)Pack; | ||
| 7762 | |||
| 7763 | #region Packet Session and User Check | ||
| 7764 | if (m_checkPackets) | ||
| 7765 | { | ||
| 7766 | if (dwellrq.AgentData.SessionID != SessionId || | ||
| 7767 | dwellrq.AgentData.AgentID != AgentId) | ||
| 7768 | return true; | ||
| 7769 | } | ||
| 7770 | #endregion | ||
| 7771 | |||
| 7772 | ParcelDwellRequest handlerParcelDwellRequest = OnParcelDwellRequest; | ||
| 7773 | if (handlerParcelDwellRequest != null) | ||
| 7774 | { | ||
| 7775 | handlerParcelDwellRequest(dwellrq.Data.LocalID, this); | ||
| 7776 | } | ||
| 7777 | return true; | ||
| 7778 | } | ||
| 7779 | |||
| 7780 | #endregion Parcel related packets | ||
| 7781 | |||
| 7782 | #region Estate Packets | ||
| 7783 | |||
| 7784 | private bool HandleEstateOwnerMessage(IClientAPI sender, Packet Pack) | ||
| 7785 | { | ||
| 7786 | EstateOwnerMessagePacket messagePacket = (EstateOwnerMessagePacket)Pack; | ||
| 7787 | //m_log.Debug(messagePacket.ToString()); | ||
| 7788 | GodLandStatRequest handlerLandStatRequest; | ||
| 7789 | |||
| 7790 | #region Packet Session and User Check | ||
| 7791 | if (m_checkPackets) | ||
| 7792 | { | ||
| 7793 | if (messagePacket.AgentData.SessionID != SessionId || | ||
| 7794 | messagePacket.AgentData.AgentID != AgentId) | ||
| 7795 | return true; | ||
| 7796 | } | ||
| 7797 | #endregion | ||
| 7798 | |||
| 7799 | switch (Utils.BytesToString(messagePacket.MethodData.Method)) | ||
| 7800 | { | ||
| 7801 | case "getinfo": | ||
| 7802 | if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false)) | ||
| 7803 | { | ||
| 7804 | OnDetailedEstateDataRequest(this, messagePacket.MethodData.Invoice); | ||
| 7805 | } | ||
| 7806 | return true; | ||
| 7807 | case "setregioninfo": | ||
| 7808 | if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false)) | ||
| 7809 | { | ||
| 7810 | OnSetEstateFlagsRequest(convertParamStringToBool(messagePacket.ParamList[0].Parameter), convertParamStringToBool(messagePacket.ParamList[1].Parameter), | ||
| 7811 | convertParamStringToBool(messagePacket.ParamList[2].Parameter), !convertParamStringToBool(messagePacket.ParamList[3].Parameter), | ||
| 7812 | Convert.ToInt16(Convert.ToDecimal(Utils.BytesToString(messagePacket.ParamList[4].Parameter))), | ||
| 7813 | (float)Convert.ToDecimal(Utils.BytesToString(messagePacket.ParamList[5].Parameter)), | ||
| 7814 | Convert.ToInt16(Utils.BytesToString(messagePacket.ParamList[6].Parameter)), | ||
| 7815 | convertParamStringToBool(messagePacket.ParamList[7].Parameter), convertParamStringToBool(messagePacket.ParamList[8].Parameter)); | ||
| 7816 | } | ||
| 7817 | return true; | ||
| 7818 | // case "texturebase": | ||
| 7819 | // if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false)) | ||
| 7820 | // { | ||
| 7821 | // foreach (EstateOwnerMessagePacket.ParamListBlock block in messagePacket.ParamList) | ||
| 7822 | // { | ||
| 7823 | // string s = Utils.BytesToString(block.Parameter); | ||
| 7824 | // string[] splitField = s.Split(' '); | ||
| 7825 | // if (splitField.Length == 2) | ||
| 7826 | // { | ||
| 7827 | // UUID tempUUID = new UUID(splitField[1]); | ||
| 7828 | // OnSetEstateTerrainBaseTexture(this, Convert.ToInt16(splitField[0]), tempUUID); | ||
| 7829 | // } | ||
| 7830 | // } | ||
| 7831 | // } | ||
| 7832 | // break; | ||
| 7833 | case "texturedetail": | ||
| 7834 | if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false)) | ||
| 7835 | { | ||
| 7836 | foreach (EstateOwnerMessagePacket.ParamListBlock block in messagePacket.ParamList) | ||
| 7837 | { | ||
| 7838 | string s = Utils.BytesToString(block.Parameter); | ||
| 7839 | string[] splitField = s.Split(' '); | ||
| 7840 | if (splitField.Length == 2) | ||
| 7841 | { | ||
| 7842 | Int16 corner = Convert.ToInt16(splitField[0]); | ||
| 7843 | UUID textureUUID = new UUID(splitField[1]); | ||
| 7844 | |||
| 7845 | OnSetEstateTerrainDetailTexture(this, corner, textureUUID); | ||
| 7846 | } | ||
| 7847 | } | ||
| 7848 | } | ||
| 7849 | |||
| 7850 | return true; | ||
| 7851 | case "textureheights": | ||
| 7852 | if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false)) | ||
| 7853 | { | ||
| 7854 | foreach (EstateOwnerMessagePacket.ParamListBlock block in messagePacket.ParamList) | ||
| 7855 | { | ||
| 7856 | string s = Utils.BytesToString(block.Parameter); | ||
| 7857 | string[] splitField = s.Split(' '); | ||
| 7858 | if (splitField.Length == 3) | ||
| 7859 | { | ||
| 7860 | Int16 corner = Convert.ToInt16(splitField[0]); | ||
| 7861 | float lowValue = (float)Convert.ToDecimal(splitField[1]); | ||
| 7862 | float highValue = (float)Convert.ToDecimal(splitField[2]); | ||
| 7863 | |||
| 7864 | OnSetEstateTerrainTextureHeights(this, corner, lowValue, highValue); | ||
| 7865 | } | ||
| 7866 | } | ||
| 7867 | } | ||
| 7868 | return true; | ||
| 7869 | case "texturecommit": | ||
| 7870 | OnCommitEstateTerrainTextureRequest(this); | ||
| 7871 | break; | ||
| 7872 | case "setregionterrain": | ||
| 7873 | if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false)) | ||
| 7874 | { | ||
| 7875 | if (messagePacket.ParamList.Length != 9) | ||
| 7876 | { | ||
| 7877 | m_log.Error("EstateOwnerMessage: SetRegionTerrain method has a ParamList of invalid length"); | ||
| 7878 | } | ||
| 7879 | else | ||
| 7880 | { | ||
| 7881 | try | ||
| 7882 | { | ||
| 7883 | string tmp = Utils.BytesToString(messagePacket.ParamList[0].Parameter); | ||
| 7884 | if (!tmp.Contains(".")) tmp += ".00"; | ||
| 7885 | float WaterHeight = (float)Convert.ToDecimal(tmp); | ||
| 7886 | tmp = Utils.BytesToString(messagePacket.ParamList[1].Parameter); | ||
| 7887 | if (!tmp.Contains(".")) tmp += ".00"; | ||
| 7888 | float TerrainRaiseLimit = (float)Convert.ToDecimal(tmp); | ||
| 7889 | tmp = Utils.BytesToString(messagePacket.ParamList[2].Parameter); | ||
| 7890 | if (!tmp.Contains(".")) tmp += ".00"; | ||
| 7891 | float TerrainLowerLimit = (float)Convert.ToDecimal(tmp); | ||
| 7892 | bool UseEstateSun = convertParamStringToBool(messagePacket.ParamList[3].Parameter); | ||
| 7893 | bool UseFixedSun = convertParamStringToBool(messagePacket.ParamList[4].Parameter); | ||
| 7894 | float SunHour = (float)Convert.ToDecimal(Utils.BytesToString(messagePacket.ParamList[5].Parameter)); | ||
| 7895 | bool UseGlobal = convertParamStringToBool(messagePacket.ParamList[6].Parameter); | ||
| 7896 | bool EstateFixedSun = convertParamStringToBool(messagePacket.ParamList[7].Parameter); | ||
| 7897 | float EstateSunHour = (float)Convert.ToDecimal(Utils.BytesToString(messagePacket.ParamList[8].Parameter)); | ||
| 7898 | |||
| 7899 | OnSetRegionTerrainSettings(WaterHeight, TerrainRaiseLimit, TerrainLowerLimit, UseEstateSun, UseFixedSun, SunHour, UseGlobal, EstateFixedSun, EstateSunHour); | ||
| 7900 | |||
| 7901 | } | ||
| 7902 | catch (Exception ex) | ||
| 7903 | { | ||
| 7904 | m_log.Error("EstateOwnerMessage: Exception while setting terrain settings: \n" + messagePacket + "\n" + ex); | ||
| 7905 | } | ||
| 7906 | } | ||
| 7907 | } | ||
| 7908 | |||
| 7909 | return true; | ||
| 7910 | case "restart": | ||
| 7911 | if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false)) | ||
| 7912 | { | ||
| 7913 | // There's only 1 block in the estateResetSim.. and that's the number of seconds till restart. | ||
| 7914 | foreach (EstateOwnerMessagePacket.ParamListBlock block in messagePacket.ParamList) | ||
| 7915 | { | ||
| 7916 | float timeSeconds; | ||
| 7917 | Utils.TryParseSingle(Utils.BytesToString(block.Parameter), out timeSeconds); | ||
| 7918 | timeSeconds = (int)timeSeconds; | ||
| 7919 | OnEstateRestartSimRequest(this, (int)timeSeconds); | ||
| 7920 | |||
| 7921 | } | ||
| 7922 | } | ||
| 7923 | return true; | ||
| 7924 | case "estatechangecovenantid": | ||
| 7925 | if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false)) | ||
| 7926 | { | ||
| 7927 | foreach (EstateOwnerMessagePacket.ParamListBlock block in messagePacket.ParamList) | ||
| 7928 | { | ||
| 7929 | UUID newCovenantID = new UUID(Utils.BytesToString(block.Parameter)); | ||
| 7930 | OnEstateChangeCovenantRequest(this, newCovenantID); | ||
| 7931 | } | ||
| 7932 | } | ||
| 7933 | return true; | ||
| 7934 | case "estateaccessdelta": // Estate access delta manages the banlist and allow list too. | ||
| 7935 | if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false)) | ||
| 7936 | { | ||
| 7937 | int estateAccessType = Convert.ToInt16(Utils.BytesToString(messagePacket.ParamList[1].Parameter)); | ||
| 7938 | OnUpdateEstateAccessDeltaRequest(this, messagePacket.MethodData.Invoice, estateAccessType, new UUID(Utils.BytesToString(messagePacket.ParamList[2].Parameter))); | ||
| 7939 | |||
| 7940 | } | ||
| 7941 | return true; | ||
| 7942 | case "simulatormessage": | ||
| 7943 | if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false)) | ||
| 7944 | { | ||
| 7945 | UUID invoice = messagePacket.MethodData.Invoice; | ||
| 7946 | UUID SenderID = new UUID(Utils.BytesToString(messagePacket.ParamList[2].Parameter)); | ||
| 7947 | string SenderName = Utils.BytesToString(messagePacket.ParamList[3].Parameter); | ||
| 7948 | string Message = Utils.BytesToString(messagePacket.ParamList[4].Parameter); | ||
| 7949 | UUID sessionID = messagePacket.AgentData.SessionID; | ||
| 7950 | OnSimulatorBlueBoxMessageRequest(this, invoice, SenderID, sessionID, SenderName, Message); | ||
| 7951 | } | ||
| 7952 | return true; | ||
| 7953 | case "instantmessage": | ||
| 7954 | if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false)) | ||
| 7955 | { | ||
| 7956 | if (messagePacket.ParamList.Length < 5) | ||
| 7957 | break; | ||
| 7958 | UUID invoice = messagePacket.MethodData.Invoice; | ||
| 7959 | UUID SenderID = new UUID(Utils.BytesToString(messagePacket.ParamList[2].Parameter)); | ||
| 7960 | string SenderName = Utils.BytesToString(messagePacket.ParamList[3].Parameter); | ||
| 7961 | string Message = Utils.BytesToString(messagePacket.ParamList[4].Parameter); | ||
| 7962 | UUID sessionID = messagePacket.AgentData.SessionID; | ||
| 7963 | OnEstateBlueBoxMessageRequest(this, invoice, SenderID, sessionID, SenderName, Message); | ||
| 7964 | } | ||
| 7965 | return true; | ||
| 7966 | case "setregiondebug": | ||
| 7967 | if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false)) | ||
| 7968 | { | ||
| 7969 | UUID invoice = messagePacket.MethodData.Invoice; | ||
| 7970 | UUID SenderID = messagePacket.AgentData.AgentID; | ||
| 7971 | bool scripted = convertParamStringToBool(messagePacket.ParamList[0].Parameter); | ||
| 7972 | bool collisionEvents = convertParamStringToBool(messagePacket.ParamList[1].Parameter); | ||
| 7973 | bool physics = convertParamStringToBool(messagePacket.ParamList[2].Parameter); | ||
| 7974 | |||
| 7975 | OnEstateDebugRegionRequest(this, invoice, SenderID, scripted, collisionEvents, physics); | ||
| 7976 | } | ||
| 7977 | return true; | ||
| 7978 | case "teleporthomeuser": | ||
| 7979 | if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false)) | ||
| 7980 | { | ||
| 7981 | UUID invoice = messagePacket.MethodData.Invoice; | ||
| 7982 | UUID SenderID = messagePacket.AgentData.AgentID; | ||
| 7983 | UUID Prey; | ||
| 7984 | |||
| 7985 | UUID.TryParse(Utils.BytesToString(messagePacket.ParamList[1].Parameter), out Prey); | ||
| 7986 | |||
| 7987 | OnEstateTeleportOneUserHomeRequest(this, invoice, SenderID, Prey); | ||
| 7988 | } | ||
| 7989 | return true; | ||
| 7990 | case "teleporthomeallusers": | ||
| 7991 | if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false)) | ||
| 7992 | { | ||
| 7993 | UUID invoice = messagePacket.MethodData.Invoice; | ||
| 7994 | UUID SenderID = messagePacket.AgentData.AgentID; | ||
| 7995 | OnEstateTeleportAllUsersHomeRequest(this, invoice, SenderID); | ||
| 7996 | } | ||
| 7997 | return true; | ||
| 7998 | case "colliders": | ||
| 7999 | handlerLandStatRequest = OnLandStatRequest; | ||
| 8000 | if (handlerLandStatRequest != null) | ||
| 8001 | { | ||
| 8002 | handlerLandStatRequest(0, 1, 0, "", this); | ||
| 8003 | } | ||
| 8004 | return true; | ||
| 8005 | case "scripts": | ||
| 8006 | handlerLandStatRequest = OnLandStatRequest; | ||
| 8007 | if (handlerLandStatRequest != null) | ||
| 8008 | { | ||
| 8009 | handlerLandStatRequest(0, 0, 0, "", this); | ||
| 8010 | } | ||
| 8011 | return true; | ||
| 8012 | case "terrain": | ||
| 8013 | if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false)) | ||
| 8014 | { | ||
| 8015 | if (messagePacket.ParamList.Length > 0) | ||
| 8016 | { | ||
| 8017 | if (Utils.BytesToString(messagePacket.ParamList[0].Parameter) == "bake") | ||
| 8018 | { | ||
| 8019 | BakeTerrain handlerBakeTerrain = OnBakeTerrain; | ||
| 8020 | if (handlerBakeTerrain != null) | ||
| 8021 | { | ||
| 8022 | handlerBakeTerrain(this); | ||
| 8023 | } | ||
| 8024 | } | ||
| 8025 | if (Utils.BytesToString(messagePacket.ParamList[0].Parameter) == "download filename") | ||
| 8026 | { | ||
| 8027 | if (messagePacket.ParamList.Length > 1) | ||
| 8028 | { | ||
| 8029 | RequestTerrain handlerRequestTerrain = OnRequestTerrain; | ||
| 8030 | if (handlerRequestTerrain != null) | ||
| 8031 | { | ||
| 8032 | handlerRequestTerrain(this, Utils.BytesToString(messagePacket.ParamList[1].Parameter)); | ||
| 8033 | } | ||
| 8034 | } | ||
| 8035 | } | ||
| 8036 | if (Utils.BytesToString(messagePacket.ParamList[0].Parameter) == "upload filename") | ||
| 8037 | { | ||
| 8038 | if (messagePacket.ParamList.Length > 1) | ||
| 8039 | { | ||
| 8040 | RequestTerrain handlerUploadTerrain = OnUploadTerrain; | ||
| 8041 | if (handlerUploadTerrain != null) | ||
| 8042 | { | ||
| 8043 | handlerUploadTerrain(this, Utils.BytesToString(messagePacket.ParamList[1].Parameter)); | ||
| 8044 | } | ||
| 8045 | } | ||
| 8046 | } | ||
| 8047 | |||
| 8048 | } | ||
| 8049 | |||
| 8050 | |||
| 8051 | } | ||
| 8052 | return true; | ||
| 8053 | |||
| 8054 | case "estatechangeinfo": | ||
| 8055 | if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false)) | ||
| 8056 | { | ||
| 8057 | UUID invoice = messagePacket.MethodData.Invoice; | ||
| 8058 | UUID SenderID = messagePacket.AgentData.AgentID; | ||
| 8059 | UInt32 param1 = Convert.ToUInt32(Utils.BytesToString(messagePacket.ParamList[1].Parameter)); | ||
| 8060 | UInt32 param2 = Convert.ToUInt32(Utils.BytesToString(messagePacket.ParamList[2].Parameter)); | ||
| 8061 | |||
| 8062 | EstateChangeInfo handlerEstateChangeInfo = OnEstateChangeInfo; | ||
| 8063 | if (handlerEstateChangeInfo != null) | ||
| 8064 | { | ||
| 8065 | handlerEstateChangeInfo(this, invoice, SenderID, param1, param2); | ||
| 8066 | } | ||
| 8067 | } | ||
| 8068 | return true; | ||
| 8069 | |||
| 8070 | default: | ||
| 8071 | m_log.Error("EstateOwnerMessage: Unknown method requested\n" + messagePacket); | ||
| 8072 | return true; | ||
| 8073 | } | ||
| 8074 | |||
| 8075 | //int parcelID, uint reportType, uint requestflags, string filter | ||
| 8076 | |||
| 8077 | //lsrp.RequestData.ParcelLocalID; | ||
| 8078 | //lsrp.RequestData.ReportType; // 1 = colliders, 0 = scripts | ||
| 8079 | //lsrp.RequestData.RequestFlags; | ||
| 8080 | //lsrp.RequestData.Filter; | ||
| 8081 | |||
| 8082 | return true; | ||
| 8083 | } | ||
| 8084 | private bool HandleRequestRegionInfo(IClientAPI sender, Packet Pack) | ||
| 8085 | { | ||
| 8086 | RequestRegionInfoPacket.AgentDataBlock mPacket = ((RequestRegionInfoPacket)Pack).AgentData; | ||
| 8087 | |||
| 8088 | #region Packet Session and User Check | ||
| 8089 | if (m_checkPackets) | ||
| 8090 | { | ||
| 8091 | if (mPacket.SessionID != SessionId || | ||
| 8092 | mPacket.AgentID != AgentId) | ||
| 8093 | return true; | ||
| 8094 | } | ||
| 8095 | #endregion | ||
| 8096 | |||
| 8097 | RegionInfoRequest handlerRegionInfoRequest = OnRegionInfoRequest; | ||
| 8098 | if (handlerRegionInfoRequest != null) | ||
| 8099 | { | ||
| 8100 | handlerRegionInfoRequest(this); | ||
| 8101 | } | ||
| 8102 | return true; | ||
| 8103 | } | ||
| 8104 | private bool HandleEstateCovenantRequest(IClientAPI sender, Packet Pack) | ||
| 8105 | { | ||
| 8106 | |||
| 8107 | //EstateCovenantRequestPacket.AgentDataBlock epack = | ||
| 8108 | // ((EstateCovenantRequestPacket)Pack).AgentData; | ||
| 8109 | |||
| 8110 | EstateCovenantRequest handlerEstateCovenantRequest = OnEstateCovenantRequest; | ||
| 8111 | if (handlerEstateCovenantRequest != null) | ||
| 8112 | { | ||
| 8113 | handlerEstateCovenantRequest(this); | ||
| 8114 | } | ||
| 8115 | return true; | ||
| 8116 | |||
| 8117 | } | ||
| 8118 | |||
| 8119 | #endregion Estate Packets | ||
| 8120 | |||
| 8121 | #region GodPackets | ||
| 8122 | |||
| 8123 | private bool HandleRequestGodlikePowers(IClientAPI sender, Packet Pack) | ||
| 8124 | { | ||
| 8125 | RequestGodlikePowersPacket rglpPack = (RequestGodlikePowersPacket)Pack; | ||
| 8126 | RequestGodlikePowersPacket.RequestBlockBlock rblock = rglpPack.RequestBlock; | ||
| 8127 | UUID token = rblock.Token; | ||
| 8128 | |||
| 8129 | RequestGodlikePowersPacket.AgentDataBlock ablock = rglpPack.AgentData; | ||
| 8130 | |||
| 8131 | RequestGodlikePowers handlerReqGodlikePowers = OnRequestGodlikePowers; | ||
| 8132 | |||
| 8133 | if (handlerReqGodlikePowers != null) | ||
| 8134 | { | ||
| 8135 | handlerReqGodlikePowers(ablock.AgentID, ablock.SessionID, token, rblock.Godlike, this); | ||
| 8136 | } | ||
| 8137 | |||
| 8138 | return true; | ||
| 8139 | } | ||
| 8140 | private bool HandleGodKickUser(IClientAPI sender, Packet Pack) | ||
| 8141 | { | ||
| 8142 | GodKickUserPacket gkupack = (GodKickUserPacket)Pack; | ||
| 8143 | |||
| 8144 | if (gkupack.UserInfo.GodSessionID == SessionId && AgentId == gkupack.UserInfo.GodID) | ||
| 8145 | { | ||
| 8146 | GodKickUser handlerGodKickUser = OnGodKickUser; | ||
| 8147 | if (handlerGodKickUser != null) | ||
| 8148 | { | ||
| 8149 | handlerGodKickUser(gkupack.UserInfo.GodID, gkupack.UserInfo.GodSessionID, | ||
| 8150 | gkupack.UserInfo.AgentID, (uint)0, gkupack.UserInfo.Reason); | ||
| 8151 | } | ||
| 8152 | } | ||
| 8153 | else | ||
| 8154 | { | ||
| 8155 | SendAgentAlertMessage("Kick request denied", false); | ||
| 8156 | } | ||
| 8157 | //KickUserPacket kupack = new KickUserPacket(); | ||
| 8158 | //KickUserPacket.UserInfoBlock kupackib = kupack.UserInfo; | ||
| 8159 | |||
| 8160 | //kupack.UserInfo.AgentID = gkupack.UserInfo.AgentID; | ||
| 8161 | //kupack.UserInfo.SessionID = gkupack.UserInfo.GodSessionID; | ||
| 8162 | |||
| 8163 | //kupack.TargetBlock.TargetIP = (uint)0; | ||
| 8164 | //kupack.TargetBlock.TargetPort = (ushort)0; | ||
| 8165 | //kupack.UserInfo.Reason = gkupack.UserInfo.Reason; | ||
| 8166 | |||
| 8167 | //OutPacket(kupack, ThrottleOutPacketType.Task); | ||
| 8168 | return true; | ||
| 8169 | } | ||
| 8170 | #endregion GodPackets | ||
| 8171 | |||
| 8172 | #region Economy/Transaction Packets | ||
| 8173 | |||
| 8174 | private bool HandleMoneyBalanceRequest(IClientAPI sender, Packet Pack) | ||
| 8175 | { | ||
| 8176 | MoneyBalanceRequestPacket moneybalancerequestpacket = (MoneyBalanceRequestPacket)Pack; | ||
| 8177 | |||
| 8178 | #region Packet Session and User Check | ||
| 8179 | if (m_checkPackets) | ||
| 8180 | { | ||
| 8181 | if (moneybalancerequestpacket.AgentData.SessionID != SessionId || | ||
| 8182 | moneybalancerequestpacket.AgentData.AgentID != AgentId) | ||
| 8183 | return true; | ||
| 8184 | } | ||
| 8185 | #endregion | ||
| 8186 | |||
| 8187 | MoneyBalanceRequest handlerMoneyBalanceRequest = OnMoneyBalanceRequest; | ||
| 8188 | |||
| 8189 | if (handlerMoneyBalanceRequest != null) | ||
| 8190 | { | ||
| 8191 | handlerMoneyBalanceRequest(this, moneybalancerequestpacket.AgentData.AgentID, moneybalancerequestpacket.AgentData.SessionID, moneybalancerequestpacket.MoneyData.TransactionID); | ||
| 8192 | } | ||
| 8193 | |||
| 8194 | return true; | ||
| 8195 | } | ||
| 8196 | private bool HandleEconomyDataRequest(IClientAPI sender, Packet Pack) | ||
| 8197 | { | ||
| 8198 | EconomyDataRequest handlerEconomoyDataRequest = OnEconomyDataRequest; | ||
| 8199 | if (handlerEconomoyDataRequest != null) | ||
| 8200 | { | ||
| 8201 | handlerEconomoyDataRequest(AgentId); | ||
| 8202 | } | ||
| 8203 | return true; | ||
| 8204 | } | ||
| 8205 | private bool HandleRequestPayPrice(IClientAPI sender, Packet Pack) | ||
| 8206 | { | ||
| 8207 | RequestPayPricePacket requestPayPricePacket = (RequestPayPricePacket)Pack; | ||
| 8208 | |||
| 8209 | RequestPayPrice handlerRequestPayPrice = OnRequestPayPrice; | ||
| 8210 | if (handlerRequestPayPrice != null) | ||
| 8211 | { | ||
| 8212 | handlerRequestPayPrice(this, requestPayPricePacket.ObjectData.ObjectID); | ||
| 8213 | } | ||
| 8214 | return true; | ||
| 8215 | } | ||
| 8216 | private bool HandleObjectSaleInfo(IClientAPI sender, Packet Pack) | ||
| 8217 | { | ||
| 8218 | ObjectSaleInfoPacket objectSaleInfoPacket = (ObjectSaleInfoPacket)Pack; | ||
| 8219 | |||
| 8220 | #region Packet Session and User Check | ||
| 8221 | if (m_checkPackets) | ||
| 8222 | { | ||
| 8223 | if (objectSaleInfoPacket.AgentData.SessionID != SessionId || | ||
| 8224 | objectSaleInfoPacket.AgentData.AgentID != AgentId) | ||
| 8225 | return true; | ||
| 8226 | } | ||
| 8227 | #endregion | ||
| 8228 | |||
| 8229 | ObjectSaleInfo handlerObjectSaleInfo = OnObjectSaleInfo; | ||
| 8230 | if (handlerObjectSaleInfo != null) | ||
| 8231 | { | ||
| 8232 | foreach (ObjectSaleInfoPacket.ObjectDataBlock d | ||
| 8233 | in objectSaleInfoPacket.ObjectData) | ||
| 8234 | { | ||
| 8235 | handlerObjectSaleInfo(this, | ||
| 8236 | objectSaleInfoPacket.AgentData.AgentID, | ||
| 8237 | objectSaleInfoPacket.AgentData.SessionID, | ||
| 8238 | d.LocalID, | ||
| 8239 | d.SaleType, | ||
| 8240 | d.SalePrice); | ||
| 8241 | } | ||
| 8242 | } | ||
| 8243 | return true; | ||
| 8244 | } | ||
| 8245 | private bool HandleObjectBuy(IClientAPI sender, Packet Pack) | ||
| 8246 | { | ||
| 8247 | ObjectBuyPacket objectBuyPacket = (ObjectBuyPacket)Pack; | ||
| 8248 | |||
| 8249 | #region Packet Session and User Check | ||
| 8250 | if (m_checkPackets) | ||
| 8251 | { | ||
| 8252 | if (objectBuyPacket.AgentData.SessionID != SessionId || | ||
| 8253 | objectBuyPacket.AgentData.AgentID != AgentId) | ||
| 8254 | return true; | ||
| 8255 | } | ||
| 8256 | #endregion | ||
| 8257 | |||
| 8258 | ObjectBuy handlerObjectBuy = OnObjectBuy; | ||
| 8259 | |||
| 8260 | if (handlerObjectBuy != null) | ||
| 8261 | { | ||
| 8262 | foreach (ObjectBuyPacket.ObjectDataBlock d | ||
| 8263 | in objectBuyPacket.ObjectData) | ||
| 8264 | { | ||
| 8265 | handlerObjectBuy(this, | ||
| 8266 | objectBuyPacket.AgentData.AgentID, | ||
| 8267 | objectBuyPacket.AgentData.SessionID, | ||
| 8268 | objectBuyPacket.AgentData.GroupID, | ||
| 8269 | objectBuyPacket.AgentData.CategoryID, | ||
| 8270 | d.ObjectLocalID, | ||
| 8271 | d.SaleType, | ||
| 8272 | d.SalePrice); | ||
| 8273 | } | ||
| 8274 | } | ||
| 8275 | return true; | ||
| 8276 | } | ||
| 8277 | |||
| 8278 | #endregion Economy/Transaction Packets | ||
| 8279 | |||
| 8280 | #region Script Packets | ||
| 8281 | private bool HandleGetScriptRunning(IClientAPI sender, Packet Pack) | ||
| 8282 | { | ||
| 8283 | GetScriptRunningPacket scriptRunning = (GetScriptRunningPacket)Pack; | ||
| 8284 | |||
| 8285 | GetScriptRunning handlerGetScriptRunning = OnGetScriptRunning; | ||
| 8286 | if (handlerGetScriptRunning != null) | ||
| 8287 | { | ||
| 8288 | handlerGetScriptRunning(this, scriptRunning.Script.ObjectID, scriptRunning.Script.ItemID); | ||
| 8289 | } | ||
| 8290 | return true; | ||
| 8291 | } | ||
| 8292 | private bool HandleSetScriptRunning(IClientAPI sender, Packet Pack) | ||
| 8293 | { | ||
| 8294 | SetScriptRunningPacket setScriptRunning = (SetScriptRunningPacket)Pack; | ||
| 8295 | |||
| 8296 | #region Packet Session and User Check | ||
| 8297 | if (m_checkPackets) | ||
| 8298 | { | ||
| 8299 | if (setScriptRunning.AgentData.SessionID != SessionId || | ||
| 8300 | setScriptRunning.AgentData.AgentID != AgentId) | ||
| 8301 | return true; | ||
| 8302 | } | ||
| 8303 | #endregion | ||
| 8304 | |||
| 8305 | SetScriptRunning handlerSetScriptRunning = OnSetScriptRunning; | ||
| 8306 | if (handlerSetScriptRunning != null) | ||
| 8307 | { | ||
| 8308 | handlerSetScriptRunning(this, setScriptRunning.Script.ObjectID, setScriptRunning.Script.ItemID, setScriptRunning.Script.Running); | ||
| 8309 | } | ||
| 8310 | return true; | ||
| 8311 | } | ||
| 8312 | |||
| 8313 | private bool HandleScriptReset(IClientAPI sender, Packet Pack) | ||
| 8314 | { | ||
| 8315 | ScriptResetPacket scriptResetPacket = (ScriptResetPacket)Pack; | ||
| 8316 | |||
| 8317 | #region Packet Session and User Check | ||
| 8318 | if (m_checkPackets) | ||
| 8319 | { | ||
| 8320 | if (scriptResetPacket.AgentData.SessionID != SessionId || | ||
| 8321 | scriptResetPacket.AgentData.AgentID != AgentId) | ||
| 8322 | return true; | ||
| 8323 | } | ||
| 8324 | #endregion | ||
| 8325 | |||
| 8326 | ScriptReset handlerScriptReset = OnScriptReset; | ||
| 8327 | if (handlerScriptReset != null) | ||
| 8328 | { | ||
| 8329 | handlerScriptReset(this, scriptResetPacket.Script.ObjectID, scriptResetPacket.Script.ItemID); | ||
| 8330 | } | ||
| 8331 | return true; | ||
| 8332 | } | ||
| 8333 | |||
| 8334 | #endregion Script Packets | ||
| 8335 | |||
| 8336 | |||
| 8337 | |||
| 6341 | #endregion Packet Handlers | 8338 | #endregion Packet Handlers |
| 6342 | 8339 | ||
| 6343 | public void SendScriptQuestion(UUID taskID, string taskName, string ownerName, UUID itemID, int question) | 8340 | public void SendScriptQuestion(UUID taskID, string taskName, string ownerName, UUID itemID, int question) |
| @@ -8456,9 +10453,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP | |||
| 8456 | break; | 10453 | break; |
| 8457 | 10454 | ||
| 8458 | //#endregion | 10455 | //#endregion |
| 8459 | */ | 10456 | |
| 8460 | #endregion | 10457 | //#region Inventory/Asset/Other related packets |
| 8461 | #region Inventory/Asset/Other related packets | ||
| 8462 | 10458 | ||
| 8463 | case PacketType.RequestImage: | 10459 | case PacketType.RequestImage: |
| 8464 | RequestImagePacket imageRequest = (RequestImagePacket)Pack; | 10460 | RequestImagePacket imageRequest = (RequestImagePacket)Pack; |
| @@ -8592,12 +10588,14 @@ namespace OpenSim.Region.ClientStack.LindenUDP | |||
| 8592 | 10588 | ||
| 8593 | MakeAssetRequest(transfer, taskID); | 10589 | MakeAssetRequest(transfer, taskID); |
| 8594 | 10590 | ||
| 8595 | /* RequestAsset = OnRequestAsset; | 10591 | // RequestAsset = OnRequestAsset; |
| 8596 | if (RequestAsset != null) | 10592 | // if (RequestAsset != null) |
| 8597 | { | 10593 | // { |
| 8598 | RequestAsset(this, transfer); | 10594 | // RequestAsset(this, transfer); |
| 8599 | }*/ | 10595 | // } |
| 10596 | |||
| 8600 | break; | 10597 | break; |
| 10598 | |||
| 8601 | case PacketType.AssetUploadRequest: | 10599 | case PacketType.AssetUploadRequest: |
| 8602 | AssetUploadRequestPacket request = (AssetUploadRequestPacket)Pack; | 10600 | AssetUploadRequestPacket request = (AssetUploadRequestPacket)Pack; |
| 8603 | 10601 | ||
| @@ -8616,6 +10614,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP | |||
| 8616 | request.AssetBlock.Tempfile); | 10614 | request.AssetBlock.Tempfile); |
| 8617 | } | 10615 | } |
| 8618 | break; | 10616 | break; |
| 10617 | |||
| 8619 | case PacketType.RequestXfer: | 10618 | case PacketType.RequestXfer: |
| 8620 | RequestXferPacket xferReq = (RequestXferPacket)Pack; | 10619 | RequestXferPacket xferReq = (RequestXferPacket)Pack; |
| 8621 | 10620 | ||
| @@ -8626,6 +10625,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP | |||
| 8626 | handlerRequestXfer(this, xferReq.XferID.ID, Util.FieldToString(xferReq.XferID.Filename)); | 10625 | handlerRequestXfer(this, xferReq.XferID.ID, Util.FieldToString(xferReq.XferID.Filename)); |
| 8627 | } | 10626 | } |
| 8628 | break; | 10627 | break; |
| 10628 | |||
| 8629 | case PacketType.SendXferPacket: | 10629 | case PacketType.SendXferPacket: |
| 8630 | SendXferPacketPacket xferRec = (SendXferPacketPacket)Pack; | 10630 | SendXferPacketPacket xferRec = (SendXferPacketPacket)Pack; |
| 8631 | 10631 | ||
| @@ -8635,6 +10635,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP | |||
| 8635 | handlerXferReceive(this, xferRec.XferID.ID, xferRec.XferID.Packet, xferRec.DataPacket.Data); | 10635 | handlerXferReceive(this, xferRec.XferID.ID, xferRec.XferID.Packet, xferRec.DataPacket.Data); |
| 8636 | } | 10636 | } |
| 8637 | break; | 10637 | break; |
| 10638 | |||
| 8638 | case PacketType.ConfirmXferPacket: | 10639 | case PacketType.ConfirmXferPacket: |
| 8639 | ConfirmXferPacketPacket confirmXfer = (ConfirmXferPacketPacket)Pack; | 10640 | ConfirmXferPacketPacket confirmXfer = (ConfirmXferPacketPacket)Pack; |
| 8640 | 10641 | ||
| @@ -8644,6 +10645,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP | |||
| 8644 | handlerConfirmXfer(this, confirmXfer.XferID.ID, confirmXfer.XferID.Packet); | 10645 | handlerConfirmXfer(this, confirmXfer.XferID.ID, confirmXfer.XferID.Packet); |
| 8645 | } | 10646 | } |
| 8646 | break; | 10647 | break; |
| 10648 | |||
| 8647 | case PacketType.AbortXfer: | 10649 | case PacketType.AbortXfer: |
| 8648 | AbortXferPacket abortXfer = (AbortXferPacket)Pack; | 10650 | AbortXferPacket abortXfer = (AbortXferPacket)Pack; |
| 8649 | AbortXfer handlerAbortXfer = OnAbortXfer; | 10651 | AbortXfer handlerAbortXfer = OnAbortXfer; |
| @@ -8653,6 +10655,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP | |||
| 8653 | } | 10655 | } |
| 8654 | 10656 | ||
| 8655 | break; | 10657 | break; |
| 10658 | |||
| 8656 | case PacketType.CreateInventoryFolder: | 10659 | case PacketType.CreateInventoryFolder: |
| 8657 | CreateInventoryFolderPacket invFolder = (CreateInventoryFolderPacket)Pack; | 10660 | CreateInventoryFolderPacket invFolder = (CreateInventoryFolderPacket)Pack; |
| 8658 | 10661 | ||
| @@ -8674,6 +10677,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP | |||
| 8674 | invFolder.FolderData.ParentID); | 10677 | invFolder.FolderData.ParentID); |
| 8675 | } | 10678 | } |
| 8676 | break; | 10679 | break; |
| 10680 | |||
| 8677 | case PacketType.UpdateInventoryFolder: | 10681 | case PacketType.UpdateInventoryFolder: |
| 8678 | if (OnUpdateInventoryFolder != null) | 10682 | if (OnUpdateInventoryFolder != null) |
| 8679 | { | 10683 | { |
| @@ -8703,6 +10707,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP | |||
| 8703 | } | 10707 | } |
| 8704 | } | 10708 | } |
| 8705 | break; | 10709 | break; |
| 10710 | |||
| 8706 | case PacketType.MoveInventoryFolder: | 10711 | case PacketType.MoveInventoryFolder: |
| 8707 | if (OnMoveInventoryFolder != null) | 10712 | if (OnMoveInventoryFolder != null) |
| 8708 | { | 10713 | { |
| @@ -8730,6 +10735,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP | |||
| 8730 | } | 10735 | } |
| 8731 | } | 10736 | } |
| 8732 | break; | 10737 | break; |
| 10738 | |||
| 8733 | case PacketType.CreateInventoryItem: | 10739 | case PacketType.CreateInventoryItem: |
| 8734 | CreateInventoryItemPacket createItem = (CreateInventoryItemPacket)Pack; | 10740 | CreateInventoryItemPacket createItem = (CreateInventoryItemPacket)Pack; |
| 8735 | 10741 | ||
| @@ -8757,6 +10763,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP | |||
| 8757 | Util.UnixTimeSinceEpoch()); | 10763 | Util.UnixTimeSinceEpoch()); |
| 8758 | } | 10764 | } |
| 8759 | break; | 10765 | break; |
| 10766 | |||
| 8760 | case PacketType.FetchInventory: | 10767 | case PacketType.FetchInventory: |
| 8761 | if (OnFetchInventory != null) | 10768 | if (OnFetchInventory != null) |
| 8762 | { | 10769 | { |
| @@ -8785,6 +10792,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP | |||
| 8785 | } | 10792 | } |
| 8786 | } | 10793 | } |
| 8787 | break; | 10794 | break; |
| 10795 | |||
| 8788 | case PacketType.FetchInventoryDescendents: | 10796 | case PacketType.FetchInventoryDescendents: |
| 8789 | FetchInventoryDescendentsPacket Fetch = (FetchInventoryDescendentsPacket)Pack; | 10797 | FetchInventoryDescendentsPacket Fetch = (FetchInventoryDescendentsPacket)Pack; |
| 8790 | 10798 | ||
| @@ -8805,6 +10813,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP | |||
| 8805 | Fetch.InventoryData.SortOrder); | 10813 | Fetch.InventoryData.SortOrder); |
| 8806 | } | 10814 | } |
| 8807 | break; | 10815 | break; |
| 10816 | |||
| 8808 | case PacketType.PurgeInventoryDescendents: | 10817 | case PacketType.PurgeInventoryDescendents: |
| 8809 | PurgeInventoryDescendentsPacket Purge = (PurgeInventoryDescendentsPacket)Pack; | 10818 | PurgeInventoryDescendentsPacket Purge = (PurgeInventoryDescendentsPacket)Pack; |
| 8810 | 10819 | ||
| @@ -8823,6 +10832,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP | |||
| 8823 | handlerPurgeInventoryDescendents(this, Purge.InventoryData.FolderID); | 10832 | handlerPurgeInventoryDescendents(this, Purge.InventoryData.FolderID); |
| 8824 | } | 10833 | } |
| 8825 | break; | 10834 | break; |
| 10835 | |||
| 8826 | case PacketType.UpdateInventoryItem: | 10836 | case PacketType.UpdateInventoryItem: |
| 8827 | UpdateInventoryItemPacket inventoryItemUpdate = (UpdateInventoryItemPacket)Pack; | 10837 | UpdateInventoryItemPacket inventoryItemUpdate = (UpdateInventoryItemPacket)Pack; |
| 8828 | 10838 | ||
| @@ -8867,6 +10877,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP | |||
| 8867 | } | 10877 | } |
| 8868 | } | 10878 | } |
| 8869 | break; | 10879 | break; |
| 10880 | |||
| 8870 | case PacketType.CopyInventoryItem: | 10881 | case PacketType.CopyInventoryItem: |
| 8871 | CopyInventoryItemPacket copyitem = (CopyInventoryItemPacket)Pack; | 10882 | CopyInventoryItemPacket copyitem = (CopyInventoryItemPacket)Pack; |
| 8872 | 10883 | ||
| @@ -8894,6 +10905,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP | |||
| 8894 | } | 10905 | } |
| 8895 | } | 10906 | } |
| 8896 | break; | 10907 | break; |
| 10908 | |||
| 8897 | case PacketType.MoveInventoryItem: | 10909 | case PacketType.MoveInventoryItem: |
| 8898 | MoveInventoryItemPacket moveitem = (MoveInventoryItemPacket)Pack; | 10910 | MoveInventoryItemPacket moveitem = (MoveInventoryItemPacket)Pack; |
| 8899 | 10911 | ||
| @@ -8927,6 +10939,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP | |||
| 8927 | } | 10939 | } |
| 8928 | } | 10940 | } |
| 8929 | break; | 10941 | break; |
| 10942 | |||
| 8930 | case PacketType.RemoveInventoryItem: | 10943 | case PacketType.RemoveInventoryItem: |
| 8931 | RemoveInventoryItemPacket removeItem = (RemoveInventoryItemPacket)Pack; | 10944 | RemoveInventoryItemPacket removeItem = (RemoveInventoryItemPacket)Pack; |
| 8932 | 10945 | ||
| @@ -8955,6 +10968,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP | |||
| 8955 | 10968 | ||
| 8956 | } | 10969 | } |
| 8957 | break; | 10970 | break; |
| 10971 | |||
| 8958 | case PacketType.RemoveInventoryFolder: | 10972 | case PacketType.RemoveInventoryFolder: |
| 8959 | RemoveInventoryFolderPacket removeFolder = (RemoveInventoryFolderPacket)Pack; | 10973 | RemoveInventoryFolderPacket removeFolder = (RemoveInventoryFolderPacket)Pack; |
| 8960 | 10974 | ||
| @@ -8982,6 +10996,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP | |||
| 8982 | } | 10996 | } |
| 8983 | } | 10997 | } |
| 8984 | break; | 10998 | break; |
| 10999 | |||
| 8985 | case PacketType.RemoveInventoryObjects: | 11000 | case PacketType.RemoveInventoryObjects: |
| 8986 | RemoveInventoryObjectsPacket removeObject = (RemoveInventoryObjectsPacket)Pack; | 11001 | RemoveInventoryObjectsPacket removeObject = (RemoveInventoryObjectsPacket)Pack; |
| 8987 | #region Packet Session and User Check | 11002 | #region Packet Session and User Check |
| @@ -9022,6 +11037,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP | |||
| 9022 | } | 11037 | } |
| 9023 | } | 11038 | } |
| 9024 | break; | 11039 | break; |
| 11040 | |||
| 9025 | case PacketType.RequestTaskInventory: | 11041 | case PacketType.RequestTaskInventory: |
| 9026 | RequestTaskInventoryPacket requesttask = (RequestTaskInventoryPacket)Pack; | 11042 | RequestTaskInventoryPacket requesttask = (RequestTaskInventoryPacket)Pack; |
| 9027 | 11043 | ||
| @@ -9040,6 +11056,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP | |||
| 9040 | handlerRequestTaskInventory(this, requesttask.InventoryData.LocalID); | 11056 | handlerRequestTaskInventory(this, requesttask.InventoryData.LocalID); |
| 9041 | } | 11057 | } |
| 9042 | break; | 11058 | break; |
| 11059 | |||
| 9043 | case PacketType.UpdateTaskInventory: | 11060 | case PacketType.UpdateTaskInventory: |
| 9044 | UpdateTaskInventoryPacket updatetask = (UpdateTaskInventoryPacket)Pack; | 11061 | UpdateTaskInventoryPacket updatetask = (UpdateTaskInventoryPacket)Pack; |
| 9045 | 11062 | ||
| @@ -9217,6 +11234,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP | |||
| 9217 | handlerMapNameRequest(this, mapName); | 11234 | handlerMapNameRequest(this, mapName); |
| 9218 | } | 11235 | } |
| 9219 | break; | 11236 | break; |
| 11237 | |||
| 9220 | case PacketType.TeleportLandmarkRequest: | 11238 | case PacketType.TeleportLandmarkRequest: |
| 9221 | TeleportLandmarkRequestPacket tpReq = (TeleportLandmarkRequestPacket)Pack; | 11239 | TeleportLandmarkRequestPacket tpReq = (TeleportLandmarkRequestPacket)Pack; |
| 9222 | 11240 | ||
| @@ -9287,7 +11305,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP | |||
| 9287 | 11305 | ||
| 9288 | } | 11306 | } |
| 9289 | break; | 11307 | break; |
| 9290 | 11308 | ||
| 9291 | case PacketType.TeleportLocationRequest: | 11309 | case PacketType.TeleportLocationRequest: |
| 9292 | TeleportLocationRequestPacket tpLocReq = (TeleportLocationRequestPacket)Pack; | 11310 | TeleportLocationRequestPacket tpLocReq = (TeleportLocationRequestPacket)Pack; |
| 9293 | // m_log.Debug(tpLocReq.ToString()); | 11311 | // m_log.Debug(tpLocReq.ToString()); |
| @@ -9317,7 +11335,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP | |||
| 9317 | } | 11335 | } |
| 9318 | break; | 11336 | break; |
| 9319 | 11337 | ||
| 9320 | #endregion | 11338 | //#endregion |
| 9321 | 11339 | ||
| 9322 | case PacketType.UUIDNameRequest: | 11340 | case PacketType.UUIDNameRequest: |
| 9323 | UUIDNameRequestPacket incoming = (UUIDNameRequestPacket)Pack; | 11341 | UUIDNameRequestPacket incoming = (UUIDNameRequestPacket)Pack; |
| @@ -9332,7 +11350,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP | |||
| 9332 | } | 11350 | } |
| 9333 | break; | 11351 | break; |
| 9334 | 11352 | ||
| 9335 | #region Parcel related packets | 11353 | //#region Parcel related packets |
| 11354 | |||
| 9336 | 11355 | ||
| 9337 | case PacketType.RegionHandleRequest: | 11356 | case PacketType.RegionHandleRequest: |
| 9338 | RegionHandleRequestPacket rhrPack = (RegionHandleRequestPacket)Pack; | 11357 | RegionHandleRequestPacket rhrPack = (RegionHandleRequestPacket)Pack; |
| @@ -9415,6 +11434,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP | |||
| 9415 | updatePacket.Data.LocalID, entries, this); | 11434 | updatePacket.Data.LocalID, entries, this); |
| 9416 | } | 11435 | } |
| 9417 | break; | 11436 | break; |
| 11437 | |||
| 9418 | case PacketType.ParcelPropertiesRequest: | 11438 | case PacketType.ParcelPropertiesRequest: |
| 9419 | 11439 | ||
| 9420 | ParcelPropertiesRequestPacket propertiesRequest = (ParcelPropertiesRequestPacket)Pack; | 11440 | ParcelPropertiesRequestPacket propertiesRequest = (ParcelPropertiesRequestPacket)Pack; |
| @@ -9439,6 +11459,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP | |||
| 9439 | propertiesRequest.ParcelData.SnapSelection, this); | 11459 | propertiesRequest.ParcelData.SnapSelection, this); |
| 9440 | } | 11460 | } |
| 9441 | break; | 11461 | break; |
| 11462 | |||
| 9442 | case PacketType.ParcelDivide: | 11463 | case PacketType.ParcelDivide: |
| 9443 | ParcelDividePacket landDivide = (ParcelDividePacket)Pack; | 11464 | ParcelDividePacket landDivide = (ParcelDividePacket)Pack; |
| 9444 | 11465 | ||
| @@ -9460,6 +11481,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP | |||
| 9460 | (int)Math.Round(landDivide.ParcelData.North), this); | 11481 | (int)Math.Round(landDivide.ParcelData.North), this); |
| 9461 | } | 11482 | } |
| 9462 | break; | 11483 | break; |
| 11484 | |||
| 9463 | case PacketType.ParcelJoin: | 11485 | case PacketType.ParcelJoin: |
| 9464 | ParcelJoinPacket landJoin = (ParcelJoinPacket)Pack; | 11486 | ParcelJoinPacket landJoin = (ParcelJoinPacket)Pack; |
| 9465 | 11487 | ||
| @@ -9482,6 +11504,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP | |||
| 9482 | (int)Math.Round(landJoin.ParcelData.North), this); | 11504 | (int)Math.Round(landJoin.ParcelData.North), this); |
| 9483 | } | 11505 | } |
| 9484 | break; | 11506 | break; |
| 11507 | |||
| 9485 | case PacketType.ParcelPropertiesUpdate: | 11508 | case PacketType.ParcelPropertiesUpdate: |
| 9486 | ParcelPropertiesUpdatePacket parcelPropertiesPacket = (ParcelPropertiesUpdatePacket)Pack; | 11509 | ParcelPropertiesUpdatePacket parcelPropertiesPacket = (ParcelPropertiesUpdatePacket)Pack; |
| 9487 | 11510 | ||
| @@ -9520,6 +11543,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP | |||
| 9520 | handlerParcelPropertiesUpdateRequest(args, parcelPropertiesPacket.ParcelData.LocalID, this); | 11543 | handlerParcelPropertiesUpdateRequest(args, parcelPropertiesPacket.ParcelData.LocalID, this); |
| 9521 | } | 11544 | } |
| 9522 | break; | 11545 | break; |
| 11546 | |||
| 9523 | case PacketType.ParcelSelectObjects: | 11547 | case PacketType.ParcelSelectObjects: |
| 9524 | ParcelSelectObjectsPacket selectPacket = (ParcelSelectObjectsPacket)Pack; | 11548 | ParcelSelectObjectsPacket selectPacket = (ParcelSelectObjectsPacket)Pack; |
| 9525 | 11549 | ||
| @@ -9548,6 +11572,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP | |||
| 9548 | Convert.ToInt32(selectPacket.ParcelData.ReturnType), returnIDs, this); | 11572 | Convert.ToInt32(selectPacket.ParcelData.ReturnType), returnIDs, this); |
| 9549 | } | 11573 | } |
| 9550 | break; | 11574 | break; |
| 11575 | |||
| 9551 | case PacketType.ParcelObjectOwnersRequest: | 11576 | case PacketType.ParcelObjectOwnersRequest: |
| 9552 | //m_log.Debug(Pack.ToString()); | 11577 | //m_log.Debug(Pack.ToString()); |
| 9553 | ParcelObjectOwnersRequestPacket reqPacket = (ParcelObjectOwnersRequestPacket)Pack; | 11578 | ParcelObjectOwnersRequestPacket reqPacket = (ParcelObjectOwnersRequestPacket)Pack; |
| @@ -9568,6 +11593,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP | |||
| 9568 | handlerParcelObjectOwnerRequest(reqPacket.ParcelData.LocalID, this); | 11593 | handlerParcelObjectOwnerRequest(reqPacket.ParcelData.LocalID, this); |
| 9569 | } | 11594 | } |
| 9570 | break; | 11595 | break; |
| 11596 | |||
| 9571 | case PacketType.ParcelGodForceOwner: | 11597 | case PacketType.ParcelGodForceOwner: |
| 9572 | ParcelGodForceOwnerPacket godForceOwnerPacket = (ParcelGodForceOwnerPacket)Pack; | 11598 | ParcelGodForceOwnerPacket godForceOwnerPacket = (ParcelGodForceOwnerPacket)Pack; |
| 9573 | 11599 | ||
| @@ -9586,6 +11612,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP | |||
| 9586 | handlerParcelGodForceOwner(godForceOwnerPacket.Data.LocalID, godForceOwnerPacket.Data.OwnerID, this); | 11612 | handlerParcelGodForceOwner(godForceOwnerPacket.Data.LocalID, godForceOwnerPacket.Data.OwnerID, this); |
| 9587 | } | 11613 | } |
| 9588 | break; | 11614 | break; |
| 11615 | |||
| 9589 | case PacketType.ParcelRelease: | 11616 | case PacketType.ParcelRelease: |
| 9590 | ParcelReleasePacket releasePacket = (ParcelReleasePacket)Pack; | 11617 | ParcelReleasePacket releasePacket = (ParcelReleasePacket)Pack; |
| 9591 | 11618 | ||
| @@ -9604,6 +11631,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP | |||
| 9604 | handlerParcelAbandonRequest(releasePacket.Data.LocalID, this); | 11631 | handlerParcelAbandonRequest(releasePacket.Data.LocalID, this); |
| 9605 | } | 11632 | } |
| 9606 | break; | 11633 | break; |
| 11634 | |||
| 9607 | case PacketType.ParcelReclaim: | 11635 | case PacketType.ParcelReclaim: |
| 9608 | ParcelReclaimPacket reclaimPacket = (ParcelReclaimPacket)Pack; | 11636 | ParcelReclaimPacket reclaimPacket = (ParcelReclaimPacket)Pack; |
| 9609 | 11637 | ||
| @@ -9622,6 +11650,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP | |||
| 9622 | handlerParcelReclaim(reclaimPacket.Data.LocalID, this); | 11650 | handlerParcelReclaim(reclaimPacket.Data.LocalID, this); |
| 9623 | } | 11651 | } |
| 9624 | break; | 11652 | break; |
| 11653 | |||
| 9625 | case PacketType.ParcelReturnObjects: | 11654 | case PacketType.ParcelReturnObjects: |
| 9626 | 11655 | ||
| 9627 | 11656 | ||
| @@ -9713,9 +11742,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP | |||
| 9713 | } | 11742 | } |
| 9714 | break; | 11743 | break; |
| 9715 | 11744 | ||
| 9716 | #endregion | 11745 | //#endregion |
| 9717 | 11746 | ||
| 9718 | #region Estate Packets | 11747 | //#region Estate Packets |
| 9719 | 11748 | ||
| 9720 | case PacketType.EstateOwnerMessage: | 11749 | case PacketType.EstateOwnerMessage: |
| 9721 | EstateOwnerMessagePacket messagePacket = (EstateOwnerMessagePacket)Pack; | 11750 | EstateOwnerMessagePacket messagePacket = (EstateOwnerMessagePacket)Pack; |
| @@ -10033,6 +12062,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP | |||
| 10033 | handlerRegionInfoRequest(this); | 12062 | handlerRegionInfoRequest(this); |
| 10034 | } | 12063 | } |
| 10035 | break; | 12064 | break; |
| 12065 | |||
| 10036 | case PacketType.EstateCovenantRequest: | 12066 | case PacketType.EstateCovenantRequest: |
| 10037 | 12067 | ||
| 10038 | //EstateCovenantRequestPacket.AgentDataBlock epack = | 12068 | //EstateCovenantRequestPacket.AgentDataBlock epack = |
| @@ -10045,9 +12075,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP | |||
| 10045 | } | 12075 | } |
| 10046 | break; | 12076 | break; |
| 10047 | 12077 | ||
| 10048 | #endregion | 12078 | //#endregion |
| 10049 | 12079 | ||
| 10050 | #region GodPackets | 12080 | //#region GodPackets |
| 10051 | 12081 | ||
| 10052 | case PacketType.RequestGodlikePowers: | 12082 | case PacketType.RequestGodlikePowers: |
| 10053 | RequestGodlikePowersPacket rglpPack = (RequestGodlikePowersPacket)Pack; | 12083 | RequestGodlikePowersPacket rglpPack = (RequestGodlikePowersPacket)Pack; |
| @@ -10064,6 +12094,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP | |||
| 10064 | } | 12094 | } |
| 10065 | 12095 | ||
| 10066 | break; | 12096 | break; |
| 12097 | |||
| 10067 | case PacketType.GodKickUser: | 12098 | case PacketType.GodKickUser: |
| 10068 | GodKickUserPacket gkupack = (GodKickUserPacket)Pack; | 12099 | GodKickUserPacket gkupack = (GodKickUserPacket)Pack; |
| 10069 | 12100 | ||
| @@ -10093,9 +12124,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP | |||
| 10093 | //OutPacket(kupack, ThrottleOutPacketType.Task); | 12124 | //OutPacket(kupack, ThrottleOutPacketType.Task); |
| 10094 | break; | 12125 | break; |
| 10095 | 12126 | ||
| 10096 | #endregion | 12127 | //#endregion |
| 10097 | 12128 | ||
| 10098 | #region Economy/Transaction Packets | 12129 | //#region Economy/Transaction Packets |
| 10099 | 12130 | ||
| 10100 | case PacketType.MoneyBalanceRequest: | 12131 | case PacketType.MoneyBalanceRequest: |
| 10101 | MoneyBalanceRequestPacket moneybalancerequestpacket = (MoneyBalanceRequestPacket)Pack; | 12132 | MoneyBalanceRequestPacket moneybalancerequestpacket = (MoneyBalanceRequestPacket)Pack; |
| @@ -10117,6 +12148,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP | |||
| 10117 | } | 12148 | } |
| 10118 | 12149 | ||
| 10119 | break; | 12150 | break; |
| 12151 | |||
| 10120 | case PacketType.EconomyDataRequest: | 12152 | case PacketType.EconomyDataRequest: |
| 10121 | 12153 | ||
| 10122 | 12154 | ||
| @@ -10126,6 +12158,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP | |||
| 10126 | handlerEconomoyDataRequest(AgentId); | 12158 | handlerEconomoyDataRequest(AgentId); |
| 10127 | } | 12159 | } |
| 10128 | break; | 12160 | break; |
| 12161 | |||
| 10129 | case PacketType.RequestPayPrice: | 12162 | case PacketType.RequestPayPrice: |
| 10130 | RequestPayPricePacket requestPayPricePacket = (RequestPayPricePacket)Pack; | 12163 | RequestPayPricePacket requestPayPricePacket = (RequestPayPricePacket)Pack; |
| 10131 | 12164 | ||
| @@ -10195,9 +12228,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP | |||
| 10195 | } | 12228 | } |
| 10196 | break; | 12229 | break; |
| 10197 | 12230 | ||
| 10198 | #endregion | 12231 | //#endregion |
| 10199 | 12232 | ||
| 10200 | #region Script Packets | 12233 | //#region Script Packets |
| 10201 | 12234 | ||
| 10202 | case PacketType.GetScriptRunning: | 12235 | case PacketType.GetScriptRunning: |
| 10203 | GetScriptRunningPacket scriptRunning = (GetScriptRunningPacket)Pack; | 12236 | GetScriptRunningPacket scriptRunning = (GetScriptRunningPacket)Pack; |
| @@ -10247,8 +12280,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP | |||
| 10247 | } | 12280 | } |
| 10248 | break; | 12281 | break; |
| 10249 | 12282 | ||
| 12283 | //#endregion | ||
| 12284 | */ | ||
| 10250 | #endregion | 12285 | #endregion |
| 10251 | |||
| 10252 | #region Gesture Managment | 12286 | #region Gesture Managment |
| 10253 | 12287 | ||
| 10254 | case PacketType.ActivateGestures: | 12288 | case PacketType.ActivateGestures: |