WebSVN – clockwerk-opensim-stable – Blame – Rev 1 – /OpenSim/Region/ClientStack/Linden/UDP/LLClientView.cs

        protected static Dictionary<PacketType, PacketMethod> PacketHandlers = new Dictionary<PacketType, PacketMethod>(); //Global/static handlers for all clients

311

312

/// <summary>

313

/// Handles UDP texture download.

314

/// </summary>

315

public LLImageManager ImageManager { get; private set; }

316

317

private readonly LLUDPServer m_udpServer;

318

private readonly LLUDPClient m_udpClient;

319

private readonly UUID m_sessionId;

320

private readonly UUID m_secureSessionId;

321

protected readonly UUID m_agentId;

322

private readonly uint m_circuitCode;

323

private readonly byte[] m_channelVersion = Utils.EmptyBytes;

324

private readonly IGroupsModule m_GroupsModule;

325

326

private PriorityQueue m_entityUpdates;

327

private PriorityQueue m_entityProps;

328

private Prioritizer m_prioritizer;

329

private bool m_disableFacelights = false;

330

private volatile bool m_justEditedTerrain = false;

331

/// <value>

332

/// List used in construction of data blocks for an object update packet. This is to stop us having to

333

/// continually recreate it.

334

/// </value>

335

protected List<ObjectUpdatePacket.ObjectDataBlock> m_fullUpdateDataBlocksBuilder;

336

337

/// <value>

338

/// Maintain a record of all the objects killed. This allows us to stop an update being sent from the

339

/// thread servicing the m_primFullUpdates queue after a kill. If this happens the object persists as an

340

/// ownerless phantom.

341

///

342

/// All manipulation of this set has to occur under a lock

343

///

344

/// </value>

345

protected HashSet<uint> m_killRecord;

346

347

// protected HashSet<uint> m_attachmentsSent;

348

349

private int m_animationSequenceNumber = 1;

350

private bool m_SendLogoutPacketWhenClosing = true;

351

352

/// <summary>

353

/// We retain a single AgentUpdateArgs so that we can constantly reuse it rather than construct a new one for

354

/// every single incoming AgentUpdate. Every client sends 10 AgentUpdate UDP messages per second, even if it

355

/// is doing absolutely nothing.

356

/// </summary>

357

/// <remarks>

358

        /// This does mean that agent updates must be processed synchronously, at least for each client, and called methods

359

/// cannot retain a reference to it outside of that method.

360

/// </remarks>

361

private AgentUpdateArgs m_thisAgentUpdateArgs = new AgentUpdateArgs();

362

363

        protected Dictionary<PacketType, PacketProcessor> m_packetHandlers = new Dictionary<PacketType, PacketProcessor>();

364

        protected Dictionary<string, GenericMessage> m_genericPacketHandlers = new Dictionary<string, GenericMessage>(); //PauPaw:Local Generic Message handlers

365

protected Scene m_scene;

366

protected string m_firstName;

367

protected string m_lastName;

368

protected Thread m_clientThread;

369

protected Vector3 m_startpos;

370

protected UUID m_activeGroupID;

371

protected string m_activeGroupName = String.Empty;

372

protected ulong m_activeGroupPowers;

373

protected Dictionary<UUID, ulong> m_groupPowers = new Dictionary<UUID, ulong>();

374

protected int m_terrainCheckerCount;

375

protected uint m_agentFOVCounter;

376

377

protected IAssetService m_assetService;

378

private const bool m_checkPackets = true;

379

380

#endregion Class Members

#region Properties

public LLUDPClient UDPClient { get { return m_udpClient; } }

385

public LLUDPServer UDPServer { get { return m_udpServer; } }

386

public IPEndPoint RemoteEndPoint { get { return m_udpClient.RemoteEndPoint; } }

387

public UUID SecureSessionId { get { return m_secureSessionId; } }

388

public IScene Scene { get { return m_scene; } }

389

public UUID SessionId { get { return m_sessionId; } }

390

public Vector3 StartPos

391

{

392

get { return m_startpos; }

393

set { m_startpos = value; }

394

}

395

public UUID AgentId { get { return m_agentId; } }

396

public ISceneAgent SceneAgent { get; set; }

397

public UUID ActiveGroupId { get { return m_activeGroupID; } }

398

public string ActiveGroupName { get { return m_activeGroupName; } }

399

public ulong ActiveGroupPowers { get { return m_activeGroupPowers; } }

400

public bool IsGroupMember(UUID groupID) { return m_groupPowers.ContainsKey(groupID); }

401

402

/// <summary>

403

/// Entity update queues

404

/// </summary>

405

public PriorityQueue EntityUpdateQueue { get { return m_entityUpdates; } }

406

407

/// <summary>

408

/// First name of the agent/avatar represented by the client

409

/// </summary>

410

public string FirstName { get { return m_firstName; } }

411

412

/// <summary>

413

/// Last name of the agent/avatar represented by the client

414

/// </summary>

415

public string LastName { get { return m_lastName; } }

416

417

/// <summary>

418

/// Full name of the client (first name and last name)

419

/// </summary>

420

public string Name { get { return FirstName + " " + LastName; } }

421

422

public uint CircuitCode { get { return m_circuitCode; } }

423

public int NextAnimationSequenceNumber { get { return m_animationSequenceNumber++; } }

424

425

/// <summary>

426

/// As well as it's function in IClientAPI, in LLClientView we are locking on this property in order to

427

/// prevent race conditions by different threads calling Close().

428

/// </summary>

429

public bool IsActive { get; set; }

430

431

/// <summary>

432

/// Used to synchronise threads when client is being closed.

433

/// </summary>

434

public Object CloseSyncLock { get; private set; }

435

436

public bool IsLoggingOut { get; set; }

437

438

public bool DisableFacelights

439

{

440

get { return m_disableFacelights; }

441

set { m_disableFacelights = value; }

442

}

443

444

public bool SendLogoutPacketWhenClosing { set { m_SendLogoutPacketWhenClosing = value; } }

445

446

#endregion Properties

// ~LLClientView()

// {

// m_log.DebugFormat("[LLCLIENTVIEW]: Destructor called for {0}, circuit code {1}", Name, CircuitCode);

// }

/// <summary>

/// Constructor

/// </summary>

public LLClientView(Scene scene, LLUDPServer udpServer, LLUDPClient udpClient, AuthenticateResponse sessionInfo,

457

UUID agentId, UUID sessionId, uint circuitCode)

458

{

459

// DebugPacketLevel = 1;

460

461

CloseSyncLock = new Object();

462

463

RegisterInterface<IClientIM>(this);

464

RegisterInterface<IClientInventory>(this);

465

RegisterInterface<IClientChat>(this);

466

467

m_scene = scene;

468

m_entityUpdates = new PriorityQueue(m_scene.Entities.Count);

469

m_entityProps = new PriorityQueue(m_scene.Entities.Count);

470

m_fullUpdateDataBlocksBuilder = new List<ObjectUpdatePacket.ObjectDataBlock>();

471

m_killRecord = new HashSet<uint>();

472

// m_attachmentsSent = new HashSet<uint>();

473

474

m_assetService = m_scene.RequestModuleInterface<IAssetService>();

475

m_GroupsModule = scene.RequestModuleInterface<IGroupsModule>();

476

ImageManager = new LLImageManager(this, m_assetService, Scene.RequestModuleInterface<IJ2KDecoder>());

477

m_channelVersion = Util.StringToBytes256(scene.GetSimulatorVersion());

478

m_agentId = agentId;

479

m_sessionId = sessionId;

480

m_secureSessionId = sessionInfo.LoginInfo.SecureSession;

481

m_circuitCode = circuitCode;

482

m_firstName = sessionInfo.LoginInfo.First;

483

m_lastName = sessionInfo.LoginInfo.Last;

484

m_startpos = sessionInfo.LoginInfo.StartPos;

485

486

m_udpServer = udpServer;

487

m_udpClient = udpClient;

488

m_udpClient.OnQueueEmpty += HandleQueueEmpty;

489

m_udpClient.HasUpdates += HandleHasUpdates;

490

m_udpClient.OnPacketStats += PopulateStats;

491

492

m_prioritizer = new Prioritizer(m_scene);

493

494

RegisterLocalPacketHandlers();

IsActive = true;

}

#region Client Methods

500

501

public void Close()

{

Close(false);

}

public void Close(bool force)

507

{

508

// We lock here to prevent race conditions between two threads calling close simultaneously (e.g.

509

// a simultaneous relog just as a client is being closed out due to no packet ack from the old connection.

510

lock (CloseSyncLock)

511

{

512

// We still perform a force close inside the sync lock since this is intended to attempt close where

513

// there is some unidentified connection problem, not where we have issues due to deadlock

514

if (!IsActive && !force)

515

{

516

m_log.DebugFormat(

517

"[CLIENT]: Not attempting to close inactive client {0} in {1} since force flag is not set",

518

Name, m_scene.Name);

return;

}

IsActive = false;

CloseWithoutChecks();

}

}

/// <summary>

/// Closes down the client view without first checking whether it is active.

530

/// </summary>

531

/// <remarks>

532

/// This exists because LLUDPServer has to set IsActive = false in earlier synchronous code before calling

533

/// CloseWithoutIsActiveCheck asynchronously.

534

///

535

/// Callers must lock ClosingSyncLock before calling.

536

/// </remarks>

537

public void CloseWithoutChecks()

538

{

539

m_log.DebugFormat(

540

"[CLIENT]: Close has been called for {0} attached to scene {1}",

541

Name, m_scene.RegionInfo.RegionName);

542

543

// Shutdown the image manager

544

ImageManager.Close();

545

546

// Fire the callback for this connection closing

547

if (OnConnectionClosed != null)

548

OnConnectionClosed(this);

549

550

// Flush all of the packets out of the UDP server for this client

551

if (m_udpServer != null)

552

m_udpServer.Flush(m_udpClient);

553

554

// Remove ourselves from the scene

555

m_scene.RemoveClient(AgentId, true);

556

SceneAgent = null;

557

558

// We can't reach into other scenes and close the connection

559

// We need to do this over grid communications

560

//m_scene.CloseAllAgents(CircuitCode);

561

562

// Disable UDP handling for this client

563

m_udpClient.Shutdown();

564

565

//m_log.InfoFormat("[CLIENTVIEW] Memory pre GC {0}", System.GC.GetTotalMemory(false));

566

//GC.Collect();

567

//m_log.InfoFormat("[CLIENTVIEW] Memory post GC {0}", System.GC.GetTotalMemory(true));

568

}

569

570

public void Kick(string message)

571

{

572

if (!SceneAgent.IsChildAgent)

573

{

574

KickUserPacket kupack = (KickUserPacket)PacketPool.Instance.GetPacket(PacketType.KickUser);

575

kupack.UserInfo.AgentID = AgentId;

576

kupack.UserInfo.SessionID = SessionId;

577

kupack.TargetBlock.TargetIP = 0;

578

kupack.TargetBlock.TargetPort = 0;

579

kupack.UserInfo.Reason = Util.StringToBytes256(message);

580

OutPacket(kupack, ThrottleOutPacketType.Task);

581

// You must sleep here or users get no message!

Thread.Sleep(500);

}

}

public void Stop()

{

}

#endregion Client Methods

592

593

#region Packet Handling

594

595

public void PopulateStats(int inPackets, int outPackets, int unAckedBytes)

596

{

597

NetworkStats handlerNetworkStatsUpdate = OnNetworkStatsUpdate;

598

if (handlerNetworkStatsUpdate != null)

599

{

600

handlerNetworkStatsUpdate(inPackets, outPackets, unAckedBytes);

}

}

public static bool AddPacketHandler(PacketType packetType, PacketMethod handler)

605

{

606

bool result = false;

607

lock (PacketHandlers)

608

{

609

if (!PacketHandlers.ContainsKey(packetType))

610

{

611

PacketHandlers.Add(packetType, handler);

result = true;

}

}

return result;

}

/// <summary>

/// Add a handler for the given packet type.

620

/// </summary>

621

/// <remarks>

622

/// The packet is handled on its own thread. If packets must be handled in the order in which they

623

/// are received then please use the synchronous version of this method.

624

/// </remarks>

625

/// <param name="packetType"></param>

626

/// <param name="handler"></param>

627

/// <returns>true if the handler was added. This is currently always the case.</returns>

628

public bool AddLocalPacketHandler(PacketType packetType, PacketMethod handler)

629

{

630

return AddLocalPacketHandler(packetType, handler, true);

}

/// <summary>

/// Add a handler for the given packet type.

635

/// </summary>

636

/// <param name="packetType"></param>

637

/// <param name="handler"></param>

638

/// <param name="doAsync">

639

/// If true, when the packet is received it is handled on its own thread rather than on the main inward bound

640

/// packet handler thread. This vastly increases respnosiveness but some packets need to be handled

641

/// synchronously.

642

/// </param>

643

/// <returns>true if the handler was added. This is currently always the case.</returns>

644

public bool AddLocalPacketHandler(PacketType packetType, PacketMethod handler, bool doAsync)

645

{

646

bool result = false;

647

lock (m_packetHandlers)

648

{

649

if (!m_packetHandlers.ContainsKey(packetType))

650

{

651

m_packetHandlers.Add(packetType, new PacketProcessor() { method = handler, Async = doAsync });

result = true;

}

}

return result;

}

public bool AddGenericPacketHandler(string MethodName, GenericMessage handler)

660

{

661

MethodName = MethodName.ToLower().Trim();

662

663

bool result = false;

664

lock (m_genericPacketHandlers)

665

{

666

if (!m_genericPacketHandlers.ContainsKey(MethodName))

667

{

668

m_genericPacketHandlers.Add(MethodName, handler);

result = true;

}

}

return result;

}

/// <summary>

/// Try to process a packet using registered packet handlers

677

/// </summary>

678

/// <param name="packet"></param>

679

/// <returns>True if a handler was found which successfully processed the packet.</returns>

680

protected virtual bool ProcessPacketMethod(Packet packet)

681

{

682

bool result = false;

683

PacketProcessor pprocessor;

684

if (m_packetHandlers.TryGetValue(packet.Type, out pprocessor))

685

{

686

//there is a local handler for this packet type

687

if (pprocessor.Async)

688

{

689

ClientInfo cinfo = UDPClient.GetClientInfo();

690

if (!cinfo.AsyncRequests.ContainsKey(packet.Type.ToString()))

691

cinfo.AsyncRequests[packet.Type.ToString()] = 0;

692

cinfo.AsyncRequests[packet.Type.ToString()]++;

693

694

object obj = new AsyncPacketProcess(this, pprocessor.method, packet);

695

Util.FireAndForget(ProcessSpecificPacketAsync, obj);

result = true;

}

else

{

ClientInfo cinfo = UDPClient.GetClientInfo();

701

if (!cinfo.SyncRequests.ContainsKey(packet.Type.ToString()))

702

cinfo.SyncRequests[packet.Type.ToString()] = 0;

703

cinfo.SyncRequests[packet.Type.ToString()]++;

704

705

result = pprocessor.method(this, packet);

}

}

else

{

//there is not a local handler so see if there is a Global handler

711

PacketMethod method = null;

712

bool found;

713

lock (PacketHandlers)

714

{

715

found = PacketHandlers.TryGetValue(packet.Type, out method);

}

if (found)

{

ClientInfo cinfo = UDPClient.GetClientInfo();

720

if (!cinfo.GenericRequests.ContainsKey(packet.Type.ToString()))

721

cinfo.GenericRequests[packet.Type.ToString()] = 0;

722

cinfo.GenericRequests[packet.Type.ToString()]++;

723

724

result = method(this, packet);

}

}

return result;

}

public void ProcessSpecificPacketAsync(object state)

731

{

732

AsyncPacketProcess packetObject = (AsyncPacketProcess)state;

try

{

packetObject.result = packetObject.Method(packetObject.ClientView, packetObject.Pack);

737

}

738

catch (Exception e)

739

{

740

// Make sure that we see any exception caused by the asynchronous operation.

741

m_log.ErrorFormat(

742

"[LLCLIENTVIEW]: Caught exception while processing {0} for {1}, {2} {3}",

743

packetObject.Pack, Name, e.Message, e.StackTrace);

}

}

#endregion Packet Handling

# region Setup

public virtual void Start()

752

{

753

m_scene.AddNewAgent(this, PresenceType.User);

754

755

RefreshGroupMembership();

}

# endregion

public void ActivateGesture(UUID assetId, UUID gestureId)

{

}

public void DeactivateGesture(UUID assetId, UUID gestureId)

{

}

// Sound

        public void SoundTrigger(UUID soundId, UUID owerid, UUID Objectid, UUID ParentId, float Gain, Vector3 Position, UInt64 Handle)

{

}

#region Scene/Avatar to Client

774

775

public void SendRegionHandshake(RegionInfo regionInfo, RegionHandshakeArgs args)

776

{

777

            RegionHandshakePacket handshake = (RegionHandshakePacket)PacketPool.Instance.GetPacket(PacketType.RegionHandshake);

778

handshake.RegionInfo = new RegionHandshakePacket.RegionInfoBlock();

779

handshake.RegionInfo.BillableFactor = args.billableFactor;

780

handshake.RegionInfo.IsEstateManager = args.isEstateManager;

781

handshake.RegionInfo.TerrainHeightRange00 = args.terrainHeightRange0;

782

handshake.RegionInfo.TerrainHeightRange01 = args.terrainHeightRange1;

783

handshake.RegionInfo.TerrainHeightRange10 = args.terrainHeightRange2;

784

handshake.RegionInfo.TerrainHeightRange11 = args.terrainHeightRange3;

785

handshake.RegionInfo.TerrainStartHeight00 = args.terrainStartHeight0;

786

handshake.RegionInfo.TerrainStartHeight01 = args.terrainStartHeight1;

787

handshake.RegionInfo.TerrainStartHeight10 = args.terrainStartHeight2;

788

handshake.RegionInfo.TerrainStartHeight11 = args.terrainStartHeight3;

789

handshake.RegionInfo.SimAccess = args.simAccess;

790

handshake.RegionInfo.WaterHeight = args.waterHeight;

791

792

handshake.RegionInfo.RegionFlags = args.regionFlags;

793

handshake.RegionInfo.SimName = Util.StringToBytes256(args.regionName);

794

handshake.RegionInfo.SimOwner = args.SimOwner;

795

handshake.RegionInfo.TerrainBase0 = args.terrainBase0;

796

handshake.RegionInfo.TerrainBase1 = args.terrainBase1;

797

handshake.RegionInfo.TerrainBase2 = args.terrainBase2;

798

handshake.RegionInfo.TerrainBase3 = args.terrainBase3;

799

handshake.RegionInfo.TerrainDetail0 = args.terrainDetail0;

800

handshake.RegionInfo.TerrainDetail1 = args.terrainDetail1;

801

handshake.RegionInfo.TerrainDetail2 = args.terrainDetail2;

802

handshake.RegionInfo.TerrainDetail3 = args.terrainDetail3;

803

handshake.RegionInfo.CacheID = UUID.Random(); //I guess this is for the client to remember an old setting?

804

handshake.RegionInfo2 = new RegionHandshakePacket.RegionInfo2Block();

805

handshake.RegionInfo2.RegionID = regionInfo.RegionID;

806

807

handshake.RegionInfo3 = new RegionHandshakePacket.RegionInfo3Block();

808

handshake.RegionInfo3.CPUClassID = 9;

809

handshake.RegionInfo3.CPURatio = 1;

810

811

handshake.RegionInfo3.ColoName = Utils.EmptyBytes;

812

handshake.RegionInfo3.ProductName = Util.StringToBytes256(regionInfo.RegionType);

813

handshake.RegionInfo3.ProductSKU = Utils.EmptyBytes;

814

815

handshake.RegionInfo4 = new RegionHandshakePacket.RegionInfo4Block[1];

816

handshake.RegionInfo4[0] = new RegionHandshakePacket.RegionInfo4Block();

817

handshake.RegionInfo4[0].RegionFlagsExtended = args.regionFlags;

818

handshake.RegionInfo4[0].RegionProtocols = 0; // 1 here would indicate that SSB is supported

819

820

OutPacket(handshake, ThrottleOutPacketType.Unknown);

}

public void MoveAgentIntoRegion(RegionInfo regInfo, Vector3 pos, Vector3 look)

825

{

826

            AgentMovementCompletePacket mov = (AgentMovementCompletePacket)PacketPool.Instance.GetPacket(PacketType.AgentMovementComplete);

827

mov.SimData.ChannelVersion = m_channelVersion;

828

mov.AgentData.SessionID = m_sessionId;

829

mov.AgentData.AgentID = AgentId;

830

mov.Data.RegionHandle = regInfo.RegionHandle;

831

mov.Data.Timestamp = (uint)Util.UnixTimeSinceEpoch();

832

833

if ((pos.X == 0) && (pos.Y == 0) && (pos.Z == 0))

834

{

835

mov.Data.Position = m_startpos;

}

else

{

mov.Data.Position = pos;

840

}

841

mov.Data.LookAt = look;

842

843

// Hack to get this out immediately and skip the throttles

844

OutPacket(mov, ThrottleOutPacketType.Unknown);

845

}

846

847

public void SendChatMessage(

848

string message, byte type, Vector3 fromPos, string fromName,

849

UUID fromAgentID, UUID ownerID, byte source, byte audible)

850

{

851

            ChatFromSimulatorPacket reply = (ChatFromSimulatorPacket)PacketPool.Instance.GetPacket(PacketType.ChatFromSimulator);

852

reply.ChatData.Audible = audible;

853

reply.ChatData.Message = Util.StringToBytes1024(message);

854

reply.ChatData.ChatType = type;

855

reply.ChatData.SourceType = source;

856

reply.ChatData.Position = fromPos;

857

reply.ChatData.FromName = Util.StringToBytes256(fromName);

858

reply.ChatData.OwnerID = ownerID;

859

reply.ChatData.SourceID = fromAgentID;

860

861

OutPacket(reply, ThrottleOutPacketType.Task);

}

/// <summary>

/// Send an instant message to this client

866

/// </summary>

867

//

868

// Don't remove transaction ID! Groups and item gives need to set it!

869

public void SendInstantMessage(GridInstantMessage im)

870

{

871

if (((Scene)(m_scene)).Permissions.CanInstantMessage(new UUID(im.fromAgentID), new UUID(im.toAgentID)))

872

{

873

ImprovedInstantMessagePacket msg

874

= (ImprovedInstantMessagePacket)PacketPool.Instance.GetPacket(PacketType.ImprovedInstantMessage);

875

876

msg.AgentData.AgentID = new UUID(im.fromAgentID);

877

msg.AgentData.SessionID = UUID.Zero;

878

msg.MessageBlock.FromAgentName = Util.StringToBytes256(im.fromAgentName);

879

msg.MessageBlock.Dialog = im.dialog;

880

msg.MessageBlock.FromGroup = im.fromGroup;

881

if (im.imSessionID == UUID.Zero.Guid)

882

msg.MessageBlock.ID = new UUID(im.fromAgentID) ^ new UUID(im.toAgentID);

883

else

884

msg.MessageBlock.ID = new UUID(im.imSessionID);

885

msg.MessageBlock.Offline = im.offline;

886

msg.MessageBlock.ParentEstateID = im.ParentEstateID;

887

msg.MessageBlock.Position = im.Position;

888

msg.MessageBlock.RegionID = new UUID(im.RegionID);

889

msg.MessageBlock.Timestamp = im.timestamp;

890

msg.MessageBlock.ToAgentID = new UUID(im.toAgentID);

891

msg.MessageBlock.Message = Util.StringToBytes1024(im.message);

892

msg.MessageBlock.BinaryBucket = im.binaryBucket;

893

894

if (im.message.StartsWith("[grouptest]"))

895

{ // this block is test code for implementing group IM - delete when group IM is finished

896

IEventQueue eq = Scene.RequestModuleInterface<IEventQueue>();

if (eq != null)

{

im.dialog = 17;

//eq.ChatterboxInvitation(

902

// new UUID("00000000-68f9-1111-024e-222222111123"),

903

                        //    "OpenSimulator Testing", im.fromAgentID, im.message, im.toAgentID, im.fromAgentName, im.dialog, 0,

904

// false, 0, new Vector3(), 1, im.imSessionID, im.fromGroup, im.binaryBucket);

905

906

eq.ChatterboxInvitation(

907

new UUID("00000000-68f9-1111-024e-222222111123"),

908

                            "OpenSimulator Testing", new UUID(im.fromAgentID), im.message, new UUID(im.toAgentID), im.fromAgentName, im.dialog, 0,

909

                            false, 0, new Vector3(), 1, new UUID(im.imSessionID), im.fromGroup, Util.StringToBytes256("OpenSimulator Testing"));

910

911

eq.ChatterBoxSessionAgentListUpdates(

912

new UUID("00000000-68f9-1111-024e-222222111123"),

913

new UUID(im.fromAgentID), new UUID(im.toAgentID), false, false, false);

914

}

915

916

Console.WriteLine("SendInstantMessage: " + msg);

917

}

918

else

919

OutPacket(msg, ThrottleOutPacketType.Task);

}

}

public void SendGenericMessage(string method, UUID invoice, List<string> message)

924

{

925

GenericMessagePacket gmp = new GenericMessagePacket();

926

927

gmp.AgentData.AgentID = AgentId;

928

gmp.AgentData.SessionID = m_sessionId;

929

gmp.AgentData.TransactionID = invoice;

930

931

gmp.MethodData.Method = Util.StringToBytes256(method);

932

gmp.ParamList = new GenericMessagePacket.ParamListBlock[message.Count];

933

int i = 0;

934

foreach (string val in message)

935

{

936

gmp.ParamList[i] = new GenericMessagePacket.ParamListBlock();

937

gmp.ParamList[i++].Parameter = Util.StringToBytes256(val);

938

}

939

940

OutPacket(gmp, ThrottleOutPacketType.Task);

941

}

942

943

public void SendGenericMessage(string method, UUID invoice, List<byte[]> message)

944

{

945

GenericMessagePacket gmp = new GenericMessagePacket();

946

947

gmp.AgentData.AgentID = AgentId;

948

gmp.AgentData.SessionID = m_sessionId;

949

gmp.AgentData.TransactionID = invoice;

950

951

gmp.MethodData.Method = Util.StringToBytes256(method);

952

gmp.ParamList = new GenericMessagePacket.ParamListBlock[message.Count];

953

int i = 0;

954

foreach (byte[] val in message)

955

{

956

gmp.ParamList[i] = new GenericMessagePacket.ParamListBlock();

957

gmp.ParamList[i++].Parameter = val;

958

}

959

960

OutPacket(gmp, ThrottleOutPacketType.Task);

961

}

962

963

public void SendGroupActiveProposals(UUID groupID, UUID transactionID, GroupActiveProposals[] Proposals)

964

{

965

int i = 0;

966

foreach (GroupActiveProposals Proposal in Proposals)

967

{

968

GroupActiveProposalItemReplyPacket GAPIRP = new GroupActiveProposalItemReplyPacket();

969

970

GAPIRP.AgentData.AgentID = AgentId;

971

GAPIRP.AgentData.GroupID = groupID;

972

GAPIRP.TransactionData.TransactionID = transactionID;

973

GAPIRP.TransactionData.TotalNumItems = ((uint)i+1);

974

                GroupActiveProposalItemReplyPacket.ProposalDataBlock ProposalData = new GroupActiveProposalItemReplyPacket.ProposalDataBlock();

975

GAPIRP.ProposalData = new GroupActiveProposalItemReplyPacket.ProposalDataBlock[1];

976

ProposalData.VoteCast = Utils.StringToBytes("false");

977

ProposalData.VoteID = new UUID(Proposal.VoteID);

978

ProposalData.VoteInitiator = new UUID(Proposal.VoteInitiator);

979

ProposalData.Majority = (float)Convert.ToInt32(Proposal.Majority);

980

ProposalData.Quorum = Convert.ToInt32(Proposal.Quorum);

981

ProposalData.TerseDateID = Utils.StringToBytes(Proposal.TerseDateID);

982

ProposalData.StartDateTime = Utils.StringToBytes(Proposal.StartDateTime);

983

ProposalData.EndDateTime = Utils.StringToBytes(Proposal.EndDateTime);

984

ProposalData.ProposalText = Utils.StringToBytes(Proposal.ProposalText);

985

ProposalData.AlreadyVoted = false;

986

GAPIRP.ProposalData[i] = ProposalData;

987

OutPacket(GAPIRP, ThrottleOutPacketType.Task);

988

i++;

989

}

990

if (Proposals.Length == 0)

991

{

992

GroupActiveProposalItemReplyPacket GAPIRP = new GroupActiveProposalItemReplyPacket();

993

994

GAPIRP.AgentData.AgentID = AgentId;

995

GAPIRP.AgentData.GroupID = groupID;

996

GAPIRP.TransactionData.TransactionID = transactionID;

997

GAPIRP.TransactionData.TotalNumItems = 1;

998

                GroupActiveProposalItemReplyPacket.ProposalDataBlock ProposalData = new GroupActiveProposalItemReplyPacket.ProposalDataBlock();

999

GAPIRP.ProposalData = new GroupActiveProposalItemReplyPacket.ProposalDataBlock[1];

1000

ProposalData.VoteCast = Utils.StringToBytes("false");

1001

ProposalData.VoteID = UUID.Zero;

1002

ProposalData.VoteInitiator = UUID.Zero;

1003

ProposalData.Majority = 0;

1004

ProposalData.Quorum = 0;

1005

ProposalData.TerseDateID = Utils.StringToBytes("");

1006

ProposalData.StartDateTime = Utils.StringToBytes("");

1007

ProposalData.EndDateTime = Utils.StringToBytes("");

1008

ProposalData.ProposalText = Utils.StringToBytes("");

1009

ProposalData.AlreadyVoted = false;

1010

GAPIRP.ProposalData[0] = ProposalData;

1011

OutPacket(GAPIRP, ThrottleOutPacketType.Task);

}

}

public void SendGroupVoteHistory(UUID groupID, UUID transactionID, GroupVoteHistory[] Votes)

1016

{

1017

int i = 0;

1018

foreach (GroupVoteHistory Vote in Votes)

1019

{

1020

GroupVoteHistoryItemReplyPacket GVHIRP = new GroupVoteHistoryItemReplyPacket();

1021

1022

GVHIRP.AgentData.AgentID = AgentId;

1023

GVHIRP.AgentData.GroupID = groupID;

1024

GVHIRP.TransactionData.TransactionID = transactionID;

1025

GVHIRP.TransactionData.TotalNumItems = ((uint)i+1);

1026

GVHIRP.HistoryItemData.VoteID = new UUID(Vote.VoteID);

1027

GVHIRP.HistoryItemData.VoteInitiator = new UUID(Vote.VoteInitiator);

1028

GVHIRP.HistoryItemData.Majority = (float)Convert.ToInt32(Vote.Majority);

1029

GVHIRP.HistoryItemData.Quorum = Convert.ToInt32(Vote.Quorum);

1030

GVHIRP.HistoryItemData.TerseDateID = Utils.StringToBytes(Vote.TerseDateID);

1031

GVHIRP.HistoryItemData.StartDateTime = Utils.StringToBytes(Vote.StartDateTime);

1032

GVHIRP.HistoryItemData.EndDateTime = Utils.StringToBytes(Vote.EndDateTime);

1033

GVHIRP.HistoryItemData.VoteType = Utils.StringToBytes(Vote.VoteType);

1034

GVHIRP.HistoryItemData.VoteResult = Utils.StringToBytes(Vote.VoteResult);

1035

GVHIRP.HistoryItemData.ProposalText = Utils.StringToBytes(Vote.ProposalText);

1036

                GroupVoteHistoryItemReplyPacket.VoteItemBlock VoteItem = new GroupVoteHistoryItemReplyPacket.VoteItemBlock();

1037

GVHIRP.VoteItem = new GroupVoteHistoryItemReplyPacket.VoteItemBlock[1];

1038

VoteItem.CandidateID = UUID.Zero;

1039

VoteItem.NumVotes = 0; //TODO: FIX THIS!!!

1040

VoteItem.VoteCast = Utils.StringToBytes("Yes");

1041

GVHIRP.VoteItem[i] = VoteItem;

1042

OutPacket(GVHIRP, ThrottleOutPacketType.Task);

1043

i++;

1044

}

1045

if (Votes.Length == 0)

1046

{

1047

GroupVoteHistoryItemReplyPacket GVHIRP = new GroupVoteHistoryItemReplyPacket();

1048

1049

GVHIRP.AgentData.AgentID = AgentId;

1050

GVHIRP.AgentData.GroupID = groupID;

1051

GVHIRP.TransactionData.TransactionID = transactionID;

1052

GVHIRP.TransactionData.TotalNumItems = 0;

1053

GVHIRP.HistoryItemData.VoteID = UUID.Zero;

1054

GVHIRP.HistoryItemData.VoteInitiator = UUID.Zero;

1055

GVHIRP.HistoryItemData.Majority = 0;

1056

GVHIRP.HistoryItemData.Quorum = 0;

1057

GVHIRP.HistoryItemData.TerseDateID = Utils.StringToBytes("");

1058

GVHIRP.HistoryItemData.StartDateTime = Utils.StringToBytes("");

1059

GVHIRP.HistoryItemData.EndDateTime = Utils.StringToBytes("");

1060

GVHIRP.HistoryItemData.VoteType = Utils.StringToBytes("");

1061

GVHIRP.HistoryItemData.VoteResult = Utils.StringToBytes("");

1062

GVHIRP.HistoryItemData.ProposalText = Utils.StringToBytes("");

1063

                GroupVoteHistoryItemReplyPacket.VoteItemBlock VoteItem = new GroupVoteHistoryItemReplyPacket.VoteItemBlock();

1064

GVHIRP.VoteItem = new GroupVoteHistoryItemReplyPacket.VoteItemBlock[1];

1065

VoteItem.CandidateID = UUID.Zero;

1066

VoteItem.NumVotes = 0; //TODO: FIX THIS!!!

1067

VoteItem.VoteCast = Utils.StringToBytes("No");

1068

GVHIRP.VoteItem[0] = VoteItem;

1069

OutPacket(GVHIRP, ThrottleOutPacketType.Task);

}

}

        public void SendGroupAccountingDetails(IClientAPI sender,UUID groupID, UUID transactionID, UUID sessionID, int amt)

1074

{

1075

GroupAccountDetailsReplyPacket GADRP = new GroupAccountDetailsReplyPacket();

1076

GADRP.AgentData = new GroupAccountDetailsReplyPacket.AgentDataBlock();

1077

GADRP.AgentData.AgentID = sender.AgentId;

1078

GADRP.AgentData.GroupID = groupID;

1079

GADRP.HistoryData = new GroupAccountDetailsReplyPacket.HistoryDataBlock[1];

1080

            GroupAccountDetailsReplyPacket.HistoryDataBlock History = new GroupAccountDetailsReplyPacket.HistoryDataBlock();

1081

GADRP.MoneyData = new GroupAccountDetailsReplyPacket.MoneyDataBlock();

1082

GADRP.MoneyData.CurrentInterval = 0;

1083

GADRP.MoneyData.IntervalDays = 7;

1084

GADRP.MoneyData.RequestID = transactionID;

1085

GADRP.MoneyData.StartDate = Utils.StringToBytes(DateTime.Today.ToString());

1086

History.Amount = amt;

1087

History.Description = Utils.StringToBytes("");

1088

GADRP.HistoryData[0] = History;

1089

OutPacket(GADRP, ThrottleOutPacketType.Task);

1090

}

1091

1092

        public void SendGroupAccountingSummary(IClientAPI sender,UUID groupID, uint moneyAmt, int totalTier, int usedTier)

1093

{

1094

GroupAccountSummaryReplyPacket GASRP =

1095

(GroupAccountSummaryReplyPacket)PacketPool.Instance.GetPacket(

1096

PacketType.GroupAccountSummaryReply);

1097

1098

GASRP.AgentData = new GroupAccountSummaryReplyPacket.AgentDataBlock();

1099

GASRP.AgentData.AgentID = sender.AgentId;

1100

GASRP.AgentData.GroupID = groupID;

1101

GASRP.MoneyData = new GroupAccountSummaryReplyPacket.MoneyDataBlock();

1102

GASRP.MoneyData.Balance = (int)moneyAmt;

1103

GASRP.MoneyData.TotalCredits = totalTier;

1104

GASRP.MoneyData.TotalDebits = usedTier;

1105

GASRP.MoneyData.StartDate = new byte[1];

1106

GASRP.MoneyData.CurrentInterval = 1;

1107

GASRP.MoneyData.GroupTaxCurrent = 0;

1108

GASRP.MoneyData.GroupTaxEstimate = 0;

1109

GASRP.MoneyData.IntervalDays = 0;

1110

GASRP.MoneyData.LandTaxCurrent = 0;

1111

GASRP.MoneyData.LandTaxEstimate = 0;

1112

GASRP.MoneyData.LastTaxDate = new byte[1];

1113

GASRP.MoneyData.LightTaxCurrent = 0;

1114

GASRP.MoneyData.TaxDate = new byte[1];

1115

GASRP.MoneyData.RequestID = sender.AgentId;

1116

GASRP.MoneyData.ParcelDirFeeEstimate = 0;

1117

GASRP.MoneyData.ParcelDirFeeCurrent = 0;

1118

GASRP.MoneyData.ObjectTaxEstimate = 0;

1119

GASRP.MoneyData.NonExemptMembers = 0;

1120

GASRP.MoneyData.ObjectTaxCurrent = 0;

1121

GASRP.MoneyData.LightTaxEstimate = 0;

1122

OutPacket(GASRP, ThrottleOutPacketType.Task);

1123

}

1124

1125

        public void SendGroupTransactionsSummaryDetails(IClientAPI sender,UUID groupID, UUID transactionID, UUID sessionID, int amt)

1126

{

1127

GroupAccountTransactionsReplyPacket GATRP =

1128

(GroupAccountTransactionsReplyPacket)PacketPool.Instance.GetPacket(

1129

PacketType.GroupAccountTransactionsReply);

1130

1131

GATRP.AgentData = new GroupAccountTransactionsReplyPacket.AgentDataBlock();

1132

GATRP.AgentData.AgentID = sender.AgentId;

1133

GATRP.AgentData.GroupID = groupID;

1134

GATRP.MoneyData = new GroupAccountTransactionsReplyPacket.MoneyDataBlock();

1135

GATRP.MoneyData.CurrentInterval = 0;

1136

GATRP.MoneyData.IntervalDays = 7;

1137

GATRP.MoneyData.RequestID = transactionID;

1138

GATRP.MoneyData.StartDate = Utils.StringToBytes(DateTime.Today.ToString());

1139

GATRP.HistoryData = new GroupAccountTransactionsReplyPacket.HistoryDataBlock[1];

1140

            GroupAccountTransactionsReplyPacket.HistoryDataBlock History = new GroupAccountTransactionsReplyPacket.HistoryDataBlock();

1141

History.Amount = 0;

1142

History.Item = Utils.StringToBytes("");

1143

History.Time = Utils.StringToBytes("");

1144

History.Type = 0;

1145

History.User = Utils.StringToBytes("");

1146

GATRP.HistoryData[0] = History;

1147

OutPacket(GATRP, ThrottleOutPacketType.Task);

}

/// <summary>

/// Send the region heightmap to the client

1152

/// </summary>

1153

/// <param name="map">heightmap</param>

1154

public virtual void SendLayerData(float[] map)

1155

{

1156

Util.FireAndForget(DoSendLayerData, map);

}

/// <summary>

/// Send terrain layer information to the client.

1161

/// </summary>

1162

/// <param name="o"></param>

1163

private void DoSendLayerData(object o)

1164

{

1165

float[] map = LLHeightFieldMoronize((float[])o);

try

{

//for (int y = 0; y < 16; y++)

1170

//{

1171

// for (int x = 0; x < 16; x++)

1172

// {

1173

// SendLayerData(x, y, map);

// }

//}

// Send LayerData in a spiral pattern. Fun!

1178

SendLayerTopRight(map, 0, 0, 15, 15);

1179

}

1180

catch (Exception e)

1181

{

1182

m_log.Error("[CLIENT]: SendLayerData() Failed with exception: " + e.Message, e);

}

}

private void SendLayerTopRight(float[] map, int x1, int y1, int x2, int y2)

1187

{

1188

// Row

1189

for (int i = x1; i <= x2; i++)

1190

SendLayerData(i, y1, map);

1191

1192

// Column

1193

for (int j = y1 + 1; j <= y2; j++)

1194

SendLayerData(x2, j, map);

1195

1196

if (x2 - x1 > 0)

1197

SendLayerBottomLeft(map, x1, y1 + 1, x2 - 1, y2);

1198

}

1199

1200

void SendLayerBottomLeft(float[] map, int x1, int y1, int x2, int y2)

1201

{

1202

// Row in reverse

1203

for (int i = x2; i >= x1; i--)

1204

SendLayerData(i, y2, map);

1205

1206

// Column in reverse

1207

for (int j = y2 - 1; j >= y1; j--)

1208

SendLayerData(x1, j, map);

1209

1210

if (x2 - x1 > 0)

1211

SendLayerTopRight(map, x1 + 1, y1, x2, y2 - 1);

}

/// <summary>

/// Sends a set of four patches (x, x+1, ..., x+3) to the client

1216

/// </summary>

1217

/// <param name="map">heightmap</param>

1218

/// <param name="px">X coordinate for patches 0..12</param>

1219

/// <param name="py">Y coordinate for patches 0..15</param>

1220

// private void SendLayerPacket(float[] map, int y, int x)

1221

// {

1222

// int[] patches = new int[4];

1223

// patches[0] = x + 0 + y * 16;

1224

// patches[1] = x + 1 + y * 16;

1225

// patches[2] = x + 2 + y * 16;

1226

// patches[3] = x + 3 + y * 16;

1227

1228

// Packet layerpack = LLClientView.TerrainManager.CreateLandPacket(map, patches);

1229

// OutPacket(layerpack, ThrottleOutPacketType.Land);

// }

/// <summary>

/// Sends a specified patch to a client

1234

/// </summary>

1235

/// <param name="px">Patch coordinate (x) 0..15</param>

1236

/// <param name="py">Patch coordinate (y) 0..15</param>

1237

/// <param name="map">heightmap</param>

1238

public void SendLayerData(int px, int py, float[] map)

{

try

{

int[] patches = new int[] { py * 16 + px };

1243

float[] heightmap = (map.Length == 65536) ?

1244

map :

1245

LLHeightFieldMoronize(map);

1246

1247

LayerDataPacket layerpack = TerrainCompressor.CreateLandPacket(heightmap, patches);

1248

1249

                // When a user edits the terrain, so much data is sent, the data queues up fast and presents a sub optimal editing experience.

1250

                // To alleviate this issue, when the user edits the terrain, we start skipping the queues until they're done editing the terrain.

1251

                // We also make them unreliable because it's extremely likely that multiple packets will be sent for a terrain patch area

1252

// invalidating previous packets for that area.

1253

1254

                // It's possible for an editing user to flood themselves with edited packets but the majority of use cases are such that only a

1255

                // tiny percentage of users will be editing the terrain.     Other, non-editing users will see the edits much slower.

1256

1257

                // One last note on this topic, by the time users are going to be editing the terrain, it's extremely likely that the sim will

1258

                // have rezzed already and therefore this is not likely going to cause any additional issues with lost packets, objects or terrain

1259

// patches.

1260

1261

                // m_justEditedTerrain is volatile, so test once and duplicate two affected statements so we only have one cache miss.

1262

if (m_justEditedTerrain)

1263

{

1264

layerpack.Header.Reliable = false;

1265

OutPacket(layerpack,

1266

ThrottleOutPacketType.Unknown );

}

else

{

layerpack.Header.Reliable = true;

1271

OutPacket(layerpack,

1272

ThrottleOutPacketType.Land);

1273

}

1274

}

1275

catch (Exception e)

1276

{

1277

m_log.Error("[CLIENT]: SendLayerData() Failed with exception: " + e.Message, e);

}

}

/// <summary>

/// Munges heightfield into the LLUDP backed in restricted heightfield.

1283

/// </summary>

1284

/// <param name="map">float array in the base; Constants.RegionSize</param>

1285

/// <returns>float array in the base 256</returns>

1286

internal float[] LLHeightFieldMoronize(float[] map)

1287

{

1288

if (map.Length == 65536)

return map;

else

{

float[] returnmap = new float[65536];

1293

1294

if (map.Length < 65535)

1295

{

1296

// rebase the vector stride to 256

1297

for (int i = 0; i < Constants.RegionSize; i++)

1298

Array.Copy(map, i * (int)Constants.RegionSize, returnmap, i * 256, (int)Constants.RegionSize);

}

else

{

for (int i = 0; i < 256; i++)

1303

Array.Copy(map, i * (int)Constants.RegionSize, returnmap, i * 256, 256);

1304

}

1305

1306

//Array.Copy(map,0,returnmap,0,(map.Length < 65536)? map.Length : 65536);

return returnmap;

}

}

/// <summary>

/// Send the wind matrix to the client

1315

/// </summary>

1316

/// <param name="windSpeeds">16x16 array of wind speeds</param>

1317

public virtual void SendWindData(Vector2[] windSpeeds)

1318

{

1319

Util.FireAndForget(DoSendWindData, windSpeeds);

}

/// <summary>

/// Send the cloud matrix to the client

1324

/// </summary>

1325

/// <param name="windSpeeds">16x16 array of cloud densities</param>

1326

public virtual void SendCloudData(float[] cloudDensity)

1327

{

1328

Util.FireAndForget(DoSendCloudData, cloudDensity);

}

/// <summary>

/// Send wind layer information to the client.

1333

/// </summary>

1334

/// <param name="o"></param>

1335

private void DoSendWindData(object o)

1336

{

1337

Vector2[] windSpeeds = (Vector2[])o;

1338

TerrainPatch[] patches = new TerrainPatch[2];

1339

patches[0] = new TerrainPatch();

1340

patches[0].Data = new float[16 * 16];

1341

patches[1] = new TerrainPatch();

1342

patches[1].Data = new float[16 * 16];

1343

1344

for (int y = 0; y < 16; y++)

1345

{

1346

for (int x = 0; x < 16; x++)

1347

{

1348

patches[0].Data[y * 16 + x] = windSpeeds[y * 16 + x].X;

1349

patches[1].Data[y * 16 + x] = windSpeeds[y * 16 + x].Y;

}

}

LayerDataPacket layerpack = TerrainCompressor.CreateLayerDataPacket(patches, TerrainPatch.LayerType.Wind);

1354

layerpack.Header.Zerocoded = true;

1355

OutPacket(layerpack, ThrottleOutPacketType.Wind);

}

/// <summary>

/// Send cloud layer information to the client.

1360

/// </summary>

1361

/// <param name="o"></param>

1362

private void DoSendCloudData(object o)

1363

{

1364

float[] cloudCover = (float[])o;

1365

TerrainPatch[] patches = new TerrainPatch[1];

1366

patches[0] = new TerrainPatch();

1367

patches[0].Data = new float[16 * 16];

1368

1369

for (int y = 0; y < 16; y++)

1370

{

1371

for (int x = 0; x < 16; x++)

1372

{

1373

patches[0].Data[y * 16 + x] = cloudCover[y * 16 + x];

}

}

LayerDataPacket layerpack = TerrainCompressor.CreateLayerDataPacket(patches, TerrainPatch.LayerType.Cloud);

1378

layerpack.Header.Zerocoded = true;

1379

OutPacket(layerpack, ThrottleOutPacketType.Cloud);

}

/// <summary>

/// Tell the client that the given neighbour region is ready to receive a child agent.

1384

/// </summary>

1385

public virtual void InformClientOfNeighbour(ulong neighbourHandle, IPEndPoint neighbourEndPoint)

1386

{

1387

IPAddress neighbourIP = neighbourEndPoint.Address;

1388

ushort neighbourPort = (ushort)neighbourEndPoint.Port;

1389

1390

            EnableSimulatorPacket enablesimpacket = (EnableSimulatorPacket)PacketPool.Instance.GetPacket(PacketType.EnableSimulator);

1391

// TODO: don't create new blocks if recycling an old packet

1392

enablesimpacket.SimulatorInfo = new EnableSimulatorPacket.SimulatorInfoBlock();

1393

enablesimpacket.SimulatorInfo.Handle = neighbourHandle;

1394

1395

byte[] byteIP = neighbourIP.GetAddressBytes();

1396

enablesimpacket.SimulatorInfo.IP = (uint)byteIP[3] << 24;

1397

enablesimpacket.SimulatorInfo.IP += (uint)byteIP[2] << 16;

1398

enablesimpacket.SimulatorInfo.IP += (uint)byteIP[1] << 8;

1399

enablesimpacket.SimulatorInfo.IP += (uint)byteIP[0];

1400

enablesimpacket.SimulatorInfo.Port = neighbourPort;

1401

1402

enablesimpacket.Header.Reliable = true; // ESP's should be reliable.

1403

1404

OutPacket(enablesimpacket, ThrottleOutPacketType.Task);

1405

}

1406

1407

public AgentCircuitData RequestClientInfo()

1408

{

1409

AgentCircuitData agentData = new AgentCircuitData();

1410

agentData.AgentID = AgentId;

1411

agentData.SessionID = m_sessionId;

1412

agentData.SecureSessionID = SecureSessionId;

1413

agentData.circuitcode = m_circuitCode;

1414

agentData.child = false;

1415

agentData.firstname = m_firstName;

1416

agentData.lastname = m_lastName;

1417

1418

ICapabilitiesModule capsModule = m_scene.RequestModuleInterface<ICapabilitiesModule>();

1419

1420

if (capsModule == null) // can happen when shutting down.

1421

return agentData;

1422

1423

agentData.CapsPath = capsModule.GetCapsPath(m_agentId);

1424

agentData.ChildrenCapSeeds = new Dictionary<ulong, string>(capsModule.GetChildrenSeeds(m_agentId));

return agentData;

}

        public virtual void CrossRegion(ulong newRegionHandle, Vector3 pos, Vector3 lookAt, IPEndPoint externalIPEndPoint,

1430

string capsURL)

1431

{

1432

Vector3 look = new Vector3(lookAt.X * 10, lookAt.Y * 10, lookAt.Z * 10);

1433

1434

            //CrossedRegionPacket newSimPack = (CrossedRegionPacket)PacketPool.Instance.GetPacket(PacketType.CrossedRegion);

1435

CrossedRegionPacket newSimPack = new CrossedRegionPacket();

1436

// TODO: don't create new blocks if recycling an old packet

1437

newSimPack.AgentData = new CrossedRegionPacket.AgentDataBlock();

1438

newSimPack.AgentData.AgentID = AgentId;

1439

newSimPack.AgentData.SessionID = m_sessionId;

1440

newSimPack.Info = new CrossedRegionPacket.InfoBlock();

1441

newSimPack.Info.Position = pos;

1442

newSimPack.Info.LookAt = look;

1443

newSimPack.RegionData = new CrossedRegionPacket.RegionDataBlock();

1444

newSimPack.RegionData.RegionHandle = newRegionHandle;

1445

byte[] byteIP = externalIPEndPoint.Address.GetAddressBytes();

1446

newSimPack.RegionData.SimIP = (uint)byteIP[3] << 24;

1447

newSimPack.RegionData.SimIP += (uint)byteIP[2] << 16;

1448

newSimPack.RegionData.SimIP += (uint)byteIP[1] << 8;

1449

newSimPack.RegionData.SimIP += (uint)byteIP[0];

1450

newSimPack.RegionData.SimPort = (ushort)externalIPEndPoint.Port;

1451

newSimPack.RegionData.SeedCapability = Util.StringToBytes256(capsURL);

1452

1453

// Hack to get this out immediately and skip throttles

1454

OutPacket(newSimPack, ThrottleOutPacketType.Unknown);

1455

}

1456

1457

internal void SendMapBlockSplit(List<MapBlockData> mapBlocks, uint flag)

1458

{

1459

MapBlockReplyPacket mapReply = (MapBlockReplyPacket)PacketPool.Instance.GetPacket(PacketType.MapBlockReply);

1460

// TODO: don't create new blocks if recycling an old packet

1461

1462

MapBlockData[] mapBlocks2 = mapBlocks.ToArray();

1463

1464

mapReply.AgentData.AgentID = AgentId;

1465

mapReply.Data = new MapBlockReplyPacket.DataBlock[mapBlocks2.Length];

1466

mapReply.AgentData.Flags = flag;

1467

1468

for (int i = 0; i < mapBlocks2.Length; i++)

1469

{

1470

mapReply.Data[i] = new MapBlockReplyPacket.DataBlock();

1471

mapReply.Data[i].MapImageID = mapBlocks2[i].MapImageId;

1472

//m_log.Warn(mapBlocks2[i].MapImageId.ToString());

1473

mapReply.Data[i].X = mapBlocks2[i].X;

1474

mapReply.Data[i].Y = mapBlocks2[i].Y;

1475

mapReply.Data[i].WaterHeight = mapBlocks2[i].WaterHeight;

1476

mapReply.Data[i].Name = Utils.StringToBytes(mapBlocks2[i].Name);

1477

mapReply.Data[i].RegionFlags = mapBlocks2[i].RegionFlags;

1478

mapReply.Data[i].Access = mapBlocks2[i].Access;

1479

mapReply.Data[i].Agents = mapBlocks2[i].Agents;

1480

}

1481

OutPacket(mapReply, ThrottleOutPacketType.Land);

1482

}

1483

1484

public void SendMapBlock(List<MapBlockData> mapBlocks, uint flag)

1485

{

1486

MapBlockData[] mapBlocks2 = mapBlocks.ToArray();

int maxsend = 10;

//int packets = Math.Ceiling(mapBlocks2.Length / maxsend);

1491

1492

List<MapBlockData> sendingBlocks = new List<MapBlockData>();

1493

1494

for (int i = 0; i < mapBlocks2.Length; i++)

1495

{

1496

sendingBlocks.Add(mapBlocks2[i]);

1497

if (((i + 1) == mapBlocks2.Length) || (((i + 1) % maxsend) == 0))

1498

{

1499

SendMapBlockSplit(sendingBlocks, flag);

1500

sendingBlocks = new List<MapBlockData>();

}

}

}

public void SendLocalTeleport(Vector3 position, Vector3 lookAt, uint flags)

1506

{

1507

TeleportLocalPacket tpLocal = (TeleportLocalPacket)PacketPool.Instance.GetPacket(PacketType.TeleportLocal);

1508

tpLocal.Info.AgentID = AgentId;

1509

tpLocal.Info.TeleportFlags = flags;

1510

tpLocal.Info.LocationID = 2;

1511

tpLocal.Info.LookAt = lookAt;

1512

tpLocal.Info.Position = position;

1513

1514

// Hack to get this out immediately and skip throttles

1515

OutPacket(tpLocal, ThrottleOutPacketType.Unknown);

1516

}

1517

1518

        public virtual void SendRegionTeleport(ulong regionHandle, byte simAccess, IPEndPoint newRegionEndPoint, uint locationID,

1519

uint flags, string capsURL)

1520

{

1521

            //TeleportFinishPacket teleport = (TeleportFinishPacket)PacketPool.Instance.GetPacket(PacketType.TeleportFinish);

1522

1523

TeleportFinishPacket teleport = new TeleportFinishPacket();

1524

teleport.Info.AgentID = AgentId;

1525

teleport.Info.RegionHandle = regionHandle;

1526

teleport.Info.SimAccess = simAccess;

1527

1528

teleport.Info.SeedCapability = Util.StringToBytes256(capsURL);

1529

1530

IPAddress oIP = newRegionEndPoint.Address;

1531

byte[] byteIP = oIP.GetAddressBytes();

1532

uint ip = (uint)byteIP[3] << 24;

1533

ip += (uint)byteIP[2] << 16;

1534

ip += (uint)byteIP[1] << 8;

1535

ip += (uint)byteIP[0];

1536

1537

teleport.Info.SimIP = ip;

1538

teleport.Info.SimPort = (ushort)newRegionEndPoint.Port;

1539

teleport.Info.LocationID = 4;

1540

teleport.Info.TeleportFlags = 1 << 4;

1541

1542

// Hack to get this out immediately and skip throttles.

1543

OutPacket(teleport, ThrottleOutPacketType.Unknown);

}

/// <summary>

/// Inform the client that a teleport attempt has failed

1548

/// </summary>

1549

public void SendTeleportFailed(string reason)

1550

{

1551

            TeleportFailedPacket tpFailed = (TeleportFailedPacket)PacketPool.Instance.GetPacket(PacketType.TeleportFailed);

1552

tpFailed.Info.AgentID = AgentId;

1553

tpFailed.Info.Reason = Util.StringToBytes256(reason);

1554

tpFailed.AlertInfo = new TeleportFailedPacket.AlertInfoBlock[0];

1555

1556

// Hack to get this out immediately and skip throttles

1557

OutPacket(tpFailed, ThrottleOutPacketType.Unknown);

}

/// <summary>

///

/// </summary>

public void SendTeleportStart(uint flags)

1564

{

1565

TeleportStartPacket tpStart = (TeleportStartPacket)PacketPool.Instance.GetPacket(PacketType.TeleportStart);

1566

//TeleportStartPacket tpStart = new TeleportStartPacket();

1567

tpStart.Info.TeleportFlags = flags; //16; // Teleport via location

1568

1569

// Hack to get this out immediately and skip throttles

1570

OutPacket(tpStart, ThrottleOutPacketType.Unknown);

1571

}

1572

1573

public void SendTeleportProgress(uint flags, string message)

1574

{

1575

            TeleportProgressPacket tpProgress = (TeleportProgressPacket)PacketPool.Instance.GetPacket(PacketType.TeleportProgress);

1576

tpProgress.AgentData.AgentID = this.AgentId;

1577

tpProgress.Info.TeleportFlags = flags;

1578

tpProgress.Info.Message = Util.StringToBytes256(message);

1579

1580

// Hack to get this out immediately and skip throttles

1581

OutPacket(tpProgress, ThrottleOutPacketType.Unknown);

1582

}

1583

1584

        public void SendMoneyBalance(UUID transaction, bool success, byte[] description, int balance, int transactionType, UUID sourceID, bool sourceIsGroup, UUID destID, bool destIsGroup, int amount, string item)

1585

{

1586

            MoneyBalanceReplyPacket money = (MoneyBalanceReplyPacket)PacketPool.Instance.GetPacket(PacketType.MoneyBalanceReply);

1587

money.MoneyData.AgentID = AgentId;

1588

money.MoneyData.TransactionID = transaction;

1589

money.MoneyData.TransactionSuccess = success;

1590

money.MoneyData.Description = description;

1591

money.MoneyData.MoneyBalance = balance;

1592

money.TransactionInfo.TransactionType = transactionType;

1593

money.TransactionInfo.SourceID = sourceID;

1594

money.TransactionInfo.IsSourceGroup = sourceIsGroup;

1595

money.TransactionInfo.DestID = destID;

1596

money.TransactionInfo.IsDestGroup = destIsGroup;

1597

money.TransactionInfo.Amount = amount;

1598

money.TransactionInfo.ItemDescription = Util.StringToBytes256(item);

1599

1600

OutPacket(money, ThrottleOutPacketType.Task);

1601

}

1602

1603

public void SendPayPrice(UUID objectID, int[] payPrice)

1604

{

1605

if (payPrice[0] == 0 &&

1606

payPrice[1] == 0 &&

1607

payPrice[2] == 0 &&

1608

payPrice[3] == 0 &&

payPrice[4] == 0)

return;

            PayPriceReplyPacket payPriceReply = (PayPriceReplyPacket)PacketPool.Instance.GetPacket(PacketType.PayPriceReply);

1613

payPriceReply.ObjectData.ObjectID = objectID;

1614

payPriceReply.ObjectData.DefaultPayPrice = payPrice[0];

1615

1616

payPriceReply.ButtonData = new PayPriceReplyPacket.ButtonDataBlock[4];

1617

payPriceReply.ButtonData[0] = new PayPriceReplyPacket.ButtonDataBlock();

1618

payPriceReply.ButtonData[0].PayButton = payPrice[1];

1619

payPriceReply.ButtonData[1] = new PayPriceReplyPacket.ButtonDataBlock();

1620

payPriceReply.ButtonData[1].PayButton = payPrice[2];

1621

payPriceReply.ButtonData[2] = new PayPriceReplyPacket.ButtonDataBlock();

1622

payPriceReply.ButtonData[2].PayButton = payPrice[3];

1623

payPriceReply.ButtonData[3] = new PayPriceReplyPacket.ButtonDataBlock();

1624

payPriceReply.ButtonData[3].PayButton = payPrice[4];

1625

1626

OutPacket(payPriceReply, ThrottleOutPacketType.Task);

1627

}

1628

1629

public void SendStartPingCheck(byte seq)

1630

{

1631

StartPingCheckPacket pc = (StartPingCheckPacket)PacketPool.Instance.GetPacket(PacketType.StartPingCheck);

1632

pc.Header.Reliable = false;

1633

1634

pc.PingID.PingID = seq;

1635

// We *could* get OldestUnacked, but it would hurt performance and not provide any benefit

1636

pc.PingID.OldestUnacked = 0;

1637

1638

OutPacket(pc, ThrottleOutPacketType.Unknown);

1639

}

1640

1641

public void SendKillObject(List<uint> localIDs)

1642

{

1643

//            m_log.DebugFormat("[CLIENT]: Sending KillObjectPacket to {0} for {1} in {2}", Name, localID, regionHandle);

1644

1645

KillObjectPacket kill = (KillObjectPacket)PacketPool.Instance.GetPacket(PacketType.KillObject);

1646

// TODO: don't create new blocks if recycling an old packet

1647

kill.ObjectData = new KillObjectPacket.ObjectDataBlock[localIDs.Count];

1648

for (int i = 0 ; i < localIDs.Count ; i++ )

1649

{

1650

kill.ObjectData[i] = new KillObjectPacket.ObjectDataBlock();

1651

kill.ObjectData[i].ID = localIDs[i];

1652

}

1653

kill.Header.Reliable = true;

1654

kill.Header.Zerocoded = true;

1655

1656

if (localIDs.Count == 1 && m_scene.GetScenePresence(localIDs[0]) != null)

1657

{

1658

OutPacket(kill, ThrottleOutPacketType.Task);

}

else

{

// We MUST lock for both manipulating the kill record and sending the packet, in order to avoid a race

1663

// condition where a kill can be processed before an out-of-date update for the same object.

1664

// ProcessEntityUpdates() also takes the m_killRecord lock.

1665

lock (m_killRecord)

1666

{

1667

foreach (uint localID in localIDs)

1668

m_killRecord.Add(localID);

1669

1670

// The throttle queue used here must match that being used for updates. Otherwise, there is a

1671

// chance that a kill packet put on a separate queue will be sent to the client before an existing

1672

// update packet on another queue. Receiving updates after kills results in unowned and undeletable

1673

// scene objects in a viewer until that viewer is relogged in.

1674

OutPacket(kill, ThrottleOutPacketType.Task);

}

}

}

/// <summary>

/// Send information about the items contained in a folder to the client.

1681

/// </summary>

1682

/// <remarks>

1683

/// XXX This method needs some refactoring loving

1684

/// </remarks>

1685

/// <param name="ownerID">The owner of the folder</param>

1686

/// <param name="folderID">The id of the folder</param>

1687

/// <param name="items">The items contained in the folder identified by folderID</param>

1688

/// <param name="folders"></param>

1689

/// <param name="fetchFolders">Do we need to send folder information?</param>

1690

/// <param name="fetchItems">Do we need to send item information?</param>

1691

public void SendInventoryFolderDetails(UUID ownerID, UUID folderID, List<InventoryItemBase> items,

1692

List<InventoryFolderBase> folders, int version,

1693

bool fetchFolders, bool fetchItems)

1694

{

1695

// An inventory descendents packet consists of a single agent section and an inventory details

1696

// section for each inventory item. The size of each inventory item is approximately 550 bytes.

1697

// In theory, UDP has a maximum packet size of 64k, so it should be possible to send descendent

1698

// packets containing metadata for in excess of 100 items. But in practice, there may be other

1699

// factors (e.g. firewalls) restraining the maximum UDP packet size. See,

1700

//

1701

// http://opensimulator.org/mantis/view.php?id=226

1702

//

1703

// for one example of this kind of thing. In fact, the Linden servers appear to only send about

1704

// 6 to 7 items at a time, so let's stick with 6

1705

int MAX_ITEMS_PER_PACKET = 5;

1706

int MAX_FOLDERS_PER_PACKET = 6;

1707

1708

int totalItems = fetchItems ? items.Count : 0;

1709

int totalFolders = fetchFolders ? folders.Count : 0;

1710

int itemsSent = 0;

1711

int foldersSent = 0;

1712

int foldersToSend = 0;

1713

int itemsToSend = 0;

1714

1715

InventoryDescendentsPacket currentPacket = null;

1716

1717

// Handle empty folders

1718

//

1719

if (totalItems == 0 && totalFolders == 0)

1720

                currentPacket = CreateInventoryDescendentsPacket(ownerID, folderID, version, items.Count + folders.Count, 0, 0);

1721

1722

// To preserve SL compatibility, we will NOT combine folders and items in one packet

1723

//

1724

while (itemsSent < totalItems || foldersSent < totalFolders)

1725

{

1726

if (currentPacket == null) // Start a new packet

1727

{

1728

foldersToSend = totalFolders - foldersSent;

1729

if (foldersToSend > MAX_FOLDERS_PER_PACKET)

1730

foldersToSend = MAX_FOLDERS_PER_PACKET;

1731

1732

if (foldersToSend == 0)

1733

{

1734

itemsToSend = totalItems - itemsSent;

1735

if (itemsToSend > MAX_ITEMS_PER_PACKET)

1736

itemsToSend = MAX_ITEMS_PER_PACKET;

1737

}

1738

1739

                    currentPacket = CreateInventoryDescendentsPacket(ownerID, folderID, version, items.Count + folders.Count, foldersToSend, itemsToSend);

1740

}

1741

1742

if (foldersToSend-- > 0)

1743

                    currentPacket.FolderData[foldersSent % MAX_FOLDERS_PER_PACKET] = CreateFolderDataBlock(folders[foldersSent++]);

1744

else if (itemsToSend-- > 0)

1745

currentPacket.ItemData[itemsSent % MAX_ITEMS_PER_PACKET] = CreateItemDataBlock(items[itemsSent++]);

1746

else

1747

{

1748

// m_log.DebugFormat(

1749

//                        "[LLCLIENTVIEW]: Sending inventory folder details packet to {0} for folder {1}", Name, folderID);

1750

OutPacket(currentPacket, ThrottleOutPacketType.Asset, false);

1751

currentPacket = null;

}

}

if (currentPacket != null)

1756

{

1757

// m_log.DebugFormat(

1758

// "[LLCLIENTVIEW]: Sending inventory folder details packet to {0} for folder {1}", Name, folderID);

1759

OutPacket(currentPacket, ThrottleOutPacketType.Asset, false);

}

}

private InventoryDescendentsPacket.FolderDataBlock CreateFolderDataBlock(InventoryFolderBase folder)

1764

{

1765

InventoryDescendentsPacket.FolderDataBlock newBlock = new InventoryDescendentsPacket.FolderDataBlock();

1766

newBlock.FolderID = folder.ID;

1767

newBlock.Name = Util.StringToBytes256(folder.Name);

1768

newBlock.ParentID = folder.ParentID;

1769

newBlock.Type = (sbyte)folder.Type;

return newBlock;

}

private InventoryDescendentsPacket.ItemDataBlock CreateItemDataBlock(InventoryItemBase item)

1775

{

1776

InventoryDescendentsPacket.ItemDataBlock newBlock = new InventoryDescendentsPacket.ItemDataBlock();

1777

newBlock.ItemID = item.ID;

1778

newBlock.AssetID = item.AssetID;

1779

newBlock.CreatorID = item.CreatorIdAsUuid;

1780

newBlock.BaseMask = item.BasePermissions;

1781

newBlock.Description = Util.StringToBytes256(item.Description);

1782

newBlock.EveryoneMask = item.EveryOnePermissions;

1783

newBlock.OwnerMask = item.CurrentPermissions;

1784

newBlock.FolderID = item.Folder;

1785

newBlock.InvType = (sbyte)item.InvType;

1786

newBlock.Name = Util.StringToBytes256(item.Name);

1787

newBlock.NextOwnerMask = item.NextPermissions;

1788

newBlock.OwnerID = item.Owner;

1789

newBlock.Type = (sbyte)item.AssetType;

1790

1791

newBlock.GroupID = item.GroupID;

1792

newBlock.GroupOwned = item.GroupOwned;

1793

newBlock.GroupMask = item.GroupPermissions;

1794

newBlock.CreationDate = item.CreationDate;

1795

newBlock.SalePrice = item.SalePrice;

1796

newBlock.SaleType = item.SaleType;

1797

newBlock.Flags = item.Flags;

1798

1799

newBlock.CRC =

1800

Helpers.InventoryCRC(newBlock.CreationDate, newBlock.SaleType,

1801

newBlock.InvType, newBlock.Type,

1802

newBlock.AssetID, newBlock.GroupID,

1803

newBlock.SalePrice,

1804

newBlock.OwnerID, newBlock.CreatorID,

1805

newBlock.ItemID, newBlock.FolderID,

1806

newBlock.EveryoneMask,

1807

newBlock.Flags, newBlock.OwnerMask,

1808

newBlock.GroupMask, newBlock.NextOwnerMask);

return newBlock;

}

private void AddNullFolderBlockToDecendentsPacket(ref InventoryDescendentsPacket packet)

1814

{

1815

packet.FolderData = new InventoryDescendentsPacket.FolderDataBlock[1];

1816

packet.FolderData[0] = new InventoryDescendentsPacket.FolderDataBlock();

1817

packet.FolderData[0].FolderID = UUID.Zero;

1818

packet.FolderData[0].ParentID = UUID.Zero;

1819

packet.FolderData[0].Type = -1;

1820

packet.FolderData[0].Name = new byte[0];

1821

}

1822

1823

private void AddNullItemBlockToDescendentsPacket(ref InventoryDescendentsPacket packet)

1824

{

1825

packet.ItemData = new InventoryDescendentsPacket.ItemDataBlock[1];

1826

packet.ItemData[0] = new InventoryDescendentsPacket.ItemDataBlock();

1827

packet.ItemData[0].ItemID = UUID.Zero;

1828

packet.ItemData[0].AssetID = UUID.Zero;

1829

packet.ItemData[0].CreatorID = UUID.Zero;

1830

packet.ItemData[0].BaseMask = 0;

1831

packet.ItemData[0].Description = new byte[0];

1832

packet.ItemData[0].EveryoneMask = 0;

1833

packet.ItemData[0].OwnerMask = 0;

1834

packet.ItemData[0].FolderID = UUID.Zero;

1835

packet.ItemData[0].InvType = (sbyte)0;

1836

packet.ItemData[0].Name = new byte[0];

1837

packet.ItemData[0].NextOwnerMask = 0;

1838

packet.ItemData[0].OwnerID = UUID.Zero;

1839

packet.ItemData[0].Type = -1;

1840

1841

packet.ItemData[0].GroupID = UUID.Zero;

1842

packet.ItemData[0].GroupOwned = false;

1843

packet.ItemData[0].GroupMask = 0;

1844

packet.ItemData[0].CreationDate = 0;

1845

packet.ItemData[0].SalePrice = 0;

1846

packet.ItemData[0].SaleType = 0;

1847

packet.ItemData[0].Flags = 0;

1848

1849

// No need to add CRC

1850

}

1851

1852

        private InventoryDescendentsPacket CreateInventoryDescendentsPacket(UUID ownerID, UUID folderID, int version, int descendents, int folders, int items)

1853

{

1854

            InventoryDescendentsPacket descend = (InventoryDescendentsPacket)PacketPool.Instance.GetPacket(PacketType.InventoryDescendents);

1855

descend.Header.Zerocoded = true;

1856

descend.AgentData.AgentID = AgentId;

1857

descend.AgentData.OwnerID = ownerID;

1858

descend.AgentData.FolderID = folderID;

1859

descend.AgentData.Version = version;

1860

descend.AgentData.Descendents = descendents;

1861

1862

if (folders > 0)

1863

descend.FolderData = new InventoryDescendentsPacket.FolderDataBlock[folders];

1864

else

1865

AddNullFolderBlockToDecendentsPacket(ref descend);

1866

1867

if (items > 0)

1868

descend.ItemData = new InventoryDescendentsPacket.ItemDataBlock[items];

1869

else

1870

AddNullItemBlockToDescendentsPacket(ref descend);

return descend;

}

public void SendInventoryItemDetails(UUID ownerID, InventoryItemBase item)

1876

{

1877

// Fudge this value. It's only needed to make the CRC anyway

1878

const uint FULL_MASK_PERMISSIONS = (uint)0x7fffffff;

1879

1880

            FetchInventoryReplyPacket inventoryReply = (FetchInventoryReplyPacket)PacketPool.Instance.GetPacket(PacketType.FetchInventoryReply);

1881

// TODO: don't create new blocks if recycling an old packet

1882

inventoryReply.AgentData.AgentID = AgentId;

1883

inventoryReply.InventoryData = new FetchInventoryReplyPacket.InventoryDataBlock[1];

1884

inventoryReply.InventoryData[0] = new FetchInventoryReplyPacket.InventoryDataBlock();

1885

inventoryReply.InventoryData[0].ItemID = item.ID;

1886

inventoryReply.InventoryData[0].AssetID = item.AssetID;

1887

inventoryReply.InventoryData[0].CreatorID = item.CreatorIdAsUuid;

1888

inventoryReply.InventoryData[0].BaseMask = item.BasePermissions;

1889

inventoryReply.InventoryData[0].CreationDate = item.CreationDate;

1890

1891

inventoryReply.InventoryData[0].Description = Util.StringToBytes256(item.Description);

1892

inventoryReply.InventoryData[0].EveryoneMask = item.EveryOnePermissions;

1893

inventoryReply.InventoryData[0].FolderID = item.Folder;

1894

inventoryReply.InventoryData[0].InvType = (sbyte)item.InvType;

1895

inventoryReply.InventoryData[0].Name = Util.StringToBytes256(item.Name);

1896

inventoryReply.InventoryData[0].NextOwnerMask = item.NextPermissions;

1897

inventoryReply.InventoryData[0].OwnerID = item.Owner;

1898

inventoryReply.InventoryData[0].OwnerMask = item.CurrentPermissions;

1899

inventoryReply.InventoryData[0].Type = (sbyte)item.AssetType;

1900

1901

inventoryReply.InventoryData[0].GroupID = item.GroupID;

1902

inventoryReply.InventoryData[0].GroupOwned = item.GroupOwned;

1903

inventoryReply.InventoryData[0].GroupMask = item.GroupPermissions;

1904

inventoryReply.InventoryData[0].Flags = item.Flags;

1905

inventoryReply.InventoryData[0].SalePrice = item.SalePrice;

1906

inventoryReply.InventoryData[0].SaleType = item.SaleType;

1907

1908

inventoryReply.InventoryData[0].CRC =

1909

Helpers.InventoryCRC(

1910

1000, 0, inventoryReply.InventoryData[0].InvType,

1911

inventoryReply.InventoryData[0].Type, inventoryReply.InventoryData[0].AssetID,

1912

inventoryReply.InventoryData[0].GroupID, 100,

1913

inventoryReply.InventoryData[0].OwnerID, inventoryReply.InventoryData[0].CreatorID,

1914

inventoryReply.InventoryData[0].ItemID, inventoryReply.InventoryData[0].FolderID,

1915

FULL_MASK_PERMISSIONS, 1, FULL_MASK_PERMISSIONS, FULL_MASK_PERMISSIONS,

1916

FULL_MASK_PERMISSIONS);

1917

inventoryReply.Header.Zerocoded = true;

1918

OutPacket(inventoryReply, ThrottleOutPacketType.Asset);

1919

}

1920

1921

protected void SendBulkUpdateInventoryFolder(InventoryFolderBase folderBase)

1922

{

1923

// We will use the same transaction id for all the separate packets to be sent out in this update.

1924

UUID transactionId = UUID.Random();

1925

1926

List<BulkUpdateInventoryPacket.FolderDataBlock> folderDataBlocks

1927

= new List<BulkUpdateInventoryPacket.FolderDataBlock>();

1928

1929

SendBulkUpdateInventoryFolderRecursive(folderBase, ref folderDataBlocks, transactionId);

1930

1931

if (folderDataBlocks.Count > 0)

1932

{

1933

// We'll end up with some unsent folder blocks if there were some empty folders at the end of the list

1934

// Send these now

1935

BulkUpdateInventoryPacket bulkUpdate

1936

= (BulkUpdateInventoryPacket)PacketPool.Instance.GetPacket(PacketType.BulkUpdateInventory);

1937

bulkUpdate.Header.Zerocoded = true;

1938

1939

bulkUpdate.AgentData.AgentID = AgentId;

1940

bulkUpdate.AgentData.TransactionID = transactionId;

1941

bulkUpdate.FolderData = folderDataBlocks.ToArray();

1942

List<BulkUpdateInventoryPacket.ItemDataBlock> foo = new List<BulkUpdateInventoryPacket.ItemDataBlock>();

1943

bulkUpdate.ItemData = foo.ToArray();

1944

1945

//m_log.Debug("SendBulkUpdateInventory :" + bulkUpdate);

1946

OutPacket(bulkUpdate, ThrottleOutPacketType.Asset);

}

}

/// <summary>

/// Recursively construct bulk update packets to send folders and items

1952

/// </summary>

1953

/// <param name="folder"></param>

1954

/// <param name="folderDataBlocks"></param>

1955

/// <param name="transactionId"></param>

1956

private void SendBulkUpdateInventoryFolderRecursive(

1957

InventoryFolderBase folder, ref List<BulkUpdateInventoryPacket.FolderDataBlock> folderDataBlocks,

1958

UUID transactionId)

1959

{

1960

folderDataBlocks.Add(GenerateBulkUpdateFolderDataBlock(folder));

1961

1962

const int MAX_ITEMS_PER_PACKET = 5;

1963

1964

IInventoryService invService = m_scene.RequestModuleInterface<IInventoryService>();

1965

// If there are any items then we have to start sending them off in this packet - the next folder will have

1966

            // to be in its own bulk update packet.  Also, we can only fit 5 items in a packet (at least this was the limit

1967

// being used on the Linden grid at 20081203).

1968

            InventoryCollection contents = invService.GetFolderContent(AgentId, folder.ID); // folder.RequestListOfItems();

1969

List<InventoryItemBase> items = contents.Items;

1970

while (items.Count > 0)

1971

{

1972

BulkUpdateInventoryPacket bulkUpdate

1973

= (BulkUpdateInventoryPacket)PacketPool.Instance.GetPacket(PacketType.BulkUpdateInventory);

1974

bulkUpdate.Header.Zerocoded = true;

1975

1976

bulkUpdate.AgentData.AgentID = AgentId;

1977

bulkUpdate.AgentData.TransactionID = transactionId;

1978

bulkUpdate.FolderData = folderDataBlocks.ToArray();

1979

1980

int itemsToSend = (items.Count > MAX_ITEMS_PER_PACKET ? MAX_ITEMS_PER_PACKET : items.Count);

1981

bulkUpdate.ItemData = new BulkUpdateInventoryPacket.ItemDataBlock[itemsToSend];

1982

1983

for (int i = 0; i < itemsToSend; i++)

1984

{

1985

// Remove from the end of the list so that we don't incur a performance penalty

1986

bulkUpdate.ItemData[i] = GenerateBulkUpdateItemDataBlock(items[items.Count - 1]);

1987

items.RemoveAt(items.Count - 1);

1988

}

1989

1990

//m_log.Debug("SendBulkUpdateInventoryRecursive :" + bulkUpdate);

1991

OutPacket(bulkUpdate, ThrottleOutPacketType.Asset);

1992

1993

folderDataBlocks = new List<BulkUpdateInventoryPacket.FolderDataBlock>();

1994

1995

                // If we're going to be sending another items packet then it needs to contain just the folder to which those

1996

// items belong.

1997

if (items.Count > 0)

1998

folderDataBlocks.Add(GenerateBulkUpdateFolderDataBlock(folder));

1999

}

2000

2001

List<InventoryFolderBase> subFolders = contents.Folders;

2002

foreach (InventoryFolderBase subFolder in subFolders)

2003

{

2004

SendBulkUpdateInventoryFolderRecursive(subFolder, ref folderDataBlocks, transactionId);

}

}

/// <summary>

/// Generate a bulk update inventory data block for the given folder

2010

/// </summary>

2011

/// <param name="folder"></param>

2012

/// <returns></returns>

2013

private BulkUpdateInventoryPacket.FolderDataBlock GenerateBulkUpdateFolderDataBlock(InventoryFolderBase folder)

2014

{

2015

BulkUpdateInventoryPacket.FolderDataBlock folderBlock = new BulkUpdateInventoryPacket.FolderDataBlock();

2016

2017

folderBlock.FolderID = folder.ID;

2018

folderBlock.ParentID = folder.ParentID;

2019

//folderBlock.Type = -1;

2020

folderBlock.Type = (sbyte)folder.Type;

2021

folderBlock.Name = Util.StringToBytes256(folder.Name);

2022

2023

return folderBlock;

}

/// <summary>

/// Generate a bulk update inventory data block for the given item

2028

/// </summary>

2029

/// <param name="item"></param>

2030

/// <returns></returns>

2031

private BulkUpdateInventoryPacket.ItemDataBlock GenerateBulkUpdateItemDataBlock(InventoryItemBase item)

2032

{

2033

BulkUpdateInventoryPacket.ItemDataBlock itemBlock = new BulkUpdateInventoryPacket.ItemDataBlock();

2034

2035

itemBlock.ItemID = item.ID;

2036

itemBlock.AssetID = item.AssetID;

2037

itemBlock.CreatorID = item.CreatorIdAsUuid;

2038

itemBlock.BaseMask = item.BasePermissions;

2039

itemBlock.Description = Util.StringToBytes256(item.Description);

2040

itemBlock.EveryoneMask = item.EveryOnePermissions;

2041

itemBlock.FolderID = item.Folder;

2042

itemBlock.InvType = (sbyte)item.InvType;

2043

itemBlock.Name = Util.StringToBytes256(item.Name);

2044

itemBlock.NextOwnerMask = item.NextPermissions;

2045

itemBlock.OwnerID = item.Owner;

2046

itemBlock.OwnerMask = item.CurrentPermissions;

2047

itemBlock.Type = (sbyte)item.AssetType;

2048

itemBlock.GroupID = item.GroupID;

2049

itemBlock.GroupOwned = item.GroupOwned;

2050

itemBlock.GroupMask = item.GroupPermissions;

2051

itemBlock.Flags = item.Flags;

2052

itemBlock.SalePrice = item.SalePrice;

2053

itemBlock.SaleType = item.SaleType;

2054

itemBlock.CreationDate = item.CreationDate;

2055

2056

itemBlock.CRC =

2057

Helpers.InventoryCRC(

2058

1000, 0, itemBlock.InvType,

2059

itemBlock.Type, itemBlock.AssetID,

2060

itemBlock.GroupID, 100,

2061

itemBlock.OwnerID, itemBlock.CreatorID,

2062

itemBlock.ItemID, itemBlock.FolderID,

2063

(uint)PermissionMask.All, 1, (uint)PermissionMask.All, (uint)PermissionMask.All,

2064

(uint)PermissionMask.All);

return itemBlock;

}

public void SendBulkUpdateInventory(InventoryNodeBase node)

2070

{

2071

if (node is InventoryItemBase)

2072

SendBulkUpdateInventoryItem((InventoryItemBase)node);

2073

else if (node is InventoryFolderBase)

2074

SendBulkUpdateInventoryFolder((InventoryFolderBase)node);

2075

else if (node != null)

2076

m_log.ErrorFormat("[CLIENT]: {0} sent unknown inventory node named {1}", Name, node.Name);

2077

else

2078

m_log.ErrorFormat("[CLIENT]: {0} sent null inventory node", Name);

2079

}

2080

2081

protected void SendBulkUpdateInventoryItem(InventoryItemBase item)

2082

{

2083

const uint FULL_MASK_PERMISSIONS = (uint)0x7ffffff;

2084

2085

BulkUpdateInventoryPacket bulkUpdate

2086

= (BulkUpdateInventoryPacket)PacketPool.Instance.GetPacket(PacketType.BulkUpdateInventory);

2087

2088

bulkUpdate.AgentData.AgentID = AgentId;

2089

bulkUpdate.AgentData.TransactionID = UUID.Random();

2090

2091

bulkUpdate.FolderData = new BulkUpdateInventoryPacket.FolderDataBlock[1];

2092

bulkUpdate.FolderData[0] = new BulkUpdateInventoryPacket.FolderDataBlock();

2093

bulkUpdate.FolderData[0].FolderID = UUID.Zero;

2094

bulkUpdate.FolderData[0].ParentID = UUID.Zero;

2095

bulkUpdate.FolderData[0].Type = -1;

2096

bulkUpdate.FolderData[0].Name = new byte[0];

2097

2098

bulkUpdate.ItemData = new BulkUpdateInventoryPacket.ItemDataBlock[1];

2099

bulkUpdate.ItemData[0] = new BulkUpdateInventoryPacket.ItemDataBlock();

2100

bulkUpdate.ItemData[0].ItemID = item.ID;

2101

bulkUpdate.ItemData[0].AssetID = item.AssetID;

2102

bulkUpdate.ItemData[0].CreatorID = item.CreatorIdAsUuid;

2103

bulkUpdate.ItemData[0].BaseMask = item.BasePermissions;

2104

bulkUpdate.ItemData[0].CreationDate = item.CreationDate;

2105

bulkUpdate.ItemData[0].Description = Util.StringToBytes256(item.Description);

2106

bulkUpdate.ItemData[0].EveryoneMask = item.EveryOnePermissions;

2107

bulkUpdate.ItemData[0].FolderID = item.Folder;

2108

bulkUpdate.ItemData[0].InvType = (sbyte)item.InvType;

2109

bulkUpdate.ItemData[0].Name = Util.StringToBytes256(item.Name);

2110

bulkUpdate.ItemData[0].NextOwnerMask = item.NextPermissions;

2111

bulkUpdate.ItemData[0].OwnerID = item.Owner;

2112

bulkUpdate.ItemData[0].OwnerMask = item.CurrentPermissions;

2113

bulkUpdate.ItemData[0].Type = (sbyte)item.AssetType;

2114

2115

bulkUpdate.ItemData[0].GroupID = item.GroupID;

2116

bulkUpdate.ItemData[0].GroupOwned = item.GroupOwned;

2117

bulkUpdate.ItemData[0].GroupMask = item.GroupPermissions;

2118

bulkUpdate.ItemData[0].Flags = item.Flags;

2119

bulkUpdate.ItemData[0].SalePrice = item.SalePrice;

2120

bulkUpdate.ItemData[0].SaleType = item.SaleType;

2121

2122

bulkUpdate.ItemData[0].CRC =

2123

Helpers.InventoryCRC(1000, 0, bulkUpdate.ItemData[0].InvType,

2124

bulkUpdate.ItemData[0].Type, bulkUpdate.ItemData[0].AssetID,

2125

bulkUpdate.ItemData[0].GroupID, 100,

2126

bulkUpdate.ItemData[0].OwnerID, bulkUpdate.ItemData[0].CreatorID,

2127

bulkUpdate.ItemData[0].ItemID, bulkUpdate.ItemData[0].FolderID,

2128

FULL_MASK_PERMISSIONS, 1, FULL_MASK_PERMISSIONS, FULL_MASK_PERMISSIONS,

2129

FULL_MASK_PERMISSIONS);

2130

bulkUpdate.Header.Zerocoded = true;

2131

OutPacket(bulkUpdate, ThrottleOutPacketType.Asset);

2132

}

2133

2134

/// <see>IClientAPI.SendInventoryItemCreateUpdate(InventoryItemBase)</see>

2135

public void SendInventoryItemCreateUpdate(InventoryItemBase Item, uint callbackId)

2136

{

2137

const uint FULL_MASK_PERMISSIONS = (uint)0x7fffffff;

2138

2139

UpdateCreateInventoryItemPacket InventoryReply

2140

= (UpdateCreateInventoryItemPacket)PacketPool.Instance.GetPacket(

2141

PacketType.UpdateCreateInventoryItem);

2142

2143

// TODO: don't create new blocks if recycling an old packet

2144

InventoryReply.AgentData.AgentID = AgentId;

2145

InventoryReply.AgentData.SimApproved = true;

2146

InventoryReply.InventoryData = new UpdateCreateInventoryItemPacket.InventoryDataBlock[1];

2147

InventoryReply.InventoryData[0] = new UpdateCreateInventoryItemPacket.InventoryDataBlock();

2148

InventoryReply.InventoryData[0].ItemID = Item.ID;

2149

InventoryReply.InventoryData[0].AssetID = Item.AssetID;

2150

InventoryReply.InventoryData[0].CreatorID = Item.CreatorIdAsUuid;

2151

InventoryReply.InventoryData[0].BaseMask = Item.BasePermissions;

2152

InventoryReply.InventoryData[0].Description = Util.StringToBytes256(Item.Description);

2153

InventoryReply.InventoryData[0].EveryoneMask = Item.EveryOnePermissions;

2154

InventoryReply.InventoryData[0].FolderID = Item.Folder;

2155

InventoryReply.InventoryData[0].InvType = (sbyte)Item.InvType;

2156

InventoryReply.InventoryData[0].Name = Util.StringToBytes256(Item.Name);

2157

InventoryReply.InventoryData[0].NextOwnerMask = Item.NextPermissions;

2158

InventoryReply.InventoryData[0].OwnerID = Item.Owner;

2159

InventoryReply.InventoryData[0].OwnerMask = Item.CurrentPermissions;

2160

InventoryReply.InventoryData[0].Type = (sbyte)Item.AssetType;

2161

InventoryReply.InventoryData[0].CallbackID = callbackId;

2162

2163

InventoryReply.InventoryData[0].GroupID = Item.GroupID;

2164

InventoryReply.InventoryData[0].GroupOwned = Item.GroupOwned;

2165

InventoryReply.InventoryData[0].GroupMask = Item.GroupPermissions;

2166

InventoryReply.InventoryData[0].Flags = Item.Flags;

2167

InventoryReply.InventoryData[0].SalePrice = Item.SalePrice;

2168

InventoryReply.InventoryData[0].SaleType = Item.SaleType;

2169

InventoryReply.InventoryData[0].CreationDate = Item.CreationDate;

2170

2171

InventoryReply.InventoryData[0].CRC =

2172

Helpers.InventoryCRC(1000, 0, InventoryReply.InventoryData[0].InvType,

2173

InventoryReply.InventoryData[0].Type, InventoryReply.InventoryData[0].AssetID,

2174

InventoryReply.InventoryData[0].GroupID, 100,

2175

InventoryReply.InventoryData[0].OwnerID, InventoryReply.InventoryData[0].CreatorID,

2176

InventoryReply.InventoryData[0].ItemID, InventoryReply.InventoryData[0].FolderID,

2177

FULL_MASK_PERMISSIONS, 1, FULL_MASK_PERMISSIONS, FULL_MASK_PERMISSIONS,

2178

FULL_MASK_PERMISSIONS);

2179

InventoryReply.Header.Zerocoded = true;

2180

OutPacket(InventoryReply, ThrottleOutPacketType.Asset);

2181

}

2182

2183

public void SendRemoveInventoryItem(UUID itemID)

2184

{

2185

            RemoveInventoryItemPacket remove = (RemoveInventoryItemPacket)PacketPool.Instance.GetPacket(PacketType.RemoveInventoryItem);

2186

// TODO: don't create new blocks if recycling an old packet

2187

remove.AgentData.AgentID = AgentId;

2188

remove.AgentData.SessionID = m_sessionId;

2189

remove.InventoryData = new RemoveInventoryItemPacket.InventoryDataBlock[1];

2190

remove.InventoryData[0] = new RemoveInventoryItemPacket.InventoryDataBlock();

2191

remove.InventoryData[0].ItemID = itemID;

2192

remove.Header.Zerocoded = true;

2193

OutPacket(remove, ThrottleOutPacketType.Asset);

2194

}

2195

2196

public void SendTakeControls(int controls, bool passToAgent, bool TakeControls)

2197

{

2198

            ScriptControlChangePacket scriptcontrol = (ScriptControlChangePacket)PacketPool.Instance.GetPacket(PacketType.ScriptControlChange);

2199

ScriptControlChangePacket.DataBlock[] data = new ScriptControlChangePacket.DataBlock[1];

2200

ScriptControlChangePacket.DataBlock ddata = new ScriptControlChangePacket.DataBlock();

2201

ddata.Controls = (uint)controls;

2202

ddata.PassToAgent = passToAgent;

2203

ddata.TakeControls = TakeControls;

2204

data[0] = ddata;

2205

scriptcontrol.Data = data;

2206

OutPacket(scriptcontrol, ThrottleOutPacketType.Task);

2207

}

2208

2209

public void SendTaskInventory(UUID taskID, short serial, byte[] fileName)

2210

{

2211

            ReplyTaskInventoryPacket replytask = (ReplyTaskInventoryPacket)PacketPool.Instance.GetPacket(PacketType.ReplyTaskInventory);

2212

replytask.InventoryData.TaskID = taskID;

2213

replytask.InventoryData.Serial = serial;

2214

replytask.InventoryData.Filename = fileName;

2215

OutPacket(replytask, ThrottleOutPacketType.Asset);

2216

}

2217

2218

public void SendXferPacket(ulong xferID, uint packet, byte[] data)

2219

{

2220

            SendXferPacketPacket sendXfer = (SendXferPacketPacket)PacketPool.Instance.GetPacket(PacketType.SendXferPacket);

2221

sendXfer.XferID.ID = xferID;

2222

sendXfer.XferID.Packet = packet;

2223

sendXfer.DataPacket.Data = data;

2224

OutPacket(sendXfer, ThrottleOutPacketType.Asset);

2225

}

2226

2227

public void SendAbortXferPacket(ulong xferID)

2228

{

2229

AbortXferPacket xferItem = (AbortXferPacket)PacketPool.Instance.GetPacket(PacketType.AbortXfer);

2230

xferItem.XferID.ID = xferID;

2231

OutPacket(xferItem, ThrottleOutPacketType.Asset);

2232

}

2233

2234

public void SendEconomyData(float EnergyEfficiency, int ObjectCapacity, int ObjectCount, int PriceEnergyUnit,

2235

                                    int PriceGroupCreate, int PriceObjectClaim, float PriceObjectRent, float PriceObjectScaleFactor,

2236

                                    int PriceParcelClaim, float PriceParcelClaimFactor, int PriceParcelRent, int PricePublicObjectDecay,

2237

                                    int PricePublicObjectDelete, int PriceRentLight, int PriceUpload, int TeleportMinPrice, float TeleportPriceExponent)

2238

{

2239

EconomyDataPacket economyData = (EconomyDataPacket)PacketPool.Instance.GetPacket(PacketType.EconomyData);

2240

economyData.Info.EnergyEfficiency = EnergyEfficiency;

2241

economyData.Info.ObjectCapacity = ObjectCapacity;

2242

economyData.Info.ObjectCount = ObjectCount;

2243

economyData.Info.PriceEnergyUnit = PriceEnergyUnit;

2244

economyData.Info.PriceGroupCreate = PriceGroupCreate;

2245

economyData.Info.PriceObjectClaim = PriceObjectClaim;

2246

economyData.Info.PriceObjectRent = PriceObjectRent;

2247

economyData.Info.PriceObjectScaleFactor = PriceObjectScaleFactor;

2248

economyData.Info.PriceParcelClaim = PriceParcelClaim;

2249

economyData.Info.PriceParcelClaimFactor = PriceParcelClaimFactor;

2250

economyData.Info.PriceParcelRent = PriceParcelRent;

2251

economyData.Info.PricePublicObjectDecay = PricePublicObjectDecay;

2252

economyData.Info.PricePublicObjectDelete = PricePublicObjectDelete;

2253

economyData.Info.PriceRentLight = PriceRentLight;

2254

economyData.Info.PriceUpload = PriceUpload;

2255

economyData.Info.TeleportMinPrice = TeleportMinPrice;

2256

economyData.Info.TeleportPriceExponent = TeleportPriceExponent;

2257

economyData.Header.Reliable = true;

2258

OutPacket(economyData, ThrottleOutPacketType.Task);

2259

}

2260

2261

        public void SendAvatarPickerReply(AvatarPickerReplyAgentDataArgs AgentData, List<AvatarPickerReplyDataArgs> Data)

2262

{

2263

//construct the AvatarPickerReply packet.

2264

AvatarPickerReplyPacket replyPacket = new AvatarPickerReplyPacket();

2265

replyPacket.AgentData.AgentID = AgentData.AgentID;

2266

replyPacket.AgentData.QueryID = AgentData.QueryID;

2267

//int i = 0;

2268

List<AvatarPickerReplyPacket.DataBlock> data_block = new List<AvatarPickerReplyPacket.DataBlock>();

2269

foreach (AvatarPickerReplyDataArgs arg in Data)

2270

{

2271

AvatarPickerReplyPacket.DataBlock db = new AvatarPickerReplyPacket.DataBlock();

2272

db.AvatarID = arg.AvatarID;

2273

db.FirstName = arg.FirstName;

2274

db.LastName = arg.LastName;

2275

data_block.Add(db);

2276

}

2277

replyPacket.Data = data_block.ToArray();

2278

OutPacket(replyPacket, ThrottleOutPacketType.Task);

2279

}

2280

2281

        public void SendAgentDataUpdate(UUID agentid, UUID activegroupid, string firstname, string lastname, ulong grouppowers, string groupname, string grouptitle)

2282

{

2283

m_activeGroupID = activegroupid;

2284

m_activeGroupName = groupname;

2285

m_activeGroupPowers = grouppowers;

2286

2287

            AgentDataUpdatePacket sendAgentDataUpdate = (AgentDataUpdatePacket)PacketPool.Instance.GetPacket(PacketType.AgentDataUpdate);

2288

sendAgentDataUpdate.AgentData.ActiveGroupID = activegroupid;

2289

sendAgentDataUpdate.AgentData.AgentID = agentid;

2290

sendAgentDataUpdate.AgentData.FirstName = Util.StringToBytes256(firstname);

2291

sendAgentDataUpdate.AgentData.GroupName = Util.StringToBytes256(groupname);

2292

sendAgentDataUpdate.AgentData.GroupPowers = grouppowers;

2293

sendAgentDataUpdate.AgentData.GroupTitle = Util.StringToBytes256(grouptitle);

2294

sendAgentDataUpdate.AgentData.LastName = Util.StringToBytes256(lastname);

2295

OutPacket(sendAgentDataUpdate, ThrottleOutPacketType.Task);

}

/// <summary>

/// Send an alert message to the client. On the Linden client (tested 1.19.1.4), this pops up a brief duration

2300

/// blue information box in the bottom right hand corner.

2301

/// </summary>

2302

/// <param name="message"></param>

2303

public void SendAlertMessage(string message)

2304

{

2305

AlertMessagePacket alertPack = (AlertMessagePacket)PacketPool.Instance.GetPacket(PacketType.AlertMessage);

2306

alertPack.AlertData = new AlertMessagePacket.AlertDataBlock();

2307

alertPack.AlertData.Message = Util.StringToBytes256(message);

2308

alertPack.AlertInfo = new AlertMessagePacket.AlertInfoBlock[0];

2309

OutPacket(alertPack, ThrottleOutPacketType.Task);

}

/// <summary>

/// Send an agent alert message to the client.

2314

/// </summary>

2315

/// <param name="message"></param>

2316

/// <param name="modal">On the linden client, if this true then it displays a one button text box placed in the

2317

/// middle of the window. If false, the message is displayed in a brief duration blue information box (as for

2318

/// the AlertMessage packet).</param>

2319

public void SendAgentAlertMessage(string message, bool modal)

2320

{

2321

OutPacket(BuildAgentAlertPacket(message, modal), ThrottleOutPacketType.Task);

}

/// <summary>

/// Construct an agent alert packet

2326

/// </summary>

2327

/// <param name="message"></param>

2328

/// <param name="modal"></param>

2329

/// <returns></returns>

2330

public AgentAlertMessagePacket BuildAgentAlertPacket(string message, bool modal)

2331

{

2332

// Prepend a slash to make the message come up in the top right

2333

// again.

2334

// Allow special formats to be sent from aware modules.

2335

            if (!modal && !message.StartsWith("ALERT: ") && !message.StartsWith("NOTIFY: ") && message != "Home position set." && message != "You died and have been teleported to your home location")

2336

message = "/" + message;

2337

            AgentAlertMessagePacket alertPack = (AgentAlertMessagePacket)PacketPool.Instance.GetPacket(PacketType.AgentAlertMessage);

2338

alertPack.AgentData.AgentID = AgentId;

2339

alertPack.AlertData.Message = Util.StringToBytes256(message);

2340

alertPack.AlertData.Modal = modal;

return alertPack;

}

public void SendLoadURL(string objectname, UUID objectID, UUID ownerID, bool groupOwned, string message,

2346

string url)

2347

{

2348

LoadURLPacket loadURL = (LoadURLPacket)PacketPool.Instance.GetPacket(PacketType.LoadURL);

2349

loadURL.Data.ObjectName = Util.StringToBytes256(objectname);

2350

loadURL.Data.ObjectID = objectID;

2351

loadURL.Data.OwnerID = ownerID;

2352

loadURL.Data.OwnerIsGroup = groupOwned;

2353

loadURL.Data.Message = Util.StringToBytes256(message);

2354

loadURL.Data.URL = Util.StringToBytes256(url);

2355

OutPacket(loadURL, ThrottleOutPacketType.Task);

2356

}

2357

2358

public void SendDialog(

2359

string objectname, UUID objectID, UUID ownerID, string ownerFirstName, string ownerLastName, string msg,

2360

UUID textureID, int ch, string[] buttonlabels)

2361

{

2362

ScriptDialogPacket dialog = (ScriptDialogPacket)PacketPool.Instance.GetPacket(PacketType.ScriptDialog);

2363

dialog.Data.ObjectID = objectID;

2364

dialog.Data.ObjectName = Util.StringToBytes256(objectname);

2365

// this is the username of the *owner*

2366

dialog.Data.FirstName = Util.StringToBytes256(ownerFirstName);

2367

dialog.Data.LastName = Util.StringToBytes256(ownerLastName);

2368

dialog.Data.Message = Util.StringToBytes1024(msg);

2369

dialog.Data.ImageID = textureID;

2370

dialog.Data.ChatChannel = ch;

2371

ScriptDialogPacket.ButtonsBlock[] buttons = new ScriptDialogPacket.ButtonsBlock[buttonlabels.Length];

2372

for (int i = 0; i < buttonlabels.Length; i++)

2373

{

2374

buttons[i] = new ScriptDialogPacket.ButtonsBlock();

2375

buttons[i].ButtonLabel = Util.StringToBytes256(buttonlabels[i]);

2376

}

2377

dialog.Buttons = buttons;

2378

2379

dialog.OwnerData = new ScriptDialogPacket.OwnerDataBlock[1];

2380

dialog.OwnerData[0] = new ScriptDialogPacket.OwnerDataBlock();

2381

dialog.OwnerData[0].OwnerID = ownerID;

2382

2383

OutPacket(dialog, ThrottleOutPacketType.Task);

2384

}

2385

2386

public void SendPreLoadSound(UUID objectID, UUID ownerID, UUID soundID)

2387

{

2388

PreloadSoundPacket preSound = (PreloadSoundPacket)PacketPool.Instance.GetPacket(PacketType.PreloadSound);

2389

// TODO: don't create new blocks if recycling an old packet

2390

preSound.DataBlock = new PreloadSoundPacket.DataBlockBlock[1];

2391

preSound.DataBlock[0] = new PreloadSoundPacket.DataBlockBlock();

2392

preSound.DataBlock[0].ObjectID = objectID;

2393

preSound.DataBlock[0].OwnerID = ownerID;

2394

preSound.DataBlock[0].SoundID = soundID;

2395

preSound.Header.Zerocoded = true;

2396

OutPacket(preSound, ThrottleOutPacketType.Task);

2397

}

2398

2399

public void SendPlayAttachedSound(UUID soundID, UUID objectID, UUID ownerID, float gain, byte flags)

2400

{

2401

AttachedSoundPacket sound = (AttachedSoundPacket)PacketPool.Instance.GetPacket(PacketType.AttachedSound);

2402

sound.DataBlock.SoundID = soundID;

2403

sound.DataBlock.ObjectID = objectID;

2404

sound.DataBlock.OwnerID = ownerID;

2405

sound.DataBlock.Gain = gain;

2406

sound.DataBlock.Flags = flags;

2407

2408

OutPacket(sound, ThrottleOutPacketType.Task);

2409

}

2410

2411

        public void SendTriggeredSound(UUID soundID, UUID ownerID, UUID objectID, UUID parentID, ulong handle, Vector3 position, float gain)

2412

{

2413

SoundTriggerPacket sound = (SoundTriggerPacket)PacketPool.Instance.GetPacket(PacketType.SoundTrigger);

2414

sound.SoundData.SoundID = soundID;

2415

sound.SoundData.OwnerID = ownerID;

2416

sound.SoundData.ObjectID = objectID;

2417

sound.SoundData.ParentID = parentID;

2418

sound.SoundData.Handle = handle;

2419

sound.SoundData.Position = position;

2420

sound.SoundData.Gain = gain;

2421

2422

OutPacket(sound, ThrottleOutPacketType.Task);

2423

}

2424

2425

public void SendAttachedSoundGainChange(UUID objectID, float gain)

2426

{

2427

            AttachedSoundGainChangePacket sound = (AttachedSoundGainChangePacket)PacketPool.Instance.GetPacket(PacketType.AttachedSoundGainChange);

2428

sound.DataBlock.ObjectID = objectID;

2429

sound.DataBlock.Gain = gain;

2430

2431

OutPacket(sound, ThrottleOutPacketType.Task);

2432

}

2433

2434

        public void SendSunPos(Vector3 Position, Vector3 Velocity, ulong CurrentTime, uint SecondsPerSunCycle, uint SecondsPerYear, float OrbitalPosition)

2435

{

2436

// Viewers based on the Linden viwer code, do wacky things for oribital positions from Midnight to Sunrise

2437

// So adjust for that

2438

// Contributed by: Godfrey

2439

2440

if (OrbitalPosition > m_sunPainDaHalfOrbitalCutoff) // things get weird from midnight to sunrise

2441

{

2442

                OrbitalPosition = (OrbitalPosition - m_sunPainDaHalfOrbitalCutoff) * 0.6666666667f + m_sunPainDaHalfOrbitalCutoff;

2443

}

2444

2445

            SimulatorViewerTimeMessagePacket viewertime = (SimulatorViewerTimeMessagePacket)PacketPool.Instance.GetPacket(PacketType.SimulatorViewerTimeMessage);

2446

viewertime.TimeInfo.SunDirection = Position;

2447

viewertime.TimeInfo.SunAngVelocity = Velocity;

2448

2449

// Sun module used to add 6 hours to adjust for linden sun hour, adding here

2450

// to prevent existing code from breaking if it assumed that 6 hours were included.

2451

// 21600 == 6 hours * 60 minutes * 60 Seconds

2452

viewertime.TimeInfo.UsecSinceStart = CurrentTime + 21600;

2453

2454

viewertime.TimeInfo.SecPerDay = SecondsPerSunCycle;

2455

viewertime.TimeInfo.SecPerYear = SecondsPerYear;

2456

viewertime.TimeInfo.SunPhase = OrbitalPosition;

2457

viewertime.Header.Reliable = false;

2458

viewertime.Header.Zerocoded = true;

2459

OutPacket(viewertime, ThrottleOutPacketType.Task);

2460

}

2461

2462

// Currently Deprecated

2463

public void SendViewerTime(int phase)

2464

{

2465

/*

2466

Console.WriteLine("SunPhase: {0}", phase);

2467

            SimulatorViewerTimeMessagePacket viewertime = (SimulatorViewerTimeMessagePacket)PacketPool.Instance.GetPacket(PacketType.SimulatorViewerTimeMessage);

2468

//viewertime.TimeInfo.SecPerDay = 86400;

2469

//viewertime.TimeInfo.SecPerYear = 31536000;

2470

viewertime.TimeInfo.SecPerDay = 1000;

2471

viewertime.TimeInfo.SecPerYear = 365000;

2472

viewertime.TimeInfo.SunPhase = 1;

2473

int sunPhase = (phase + 2) / 2;

2474

if ((sunPhase < 6) || (sunPhase > 36))

2475

{

2476

viewertime.TimeInfo.SunDirection = new Vector3(0f, 0.8f, -0.8f);

2477

Console.WriteLine("sending night");

}

else

{

if (sunPhase < 12)

{

sunPhase = 12;

}

sunPhase = sunPhase - 12;

2486

2487

float yValue = 0.1f * (sunPhase);

2488

Console.WriteLine("Computed SunPhase: {0}, yValue: {1}", sunPhase, yValue);

2489

if (yValue > 1.2f)

2490

{

2491

yValue = yValue - 1.2f;

2492

}

2493

2494

yValue = Util.Clip(yValue, 0, 1);

if (sunPhase < 14)

{

yValue = 1 - yValue;

}

if (sunPhase < 12)

{

yValue *= -1;

}

viewertime.TimeInfo.SunDirection = new Vector3(0f, yValue, 0.3f);

2505

Console.WriteLine("sending sun update " + yValue);

2506

}

2507

viewertime.TimeInfo.SunAngVelocity = new Vector3(0, 0.0f, 10.0f);

2508

viewertime.TimeInfo.UsecSinceStart = (ulong)Util.UnixTimeSinceEpoch();

2509

viewertime.Header.Reliable = false;

2510

OutPacket(viewertime, ThrottleOutPacketType.Task);

*/

}

public void SendViewerEffect(ViewerEffectPacket.EffectBlock[] effectBlocks)

2515

{

2516

ViewerEffectPacket packet = (ViewerEffectPacket)PacketPool.Instance.GetPacket(PacketType.ViewerEffect);

2517

packet.Header.Reliable = false;

2518

packet.Header.Zerocoded = true;

2519

2520

packet.AgentData.AgentID = AgentId;

2521

packet.AgentData.SessionID = SessionId;

2522

2523

packet.Effect = effectBlocks;

2524

2525

// OutPacket(packet, ThrottleOutPacketType.State);

2526

OutPacket(packet, ThrottleOutPacketType.Task);

2527

}

2528

2529

public void SendAvatarProperties(UUID avatarID, string aboutText, string bornOn, Byte[] charterMember,

2530

string flAbout, uint flags, UUID flImageID, UUID imageID, string profileURL,

2531

UUID partnerID)

2532

{

2533

            AvatarPropertiesReplyPacket avatarReply = (AvatarPropertiesReplyPacket)PacketPool.Instance.GetPacket(PacketType.AvatarPropertiesReply);

2534

avatarReply.AgentData.AgentID = AgentId;

2535

avatarReply.AgentData.AvatarID = avatarID;

2536

if (aboutText != null)

2537

avatarReply.PropertiesData.AboutText = Util.StringToBytes1024(aboutText);

2538

else

2539

avatarReply.PropertiesData.AboutText = Utils.EmptyBytes;

2540

avatarReply.PropertiesData.BornOn = Util.StringToBytes256(bornOn);

2541

avatarReply.PropertiesData.CharterMember = charterMember;

2542

if (flAbout != null)

2543

avatarReply.PropertiesData.FLAboutText = Util.StringToBytes256(flAbout);

2544

else

2545

avatarReply.PropertiesData.FLAboutText = Utils.EmptyBytes;

2546

avatarReply.PropertiesData.Flags = flags;

2547

avatarReply.PropertiesData.FLImageID = flImageID;

2548

avatarReply.PropertiesData.ImageID = imageID;

2549

avatarReply.PropertiesData.ProfileURL = Util.StringToBytes256(profileURL);

2550

avatarReply.PropertiesData.PartnerID = partnerID;

2551

OutPacket(avatarReply, ThrottleOutPacketType.Task);

}

/// <summary>

/// Send the client an Estate message blue box pop-down with a single OK button

2556

/// </summary>

2557

/// <param name="FromAvatarID"></param>

2558

/// <param name="fromSessionID"></param>

2559

/// <param name="FromAvatarName"></param>

2560

/// <param name="Message"></param>

2561

public void SendBlueBoxMessage(UUID FromAvatarID, String FromAvatarName, String Message)

2562

{

2563

if (!SceneAgent.IsChildAgent)

2564

                SendInstantMessage(new GridInstantMessage(null, FromAvatarID, FromAvatarName, AgentId, 1, Message, false, new Vector3()));

2565

2566

            //SendInstantMessage(FromAvatarID, fromSessionID, Message, AgentId, SessionId, FromAvatarName, (byte)21,(uint) Util.UnixTimeSinceEpoch());

2567

}

2568

2569

public void SendLogoutPacket()

2570

{

2571

// I know this is a bit of a hack, however there are times when you don't

2572

// want to send this, but still need to do the rest of the shutdown process

2573

// this method gets called from the packet server.. which makes it practically

2574

// impossible to do any other way.

2575

2576

if (m_SendLogoutPacketWhenClosing)

2577

{

2578

LogoutReplyPacket logReply = (LogoutReplyPacket)PacketPool.Instance.GetPacket(PacketType.LogoutReply);

2579

// TODO: don't create new blocks if recycling an old packet

2580

logReply.AgentData.AgentID = AgentId;

2581

logReply.AgentData.SessionID = SessionId;

2582

logReply.InventoryData = new LogoutReplyPacket.InventoryDataBlock[1];

2583

logReply.InventoryData[0] = new LogoutReplyPacket.InventoryDataBlock();

2584

logReply.InventoryData[0].ItemID = UUID.Zero;

2585

2586

OutPacket(logReply, ThrottleOutPacketType.Task);

}

}

public void SendHealth(float health)

2591

{

2592

            HealthMessagePacket healthpacket = (HealthMessagePacket)PacketPool.Instance.GetPacket(PacketType.HealthMessage);

2593

healthpacket.HealthData.Health = health;

2594

OutPacket(healthpacket, ThrottleOutPacketType.Task);

2595

}

2596

2597

public void SendAgentOnline(UUID[] agentIDs)

2598

{

2599

OnlineNotificationPacket onp = new OnlineNotificationPacket();

2600

            OnlineNotificationPacket.AgentBlockBlock[] onpb = new OnlineNotificationPacket.AgentBlockBlock[agentIDs.Length];

2601

for (int i = 0; i < agentIDs.Length; i++)

2602

{

2603

OnlineNotificationPacket.AgentBlockBlock onpbl = new OnlineNotificationPacket.AgentBlockBlock();

2604

onpbl.AgentID = agentIDs[i];

2605

onpb[i] = onpbl;

2606

}

2607

onp.AgentBlock = onpb;

2608

onp.Header.Reliable = true;

2609

OutPacket(onp, ThrottleOutPacketType.Task);

2610

}

2611

2612

public void SendAgentOffline(UUID[] agentIDs)

2613

{

2614

OfflineNotificationPacket offp = new OfflineNotificationPacket();

2615

            OfflineNotificationPacket.AgentBlockBlock[] offpb = new OfflineNotificationPacket.AgentBlockBlock[agentIDs.Length];

2616

for (int i = 0; i < agentIDs.Length; i++)

2617

{

2618

OfflineNotificationPacket.AgentBlockBlock onpbl = new OfflineNotificationPacket.AgentBlockBlock();

2619

onpbl.AgentID = agentIDs[i];

2620

offpb[i] = onpbl;

2621

}

2622

offp.AgentBlock = offpb;

2623

offp.Header.Reliable = true;

2624

OutPacket(offp, ThrottleOutPacketType.Task);

2625

}

2626

2627

public void SendSitResponse(UUID TargetID, Vector3 OffsetPos, Quaternion SitOrientation, bool autopilot,

2628

Vector3 CameraAtOffset, Vector3 CameraEyeOffset, bool ForceMouseLook)

2629

{

2630

AvatarSitResponsePacket avatarSitResponse = new AvatarSitResponsePacket();

2631

avatarSitResponse.SitObject.ID = TargetID;

2632

if (CameraAtOffset != Vector3.Zero)

2633

{

2634

avatarSitResponse.SitTransform.CameraAtOffset = CameraAtOffset;

2635

avatarSitResponse.SitTransform.CameraEyeOffset = CameraEyeOffset;

2636

}

2637

avatarSitResponse.SitTransform.ForceMouselook = ForceMouseLook;

2638

avatarSitResponse.SitTransform.AutoPilot = autopilot;

2639

avatarSitResponse.SitTransform.SitPosition = OffsetPos;

2640

avatarSitResponse.SitTransform.SitRotation = SitOrientation;

2641

2642

OutPacket(avatarSitResponse, ThrottleOutPacketType.Task);

2643

}

2644

2645

public void SendAdminResponse(UUID Token, uint AdminLevel)

2646

{

2647

GrantGodlikePowersPacket respondPacket = new GrantGodlikePowersPacket();

2648

GrantGodlikePowersPacket.GrantDataBlock gdb = new GrantGodlikePowersPacket.GrantDataBlock();

2649

GrantGodlikePowersPacket.AgentDataBlock adb = new GrantGodlikePowersPacket.AgentDataBlock();

2650

2651

adb.AgentID = AgentId;

2652

adb.SessionID = SessionId; // More security

2653

gdb.GodLevel = (byte)AdminLevel;

2654

gdb.Token = Token;

2655

//respondPacket.AgentData = (GrantGodlikePowersPacket.AgentDataBlock)ablock;

2656

respondPacket.GrantData = gdb;

2657

respondPacket.AgentData = adb;

2658

OutPacket(respondPacket, ThrottleOutPacketType.Task);

2659

}

2660

2661

public void SendGroupMembership(GroupMembershipData[] GroupMembership)

2662

{

2663

m_groupPowers.Clear();

2664

2665

AgentGroupDataUpdatePacket Groupupdate = new AgentGroupDataUpdatePacket();

2666

            AgentGroupDataUpdatePacket.GroupDataBlock[] Groups = new AgentGroupDataUpdatePacket.GroupDataBlock[GroupMembership.Length];

2667

for (int i = 0; i < GroupMembership.Length; i++)

2668

{

2669

m_groupPowers[GroupMembership[i].GroupID] = GroupMembership[i].GroupPowers;

2670

2671

AgentGroupDataUpdatePacket.GroupDataBlock Group = new AgentGroupDataUpdatePacket.GroupDataBlock();

2672

Group.AcceptNotices = GroupMembership[i].AcceptNotices;

2673

Group.Contribution = GroupMembership[i].Contribution;

2674

Group.GroupID = GroupMembership[i].GroupID;

2675

Group.GroupInsigniaID = GroupMembership[i].GroupPicture;

2676

Group.GroupName = Util.StringToBytes256(GroupMembership[i].GroupName);

2677

Group.GroupPowers = GroupMembership[i].GroupPowers;

Groups[i] = Group;

}

Groupupdate.GroupData = Groups;

2683

Groupupdate.AgentData = new AgentGroupDataUpdatePacket.AgentDataBlock();

2684

Groupupdate.AgentData.AgentID = AgentId;

2685

OutPacket(Groupupdate, ThrottleOutPacketType.Task);

try

{

IEventQueue eq = Scene.RequestModuleInterface<IEventQueue>();

2690

if (eq != null)

2691

{

2692

eq.GroupMembership(Groupupdate, this.AgentId);

2693

}

2694

}

2695

catch (Exception ex)

2696

{

2697

m_log.Error("Unable to send group membership data via eventqueue - exception: " + ex.ToString());

2698

m_log.Warn("sending group membership data via UDP");

2699

OutPacket(Groupupdate, ThrottleOutPacketType.Task);

}

}

public void SendPartPhysicsProprieties(ISceneEntity entity)

2704

{

2705

SceneObjectPart part = (SceneObjectPart)entity;

2706

if (part != null && AgentId != UUID.Zero)

{

try

{

IEventQueue eq = Scene.RequestModuleInterface<IEventQueue>();

2711

if (eq != null)

2712

{

2713

uint localid = part.LocalId;

2714

byte physshapetype = part.PhysicsShapeType;

2715

float density = part.Density;

2716

float friction = part.Friction;

2717

float bounce = part.Restitution;

2718

float gravmod = part.GravityModifier;

2719

eq.partPhysicsProperties(localid, physshapetype, density, friction, bounce, gravmod,AgentId);

2720

}

2721

}

2722

catch (Exception ex)

2723

{

2724

m_log.Error("Unable to send part Physics Proprieties - exception: " + ex.ToString());

2725

}

2726

part.UpdatePhysRequired = false;

}

}

public void SendGroupNameReply(UUID groupLLUID, string GroupName)

2733

{

2734

UUIDGroupNameReplyPacket pack = new UUIDGroupNameReplyPacket();

2735

            UUIDGroupNameReplyPacket.UUIDNameBlockBlock[] uidnameblock = new UUIDGroupNameReplyPacket.UUIDNameBlockBlock[1];

2736

UUIDGroupNameReplyPacket.UUIDNameBlockBlock uidnamebloc = new UUIDGroupNameReplyPacket.UUIDNameBlockBlock();

2737

uidnamebloc.ID = groupLLUID;

2738

uidnamebloc.GroupName = Util.StringToBytes256(GroupName);

2739

uidnameblock[0] = uidnamebloc;

2740

pack.UUIDNameBlock = uidnameblock;

2741

OutPacket(pack, ThrottleOutPacketType.Task);

2742

}

2743

2744

public void SendLandStatReply(uint reportType, uint requestFlags, uint resultCount, LandStatReportItem[] lsrpia)

2745

{

2746

LandStatReplyPacket lsrp = new LandStatReplyPacket();

2747

// LandStatReplyPacket.RequestDataBlock lsreqdpb = new LandStatReplyPacket.RequestDataBlock();

2748

LandStatReplyPacket.ReportDataBlock[] lsrepdba = new LandStatReplyPacket.ReportDataBlock[lsrpia.Length];

2749

//LandStatReplyPacket.ReportDataBlock lsrepdb = new LandStatReplyPacket.ReportDataBlock();

2750

// lsrepdb.

2751

lsrp.RequestData.ReportType = reportType;

2752

lsrp.RequestData.RequestFlags = requestFlags;

2753

lsrp.RequestData.TotalObjectCount = resultCount;

2754

for (int i = 0; i < lsrpia.Length; i++)

2755

{

2756

LandStatReplyPacket.ReportDataBlock lsrepdb = new LandStatReplyPacket.ReportDataBlock();

2757

lsrepdb.LocationX = lsrpia[i].LocationX;

2758

lsrepdb.LocationY = lsrpia[i].LocationY;

2759

lsrepdb.LocationZ = lsrpia[i].LocationZ;

2760

lsrepdb.Score = lsrpia[i].Score;

2761

lsrepdb.TaskID = lsrpia[i].TaskID;

2762

lsrepdb.TaskLocalID = lsrpia[i].TaskLocalID;

2763

lsrepdb.TaskName = Util.StringToBytes256(lsrpia[i].TaskName);

2764

lsrepdb.OwnerName = Util.StringToBytes256(lsrpia[i].OwnerName);

2765

lsrepdba[i] = lsrepdb;

2766

}

2767

lsrp.ReportData = lsrepdba;

2768

OutPacket(lsrp, ThrottleOutPacketType.Task);

2769

}

2770

2771

public void SendScriptRunningReply(UUID objectID, UUID itemID, bool running)

2772

{

2773

ScriptRunningReplyPacket scriptRunningReply = new ScriptRunningReplyPacket();

2774

scriptRunningReply.Script.ObjectID = objectID;

2775

scriptRunningReply.Script.ItemID = itemID;

2776

scriptRunningReply.Script.Running = running;

2777

2778

OutPacket(scriptRunningReply, ThrottleOutPacketType.Task);

2779

}

2780

2781

public void SendAsset(AssetRequestToClient req)

2782

{

2783

if (req.AssetInf.Data == null)

2784

{

2785

m_log.ErrorFormat("Cannot send asset {0} ({1}), asset data is null",

2786

req.AssetInf.ID, req.AssetInf.Metadata.ContentType);

return;

}

//m_log.Debug("sending asset " + req.RequestAssetID);

2791

TransferInfoPacket Transfer = new TransferInfoPacket();

2792

Transfer.TransferInfo.ChannelType = 2;

2793

Transfer.TransferInfo.Status = 0;

2794

Transfer.TransferInfo.TargetType = 0;

2795

if (req.AssetRequestSource == 2)

2796

{

2797

Transfer.TransferInfo.Params = new byte[20];

2798

Array.Copy(req.RequestAssetID.GetBytes(), 0, Transfer.TransferInfo.Params, 0, 16);

2799

int assType = req.AssetInf.Type;

2800

Array.Copy(Utils.IntToBytes(assType), 0, Transfer.TransferInfo.Params, 16, 4);

2801

}

2802

else if (req.AssetRequestSource == 3)

2803

{

2804

Transfer.TransferInfo.Params = req.Params;

2805

// Transfer.TransferInfo.Params = new byte[100];

2806

//Array.Copy(req.RequestUser.AgentId.GetBytes(), 0, Transfer.TransferInfo.Params, 0, 16);

2807

//Array.Copy(req.RequestUser.SessionId.GetBytes(), 0, Transfer.TransferInfo.Params, 16, 16);

2808

}

2809

Transfer.TransferInfo.Size = req.AssetInf.Data.Length;

2810

Transfer.TransferInfo.TransferID = req.TransferRequestID;

2811

Transfer.Header.Zerocoded = true;

2812

OutPacket(Transfer, ThrottleOutPacketType.Asset);

2813

2814

if (req.NumPackets == 1)

2815

{

2816

TransferPacketPacket TransferPacket = new TransferPacketPacket();

2817

TransferPacket.TransferData.Packet = 0;

2818

TransferPacket.TransferData.ChannelType = 2;

2819

TransferPacket.TransferData.TransferID = req.TransferRequestID;

2820

TransferPacket.TransferData.Data = req.AssetInf.Data;

2821

TransferPacket.TransferData.Status = 1;

2822

TransferPacket.Header.Zerocoded = true;

2823

OutPacket(TransferPacket, ThrottleOutPacketType.Asset);

}

else

{

int processedLength = 0;

2828

int maxChunkSize = Settings.MAX_PACKET_SIZE - 100;

2829

int packetNumber = 0;

2830

2831

while (processedLength < req.AssetInf.Data.Length)

2832

{

2833

TransferPacketPacket TransferPacket = new TransferPacketPacket();

2834

TransferPacket.TransferData.Packet = packetNumber;

2835

TransferPacket.TransferData.ChannelType = 2;

2836

TransferPacket.TransferData.TransferID = req.TransferRequestID;

2837

2838

int chunkSize = Math.Min(req.AssetInf.Data.Length - processedLength, maxChunkSize);

2839

byte[] chunk = new byte[chunkSize];

2840

Array.Copy(req.AssetInf.Data, processedLength, chunk, 0, chunk.Length);

2841

2842

TransferPacket.TransferData.Data = chunk;

2843

2844

// 0 indicates more packets to come, 1 indicates last packet

2845

if (req.AssetInf.Data.Length - processedLength > maxChunkSize)

2846

{

2847

TransferPacket.TransferData.Status = 0;

}

else

{

TransferPacket.TransferData.Status = 1;

2852

}

2853

TransferPacket.Header.Zerocoded = true;

2854

OutPacket(TransferPacket, ThrottleOutPacketType.Asset);

2855

2856

processedLength += chunkSize;

packetNumber++;

}

}

}

public void SendAssetNotFound(AssetRequestToClient req)

2863

{

2864

TransferInfoPacket Transfer = new TransferInfoPacket();

2865

Transfer.TransferInfo.ChannelType = 2;

2866

Transfer.TransferInfo.Status = -2;

2867

Transfer.TransferInfo.TargetType = 0;

2868

Transfer.TransferInfo.Params = req.Params;

2869

Transfer.TransferInfo.Size = 0;

2870

Transfer.TransferInfo.TransferID = req.TransferRequestID;

2871

Transfer.Header.Zerocoded = true;

2872

OutPacket(Transfer, ThrottleOutPacketType.Asset);

2873

}

2874

2875

public void SendTexture(AssetBase TextureAsset)

{

}

public void SendRegionHandle(UUID regionID, ulong handle)

2881

{

2882

            RegionIDAndHandleReplyPacket reply = (RegionIDAndHandleReplyPacket)PacketPool.Instance.GetPacket(PacketType.RegionIDAndHandleReply);

2883

reply.ReplyBlock.RegionID = regionID;

2884

reply.ReplyBlock.RegionHandle = handle;

2885

OutPacket(reply, ThrottleOutPacketType.Land);

2886

}

2887

2888

public void SendParcelInfo(RegionInfo info, LandData land, UUID parcelID, uint x, uint y)

2889

{

2890

float dwell = 0.0f;

2891

IDwellModule dwellModule = m_scene.RequestModuleInterface<IDwellModule>();

2892

if (dwellModule != null)

2893

dwell = dwellModule.GetDwell(land.GlobalID);

2894

            ParcelInfoReplyPacket reply = (ParcelInfoReplyPacket)PacketPool.Instance.GetPacket(PacketType.ParcelInfoReply);

2895

reply.AgentData.AgentID = m_agentId;

2896

reply.Data.ParcelID = parcelID;

2897

reply.Data.OwnerID = land.OwnerID;

2898

reply.Data.Name = Utils.StringToBytes(land.Name);

2899

reply.Data.Desc = Utils.StringToBytes(land.Description);

2900

reply.Data.ActualArea = land.Area;

2901

reply.Data.BillableArea = land.Area; // TODO: what is this?

2902

2903

// Bit 0: Mature, bit 7: on sale, other bits: no idea

2904

reply.Data.Flags = (byte)(

2905

(info.AccessLevel > 13 ? (1 << 0) : 0) +

2906

((land.Flags & (uint)ParcelFlags.ForSale) != 0 ? (1 << 7) : 0));

2907

2908

Vector3 pos = land.UserLocation;

2909

if (pos.Equals(Vector3.Zero))

2910

{

2911

pos = (land.AABBMax + land.AABBMin) * 0.5f;

2912

}

2913

reply.Data.GlobalX = info.RegionLocX + x;

2914

reply.Data.GlobalY = info.RegionLocY + y;

2915

reply.Data.GlobalZ = pos.Z;

2916

reply.Data.SimName = Utils.StringToBytes(info.RegionName);

2917

reply.Data.SnapshotID = land.SnapshotID;

2918

reply.Data.Dwell = dwell;

2919

reply.Data.SalePrice = land.SalePrice;

2920

reply.Data.AuctionID = (int)land.AuctionID;

2921

2922

OutPacket(reply, ThrottleOutPacketType.Land);

2923

}

2924

2925

public void SendScriptTeleportRequest(string objName, string simName, Vector3 pos, Vector3 lookAt)

2926

{

2927

            ScriptTeleportRequestPacket packet = (ScriptTeleportRequestPacket)PacketPool.Instance.GetPacket(PacketType.ScriptTeleportRequest);

2928

2929

packet.Data.ObjectName = Utils.StringToBytes(objName);

2930

packet.Data.SimName = Utils.StringToBytes(simName);

2931

packet.Data.SimPosition = pos;

2932

packet.Data.LookAt = lookAt;

2933

2934

OutPacket(packet, ThrottleOutPacketType.Task);

2935

}

2936

2937

public void SendDirPlacesReply(UUID queryID, DirPlacesReplyData[] data)

2938

{

2939

            DirPlacesReplyPacket packet = (DirPlacesReplyPacket)PacketPool.Instance.GetPacket(PacketType.DirPlacesReply);

2940

2941

packet.AgentData = new DirPlacesReplyPacket.AgentDataBlock();

2942

2943

packet.QueryData = new DirPlacesReplyPacket.QueryDataBlock[1];

2944

packet.QueryData[0] = new DirPlacesReplyPacket.QueryDataBlock();

2945

2946

packet.AgentData.AgentID = AgentId;

2947

2948

packet.QueryData[0].QueryID = queryID;

2949

2950

DirPlacesReplyPacket.QueryRepliesBlock[] replies =

2951

new DirPlacesReplyPacket.QueryRepliesBlock[0];

2952

DirPlacesReplyPacket.StatusDataBlock[] status =

2953

new DirPlacesReplyPacket.StatusDataBlock[0];

2954

2955

packet.QueryReplies = replies;

2956

packet.StatusData = status;

2957

2958

foreach (DirPlacesReplyData d in data)

2959

{

2960

int idx = replies.Length;

2961

Array.Resize(ref replies, idx + 1);

2962

Array.Resize(ref status, idx + 1);

2963

2964

replies[idx] = new DirPlacesReplyPacket.QueryRepliesBlock();

2965

status[idx] = new DirPlacesReplyPacket.StatusDataBlock();

2966

replies[idx].ParcelID = d.parcelID;

2967

replies[idx].Name = Utils.StringToBytes(d.name);

2968

replies[idx].ForSale = d.forSale;

2969

replies[idx].Auction = d.auction;

2970

replies[idx].Dwell = d.dwell;

2971

status[idx].Status = d.Status;

2972

2973

packet.QueryReplies = replies;

2974

packet.StatusData = status;

2975

2976

if (packet.Length >= 1000)

2977

{

2978

OutPacket(packet, ThrottleOutPacketType.Task);

2979

2980

packet = (DirPlacesReplyPacket)PacketPool.Instance.GetPacket(PacketType.DirPlacesReply);

2981

2982

packet.AgentData = new DirPlacesReplyPacket.AgentDataBlock();

2983

2984

packet.QueryData = new DirPlacesReplyPacket.QueryDataBlock[1];

2985

packet.QueryData[0] = new DirPlacesReplyPacket.QueryDataBlock();

2986

2987

packet.AgentData.AgentID = AgentId;

2988

2989

packet.QueryData[0].QueryID = queryID;

2990

2991

replies = new DirPlacesReplyPacket.QueryRepliesBlock[0];

2992

status = new DirPlacesReplyPacket.StatusDataBlock[0];

}

}

if (replies.Length > 0 || data.Length == 0)

2997

OutPacket(packet, ThrottleOutPacketType.Task);

2998

}

2999

3000

public void SendDirPeopleReply(UUID queryID, DirPeopleReplyData[] data)

3001

{

3002

            DirPeopleReplyPacket packet = (DirPeopleReplyPacket)PacketPool.Instance.GetPacket(PacketType.DirPeopleReply);

3003

3004

packet.AgentData = new DirPeopleReplyPacket.AgentDataBlock();

3005

packet.AgentData.AgentID = AgentId;

3006

3007

packet.QueryData = new DirPeopleReplyPacket.QueryDataBlock();

3008

packet.QueryData.QueryID = queryID;

3009

3010

packet.QueryReplies = new DirPeopleReplyPacket.QueryRepliesBlock[

data.Length];

int i = 0;

foreach (DirPeopleReplyData d in data)

3015

{

3016

packet.QueryReplies[i] = new DirPeopleReplyPacket.QueryRepliesBlock();

3017

packet.QueryReplies[i].AgentID = d.agentID;

3018

packet.QueryReplies[i].FirstName =

3019

Utils.StringToBytes(d.firstName);

3020

packet.QueryReplies[i].LastName =

3021

Utils.StringToBytes(d.lastName);

3022

packet.QueryReplies[i].Group =

3023

Utils.StringToBytes(d.group);

3024

packet.QueryReplies[i].Online = d.online;

3025

packet.QueryReplies[i].Reputation = d.reputation;

i++;

}

OutPacket(packet, ThrottleOutPacketType.Task);

3030

}

3031

3032

public void SendDirEventsReply(UUID queryID, DirEventsReplyData[] data)

3033

{

3034

            DirEventsReplyPacket packet = (DirEventsReplyPacket)PacketPool.Instance.GetPacket(PacketType.DirEventsReply);

3035

3036

packet.AgentData = new DirEventsReplyPacket.AgentDataBlock();

3037

packet.AgentData.AgentID = AgentId;

3038

3039

packet.QueryData = new DirEventsReplyPacket.QueryDataBlock();

3040

packet.QueryData.QueryID = queryID;

3041

3042

packet.QueryReplies = new DirEventsReplyPacket.QueryRepliesBlock[

3043

data.Length];

3044

3045

packet.StatusData = new DirEventsReplyPacket.StatusDataBlock[

data.Length];

int i = 0;

foreach (DirEventsReplyData d in data)

3050

{

3051

packet.QueryReplies[i] = new DirEventsReplyPacket.QueryRepliesBlock();

3052

packet.StatusData[i] = new DirEventsReplyPacket.StatusDataBlock();

3053

packet.QueryReplies[i].OwnerID = d.ownerID;

3054

packet.QueryReplies[i].Name =

3055

Utils.StringToBytes(d.name);

3056

packet.QueryReplies[i].EventID = d.eventID;

3057

packet.QueryReplies[i].Date =

3058

Utils.StringToBytes(d.date);

3059

packet.QueryReplies[i].UnixTime = d.unixTime;

3060

packet.QueryReplies[i].EventFlags = d.eventFlags;

3061

packet.StatusData[i].Status = d.Status;

i++;

}

OutPacket(packet, ThrottleOutPacketType.Task);

3066

}

3067

3068

public void SendDirGroupsReply(UUID queryID, DirGroupsReplyData[] data)

3069

{

3070

            DirGroupsReplyPacket packet = (DirGroupsReplyPacket)PacketPool.Instance.GetPacket(PacketType.DirGroupsReply);

3071

3072

packet.AgentData = new DirGroupsReplyPacket.AgentDataBlock();

3073

packet.AgentData.AgentID = AgentId;

3074

3075

packet.QueryData = new DirGroupsReplyPacket.QueryDataBlock();

3076

packet.QueryData.QueryID = queryID;

3077

3078

packet.QueryReplies = new DirGroupsReplyPacket.QueryRepliesBlock[

data.Length];

int i = 0;

foreach (DirGroupsReplyData d in data)

3083

{

3084

packet.QueryReplies[i] = new DirGroupsReplyPacket.QueryRepliesBlock();

3085

packet.QueryReplies[i].GroupID = d.groupID;

3086

packet.QueryReplies[i].GroupName =

3087

Utils.StringToBytes(d.groupName);

3088

packet.QueryReplies[i].Members = d.members;

3089

packet.QueryReplies[i].SearchOrder = d.searchOrder;

i++;

}

OutPacket(packet, ThrottleOutPacketType.Task);

3094

}

3095

3096

public void SendDirClassifiedReply(UUID queryID, DirClassifiedReplyData[] data)

3097

{

3098

            DirClassifiedReplyPacket packet = (DirClassifiedReplyPacket)PacketPool.Instance.GetPacket(PacketType.DirClassifiedReply);

3099

3100

packet.AgentData = new DirClassifiedReplyPacket.AgentDataBlock();

3101

packet.AgentData.AgentID = AgentId;

3102

3103

packet.QueryData = new DirClassifiedReplyPacket.QueryDataBlock();

3104

packet.QueryData.QueryID = queryID;

3105

3106

packet.QueryReplies = new DirClassifiedReplyPacket.QueryRepliesBlock[

3107

data.Length];

3108

packet.StatusData = new DirClassifiedReplyPacket.StatusDataBlock[

data.Length];

int i = 0;

foreach (DirClassifiedReplyData d in data)

3113

{

3114

packet.QueryReplies[i] = new DirClassifiedReplyPacket.QueryRepliesBlock();

3115

packet.StatusData[i] = new DirClassifiedReplyPacket.StatusDataBlock();

3116

packet.QueryReplies[i].ClassifiedID = d.classifiedID;

3117

packet.QueryReplies[i].Name =

3118

Utils.StringToBytes(d.name);

3119

packet.QueryReplies[i].ClassifiedFlags = d.classifiedFlags;

3120

packet.QueryReplies[i].CreationDate = d.creationDate;

3121

packet.QueryReplies[i].ExpirationDate = d.expirationDate;

3122

packet.QueryReplies[i].PriceForListing = d.price;

3123

packet.StatusData[i].Status = d.Status;

i++;

}

OutPacket(packet, ThrottleOutPacketType.Task);

3128

}

3129

3130

public void SendDirLandReply(UUID queryID, DirLandReplyData[] data)

3131

{

3132

DirLandReplyPacket packet = (DirLandReplyPacket)PacketPool.Instance.GetPacket(PacketType.DirLandReply);

3133

3134

packet.AgentData = new DirLandReplyPacket.AgentDataBlock();

3135

packet.AgentData.AgentID = AgentId;

3136

3137

packet.QueryData = new DirLandReplyPacket.QueryDataBlock();

3138

packet.QueryData.QueryID = queryID;

3139

3140

packet.QueryReplies = new DirLandReplyPacket.QueryRepliesBlock[

data.Length];

int i = 0;

foreach (DirLandReplyData d in data)

3145

{

3146

packet.QueryReplies[i] = new DirLandReplyPacket.QueryRepliesBlock();

3147

packet.QueryReplies[i].ParcelID = d.parcelID;

3148

packet.QueryReplies[i].Name =

3149

Utils.StringToBytes(d.name);

3150

packet.QueryReplies[i].Auction = d.auction;

3151

packet.QueryReplies[i].ForSale = d.forSale;

3152

packet.QueryReplies[i].SalePrice = d.salePrice;

3153

packet.QueryReplies[i].ActualArea = d.actualArea;

i++;

}

OutPacket(packet, ThrottleOutPacketType.Task);

3158

}

3159

3160

public void SendDirPopularReply(UUID queryID, DirPopularReplyData[] data)

3161

{

3162

            DirPopularReplyPacket packet = (DirPopularReplyPacket)PacketPool.Instance.GetPacket(PacketType.DirPopularReply);

3163

3164

packet.AgentData = new DirPopularReplyPacket.AgentDataBlock();

3165

packet.AgentData.AgentID = AgentId;

3166

3167

packet.QueryData = new DirPopularReplyPacket.QueryDataBlock();

3168

packet.QueryData.QueryID = queryID;

3169

3170

packet.QueryReplies = new DirPopularReplyPacket.QueryRepliesBlock[

data.Length];

int i = 0;

foreach (DirPopularReplyData d in data)

3175

{

3176

packet.QueryReplies[i] = new DirPopularReplyPacket.QueryRepliesBlock();

3177

packet.QueryReplies[i].ParcelID = d.parcelID;

3178

packet.QueryReplies[i].Name =

3179

Utils.StringToBytes(d.name);

3180

packet.QueryReplies[i].Dwell = d.dwell;

i++;

}

OutPacket(packet, ThrottleOutPacketType.Task);

3185

}

3186

3187

public void SendEventInfoReply(EventData data)

3188

{

3189

            EventInfoReplyPacket packet = (EventInfoReplyPacket)PacketPool.Instance.GetPacket(PacketType.EventInfoReply);

3190

3191

packet.AgentData = new EventInfoReplyPacket.AgentDataBlock();

3192

packet.AgentData.AgentID = AgentId;

3193

3194

packet.EventData = new EventInfoReplyPacket.EventDataBlock();

3195

packet.EventData.EventID = data.eventID;

3196

packet.EventData.Creator = Utils.StringToBytes(data.creator);

3197

packet.EventData.Name = Utils.StringToBytes(data.name);

3198

packet.EventData.Category = Utils.StringToBytes(data.category);

3199

packet.EventData.Desc = Utils.StringToBytes(data.description);

3200

packet.EventData.Date = Utils.StringToBytes(data.date);

3201

packet.EventData.DateUTC = data.dateUTC;

3202

packet.EventData.Duration = data.duration;

3203

packet.EventData.Cover = data.cover;

3204

packet.EventData.Amount = data.amount;

3205

packet.EventData.SimName = Utils.StringToBytes(data.simName);

3206

packet.EventData.GlobalPos = new Vector3d(data.globalPos);

3207

packet.EventData.EventFlags = data.eventFlags;

3208

3209

OutPacket(packet, ThrottleOutPacketType.Task);

3210

}

3211

3212

public void SendMapItemReply(mapItemReply[] replies, uint mapitemtype, uint flags)

3213

{

3214

MapItemReplyPacket mirplk = new MapItemReplyPacket();

3215

mirplk.AgentData.AgentID = AgentId;

3216

mirplk.RequestData.ItemType = mapitemtype;

3217

mirplk.Data = new MapItemReplyPacket.DataBlock[replies.Length];

3218

for (int i = 0; i < replies.Length; i++)

3219

{

3220

MapItemReplyPacket.DataBlock mrdata = new MapItemReplyPacket.DataBlock();

3221

mrdata.X = replies[i].x;

3222

mrdata.Y = replies[i].y;

3223

mrdata.ID = replies[i].id;

3224

mrdata.Extra = replies[i].Extra;

3225

mrdata.Extra2 = replies[i].Extra2;

3226

mrdata.Name = Utils.StringToBytes(replies[i].name);

3227

mirplk.Data[i] = mrdata;

3228

}

3229

//m_log.Debug(mirplk.ToString());

3230

OutPacket(mirplk, ThrottleOutPacketType.Task);

}

public void SendOfferCallingCard(UUID srcID, UUID transactionID)

3235

{

3236

// a bit special, as this uses AgentID to store the source instead

3237

// of the destination. The destination (the receiver) goes into destID

3238

            OfferCallingCardPacket p = (OfferCallingCardPacket)PacketPool.Instance.GetPacket(PacketType.OfferCallingCard);

3239

p.AgentData.AgentID = srcID;

3240

p.AgentData.SessionID = UUID.Zero;

3241

p.AgentBlock.DestID = AgentId;

3242

p.AgentBlock.TransactionID = transactionID;

3243

OutPacket(p, ThrottleOutPacketType.Task);

3244

}

3245

3246

public void SendAcceptCallingCard(UUID transactionID)

3247

{

3248

            AcceptCallingCardPacket p = (AcceptCallingCardPacket)PacketPool.Instance.GetPacket(PacketType.AcceptCallingCard);

3249

p.AgentData.AgentID = AgentId;

3250

p.AgentData.SessionID = UUID.Zero;

3251

p.FolderData = new AcceptCallingCardPacket.FolderDataBlock[1];

3252

p.FolderData[0] = new AcceptCallingCardPacket.FolderDataBlock();

3253

p.FolderData[0].FolderID = UUID.Zero;

3254

OutPacket(p, ThrottleOutPacketType.Task);

3255

}

3256

3257

public void SendDeclineCallingCard(UUID transactionID)

3258

{

3259

            DeclineCallingCardPacket p = (DeclineCallingCardPacket)PacketPool.Instance.GetPacket(PacketType.DeclineCallingCard);

3260

p.AgentData.AgentID = AgentId;

3261

p.AgentData.SessionID = UUID.Zero;

3262

p.TransactionBlock.TransactionID = transactionID;

3263

OutPacket(p, ThrottleOutPacketType.Task);

3264

}

3265

3266

public void SendTerminateFriend(UUID exFriendID)

3267

{

3268

            TerminateFriendshipPacket p = (TerminateFriendshipPacket)PacketPool.Instance.GetPacket(PacketType.TerminateFriendship);

3269

p.AgentData.AgentID = AgentId;

3270

p.AgentData.SessionID = SessionId;

3271

p.ExBlock.OtherID = exFriendID;

3272

OutPacket(p, ThrottleOutPacketType.Task);

3273

}

3274

3275

public void SendAvatarGroupsReply(UUID avatarID, GroupMembershipData[] data)

3276

{

3277

OSDMap llsd = new OSDMap(3);

3278

OSDArray AgentData = new OSDArray(1);

3279

OSDMap AgentDataMap = new OSDMap(1);

3280

AgentDataMap.Add("AgentID", OSD.FromUUID(this.AgentId));

3281

AgentDataMap.Add("AvatarID", OSD.FromUUID(avatarID));

3282

AgentData.Add(AgentDataMap);

3283

llsd.Add("AgentData", AgentData);

3284

OSDArray GroupData = new OSDArray(data.Length);

3285

OSDArray NewGroupData = new OSDArray(data.Length);

3286

foreach (GroupMembershipData m in data)

3287

{

3288

OSDMap GroupDataMap = new OSDMap(6);

3289

OSDMap NewGroupDataMap = new OSDMap(1);

3290

GroupDataMap.Add("GroupPowers", OSD.FromULong(m.GroupPowers));

3291

GroupDataMap.Add("AcceptNotices", OSD.FromBoolean(m.AcceptNotices));

3292

GroupDataMap.Add("GroupTitle", OSD.FromString(m.GroupTitle));

3293

GroupDataMap.Add("GroupID", OSD.FromUUID(m.GroupID));

3294

GroupDataMap.Add("GroupName", OSD.FromString(m.GroupName));

3295

GroupDataMap.Add("GroupInsigniaID", OSD.FromUUID(m.GroupPicture));

3296

NewGroupDataMap.Add("ListInProfile", OSD.FromBoolean(m.ListInProfile));

3297

GroupData.Add(GroupDataMap);

3298

NewGroupData.Add(NewGroupDataMap);

3299

}

3300

llsd.Add("GroupData", GroupData);

3301

llsd.Add("NewGroupData", NewGroupData);

3302

3303

IEventQueue eq = this.Scene.RequestModuleInterface<IEventQueue>();

3304

if (eq != null)

3305

{

3306

eq.Enqueue(BuildEvent("AvatarGroupsReply", llsd), this.AgentId);

}

}

public void SendJoinGroupReply(UUID groupID, bool success)

3311

{

3312

JoinGroupReplyPacket p = (JoinGroupReplyPacket)PacketPool.Instance.GetPacket(PacketType.JoinGroupReply);

3313

3314

p.AgentData = new JoinGroupReplyPacket.AgentDataBlock();

3315

p.AgentData.AgentID = AgentId;

3316

3317

p.GroupData = new JoinGroupReplyPacket.GroupDataBlock();

3318

p.GroupData.GroupID = groupID;

3319

p.GroupData.Success = success;

3320

3321

OutPacket(p, ThrottleOutPacketType.Task);

3322

}

3323

3324

public void SendEjectGroupMemberReply(UUID agentID, UUID groupID, bool success)

3325

{

3326

            EjectGroupMemberReplyPacket p = (EjectGroupMemberReplyPacket)PacketPool.Instance.GetPacket(PacketType.EjectGroupMemberReply);

3327

3328

p.AgentData = new EjectGroupMemberReplyPacket.AgentDataBlock();

3329

p.AgentData.AgentID = agentID;

3330

3331

p.GroupData = new EjectGroupMemberReplyPacket.GroupDataBlock();

3332

p.GroupData.GroupID = groupID;

3333

3334

p.EjectData = new EjectGroupMemberReplyPacket.EjectDataBlock();

3335

p.EjectData.Success = success;

3336

3337

OutPacket(p, ThrottleOutPacketType.Task);

3338

}

3339

3340

public void SendLeaveGroupReply(UUID groupID, bool success)

3341

{

3342

LeaveGroupReplyPacket p = (LeaveGroupReplyPacket)PacketPool.Instance.GetPacket(PacketType.LeaveGroupReply);

3343

3344

p.AgentData = new LeaveGroupReplyPacket.AgentDataBlock();

3345

p.AgentData.AgentID = AgentId;

3346

3347

p.GroupData = new LeaveGroupReplyPacket.GroupDataBlock();

3348

p.GroupData.GroupID = groupID;

3349

p.GroupData.Success = success;

3350

3351

OutPacket(p, ThrottleOutPacketType.Task);

3352

}

3353

3354

public void SendAvatarClassifiedReply(UUID targetID, UUID[] classifiedID, string[] name)

3355

{

3356

if (classifiedID.Length != name.Length)

3357

return;

3358

3359

AvatarClassifiedReplyPacket ac =

3360

(AvatarClassifiedReplyPacket)PacketPool.Instance.GetPacket(

3361

PacketType.AvatarClassifiedReply);

3362

3363

ac.AgentData = new AvatarClassifiedReplyPacket.AgentDataBlock();

3364

ac.AgentData.AgentID = AgentId;

3365

ac.AgentData.TargetID = targetID;

3366

3367

ac.Data = new AvatarClassifiedReplyPacket.DataBlock[classifiedID.Length];

3368

int i;

3369

for (i = 0; i < classifiedID.Length; i++)

3370

{

3371

ac.Data[i].ClassifiedID = classifiedID[i];

3372

ac.Data[i].Name = Utils.StringToBytes(name[i]);

3373

}

3374

3375

OutPacket(ac, ThrottleOutPacketType.Task);

3376

}

3377

3378

        public void SendClassifiedInfoReply(UUID classifiedID, UUID creatorID, uint creationDate, uint expirationDate, uint category, string name, string description, UUID parcelID, uint parentEstate, UUID snapshotID, string simName, Vector3 globalPos, string parcelName, byte classifiedFlags, int price)

3379

{

3380

ClassifiedInfoReplyPacket cr =

3381

(ClassifiedInfoReplyPacket)PacketPool.Instance.GetPacket(

3382

PacketType.ClassifiedInfoReply);

3383

3384

cr.AgentData = new ClassifiedInfoReplyPacket.AgentDataBlock();

3385

cr.AgentData.AgentID = AgentId;

3386

3387

cr.Data = new ClassifiedInfoReplyPacket.DataBlock();

3388

cr.Data.ClassifiedID = classifiedID;

3389

cr.Data.CreatorID = creatorID;

3390

cr.Data.CreationDate = creationDate;

3391

cr.Data.ExpirationDate = expirationDate;

3392

cr.Data.Category = category;

3393

cr.Data.Name = Utils.StringToBytes(name);

3394

cr.Data.Desc = Utils.StringToBytes(description);

3395

cr.Data.ParcelID = parcelID;

3396

cr.Data.ParentEstate = parentEstate;

3397

cr.Data.SnapshotID = snapshotID;

3398

cr.Data.SimName = Utils.StringToBytes(simName);

3399

cr.Data.PosGlobal = new Vector3d(globalPos);

3400

cr.Data.ParcelName = Utils.StringToBytes(parcelName);

3401

cr.Data.ClassifiedFlags = classifiedFlags;

3402

cr.Data.PriceForListing = price;

3403

3404

OutPacket(cr, ThrottleOutPacketType.Task);

3405

}

3406

3407

public void SendAgentDropGroup(UUID groupID)

3408

{

3409

AgentDropGroupPacket dg =

3410

(AgentDropGroupPacket)PacketPool.Instance.GetPacket(

3411

PacketType.AgentDropGroup);

3412

3413

dg.AgentData = new AgentDropGroupPacket.AgentDataBlock();

3414

dg.AgentData.AgentID = AgentId;

3415

dg.AgentData.GroupID = groupID;

3416

3417

OutPacket(dg, ThrottleOutPacketType.Task);

3418

}

3419

3420

public void SendAvatarNotesReply(UUID targetID, string text)

3421

{

3422

AvatarNotesReplyPacket an =

3423

(AvatarNotesReplyPacket)PacketPool.Instance.GetPacket(

3424

PacketType.AvatarNotesReply);

3425

3426

an.AgentData = new AvatarNotesReplyPacket.AgentDataBlock();

3427

an.AgentData.AgentID = AgentId;

3428

3429

an.Data = new AvatarNotesReplyPacket.DataBlock();

3430

an.Data.TargetID = targetID;

3431

an.Data.Notes = Utils.StringToBytes(text);

3432

3433

OutPacket(an, ThrottleOutPacketType.Task);

3434

}

3435

3436

public void SendAvatarPicksReply(UUID targetID, Dictionary<UUID, string> picks)

3437

{

3438

AvatarPicksReplyPacket ap =

3439

(AvatarPicksReplyPacket)PacketPool.Instance.GetPacket(

3440

PacketType.AvatarPicksReply);

3441

3442

ap.AgentData = new AvatarPicksReplyPacket.AgentDataBlock();

3443

ap.AgentData.AgentID = AgentId;

3444

ap.AgentData.TargetID = targetID;

3445

3446

ap.Data = new AvatarPicksReplyPacket.DataBlock[picks.Count];

3447

3448

int i = 0;

3449

foreach (KeyValuePair<UUID, string> pick in picks)

3450

{

3451

ap.Data[i] = new AvatarPicksReplyPacket.DataBlock();

3452

ap.Data[i].PickID = pick.Key;

3453

ap.Data[i].PickName = Utils.StringToBytes(pick.Value);

i++;

}

OutPacket(ap, ThrottleOutPacketType.Task);

3458

}

3459

3460

public void SendAvatarClassifiedReply(UUID targetID, Dictionary<UUID, string> classifieds)

3461

{

3462

AvatarClassifiedReplyPacket ac =

3463

(AvatarClassifiedReplyPacket)PacketPool.Instance.GetPacket(

3464

PacketType.AvatarClassifiedReply);

3465

3466

ac.AgentData = new AvatarClassifiedReplyPacket.AgentDataBlock();

3467

ac.AgentData.AgentID = AgentId;

3468

ac.AgentData.TargetID = targetID;

3469

3470

ac.Data = new AvatarClassifiedReplyPacket.DataBlock[classifieds.Count];

3471

3472

int i = 0;

3473

foreach (KeyValuePair<UUID, string> classified in classifieds)

3474

{

3475

ac.Data[i] = new AvatarClassifiedReplyPacket.DataBlock();

3476

ac.Data[i].ClassifiedID = classified.Key;

3477

ac.Data[i].Name = Utils.StringToBytes(classified.Value);

i++;

}

OutPacket(ac, ThrottleOutPacketType.Task);

3482

}

3483

3484

public void SendParcelDwellReply(int localID, UUID parcelID, float dwell)

3485

{

3486

ParcelDwellReplyPacket pd =

3487

(ParcelDwellReplyPacket)PacketPool.Instance.GetPacket(

3488

PacketType.ParcelDwellReply);

3489

3490

pd.AgentData = new ParcelDwellReplyPacket.AgentDataBlock();

3491

pd.AgentData.AgentID = AgentId;

3492

3493

pd.Data = new ParcelDwellReplyPacket.DataBlock();

3494

pd.Data.LocalID = localID;

3495

pd.Data.ParcelID = parcelID;

3496

pd.Data.Dwell = dwell;

3497

3498

OutPacket(pd, ThrottleOutPacketType.Land);

3499

}

3500

3501

public void SendUserInfoReply(bool imViaEmail, bool visible, string email)

3502

{

3503

UserInfoReplyPacket ur =

3504

(UserInfoReplyPacket)PacketPool.Instance.GetPacket(

3505

PacketType.UserInfoReply);

3506

3507

string Visible = "hidden";

3508

if (visible)

3509

Visible = "default";

3510

3511

ur.AgentData = new UserInfoReplyPacket.AgentDataBlock();

3512

ur.AgentData.AgentID = AgentId;

3513

3514

ur.UserData = new UserInfoReplyPacket.UserDataBlock();

3515

ur.UserData.IMViaEMail = imViaEmail;

3516

ur.UserData.DirectoryVisibility = Utils.StringToBytes(Visible);

3517

ur.UserData.EMail = Utils.StringToBytes(email);

3518

3519

OutPacket(ur, ThrottleOutPacketType.Task);

3520

}

3521

3522

public void SendCreateGroupReply(UUID groupID, bool success, string message)

3523

{

3524

            CreateGroupReplyPacket createGroupReply = (CreateGroupReplyPacket)PacketPool.Instance.GetPacket(PacketType.CreateGroupReply);

3525

3526

createGroupReply.AgentData =

3527

new CreateGroupReplyPacket.AgentDataBlock();

3528

createGroupReply.ReplyData =

3529

new CreateGroupReplyPacket.ReplyDataBlock();

3530

3531

createGroupReply.AgentData.AgentID = AgentId;

3532

createGroupReply.ReplyData.GroupID = groupID;

3533

3534

createGroupReply.ReplyData.Success = success;

3535

createGroupReply.ReplyData.Message = Utils.StringToBytes(message);

3536

OutPacket(createGroupReply, ThrottleOutPacketType.Task);

3537

}

3538

3539

public void SendUseCachedMuteList()

3540

{

3541

            UseCachedMuteListPacket useCachedMuteList = (UseCachedMuteListPacket)PacketPool.Instance.GetPacket(PacketType.UseCachedMuteList);

3542

3543

useCachedMuteList.AgentData = new UseCachedMuteListPacket.AgentDataBlock();

3544

useCachedMuteList.AgentData.AgentID = AgentId;

3545

3546

OutPacket(useCachedMuteList, ThrottleOutPacketType.Task);

3547

}

3548

3549

public void SendMuteListUpdate(string filename)

3550

{

3551

            MuteListUpdatePacket muteListUpdate = (MuteListUpdatePacket)PacketPool.Instance.GetPacket(PacketType.MuteListUpdate);

3552

3553

muteListUpdate.MuteData = new MuteListUpdatePacket.MuteDataBlock();

3554

muteListUpdate.MuteData.AgentID = AgentId;

3555

muteListUpdate.MuteData.Filename = Utils.StringToBytes(filename);

3556

3557

OutPacket(muteListUpdate, ThrottleOutPacketType.Task);

3558

}

3559

3560

        public void SendPickInfoReply(UUID pickID, UUID creatorID, bool topPick, UUID parcelID, string name, string desc, UUID snapshotID, string user, string originalName, string simName, Vector3 posGlobal, int sortOrder, bool enabled)

3561

{

3562

            PickInfoReplyPacket pickInfoReply = (PickInfoReplyPacket)PacketPool.Instance.GetPacket(PacketType.PickInfoReply);

3563

3564

pickInfoReply.AgentData = new PickInfoReplyPacket.AgentDataBlock();

3565

pickInfoReply.AgentData.AgentID = AgentId;

3566

3567

pickInfoReply.Data = new PickInfoReplyPacket.DataBlock();

3568

pickInfoReply.Data.PickID = pickID;

3569

pickInfoReply.Data.CreatorID = creatorID;

3570

pickInfoReply.Data.TopPick = topPick;

3571

pickInfoReply.Data.ParcelID = parcelID;

3572

pickInfoReply.Data.Name = Utils.StringToBytes(name);

3573

pickInfoReply.Data.Desc = Utils.StringToBytes(desc);

3574

pickInfoReply.Data.SnapshotID = snapshotID;

3575

pickInfoReply.Data.User = Utils.StringToBytes(user);

3576

pickInfoReply.Data.OriginalName = Utils.StringToBytes(originalName);

3577

pickInfoReply.Data.SimName = Utils.StringToBytes(simName);

3578

pickInfoReply.Data.PosGlobal = new Vector3d(posGlobal);

3579

pickInfoReply.Data.SortOrder = sortOrder;

3580

pickInfoReply.Data.Enabled = enabled;

3581

3582

OutPacket(pickInfoReply, ThrottleOutPacketType.Task);

3583

}

3584

3585

#endregion Scene/Avatar to Client

// Gesture

#region Appearance/ Wearables Methods

3590

3591

public void SendWearables(AvatarWearable[] wearables, int serial)

3592

{

3593

            AgentWearablesUpdatePacket aw = (AgentWearablesUpdatePacket)PacketPool.Instance.GetPacket(PacketType.AgentWearablesUpdate);

3594

aw.AgentData.AgentID = AgentId;

3595

aw.AgentData.SerialNum = (uint)serial;

3596

aw.AgentData.SessionID = m_sessionId;

3597

3598

int count = 0;

3599

for (int i = 0; i < wearables.Length; i++)

3600

count += wearables[i].Count;

3601

3602

// TODO: don't create new blocks if recycling an old packet

3603

aw.WearableData = new AgentWearablesUpdatePacket.WearableDataBlock[count];

3604

AgentWearablesUpdatePacket.WearableDataBlock awb;

3605

int idx = 0;

3606

for (int i = 0; i < wearables.Length; i++)

3607

{

3608

for (int j = 0; j < wearables[i].Count; j++)

3609

{

3610

awb = new AgentWearablesUpdatePacket.WearableDataBlock();

3611

awb.WearableType = (byte)i;

3612

awb.AssetID = wearables[i][j].AssetID;

3613

awb.ItemID = wearables[i][j].ItemID;

3614

aw.WearableData[idx] = awb;

3615

idx++;

3616

3617

// m_log.DebugFormat(

3618

// "[APPEARANCE]: Sending wearable item/asset {0} {1} (index {2}) for {3}",

3619

// awb.ItemID, awb.AssetID, i, Name);

}

}

OutPacket(aw, ThrottleOutPacketType.Task);

3624

}

3625

3626

public void SendAppearance(UUID agentID, byte[] visualParams, byte[] textureEntry)

3627

{

3628

// m_log.DebugFormat(

3629

// "[LLCLIENTVIEW]: Sending avatar appearance for {0} with {1} bytes to {2} {3}",

3630

// agentID, textureEntry.Length, Name, AgentId);

3631

3632

            AvatarAppearancePacket avp = (AvatarAppearancePacket)PacketPool.Instance.GetPacket(PacketType.AvatarAppearance);

3633

// TODO: don't create new blocks if recycling an old packet

3634

avp.VisualParam = new AvatarAppearancePacket.VisualParamBlock[visualParams.Length];

3635

avp.ObjectData.TextureEntry = textureEntry;

3636

3637

AvatarAppearancePacket.VisualParamBlock avblock = null;

3638

for (int i = 0; i < visualParams.Length; i++)

3639

{

3640

avblock = new AvatarAppearancePacket.VisualParamBlock();

3641

avblock.ParamValue = visualParams[i];

3642

avp.VisualParam[i] = avblock;

3643

}

3644

3645

avp.Sender.IsTrial = false;

3646

avp.Sender.ID = agentID;

3647

avp.AppearanceData = new AvatarAppearancePacket.AppearanceDataBlock[0];

3648

//m_log.DebugFormat("[CLIENT]: Sending appearance for {0} to {1}", agentID.ToString(), AgentId.ToString());

3649

OutPacket(avp, ThrottleOutPacketType.Task);

3650

}

3651

3652

public void SendAnimations(UUID[] animations, int[] seqs, UUID sourceAgentId, UUID[] objectIDs)

3653

{

3654

// m_log.DebugFormat("[LLCLIENTVIEW]: Sending animations for {0} to {1}", sourceAgentId, Name);

3655

3656

            AvatarAnimationPacket ani = (AvatarAnimationPacket)PacketPool.Instance.GetPacket(PacketType.AvatarAnimation);

3657

// TODO: don't create new blocks if recycling an old packet

3658

ani.AnimationSourceList = new AvatarAnimationPacket.AnimationSourceListBlock[animations.Length];

3659

ani.Sender = new AvatarAnimationPacket.SenderBlock();

3660

ani.Sender.ID = sourceAgentId;

3661

ani.AnimationList = new AvatarAnimationPacket.AnimationListBlock[animations.Length];

3662

ani.PhysicalAvatarEventList = new AvatarAnimationPacket.PhysicalAvatarEventListBlock[0];

3663

3664

for (int i = 0; i < animations.Length; ++i)

3665

{

3666

ani.AnimationList[i] = new AvatarAnimationPacket.AnimationListBlock();

3667

ani.AnimationList[i].AnimID = animations[i];

3668

ani.AnimationList[i].AnimSequenceID = seqs[i];

3669

3670

ani.AnimationSourceList[i] = new AvatarAnimationPacket.AnimationSourceListBlock();

3671

if (objectIDs[i].Equals(sourceAgentId))

3672

ani.AnimationSourceList[i].ObjectID = UUID.Zero;

3673

else

3674

ani.AnimationSourceList[i].ObjectID = objectIDs[i];

3675

}

3676

ani.Header.Reliable = false;

3677

OutPacket(ani, ThrottleOutPacketType.Task);

}

#endregion

#region Avatar Packet/Data Sending Methods

3683

3684

/// <summary>

3685

/// Send an ObjectUpdate packet with information about an avatar

3686

/// </summary>

3687

public void SendAvatarDataImmediate(ISceneEntity avatar)

3688

{

3689

// m_log.DebugFormat(

3690

// "[LLCLIENTVIEW]: Sending immediate object update for avatar {0} {1} to {2} {3}",

3691

// avatar.Name, avatar.UUID, Name, AgentId);

3692

3693

ScenePresence presence = avatar as ScenePresence;

3694

if (presence == null)

3695

return;

3696

3697

ObjectUpdatePacket objupdate = (ObjectUpdatePacket)PacketPool.Instance.GetPacket(PacketType.ObjectUpdate);

3698

objupdate.Header.Zerocoded = true;

3699

3700

objupdate.RegionData.RegionHandle = presence.RegionHandle;

3701

objupdate.RegionData.TimeDilation = ushort.MaxValue;

3702

3703

objupdate.ObjectData = new ObjectUpdatePacket.ObjectDataBlock[1];

3704

objupdate.ObjectData[0] = CreateAvatarUpdateBlock(presence);

3705

3706

OutPacket(objupdate, ThrottleOutPacketType.Task);

3707

3708

// We need to record the avatar local id since the root prim of an attachment points to this.

3709

// m_attachmentsSent.Add(avatar.LocalId);

3710

}

3711

3712

public void SendCoarseLocationUpdate(List<UUID> users, List<Vector3> CoarseLocations)

3713

{

3714

// We don't need to update inactive clients.

if (!IsActive)

return;

            CoarseLocationUpdatePacket loc = (CoarseLocationUpdatePacket)PacketPool.Instance.GetPacket(PacketType.CoarseLocationUpdate);

3719

loc.Header.Reliable = false;

3720

3721

// Each packet can only hold around 60 avatar positions and the client clears the mini-map each time

3722

// a CoarseLocationUpdate packet is received. Oh well.

3723

int total = Math.Min(CoarseLocations.Count, 60);

3724

3725

CoarseLocationUpdatePacket.IndexBlock ib = new CoarseLocationUpdatePacket.IndexBlock();

3726

3727

loc.Location = new CoarseLocationUpdatePacket.LocationBlock[total];

3728

loc.AgentData = new CoarseLocationUpdatePacket.AgentDataBlock[total];

3729

3730

int selfindex = -1;

3731

for (int i = 0; i < total; i++)

3732

{

3733

CoarseLocationUpdatePacket.LocationBlock lb =

3734

new CoarseLocationUpdatePacket.LocationBlock();

3735

3736

lb.X = (byte)CoarseLocations[i].X;

3737

lb.Y = (byte)CoarseLocations[i].Y;

3738

3739

lb.Z = CoarseLocations[i].Z > 1024 ? (byte)0 : (byte)(CoarseLocations[i].Z * 0.25f);

3740

loc.Location[i] = lb;

3741

loc.AgentData[i] = new CoarseLocationUpdatePacket.AgentDataBlock();

3742

loc.AgentData[i].AgentID = users[i];

3743

if (users[i] == AgentId)

selfindex = i;

}

ib.You = (short)selfindex;

ib.Prey = -1;

loc.Index = ib;

OutPacket(loc, ThrottleOutPacketType.Task);

3752

}

3753

3754

#endregion Avatar Packet/Data Sending Methods

3755

3756

#region Primitive Packet/Data Sending Methods

/// <summary>

/// Generate one of the object update packets based on PrimUpdateFlags

3761

/// and broadcast the packet to clients

3762

/// </summary>

3763

public void SendEntityUpdate(ISceneEntity entity, PrimUpdateFlags updateFlags)

3764

{

3765

//double priority = m_prioritizer.GetUpdatePriority(this, entity);

3766

uint priority = m_prioritizer.GetUpdatePriority(this, entity);

3767

3768

lock (m_entityUpdates.SyncRoot)

3769

m_entityUpdates.Enqueue(priority, new EntityUpdate(entity, updateFlags, m_scene.TimeDilation));

}

/// <summary>

/// Requeue an EntityUpdate when it was not acknowledged by the client.

3774

/// We will update the priority and put it in the correct queue, merging update flags

3775

/// with any other updates that may be queued for the same entity.

3776

/// The original update time is used for the merged update.

3777

/// </summary>

3778

private void ResendPrimUpdate(EntityUpdate update)

3779

{

3780

// If the update exists in priority queue, it will be updated.

3781

// If it does not exist then it will be added with the current (rather than its original) priority

3782

uint priority = m_prioritizer.GetUpdatePriority(this, update.Entity);

3783

3784

lock (m_entityUpdates.SyncRoot)

3785

m_entityUpdates.Enqueue(priority, update);

}

/// <summary>

/// Requeue a list of EntityUpdates when they were not acknowledged by the client.

3790

/// We will update the priority and put it in the correct queue, merging update flags

3791

/// with any other updates that may be queued for the same entity.

3792

/// The original update time is used for the merged update.

3793

/// </summary>

3794

private void ResendPrimUpdates(List<EntityUpdate> updates, OutgoingPacket oPacket)

3795

{

3796

            // m_log.WarnFormat("[CLIENT] resending prim updates {0}, packet sequence number {1}", updates[0].UpdateTime, oPacket.SequenceNumber);

3797

3798

// Remove the update packet from the list of packets waiting for acknowledgement

3799

// because we are requeuing the list of updates. They will be resent in new packets

3800

// with the most recent state and priority.

3801

m_udpClient.NeedAcks.Remove(oPacket.SequenceNumber);

3802

3803

// Count this as a resent packet since we are going to requeue all of the updates contained in it

3804

Interlocked.Increment(ref m_udpClient.PacketsResent);

3805

3806

foreach (EntityUpdate update in updates)

3807

ResendPrimUpdate(update);

3808

}

3809

3810

//        OpenSim.Framework.Lazy<List<ObjectUpdatePacket.ObjectDataBlock>> objectUpdateBlocks = new OpenSim.Framework.Lazy<List<ObjectUpdatePacket.ObjectDataBlock>>();

3811

//        OpenSim.Framework.Lazy<List<ObjectUpdateCompressedPacket.ObjectDataBlock>> compressedUpdateBlocks = new OpenSim.Framework.Lazy<List<ObjectUpdateCompressedPacket.ObjectDataBlock>>();

3812

//        OpenSim.Framework.Lazy<List<ImprovedTerseObjectUpdatePacket.ObjectDataBlock>> terseUpdateBlocks = new OpenSim.Framework.Lazy<List<ImprovedTerseObjectUpdatePacket.ObjectDataBlock>>();

3813

//        OpenSim.Framework.Lazy<List<ImprovedTerseObjectUpdatePacket.ObjectDataBlock>> terseAgentUpdateBlocks = new OpenSim.Framework.Lazy<List<ImprovedTerseObjectUpdatePacket.ObjectDataBlock>>();

3814

//

3815

// OpenSim.Framework.Lazy<List<EntityUpdate>> objectUpdates = new OpenSim.Framework.Lazy<List<EntityUpdate>>();

3816

//        OpenSim.Framework.Lazy<List<EntityUpdate>> compressedUpdates = new OpenSim.Framework.Lazy<List<EntityUpdate>>();

3817

// OpenSim.Framework.Lazy<List<EntityUpdate>> terseUpdates = new OpenSim.Framework.Lazy<List<EntityUpdate>>();

3818

//        OpenSim.Framework.Lazy<List<EntityUpdate>> terseAgentUpdates = new OpenSim.Framework.Lazy<List<EntityUpdate>>();

3819

3820

3821

private void ProcessEntityUpdates(int maxUpdates)

3822

{

3823

            OpenSim.Framework.Lazy<List<ObjectUpdatePacket.ObjectDataBlock>> objectUpdateBlocks = new OpenSim.Framework.Lazy<List<ObjectUpdatePacket.ObjectDataBlock>>();

3824

            OpenSim.Framework.Lazy<List<ObjectUpdateCompressedPacket.ObjectDataBlock>> compressedUpdateBlocks = new OpenSim.Framework.Lazy<List<ObjectUpdateCompressedPacket.ObjectDataBlock>>();

3825

            OpenSim.Framework.Lazy<List<ImprovedTerseObjectUpdatePacket.ObjectDataBlock>> terseUpdateBlocks = new OpenSim.Framework.Lazy<List<ImprovedTerseObjectUpdatePacket.ObjectDataBlock>>();

3826

            OpenSim.Framework.Lazy<List<ImprovedTerseObjectUpdatePacket.ObjectDataBlock>> terseAgentUpdateBlocks = new OpenSim.Framework.Lazy<List<ImprovedTerseObjectUpdatePacket.ObjectDataBlock>>();

3827

3828

OpenSim.Framework.Lazy<List<EntityUpdate>> objectUpdates = new OpenSim.Framework.Lazy<List<EntityUpdate>>();

3829

            OpenSim.Framework.Lazy<List<EntityUpdate>> compressedUpdates = new OpenSim.Framework.Lazy<List<EntityUpdate>>();

3830

OpenSim.Framework.Lazy<List<EntityUpdate>> terseUpdates = new OpenSim.Framework.Lazy<List<EntityUpdate>>();

3831

            OpenSim.Framework.Lazy<List<EntityUpdate>> terseAgentUpdates = new OpenSim.Framework.Lazy<List<EntityUpdate>>();

3832

3833

// objectUpdateBlocks.Value.Clear();

3834

// compressedUpdateBlocks.Value.Clear();

3835

// terseUpdateBlocks.Value.Clear();

3836

// terseAgentUpdateBlocks.Value.Clear();

3837

// objectUpdates.Value.Clear();

3838

// compressedUpdates.Value.Clear();

3839

// terseUpdates.Value.Clear();

3840

// terseAgentUpdates.Value.Clear();

3841

3842

// Check to see if this is a flush

3843

if (maxUpdates <= 0)

3844

{

3845

maxUpdates = Int32.MaxValue;

3846

}

3847

3848

int updatesThisCall = 0;

3849

3850

// We must lock for both manipulating the kill record and sending the packet, in order to avoid a race

3851

// condition where a kill can be processed before an out-of-date update for the same object.

3852

lock (m_killRecord)

3853

{

3854

float avgTimeDilation = 1.0f;

3855

IEntityUpdate iupdate;

3856

Int32 timeinqueue; // this is just debugging code & can be dropped later

3857

3858

while (updatesThisCall < maxUpdates)

3859

{

3860

lock (m_entityUpdates.SyncRoot)

3861

if (!m_entityUpdates.TryDequeue(out iupdate, out timeinqueue))

3862

break;

3863

3864

EntityUpdate update = (EntityUpdate)iupdate;

3865

3866

avgTimeDilation += update.TimeDilation;

3867

avgTimeDilation *= 0.5f;

3868

3869

if (update.Entity is SceneObjectPart)

3870

{

3871

SceneObjectPart part = (SceneObjectPart)update.Entity;

3872

3873

                        // Please do not remove this unless you can demonstrate on the OpenSim mailing list that a client

3874

                        // will never receive an update after a prim kill.  Even then, keeping the kill record may be a good

3875

// safety measure.

3876

//

3877

// If a Linden Lab 1.23.5 client (and possibly later and earlier) receives an object update

3878

                        // after a kill, it will keep displaying the deleted object until relog.  OpenSim currently performs

3879

                        // updates and kills on different threads with different scheduling strategies, hence this protection.

3880

//

3881

// This doesn't appear to apply to child prims - a client will happily ignore these updates

3882

// after the root prim has been deleted.

3883

if (m_killRecord.Contains(part.LocalId))

3884

{

3885

// m_log.WarnFormat(

3886

        //                            "[CLIENT]: Preventing update for prim with local id {0} after client for user {1} told it was deleted",

3887

// part.LocalId, Name);

continue;

}

if (part.ParentGroup.IsAttachment && m_disableFacelights)

3892

{

3893

if (part.ParentGroup.RootPart.Shape.State != (byte)AttachmentPoint.LeftHand &&

3894

part.ParentGroup.RootPart.Shape.State != (byte)AttachmentPoint.RightHand)

3895

{

3896

part.Shape.LightEntry = false;

}

}

if (part.Shape != null && (part.Shape.SculptType == (byte)SculptType.Mesh))

3901

{

3902

// Ensure that mesh has at least 8 valid faces

3903

part.Shape.ProfileBegin = 12500;

3904

part.Shape.ProfileEnd = 0;

3905

part.Shape.ProfileHollow = 27500;

}

}

#region UpdateFlags to packet type conversion

3910

3911

PrimUpdateFlags updateFlags = (PrimUpdateFlags)update.Flags;

3912

3913

bool canUseCompressed = true;

3914

bool canUseImproved = true;

3915

3916

// Compressed object updates only make sense for LL primitives

3917

if (!(update.Entity is SceneObjectPart))

3918

{

3919

canUseCompressed = false;

3920

}

3921

3922

if (updateFlags.HasFlag(PrimUpdateFlags.FullUpdate))

3923

{

3924

canUseCompressed = false;

3925

canUseImproved = false;

}

else

{

if (updateFlags.HasFlag(PrimUpdateFlags.Velocity) ||

3930

updateFlags.HasFlag(PrimUpdateFlags.Acceleration) ||

3931

updateFlags.HasFlag(PrimUpdateFlags.CollisionPlane) ||

3932

updateFlags.HasFlag(PrimUpdateFlags.Joint))

3933

{

3934

canUseCompressed = false;

3935

}

3936

3937

if (updateFlags.HasFlag(PrimUpdateFlags.PrimFlags) ||

3938

updateFlags.HasFlag(PrimUpdateFlags.ParentID) ||

3939

updateFlags.HasFlag(PrimUpdateFlags.Scale) ||

3940

updateFlags.HasFlag(PrimUpdateFlags.PrimData) ||

3941

updateFlags.HasFlag(PrimUpdateFlags.Text) ||

3942

updateFlags.HasFlag(PrimUpdateFlags.NameValue) ||

3943

updateFlags.HasFlag(PrimUpdateFlags.ExtraData) ||

3944

updateFlags.HasFlag(PrimUpdateFlags.TextureAnim) ||

3945

updateFlags.HasFlag(PrimUpdateFlags.Sound) ||

3946

updateFlags.HasFlag(PrimUpdateFlags.Particles) ||

3947

updateFlags.HasFlag(PrimUpdateFlags.Material) ||

3948

updateFlags.HasFlag(PrimUpdateFlags.ClickAction) ||

3949

updateFlags.HasFlag(PrimUpdateFlags.MediaURL) ||

3950

updateFlags.HasFlag(PrimUpdateFlags.Joint))

3951

{

3952

canUseImproved = false;

}

}

#endregion UpdateFlags to packet type conversion

3957

3958

#region Block Construction

3959

3960

// TODO: Remove this once we can build compressed updates

3961

canUseCompressed = false;

3962

3963

if (!canUseImproved && !canUseCompressed)

3964

{

3965

ObjectUpdatePacket.ObjectDataBlock updateBlock;

3966

3967

if (update.Entity is ScenePresence)

3968

{

3969

updateBlock = CreateAvatarUpdateBlock((ScenePresence)update.Entity);

}

else

{

SceneObjectPart part = (SceneObjectPart)update.Entity;

3974

updateBlock = CreatePrimUpdateBlock(part, AgentId);

3975

3976

// If the part has become a private hud since the update was scheduled then we do not

3977

// want to send it to other avatars.

3978

if (part.ParentGroup.IsAttachment

3979

&& part.ParentGroup.HasPrivateAttachmentPoint

3980

&& part.ParentGroup.AttachedAvatar != AgentId)

3981

continue;

3982

3983

// If the part has since been deleted, then drop the update. In the case of attachments,

3984

// this is to avoid spurious updates to other viewers since post-processing of attachments

3985

// has to change the IsAttachment flag for various reasons (which will end up in a pass

3986

// of the test above).

3987

//

3988

// Actual deletions (kills) happen in another method.

3989

if (part.ParentGroup.IsDeleted)

continue;

}

objectUpdateBlocks.Value.Add(updateBlock);

3994

objectUpdates.Value.Add(update);

3995

}

3996

else if (!canUseImproved)

3997

{

3998

SceneObjectPart part = (SceneObjectPart)update.Entity;

3999

ObjectUpdateCompressedPacket.ObjectDataBlock compressedBlock

4000

= CreateCompressedUpdateBlock(part, updateFlags);

4001

4002

// If the part has since been deleted, then drop the update. In the case of attachments,

4003

// this is to avoid spurious updates to other viewers since post-processing of attachments

4004

// has to change the IsAttachment flag for various reasons (which will end up in a pass

4005

// of the test above).

4006

//

4007

// Actual deletions (kills) happen in another method.

4008

if (part.ParentGroup.IsDeleted)

4009

continue;

4010

4011

compressedUpdateBlocks.Value.Add(compressedBlock);

4012

compressedUpdates.Value.Add(update);

}

else

{

if (update.Entity is ScenePresence && ((ScenePresence)update.Entity).UUID == AgentId)

4017

{

4018

// Self updates go into a special list

4019

                            terseAgentUpdateBlocks.Value.Add(CreateImprovedTerseBlock(update.Entity, updateFlags.HasFlag(PrimUpdateFlags.Textures)));

4020

terseAgentUpdates.Value.Add(update);

}

else

{

ImprovedTerseObjectUpdatePacket.ObjectDataBlock terseUpdateBlock

4025

                                = CreateImprovedTerseBlock(update.Entity, updateFlags.HasFlag(PrimUpdateFlags.Textures));

4026

4027

// Everything else goes here

4028

if (update.Entity is SceneObjectPart)

4029

{

4030

SceneObjectPart part = (SceneObjectPart)update.Entity;

4031

4032

// If the part has become a private hud since the update was scheduled then we do not

4033

// want to send it to other avatars.

4034

if (part.ParentGroup.IsAttachment

4035

&& part.ParentGroup.HasPrivateAttachmentPoint

4036

&& part.ParentGroup.AttachedAvatar != AgentId)

4037

continue;

4038

4039

                                // If the part has since been deleted, then drop the update.  In the case of attachments,

4040

                                // this is to avoid spurious updates to other viewers since post-processing of attachments

4041

// has to change the IsAttachment flag for various reasons (which will end up in a pass

4042

// of the test above).

4043

//

4044

// Actual deletions (kills) happen in another method.

4045

if (part.ParentGroup.IsDeleted)

continue;

}

terseUpdateBlocks.Value.Add(terseUpdateBlock);

4050

terseUpdates.Value.Add(update);

}

}

++updatesThisCall;

#endregion Block Construction

4057

}

4058

4059

#region Packet Sending

4060

ushort timeDilation = Utils.FloatToUInt16(avgTimeDilation, 0.0f, 1.0f);

4061

4062

if (terseAgentUpdateBlocks.IsValueCreated)

4063

{

4064

List<ImprovedTerseObjectUpdatePacket.ObjectDataBlock> blocks = terseAgentUpdateBlocks.Value;

4065

4066

ImprovedTerseObjectUpdatePacket packet

4067

                        = (ImprovedTerseObjectUpdatePacket)PacketPool.Instance.GetPacket(PacketType.ImprovedTerseObjectUpdate);

4068

4069

packet.RegionData.RegionHandle = m_scene.RegionInfo.RegionHandle;

4070

packet.RegionData.TimeDilation = timeDilation;

4071

packet.ObjectData = new ImprovedTerseObjectUpdatePacket.ObjectDataBlock[blocks.Count];

4072

4073

for (int i = 0; i < blocks.Count; i++)

4074

packet.ObjectData[i] = blocks[i];

4075

// If any of the packets created from this call go unacknowledged, all of the updates will be resent

4076

                    OutPacket(packet, ThrottleOutPacketType.Unknown, true, delegate(OutgoingPacket oPacket) { ResendPrimUpdates(terseAgentUpdates.Value, oPacket); });

4077

}

4078

4079

if (objectUpdateBlocks.IsValueCreated)

4080

{

4081

List<ObjectUpdatePacket.ObjectDataBlock> blocks = objectUpdateBlocks.Value;

4082

4083

                    ObjectUpdatePacket packet = (ObjectUpdatePacket)PacketPool.Instance.GetPacket(PacketType.ObjectUpdate);

4084

packet.RegionData.RegionHandle = m_scene.RegionInfo.RegionHandle;

4085

packet.RegionData.TimeDilation = timeDilation;

4086

packet.ObjectData = new ObjectUpdatePacket.ObjectDataBlock[blocks.Count];

4087

4088

for (int i = 0; i < blocks.Count; i++)

4089

packet.ObjectData[i] = blocks[i];

4090

// If any of the packets created from this call go unacknowledged, all of the updates will be resent

4091

                    OutPacket(packet, ThrottleOutPacketType.Task, true, delegate(OutgoingPacket oPacket) { ResendPrimUpdates(objectUpdates.Value, oPacket); });

4092

}

4093

4094

if (compressedUpdateBlocks.IsValueCreated)

4095

{

4096

List<ObjectUpdateCompressedPacket.ObjectDataBlock> blocks = compressedUpdateBlocks.Value;

4097

4098

                    ObjectUpdateCompressedPacket packet = (ObjectUpdateCompressedPacket)PacketPool.Instance.GetPacket(PacketType.ObjectUpdateCompressed);

4099

packet.RegionData.RegionHandle = m_scene.RegionInfo.RegionHandle;

4100

packet.RegionData.TimeDilation = timeDilation;

4101

packet.ObjectData = new ObjectUpdateCompressedPacket.ObjectDataBlock[blocks.Count];

4102

4103

for (int i = 0; i < blocks.Count; i++)

4104

packet.ObjectData[i] = blocks[i];

4105

// If any of the packets created from this call go unacknowledged, all of the updates will be resent

4106

                    OutPacket(packet, ThrottleOutPacketType.Task, true, delegate(OutgoingPacket oPacket) { ResendPrimUpdates(compressedUpdates.Value, oPacket); });

4107

}

4108

4109

if (terseUpdateBlocks.IsValueCreated)

4110

{

4111

List<ImprovedTerseObjectUpdatePacket.ObjectDataBlock> blocks = terseUpdateBlocks.Value;

4112

4113

ImprovedTerseObjectUpdatePacket packet

4114

= (ImprovedTerseObjectUpdatePacket)PacketPool.Instance.GetPacket(

4115

PacketType.ImprovedTerseObjectUpdate);

4116

4117

packet.RegionData.RegionHandle = m_scene.RegionInfo.RegionHandle;

4118

packet.RegionData.TimeDilation = timeDilation;

4119

packet.ObjectData = new ImprovedTerseObjectUpdatePacket.ObjectDataBlock[blocks.Count];

4120

4121

for (int i = 0; i < blocks.Count; i++)

4122

packet.ObjectData[i] = blocks[i];

4123

// If any of the packets created from this call go unacknowledged, all of the updates will be resent

4124

                    OutPacket(packet, ThrottleOutPacketType.Task, true, delegate(OutgoingPacket oPacket) { ResendPrimUpdates(terseUpdates.Value, oPacket); });

}

}

#endregion Packet Sending

4129

}

4130

4131

public void ReprioritizeUpdates()

4132

{

4133

lock (m_entityUpdates.SyncRoot)

4134

m_entityUpdates.Reprioritize(UpdatePriorityHandler);

4135

}

4136

4137

private bool UpdatePriorityHandler(ref uint priority, ISceneEntity entity)

4138

{

4139

if (entity != null)

4140

{

4141

priority = m_prioritizer.GetUpdatePriority(this, entity);

return true;

}

return false;

}

public void FlushPrimUpdates()

4149

{

4150

m_log.WarnFormat("[CLIENT]: Flushing prim updates to " + m_firstName + " " + m_lastName);

4151

4152

while (m_entityUpdates.Count > 0)

4153

ProcessEntityUpdates(-1);

4154

}

4155

4156

#endregion Primitive Packet/Data Sending Methods

4157

4158

// These are used to implement an adaptive backoff in the number

4159

// of updates converted to packets. Since we don't want packets

4160

// to sit in the queue with old data, only convert enough updates

4161

// to packets that can be sent in 200ms.

4162

private Int32 m_LastQueueFill = 0;

4163

private Int32 m_maxUpdates = 0;

4164

4165

void HandleQueueEmpty(ThrottleOutPacketTypeFlags categories)

4166

{

4167

// if (!m_udpServer.IsRunningOutbound)

4168

// return;

4169

4170

if ((categories & ThrottleOutPacketTypeFlags.Task) != 0)

4171

{

4172

// if (!m_udpServer.IsRunningOutbound)

4173

// return;

4174

4175

if (m_maxUpdates == 0 || m_LastQueueFill == 0)

4176

{

4177

m_maxUpdates = m_udpServer.PrimUpdatesPerCallback;

}

else

{

if (Util.EnvironmentTickCountSubtract(m_LastQueueFill) < 200)

4182

m_maxUpdates += 5;

4183

else

4184

m_maxUpdates = m_maxUpdates >> 1;

4185

}

4186

m_maxUpdates = Util.Clamp<Int32>(m_maxUpdates,10,500);

4187

m_LastQueueFill = Util.EnvironmentTickCount();

4188

4189

if (m_entityUpdates.Count > 0)

4190

ProcessEntityUpdates(m_maxUpdates);

4191

4192

if (m_entityProps.Count > 0)

4193

ProcessEntityPropertyRequests(m_maxUpdates);

4194

}

4195

4196

if ((categories & ThrottleOutPacketTypeFlags.Texture) != 0)

4197

ImageManager.ProcessImageQueue(m_udpServer.TextureSendLimit);

4198

}

4199

4200

internal bool HandleHasUpdates(ThrottleOutPacketTypeFlags categories)

4201

{

4202

bool hasUpdates = false;

4203

4204

if ((categories & ThrottleOutPacketTypeFlags.Task) != 0)

4205

{

4206

if (m_entityUpdates.Count > 0)

4207

hasUpdates = true;

4208

else if (m_entityProps.Count > 0)

hasUpdates = true;

}

if ((categories & ThrottleOutPacketTypeFlags.Texture) != 0)

4213

{

4214

if (ImageManager.HasUpdates())

hasUpdates = true;

}

return hasUpdates;

}

public void SendAssetUploadCompleteMessage(sbyte AssetType, bool Success, UUID AssetFullID)

4222

{

4223

AssetUploadCompletePacket newPack = new AssetUploadCompletePacket();

4224

newPack.AssetBlock.Type = AssetType;

4225

newPack.AssetBlock.Success = Success;

4226

newPack.AssetBlock.UUID = AssetFullID;

4227

newPack.Header.Zerocoded = true;

4228

OutPacket(newPack, ThrottleOutPacketType.Asset);

4229

}

4230

4231

public void SendXferRequest(ulong XferID, short AssetType, UUID vFileID, byte FilePath, byte[] FileName)

4232

{

4233

RequestXferPacket newPack = new RequestXferPacket();

4234

newPack.XferID.ID = XferID;

4235

newPack.XferID.VFileType = AssetType;

4236

newPack.XferID.VFileID = vFileID;

4237

newPack.XferID.FilePath = FilePath;

4238

newPack.XferID.Filename = FileName;

4239

newPack.Header.Zerocoded = true;

4240

OutPacket(newPack, ThrottleOutPacketType.Asset);

4241

}

4242

4243

public void SendConfirmXfer(ulong xferID, uint PacketID)

4244

{

4245

ConfirmXferPacketPacket newPack = new ConfirmXferPacketPacket();

4246

newPack.XferID.ID = xferID;

4247

newPack.XferID.Packet = PacketID;

4248

newPack.Header.Zerocoded = true;

4249

OutPacket(newPack, ThrottleOutPacketType.Asset);

4250

}

4251

4252

public void SendInitiateDownload(string simFileName, string clientFileName)

4253

{

4254

InitiateDownloadPacket newPack = new InitiateDownloadPacket();

4255

newPack.AgentData.AgentID = AgentId;

4256

newPack.FileData.SimFilename = Utils.StringToBytes(simFileName);

4257

newPack.FileData.ViewerFilename = Utils.StringToBytes(clientFileName);

4258

OutPacket(newPack, ThrottleOutPacketType.Asset);

4259

}

4260

4261

public void SendImageFirstPart(

4262

ushort numParts, UUID ImageUUID, uint ImageSize, byte[] ImageData, byte imageCodec)

4263

{

4264

ImageDataPacket im = new ImageDataPacket();

4265

im.Header.Reliable = false;

4266

im.ImageID.Packets = numParts;

4267

im.ImageID.ID = ImageUUID;

4268

4269

if (ImageSize > 0)

4270

im.ImageID.Size = ImageSize;

4271

4272

im.ImageData.Data = ImageData;

4273

im.ImageID.Codec = imageCodec;

4274

im.Header.Zerocoded = true;

4275

OutPacket(im, ThrottleOutPacketType.Texture);

4276

}

4277

4278

public void SendImageNextPart(ushort partNumber, UUID imageUuid, byte[] imageData)

4279

{

4280

ImagePacketPacket im = new ImagePacketPacket();

4281

im.Header.Reliable = false;

4282

im.ImageID.Packet = partNumber;

4283

im.ImageID.ID = imageUuid;

4284

im.ImageData.Data = imageData;

4285

4286

OutPacket(im, ThrottleOutPacketType.Texture);

4287

}

4288

4289

public void SendImageNotFound(UUID imageid)

4290

{

4291

ImageNotInDatabasePacket notFoundPacket

4292

= (ImageNotInDatabasePacket)PacketPool.Instance.GetPacket(PacketType.ImageNotInDatabase);

4293

4294

notFoundPacket.ImageID.ID = imageid;

4295

4296

OutPacket(notFoundPacket, ThrottleOutPacketType.Texture);

4297

}

4298

4299

public void SendShutdownConnectionNotice()

4300

{

4301

OutPacket(PacketPool.Instance.GetPacket(PacketType.DisableSimulator), ThrottleOutPacketType.Unknown);

4302

}

4303

4304

public void SendSimStats(SimStats stats)

4305

{

4306

SimStatsPacket pack = new SimStatsPacket();

4307

pack.Region = new SimStatsPacket.RegionBlock();

4308

pack.Region.RegionX = stats.RegionX;

4309

pack.Region.RegionY = stats.RegionY;

4310

pack.Region.RegionFlags = stats.RegionFlags;

4311

pack.Region.ObjectCapacity = stats.ObjectCapacity;

4312

//pack.Region = //stats.RegionBlock;

4313

pack.Stat = stats.StatsBlock;

4314

4315

pack.Header.Reliable = false;

4316

pack.RegionInfo = new SimStatsPacket.RegionInfoBlock[0];

4317

OutPacket(pack, ThrottleOutPacketType.Task);

4318

}

4319

4320

private class ObjectPropertyUpdate : IEntityUpdate

4321

{

4322

internal bool SendFamilyProps;

4323

internal bool SendObjectProps;

4324

4325

public ObjectPropertyUpdate(ISceneEntity entity, uint flags, bool sendfam, bool sendobj)

4326

: base(entity,flags)

4327

{

4328

SendFamilyProps = sendfam;

4329

SendObjectProps = sendobj;

4330

}

4331

public void Update(ObjectPropertyUpdate update)

4332

{

4333

SendFamilyProps = SendFamilyProps || update.SendFamilyProps;

4334

SendObjectProps = SendObjectProps || update.SendObjectProps;

4335

// other properties may need to be updated by base class

4336

base.Update(update);

}

}

public void SendObjectPropertiesFamilyData(ISceneEntity entity, uint requestFlags)

4341

{

4342

uint priority = 0; // time based ordering only

4343

lock (m_entityProps.SyncRoot)

4344

m_entityProps.Enqueue(priority, new ObjectPropertyUpdate(entity,requestFlags,true,false));

4345

}

4346

4347

private void ResendPropertyUpdate(ObjectPropertyUpdate update)

4348

{

4349

uint priority = 0;

4350

lock (m_entityProps.SyncRoot)

4351

m_entityProps.Enqueue(priority, update);

4352

}

4353

4354

private void ResendPropertyUpdates(List<ObjectPropertyUpdate> updates, OutgoingPacket oPacket)

4355

{

4356

// m_log.WarnFormat("[CLIENT] resending object property {0}",updates[0].UpdateTime);

4357

4358

// Remove the update packet from the list of packets waiting for acknowledgement

4359

// because we are requeuing the list of updates. They will be resent in new packets

4360

// with the most recent state.

4361

m_udpClient.NeedAcks.Remove(oPacket.SequenceNumber);

4362

4363

// Count this as a resent packet since we are going to requeue all of the updates contained in it

4364

Interlocked.Increment(ref m_udpClient.PacketsResent);

4365

4366

foreach (ObjectPropertyUpdate update in updates)

4367

ResendPropertyUpdate(update);

4368

}

4369

4370

public void SendObjectPropertiesReply(ISceneEntity entity)

4371

{

4372

uint priority = 0; // time based ordering only

4373

lock (m_entityProps.SyncRoot)

4374

m_entityProps.Enqueue(priority, new ObjectPropertyUpdate(entity,0,false,true));

4375

}

4376

4377

private void ProcessEntityPropertyRequests(int maxUpdates)

4378

{

4379

OpenSim.Framework.Lazy<List<ObjectPropertiesFamilyPacket.ObjectDataBlock>> objectFamilyBlocks =

4380

new OpenSim.Framework.Lazy<List<ObjectPropertiesFamilyPacket.ObjectDataBlock>>();

4381

4382

OpenSim.Framework.Lazy<List<ObjectPropertiesPacket.ObjectDataBlock>> objectPropertiesBlocks =

4383

new OpenSim.Framework.Lazy<List<ObjectPropertiesPacket.ObjectDataBlock>>();

4384

4385

OpenSim.Framework.Lazy<List<ObjectPropertyUpdate>> familyUpdates =

4386

new OpenSim.Framework.Lazy<List<ObjectPropertyUpdate>>();

4387

4388

OpenSim.Framework.Lazy<List<ObjectPropertyUpdate>> propertyUpdates =

4389

new OpenSim.Framework.Lazy<List<ObjectPropertyUpdate>>();

4390

4391

IEntityUpdate iupdate;

4392

Int32 timeinqueue; // this is just debugging code & can be dropped later

4393

4394

int updatesThisCall = 0;

4395

while (updatesThisCall < m_maxUpdates)

4396

{

4397

lock (m_entityProps.SyncRoot)

4398

if (!m_entityProps.TryDequeue(out iupdate, out timeinqueue))

4399

break;

4400

4401

ObjectPropertyUpdate update = (ObjectPropertyUpdate)iupdate;

4402

if (update.SendFamilyProps)

4403

{

4404

if (update.Entity is SceneObjectPart)

4405

{

4406

SceneObjectPart sop = (SceneObjectPart)update.Entity;

4407

                        ObjectPropertiesFamilyPacket.ObjectDataBlock objPropDB = CreateObjectPropertiesFamilyBlock(sop,update.Flags);

4408

objectFamilyBlocks.Value.Add(objPropDB);

4409

familyUpdates.Value.Add(update);

}

}

if (update.SendObjectProps)

4414

{

4415

if (update.Entity is SceneObjectPart)

4416

{

4417

SceneObjectPart sop = (SceneObjectPart)update.Entity;

4418

ObjectPropertiesPacket.ObjectDataBlock objPropDB = CreateObjectPropertiesBlock(sop);

4419

objectPropertiesBlocks.Value.Add(objPropDB);

4420

propertyUpdates.Value.Add(update);

}

}

updatesThisCall++;

}

// Int32 ppcnt = 0;

4429

// Int32 pbcnt = 0;

4430

4431

if (objectPropertiesBlocks.IsValueCreated)

4432

{

4433

List<ObjectPropertiesPacket.ObjectDataBlock> blocks = objectPropertiesBlocks.Value;

4434

List<ObjectPropertyUpdate> updates = propertyUpdates.Value;

4435

4436

                ObjectPropertiesPacket packet = (ObjectPropertiesPacket)PacketPool.Instance.GetPacket(PacketType.ObjectProperties);

4437

packet.ObjectData = new ObjectPropertiesPacket.ObjectDataBlock[blocks.Count];

4438

for (int i = 0; i < blocks.Count; i++)

4439

packet.ObjectData[i] = blocks[i];

4440

4441

packet.Header.Zerocoded = true;

4442

4443

// Pass in the delegate so that if this packet needs to be resent, we send the current properties

4444

// of the object rather than the properties when the packet was created

4445

OutPacket(packet, ThrottleOutPacketType.Task, true,

4446

delegate(OutgoingPacket oPacket)

4447

{

4448

ResendPropertyUpdates(updates, oPacket);

4449

});

4450

4451

// pbcnt += blocks.Count;

// ppcnt++;

}

// Int32 fpcnt = 0;

4456

// Int32 fbcnt = 0;

4457

4458

if (objectFamilyBlocks.IsValueCreated)

4459

{

4460

List<ObjectPropertiesFamilyPacket.ObjectDataBlock> blocks = objectFamilyBlocks.Value;

4461

4462

// one packet per object block... uggh...

4463

for (int i = 0; i < blocks.Count; i++)

4464

{

4465

ObjectPropertiesFamilyPacket packet =

4466

(ObjectPropertiesFamilyPacket)PacketPool.Instance.GetPacket(PacketType.ObjectPropertiesFamily);

4467

4468

packet.ObjectData = blocks[i];

4469

packet.Header.Zerocoded = true;

4470

4471

// Pass in the delegate so that if this packet needs to be resent, we send the current properties

4472

// of the object rather than the properties when the packet was created

4473

List<ObjectPropertyUpdate> updates = new List<ObjectPropertyUpdate>();

4474

updates.Add(familyUpdates.Value[i]);

4475

OutPacket(packet, ThrottleOutPacketType.Task, true,

4476

delegate(OutgoingPacket oPacket)

4477

{

4478

ResendPropertyUpdates(updates, oPacket);

});

// fpcnt++;

// fbcnt++;

}

}

// m_log.WarnFormat("[PACKETCOUNTS] queued {0} property packets with {1} blocks",ppcnt,pbcnt);

4488

// m_log.WarnFormat("[PACKETCOUNTS] queued {0} family property packets with {1} blocks",fpcnt,fbcnt);

4489

}

4490

4491

        private ObjectPropertiesFamilyPacket.ObjectDataBlock CreateObjectPropertiesFamilyBlock(SceneObjectPart sop, uint requestFlags)

4492

{

4493

ObjectPropertiesFamilyPacket.ObjectDataBlock block = new ObjectPropertiesFamilyPacket.ObjectDataBlock();

4494

4495

block.RequestFlags = requestFlags;

4496

block.ObjectID = sop.UUID;

4497

if (sop.OwnerID == sop.GroupID)

4498

block.OwnerID = UUID.Zero;

4499

else

4500

block.OwnerID = sop.OwnerID;

4501

block.GroupID = sop.GroupID;

4502

block.BaseMask = sop.BaseMask;

4503

block.OwnerMask = sop.OwnerMask;

4504

block.GroupMask = sop.GroupMask;

4505

block.EveryoneMask = sop.EveryoneMask;

4506

block.NextOwnerMask = sop.NextOwnerMask;

4507

4508

// TODO: More properties are needed in SceneObjectPart!

4509

block.OwnershipCost = sop.OwnershipCost;

4510

block.SaleType = sop.ObjectSaleType;

4511

block.SalePrice = sop.SalePrice;

4512

block.Category = sop.Category;

4513

block.LastOwnerID = sop.CreatorID; // copied from old SOG call... is this right?

4514

block.Name = Util.StringToBytes256(sop.Name);

4515

block.Description = Util.StringToBytes256(sop.Description);

return block;

}

private ObjectPropertiesPacket.ObjectDataBlock CreateObjectPropertiesBlock(SceneObjectPart sop)

4521

{

4522

            //ObjectPropertiesPacket proper = (ObjectPropertiesPacket)PacketPool.Instance.GetPacket(PacketType.ObjectProperties);

4523

// TODO: don't create new blocks if recycling an old packet

4524

4525

ObjectPropertiesPacket.ObjectDataBlock block =

4526

new ObjectPropertiesPacket.ObjectDataBlock();

4527

4528

block.ObjectID = sop.UUID;

4529

block.Name = Util.StringToBytes256(sop.Name);

4530

block.Description = Util.StringToBytes256(sop.Description);

4531

4532

block.CreationDate = (ulong)sop.CreationDate * 1000000; // viewer wants date in microseconds

4533

block.CreatorID = sop.CreatorID;

4534

block.GroupID = sop.GroupID;

4535

block.LastOwnerID = sop.LastOwnerID;

4536

if (sop.OwnerID == sop.GroupID)

4537

block.OwnerID = UUID.Zero;

4538

else

4539

block.OwnerID = sop.OwnerID;

4540

4541

block.ItemID = sop.FromUserInventoryItemID;

4542

block.FolderID = UUID.Zero; // sog.FromFolderID ??

4543

block.FromTaskID = UUID.Zero; // ???

4544

block.InventorySerial = (short)sop.InventorySerial;

4545

4546

SceneObjectPart root = sop.ParentGroup.RootPart;

4547

4548

block.TouchName = Util.StringToBytes256(root.TouchName);

4549

block.TextureID = new byte[0]; // TextureID ???

4550

block.SitName = Util.StringToBytes256(root.SitName);

4551

block.OwnerMask = root.OwnerMask;

4552

block.NextOwnerMask = root.NextOwnerMask;

4553

block.GroupMask = root.GroupMask;

4554

block.EveryoneMask = root.EveryoneMask;

4555

block.BaseMask = root.BaseMask;

4556

block.SaleType = root.ObjectSaleType;

4557

block.SalePrice = root.SalePrice;

return block;

}

#region Estate Data Sending Methods

4563

4564

private static bool convertParamStringToBool(byte[] field)

4565

{

4566

string s = Utils.BytesToString(field);

4567

if (s == "1" || s.ToLower() == "y" || s.ToLower() == "yes" || s.ToLower() == "t" || s.ToLower() == "true")

{

return true;

}

return false;

}

public void SendEstateList(UUID invoice, int code, UUID[] Data, uint estateID)

4575

4576

{

4577

EstateOwnerMessagePacket packet = new EstateOwnerMessagePacket();

4578

packet.AgentData.TransactionID = UUID.Random();

4579

packet.AgentData.AgentID = AgentId;

4580

packet.AgentData.SessionID = SessionId;

4581

packet.MethodData.Invoice = invoice;

4582

packet.MethodData.Method = Utils.StringToBytes("setaccess");

4583

4584

            EstateOwnerMessagePacket.ParamListBlock[] returnblock = new EstateOwnerMessagePacket.ParamListBlock[6 + Data.Length];

4585

4586

for (int i = 0; i < (6 + Data.Length); i++)

4587

{

4588

returnblock[i] = new EstateOwnerMessagePacket.ParamListBlock();

}

int j = 0;

returnblock[j].Parameter = Utils.StringToBytes(estateID.ToString()); j++;

4593

returnblock[j].Parameter = Utils.StringToBytes(code.ToString()); j++;

4594

returnblock[j].Parameter = Utils.StringToBytes("0"); j++;

4595

returnblock[j].Parameter = Utils.StringToBytes("0"); j++;

4596

returnblock[j].Parameter = Utils.StringToBytes("0"); j++;

4597

returnblock[j].Parameter = Utils.StringToBytes("0"); j++;

4598

4599

j = 2; // Agents

4600

if ((code & 2) != 0)

4601

j = 3; // Groups

4602

if ((code & 8) != 0)

4603

j = 5; // Managers

4604

4605

returnblock[j].Parameter = Utils.StringToBytes(Data.Length.ToString());

4606

j = 6;

4607

4608

for (int i = 0; i < Data.Length; i++)

4609

{

4610

returnblock[j].Parameter = Data[i].GetBytes(); j++;

4611

}

4612

packet.ParamList = returnblock;

4613

packet.Header.Reliable = true;

4614

OutPacket(packet, ThrottleOutPacketType.Task);

4615

}

4616

4617

public void SendBannedUserList(UUID invoice, EstateBan[] bl, uint estateID)

4618

{

4619

List<UUID> BannedUsers = new List<UUID>();

4620

4621

for (int i = 0; i < bl.Length; i++)

{

if (bl[i] == null)

continue;

if (bl[i].BannedUserID == UUID.Zero)

4626

continue;

4627

BannedUsers.Add(bl[i].BannedUserID);

4628

4629

if (BannedUsers.Count >= 50 || (i == (bl.Length - 1) && BannedUsers.Count > 0))

4630

{

4631

EstateOwnerMessagePacket packet = new EstateOwnerMessagePacket();

4632

packet.AgentData.TransactionID = UUID.Random();

4633

packet.AgentData.AgentID = AgentId;

4634

packet.AgentData.SessionID = SessionId;

4635

packet.MethodData.Invoice = invoice;

4636

packet.MethodData.Method = Utils.StringToBytes("setaccess");

4637

4638

                    EstateOwnerMessagePacket.ParamListBlock[] returnblock = new EstateOwnerMessagePacket.ParamListBlock[6 + BannedUsers.Count];

4639

4640

int j;

4641

for (j = 0; j < (6 + BannedUsers.Count); j++)

4642

{

4643

returnblock[j] = new EstateOwnerMessagePacket.ParamListBlock();

}

j = 0;

returnblock[j].Parameter = Utils.StringToBytes(estateID.ToString()); j++;

4648

                    returnblock[j].Parameter = Utils.StringToBytes(((int)Constants.EstateAccessCodex.EstateBans).ToString()); j++;

4649

returnblock[j].Parameter = Utils.StringToBytes("0"); j++;

4650

returnblock[j].Parameter = Utils.StringToBytes("0"); j++;

4651

returnblock[j].Parameter = Utils.StringToBytes(BannedUsers.Count.ToString()); j++;

4652

returnblock[j].Parameter = Utils.StringToBytes("0"); j++;

4653

4654

foreach (UUID banned in BannedUsers)

4655

{

4656

returnblock[j].Parameter = banned.GetBytes(); j++;

4657

}

4658

packet.ParamList = returnblock;

4659

packet.Header.Reliable = true;

4660

OutPacket(packet, ThrottleOutPacketType.Task);

4661

4662

BannedUsers.Clear();

}

}

}

public void SendRegionInfoToEstateMenu(RegionInfoForEstateMenuArgs args)

4669

{

4670

RegionInfoPacket rinfopack = new RegionInfoPacket();

4671

RegionInfoPacket.RegionInfoBlock rinfoblk = new RegionInfoPacket.RegionInfoBlock();

4672

rinfopack.AgentData.AgentID = AgentId;

4673

rinfopack.AgentData.SessionID = SessionId;

4674

rinfoblk.BillableFactor = args.billableFactor;

4675

rinfoblk.EstateID = args.estateID;

4676

rinfoblk.MaxAgents = args.maxAgents;

4677

rinfoblk.ObjectBonusFactor = args.objectBonusFactor;

4678

rinfoblk.ParentEstateID = args.parentEstateID;

4679

rinfoblk.PricePerMeter = args.pricePerMeter;

4680

rinfoblk.RedirectGridX = args.redirectGridX;

4681

rinfoblk.RedirectGridY = args.redirectGridY;

4682

rinfoblk.RegionFlags = args.regionFlags;

4683

rinfoblk.SimAccess = args.simAccess;

4684

rinfoblk.SunHour = args.sunHour;

4685

rinfoblk.TerrainLowerLimit = args.terrainLowerLimit;

4686

rinfoblk.TerrainRaiseLimit = args.terrainRaiseLimit;

4687

rinfoblk.UseEstateSun = args.useEstateSun;

4688

rinfoblk.WaterHeight = args.waterHeight;

4689

rinfoblk.SimName = Utils.StringToBytes(args.simName);

4690

4691

rinfopack.RegionInfo2 = new RegionInfoPacket.RegionInfo2Block();

4692

rinfopack.RegionInfo2.HardMaxAgents = uint.MaxValue;

4693

rinfopack.RegionInfo2.HardMaxObjects = uint.MaxValue;

4694

rinfopack.RegionInfo2.MaxAgents32 = uint.MaxValue;

4695

rinfopack.RegionInfo2.ProductName = Util.StringToBytes256(args.regionType);

4696

rinfopack.RegionInfo2.ProductSKU = Utils.EmptyBytes;

4697

4698

rinfopack.HasVariableBlocks = true;

4699

rinfopack.RegionInfo = rinfoblk;

4700

rinfopack.AgentData = new RegionInfoPacket.AgentDataBlock();

4701

rinfopack.AgentData.AgentID = AgentId;

4702

rinfopack.AgentData.SessionID = SessionId;

4703

rinfopack.RegionInfo3 = new RegionInfoPacket.RegionInfo3Block[0];

4704

4705

OutPacket(rinfopack, ThrottleOutPacketType.Task);

4706

}

4707

4708

public void SendEstateCovenantInformation(UUID covenant)

4709

{

4710

// m_log.DebugFormat("[LLCLIENTVIEW]: Sending estate covenant asset id of {0} to {1}", covenant, Name);

4711

4712

EstateCovenantReplyPacket einfopack = new EstateCovenantReplyPacket();

4713

EstateCovenantReplyPacket.DataBlock edata = new EstateCovenantReplyPacket.DataBlock();

4714

edata.CovenantID = covenant;

4715

edata.CovenantTimestamp = (uint) m_scene.RegionInfo.RegionSettings.CovenantChangedDateTime;

4716

edata.EstateOwnerID = m_scene.RegionInfo.EstateSettings.EstateOwner;

4717

edata.EstateName = Utils.StringToBytes(m_scene.RegionInfo.EstateSettings.EstateName);

4718

einfopack.Data = edata;

4719

OutPacket(einfopack, ThrottleOutPacketType.Task);

4720

}

4721

4722

public void SendDetailedEstateData(

4723

UUID invoice, string estateName, uint estateID, uint parentEstate, uint estateFlags, uint sunPosition,

4724

UUID covenant, uint covenantChanged, string abuseEmail, UUID estateOwner)

4725

{

4726

// m_log.DebugFormat(

4727

// "[LLCLIENTVIEW]: Sending detailed estate data to {0} with covenant asset id {1}", Name, covenant);

4728

4729

EstateOwnerMessagePacket packet = new EstateOwnerMessagePacket();

4730

packet.MethodData.Invoice = invoice;

4731

packet.AgentData.TransactionID = UUID.Random();

4732

packet.MethodData.Method = Utils.StringToBytes("estateupdateinfo");

4733

EstateOwnerMessagePacket.ParamListBlock[] returnblock = new EstateOwnerMessagePacket.ParamListBlock[10];

4734

4735

for (int i = 0; i < 10; i++)

4736

{

4737

returnblock[i] = new EstateOwnerMessagePacket.ParamListBlock();

4738

}

4739

4740

//Sending Estate Settings

4741

returnblock[0].Parameter = Utils.StringToBytes(estateName);

4742

returnblock[1].Parameter = Utils.StringToBytes(estateOwner.ToString());

4743

returnblock[2].Parameter = Utils.StringToBytes(estateID.ToString());

4744

4745

returnblock[3].Parameter = Utils.StringToBytes(estateFlags.ToString());

4746

returnblock[4].Parameter = Utils.StringToBytes(sunPosition.ToString());

4747

returnblock[5].Parameter = Utils.StringToBytes(parentEstate.ToString());

4748

returnblock[6].Parameter = Utils.StringToBytes(covenant.ToString());

4749

returnblock[7].Parameter = Utils.StringToBytes(covenantChanged.ToString());

4750

returnblock[8].Parameter = Utils.StringToBytes("1"); // what is this?

4751

returnblock[9].Parameter = Utils.StringToBytes(abuseEmail);

4752

4753

packet.ParamList = returnblock;

4754

packet.Header.Reliable = false;

4755

//m_log.Debug("[ESTATE]: SIM--->" + packet.ToString());

4756

OutPacket(packet, ThrottleOutPacketType.Task);

4757

}

4758

4759

        public void SendTelehubInfo(UUID ObjectID, string ObjectName, Vector3 ObjectPos, Quaternion ObjectRot, List<Vector3> SpawnPoint)

4760

{

4761

TelehubInfoPacket packet = (TelehubInfoPacket)PacketPool.Instance.GetPacket(PacketType.TelehubInfo);

4762

packet.TelehubBlock.ObjectID = ObjectID;

4763

packet.TelehubBlock.ObjectName = Utils.StringToBytes(ObjectName);

4764

packet.TelehubBlock.TelehubPos = ObjectPos;

4765

packet.TelehubBlock.TelehubRot = ObjectRot;

4766

4767

packet.SpawnPointBlock = new TelehubInfoPacket.SpawnPointBlockBlock[SpawnPoint.Count];

4768

for (int n = 0; n < SpawnPoint.Count; n++)

4769

{

4770

packet.SpawnPointBlock[n] = new TelehubInfoPacket.SpawnPointBlockBlock{SpawnPointPos = SpawnPoint[n]};

4771

}

4772

4773

OutPacket(packet, ThrottleOutPacketType.Task);

}

#endregion

#region Land Data Sending Methods

4779

4780

public void SendLandParcelOverlay(byte[] data, int sequence_id)

4781

{

4782

ParcelOverlayPacket packet = (ParcelOverlayPacket)PacketPool.Instance.GetPacket(PacketType.ParcelOverlay);

4783

packet.ParcelData.Data = data;

4784

packet.ParcelData.SequenceID = sequence_id;

4785

packet.Header.Zerocoded = true;

4786

OutPacket(packet, ThrottleOutPacketType.Task);

4787

}

4788

4789

public void SendLandProperties(

4790

int sequence_id, bool snap_selection, int request_result, ILandObject lo,

4791

float simObjectBonusFactor, int parcelObjectCapacity, int simObjectCapacity, uint regionFlags)

4792

{

4793

// m_log.DebugFormat("[LLCLIENTVIEW]: Sending land properties for {0} to {1}", lo.LandData.GlobalID, Name);

4794

4795

LandData landData = lo.LandData;

4796

4797

ParcelPropertiesMessage updateMessage = new ParcelPropertiesMessage();

4798

4799

updateMessage.AABBMax = landData.AABBMax;

4800

updateMessage.AABBMin = landData.AABBMin;

4801

updateMessage.Area = landData.Area;

4802

updateMessage.AuctionID = landData.AuctionID;

4803

updateMessage.AuthBuyerID = landData.AuthBuyerID;

4804

updateMessage.Bitmap = landData.Bitmap;

4805

updateMessage.Desc = landData.Description;

4806

updateMessage.Category = landData.Category;

4807

updateMessage.ClaimDate = Util.ToDateTime(landData.ClaimDate);

4808

updateMessage.ClaimPrice = landData.ClaimPrice;

4809

updateMessage.GroupID = landData.GroupID;

4810

updateMessage.IsGroupOwned = landData.IsGroupOwned;

4811

updateMessage.LandingType = (LandingType) landData.LandingType;

4812

updateMessage.LocalID = landData.LocalID;

4813

4814

if (landData.Area > 0)

4815

{

4816

updateMessage.MaxPrims = parcelObjectCapacity;

}

else

{

updateMessage.MaxPrims = 0;

4821

}

4822

4823

updateMessage.MediaAutoScale = Convert.ToBoolean(landData.MediaAutoScale);

4824

updateMessage.MediaID = landData.MediaID;

4825

updateMessage.MediaURL = landData.MediaURL;

4826

updateMessage.MusicURL = landData.MusicURL;

4827

updateMessage.Name = landData.Name;

4828

updateMessage.OtherCleanTime = landData.OtherCleanTime;

4829

updateMessage.OtherCount = 0; //TODO: Unimplemented

4830

updateMessage.OwnerID = landData.OwnerID;

4831

updateMessage.ParcelFlags = (ParcelFlags) landData.Flags;

4832

updateMessage.ParcelPrimBonus = simObjectBonusFactor;

4833

updateMessage.PassHours = landData.PassHours;

4834

updateMessage.PassPrice = landData.PassPrice;

4835

updateMessage.PublicCount = 0; //TODO: Unimplemented

4836

4837

updateMessage.RegionPushOverride = (regionFlags & (uint)RegionFlags.RestrictPushObject) > 0;

4838

updateMessage.RegionDenyAnonymous = (regionFlags & (uint)RegionFlags.DenyAnonymous) > 0;

4839

4840

//updateMessage.RegionDenyIdentified = (regionFlags & (uint)RegionFlags.DenyIdentified) > 0;

4841

//updateMessage.RegionDenyTransacted = (regionFlags & (uint)RegionFlags.DenyTransacted) > 0;

4842

4843

updateMessage.RentPrice = 0;

4844

updateMessage.RequestResult = (ParcelResult) request_result;

4845

updateMessage.SalePrice = landData.SalePrice;

4846

updateMessage.SelfCount = 0; //TODO: Unimplemented

4847

updateMessage.SequenceID = sequence_id;

4848

4849

if (landData.SimwideArea > 0)

4850

{

4851

                int simulatorCapacity = (int)(((float)landData.SimwideArea / 65536.0f) * (float)m_scene.RegionInfo.ObjectCapacity * (float)m_scene.RegionInfo.RegionSettings.ObjectBonus);

4852

updateMessage.SimWideMaxPrims = simulatorCapacity;

}

else

{

updateMessage.SimWideMaxPrims = 0;

4857

}

4858

4859

updateMessage.SnapSelection = snap_selection;

4860

updateMessage.SnapshotID = landData.SnapshotID;

4861

updateMessage.Status = (ParcelStatus) landData.Status;

4862

updateMessage.UserLocation = landData.UserLocation;

4863

updateMessage.UserLookAt = landData.UserLookAt;

4864

4865

updateMessage.MediaType = landData.MediaType;

4866

updateMessage.MediaDesc = landData.MediaDescription;

4867

updateMessage.MediaWidth = landData.MediaWidth;

4868

updateMessage.MediaHeight = landData.MediaHeight;

4869

updateMessage.MediaLoop = landData.MediaLoop;

4870

updateMessage.ObscureMusic = landData.ObscureMusic;

4871

updateMessage.ObscureMedia = landData.ObscureMedia;

4872

4873

IPrimCounts pc = lo.PrimCounts;

4874

updateMessage.OwnerPrims = pc.Owner;

4875

updateMessage.GroupPrims = pc.Group;

4876

updateMessage.OtherPrims = pc.Others;

4877

updateMessage.SelectedPrims = pc.Selected;

4878

updateMessage.TotalPrims = pc.Total;

4879

updateMessage.SimWideTotalPrims = pc.Simulator;

try

{

IEventQueue eq = Scene.RequestModuleInterface<IEventQueue>();

4884

if (eq != null)

4885

{

4886

eq.ParcelProperties(updateMessage, this.AgentId);

}

else

{

m_log.Warn("[LLCLIENTVIEW]: No EQ Interface when sending parcel data.");

4891

}

4892

}

4893

catch (Exception ex)

4894

{

4895

m_log.Error("[LLCLIENTVIEW]: Unable to send parcel data via eventqueue - exception: " + ex.ToString());

}

}

public void SendLandAccessListData(List<LandAccessEntry> accessList, uint accessFlag, int localLandID)

4900

{

4901

            ParcelAccessListReplyPacket replyPacket = (ParcelAccessListReplyPacket)PacketPool.Instance.GetPacket(PacketType.ParcelAccessListReply);

4902

replyPacket.Data.AgentID = AgentId;

4903

replyPacket.Data.Flags = accessFlag;

4904

replyPacket.Data.LocalID = localLandID;

4905

replyPacket.Data.SequenceID = 0;

4906

4907

List<ParcelAccessListReplyPacket.ListBlock> list = new List<ParcelAccessListReplyPacket.ListBlock>();

4908

foreach (LandAccessEntry entry in accessList)

4909

{

4910

ParcelAccessListReplyPacket.ListBlock block = new ParcelAccessListReplyPacket.ListBlock();

4911

block.Flags = accessFlag;

4912

block.ID = entry.AgentID;

4913

block.Time = entry.Expires;

list.Add(block);

}

replyPacket.List = list.ToArray();

4918

replyPacket.Header.Zerocoded = true;

4919

OutPacket(replyPacket, ThrottleOutPacketType.Task);

4920

}

4921

4922

public void SendForceClientSelectObjects(List<uint> ObjectIDs)

4923

{

4924

// m_log.DebugFormat("[LLCLIENTVIEW] sending select with {0} objects", ObjectIDs.Count);

4925

4926

bool firstCall = true;

4927

const int MAX_OBJECTS_PER_PACKET = 251;

4928

            ForceObjectSelectPacket pack = (ForceObjectSelectPacket)PacketPool.Instance.GetPacket(PacketType.ForceObjectSelect);

4929

ForceObjectSelectPacket.DataBlock[] data;

4930

while (ObjectIDs.Count > 0)

{

if (firstCall)

{

pack._Header.ResetList = true;

firstCall = false;

}

else

{

pack._Header.ResetList = false;

4940

}

4941

4942

if (ObjectIDs.Count > MAX_OBJECTS_PER_PACKET)

4943

{

4944

data = new ForceObjectSelectPacket.DataBlock[MAX_OBJECTS_PER_PACKET];

}

else

{

data = new ForceObjectSelectPacket.DataBlock[ObjectIDs.Count];

}

int i;

for (i = 0; i < MAX_OBJECTS_PER_PACKET && ObjectIDs.Count > 0; i++)

4953

{

4954

data[i] = new ForceObjectSelectPacket.DataBlock();

4955

data[i].LocalID = Convert.ToUInt32(ObjectIDs[0]);

4956

ObjectIDs.RemoveAt(0);

4957

}

4958

pack.Data = data;

4959

pack.Header.Zerocoded = true;

4960

OutPacket(pack, ThrottleOutPacketType.Task);

}

}

public void SendCameraConstraint(Vector4 ConstraintPlane)

4965

{

4966

            CameraConstraintPacket cpack = (CameraConstraintPacket)PacketPool.Instance.GetPacket(PacketType.CameraConstraint);

4967

cpack.CameraCollidePlane = new CameraConstraintPacket.CameraCollidePlaneBlock();

4968

cpack.CameraCollidePlane.Plane = ConstraintPlane;

4969

//m_log.DebugFormat("[CLIENTVIEW]: Constraint {0}", ConstraintPlane);

4970

OutPacket(cpack, ThrottleOutPacketType.Task);

4971

}

4972

4973

public void SendLandObjectOwners(LandData land, List<UUID> groups, Dictionary<UUID, int> ownersAndCount)

4974

{

4975

int notifyCount = ownersAndCount.Count;

4976

            ParcelObjectOwnersReplyPacket pack = (ParcelObjectOwnersReplyPacket)PacketPool.Instance.GetPacket(PacketType.ParcelObjectOwnersReply);

4977

4978

if (notifyCount > 0)

4979

{

4980

if (notifyCount > 32)

4981

{

4982

m_log.InfoFormat(

4983

                        "[LAND]: More than {0} avatars own prims on this parcel.  Only sending back details of first {0}"

4984

+ " - a developer might want to investigate whether this is a hard limit", 32);

notifyCount = 32;

}

ParcelObjectOwnersReplyPacket.DataBlock[] dataBlock

4990

= new ParcelObjectOwnersReplyPacket.DataBlock[notifyCount];

4991

4992

int num = 0;

4993

foreach (UUID owner in ownersAndCount.Keys)

4994

{

4995

dataBlock[num] = new ParcelObjectOwnersReplyPacket.DataBlock();

4996

dataBlock[num].Count = ownersAndCount[owner];

4997

4998

if (land.GroupID == owner || groups.Contains(owner))

4999

dataBlock[num].IsGroupOwned = true;

5000

5001

dataBlock[num].OnlineStatus = true; //TODO: fix me later

5002

dataBlock[num].OwnerID = owner;

num++;

if (num >= notifyCount)

{

break;

}

}

pack.Data = dataBlock;

}

else

{

pack.Data = new ParcelObjectOwnersReplyPacket.DataBlock[0];

5017

}

5018

pack.Header.Zerocoded = true;

5019

this.OutPacket(pack, ThrottleOutPacketType.Task);

}

#endregion

#region Helper Methods

5025

5026

        protected ImprovedTerseObjectUpdatePacket.ObjectDataBlock CreateImprovedTerseBlock(ISceneEntity entity, bool sendTexture)

5027

{

5028

#region ScenePresence/SOP Handling

5029

5030

bool avatar = (entity is ScenePresence);

5031

uint localID = entity.LocalId;

5032

uint attachPoint;

5033

Vector4 collisionPlane;

5034

Vector3 position, velocity, acceleration, angularVelocity;

5035

Quaternion rotation;

5036

byte[] textureEntry;

5037

5038

if (entity is ScenePresence)

5039

{

5040

ScenePresence presence = (ScenePresence)entity;

5041

5042

attachPoint = presence.State;

5043

collisionPlane = presence.CollisionPlane;

5044

position = presence.OffsetPosition;

5045

velocity = presence.Velocity;

5046

acceleration = Vector3.Zero;

5047

5048

// Interestingly, sending this to non-zero will cause the client's avatar to start moving & accelerating

5049

// in that direction, even though we don't model this on the server. Implementing this in the future

5050

// may improve movement smoothness.

5051

// acceleration = new Vector3(1, 0, 0);

5052

5053

angularVelocity = presence.AngularVelocity;

5054

rotation = presence.Rotation;

5055

5056

if (sendTexture)

5057

textureEntry = presence.Appearance.Texture.GetBytes();

5058

else

5059

textureEntry = null;

}

else

{

SceneObjectPart part = (SceneObjectPart)entity;

5064

5065

attachPoint = part.ParentGroup.AttachmentPoint;

5066

attachPoint = ((attachPoint % 16) * 16 + (attachPoint / 16));

5067

// m_log.DebugFormat(

5068

// "[LLCLIENTVIEW]: Sending attachPoint {0} for {1} {2} to {3}",

5069

// attachPoint, part.Name, part.LocalId, Name);

5070

5071

collisionPlane = Vector4.Zero;

5072

position = part.RelativePosition;

5073

velocity = part.Velocity;

5074

acceleration = part.Acceleration;

5075

angularVelocity = part.AngularVelocity;

5076

rotation = part.RotationOffset;

5077

5078

if (sendTexture)

5079

textureEntry = part.Shape.TextureEntry;

5080

else

5081

textureEntry = null;

5082

}

5083

5084

#endregion ScenePresence/SOP Handling

5085

5086

int pos = 0;

5087

byte[] data = new byte[(avatar ? 60 : 44)];

5088

5089

// LocalID

5090

Utils.UIntToBytes(localID, data, pos);

5091

pos += 4;

5092

5093

// Avatar/CollisionPlane

5094

data[pos++] = (byte) attachPoint;

if (avatar)

{

data[pos++] = 1;

if (collisionPlane == Vector4.Zero)

5100

collisionPlane = Vector4.UnitW;

5101

//m_log.DebugFormat("CollisionPlane: {0}",collisionPlane);

5102

collisionPlane.ToBytes(data, pos);

pos += 16;

}

else

{

++pos;

}

// Position

position.ToBytes(data, pos);

pos += 12;

// Velocity

Utils.UInt16ToBytes(Utils.FloatToUInt16(velocity.X, -128.0f, 128.0f), data, pos); pos += 2;

5116

Utils.UInt16ToBytes(Utils.FloatToUInt16(velocity.Y, -128.0f, 128.0f), data, pos); pos += 2;

5117

Utils.UInt16ToBytes(Utils.FloatToUInt16(velocity.Z, -128.0f, 128.0f), data, pos); pos += 2;

5118

5119

// Acceleration

5120

Utils.UInt16ToBytes(Utils.FloatToUInt16(acceleration.X, -64.0f, 64.0f), data, pos); pos += 2;

5121

Utils.UInt16ToBytes(Utils.FloatToUInt16(acceleration.Y, -64.0f, 64.0f), data, pos); pos += 2;

5122

Utils.UInt16ToBytes(Utils.FloatToUInt16(acceleration.Z, -64.0f, 64.0f), data, pos); pos += 2;

5123

5124

// Rotation

5125

Utils.UInt16ToBytes(Utils.FloatToUInt16(rotation.X, -1.0f, 1.0f), data, pos); pos += 2;

5126

Utils.UInt16ToBytes(Utils.FloatToUInt16(rotation.Y, -1.0f, 1.0f), data, pos); pos += 2;

5127

Utils.UInt16ToBytes(Utils.FloatToUInt16(rotation.Z, -1.0f, 1.0f), data, pos); pos += 2;

5128

Utils.UInt16ToBytes(Utils.FloatToUInt16(rotation.W, -1.0f, 1.0f), data, pos); pos += 2;

5129

5130

// Angular Velocity

5131

Utils.UInt16ToBytes(Utils.FloatToUInt16(angularVelocity.X, -64.0f, 64.0f), data, pos); pos += 2;

5132

Utils.UInt16ToBytes(Utils.FloatToUInt16(angularVelocity.Y, -64.0f, 64.0f), data, pos); pos += 2;

5133

Utils.UInt16ToBytes(Utils.FloatToUInt16(angularVelocity.Z, -64.0f, 64.0f), data, pos); pos += 2;

5134

5135

ImprovedTerseObjectUpdatePacket.ObjectDataBlock block

5136

= PacketPool.Instance.GetDataBlock<ImprovedTerseObjectUpdatePacket.ObjectDataBlock>();

block.Data = data;

if (textureEntry != null && textureEntry.Length > 0)

5141

{

5142

byte[] teBytesFinal = new byte[textureEntry.Length + 4];

5143

5144

// Texture Length

5145

Utils.IntToBytes(textureEntry.Length, textureEntry, 0);

5146

// Texture

5147

Buffer.BlockCopy(textureEntry, 0, teBytesFinal, 4, textureEntry.Length);

5148

5149

block.TextureEntry = teBytesFinal;

}

else

{

block.TextureEntry = Utils.EmptyBytes;

}

return block;

}

protected ObjectUpdatePacket.ObjectDataBlock CreateAvatarUpdateBlock(ScenePresence data)

5160

{

5161

byte[] objectData = new byte[76];

5162

5163

data.CollisionPlane.ToBytes(objectData, 0);

5164

data.OffsetPosition.ToBytes(objectData, 16);

5165

// data.Velocity.ToBytes(objectData, 28);

5166

// data.Acceleration.ToBytes(objectData, 40);

5167

data.Rotation.ToBytes(objectData, 52);

5168

//data.AngularVelocity.ToBytes(objectData, 64);

5169

5170

ObjectUpdatePacket.ObjectDataBlock update = new ObjectUpdatePacket.ObjectDataBlock();

5171

5172

update.Data = Utils.EmptyBytes;

5173

update.ExtraParams = new byte[1];

5174

update.FullID = data.UUID;

5175

update.ID = data.LocalId;

5176

update.Material = (byte)Material.Flesh;

5177

update.MediaURL = Utils.EmptyBytes;

5178

            update.NameValue = Utils.StringToBytes("FirstName STRING RW SV " + data.Firstname + "\nLastName STRING RW SV " +

5179

data.Lastname + "\nTitle STRING RW SV " + data.Grouptitle);

5180

update.ObjectData = objectData;

5181

update.ParentID = data.ParentID;

5182

update.PathCurve = 16;

5183

update.PathScaleX = 100;

5184

update.PathScaleY = 100;

5185

update.PCode = (byte)PCode.Avatar;

5186

update.ProfileCurve = 1;

5187

update.PSBlock = Utils.EmptyBytes;

5188

update.Scale = new Vector3(0.45f, 0.6f, 1.9f);

5189

update.Text = Utils.EmptyBytes;

5190

update.TextColor = new byte[4];

5191

5192

// Don't send texture anim for avatars - this has no meaning for them.

5193

update.TextureAnim = Utils.EmptyBytes;

5194

5195

// Don't send texture entry for avatars here - this is accomplished via the AvatarAppearance packet

5196

update.TextureEntry = Utils.EmptyBytes;

5197

//            update.TextureEntry = (data.Appearance.Texture != null) ? data.Appearance.Texture.GetBytes() : Utils.EmptyBytes;

5198

5199

update.UpdateFlags = (uint)(

5200

PrimFlags.Physics | PrimFlags.ObjectModify | PrimFlags.ObjectCopy | PrimFlags.ObjectAnyOwner |

5201

PrimFlags.ObjectYouOwner | PrimFlags.ObjectMove | PrimFlags.InventoryEmpty | PrimFlags.ObjectTransfer |

5202

PrimFlags.ObjectOwnerModify);

return update;

}

protected ObjectUpdatePacket.ObjectDataBlock CreatePrimUpdateBlock(SceneObjectPart data, UUID recipientID)

5208

{

5209

byte[] objectData = new byte[60];

5210

data.RelativePosition.ToBytes(objectData, 0);

5211

data.Velocity.ToBytes(objectData, 12);

5212

data.Acceleration.ToBytes(objectData, 24);

5213

try

5214

{

5215

data.RotationOffset.ToBytes(objectData, 36);

5216

}

5217

catch (Exception e)

5218

{

5219

                m_log.Warn("[LLClientView]: exception converting quaternion to bytes, using Quaternion.Identity. Exception: " + e.ToString());

5220

OpenMetaverse.Quaternion.Identity.ToBytes(objectData, 36);

5221

}

5222

data.AngularVelocity.ToBytes(objectData, 48);

5223

5224

ObjectUpdatePacket.ObjectDataBlock update = new ObjectUpdatePacket.ObjectDataBlock();

5225

update.ClickAction = (byte)data.ClickAction;

5226

update.CRC = 0;

5227

update.ExtraParams = data.Shape.ExtraParams ?? Utils.EmptyBytes;

5228

update.FullID = data.UUID;

5229

update.ID = data.LocalId;

5230

//update.JointAxisOrAnchor = Vector3.Zero; // These are deprecated

5231

//update.JointPivot = Vector3.Zero;

5232

//update.JointType = 0;

5233

update.Material = data.Material;

5234

update.MediaURL = Utils.EmptyBytes; // FIXME: Support this in OpenSim

5235

if (data.ParentGroup.IsAttachment)

5236

{

5237

update.NameValue = Util.StringToBytes256("AttachItemID STRING RW SV " + data.ParentGroup.FromItemID);

5238

                update.State = (byte)((data.ParentGroup.AttachmentPoint % 16) * 16 + (data.ParentGroup.AttachmentPoint / 16));

}

else

{

update.NameValue = Utils.EmptyBytes;

5243

5244

// The root part state is the canonical state for all parts of the object. The other part states in the

5245

// case for attachments may contain conflicting values that can end up crashing the viewer.

5246

update.State = data.ParentGroup.RootPart.Shape.State;

5247

}

5248

5249

// m_log.DebugFormat(

5250

// "[LLCLIENTVIEW]: Sending state {0} for {1} {2} to {3}",

5251

// update.State, data.Name, data.LocalId, Name);

5252

5253

update.ObjectData = objectData;

5254

update.ParentID = data.ParentID;

5255

update.PathBegin = data.Shape.PathBegin;

5256

update.PathCurve = data.Shape.PathCurve;

5257

update.PathEnd = data.Shape.PathEnd;

5258

update.PathRadiusOffset = data.Shape.PathRadiusOffset;

5259

update.PathRevolutions = data.Shape.PathRevolutions;

5260

update.PathScaleX = data.Shape.PathScaleX;

5261

update.PathScaleY = data.Shape.PathScaleY;

5262

update.PathShearX = data.Shape.PathShearX;

5263

update.PathShearY = data.Shape.PathShearY;

5264

update.PathSkew = data.Shape.PathSkew;

5265

update.PathTaperX = data.Shape.PathTaperX;

5266

update.PathTaperY = data.Shape.PathTaperY;

5267

update.PathTwist = data.Shape.PathTwist;

5268

update.PathTwistBegin = data.Shape.PathTwistBegin;

5269

update.PCode = data.Shape.PCode;

5270

update.ProfileBegin = data.Shape.ProfileBegin;

5271

update.ProfileCurve = data.Shape.ProfileCurve;

5272

update.ProfileEnd = data.Shape.ProfileEnd;

5273

update.ProfileHollow = data.Shape.ProfileHollow;

5274

update.PSBlock = data.ParticleSystem ?? Utils.EmptyBytes;

5275

update.TextColor = data.GetTextColor().GetBytes(false);

5276

update.TextureAnim = data.TextureAnimation ?? Utils.EmptyBytes;

5277

update.TextureEntry = data.Shape.TextureEntry ?? Utils.EmptyBytes;

5278

update.Scale = data.Shape.Scale;

5279

update.Text = Util.StringToBytes256(data.Text);

5280

update.MediaURL = Util.StringToBytes256(data.MediaUrl);

#region PrimFlags

PrimFlags flags = (PrimFlags)m_scene.Permissions.GenerateClientFlags(recipientID, data.UUID);

5285

5286

// Don't send the CreateSelected flag to everyone

5287

flags &= ~PrimFlags.CreateSelected;

5288

5289

if (recipientID == data.OwnerID)

5290

{

5291

if (data.CreateSelected)

5292

{

5293

// Only send this flag once, then unset it

5294

flags |= PrimFlags.CreateSelected;

5295

data.CreateSelected = false;

}

}

// m_log.DebugFormat(

5300

// "[LLCLIENTVIEW]: Constructing client update for part {0} {1} with flags {2}, localId {3}",

5301

// data.Name, update.FullID, flags, update.ID);

5302

5303

update.UpdateFlags = (uint)flags;

5304

5305

#endregion PrimFlags

5306

5307

if (data.Sound != UUID.Zero)

5308

{

5309

update.Sound = data.Sound;

5310

update.OwnerID = data.OwnerID;

5311

update.Gain = (float)data.SoundGain;

5312

update.Radius = (float)data.SoundRadius;

5313

update.Flags = data.SoundFlags;

5314

}

5315

5316

switch ((PCode)data.Shape.PCode)

{

case PCode.Grass:

case PCode.Tree:

case PCode.NewTree:

5321

update.Data = new byte[] { data.Shape.State };

5322

break;

5323

default:

5324

update.Data = Utils.EmptyBytes;

break;

}

return update;

}

        protected ObjectUpdateCompressedPacket.ObjectDataBlock CreateCompressedUpdateBlock(SceneObjectPart part, PrimUpdateFlags updateFlags)

5332

{

5333

// TODO: Implement this

return null;

}

public void SendNameReply(UUID profileId, string firstname, string lastname)

5338

{

5339

UUIDNameReplyPacket packet = (UUIDNameReplyPacket)PacketPool.Instance.GetPacket(PacketType.UUIDNameReply);

5340

// TODO: don't create new blocks if recycling an old packet

5341

packet.UUIDNameBlock = new UUIDNameReplyPacket.UUIDNameBlockBlock[1];

5342

packet.UUIDNameBlock[0] = new UUIDNameReplyPacket.UUIDNameBlockBlock();

5343

packet.UUIDNameBlock[0].ID = profileId;

5344

packet.UUIDNameBlock[0].FirstName = Util.StringToBytes256(firstname);

5345

packet.UUIDNameBlock[0].LastName = Util.StringToBytes256(lastname);

5346

5347

OutPacket(packet, ThrottleOutPacketType.Task);

5348

}

5349

5350

public ulong GetGroupPowers(UUID groupID)

5351

{

5352

if (groupID == m_activeGroupID)

5353

return m_activeGroupPowers;

5354

5355

if (m_groupPowers.ContainsKey(groupID))

5356

return m_groupPowers[groupID];

return 0;

}

#endregion

/// <summary>

/// This is a different way of processing packets then ProcessInPacket

5365

/// </summary>

5366

protected virtual void RegisterLocalPacketHandlers()

5367

{

5368

AddLocalPacketHandler(PacketType.LogoutRequest, HandleLogout);

5369

5370

// If AgentUpdate is ever handled asynchronously, then we will also need to construct a new AgentUpdateArgs

5371

// for each AgentUpdate packet.

5372

AddLocalPacketHandler(PacketType.AgentUpdate, HandleAgentUpdate, false);

5373

5374

AddLocalPacketHandler(PacketType.ViewerEffect, HandleViewerEffect, false);

5375

AddLocalPacketHandler(PacketType.AgentCachedTexture, HandleAgentTextureCached, false);

5376

AddLocalPacketHandler(PacketType.MultipleObjectUpdate, HandleMultipleObjUpdate, false);

5377

AddLocalPacketHandler(PacketType.MoneyTransferRequest, HandleMoneyTransferRequest, false);

5378

AddLocalPacketHandler(PacketType.ParcelBuy, HandleParcelBuyRequest, false);

5379

AddLocalPacketHandler(PacketType.UUIDGroupNameRequest, HandleUUIDGroupNameRequest);

5380

AddLocalPacketHandler(PacketType.ObjectGroup, HandleObjectGroupRequest);

5381

AddLocalPacketHandler(PacketType.GenericMessage, HandleGenericMessage);

5382

AddLocalPacketHandler(PacketType.AvatarPropertiesRequest, HandleAvatarPropertiesRequest);

5383

AddLocalPacketHandler(PacketType.ChatFromViewer, HandleChatFromViewer);

5384

AddLocalPacketHandler(PacketType.AvatarPropertiesUpdate, HandlerAvatarPropertiesUpdate);

5385

AddLocalPacketHandler(PacketType.ScriptDialogReply, HandlerScriptDialogReply);

5386

AddLocalPacketHandler(PacketType.ImprovedInstantMessage, HandlerImprovedInstantMessage);

5387

AddLocalPacketHandler(PacketType.AcceptFriendship, HandlerAcceptFriendship);

5388

AddLocalPacketHandler(PacketType.DeclineFriendship, HandlerDeclineFriendship);

5389

AddLocalPacketHandler(PacketType.TerminateFriendship, HandlerTerminateFriendship);

5390

AddLocalPacketHandler(PacketType.RezObject, HandlerRezObject);

5391

AddLocalPacketHandler(PacketType.DeRezObject, HandlerDeRezObject);

5392

AddLocalPacketHandler(PacketType.ModifyLand, HandlerModifyLand);

5393

AddLocalPacketHandler(PacketType.RegionHandshakeReply, HandlerRegionHandshakeReply, false);

5394

AddLocalPacketHandler(PacketType.AgentWearablesRequest, HandlerAgentWearablesRequest);

5395

AddLocalPacketHandler(PacketType.AgentSetAppearance, HandlerAgentSetAppearance);

5396

AddLocalPacketHandler(PacketType.AgentIsNowWearing, HandlerAgentIsNowWearing);

5397

AddLocalPacketHandler(PacketType.RezSingleAttachmentFromInv, HandlerRezSingleAttachmentFromInv);

5398

AddLocalPacketHandler(PacketType.RezMultipleAttachmentsFromInv, HandleRezMultipleAttachmentsFromInv);

5399

AddLocalPacketHandler(PacketType.DetachAttachmentIntoInv, HandleDetachAttachmentIntoInv);

5400

AddLocalPacketHandler(PacketType.ObjectAttach, HandleObjectAttach);

5401

AddLocalPacketHandler(PacketType.ObjectDetach, HandleObjectDetach);

5402

AddLocalPacketHandler(PacketType.ObjectDrop, HandleObjectDrop);

5403

AddLocalPacketHandler(PacketType.SetAlwaysRun, HandleSetAlwaysRun, false);

5404

AddLocalPacketHandler(PacketType.CompleteAgentMovement, HandleCompleteAgentMovement);

5405

AddLocalPacketHandler(PacketType.AgentAnimation, HandleAgentAnimation, false);

5406

AddLocalPacketHandler(PacketType.AgentRequestSit, HandleAgentRequestSit);

5407

AddLocalPacketHandler(PacketType.AgentSit, HandleAgentSit);

5408

AddLocalPacketHandler(PacketType.SoundTrigger, HandleSoundTrigger);

5409

AddLocalPacketHandler(PacketType.AvatarPickerRequest, HandleAvatarPickerRequest);

5410

AddLocalPacketHandler(PacketType.AgentDataUpdateRequest, HandleAgentDataUpdateRequest);

5411

AddLocalPacketHandler(PacketType.UserInfoRequest, HandleUserInfoRequest);

5412

AddLocalPacketHandler(PacketType.UpdateUserInfo, HandleUpdateUserInfo);

5413

AddLocalPacketHandler(PacketType.SetStartLocationRequest, HandleSetStartLocationRequest);

5414

AddLocalPacketHandler(PacketType.AgentThrottle, HandleAgentThrottle, false);

5415

AddLocalPacketHandler(PacketType.AgentPause, HandleAgentPause, false);

5416

AddLocalPacketHandler(PacketType.AgentResume, HandleAgentResume, false);

5417

AddLocalPacketHandler(PacketType.ForceScriptControlRelease, HandleForceScriptControlRelease);

5418

AddLocalPacketHandler(PacketType.ObjectLink, HandleObjectLink);

5419

AddLocalPacketHandler(PacketType.ObjectDelink, HandleObjectDelink);

5420

AddLocalPacketHandler(PacketType.ObjectAdd, HandleObjectAdd);

5421

AddLocalPacketHandler(PacketType.ObjectShape, HandleObjectShape);

5422

AddLocalPacketHandler(PacketType.ObjectExtraParams, HandleObjectExtraParams);

5423

AddLocalPacketHandler(PacketType.ObjectDuplicate, HandleObjectDuplicate);

5424

AddLocalPacketHandler(PacketType.RequestMultipleObjects, HandleRequestMultipleObjects);

5425

AddLocalPacketHandler(PacketType.ObjectSelect, HandleObjectSelect);

5426

AddLocalPacketHandler(PacketType.ObjectDeselect, HandleObjectDeselect);

5427

AddLocalPacketHandler(PacketType.ObjectPosition, HandleObjectPosition);

5428

AddLocalPacketHandler(PacketType.ObjectScale, HandleObjectScale);

5429

AddLocalPacketHandler(PacketType.ObjectRotation, HandleObjectRotation);

5430

AddLocalPacketHandler(PacketType.ObjectFlagUpdate, HandleObjectFlagUpdate);

5431

5432

// Handle ObjectImage (TextureEntry) updates synchronously, since when updating multiple prim faces at once,

5433

// some clients will send out a separate ObjectImage packet for each face

5434

AddLocalPacketHandler(PacketType.ObjectImage, HandleObjectImage, false);

5435

5436

AddLocalPacketHandler(PacketType.ObjectGrab, HandleObjectGrab, false);

5437

AddLocalPacketHandler(PacketType.ObjectGrabUpdate, HandleObjectGrabUpdate, false);

5438

AddLocalPacketHandler(PacketType.ObjectDeGrab, HandleObjectDeGrab);

5439

AddLocalPacketHandler(PacketType.ObjectSpinStart, HandleObjectSpinStart, false);

5440

AddLocalPacketHandler(PacketType.ObjectSpinUpdate, HandleObjectSpinUpdate, false);

5441

AddLocalPacketHandler(PacketType.ObjectSpinStop, HandleObjectSpinStop, false);

5442

AddLocalPacketHandler(PacketType.ObjectDescription, HandleObjectDescription, false);

5443

AddLocalPacketHandler(PacketType.ObjectName, HandleObjectName, false);

5444

AddLocalPacketHandler(PacketType.ObjectPermissions, HandleObjectPermissions, false);

5445

AddLocalPacketHandler(PacketType.Undo, HandleUndo, false);

5446

AddLocalPacketHandler(PacketType.UndoLand, HandleLandUndo, false);

5447

AddLocalPacketHandler(PacketType.Redo, HandleRedo, false);

5448

AddLocalPacketHandler(PacketType.ObjectDuplicateOnRay, HandleObjectDuplicateOnRay);

5449

AddLocalPacketHandler(PacketType.RequestObjectPropertiesFamily, HandleRequestObjectPropertiesFamily, false);

5450

AddLocalPacketHandler(PacketType.ObjectIncludeInSearch, HandleObjectIncludeInSearch);

5451

AddLocalPacketHandler(PacketType.ScriptAnswerYes, HandleScriptAnswerYes, false);

5452

AddLocalPacketHandler(PacketType.ObjectClickAction, HandleObjectClickAction, false);

5453

AddLocalPacketHandler(PacketType.ObjectMaterial, HandleObjectMaterial, false);

5454

AddLocalPacketHandler(PacketType.RequestImage, HandleRequestImage, false);

5455

AddLocalPacketHandler(PacketType.TransferRequest, HandleTransferRequest, false);

5456

AddLocalPacketHandler(PacketType.AssetUploadRequest, HandleAssetUploadRequest);

5457

AddLocalPacketHandler(PacketType.RequestXfer, HandleRequestXfer);

5458

AddLocalPacketHandler(PacketType.SendXferPacket, HandleSendXferPacket);

5459

AddLocalPacketHandler(PacketType.ConfirmXferPacket, HandleConfirmXferPacket);

5460

AddLocalPacketHandler(PacketType.AbortXfer, HandleAbortXfer);

5461

AddLocalPacketHandler(PacketType.CreateInventoryFolder, HandleCreateInventoryFolder);

5462

AddLocalPacketHandler(PacketType.UpdateInventoryFolder, HandleUpdateInventoryFolder);

5463

AddLocalPacketHandler(PacketType.MoveInventoryFolder, HandleMoveInventoryFolder);

5464

AddLocalPacketHandler(PacketType.CreateInventoryItem, HandleCreateInventoryItem);

5465

AddLocalPacketHandler(PacketType.LinkInventoryItem, HandleLinkInventoryItem);

5466

AddLocalPacketHandler(PacketType.FetchInventory, HandleFetchInventory);

5467

AddLocalPacketHandler(PacketType.FetchInventoryDescendents, HandleFetchInventoryDescendents);

5468

AddLocalPacketHandler(PacketType.PurgeInventoryDescendents, HandlePurgeInventoryDescendents);

5469

AddLocalPacketHandler(PacketType.UpdateInventoryItem, HandleUpdateInventoryItem);

5470

AddLocalPacketHandler(PacketType.CopyInventoryItem, HandleCopyInventoryItem);

5471

AddLocalPacketHandler(PacketType.MoveInventoryItem, HandleMoveInventoryItem);

5472

AddLocalPacketHandler(PacketType.RemoveInventoryItem, HandleRemoveInventoryItem);

5473

AddLocalPacketHandler(PacketType.RemoveInventoryFolder, HandleRemoveInventoryFolder);

5474

AddLocalPacketHandler(PacketType.RemoveInventoryObjects, HandleRemoveInventoryObjects);

5475

AddLocalPacketHandler(PacketType.RequestTaskInventory, HandleRequestTaskInventory);

5476

AddLocalPacketHandler(PacketType.UpdateTaskInventory, HandleUpdateTaskInventory);

5477

AddLocalPacketHandler(PacketType.RemoveTaskInventory, HandleRemoveTaskInventory);

5478

AddLocalPacketHandler(PacketType.MoveTaskInventory, HandleMoveTaskInventory);

5479

AddLocalPacketHandler(PacketType.RezScript, HandleRezScript);

5480

AddLocalPacketHandler(PacketType.MapLayerRequest, HandleMapLayerRequest);

5481

AddLocalPacketHandler(PacketType.MapBlockRequest, HandleMapBlockRequest);

5482

AddLocalPacketHandler(PacketType.MapNameRequest, HandleMapNameRequest);

5483

AddLocalPacketHandler(PacketType.TeleportLandmarkRequest, HandleTeleportLandmarkRequest);

5484

AddLocalPacketHandler(PacketType.TeleportCancel, HandleTeleportCancel);

5485

AddLocalPacketHandler(PacketType.TeleportLocationRequest, HandleTeleportLocationRequest);

5486

AddLocalPacketHandler(PacketType.UUIDNameRequest, HandleUUIDNameRequest, false);

5487

AddLocalPacketHandler(PacketType.RegionHandleRequest, HandleRegionHandleRequest, false);

5488

AddLocalPacketHandler(PacketType.ParcelInfoRequest, HandleParcelInfoRequest);

5489

AddLocalPacketHandler(PacketType.ParcelAccessListRequest, HandleParcelAccessListRequest, false);

5490

AddLocalPacketHandler(PacketType.ParcelAccessListUpdate, HandleParcelAccessListUpdate, false);

5491

AddLocalPacketHandler(PacketType.ParcelPropertiesRequest, HandleParcelPropertiesRequest, false);

5492

AddLocalPacketHandler(PacketType.ParcelDivide, HandleParcelDivide);

5493

AddLocalPacketHandler(PacketType.ParcelJoin, HandleParcelJoin);

5494

AddLocalPacketHandler(PacketType.ParcelPropertiesUpdate, HandleParcelPropertiesUpdate);

5495

AddLocalPacketHandler(PacketType.ParcelSelectObjects, HandleParcelSelectObjects);

5496

AddLocalPacketHandler(PacketType.ParcelObjectOwnersRequest, HandleParcelObjectOwnersRequest);

5497

AddLocalPacketHandler(PacketType.ParcelGodForceOwner, HandleParcelGodForceOwner);

5498

AddLocalPacketHandler(PacketType.ParcelRelease, HandleParcelRelease);

5499

AddLocalPacketHandler(PacketType.ParcelReclaim, HandleParcelReclaim);

5500

AddLocalPacketHandler(PacketType.ParcelReturnObjects, HandleParcelReturnObjects);

5501

AddLocalPacketHandler(PacketType.ParcelSetOtherCleanTime, HandleParcelSetOtherCleanTime);

5502

AddLocalPacketHandler(PacketType.LandStatRequest, HandleLandStatRequest);

5503

AddLocalPacketHandler(PacketType.ParcelDwellRequest, HandleParcelDwellRequest);

5504

AddLocalPacketHandler(PacketType.EstateOwnerMessage, HandleEstateOwnerMessage);

5505

AddLocalPacketHandler(PacketType.RequestRegionInfo, HandleRequestRegionInfo, false);

5506

AddLocalPacketHandler(PacketType.EstateCovenantRequest, HandleEstateCovenantRequest);

5507

AddLocalPacketHandler(PacketType.RequestGodlikePowers, HandleRequestGodlikePowers);

5508

AddLocalPacketHandler(PacketType.GodKickUser, HandleGodKickUser);

5509

AddLocalPacketHandler(PacketType.MoneyBalanceRequest, HandleMoneyBalanceRequest);

5510

AddLocalPacketHandler(PacketType.EconomyDataRequest, HandleEconomyDataRequest);

5511

AddLocalPacketHandler(PacketType.RequestPayPrice, HandleRequestPayPrice);

5512

AddLocalPacketHandler(PacketType.ObjectSaleInfo, HandleObjectSaleInfo);

5513

AddLocalPacketHandler(PacketType.ObjectBuy, HandleObjectBuy);

5514

AddLocalPacketHandler(PacketType.GetScriptRunning, HandleGetScriptRunning);

5515

AddLocalPacketHandler(PacketType.SetScriptRunning, HandleSetScriptRunning);

5516

AddLocalPacketHandler(PacketType.ScriptReset, HandleScriptReset);

5517

AddLocalPacketHandler(PacketType.ActivateGestures, HandleActivateGestures);

5518

AddLocalPacketHandler(PacketType.DeactivateGestures, HandleDeactivateGestures);

5519

AddLocalPacketHandler(PacketType.ObjectOwner, HandleObjectOwner);

5520

AddLocalPacketHandler(PacketType.AgentFOV, HandleAgentFOV, false);

5521

AddLocalPacketHandler(PacketType.ViewerStats, HandleViewerStats);

5522

AddLocalPacketHandler(PacketType.MapItemRequest, HandleMapItemRequest, false);

5523

AddLocalPacketHandler(PacketType.TransferAbort, HandleTransferAbort, false);

5524

AddLocalPacketHandler(PacketType.MuteListRequest, HandleMuteListRequest, false);

5525

AddLocalPacketHandler(PacketType.UseCircuitCode, HandleUseCircuitCode);

5526

AddLocalPacketHandler(PacketType.AgentHeightWidth, HandleAgentHeightWidth, false);

5527

AddLocalPacketHandler(PacketType.InventoryDescendents, HandleInventoryDescendents);

5528

AddLocalPacketHandler(PacketType.DirPlacesQuery, HandleDirPlacesQuery);

5529

AddLocalPacketHandler(PacketType.DirFindQuery, HandleDirFindQuery);

5530

AddLocalPacketHandler(PacketType.DirLandQuery, HandleDirLandQuery);

5531

AddLocalPacketHandler(PacketType.DirPopularQuery, HandleDirPopularQuery);

5532

AddLocalPacketHandler(PacketType.DirClassifiedQuery, HandleDirClassifiedQuery);

5533

AddLocalPacketHandler(PacketType.EventInfoRequest, HandleEventInfoRequest);

5534

AddLocalPacketHandler(PacketType.OfferCallingCard, HandleOfferCallingCard);

5535

AddLocalPacketHandler(PacketType.AcceptCallingCard, HandleAcceptCallingCard);

5536

AddLocalPacketHandler(PacketType.DeclineCallingCard, HandleDeclineCallingCard);

5537

AddLocalPacketHandler(PacketType.ActivateGroup, HandleActivateGroup);

5538

AddLocalPacketHandler(PacketType.GroupTitlesRequest, HandleGroupTitlesRequest);

5539

AddLocalPacketHandler(PacketType.GroupProfileRequest, HandleGroupProfileRequest);

5540

AddLocalPacketHandler(PacketType.GroupMembersRequest, HandleGroupMembersRequest);

5541

AddLocalPacketHandler(PacketType.GroupRoleDataRequest, HandleGroupRoleDataRequest);

5542

AddLocalPacketHandler(PacketType.GroupRoleMembersRequest, HandleGroupRoleMembersRequest);

5543

AddLocalPacketHandler(PacketType.CreateGroupRequest, HandleCreateGroupRequest);

5544

AddLocalPacketHandler(PacketType.UpdateGroupInfo, HandleUpdateGroupInfo);

5545

AddLocalPacketHandler(PacketType.SetGroupAcceptNotices, HandleSetGroupAcceptNotices);

5546

AddLocalPacketHandler(PacketType.GroupTitleUpdate, HandleGroupTitleUpdate);

5547

AddLocalPacketHandler(PacketType.ParcelDeedToGroup, HandleParcelDeedToGroup);

5548

AddLocalPacketHandler(PacketType.GroupNoticesListRequest, HandleGroupNoticesListRequest);

5549

AddLocalPacketHandler(PacketType.GroupNoticeRequest, HandleGroupNoticeRequest);

5550

AddLocalPacketHandler(PacketType.GroupRoleUpdate, HandleGroupRoleUpdate);

5551

AddLocalPacketHandler(PacketType.GroupRoleChanges, HandleGroupRoleChanges);

5552

AddLocalPacketHandler(PacketType.JoinGroupRequest, HandleJoinGroupRequest);

5553

AddLocalPacketHandler(PacketType.LeaveGroupRequest, HandleLeaveGroupRequest);

5554

AddLocalPacketHandler(PacketType.EjectGroupMemberRequest, HandleEjectGroupMemberRequest);

5555

AddLocalPacketHandler(PacketType.InviteGroupRequest, HandleInviteGroupRequest);

5556

AddLocalPacketHandler(PacketType.StartLure, HandleStartLure);

5557

AddLocalPacketHandler(PacketType.TeleportLureRequest, HandleTeleportLureRequest);

5558

AddLocalPacketHandler(PacketType.ClassifiedInfoRequest, HandleClassifiedInfoRequest);

5559

AddLocalPacketHandler(PacketType.ClassifiedInfoUpdate, HandleClassifiedInfoUpdate);

5560

AddLocalPacketHandler(PacketType.ClassifiedDelete, HandleClassifiedDelete);

5561

AddLocalPacketHandler(PacketType.ClassifiedGodDelete, HandleClassifiedGodDelete);

5562

AddLocalPacketHandler(PacketType.EventGodDelete, HandleEventGodDelete);

5563

AddLocalPacketHandler(PacketType.EventNotificationAddRequest, HandleEventNotificationAddRequest);

5564

AddLocalPacketHandler(PacketType.EventNotificationRemoveRequest, HandleEventNotificationRemoveRequest);

5565

AddLocalPacketHandler(PacketType.RetrieveInstantMessages, HandleRetrieveInstantMessages);

5566

AddLocalPacketHandler(PacketType.PickDelete, HandlePickDelete);

5567

AddLocalPacketHandler(PacketType.PickGodDelete, HandlePickGodDelete);

5568

AddLocalPacketHandler(PacketType.PickInfoUpdate, HandlePickInfoUpdate);

5569

AddLocalPacketHandler(PacketType.AvatarNotesUpdate, HandleAvatarNotesUpdate);

5570

AddLocalPacketHandler(PacketType.AvatarInterestsUpdate, HandleAvatarInterestsUpdate);

5571

AddLocalPacketHandler(PacketType.GrantUserRights, HandleGrantUserRights);

5572

AddLocalPacketHandler(PacketType.PlacesQuery, HandlePlacesQuery);

5573

AddLocalPacketHandler(PacketType.UpdateMuteListEntry, HandleUpdateMuteListEntry);

5574

AddLocalPacketHandler(PacketType.RemoveMuteListEntry, HandleRemoveMuteListEntry);

5575

AddLocalPacketHandler(PacketType.UserReport, HandleUserReport);

5576

AddLocalPacketHandler(PacketType.FindAgent, HandleFindAgent);

5577

AddLocalPacketHandler(PacketType.TrackAgent, HandleTrackAgent);

5578

AddLocalPacketHandler(PacketType.GodUpdateRegionInfo, HandleGodUpdateRegionInfoUpdate);

5579

AddLocalPacketHandler(PacketType.GodlikeMessage, HandleGodlikeMessage);

5580

AddLocalPacketHandler(PacketType.StateSave, HandleSaveStatePacket);

5581

AddLocalPacketHandler(PacketType.GroupAccountDetailsRequest, HandleGroupAccountDetailsRequest);

5582

AddLocalPacketHandler(PacketType.GroupAccountSummaryRequest, HandleGroupAccountSummaryRequest);

5583

AddLocalPacketHandler(PacketType.GroupAccountTransactionsRequest, HandleGroupTransactionsDetailsRequest);

5584

AddLocalPacketHandler(PacketType.FreezeUser, HandleFreezeUser);

5585

AddLocalPacketHandler(PacketType.EjectUser, HandleEjectUser);

5586

AddLocalPacketHandler(PacketType.ParcelBuyPass, HandleParcelBuyPass);

5587

AddLocalPacketHandler(PacketType.ParcelGodMarkAsContent, HandleParcelGodMarkAsContent);

5588

AddLocalPacketHandler(PacketType.GroupActiveProposalsRequest, HandleGroupActiveProposalsRequest);

5589

AddLocalPacketHandler(PacketType.GroupVoteHistoryRequest, HandleGroupVoteHistoryRequest);

5590

AddLocalPacketHandler(PacketType.SimWideDeletes, HandleSimWideDeletes);

5591

AddLocalPacketHandler(PacketType.SendPostcard, HandleSendPostcard);

5592

5593

AddGenericPacketHandler("autopilot", HandleAutopilot);

5594

}

5595

5596

#region Packet Handlers

5597

5598

public int TotalAgentUpdates { get; set; }

5599

5600

#region Scene/Avatar

5601

5602

// Threshold for body rotation to be a significant agent update

5603

private const float QDELTA = 0.000001f;

5604

// Threshold for camera rotation to be a significant agent update

5605

private const float VDELTA = 0.01f;

5606

5607

/// <summary>

5608

/// This checks the update significance against the last update made.

5609

/// </summary>

5610

/// <remarks>Can only be called by one thread at a time</remarks>

5611

/// <returns></returns>

5612

/// <param name='x'></param>

5613

public bool CheckAgentUpdateSignificance(AgentUpdatePacket.AgentDataBlock x)

5614

{

5615

return CheckAgentMovementUpdateSignificance(x) || CheckAgentCameraUpdateSignificance(x);

}

/// <summary>

/// This checks the movement/state update significance against the last update made.

5620

/// </summary>

5621

/// <remarks>Can only be called by one thread at a time</remarks>

5622

/// <returns></returns>

5623

/// <param name='x'></param>

5624

private bool CheckAgentMovementUpdateSignificance(AgentUpdatePacket.AgentDataBlock x)

5625

{

5626

float qdelta1 = 1 - (float)Math.Pow(Quaternion.Dot(x.BodyRotation, m_thisAgentUpdateArgs.BodyRotation), 2);

5627

//qdelta2 = 1 - (float)Math.Pow(Quaternion.Dot(x.HeadRotation, m_thisAgentUpdateArgs.HeadRotation), 2);

5628

5629

bool movementSignificant =

5630

                (qdelta1 > QDELTA)                                          // significant if body rotation above threshold

5631

// Ignoring head rotation altogether, because it's not being used for anything interesting up the stack

5632

                // || (qdelta2 > QDELTA * 10)                               // significant if head rotation above threshold

5633

|| (x.ControlFlags != m_thisAgentUpdateArgs.ControlFlags) // significant if control flags changed

5634

                || (x.ControlFlags != (byte)AgentManager.ControlFlags.NONE) // significant if user supplying any movement update commands

5635

|| (x.Far != m_thisAgentUpdateArgs.Far) // significant if far distance changed

5636

|| (x.Flags != m_thisAgentUpdateArgs.Flags) // significant if Flags changed

5637

|| (x.State != m_thisAgentUpdateArgs.State) // significant if Stats changed

5638

;

5639

//if (movementSignificant)

5640

//{

5641

//m_log.DebugFormat("[LLCLIENTVIEW]: Bod {0} {1}",

5642

// qdelta1, qdelta2);

5643

//m_log.DebugFormat("[LLCLIENTVIEW]: St {0} {1} {2} {3}",

5644

// x.ControlFlags, x.Flags, x.Far, x.State);

5645

//}

5646

return movementSignificant;

}

/// <summary>

/// This checks the camera update significance against the last update made.

5651

/// </summary>

5652

/// <remarks>Can only be called by one thread at a time</remarks>

5653

/// <returns></returns>

5654

/// <param name='x'></param>

5655

private bool CheckAgentCameraUpdateSignificance(AgentUpdatePacket.AgentDataBlock x)

5656

{

5657

float vdelta1 = Vector3.Distance(x.CameraAtAxis, m_thisAgentUpdateArgs.CameraAtAxis);

5658

float vdelta2 = Vector3.Distance(x.CameraCenter, m_thisAgentUpdateArgs.CameraCenter);

5659

float vdelta3 = Vector3.Distance(x.CameraLeftAxis, m_thisAgentUpdateArgs.CameraLeftAxis);

5660

float vdelta4 = Vector3.Distance(x.CameraUpAxis, m_thisAgentUpdateArgs.CameraUpAxis);

5661

5662

bool cameraSignificant =

5663

(vdelta1 > VDELTA) ||

5664

(vdelta2 > VDELTA) ||

5665

(vdelta3 > VDELTA) ||

(vdelta4 > VDELTA)

;

//if (cameraSignificant)

5670

//{

5671

//m_log.DebugFormat("[LLCLIENTVIEW]: Cam1 {0} {1}",

5672

// x.CameraAtAxis, x.CameraCenter);

5673

//m_log.DebugFormat("[LLCLIENTVIEW]: Cam2 {0} {1}",

5674

// x.CameraLeftAxis, x.CameraUpAxis);

5675

//}

5676

5677

return cameraSignificant;

5678

}

5679

5680

private bool HandleAgentUpdate(IClientAPI sener, Packet packet)

5681

{

5682

// We got here, which means that something in agent update was significant

5683

5684

AgentUpdatePacket agentUpdate = (AgentUpdatePacket)packet;

5685

AgentUpdatePacket.AgentDataBlock x = agentUpdate.AgentData;

5686

5687

if (x.AgentID != AgentId || x.SessionID != SessionId)

5688

return false;

5689

5690

// Before we update the current m_thisAgentUpdateArgs, let's check this again

5691

// to see what exactly changed

5692

bool movement = CheckAgentMovementUpdateSignificance(x);

5693

bool camera = CheckAgentCameraUpdateSignificance(x);

5694

5695

m_thisAgentUpdateArgs.AgentID = x.AgentID;

5696

m_thisAgentUpdateArgs.BodyRotation = x.BodyRotation;

5697

m_thisAgentUpdateArgs.CameraAtAxis = x.CameraAtAxis;

5698

m_thisAgentUpdateArgs.CameraCenter = x.CameraCenter;

5699

m_thisAgentUpdateArgs.CameraLeftAxis = x.CameraLeftAxis;

5700

m_thisAgentUpdateArgs.CameraUpAxis = x.CameraUpAxis;

5701

m_thisAgentUpdateArgs.ControlFlags = x.ControlFlags;

5702

m_thisAgentUpdateArgs.Far = x.Far;

5703

m_thisAgentUpdateArgs.Flags = x.Flags;

5704

m_thisAgentUpdateArgs.HeadRotation = x.HeadRotation;

5705

m_thisAgentUpdateArgs.SessionID = x.SessionID;

5706

m_thisAgentUpdateArgs.State = x.State;

5707

5708

UpdateAgent handlerAgentUpdate = OnAgentUpdate;

5709

UpdateAgent handlerPreAgentUpdate = OnPreAgentUpdate;

5710

UpdateAgent handlerAgentCameraUpdate = OnAgentCameraUpdate;

5711

5712

// Was there a significant movement/state change?

5713

if (movement)

5714

{

5715

if (handlerPreAgentUpdate != null)

5716

OnPreAgentUpdate(this, m_thisAgentUpdateArgs);

5717

5718

if (handlerAgentUpdate != null)

5719

OnAgentUpdate(this, m_thisAgentUpdateArgs);

5720

}

5721

// Was there a significant camera(s) change?

5722

if (camera)

5723

if (handlerAgentCameraUpdate != null)

5724

handlerAgentCameraUpdate(this, m_thisAgentUpdateArgs);

5725

5726

handlerAgentUpdate = null;

5727

handlerPreAgentUpdate = null;

5728

handlerAgentCameraUpdate = null;

5729

5730

PacketPool.Instance.ReturnPacket(packet);

return true;

}

private bool HandleMoneyTransferRequest(IClientAPI sender, Packet Pack)

5736

{

5737

MoneyTransferRequestPacket money = (MoneyTransferRequestPacket)Pack;

5738

// validate the agent owns the agentID and sessionID

5739

if (money.MoneyData.SourceID == sender.AgentId && money.AgentData.AgentID == sender.AgentId &&

5740

money.AgentData.SessionID == sender.SessionId)

5741

{

5742

MoneyTransferRequest handlerMoneyTransferRequest = OnMoneyTransferRequest;

5743

if (handlerMoneyTransferRequest != null)

5744

{

5745

handlerMoneyTransferRequest(money.MoneyData.SourceID, money.MoneyData.DestID,

5746

money.MoneyData.Amount, money.MoneyData.TransactionType,

5747

Util.FieldToString(money.MoneyData.Description));

}

return true;

}

return false;

}

private bool HandleParcelGodMarkAsContent(IClientAPI client, Packet Packet)

5757

{

5758

ParcelGodMarkAsContentPacket ParcelGodMarkAsContent =

5759

(ParcelGodMarkAsContentPacket)Packet;

5760

5761

ParcelGodMark ParcelGodMarkAsContentHandler = OnParcelGodMark;

5762

if (ParcelGodMarkAsContentHandler != null)

5763

{

5764

ParcelGodMarkAsContentHandler(this,

5765

ParcelGodMarkAsContent.AgentData.AgentID,

5766

ParcelGodMarkAsContent.ParcelData.LocalID);

return true;

}

return false;

}

private bool HandleFreezeUser(IClientAPI client, Packet Packet)

5773

{

5774

FreezeUserPacket FreezeUser = (FreezeUserPacket)Packet;

5775

5776

FreezeUserUpdate FreezeUserHandler = OnParcelFreezeUser;

5777

if (FreezeUserHandler != null)

5778

{

5779

FreezeUserHandler(this,

5780

FreezeUser.AgentData.AgentID,

5781

FreezeUser.Data.Flags,

5782

FreezeUser.Data.TargetID);

return true;

}

return false;

}

private bool HandleEjectUser(IClientAPI client, Packet Packet)

5789

{

5790

EjectUserPacket EjectUser =

5791

(EjectUserPacket)Packet;

5792

5793

EjectUserUpdate EjectUserHandler = OnParcelEjectUser;

5794

if (EjectUserHandler != null)

5795

{

5796

EjectUserHandler(this,

5797

EjectUser.AgentData.AgentID,

5798

EjectUser.Data.Flags,

5799

EjectUser.Data.TargetID);

return true;

}

return false;

}

private bool HandleParcelBuyPass(IClientAPI client, Packet Packet)

5806

{

5807

ParcelBuyPassPacket ParcelBuyPass =

5808

(ParcelBuyPassPacket)Packet;

5809

5810

ParcelBuyPass ParcelBuyPassHandler = OnParcelBuyPass;

5811

if (ParcelBuyPassHandler != null)

5812

{

5813

ParcelBuyPassHandler(this,

5814

ParcelBuyPass.AgentData.AgentID,

5815

ParcelBuyPass.ParcelData.LocalID);

return true;

}

return false;

}

private bool HandleParcelBuyRequest(IClientAPI sender, Packet Pack)

5822

{

5823

ParcelBuyPacket parcel = (ParcelBuyPacket)Pack;

5824

if (parcel.AgentData.AgentID == AgentId && parcel.AgentData.SessionID == SessionId)

5825

{

5826

ParcelBuy handlerParcelBuy = OnParcelBuy;

5827

if (handlerParcelBuy != null)

5828

{

5829

handlerParcelBuy(parcel.AgentData.AgentID, parcel.Data.GroupID, parcel.Data.Final,

5830

parcel.Data.IsGroupOwned,

5831

parcel.Data.RemoveContribution, parcel.Data.LocalID, parcel.ParcelData.Area,

5832

parcel.ParcelData.Price,

false);

}

return true;

}

return false;

}

private bool HandleUUIDGroupNameRequest(IClientAPI sender, Packet Pack)

5841

{

5842

UUIDGroupNameRequestPacket upack = (UUIDGroupNameRequestPacket)Pack;

5843

5844

5845

for (int i = 0; i < upack.UUIDNameBlock.Length; i++)

5846

{

5847

UUIDNameRequest handlerUUIDGroupNameRequest = OnUUIDGroupNameRequest;

5848

if (handlerUUIDGroupNameRequest != null)

5849

{

5850

handlerUUIDGroupNameRequest(upack.UUIDNameBlock[i].ID, this);

}

}

return true;

}

public bool HandleGenericMessage(IClientAPI sender, Packet pack)

5858

{

5859

GenericMessagePacket gmpack = (GenericMessagePacket)pack;

5860

if (m_genericPacketHandlers.Count == 0) return false;

5861

if (gmpack.AgentData.SessionID != SessionId) return false;

5862

5863

GenericMessage handlerGenericMessage = null;

5864

5865

string method = Util.FieldToString(gmpack.MethodData.Method).ToLower().Trim();

5866

5867

if (m_genericPacketHandlers.TryGetValue(method, out handlerGenericMessage))

5868

{

5869

List<string> msg = new List<string>();

5870

List<byte[]> msgBytes = new List<byte[]>();

5871

5872

if (handlerGenericMessage != null)

5873

{

5874

foreach (GenericMessagePacket.ParamListBlock block in gmpack.ParamList)

5875

{

5876

msg.Add(Util.FieldToString(block.Parameter));

5877

msgBytes.Add(block.Parameter);

}

try

{

if (OnBinaryGenericMessage != null)

5882

{

5883

OnBinaryGenericMessage(this, method, msgBytes.ToArray());

5884

}

5885

handlerGenericMessage(sender, method, msg);

5886

return true;

5887

}

5888

catch (Exception e)

5889

{

5890

m_log.ErrorFormat(

5891

"[LLCLIENTVIEW]: Exeception when handling generic message {0}{1}", e.Message, e.StackTrace);

}

}

}

//m_log.Debug("[LLCLIENTVIEW]: Not handling GenericMessage with method-type of: " + method);

return false;

}

public bool HandleObjectGroupRequest(IClientAPI sender, Packet Pack)

5901

{

5902

ObjectGroupPacket ogpack = (ObjectGroupPacket)Pack;

5903

if (ogpack.AgentData.SessionID != SessionId) return false;

5904

5905

RequestObjectPropertiesFamily handlerObjectGroupRequest = OnObjectGroupRequest;

5906

if (handlerObjectGroupRequest != null)

5907

{

5908

for (int i = 0; i < ogpack.ObjectData.Length; i++)

5909

{

5910

                    handlerObjectGroupRequest(this, ogpack.AgentData.GroupID, ogpack.ObjectData[i].ObjectLocalID, UUID.Zero);

}

}

return true;

}

private bool HandleViewerEffect(IClientAPI sender, Packet Pack)

5917

{

5918

ViewerEffectPacket viewer = (ViewerEffectPacket)Pack;

5919

if (viewer.AgentData.SessionID != SessionId) return false;

5920

ViewerEffectEventHandler handlerViewerEffect = OnViewerEffect;

5921

if (handlerViewerEffect != null)

5922

{

5923

int length = viewer.Effect.Length;

5924

List<ViewerEffectEventHandlerArg> args = new List<ViewerEffectEventHandlerArg>(length);

5925

for (int i = 0; i < length; i++)

5926

{

5927

//copy the effects block arguments into the event handler arg.

5928

ViewerEffectEventHandlerArg argument = new ViewerEffectEventHandlerArg();

5929

argument.AgentID = viewer.Effect[i].AgentID;

5930

argument.Color = viewer.Effect[i].Color;

5931

argument.Duration = viewer.Effect[i].Duration;

5932

argument.ID = viewer.Effect[i].ID;

5933

argument.Type = viewer.Effect[i].Type;

5934

argument.TypeData = viewer.Effect[i].TypeData;

5935

args.Add(argument);

5936

}

5937

5938

handlerViewerEffect(sender, args);

}

return true;

}

private bool HandleAvatarPropertiesRequest(IClientAPI sender, Packet Pack)

5945

{

5946

AvatarPropertiesRequestPacket avatarProperties = (AvatarPropertiesRequestPacket)Pack;

5947

5948

#region Packet Session and User Check

5949

if (m_checkPackets)

5950

{

5951

if (avatarProperties.AgentData.SessionID != SessionId ||

5952

avatarProperties.AgentData.AgentID != AgentId)

return true;

}

#endregion

RequestAvatarProperties handlerRequestAvatarProperties = OnRequestAvatarProperties;

5958

if (handlerRequestAvatarProperties != null)

5959

{

5960

handlerRequestAvatarProperties(this, avatarProperties.AgentData.AvatarID);

}

return true;

}

private bool HandleChatFromViewer(IClientAPI sender, Packet Pack)

5966

{

5967

ChatFromViewerPacket inchatpack = (ChatFromViewerPacket)Pack;

5968

5969

#region Packet Session and User Check

5970

if (m_checkPackets)

5971

{

5972

if (inchatpack.AgentData.SessionID != SessionId ||

5973

inchatpack.AgentData.AgentID != AgentId)

return true;

}

#endregion

string fromName = String.Empty; //ClientAvatar.firstname + " " + ClientAvatar.lastname;

5979

byte[] message = inchatpack.ChatData.Message;

5980

byte type = inchatpack.ChatData.Type;

5981

Vector3 fromPos = new Vector3(); // ClientAvatar.Pos;

5982

// UUID fromAgentID = AgentId;

5983

5984

int channel = inchatpack.ChatData.Channel;

5985

5986

if (OnChatFromClient != null)

5987

{

5988

OSChatMessage args = new OSChatMessage();

5989

args.Channel = channel;

5990

args.From = fromName;

5991

args.Message = Utils.BytesToString(message);

5992

args.Type = (ChatTypeEnum)type;

5993

args.Position = fromPos;

5994

5995

args.Scene = Scene;

5996

args.Sender = this;

5997

args.SenderUUID = this.AgentId;

5998

5999

ChatMessage handlerChatFromClient = OnChatFromClient;

6000

if (handlerChatFromClient != null)

6001

handlerChatFromClient(this, args);

}

return true;

}

private bool HandlerAvatarPropertiesUpdate(IClientAPI sender, Packet Pack)

6007

{

6008

AvatarPropertiesUpdatePacket avatarProps = (AvatarPropertiesUpdatePacket)Pack;

6009

6010

#region Packet Session and User Check

6011

if (m_checkPackets)

6012

{

6013

if (avatarProps.AgentData.SessionID != SessionId ||

6014

avatarProps.AgentData.AgentID != AgentId)

return true;

}

#endregion

UpdateAvatarProperties handlerUpdateAvatarProperties = OnUpdateAvatarProperties;

6020

if (handlerUpdateAvatarProperties != null)

6021

{

6022

AvatarPropertiesUpdatePacket.PropertiesDataBlock Properties = avatarProps.PropertiesData;

6023

UserProfileData UserProfile = new UserProfileData();

6024

UserProfile.ID = AgentId;

6025

UserProfile.AboutText = Utils.BytesToString(Properties.AboutText);

6026

UserProfile.FirstLifeAboutText = Utils.BytesToString(Properties.FLAboutText);

6027

UserProfile.FirstLifeImage = Properties.FLImageID;

6028

UserProfile.Image = Properties.ImageID;

6029

UserProfile.ProfileUrl = Utils.BytesToString(Properties.ProfileURL);

6030

UserProfile.UserFlags &= ~3;

6031

UserProfile.UserFlags |= Properties.AllowPublish ? 1 : 0;

6032

UserProfile.UserFlags |= Properties.MaturePublish ? 2 : 0;

6033

6034

handlerUpdateAvatarProperties(this, UserProfile);

}

return true;

}

private bool HandlerScriptDialogReply(IClientAPI sender, Packet Pack)

6040

{

6041

ScriptDialogReplyPacket rdialog = (ScriptDialogReplyPacket)Pack;

6042

6043

//m_log.DebugFormat("[CLIENT]: Received ScriptDialogReply from {0}", rdialog.Data.ObjectID);

6044

6045

#region Packet Session and User Check

6046

if (m_checkPackets)

6047

{

6048

if (rdialog.AgentData.SessionID != SessionId ||

6049

rdialog.AgentData.AgentID != AgentId)

return true;

}

#endregion

int ch = rdialog.Data.ChatChannel;

6055

byte[] msg = rdialog.Data.ButtonLabel;

6056

if (OnChatFromClient != null)

6057

{

6058

OSChatMessage args = new OSChatMessage();

6059

args.Channel = ch;

6060

args.From = String.Empty;

6061

args.Message = Utils.BytesToString(msg);

6062

args.Type = ChatTypeEnum.Region; //Behaviour in SL is that the response can be heard from any distance

6063

args.Position = new Vector3();

6064

args.Scene = Scene;

6065

args.Sender = this;

6066

ChatMessage handlerChatFromClient2 = OnChatFromClient;

6067

if (handlerChatFromClient2 != null)

6068

handlerChatFromClient2(this, args);

}

return true;

}

private bool HandlerImprovedInstantMessage(IClientAPI sender, Packet Pack)

6075

{

6076

ImprovedInstantMessagePacket msgpack = (ImprovedInstantMessagePacket)Pack;

6077

6078

#region Packet Session and User Check

6079

if (m_checkPackets)

6080

{

6081

if (msgpack.AgentData.SessionID != SessionId ||

6082

msgpack.AgentData.AgentID != AgentId)

return true;

}

#endregion

string IMfromName = Util.FieldToString(msgpack.MessageBlock.FromAgentName);

6088

string IMmessage = Utils.BytesToString(msgpack.MessageBlock.Message);

6089

ImprovedInstantMessage handlerInstantMessage = OnInstantMessage;

6090

6091

if (handlerInstantMessage != null)

6092

{

6093

GridInstantMessage im = new GridInstantMessage(Scene,

6094

msgpack.AgentData.AgentID,

6095

IMfromName,

6096

msgpack.MessageBlock.ToAgentID,

6097

msgpack.MessageBlock.Dialog,

6098

msgpack.MessageBlock.FromGroup,

6099

IMmessage,

6100

msgpack.MessageBlock.ID,

6101

msgpack.MessageBlock.Offline != 0 ? true : false,

6102

msgpack.MessageBlock.Position,

6103

msgpack.MessageBlock.BinaryBucket,

6104

true);

6105

6106

handlerInstantMessage(this, im);

}

return true;

}

private bool HandlerAcceptFriendship(IClientAPI sender, Packet Pack)

6113

{

6114

AcceptFriendshipPacket afriendpack = (AcceptFriendshipPacket)Pack;

6115

6116

#region Packet Session and User Check

6117

if (m_checkPackets)

6118

{

6119

if (afriendpack.AgentData.SessionID != SessionId ||

6120

afriendpack.AgentData.AgentID != AgentId)

return true;

}

#endregion

// My guess is this is the folder to stick the calling card into

6126

List<UUID> callingCardFolders = new List<UUID>();

6127

6128

UUID transactionID = afriendpack.TransactionBlock.TransactionID;

6129

6130

for (int fi = 0; fi < afriendpack.FolderData.Length; fi++)

6131

{

6132

callingCardFolders.Add(afriendpack.FolderData[fi].FolderID);

6133

}

6134

6135

FriendActionDelegate handlerApproveFriendRequest = OnApproveFriendRequest;

6136

if (handlerApproveFriendRequest != null)

6137

{

6138

handlerApproveFriendRequest(this, transactionID, callingCardFolders);

}

return true;

}

private bool HandlerDeclineFriendship(IClientAPI sender, Packet Pack)

6145

{

6146

DeclineFriendshipPacket dfriendpack = (DeclineFriendshipPacket)Pack;

6147

6148

#region Packet Session and User Check

6149

if (m_checkPackets)

6150

{

6151

if (dfriendpack.AgentData.SessionID != SessionId ||

6152

dfriendpack.AgentData.AgentID != AgentId)

return true;

}

#endregion

if (OnDenyFriendRequest != null)

6158

{

6159

OnDenyFriendRequest(this,

6160

dfriendpack.TransactionBlock.TransactionID,

null);

}

return true;

}

private bool HandlerTerminateFriendship(IClientAPI sender, Packet Pack)

6167

{

6168

TerminateFriendshipPacket tfriendpack = (TerminateFriendshipPacket)Pack;

6169

6170

#region Packet Session and User Check

6171

if (m_checkPackets)

6172

{

6173

if (tfriendpack.AgentData.SessionID != SessionId ||

6174

tfriendpack.AgentData.AgentID != AgentId)

return true;

}

#endregion

UUID exFriendID = tfriendpack.ExBlock.OtherID;

6180

FriendshipTermination TerminateFriendshipHandler = OnTerminateFriendship;

6181

if (TerminateFriendshipHandler != null)

6182

{

6183

TerminateFriendshipHandler(this, exFriendID);

return true;

}

return false;

}

private bool HandleFindAgent(IClientAPI client, Packet Packet)

6191

{

6192

FindAgentPacket FindAgent =

6193

(FindAgentPacket)Packet;

6194

6195

FindAgentUpdate FindAgentHandler = OnFindAgent;

6196

if (FindAgentHandler != null)

6197

{

6198

FindAgentHandler(this,FindAgent.AgentBlock.Hunter,FindAgent.AgentBlock.Prey);

return true;

}

return false;

}

private bool HandleTrackAgent(IClientAPI client, Packet Packet)

6205

{

6206

TrackAgentPacket TrackAgent =

6207

(TrackAgentPacket)Packet;

6208

6209

TrackAgentUpdate TrackAgentHandler = OnTrackAgent;

6210

if (TrackAgentHandler != null)

6211

{

6212

TrackAgentHandler(this,

6213

TrackAgent.AgentData.AgentID,

6214

TrackAgent.TargetData.PreyID);

return true;

}

return false;

}

private bool HandlerRezObject(IClientAPI sender, Packet Pack)

6221

{

6222

RezObjectPacket rezPacket = (RezObjectPacket)Pack;

6223

6224

#region Packet Session and User Check

6225

if (m_checkPackets)

6226

{

6227

if (rezPacket.AgentData.SessionID != SessionId ||

6228

rezPacket.AgentData.AgentID != AgentId)

return true;

}

#endregion

RezObject handlerRezObject = OnRezObject;

6234

if (handlerRezObject != null)

6235

{

6236

handlerRezObject(this, rezPacket.InventoryData.ItemID, rezPacket.RezData.RayEnd,

6237

rezPacket.RezData.RayStart, rezPacket.RezData.RayTargetID,

6238

rezPacket.RezData.BypassRaycast, rezPacket.RezData.RayEndIsIntersection,

6239

rezPacket.RezData.RezSelected, rezPacket.RezData.RemoveItem,

6240

rezPacket.RezData.FromTaskID);

}

return true;

}

private bool HandlerDeRezObject(IClientAPI sender, Packet Pack)

6246

{

6247

DeRezObjectPacket DeRezPacket = (DeRezObjectPacket)Pack;

6248

6249

#region Packet Session and User Check

6250

if (m_checkPackets)

6251

{

6252

if (DeRezPacket.AgentData.SessionID != SessionId ||

6253

DeRezPacket.AgentData.AgentID != AgentId)

return true;

}

#endregion

DeRezObject handlerDeRezObject = OnDeRezObject;

6259

if (handlerDeRezObject != null)

6260

{

6261

List<uint> deRezIDs = new List<uint>();

6262

6263

foreach (DeRezObjectPacket.ObjectDataBlock data in

6264

DeRezPacket.ObjectData)

6265

{

6266

deRezIDs.Add(data.ObjectLocalID);

6267

}

6268

// It just so happens that the values on the DeRezAction enumerator match the Destination

6269

// values given by a Second Life client

6270

handlerDeRezObject(this, deRezIDs,

6271

DeRezPacket.AgentBlock.GroupID,

6272

(DeRezAction)DeRezPacket.AgentBlock.Destination,

6273

DeRezPacket.AgentBlock.DestinationID);

}

return true;

}

private bool HandlerModifyLand(IClientAPI sender, Packet Pack)

6280

{

6281

ModifyLandPacket modify = (ModifyLandPacket)Pack;

6282

6283

#region Packet Session and User Check

6284

if (m_checkPackets)

6285

{

6286

if (modify.AgentData.SessionID != SessionId ||

6287

modify.AgentData.AgentID != AgentId)

return true;

}

#endregion

//m_log.Info("[LAND]: LAND:" + modify.ToString());

6293

if (modify.ParcelData.Length > 0)

6294

{

6295

                // Note: the ModifyTerrain event handler sends out updated packets before the end of this event.  Therefore,

6296

                // a simple boolean value should work and perhaps queue up just a few terrain patch packets at the end of the edit.

6297

m_justEditedTerrain = true; // Prevent terrain packet (Land layer) from being queued, make it unreliable

6298

if (OnModifyTerrain != null)

6299

{

6300

for (int i = 0; i < modify.ParcelData.Length; i++)

6301

{

6302

ModifyTerrain handlerModifyTerrain = OnModifyTerrain;

6303

if (handlerModifyTerrain != null)

6304

{

6305

handlerModifyTerrain(AgentId, modify.ModifyBlock.Height, modify.ModifyBlock.Seconds,

6306

modify.ModifyBlock.BrushSize,

6307

modify.ModifyBlock.Action, modify.ParcelData[i].North,

6308

modify.ParcelData[i].West, modify.ParcelData[i].South,

6309

modify.ParcelData[i].East, AgentId);

}

}

}

m_justEditedTerrain = false; // Queue terrain packet (Land layer) if necessary, make it reliable again

}

return true;

}

private bool HandlerRegionHandshakeReply(IClientAPI sender, Packet Pack)

6320

{

6321

Action<IClientAPI> handlerRegionHandShakeReply = OnRegionHandShakeReply;

6322

if (handlerRegionHandShakeReply != null)

6323

{

6324

handlerRegionHandShakeReply(this);

}

return true;

}

private bool HandlerAgentWearablesRequest(IClientAPI sender, Packet Pack)

6331

{

6332

GenericCall1 handlerRequestWearables = OnRequestWearables;

6333

6334

if (handlerRequestWearables != null)

6335

{

6336

handlerRequestWearables(sender);

6337

}

6338

6339

Action<IClientAPI> handlerRequestAvatarsData = OnRequestAvatarsData;

6340

6341

if (handlerRequestAvatarsData != null)

6342

{

6343

handlerRequestAvatarsData(this);

}

return true;

}

private bool HandlerAgentSetAppearance(IClientAPI sender, Packet Pack)

6350

{

6351

AgentSetAppearancePacket appear = (AgentSetAppearancePacket)Pack;

6352

6353

#region Packet Session and User Check

6354

if (m_checkPackets)

6355

{

6356

if (appear.AgentData.SessionID != SessionId ||

6357

appear.AgentData.AgentID != AgentId)

return true;

}

#endregion

SetAppearance handlerSetAppearance = OnSetAppearance;

6363

if (handlerSetAppearance != null)

6364

{

6365

// Temporarily protect ourselves from the mantis #951 failure.

6366

// However, we could do this for several other handlers where a failure isn't terminal

6367

// for the client session anyway, in order to protect ourselves against bad code in plugins

6368

try

6369

{

6370

byte[] visualparams = new byte[appear.VisualParam.Length];

6371

for (int i = 0; i < appear.VisualParam.Length; i++)

6372

visualparams[i] = appear.VisualParam[i].ParamValue;

6373

6374

Primitive.TextureEntry te = null;

6375

if (appear.ObjectData.TextureEntry.Length > 1)

6376

                        te = new Primitive.TextureEntry(appear.ObjectData.TextureEntry, 0, appear.ObjectData.TextureEntry.Length);

6377

6378

List<CachedTextureRequestArg> hashes = new List<CachedTextureRequestArg>();

6379

for (int i = 0; i < appear.WearableData.Length; i++)

6380

{

6381

CachedTextureRequestArg arg = new CachedTextureRequestArg();

6382

arg.BakedTextureIndex = appear.WearableData[i].TextureIndex;

6383

arg.WearableHashID = appear.WearableData[i].CacheID;

hashes.Add(arg);

}

handlerSetAppearance(sender, te, visualparams, hashes);

6388

}

6389

catch (Exception e)

6390

{

6391

m_log.ErrorFormat(

6392

"[CLIENT VIEW]: AgentSetApperance packet handler threw an exception, {0}",

e);

}

}

return true;

}

private bool HandlerAgentIsNowWearing(IClientAPI sender, Packet Pack)

6401

{

6402

if (OnAvatarNowWearing != null)

6403

{

6404

AgentIsNowWearingPacket nowWearing = (AgentIsNowWearingPacket)Pack;

6405

6406

#region Packet Session and User Check

6407

if (m_checkPackets)

6408

{

6409

if (nowWearing.AgentData.SessionID != SessionId ||

6410

nowWearing.AgentData.AgentID != AgentId)

return true;

}

#endregion

AvatarWearingArgs wearingArgs = new AvatarWearingArgs();

6416

for (int i = 0; i < nowWearing.WearableData.Length; i++)

6417

{

6418

                    //m_log.DebugFormat("[XXX]: Wearable type {0} item {1}", nowWearing.WearableData[i].WearableType, nowWearing.WearableData[i].ItemID);

6419

AvatarWearingArgs.Wearable wearable =

6420

new AvatarWearingArgs.Wearable(nowWearing.WearableData[i].ItemID,

6421

nowWearing.WearableData[i].WearableType);

6422

wearingArgs.NowWearing.Add(wearable);

6423

}

6424

6425

AvatarNowWearing handlerAvatarNowWearing = OnAvatarNowWearing;

6426

if (handlerAvatarNowWearing != null)

6427

{

6428

handlerAvatarNowWearing(this, wearingArgs);

}

}

return true;

}

private bool HandlerRezSingleAttachmentFromInv(IClientAPI sender, Packet Pack)

6435

{

6436

RezSingleAttachmentFromInv handlerRezSingleAttachment = OnRezSingleAttachmentFromInv;

6437

if (handlerRezSingleAttachment != null)

6438

{

6439

RezSingleAttachmentFromInvPacket rez = (RezSingleAttachmentFromInvPacket)Pack;

6440

6441

#region Packet Session and User Check

6442

if (m_checkPackets)

6443

{

6444

if (rez.AgentData.SessionID != SessionId ||

6445

rez.AgentData.AgentID != AgentId)

return true;

}

#endregion

handlerRezSingleAttachment(this, rez.ObjectData.ItemID,

6451

rez.ObjectData.AttachmentPt);

}

return true;

}

private bool HandleRezMultipleAttachmentsFromInv(IClientAPI sender, Packet Pack)

6458

{

6459

RezMultipleAttachmentsFromInv handlerRezMultipleAttachments = OnRezMultipleAttachmentsFromInv;

6460

if (handlerRezMultipleAttachments != null)

6461

{

6462

List<KeyValuePair<UUID, uint>> rezlist = new List<KeyValuePair<UUID, uint>>();

6463

                foreach (RezMultipleAttachmentsFromInvPacket.ObjectDataBlock obj in ((RezMultipleAttachmentsFromInvPacket)Pack).ObjectData)

6464

rezlist.Add(new KeyValuePair<UUID, uint>(obj.ItemID, obj.AttachmentPt));

6465

handlerRezMultipleAttachments(this, rezlist);

}

return true;

}

private bool HandleDetachAttachmentIntoInv(IClientAPI sender, Packet Pack)

6472

{

6473

UUIDNameRequest handlerDetachAttachmentIntoInv = OnDetachAttachmentIntoInv;

6474

if (handlerDetachAttachmentIntoInv != null)

6475

{

6476

DetachAttachmentIntoInvPacket detachtoInv = (DetachAttachmentIntoInvPacket)Pack;

6477

6478

#region Packet Session and User Check

6479

// UNSUPPORTED ON THIS PACKET

6480

#endregion

6481

6482

UUID itemID = detachtoInv.ObjectData.ItemID;

6483

// UUID ATTACH_agentID = detachtoInv.ObjectData.AgentID;

6484

6485

handlerDetachAttachmentIntoInv(itemID, this);

}

return true;

}

private bool HandleObjectAttach(IClientAPI sender, Packet Pack)

6491

{

6492

if (OnObjectAttach != null)

6493

{

6494

ObjectAttachPacket att = (ObjectAttachPacket)Pack;

6495

6496

#region Packet Session and User Check

6497

if (m_checkPackets)

6498

{

6499

if (att.AgentData.SessionID != SessionId ||

6500

att.AgentData.AgentID != AgentId)

return true;

}

#endregion

ObjectAttach handlerObjectAttach = OnObjectAttach;

6506

6507

if (handlerObjectAttach != null)

6508

{

6509

if (att.ObjectData.Length > 0)

6510

{

6511

                        handlerObjectAttach(this, att.ObjectData[0].ObjectLocalID, att.AgentData.AttachmentPoint, false);

}

}

}

return true;

}

private bool HandleObjectDetach(IClientAPI sender, Packet Pack)

6519

{

6520

ObjectDetachPacket dett = (ObjectDetachPacket)Pack;

6521

6522

#region Packet Session and User Check

6523

if (m_checkPackets)

6524

{

6525

if (dett.AgentData.SessionID != SessionId ||

6526

dett.AgentData.AgentID != AgentId)

return true;

}

#endregion

for (int j = 0; j < dett.ObjectData.Length; j++)

6532

{

6533

uint obj = dett.ObjectData[j].ObjectLocalID;

6534

ObjectDeselect handlerObjectDetach = OnObjectDetach;

6535

if (handlerObjectDetach != null)

6536

{

6537

handlerObjectDetach(obj, this);

}

}

return true;

}

private bool HandleObjectDrop(IClientAPI sender, Packet Pack)

6545

{

6546

ObjectDropPacket dropp = (ObjectDropPacket)Pack;

6547

6548

#region Packet Session and User Check

6549

if (m_checkPackets)

6550

{

6551

if (dropp.AgentData.SessionID != SessionId ||

6552

dropp.AgentData.AgentID != AgentId)

return true;

}

#endregion

for (int j = 0; j < dropp.ObjectData.Length; j++)

6558

{

6559

uint obj = dropp.ObjectData[j].ObjectLocalID;

6560

ObjectDrop handlerObjectDrop = OnObjectDrop;

6561

if (handlerObjectDrop != null)

6562

{

6563

handlerObjectDrop(obj, this);

}

}

return true;

}

private bool HandleSetAlwaysRun(IClientAPI sender, Packet Pack)

6570

{

6571

SetAlwaysRunPacket run = (SetAlwaysRunPacket)Pack;

6572

6573

#region Packet Session and User Check

6574

if (m_checkPackets)

6575

{

6576

if (run.AgentData.SessionID != SessionId ||

6577

run.AgentData.AgentID != AgentId)

return true;

}

#endregion

SetAlwaysRun handlerSetAlwaysRun = OnSetAlwaysRun;

6583

if (handlerSetAlwaysRun != null)

6584

handlerSetAlwaysRun(this, run.AgentData.AlwaysRun);

return true;

}

private bool HandleCompleteAgentMovement(IClientAPI sender, Packet Pack)

6590

{

6591

Action<IClientAPI, bool> handlerCompleteMovementToRegion = OnCompleteMovementToRegion;

6592

if (handlerCompleteMovementToRegion != null)

6593

{

6594

handlerCompleteMovementToRegion(sender, true);

6595

}

6596

handlerCompleteMovementToRegion = null;

return true;

}

private bool HandleAgentAnimation(IClientAPI sender, Packet Pack)

6602

{

6603

AgentAnimationPacket AgentAni = (AgentAnimationPacket)Pack;

6604

6605

#region Packet Session and User Check

6606

if (m_checkPackets)

6607

{

6608

if (AgentAni.AgentData.SessionID != SessionId ||

6609

AgentAni.AgentData.AgentID != AgentId)

return true;

}

#endregion

StartAnim handlerStartAnim = null;

6615

StopAnim handlerStopAnim = null;

6616

6617

for (int i = 0; i < AgentAni.AnimationList.Length; i++)

6618

{

6619

if (AgentAni.AnimationList[i].StartAnim)

6620

{

6621

handlerStartAnim = OnStartAnim;

6622

if (handlerStartAnim != null)

6623

{

6624

handlerStartAnim(this, AgentAni.AnimationList[i].AnimID);

}

}

else

{

handlerStopAnim = OnStopAnim;

6630

if (handlerStopAnim != null)

6631

{

6632

handlerStopAnim(this, AgentAni.AnimationList[i].AnimID);

}

}

}

return true;

}

private bool HandleAgentRequestSit(IClientAPI sender, Packet Pack)

6640

{

6641

if (OnAgentRequestSit != null)

6642

{

6643

AgentRequestSitPacket agentRequestSit = (AgentRequestSitPacket)Pack;

6644

6645

#region Packet Session and User Check

6646

if (m_checkPackets)

6647

{

6648

if (agentRequestSit.AgentData.SessionID != SessionId ||

6649

agentRequestSit.AgentData.AgentID != AgentId)

return true;

}

#endregion

if (SceneAgent.IsChildAgent)

6655

{

6656

SendCantSitBecauseChildAgentResponse();

return true;

}

AgentRequestSit handlerAgentRequestSit = OnAgentRequestSit;

6661

6662

if (handlerAgentRequestSit != null)

6663

handlerAgentRequestSit(this, agentRequestSit.AgentData.AgentID,

6664

agentRequestSit.TargetObject.TargetID, agentRequestSit.TargetObject.Offset);

}

return true;

}

private bool HandleAgentSit(IClientAPI sender, Packet Pack)

6670

{

6671

if (OnAgentSit != null)

6672

{

6673

AgentSitPacket agentSit = (AgentSitPacket)Pack;

6674

6675

#region Packet Session and User Check

6676

if (m_checkPackets)

6677

{

6678

if (agentSit.AgentData.SessionID != SessionId ||

6679

agentSit.AgentData.AgentID != AgentId)

return true;

}

#endregion

if (SceneAgent.IsChildAgent)

6685

{

6686

SendCantSitBecauseChildAgentResponse();

return true;

}

AgentSit handlerAgentSit = OnAgentSit;

6691

if (handlerAgentSit != null)

6692

{

6693

OnAgentSit(this, agentSit.AgentData.AgentID);

}

}

return true;

}

/// <summary>

/// Used when a child agent gets a sit response which should not be fulfilled.

6701

/// </summary>

6702

private void SendCantSitBecauseChildAgentResponse()

6703

{

6704

SendAlertMessage("Try moving closer. Can't sit on object because it is not in the same region as you.");

6705

}

6706

6707

private bool HandleSoundTrigger(IClientAPI sender, Packet Pack)

6708

{

6709

SoundTriggerPacket soundTriggerPacket = (SoundTriggerPacket)Pack;

6710

6711

#region Packet Session and User Check

6712

if (m_checkPackets)

6713

{

6714

// UNSUPPORTED ON THIS PACKET

}

#endregion

SoundTrigger handlerSoundTrigger = OnSoundTrigger;

6719

if (handlerSoundTrigger != null)

6720

{

6721

// UUIDS are sent as zeroes by the client, substitute agent's id

6722

handlerSoundTrigger(soundTriggerPacket.SoundData.SoundID, AgentId,

6723

AgentId, AgentId,

6724

soundTriggerPacket.SoundData.Gain, soundTriggerPacket.SoundData.Position,

6725

soundTriggerPacket.SoundData.Handle, 0);

}

return true;

}

private bool HandleAvatarPickerRequest(IClientAPI sender, Packet Pack)

6732

{

6733

AvatarPickerRequestPacket avRequestQuery = (AvatarPickerRequestPacket)Pack;

6734

6735

#region Packet Session and User Check

6736

if (m_checkPackets)

6737

{

6738

if (avRequestQuery.AgentData.SessionID != SessionId ||

6739

avRequestQuery.AgentData.AgentID != AgentId)

return true;

}

#endregion

AvatarPickerRequestPacket.AgentDataBlock Requestdata = avRequestQuery.AgentData;

6745

AvatarPickerRequestPacket.DataBlock querydata = avRequestQuery.Data;

6746

//m_log.Debug("Agent Sends:" + Utils.BytesToString(querydata.Name));

6747

6748

AvatarPickerRequest handlerAvatarPickerRequest = OnAvatarPickerRequest;

6749

if (handlerAvatarPickerRequest != null)

6750

{

6751

handlerAvatarPickerRequest(this, Requestdata.AgentID, Requestdata.QueryID,

6752

Utils.BytesToString(querydata.Name));

}

return true;

}

private bool HandleAgentDataUpdateRequest(IClientAPI sender, Packet Pack)

6758

{

6759

AgentDataUpdateRequestPacket avRequestDataUpdatePacket = (AgentDataUpdateRequestPacket)Pack;

6760

6761

#region Packet Session and User Check

6762

if (m_checkPackets)

6763

{

6764

if (avRequestDataUpdatePacket.AgentData.SessionID != SessionId ||

6765

avRequestDataUpdatePacket.AgentData.AgentID != AgentId)

return true;

}

#endregion

FetchInventory handlerAgentDataUpdateRequest = OnAgentDataUpdateRequest;

6771

6772

if (handlerAgentDataUpdateRequest != null)

6773

{

6774

                handlerAgentDataUpdateRequest(this, avRequestDataUpdatePacket.AgentData.AgentID, avRequestDataUpdatePacket.AgentData.SessionID);

}

return true;

}

private bool HandleUserInfoRequest(IClientAPI sender, Packet Pack)

6781

{

6782

UserInfoRequest handlerUserInfoRequest = OnUserInfoRequest;

6783

if (handlerUserInfoRequest != null)

6784

{

6785

handlerUserInfoRequest(this);

}

else

{

SendUserInfoReply(false, true, "");

}

return true;

}

private bool HandleUpdateUserInfo(IClientAPI sender, Packet Pack)

6796

{

6797

UpdateUserInfoPacket updateUserInfo = (UpdateUserInfoPacket)Pack;

6798

6799

#region Packet Session and User Check

6800

if (m_checkPackets)

6801

{

6802

if (updateUserInfo.AgentData.SessionID != SessionId ||

6803

updateUserInfo.AgentData.AgentID != AgentId)

return true;

}

#endregion

UpdateUserInfo handlerUpdateUserInfo = OnUpdateUserInfo;

6809

if (handlerUpdateUserInfo != null)

6810

{

6811

bool visible = true;

6812

string DirectoryVisibility =

6813

Utils.BytesToString(updateUserInfo.UserData.DirectoryVisibility);

6814

if (DirectoryVisibility == "hidden")

6815

visible = false;

6816

6817

handlerUpdateUserInfo(

6818

updateUserInfo.UserData.IMViaEMail,

visible, this);

}

return true;

}

private bool HandleSetStartLocationRequest(IClientAPI sender, Packet Pack)

6825

{

6826

SetStartLocationRequestPacket avSetStartLocationRequestPacket = (SetStartLocationRequestPacket)Pack;

6827

6828

#region Packet Session and User Check

6829

if (m_checkPackets)

6830

{

6831

if (avSetStartLocationRequestPacket.AgentData.SessionID != SessionId ||

6832

avSetStartLocationRequestPacket.AgentData.AgentID != AgentId)

return true;

}

#endregion

            if (avSetStartLocationRequestPacket.AgentData.AgentID == AgentId && avSetStartLocationRequestPacket.AgentData.SessionID == SessionId)

6838

{

6839

// Linden Client limitation..

6840

if (avSetStartLocationRequestPacket.StartLocationData.LocationPos.X == 255.5f

6841

|| avSetStartLocationRequestPacket.StartLocationData.LocationPos.Y == 255.5f)

6842

{

6843

ScenePresence avatar = null;

6844

if (((Scene)m_scene).TryGetScenePresence(AgentId, out avatar))

6845

{

6846

if (avSetStartLocationRequestPacket.StartLocationData.LocationPos.X == 255.5f)

6847

{

6848

avSetStartLocationRequestPacket.StartLocationData.LocationPos.X = avatar.AbsolutePosition.X;

6849

}

6850

if (avSetStartLocationRequestPacket.StartLocationData.LocationPos.Y == 255.5f)

6851

{

6852

avSetStartLocationRequestPacket.StartLocationData.LocationPos.Y = avatar.AbsolutePosition.Y;

}

}

}

TeleportLocationRequest handlerSetStartLocationRequest = OnSetStartLocationRequest;

6858

if (handlerSetStartLocationRequest != null)

6859

{

6860

                    handlerSetStartLocationRequest(this, 0, avSetStartLocationRequestPacket.StartLocationData.LocationPos,

6861

avSetStartLocationRequestPacket.StartLocationData.LocationLookAt,

6862

avSetStartLocationRequestPacket.StartLocationData.LocationID);

}

}

return true;

}

private bool HandleAgentThrottle(IClientAPI sender, Packet Pack)

6869

{

6870

AgentThrottlePacket atpack = (AgentThrottlePacket)Pack;

6871

6872

#region Packet Session and User Check

6873

if (m_checkPackets)

6874

{

6875

if (atpack.AgentData.SessionID != SessionId ||

6876

atpack.AgentData.AgentID != AgentId)

return true;

}

#endregion

m_udpClient.SetThrottles(atpack.Throttle.Throttles);

return true;

}

private bool HandleAgentPause(IClientAPI sender, Packet Pack)

6886

{

6887

m_udpClient.IsPaused = true;

return true;

}

private bool HandleAgentResume(IClientAPI sender, Packet Pack)

6892

{

6893

m_udpClient.IsPaused = false;

6894

SendStartPingCheck(m_udpClient.CurrentPingSequence++);

return true;

}

private bool HandleForceScriptControlRelease(IClientAPI sender, Packet Pack)

6899

{

6900

ForceReleaseControls handlerForceReleaseControls = OnForceReleaseControls;

6901

if (handlerForceReleaseControls != null)

6902

{

6903

handlerForceReleaseControls(this, AgentId);

}

return true;

}

#endregion Scene/Avatar

6909

6910

#region Objects/m_sceneObjects

6911

6912

private bool HandleObjectLink(IClientAPI sender, Packet Pack)

6913

{

6914

ObjectLinkPacket link = (ObjectLinkPacket)Pack;

6915

6916

#region Packet Session and User Check

6917

if (m_checkPackets)

6918

{

6919

if (link.AgentData.SessionID != SessionId ||

6920

link.AgentData.AgentID != AgentId)

return true;

}

#endregion

uint parentprimid = 0;

6926

List<uint> childrenprims = new List<uint>();

6927

if (link.ObjectData.Length > 1)

6928

{

6929

parentprimid = link.ObjectData[0].ObjectLocalID;

6930

6931

for (int i = 1; i < link.ObjectData.Length; i++)

6932

{

6933

childrenprims.Add(link.ObjectData[i].ObjectLocalID);

6934

}

6935

}

6936

LinkObjects handlerLinkObjects = OnLinkObjects;

6937

if (handlerLinkObjects != null)

6938

{

6939

handlerLinkObjects(this, parentprimid, childrenprims);

}

return true;

}

private bool HandleObjectDelink(IClientAPI sender, Packet Pack)

6945

{

6946

ObjectDelinkPacket delink = (ObjectDelinkPacket)Pack;

6947

6948

#region Packet Session and User Check

6949

if (m_checkPackets)

6950

{

6951

if (delink.AgentData.SessionID != SessionId ||

6952

delink.AgentData.AgentID != AgentId)

return true;

}

#endregion

// It appears the prim at index 0 is not always the root prim (for

6958

// instance, when one prim of a link set has been edited independently

6959

// of the others). Therefore, we'll pass all the ids onto the delink

6960

// method for it to decide which is the root.

6961

List<uint> prims = new List<uint>();

6962

for (int i = 0; i < delink.ObjectData.Length; i++)

6963

{

6964

prims.Add(delink.ObjectData[i].ObjectLocalID);

6965

}

6966

DelinkObjects handlerDelinkObjects = OnDelinkObjects;

6967

if (handlerDelinkObjects != null)

6968

{

6969

handlerDelinkObjects(prims, this);

}

return true;

}

private bool HandleObjectAdd(IClientAPI sender, Packet Pack)

6976

{

6977

if (OnAddPrim != null)

6978

{

6979

ObjectAddPacket addPacket = (ObjectAddPacket)Pack;

6980

6981

#region Packet Session and User Check

6982

if (m_checkPackets)

6983

{

6984

if (addPacket.AgentData.SessionID != SessionId ||

6985

addPacket.AgentData.AgentID != AgentId)

return true;

}

#endregion

PrimitiveBaseShape shape = GetShapeFromAddPacket(addPacket);

6991

// m_log.Info("[REZData]: " + addPacket.ToString());

6992

//BypassRaycast: 1

6993

//RayStart: <69.79469, 158.2652, 98.40343>

6994

//RayEnd: <61.97724, 141.995, 92.58341>

6995

//RayTargetID: 00000000-0000-0000-0000-000000000000

6996

6997

//Check to see if adding the prim is allowed; useful for any module wanting to restrict the

6998

//object from rezing initially

6999

7000

AddNewPrim handlerAddPrim = OnAddPrim;

7001

if (handlerAddPrim != null)

7002

                    handlerAddPrim(AgentId, ActiveGroupId, addPacket.ObjectData.RayEnd, addPacket.ObjectData.Rotation, shape, addPacket.ObjectData.BypassRaycast, addPacket.ObjectData.RayStart, addPacket.ObjectData.RayTargetID, addPacket.ObjectData.RayEndIsIntersection);

}

return true;

}

private bool HandleObjectShape(IClientAPI sender, Packet Pack)

7008

{

7009

ObjectShapePacket shapePacket = (ObjectShapePacket)Pack;

7010

7011

#region Packet Session and User Check

7012

if (m_checkPackets)

7013

{

7014

if (shapePacket.AgentData.SessionID != SessionId ||

7015

shapePacket.AgentData.AgentID != AgentId)

return true;

}

#endregion

UpdateShape handlerUpdatePrimShape = null;

7021

for (int i = 0; i < shapePacket.ObjectData.Length; i++)

7022

{

7023

handlerUpdatePrimShape = OnUpdatePrimShape;

7024

if (handlerUpdatePrimShape != null)

7025

{

7026

UpdateShapeArgs shapeData = new UpdateShapeArgs();

7027

shapeData.ObjectLocalID = shapePacket.ObjectData[i].ObjectLocalID;

7028

shapeData.PathBegin = shapePacket.ObjectData[i].PathBegin;

7029

shapeData.PathCurve = shapePacket.ObjectData[i].PathCurve;

7030

shapeData.PathEnd = shapePacket.ObjectData[i].PathEnd;

7031

shapeData.PathRadiusOffset = shapePacket.ObjectData[i].PathRadiusOffset;

7032

shapeData.PathRevolutions = shapePacket.ObjectData[i].PathRevolutions;

7033

shapeData.PathScaleX = shapePacket.ObjectData[i].PathScaleX;

7034

shapeData.PathScaleY = shapePacket.ObjectData[i].PathScaleY;

7035

shapeData.PathShearX = shapePacket.ObjectData[i].PathShearX;

7036

shapeData.PathShearY = shapePacket.ObjectData[i].PathShearY;

7037

shapeData.PathSkew = shapePacket.ObjectData[i].PathSkew;

7038

shapeData.PathTaperX = shapePacket.ObjectData[i].PathTaperX;

7039

shapeData.PathTaperY = shapePacket.ObjectData[i].PathTaperY;

7040

shapeData.PathTwist = shapePacket.ObjectData[i].PathTwist;

7041

shapeData.PathTwistBegin = shapePacket.ObjectData[i].PathTwistBegin;

7042

shapeData.ProfileBegin = shapePacket.ObjectData[i].ProfileBegin;

7043

shapeData.ProfileCurve = shapePacket.ObjectData[i].ProfileCurve;

7044

shapeData.ProfileEnd = shapePacket.ObjectData[i].ProfileEnd;

7045

shapeData.ProfileHollow = shapePacket.ObjectData[i].ProfileHollow;

7046

7047

handlerUpdatePrimShape(m_agentId, shapePacket.ObjectData[i].ObjectLocalID,

shapeData);

}

}

return true;

}

private bool HandleObjectExtraParams(IClientAPI sender, Packet Pack)

7055

{

7056

ObjectExtraParamsPacket extraPar = (ObjectExtraParamsPacket)Pack;

7057

7058

#region Packet Session and User Check

7059

if (m_checkPackets)

7060

{

7061

if (extraPar.AgentData.SessionID != SessionId ||

7062

extraPar.AgentData.AgentID != AgentId)

return true;

}

#endregion

ObjectExtraParams handlerUpdateExtraParams = OnUpdateExtraParams;

7068

if (handlerUpdateExtraParams != null)

7069

{

7070

for (int i = 0; i < extraPar.ObjectData.Length; i++)

7071

{

7072

handlerUpdateExtraParams(m_agentId, extraPar.ObjectData[i].ObjectLocalID,

7073

extraPar.ObjectData[i].ParamType,

7074

extraPar.ObjectData[i].ParamInUse, extraPar.ObjectData[i].ParamData);

}

}

return true;

}

private bool HandleObjectDuplicate(IClientAPI sender, Packet Pack)

7081

{

7082

ObjectDuplicatePacket dupe = (ObjectDuplicatePacket)Pack;

7083

7084

#region Packet Session and User Check

7085

if (m_checkPackets)

7086

{

7087

if (dupe.AgentData.SessionID != SessionId ||

7088

dupe.AgentData.AgentID != AgentId)

return true;

}

#endregion

// ObjectDuplicatePacket.AgentDataBlock AgentandGroupData = dupe.AgentData;

7094

7095

ObjectDuplicate handlerObjectDuplicate = null;

7096

7097

for (int i = 0; i < dupe.ObjectData.Length; i++)

7098

{

7099

handlerObjectDuplicate = OnObjectDuplicate;

7100

if (handlerObjectDuplicate != null)

7101

{

7102

handlerObjectDuplicate(dupe.ObjectData[i].ObjectLocalID, dupe.SharedData.Offset,

7103

dupe.SharedData.DuplicateFlags, AgentId,

m_activeGroupID);

}

}

return true;

}

private bool HandleRequestMultipleObjects(IClientAPI sender, Packet Pack)

7112

{

7113

RequestMultipleObjectsPacket incomingRequest = (RequestMultipleObjectsPacket)Pack;

7114

7115

#region Packet Session and User Check

7116

if (m_checkPackets)

7117

{

7118

if (incomingRequest.AgentData.SessionID != SessionId ||

7119

incomingRequest.AgentData.AgentID != AgentId)

return true;

}

#endregion

ObjectRequest handlerObjectRequest = null;

7125

7126

for (int i = 0; i < incomingRequest.ObjectData.Length; i++)

7127

{

7128

handlerObjectRequest = OnObjectRequest;

7129

if (handlerObjectRequest != null)

7130

{

7131

handlerObjectRequest(incomingRequest.ObjectData[i].ID, this);

}

}

return true;

}

private bool HandleObjectSelect(IClientAPI sender, Packet Pack)

7138

{

7139

ObjectSelectPacket incomingselect = (ObjectSelectPacket)Pack;

7140

7141

#region Packet Session and User Check

7142

if (m_checkPackets)

7143

{

7144

if (incomingselect.AgentData.SessionID != SessionId ||

7145

incomingselect.AgentData.AgentID != AgentId)

return true;

}

#endregion

ObjectSelect handlerObjectSelect = null;

7151

7152

for (int i = 0; i < incomingselect.ObjectData.Length; i++)

7153

{

7154

handlerObjectSelect = OnObjectSelect;

7155

if (handlerObjectSelect != null)

7156

{

7157

handlerObjectSelect(incomingselect.ObjectData[i].ObjectLocalID, this);

}

}

return true;

}

private bool HandleObjectDeselect(IClientAPI sender, Packet Pack)

7164

{

7165

ObjectDeselectPacket incomingdeselect = (ObjectDeselectPacket)Pack;

7166

7167

#region Packet Session and User Check

7168

if (m_checkPackets)

7169

{

7170

if (incomingdeselect.AgentData.SessionID != SessionId ||

7171

incomingdeselect.AgentData.AgentID != AgentId)

return true;

}

#endregion

ObjectDeselect handlerObjectDeselect = null;

7177

7178

for (int i = 0; i < incomingdeselect.ObjectData.Length; i++)

7179

{

7180

handlerObjectDeselect = OnObjectDeselect;

7181

if (handlerObjectDeselect != null)

7182

{

7183

OnObjectDeselect(incomingdeselect.ObjectData[i].ObjectLocalID, this);

}

}

return true;

}

private bool HandleObjectPosition(IClientAPI sender, Packet Pack)

7190

{

7191

// DEPRECATED: but till libsecondlife removes it, people will use it

7192

ObjectPositionPacket position = (ObjectPositionPacket)Pack;

7193

7194

#region Packet Session and User Check

7195

if (m_checkPackets)

7196

{

7197

if (position.AgentData.SessionID != SessionId ||

7198

position.AgentData.AgentID != AgentId)

return true;

}

#endregion

for (int i = 0; i < position.ObjectData.Length; i++)

7205

{

7206

UpdateVector handlerUpdateVector = OnUpdatePrimGroupPosition;

7207

if (handlerUpdateVector != null)

7208

handlerUpdateVector(position.ObjectData[i].ObjectLocalID, position.ObjectData[i].Position, this);

}

return true;

}

private bool HandleObjectScale(IClientAPI sender, Packet Pack)

7215

{

7216

// DEPRECATED: but till libsecondlife removes it, people will use it

7217

ObjectScalePacket scale = (ObjectScalePacket)Pack;

7218

7219

#region Packet Session and User Check

7220

if (m_checkPackets)

7221

{

7222

if (scale.AgentData.SessionID != SessionId ||

7223

scale.AgentData.AgentID != AgentId)

return true;

}

#endregion

for (int i = 0; i < scale.ObjectData.Length; i++)

7229

{

7230

UpdateVector handlerUpdatePrimGroupScale = OnUpdatePrimGroupScale;

7231

if (handlerUpdatePrimGroupScale != null)

7232

handlerUpdatePrimGroupScale(scale.ObjectData[i].ObjectLocalID, scale.ObjectData[i].Scale, this);

}

return true;

}

private bool HandleObjectRotation(IClientAPI sender, Packet Pack)

7239

{

7240

// DEPRECATED: but till libsecondlife removes it, people will use it

7241

ObjectRotationPacket rotation = (ObjectRotationPacket)Pack;

7242

7243

#region Packet Session and User Check

7244

if (m_checkPackets)

7245

{

7246

if (rotation.AgentData.SessionID != SessionId ||

7247

rotation.AgentData.AgentID != AgentId)

return true;

}

#endregion

for (int i = 0; i < rotation.ObjectData.Length; i++)

7253

{

7254

UpdatePrimRotation handlerUpdatePrimRotation = OnUpdatePrimGroupRotation;

7255

if (handlerUpdatePrimRotation != null)

7256

                    handlerUpdatePrimRotation(rotation.ObjectData[i].ObjectLocalID, rotation.ObjectData[i].Rotation, this);

}

return true;

}

private bool HandleObjectFlagUpdate(IClientAPI sender, Packet Pack)

7263

{

7264

ObjectFlagUpdatePacket flags = (ObjectFlagUpdatePacket)Pack;

7265

7266

#region Packet Session and User Check

7267

if (m_checkPackets)

7268

{

7269

if (flags.AgentData.SessionID != SessionId ||

7270

flags.AgentData.AgentID != AgentId)

return true;

}

#endregion

UpdatePrimFlags handlerUpdatePrimFlags = OnUpdatePrimFlags;

7276

7277

if (handlerUpdatePrimFlags != null)

7278

{

7279

// byte[] data = Pack.ToBytes();

7280

// 46,47,48 are special positions within the packet

7281

// This may change so perhaps we need a better way

7282

// of storing this (OMV.FlagUpdatePacket.UsePhysics,etc?)

7283

/*

7284

bool UsePhysics = (data[46] != 0) ? true : false;

7285

bool IsTemporary = (data[47] != 0) ? true : false;

7286

bool IsPhantom = (data[48] != 0) ? true : false;

7287

                                handlerUpdatePrimFlags(flags.AgentData.ObjectLocalID, UsePhysics, IsTemporary, IsPhantom, this);

7288

*/

7289

bool UsePhysics = flags.AgentData.UsePhysics;

7290

bool IsPhantom = flags.AgentData.IsPhantom;

7291

bool IsTemporary = flags.AgentData.IsTemporary;

7292

ObjectFlagUpdatePacket.ExtraPhysicsBlock[] blocks = flags.ExtraPhysics;

7293

ExtraPhysicsData physdata = new ExtraPhysicsData();

7294

7295

if (blocks == null || blocks.Length == 0)

7296

{

7297

physdata.PhysShapeType = PhysShapeType.invalid;

}

else

{

ObjectFlagUpdatePacket.ExtraPhysicsBlock phsblock = blocks[0];

7302

physdata.PhysShapeType = (PhysShapeType)phsblock.PhysicsShapeType;

7303

physdata.Bounce = phsblock.Restitution;

7304

physdata.Density = phsblock.Density;

7305

physdata.Friction = phsblock.Friction;

7306

physdata.GravitationModifier = phsblock.GravityMultiplier;

7307

}

7308

7309

                handlerUpdatePrimFlags(flags.AgentData.ObjectLocalID, UsePhysics, IsTemporary, IsPhantom, physdata, this);

}

return true;

}

private bool HandleObjectImage(IClientAPI sender, Packet Pack)

7315

{

7316

ObjectImagePacket imagePack = (ObjectImagePacket)Pack;

7317

7318

UpdatePrimTexture handlerUpdatePrimTexture = null;

7319

for (int i = 0; i < imagePack.ObjectData.Length; i++)

7320

{

7321

handlerUpdatePrimTexture = OnUpdatePrimTexture;

7322

if (handlerUpdatePrimTexture != null)

7323

{

7324

handlerUpdatePrimTexture(imagePack.ObjectData[i].ObjectLocalID,

7325

imagePack.ObjectData[i].TextureEntry, this);

}

}

return true;

}

private bool HandleObjectGrab(IClientAPI sender, Packet Pack)

7332

{

7333

ObjectGrabPacket grab = (ObjectGrabPacket)Pack;

7334

7335

#region Packet Session and User Check

7336

if (m_checkPackets)

7337

{

7338

if (grab.AgentData.SessionID != SessionId ||

7339

grab.AgentData.AgentID != AgentId)

return true;

}

#endregion

GrabObject handlerGrabObject = OnGrabObject;

7345

7346

if (handlerGrabObject != null)

7347

{

7348

List<SurfaceTouchEventArgs> touchArgs = new List<SurfaceTouchEventArgs>();

7349

if ((grab.SurfaceInfo != null) && (grab.SurfaceInfo.Length > 0))

7350

{

7351

foreach (ObjectGrabPacket.SurfaceInfoBlock surfaceInfo in grab.SurfaceInfo)

7352

{

7353

SurfaceTouchEventArgs arg = new SurfaceTouchEventArgs();

7354

arg.Binormal = surfaceInfo.Binormal;

7355

arg.FaceIndex = surfaceInfo.FaceIndex;

7356

arg.Normal = surfaceInfo.Normal;

7357

arg.Position = surfaceInfo.Position;

7358

arg.STCoord = surfaceInfo.STCoord;

7359

arg.UVCoord = surfaceInfo.UVCoord;

7360

touchArgs.Add(arg);

7361

}

7362

}

7363

handlerGrabObject(grab.ObjectData.LocalID, grab.ObjectData.GrabOffset, this, touchArgs);

}

return true;

}

private bool HandleObjectGrabUpdate(IClientAPI sender, Packet Pack)

7369

{

7370

ObjectGrabUpdatePacket grabUpdate = (ObjectGrabUpdatePacket)Pack;

7371

7372

#region Packet Session and User Check

7373

if (m_checkPackets)

7374

{

7375

if (grabUpdate.AgentData.SessionID != SessionId ||

7376

grabUpdate.AgentData.AgentID != AgentId)

return true;

}

#endregion

MoveObject handlerGrabUpdate = OnGrabUpdate;

7382

7383

if (handlerGrabUpdate != null)

7384

{

7385

List<SurfaceTouchEventArgs> touchArgs = new List<SurfaceTouchEventArgs>();

7386

if ((grabUpdate.SurfaceInfo != null) && (grabUpdate.SurfaceInfo.Length > 0))

7387

{

7388

foreach (ObjectGrabUpdatePacket.SurfaceInfoBlock surfaceInfo in grabUpdate.SurfaceInfo)

7389

{

7390

SurfaceTouchEventArgs arg = new SurfaceTouchEventArgs();

7391

arg.Binormal = surfaceInfo.Binormal;

7392

arg.FaceIndex = surfaceInfo.FaceIndex;

7393

arg.Normal = surfaceInfo.Normal;

7394

arg.Position = surfaceInfo.Position;

7395

arg.STCoord = surfaceInfo.STCoord;

7396

arg.UVCoord = surfaceInfo.UVCoord;

7397

touchArgs.Add(arg);

7398

}

7399

}

7400

handlerGrabUpdate(grabUpdate.ObjectData.ObjectID, grabUpdate.ObjectData.GrabOffsetInitial,

7401

grabUpdate.ObjectData.GrabPosition, this, touchArgs);

}

return true;

}

private bool HandleObjectDeGrab(IClientAPI sender, Packet Pack)

7407

{

7408

ObjectDeGrabPacket deGrab = (ObjectDeGrabPacket)Pack;

7409

7410

#region Packet Session and User Check

7411

if (m_checkPackets)

7412

{

7413

if (deGrab.AgentData.SessionID != SessionId ||

7414

deGrab.AgentData.AgentID != AgentId)

return true;

}

#endregion

DeGrabObject handlerDeGrabObject = OnDeGrabObject;

7420

if (handlerDeGrabObject != null)

7421

{

7422

List<SurfaceTouchEventArgs> touchArgs = new List<SurfaceTouchEventArgs>();

7423

if ((deGrab.SurfaceInfo != null) && (deGrab.SurfaceInfo.Length > 0))

7424

{

7425

foreach (ObjectDeGrabPacket.SurfaceInfoBlock surfaceInfo in deGrab.SurfaceInfo)

7426

{

7427

SurfaceTouchEventArgs arg = new SurfaceTouchEventArgs();

7428

arg.Binormal = surfaceInfo.Binormal;

7429

arg.FaceIndex = surfaceInfo.FaceIndex;

7430

arg.Normal = surfaceInfo.Normal;

7431

arg.Position = surfaceInfo.Position;

7432

arg.STCoord = surfaceInfo.STCoord;

7433

arg.UVCoord = surfaceInfo.UVCoord;

7434

touchArgs.Add(arg);

7435

}

7436

}

7437

handlerDeGrabObject(deGrab.ObjectData.LocalID, this, touchArgs);

}

return true;

}

private bool HandleObjectSpinStart(IClientAPI sender, Packet Pack)

7443

{

7444

//m_log.Warn("[CLIENT]: unhandled ObjectSpinStart packet");

7445

ObjectSpinStartPacket spinStart = (ObjectSpinStartPacket)Pack;

7446

7447

#region Packet Session and User Check

7448

if (m_checkPackets)

7449

{

7450

if (spinStart.AgentData.SessionID != SessionId ||

7451

spinStart.AgentData.AgentID != AgentId)

return true;

}

#endregion

SpinStart handlerSpinStart = OnSpinStart;

7457

if (handlerSpinStart != null)

7458

{

7459

handlerSpinStart(spinStart.ObjectData.ObjectID, this);

}

return true;

}

private bool HandleObjectSpinUpdate(IClientAPI sender, Packet Pack)

7465

{

7466

//m_log.Warn("[CLIENT]: unhandled ObjectSpinUpdate packet");

7467

ObjectSpinUpdatePacket spinUpdate = (ObjectSpinUpdatePacket)Pack;

7468

7469

#region Packet Session and User Check

7470

if (m_checkPackets)

7471

{

7472

if (spinUpdate.AgentData.SessionID != SessionId ||

7473

spinUpdate.AgentData.AgentID != AgentId)

return true;

}

#endregion

Vector3 axis;

float angle;

spinUpdate.ObjectData.Rotation.GetAxisAngle(out axis, out angle);

7481

//m_log.Warn("[CLIENT]: ObjectSpinUpdate packet rot axis:" + axis + " angle:" + angle);

7482

7483

SpinObject handlerSpinUpdate = OnSpinUpdate;

7484

if (handlerSpinUpdate != null)

7485

{

7486

handlerSpinUpdate(spinUpdate.ObjectData.ObjectID, spinUpdate.ObjectData.Rotation, this);

}

return true;

}

private bool HandleObjectSpinStop(IClientAPI sender, Packet Pack)

7492

{

7493

//m_log.Warn("[CLIENT]: unhandled ObjectSpinStop packet");

7494

ObjectSpinStopPacket spinStop = (ObjectSpinStopPacket)Pack;

7495

7496

#region Packet Session and User Check

7497

if (m_checkPackets)

7498

{

7499

if (spinStop.AgentData.SessionID != SessionId ||

7500

spinStop.AgentData.AgentID != AgentId)

return true;

}

#endregion

SpinStop handlerSpinStop = OnSpinStop;

7506

if (handlerSpinStop != null)

7507

{

7508

handlerSpinStop(spinStop.ObjectData.ObjectID, this);

}

return true;

}

private bool HandleObjectDescription(IClientAPI sender, Packet Pack)

7514

{

7515

ObjectDescriptionPacket objDes = (ObjectDescriptionPacket)Pack;

7516

7517

#region Packet Session and User Check

7518

if (m_checkPackets)

7519

{

7520

if (objDes.AgentData.SessionID != SessionId ||

7521

objDes.AgentData.AgentID != AgentId)

return true;

}

#endregion

GenericCall7 handlerObjectDescription = null;

7527

7528

for (int i = 0; i < objDes.ObjectData.Length; i++)

7529

{

7530

handlerObjectDescription = OnObjectDescription;

7531

if (handlerObjectDescription != null)

7532

{

7533

handlerObjectDescription(this, objDes.ObjectData[i].LocalID,

7534

Util.FieldToString(objDes.ObjectData[i].Description));

}

}

return true;

}

private bool HandleObjectName(IClientAPI sender, Packet Pack)

7541

{

7542

ObjectNamePacket objName = (ObjectNamePacket)Pack;

7543

7544

#region Packet Session and User Check

7545

if (m_checkPackets)

7546

{

7547

if (objName.AgentData.SessionID != SessionId ||

7548

objName.AgentData.AgentID != AgentId)

return true;

}

#endregion

GenericCall7 handlerObjectName = null;

7554

for (int i = 0; i < objName.ObjectData.Length; i++)

7555

{

7556

handlerObjectName = OnObjectName;

7557

if (handlerObjectName != null)

7558

{

7559

handlerObjectName(this, objName.ObjectData[i].LocalID,

7560

Util.FieldToString(objName.ObjectData[i].Name));

}

}

return true;

}

private bool HandleObjectPermissions(IClientAPI sender, Packet Pack)

7567

{

7568

if (OnObjectPermissions != null)

7569

{

7570

ObjectPermissionsPacket newobjPerms = (ObjectPermissionsPacket)Pack;

7571

7572

#region Packet Session and User Check

7573

if (m_checkPackets)

7574

{

7575

if (newobjPerms.AgentData.SessionID != SessionId ||

7576

newobjPerms.AgentData.AgentID != AgentId)

return true;

}

#endregion

UUID AgentID = newobjPerms.AgentData.AgentID;

7582

UUID SessionID = newobjPerms.AgentData.SessionID;

7583

7584

ObjectPermissions handlerObjectPermissions = null;

7585

7586

for (int i = 0; i < newobjPerms.ObjectData.Length; i++)

7587

{

7588

ObjectPermissionsPacket.ObjectDataBlock permChanges = newobjPerms.ObjectData[i];

7589

7590

byte field = permChanges.Field;

7591

uint localID = permChanges.ObjectLocalID;

7592

uint mask = permChanges.Mask;

7593

byte set = permChanges.Set;

7594

7595

handlerObjectPermissions = OnObjectPermissions;

7596

7597

if (handlerObjectPermissions != null)

7598

handlerObjectPermissions(this, AgentID, SessionID, field, localID, mask, set);

}

}

// Here's our data,

7603

// PermField contains the field the info goes into

7604

// PermField determines which mask we're changing

7605

//

7606

// chmask is the mask of the change

7607

// setTF is whether we're adding it or taking it away

7608

//

7609

// objLocalID is the localID of the object.

7610

7611

// Unfortunately, we have to pass the event the packet because objData is an array

7612

// That means multiple object perms may be updated in a single packet.

return true;

}

private bool HandleUndo(IClientAPI sender, Packet Pack)

7618

{

7619

UndoPacket undoitem = (UndoPacket)Pack;

7620

7621

#region Packet Session and User Check

7622

if (m_checkPackets)

7623

{

7624

if (undoitem.AgentData.SessionID != SessionId ||

7625

undoitem.AgentData.AgentID != AgentId)

return true;

}

#endregion

if (undoitem.ObjectData.Length > 0)

7631

{

7632

for (int i = 0; i < undoitem.ObjectData.Length; i++)

7633

{

7634

UUID objiD = undoitem.ObjectData[i].ObjectID;

7635

AgentSit handlerOnUndo = OnUndo;

7636

if (handlerOnUndo != null)

7637

{

7638

handlerOnUndo(this, objiD);

}

}

}

return true;

}

private bool HandleLandUndo(IClientAPI sender, Packet Pack)

7647

{

7648

UndoLandPacket undolanditem = (UndoLandPacket)Pack;

7649

7650

#region Packet Session and User Check

7651

if (m_checkPackets)

7652

{

7653

if (undolanditem.AgentData.SessionID != SessionId ||

7654

undolanditem.AgentData.AgentID != AgentId)

return true;

}

#endregion

LandUndo handlerOnUndo = OnLandUndo;

7660

if (handlerOnUndo != null)

7661

{

7662

handlerOnUndo(this);

}

return true;

}

private bool HandleRedo(IClientAPI sender, Packet Pack)

7668

{

7669

RedoPacket redoitem = (RedoPacket)Pack;

7670

7671

#region Packet Session and User Check

7672

if (m_checkPackets)

7673

{

7674

if (redoitem.AgentData.SessionID != SessionId ||

7675

redoitem.AgentData.AgentID != AgentId)

return true;

}

#endregion

if (redoitem.ObjectData.Length > 0)

7681

{

7682

for (int i = 0; i < redoitem.ObjectData.Length; i++)

7683

{

7684

UUID objiD = redoitem.ObjectData[i].ObjectID;

7685

AgentSit handlerOnRedo = OnRedo;

7686

if (handlerOnRedo != null)

7687

{

7688

handlerOnRedo(this, objiD);

}

}

}

return true;

}

private bool HandleObjectDuplicateOnRay(IClientAPI sender, Packet Pack)

7697

{

7698

ObjectDuplicateOnRayPacket dupeOnRay = (ObjectDuplicateOnRayPacket)Pack;

7699

7700

#region Packet Session and User Check

7701

if (m_checkPackets)

7702

{

7703

if (dupeOnRay.AgentData.SessionID != SessionId ||

7704

dupeOnRay.AgentData.AgentID != AgentId)

return true;

}

#endregion

ObjectDuplicateOnRay handlerObjectDuplicateOnRay = null;

7710

7711

for (int i = 0; i < dupeOnRay.ObjectData.Length; i++)

7712

{

7713

handlerObjectDuplicateOnRay = OnObjectDuplicateOnRay;

7714

if (handlerObjectDuplicateOnRay != null)

7715

{

7716

                    handlerObjectDuplicateOnRay(dupeOnRay.ObjectData[i].ObjectLocalID, dupeOnRay.AgentData.DuplicateFlags,

7717

                                                AgentId, m_activeGroupID, dupeOnRay.AgentData.RayTargetID, dupeOnRay.AgentData.RayEnd,

7718

                                                dupeOnRay.AgentData.RayStart, dupeOnRay.AgentData.BypassRaycast, dupeOnRay.AgentData.RayEndIsIntersection,

7719

dupeOnRay.AgentData.CopyCenters, dupeOnRay.AgentData.CopyRotates);

}

}

return true;

}

private bool HandleRequestObjectPropertiesFamily(IClientAPI sender, Packet Pack)

7727

{

7728

//This powers the little tooltip that appears when you move your mouse over an object

7729

RequestObjectPropertiesFamilyPacket packToolTip = (RequestObjectPropertiesFamilyPacket)Pack;

7730

7731

#region Packet Session and User Check

7732

if (m_checkPackets)

7733

{

7734

if (packToolTip.AgentData.SessionID != SessionId ||

7735

packToolTip.AgentData.AgentID != AgentId)

return true;

}

#endregion

RequestObjectPropertiesFamilyPacket.ObjectDataBlock packObjBlock = packToolTip.ObjectData;

7741

7742

RequestObjectPropertiesFamily handlerRequestObjectPropertiesFamily = OnRequestObjectPropertiesFamily;

7743

7744

if (handlerRequestObjectPropertiesFamily != null)

7745

{

7746

handlerRequestObjectPropertiesFamily(this, m_agentId, packObjBlock.RequestFlags,

7747

packObjBlock.ObjectID);

}

return true;

}

private bool HandleObjectIncludeInSearch(IClientAPI sender, Packet Pack)

7754

{

7755

//This lets us set objects to appear in search (stuff like DataSnapshot, etc)

7756

ObjectIncludeInSearchPacket packInSearch = (ObjectIncludeInSearchPacket)Pack;

7757

ObjectIncludeInSearch handlerObjectIncludeInSearch = null;

7758

7759

#region Packet Session and User Check

7760

if (m_checkPackets)

7761

{

7762

if (packInSearch.AgentData.SessionID != SessionId ||

7763

packInSearch.AgentData.AgentID != AgentId)

return true;

}

#endregion

foreach (ObjectIncludeInSearchPacket.ObjectDataBlock objData in packInSearch.ObjectData)

7769

{

7770

bool inSearch = objData.IncludeInSearch;

7771

uint localID = objData.ObjectLocalID;

7772

7773

handlerObjectIncludeInSearch = OnObjectIncludeInSearch;

7774

7775

if (handlerObjectIncludeInSearch != null)

7776

{

7777

handlerObjectIncludeInSearch(this, inSearch, localID);

}

}

return true;

}

private bool HandleScriptAnswerYes(IClientAPI sender, Packet Pack)

7784

{

7785

ScriptAnswerYesPacket scriptAnswer = (ScriptAnswerYesPacket)Pack;

7786

7787

#region Packet Session and User Check

7788

if (m_checkPackets)

7789

{

7790

if (scriptAnswer.AgentData.SessionID != SessionId ||

7791

scriptAnswer.AgentData.AgentID != AgentId)

return true;

}

#endregion

ScriptAnswer handlerScriptAnswer = OnScriptAnswer;

7797

if (handlerScriptAnswer != null)

7798

{

7799

                handlerScriptAnswer(this, scriptAnswer.Data.TaskID, scriptAnswer.Data.ItemID, scriptAnswer.Data.Questions);

}

return true;

}

private bool HandleObjectClickAction(IClientAPI sender, Packet Pack)

7805

{

7806

ObjectClickActionPacket ocpacket = (ObjectClickActionPacket)Pack;

7807

7808

#region Packet Session and User Check

7809

if (m_checkPackets)

7810

{

7811

if (ocpacket.AgentData.SessionID != SessionId ||

7812

ocpacket.AgentData.AgentID != AgentId)

return true;

}

#endregion

GenericCall7 handlerObjectClickAction = OnObjectClickAction;

7818

if (handlerObjectClickAction != null)

7819

{

7820

foreach (ObjectClickActionPacket.ObjectDataBlock odata in ocpacket.ObjectData)

7821

{

7822

byte action = odata.ClickAction;

7823

uint localID = odata.ObjectLocalID;

7824

handlerObjectClickAction(this, localID, action.ToString());

}

}

return true;

}

private bool HandleObjectMaterial(IClientAPI sender, Packet Pack)

7831

{

7832

ObjectMaterialPacket ompacket = (ObjectMaterialPacket)Pack;

7833

7834

#region Packet Session and User Check

7835

if (m_checkPackets)

7836

{

7837

if (ompacket.AgentData.SessionID != SessionId ||

7838

ompacket.AgentData.AgentID != AgentId)

return true;

}

#endregion

GenericCall7 handlerObjectMaterial = OnObjectMaterial;

7844

if (handlerObjectMaterial != null)

7845

{

7846

foreach (ObjectMaterialPacket.ObjectDataBlock odata in ompacket.ObjectData)

7847

{

7848

byte material = odata.Material;

7849

uint localID = odata.ObjectLocalID;

7850

handlerObjectMaterial(this, localID, material.ToString());

}

}

return true;

}

#endregion Objects/m_sceneObjects

7857

7858

#region Inventory/Asset/Other related packets

7859

7860

private bool HandleRequestImage(IClientAPI sender, Packet Pack)

7861

{

7862

RequestImagePacket imageRequest = (RequestImagePacket)Pack;

7863

//m_log.Debug("image request: " + Pack.ToString());

7864

7865

#region Packet Session and User Check

7866

if (m_checkPackets)

7867

{

7868

if (imageRequest.AgentData.SessionID != SessionId ||

7869

imageRequest.AgentData.AgentID != AgentId)

return true;

}

#endregion

//handlerTextureRequest = null;

7875

for (int i = 0; i < imageRequest.RequestImage.Length; i++)

7876

{

7877

TextureRequestArgs args = new TextureRequestArgs();

7878

7879

RequestImagePacket.RequestImageBlock block = imageRequest.RequestImage[i];

7880

7881

args.RequestedAssetID = block.Image;

7882

args.DiscardLevel = block.DiscardLevel;

7883

args.PacketNumber = block.Packet;

7884

args.Priority = block.DownloadPriority;

7885

args.requestSequence = imageRequest.Header.Sequence;

7886

7887

// NOTE: This is not a built in part of the LLUDP protocol, but we double the

7888

// priority of avatar textures to get avatars rezzing in faster than the

7889

// surrounding scene

7890

if ((ImageType)block.Type == ImageType.Baked)

7891

args.Priority *= 2.0f;

7892

7893

ImageManager.EnqueueReq(args);

}

return true;

}

/// <summary>

/// This is the entry point for the UDP route by which the client can retrieve asset data. If the request

7901

/// is successful then a TransferInfo packet will be sent back, followed by one or more TransferPackets

7902

/// </summary>

7903

/// <param name="sender"></param>

7904

/// <param name="Pack"></param>

7905

/// <returns>This parameter may be ignored since we appear to return true whatever happens</returns>

7906

private bool HandleTransferRequest(IClientAPI sender, Packet Pack)

7907

{

7908

//m_log.Debug("ClientView.ProcessPackets.cs:ProcessInPacket() - Got transfer request");

7909

7910

TransferRequestPacket transfer = (TransferRequestPacket)Pack;

7911

UUID taskID = UUID.Zero;

7912

if (transfer.TransferInfo.SourceType == (int)SourceType.SimInventoryItem)

7913

{

7914

if (!(((Scene)m_scene).Permissions.BypassPermissions()))

7915

{

7916

// We're spawning a thread because the permissions check can block this thread

7917

Util.FireAndForget(delegate

7918

{

7919

// This requests the asset if needed

7920

HandleSimInventoryTransferRequestWithPermsCheck(sender, transfer);

});

return true;

}

}

else if (transfer.TransferInfo.SourceType == (int)SourceType.SimEstate)

7926

{

7927

//TransferRequestPacket does not include covenant uuid?

7928

//get scene covenant uuid

7929

taskID = m_scene.RegionInfo.RegionSettings.Covenant;

7930

}

7931

7932

// This is non-blocking

7933

MakeAssetRequest(transfer, taskID);

return true;

}

private void HandleSimInventoryTransferRequestWithPermsCheck(IClientAPI sender, TransferRequestPacket transfer)

7939

{

7940

UUID taskID = new UUID(transfer.TransferInfo.Params, 48);

7941

UUID itemID = new UUID(transfer.TransferInfo.Params, 64);

7942

UUID requestID = new UUID(transfer.TransferInfo.Params, 80);

7943

7944

//m_log.DebugFormat(

7945

// "[CLIENT]: Got request for asset {0} from item {1} in prim {2} by {3}",

7946

// requestID, itemID, taskID, Name);

7947

7948

//m_log.Debug("Transfer Request: " + transfer.ToString());

7949

// Validate inventory transfers

7950

// Has to be done here, because AssetCache can't do it

7951

//

7952

if (taskID != UUID.Zero) // Prim

7953

{

7954

SceneObjectPart part = ((Scene)m_scene).GetSceneObjectPart(taskID);

if (part == null)

{

m_log.WarnFormat(

"[CLIENT]: {0} requested asset {1} from item {2} in prim {3} but prim does not exist",

7960

Name, requestID, itemID, taskID);

return;

}

TaskInventoryItem tii = part.Inventory.GetInventoryItem(itemID);

if (tii == null)

{

m_log.WarnFormat(

"[CLIENT]: {0} requested asset {1} from item {2} in prim {3} but item does not exist",

7969

Name, requestID, itemID, taskID);

return;

}

if (tii.Type == (int)AssetType.LSLText)

7974

{

7975

if (!((Scene)m_scene).Permissions.CanEditScript(itemID, taskID, AgentId))

7976

return;

7977

}

7978

else if (tii.Type == (int)AssetType.Notecard)

7979

{

7980

if (!((Scene)m_scene).Permissions.CanEditNotecard(itemID, taskID, AgentId))

return;

}

else

{

// TODO: Change this code to allow items other than notecards and scripts to be successfully

7986

                    // shared with group.  In fact, this whole block of permissions checking should move to an IPermissionsModule

7987

if (part.OwnerID != AgentId)

7988

{

7989

m_log.WarnFormat(

7990

"[CLIENT]: {0} requested asset {1} from item {2} in prim {3} but the prim is owned by {4}",

7991

Name, requestID, itemID, taskID, part.OwnerID);

return;

}

if ((part.OwnerMask & (uint)PermissionMask.Modify) == 0)

7996

{

7997

m_log.WarnFormat(

7998

                            "[CLIENT]: {0} requested asset {1} from item {2} in prim {3} but modify permissions are not set",

7999

Name, requestID, itemID, taskID);

return;

}

if (tii.OwnerID != AgentId)

8004

{

8005

m_log.WarnFormat(

8006

"[CLIENT]: {0} requested asset {1} from item {2} in prim {3} but the item is owned by {4}",

8007

Name, requestID, itemID, taskID, tii.OwnerID);

return;

}

if ((

                        tii.CurrentPermissions & ((uint)PermissionMask.Modify | (uint)PermissionMask.Copy | (uint)PermissionMask.Transfer))

8013

                            != ((uint)PermissionMask.Modify | (uint)PermissionMask.Copy | (uint)PermissionMask.Transfer))

8014

{

8015

m_log.WarnFormat(

8016

                            "[CLIENT]: {0} requested asset {1} from item {2} in prim {3} but item permissions are not modify/copy/transfer",

8017

Name, requestID, itemID, taskID);

return;

}

if (tii.AssetID != requestID)

8022

{

8023

m_log.WarnFormat(

8024

                            "[CLIENT]: {0} requested asset {1} from item {2} in prim {3} but this does not match item's asset {4}",

8025

Name, requestID, itemID, taskID, tii.AssetID);

return;

}

}

}

else // Agent

{

IInventoryAccessModule invAccess = m_scene.RequestModuleInterface<IInventoryAccessModule>();

8033

if (invAccess != null)

8034

{

8035

if (!invAccess.CanGetAgentInventoryItem(this, itemID, requestID))

return;

}

else

{

return;

}

}

// Permissions out of the way, let's request the asset

8045

MakeAssetRequest(transfer, taskID);

}

private bool HandleAssetUploadRequest(IClientAPI sender, Packet Pack)

8051

{

8052

AssetUploadRequestPacket request = (AssetUploadRequestPacket)Pack;

8053

8054

// m_log.Debug("upload request " + request.ToString());

8055

            // m_log.Debug("upload request was for assetid: " + request.AssetBlock.TransactionID.Combine(this.SecureSessionId).ToString());

8056

UUID temp = UUID.Combine(request.AssetBlock.TransactionID, SecureSessionId);

8057

8058

UDPAssetUploadRequest handlerAssetUploadRequest = OnAssetUploadRequest;

8059

8060

if (handlerAssetUploadRequest != null)

8061

{

8062

handlerAssetUploadRequest(this, temp,

8063

request.AssetBlock.TransactionID, request.AssetBlock.Type,

8064

request.AssetBlock.AssetData, request.AssetBlock.StoreLocal,

8065

request.AssetBlock.Tempfile);

}

return true;

}

private bool HandleRequestXfer(IClientAPI sender, Packet Pack)

8071

{

8072

RequestXferPacket xferReq = (RequestXferPacket)Pack;

8073

8074

RequestXfer handlerRequestXfer = OnRequestXfer;

8075

8076

if (handlerRequestXfer != null)

8077

{

8078

handlerRequestXfer(this, xferReq.XferID.ID, Util.FieldToString(xferReq.XferID.Filename));

}

return true;

}

private bool HandleSendXferPacket(IClientAPI sender, Packet Pack)

8084

{

8085

SendXferPacketPacket xferRec = (SendXferPacketPacket)Pack;

8086

8087

XferReceive handlerXferReceive = OnXferReceive;

8088

if (handlerXferReceive != null)

8089

{

8090

handlerXferReceive(this, xferRec.XferID.ID, xferRec.XferID.Packet, xferRec.DataPacket.Data);

}

return true;

}

private bool HandleConfirmXferPacket(IClientAPI sender, Packet Pack)

8096

{

8097

ConfirmXferPacketPacket confirmXfer = (ConfirmXferPacketPacket)Pack;

8098

8099

ConfirmXfer handlerConfirmXfer = OnConfirmXfer;

8100

if (handlerConfirmXfer != null)

8101

{

8102

handlerConfirmXfer(this, confirmXfer.XferID.ID, confirmXfer.XferID.Packet);

}

return true;

}

private bool HandleAbortXfer(IClientAPI sender, Packet Pack)

8108

{

8109

AbortXferPacket abortXfer = (AbortXferPacket)Pack;

8110

AbortXfer handlerAbortXfer = OnAbortXfer;

8111

if (handlerAbortXfer != null)

8112

{

8113

handlerAbortXfer(this, abortXfer.XferID.ID);

}

return true;

}

private bool HandleCreateInventoryFolder(IClientAPI sender, Packet Pack)

8120

{

8121

CreateInventoryFolderPacket invFolder = (CreateInventoryFolderPacket)Pack;

8122

8123

#region Packet Session and User Check

8124

if (m_checkPackets)

8125

{

8126

if (invFolder.AgentData.SessionID != SessionId ||

8127

invFolder.AgentData.AgentID != AgentId)

return true;

}

#endregion

CreateInventoryFolder handlerCreateInventoryFolder = OnCreateNewInventoryFolder;

8133

if (handlerCreateInventoryFolder != null)

8134

{

8135

handlerCreateInventoryFolder(this, invFolder.FolderData.FolderID,

8136

(ushort)invFolder.FolderData.Type,

8137

Util.FieldToString(invFolder.FolderData.Name),

8138

invFolder.FolderData.ParentID);

}

return true;

}

private bool HandleUpdateInventoryFolder(IClientAPI sender, Packet Pack)

8144

{

8145

if (OnUpdateInventoryFolder != null)

8146

{

8147

UpdateInventoryFolderPacket invFolderx = (UpdateInventoryFolderPacket)Pack;

8148

8149

#region Packet Session and User Check

8150

if (m_checkPackets)

8151

{

8152

if (invFolderx.AgentData.SessionID != SessionId ||

8153

invFolderx.AgentData.AgentID != AgentId)

return true;

}

#endregion

UpdateInventoryFolder handlerUpdateInventoryFolder = null;

8159

8160

for (int i = 0; i < invFolderx.FolderData.Length; i++)

8161

{

8162

handlerUpdateInventoryFolder = OnUpdateInventoryFolder;

8163

if (handlerUpdateInventoryFolder != null)

8164

{

8165

OnUpdateInventoryFolder(this, invFolderx.FolderData[i].FolderID,

8166

(ushort)invFolderx.FolderData[i].Type,

8167

Util.FieldToString(invFolderx.FolderData[i].Name),

8168

invFolderx.FolderData[i].ParentID);

}

}

}

return true;

}

private bool HandleMoveInventoryFolder(IClientAPI sender, Packet Pack)

8176

{

8177

if (OnMoveInventoryFolder != null)

8178

{

8179

MoveInventoryFolderPacket invFoldery = (MoveInventoryFolderPacket)Pack;

8180

8181

#region Packet Session and User Check

8182

if (m_checkPackets)

8183

{

8184

if (invFoldery.AgentData.SessionID != SessionId ||

8185

invFoldery.AgentData.AgentID != AgentId)

return true;

}

#endregion

MoveInventoryFolder handlerMoveInventoryFolder = null;

8191

8192

for (int i = 0; i < invFoldery.InventoryData.Length; i++)

8193

{

8194

handlerMoveInventoryFolder = OnMoveInventoryFolder;

8195

if (handlerMoveInventoryFolder != null)

8196

{

8197

OnMoveInventoryFolder(this, invFoldery.InventoryData[i].FolderID,

8198

invFoldery.InventoryData[i].ParentID);

}

}

}

return true;

}

private bool HandleCreateInventoryItem(IClientAPI sender, Packet Pack)

8206

{

8207

CreateInventoryItemPacket createItem = (CreateInventoryItemPacket)Pack;

8208

8209

#region Packet Session and User Check

8210

if (m_checkPackets)

8211

{

8212

if (createItem.AgentData.SessionID != SessionId ||

8213

createItem.AgentData.AgentID != AgentId)

return true;

}

#endregion

CreateNewInventoryItem handlerCreateNewInventoryItem = OnCreateNewInventoryItem;

8219

if (handlerCreateNewInventoryItem != null)

8220

{

8221

handlerCreateNewInventoryItem(this, createItem.InventoryBlock.TransactionID,

8222

createItem.InventoryBlock.FolderID,

8223

createItem.InventoryBlock.CallbackID,

8224

Util.FieldToString(createItem.InventoryBlock.Description),

8225

Util.FieldToString(createItem.InventoryBlock.Name),

8226

createItem.InventoryBlock.InvType,

8227

createItem.InventoryBlock.Type,

8228

createItem.InventoryBlock.WearableType,

8229

createItem.InventoryBlock.NextOwnerMask,

8230

Util.UnixTimeSinceEpoch());

}

return true;

}

private bool HandleLinkInventoryItem(IClientAPI sender, Packet Pack)

8236

{

8237

LinkInventoryItemPacket createLink = (LinkInventoryItemPacket)Pack;

8238

8239

#region Packet Session and User Check

8240

if (m_checkPackets)

8241

{

8242

if (createLink.AgentData.SessionID != SessionId ||

8243

createLink.AgentData.AgentID != AgentId)

return true;

}

#endregion

LinkInventoryItem linkInventoryItem = OnLinkInventoryItem;

8249

8250

if (linkInventoryItem != null)

{

linkInventoryItem(

this,

createLink.InventoryBlock.TransactionID,

8255

createLink.InventoryBlock.FolderID,

8256

createLink.InventoryBlock.CallbackID,

8257

Util.FieldToString(createLink.InventoryBlock.Description),

8258

Util.FieldToString(createLink.InventoryBlock.Name),

8259

createLink.InventoryBlock.InvType,

8260

createLink.InventoryBlock.Type,

8261

createLink.InventoryBlock.OldItemID);

}

return true;

}

private bool HandleFetchInventory(IClientAPI sender, Packet Pack)

8268

{

8269

if (OnFetchInventory != null)

8270

{

8271

FetchInventoryPacket FetchInventoryx = (FetchInventoryPacket)Pack;

8272

8273

#region Packet Session and User Check

8274

if (m_checkPackets)

8275

{

8276

if (FetchInventoryx.AgentData.SessionID != SessionId ||

8277

FetchInventoryx.AgentData.AgentID != AgentId)

return true;

}

#endregion

FetchInventory handlerFetchInventory = null;

8283

8284

for (int i = 0; i < FetchInventoryx.InventoryData.Length; i++)

8285

{

8286

handlerFetchInventory = OnFetchInventory;

8287

8288

if (handlerFetchInventory != null)

8289

{

8290

OnFetchInventory(this, FetchInventoryx.InventoryData[i].ItemID,

8291

FetchInventoryx.InventoryData[i].OwnerID);

}

}

}

return true;

}

private bool HandleFetchInventoryDescendents(IClientAPI sender, Packet Pack)

8299

{

8300

FetchInventoryDescendentsPacket Fetch = (FetchInventoryDescendentsPacket)Pack;

8301

8302

#region Packet Session and User Check

8303

if (m_checkPackets)

8304

{

8305

if (Fetch.AgentData.SessionID != SessionId ||

8306

Fetch.AgentData.AgentID != AgentId)

return true;

}

#endregion

FetchInventoryDescendents handlerFetchInventoryDescendents = OnFetchInventoryDescendents;

8312

if (handlerFetchInventoryDescendents != null)

8313

{

8314

handlerFetchInventoryDescendents(this, Fetch.InventoryData.FolderID, Fetch.InventoryData.OwnerID,

8315

Fetch.InventoryData.FetchFolders, Fetch.InventoryData.FetchItems,

8316

Fetch.InventoryData.SortOrder);

}

return true;

}

private bool HandlePurgeInventoryDescendents(IClientAPI sender, Packet Pack)

8322

{

8323

PurgeInventoryDescendentsPacket Purge = (PurgeInventoryDescendentsPacket)Pack;

8324

8325

#region Packet Session and User Check

8326

if (m_checkPackets)

8327

{

8328

if (Purge.AgentData.SessionID != SessionId ||

8329

Purge.AgentData.AgentID != AgentId)

return true;

}

#endregion

PurgeInventoryDescendents handlerPurgeInventoryDescendents = OnPurgeInventoryDescendents;

8335

if (handlerPurgeInventoryDescendents != null)

8336

{

8337

handlerPurgeInventoryDescendents(this, Purge.InventoryData.FolderID);

}

return true;

}

private bool HandleUpdateInventoryItem(IClientAPI sender, Packet Pack)

8343

{

8344

UpdateInventoryItemPacket inventoryItemUpdate = (UpdateInventoryItemPacket)Pack;

8345

8346

#region Packet Session and User Check

8347

if (m_checkPackets)

8348

{

8349

if (inventoryItemUpdate.AgentData.SessionID != SessionId ||

8350

inventoryItemUpdate.AgentData.AgentID != AgentId)

return true;

}

#endregion

if (OnUpdateInventoryItem != null)

8356

{

8357

UpdateInventoryItem handlerUpdateInventoryItem = null;

8358

for (int i = 0; i < inventoryItemUpdate.InventoryData.Length; i++)

8359

{

8360

handlerUpdateInventoryItem = OnUpdateInventoryItem;

8361

8362

if (handlerUpdateInventoryItem != null)

8363

{

8364

InventoryItemBase itemUpd = new InventoryItemBase();

8365

itemUpd.ID = inventoryItemUpdate.InventoryData[i].ItemID;

8366

itemUpd.Name = Util.FieldToString(inventoryItemUpdate.InventoryData[i].Name);

8367

itemUpd.Description = Util.FieldToString(inventoryItemUpdate.InventoryData[i].Description);

8368

itemUpd.GroupID = inventoryItemUpdate.InventoryData[i].GroupID;

8369

itemUpd.GroupOwned = inventoryItemUpdate.InventoryData[i].GroupOwned;

8370

itemUpd.GroupPermissions = inventoryItemUpdate.InventoryData[i].GroupMask;

8371

itemUpd.NextPermissions = inventoryItemUpdate.InventoryData[i].NextOwnerMask;

8372

itemUpd.EveryOnePermissions = inventoryItemUpdate.InventoryData[i].EveryoneMask;

8373

itemUpd.CreationDate = inventoryItemUpdate.InventoryData[i].CreationDate;

8374

itemUpd.Folder = inventoryItemUpdate.InventoryData[i].FolderID;

8375

itemUpd.InvType = inventoryItemUpdate.InventoryData[i].InvType;

8376

itemUpd.SalePrice = inventoryItemUpdate.InventoryData[i].SalePrice;

8377

itemUpd.SaleType = inventoryItemUpdate.InventoryData[i].SaleType;

8378

itemUpd.Flags = inventoryItemUpdate.InventoryData[i].Flags;

8379

8380

OnUpdateInventoryItem(this, inventoryItemUpdate.InventoryData[i].TransactionID,

8381

inventoryItemUpdate.InventoryData[i].ItemID,

itemUpd);

}

}

}

return true;

}

private bool HandleCopyInventoryItem(IClientAPI sender, Packet Pack)

8390

{

8391

CopyInventoryItemPacket copyitem = (CopyInventoryItemPacket)Pack;

8392

8393

#region Packet Session and User Check

8394

if (m_checkPackets)

8395

{

8396

if (copyitem.AgentData.SessionID != SessionId ||

8397

copyitem.AgentData.AgentID != AgentId)

return true;

}

#endregion

CopyInventoryItem handlerCopyInventoryItem = null;

8403

if (OnCopyInventoryItem != null)

8404

{

8405

foreach (CopyInventoryItemPacket.InventoryDataBlock datablock in copyitem.InventoryData)

8406

{

8407

handlerCopyInventoryItem = OnCopyInventoryItem;

8408

if (handlerCopyInventoryItem != null)

8409

{

8410

handlerCopyInventoryItem(this, datablock.CallbackID, datablock.OldAgentID,

8411

datablock.OldItemID, datablock.NewFolderID,

8412

Util.FieldToString(datablock.NewName));

}

}

}

return true;

}

private bool HandleMoveInventoryItem(IClientAPI sender, Packet Pack)

8420

{

8421

MoveInventoryItemPacket moveitem = (MoveInventoryItemPacket)Pack;

8422

8423

#region Packet Session and User Check

8424

if (m_checkPackets)

8425

{

8426

if (moveitem.AgentData.SessionID != SessionId ||

8427

moveitem.AgentData.AgentID != AgentId)

return true;

}

#endregion

if (OnMoveInventoryItem != null)

8433

{

8434

MoveInventoryItem handlerMoveInventoryItem = null;

8435

InventoryItemBase itm = null;

8436

List<InventoryItemBase> items = new List<InventoryItemBase>();

8437

foreach (MoveInventoryItemPacket.InventoryDataBlock datablock in moveitem.InventoryData)

8438

{

8439

itm = new InventoryItemBase(datablock.ItemID, AgentId);

8440

itm.Folder = datablock.FolderID;

8441

itm.Name = Util.FieldToString(datablock.NewName);

8442

// weird, comes out as empty string

8443

//m_log.DebugFormat("[XXX] new name: {0}", itm.Name);

8444

items.Add(itm);

8445

}

8446

handlerMoveInventoryItem = OnMoveInventoryItem;

8447

if (handlerMoveInventoryItem != null)

8448

{

8449

handlerMoveInventoryItem(this, items);

}

}

return true;

}

private bool HandleRemoveInventoryItem(IClientAPI sender, Packet Pack)

8456

{

8457

RemoveInventoryItemPacket removeItem = (RemoveInventoryItemPacket)Pack;

8458

8459

#region Packet Session and User Check

8460

if (m_checkPackets)

8461

{

8462

if (removeItem.AgentData.SessionID != SessionId ||

8463

removeItem.AgentData.AgentID != AgentId)

return true;

}

#endregion

if (OnRemoveInventoryItem != null)

8469

{

8470

RemoveInventoryItem handlerRemoveInventoryItem = null;

8471

List<UUID> uuids = new List<UUID>();

8472

foreach (RemoveInventoryItemPacket.InventoryDataBlock datablock in removeItem.InventoryData)

8473

{

8474

uuids.Add(datablock.ItemID);

8475

}

8476

handlerRemoveInventoryItem = OnRemoveInventoryItem;

8477

if (handlerRemoveInventoryItem != null)

8478

{

8479

handlerRemoveInventoryItem(this, uuids);

}

}

return true;

}

private bool HandleRemoveInventoryFolder(IClientAPI sender, Packet Pack)

8487

{

8488

RemoveInventoryFolderPacket removeFolder = (RemoveInventoryFolderPacket)Pack;

8489

8490

#region Packet Session and User Check

8491

if (m_checkPackets)

8492

{

8493

if (removeFolder.AgentData.SessionID != SessionId ||

8494

removeFolder.AgentData.AgentID != AgentId)

return true;

}

#endregion

if (OnRemoveInventoryFolder != null)

8500

{

8501

RemoveInventoryFolder handlerRemoveInventoryFolder = null;

8502

List<UUID> uuids = new List<UUID>();

8503

foreach (RemoveInventoryFolderPacket.FolderDataBlock datablock in removeFolder.FolderData)

8504

{

8505

uuids.Add(datablock.FolderID);

8506

}

8507

handlerRemoveInventoryFolder = OnRemoveInventoryFolder;

8508

if (handlerRemoveInventoryFolder != null)

8509

{

8510

handlerRemoveInventoryFolder(this, uuids);

}

}

return true;

}

private bool HandleRemoveInventoryObjects(IClientAPI sender, Packet Pack)

8517

{

8518

RemoveInventoryObjectsPacket removeObject = (RemoveInventoryObjectsPacket)Pack;

8519

#region Packet Session and User Check

8520

if (m_checkPackets)

8521

{

8522

if (removeObject.AgentData.SessionID != SessionId ||

8523

removeObject.AgentData.AgentID != AgentId)

return true;

}

#endregion

if (OnRemoveInventoryFolder != null)

8528

{

8529

RemoveInventoryFolder handlerRemoveInventoryFolder = null;

8530

List<UUID> uuids = new List<UUID>();

8531

foreach (RemoveInventoryObjectsPacket.FolderDataBlock datablock in removeObject.FolderData)

8532

{

8533

uuids.Add(datablock.FolderID);

8534

}

8535

handlerRemoveInventoryFolder = OnRemoveInventoryFolder;

8536

if (handlerRemoveInventoryFolder != null)

8537

{

8538

handlerRemoveInventoryFolder(this, uuids);

}

}

if (OnRemoveInventoryItem != null)

8543

{

8544

RemoveInventoryItem handlerRemoveInventoryItem = null;

8545

List<UUID> uuids = new List<UUID>();

8546

foreach (RemoveInventoryObjectsPacket.ItemDataBlock datablock in removeObject.ItemData)

8547

{

8548

uuids.Add(datablock.ItemID);

8549

}

8550

handlerRemoveInventoryItem = OnRemoveInventoryItem;

8551

if (handlerRemoveInventoryItem != null)

8552

{

8553

handlerRemoveInventoryItem(this, uuids);

}

}

return true;

}

private bool HandleRequestTaskInventory(IClientAPI sender, Packet Pack)

8560

{

8561

RequestTaskInventoryPacket requesttask = (RequestTaskInventoryPacket)Pack;

8562

8563

#region Packet Session and User Check

8564

if (m_checkPackets)

8565

{

8566

if (requesttask.AgentData.SessionID != SessionId ||

8567

requesttask.AgentData.AgentID != AgentId)

return true;

}

#endregion

RequestTaskInventory handlerRequestTaskInventory = OnRequestTaskInventory;

8573

if (handlerRequestTaskInventory != null)

8574

{

8575

handlerRequestTaskInventory(this, requesttask.InventoryData.LocalID);

}

return true;

}

private bool HandleUpdateTaskInventory(IClientAPI sender, Packet Pack)

8581

{

8582

UpdateTaskInventoryPacket updatetask = (UpdateTaskInventoryPacket)Pack;

8583

8584

#region Packet Session and User Check

8585

if (m_checkPackets)

8586

{

8587

if (updatetask.AgentData.SessionID != SessionId ||

8588

updatetask.AgentData.AgentID != AgentId)

return true;

}

#endregion

if (OnUpdateTaskInventory != null)

8594

{

8595

if (updatetask.UpdateData.Key == 0)

8596

{

8597

UpdateTaskInventory handlerUpdateTaskInventory = OnUpdateTaskInventory;

8598

if (handlerUpdateTaskInventory != null)

8599

{

8600

TaskInventoryItem newTaskItem = new TaskInventoryItem();

8601

newTaskItem.ItemID = updatetask.InventoryData.ItemID;

8602

newTaskItem.ParentID = updatetask.InventoryData.FolderID;

8603

newTaskItem.CreatorID = updatetask.InventoryData.CreatorID;

8604

newTaskItem.OwnerID = updatetask.InventoryData.OwnerID;

8605

newTaskItem.GroupID = updatetask.InventoryData.GroupID;

8606

newTaskItem.BasePermissions = updatetask.InventoryData.BaseMask;

8607

newTaskItem.CurrentPermissions = updatetask.InventoryData.OwnerMask;

8608

newTaskItem.GroupPermissions = updatetask.InventoryData.GroupMask;

8609

newTaskItem.EveryonePermissions = updatetask.InventoryData.EveryoneMask;

8610

newTaskItem.NextPermissions = updatetask.InventoryData.NextOwnerMask;

8611

8612

                        // Unused?  Clicking share with group sets GroupPermissions instead, so perhaps this is something

8613

// different

8614

//newTaskItem.GroupOwned=updatetask.InventoryData.GroupOwned;

8615

newTaskItem.Type = updatetask.InventoryData.Type;

8616

newTaskItem.InvType = updatetask.InventoryData.InvType;

8617

newTaskItem.Flags = updatetask.InventoryData.Flags;

8618

//newTaskItem.SaleType=updatetask.InventoryData.SaleType;

8619

//newTaskItem.SalePrice=updatetask.InventoryData.SalePrice;

8620

newTaskItem.Name = Util.FieldToString(updatetask.InventoryData.Name);

8621

newTaskItem.Description = Util.FieldToString(updatetask.InventoryData.Description);

8622

newTaskItem.CreationDate = (uint)updatetask.InventoryData.CreationDate;

8623

handlerUpdateTaskInventory(this, updatetask.InventoryData.TransactionID,

8624

newTaskItem, updatetask.UpdateData.LocalID);

}

}

}

return true;

}

private bool HandleRemoveTaskInventory(IClientAPI sender, Packet Pack)

8633

{

8634

RemoveTaskInventoryPacket removeTask = (RemoveTaskInventoryPacket)Pack;

8635

8636

#region Packet Session and User Check

8637

if (m_checkPackets)

8638

{

8639

if (removeTask.AgentData.SessionID != SessionId ||

8640

removeTask.AgentData.AgentID != AgentId)

return true;

}

#endregion

RemoveTaskInventory handlerRemoveTaskItem = OnRemoveTaskItem;

8646

8647

if (handlerRemoveTaskItem != null)

8648

{

8649

handlerRemoveTaskItem(this, removeTask.InventoryData.ItemID, removeTask.InventoryData.LocalID);

}

return true;

}

private bool HandleMoveTaskInventory(IClientAPI sender, Packet Pack)

8656

{

8657

MoveTaskInventoryPacket moveTaskInventoryPacket = (MoveTaskInventoryPacket)Pack;

8658

8659

#region Packet Session and User Check

8660

if (m_checkPackets)

8661

{

8662

if (moveTaskInventoryPacket.AgentData.SessionID != SessionId ||

8663

moveTaskInventoryPacket.AgentData.AgentID != AgentId)

return true;

}

#endregion

MoveTaskInventory handlerMoveTaskItem = OnMoveTaskItem;

8669

8670

if (handlerMoveTaskItem != null)

8671

{

8672

handlerMoveTaskItem(

8673

this, moveTaskInventoryPacket.AgentData.FolderID,

8674

moveTaskInventoryPacket.InventoryData.LocalID,

8675

moveTaskInventoryPacket.InventoryData.ItemID);

}

return true;

}

private bool HandleRezScript(IClientAPI sender, Packet Pack)

8682

{

8683

//m_log.Debug(Pack.ToString());

8684

RezScriptPacket rezScriptx = (RezScriptPacket)Pack;

8685

8686

#region Packet Session and User Check

8687

if (m_checkPackets)

8688

{

8689

if (rezScriptx.AgentData.SessionID != SessionId ||

8690

rezScriptx.AgentData.AgentID != AgentId)

return true;

}

#endregion

RezScript handlerRezScript = OnRezScript;

8696

InventoryItemBase item = new InventoryItemBase();

8697

item.ID = rezScriptx.InventoryBlock.ItemID;

8698

item.Folder = rezScriptx.InventoryBlock.FolderID;

8699

item.CreatorId = rezScriptx.InventoryBlock.CreatorID.ToString();

8700

item.Owner = rezScriptx.InventoryBlock.OwnerID;

8701

item.BasePermissions = rezScriptx.InventoryBlock.BaseMask;

8702

item.CurrentPermissions = rezScriptx.InventoryBlock.OwnerMask;

8703

item.EveryOnePermissions = rezScriptx.InventoryBlock.EveryoneMask;

8704

item.NextPermissions = rezScriptx.InventoryBlock.NextOwnerMask;

8705

item.GroupPermissions = rezScriptx.InventoryBlock.GroupMask;

8706

item.GroupOwned = rezScriptx.InventoryBlock.GroupOwned;

8707

item.GroupID = rezScriptx.InventoryBlock.GroupID;

8708

item.AssetType = rezScriptx.InventoryBlock.Type;

8709

item.InvType = rezScriptx.InventoryBlock.InvType;

8710

item.Flags = rezScriptx.InventoryBlock.Flags;

8711

item.SaleType = rezScriptx.InventoryBlock.SaleType;

8712

item.SalePrice = rezScriptx.InventoryBlock.SalePrice;

8713

item.Name = Util.FieldToString(rezScriptx.InventoryBlock.Name);

8714

item.Description = Util.FieldToString(rezScriptx.InventoryBlock.Description);

8715

item.CreationDate = rezScriptx.InventoryBlock.CreationDate;

8716

8717

if (handlerRezScript != null)

8718

{

8719

                handlerRezScript(this, item, rezScriptx.InventoryBlock.TransactionID, rezScriptx.UpdateBlock.ObjectLocalID);

}

return true;

}

private bool HandleMapLayerRequest(IClientAPI sender, Packet Pack)

{

RequestMapLayer();

return true;

}

private bool HandleMapBlockRequest(IClientAPI sender, Packet Pack)

8731

{

8732

MapBlockRequestPacket MapRequest = (MapBlockRequestPacket)Pack;

8733

8734

#region Packet Session and User Check

8735

if (m_checkPackets)

8736

{

8737

if (MapRequest.AgentData.SessionID != SessionId ||

8738

MapRequest.AgentData.AgentID != AgentId)

return true;

}

#endregion

RequestMapBlocks handlerRequestMapBlocks = OnRequestMapBlocks;

8744

if (handlerRequestMapBlocks != null)

8745

{

8746

handlerRequestMapBlocks(this, MapRequest.PositionData.MinX, MapRequest.PositionData.MinY,

8747

                                        MapRequest.PositionData.MaxX, MapRequest.PositionData.MaxY, MapRequest.AgentData.Flags);

}

return true;

}

private bool HandleMapNameRequest(IClientAPI sender, Packet Pack)

8753

{

8754

MapNameRequestPacket map = (MapNameRequestPacket)Pack;

8755

8756

#region Packet Session and User Check

8757

if (m_checkPackets)

8758

{

8759

if (map.AgentData.SessionID != SessionId ||

8760

map.AgentData.AgentID != AgentId)

return true;

}

#endregion

string mapName = Util.UTF8.GetString(map.NameData.Name, 0,

8765

map.NameData.Name.Length - 1);

8766

RequestMapName handlerMapNameRequest = OnMapNameRequest;

8767

if (handlerMapNameRequest != null)

8768

{

8769

handlerMapNameRequest(this, mapName, map.AgentData.Flags);

}

return true;

}

private bool HandleTeleportLandmarkRequest(IClientAPI sender, Packet Pack)

8775

{

8776

TeleportLandmarkRequestPacket tpReq = (TeleportLandmarkRequestPacket)Pack;

8777

8778

#region Packet Session and User Check

8779

if (m_checkPackets)

8780

{

8781

if (tpReq.Info.SessionID != SessionId ||

8782

tpReq.Info.AgentID != AgentId)

return true;

}

#endregion

UUID lmid = tpReq.Info.LandmarkID;

8788

AssetLandmark lm;

8789

if (lmid != UUID.Zero)

8790

{

8791

8792

//AssetBase lma = m_assetCache.GetAsset(lmid, false);

8793

AssetBase lma = m_assetService.Get(lmid.ToString());

if (lma == null)

{

// Failed to find landmark

8798

8799

// Let's try to search in the user's home asset server

8800

lma = FindAssetInUserAssetServer(lmid.ToString());

if (lma == null)

{

// Really doesn't exist

8805

                        TeleportCancelPacket tpCancel = (TeleportCancelPacket)PacketPool.Instance.GetPacket(PacketType.TeleportCancel);

8806

tpCancel.Info.SessionID = tpReq.Info.SessionID;

8807

tpCancel.Info.AgentID = tpReq.Info.AgentID;

8808

OutPacket(tpCancel, ThrottleOutPacketType.Task);

}

}

try

{

lm = new AssetLandmark(lma);

8815

}

8816

catch (NullReferenceException)

8817

{

8818

// asset not found generates null ref inside the assetlandmark constructor.

8819

                    TeleportCancelPacket tpCancel = (TeleportCancelPacket)PacketPool.Instance.GetPacket(PacketType.TeleportCancel);

8820

tpCancel.Info.SessionID = tpReq.Info.SessionID;

8821

tpCancel.Info.AgentID = tpReq.Info.AgentID;

8822

OutPacket(tpCancel, ThrottleOutPacketType.Task);

return true;

}

}

else

{

// Teleport home request

8829

UUIDNameRequest handlerTeleportHomeRequest = OnTeleportHomeRequest;

8830

if (handlerTeleportHomeRequest != null)

8831

{

8832

handlerTeleportHomeRequest(AgentId, this);

}

return true;

}

TeleportLandmarkRequest handlerTeleportLandmarkRequest = OnTeleportLandmarkRequest;

8838

if (handlerTeleportLandmarkRequest != null)

8839

{

8840

handlerTeleportLandmarkRequest(this, lm);

}

else

{

//no event handler so cancel request

8845

                TeleportCancelPacket tpCancel = (TeleportCancelPacket)PacketPool.Instance.GetPacket(PacketType.TeleportCancel);

8846

tpCancel.Info.AgentID = tpReq.Info.AgentID;

8847

tpCancel.Info.SessionID = tpReq.Info.SessionID;

8848

OutPacket(tpCancel, ThrottleOutPacketType.Task);

}

return true;

}

private bool HandleTeleportCancel(IClientAPI sender, Packet Pack)

8855

{

8856

TeleportCancel handlerTeleportCancel = OnTeleportCancel;

8857

if (handlerTeleportCancel != null)

8858

{

8859

handlerTeleportCancel(this);

}

return true;

}

private AssetBase FindAssetInUserAssetServer(string id)

8865

{

8866

AgentCircuitData aCircuit = ((Scene)Scene).AuthenticateHandler.GetAgentCircuitData(CircuitCode);

8867

if (aCircuit != null && aCircuit.ServiceURLs != null && aCircuit.ServiceURLs.ContainsKey("AssetServerURI"))

8868

{

8869

string assetServer = aCircuit.ServiceURLs["AssetServerURI"].ToString();

8870

return ((Scene)Scene).AssetService.Get(assetServer + "/" + id);

}

return null;

}

private bool HandleTeleportLocationRequest(IClientAPI sender, Packet Pack)

8877

{

8878

TeleportLocationRequestPacket tpLocReq = (TeleportLocationRequestPacket)Pack;

8879

// m_log.Debug(tpLocReq.ToString());

8880

8881

#region Packet Session and User Check

8882

if (m_checkPackets)

8883

{

8884

if (tpLocReq.AgentData.SessionID != SessionId ||

8885

tpLocReq.AgentData.AgentID != AgentId)

return true;

}

#endregion

TeleportLocationRequest handlerTeleportLocationRequest = OnTeleportLocationRequest;

8891

if (handlerTeleportLocationRequest != null)

8892

{

8893

handlerTeleportLocationRequest(this, tpLocReq.Info.RegionHandle, tpLocReq.Info.Position,

8894

tpLocReq.Info.LookAt, 16);

}

else

{

//no event handler so cancel request

8899

                TeleportCancelPacket tpCancel = (TeleportCancelPacket)PacketPool.Instance.GetPacket(PacketType.TeleportCancel);

8900

tpCancel.Info.SessionID = tpLocReq.AgentData.SessionID;

8901

tpCancel.Info.AgentID = tpLocReq.AgentData.AgentID;

8902

OutPacket(tpCancel, ThrottleOutPacketType.Task);

}

return true;

}

#endregion Inventory/Asset/Other related packets

8908

8909

private bool HandleUUIDNameRequest(IClientAPI sender, Packet Pack)

8910

{

8911

UUIDNameRequestPacket incoming = (UUIDNameRequestPacket)Pack;

8912

8913

foreach (UUIDNameRequestPacket.UUIDNameBlockBlock UUIDBlock in incoming.UUIDNameBlock)

8914

{

8915

UUIDNameRequest handlerNameRequest = OnNameFromUUIDRequest;

8916

if (handlerNameRequest != null)

8917

{

8918

handlerNameRequest(UUIDBlock.ID, this);

}

}

return true;

}

#region Parcel related packets

8925

8926

private bool HandleRegionHandleRequest(IClientAPI sender, Packet Pack)

8927

{

8928

RegionHandleRequestPacket rhrPack = (RegionHandleRequestPacket)Pack;

8929

8930

RegionHandleRequest handlerRegionHandleRequest = OnRegionHandleRequest;

8931

if (handlerRegionHandleRequest != null)

8932

{

8933

handlerRegionHandleRequest(this, rhrPack.RequestBlock.RegionID);

}

return true;

}

private bool HandleParcelInfoRequest(IClientAPI sender, Packet Pack)

8939

{

8940

ParcelInfoRequestPacket pirPack = (ParcelInfoRequestPacket)Pack;

8941

8942

#region Packet Session and User Check

8943

if (m_checkPackets)

8944

{

8945

if (pirPack.AgentData.SessionID != SessionId ||

8946

pirPack.AgentData.AgentID != AgentId)

return true;

}

#endregion

ParcelInfoRequest handlerParcelInfoRequest = OnParcelInfoRequest;

8952

if (handlerParcelInfoRequest != null)

8953

{

8954

handlerParcelInfoRequest(this, pirPack.Data.ParcelID);

}

return true;

}

private bool HandleParcelAccessListRequest(IClientAPI sender, Packet Pack)

8960

{

8961

ParcelAccessListRequestPacket requestPacket = (ParcelAccessListRequestPacket)Pack;

8962

8963

#region Packet Session and User Check

8964

if (m_checkPackets)

8965

{

8966

if (requestPacket.AgentData.SessionID != SessionId ||

8967

requestPacket.AgentData.AgentID != AgentId)

return true;

}

#endregion

ParcelAccessListRequest handlerParcelAccessListRequest = OnParcelAccessListRequest;

8973

8974

if (handlerParcelAccessListRequest != null)

8975

{

8976

handlerParcelAccessListRequest(requestPacket.AgentData.AgentID, requestPacket.AgentData.SessionID,

8977

requestPacket.Data.Flags, requestPacket.Data.SequenceID,

8978

requestPacket.Data.LocalID, this);

}

return true;

}

private bool HandleParcelAccessListUpdate(IClientAPI sender, Packet Pack)

8984

{

8985

ParcelAccessListUpdatePacket updatePacket = (ParcelAccessListUpdatePacket)Pack;

8986

8987

#region Packet Session and User Check

8988

if (m_checkPackets)

8989

{

8990

if (updatePacket.AgentData.SessionID != SessionId ||

8991

updatePacket.AgentData.AgentID != AgentId)

return true;

}

#endregion

List<LandAccessEntry> entries = new List<LandAccessEntry>();

8997

foreach (ParcelAccessListUpdatePacket.ListBlock block in updatePacket.List)

8998

{

8999

LandAccessEntry entry = new LandAccessEntry();

9000

entry.AgentID = block.ID;

9001

entry.Flags = (AccessList)block.Flags;

9002

entry.Expires = block.Time;

9003

entries.Add(entry);

9004

}

9005

9006

ParcelAccessListUpdateRequest handlerParcelAccessListUpdateRequest = OnParcelAccessListUpdateRequest;

9007

if (handlerParcelAccessListUpdateRequest != null)

9008

{

9009

handlerParcelAccessListUpdateRequest(updatePacket.AgentData.AgentID,

9010

updatePacket.Data.Flags,

9011

updatePacket.Data.LocalID,

9012

updatePacket.Data.TransactionID,

9013

updatePacket.Data.SequenceID,

9014

updatePacket.Data.Sections,

entries, this);

}

return true;

}

private bool HandleParcelPropertiesRequest(IClientAPI sender, Packet Pack)

9021

{

9022

ParcelPropertiesRequestPacket propertiesRequest = (ParcelPropertiesRequestPacket)Pack;

9023

9024

#region Packet Session and User Check

9025

if (m_checkPackets)

9026

{

9027

if (propertiesRequest.AgentData.SessionID != SessionId ||

9028

propertiesRequest.AgentData.AgentID != AgentId)

return true;

}

#endregion

ParcelPropertiesRequest handlerParcelPropertiesRequest = OnParcelPropertiesRequest;

9034

if (handlerParcelPropertiesRequest != null)

9035

{

9036

handlerParcelPropertiesRequest((int)Math.Round(propertiesRequest.ParcelData.West),

9037

(int)Math.Round(propertiesRequest.ParcelData.South),

9038

(int)Math.Round(propertiesRequest.ParcelData.East),

9039

(int)Math.Round(propertiesRequest.ParcelData.North),

9040

propertiesRequest.ParcelData.SequenceID,

9041

propertiesRequest.ParcelData.SnapSelection, this);

}

return true;

}

private bool HandleParcelDivide(IClientAPI sender, Packet Pack)

9047

{

9048

ParcelDividePacket landDivide = (ParcelDividePacket)Pack;

9049

9050

#region Packet Session and User Check

9051

if (m_checkPackets)

9052

{

9053

if (landDivide.AgentData.SessionID != SessionId ||

9054

landDivide.AgentData.AgentID != AgentId)

return true;

}

#endregion

ParcelDivideRequest handlerParcelDivideRequest = OnParcelDivideRequest;

9060

if (handlerParcelDivideRequest != null)

9061

{

9062

handlerParcelDivideRequest((int)Math.Round(landDivide.ParcelData.West),

9063

(int)Math.Round(landDivide.ParcelData.South),

9064

(int)Math.Round(landDivide.ParcelData.East),

9065

(int)Math.Round(landDivide.ParcelData.North), this);

}

return true;

}

private bool HandleParcelJoin(IClientAPI sender, Packet Pack)

9071

{

9072

ParcelJoinPacket landJoin = (ParcelJoinPacket)Pack;

9073

9074

#region Packet Session and User Check

9075

if (m_checkPackets)

9076

{

9077

if (landJoin.AgentData.SessionID != SessionId ||

9078

landJoin.AgentData.AgentID != AgentId)

return true;

}

#endregion

ParcelJoinRequest handlerParcelJoinRequest = OnParcelJoinRequest;

9084

9085

if (handlerParcelJoinRequest != null)

9086

{

9087

handlerParcelJoinRequest((int)Math.Round(landJoin.ParcelData.West),

9088

(int)Math.Round(landJoin.ParcelData.South),

9089

(int)Math.Round(landJoin.ParcelData.East),

9090

(int)Math.Round(landJoin.ParcelData.North), this);

}

return true;

}

private bool HandleParcelPropertiesUpdate(IClientAPI sender, Packet Pack)

9096

{

9097

ParcelPropertiesUpdatePacket parcelPropertiesPacket = (ParcelPropertiesUpdatePacket)Pack;

9098

9099

#region Packet Session and User Check

9100

if (m_checkPackets)

9101

{

9102

if (parcelPropertiesPacket.AgentData.SessionID != SessionId ||

9103

parcelPropertiesPacket.AgentData.AgentID != AgentId)

return true;

}

#endregion

ParcelPropertiesUpdateRequest handlerParcelPropertiesUpdateRequest = OnParcelPropertiesUpdateRequest;

9109

9110

if (handlerParcelPropertiesUpdateRequest != null)

9111

{

9112

LandUpdateArgs args = new LandUpdateArgs();

9113

9114

args.AuthBuyerID = parcelPropertiesPacket.ParcelData.AuthBuyerID;

9115

args.Category = (ParcelCategory)parcelPropertiesPacket.ParcelData.Category;

9116

args.Desc = Utils.BytesToString(parcelPropertiesPacket.ParcelData.Desc);

9117

args.GroupID = parcelPropertiesPacket.ParcelData.GroupID;

9118

args.LandingType = parcelPropertiesPacket.ParcelData.LandingType;

9119

args.MediaAutoScale = parcelPropertiesPacket.ParcelData.MediaAutoScale;

9120

args.MediaID = parcelPropertiesPacket.ParcelData.MediaID;

9121

args.MediaURL = Utils.BytesToString(parcelPropertiesPacket.ParcelData.MediaURL);

9122

args.MusicURL = Utils.BytesToString(parcelPropertiesPacket.ParcelData.MusicURL);

9123

args.Name = Utils.BytesToString(parcelPropertiesPacket.ParcelData.Name);

9124

args.ParcelFlags = parcelPropertiesPacket.ParcelData.ParcelFlags;

9125

args.PassHours = parcelPropertiesPacket.ParcelData.PassHours;

9126

args.PassPrice = parcelPropertiesPacket.ParcelData.PassPrice;

9127

args.SalePrice = parcelPropertiesPacket.ParcelData.SalePrice;

9128

args.SnapshotID = parcelPropertiesPacket.ParcelData.SnapshotID;

9129

args.UserLocation = parcelPropertiesPacket.ParcelData.UserLocation;

9130

args.UserLookAt = parcelPropertiesPacket.ParcelData.UserLookAt;

9131

handlerParcelPropertiesUpdateRequest(args, parcelPropertiesPacket.ParcelData.LocalID, this);

}

return true;

}

private bool HandleParcelSelectObjects(IClientAPI sender, Packet Pack)

9137

{

9138

ParcelSelectObjectsPacket selectPacket = (ParcelSelectObjectsPacket)Pack;

9139

9140

#region Packet Session and User Check

9141

if (m_checkPackets)

9142

{

9143

if (selectPacket.AgentData.SessionID != SessionId ||

9144

selectPacket.AgentData.AgentID != AgentId)

return true;

}

#endregion

List<UUID> returnIDs = new List<UUID>();

9150

9151

foreach (ParcelSelectObjectsPacket.ReturnIDsBlock rb in

9152

selectPacket.ReturnIDs)

9153

{

9154

returnIDs.Add(rb.ReturnID);

9155

}

9156

9157

ParcelSelectObjects handlerParcelSelectObjects = OnParcelSelectObjects;

9158

9159

if (handlerParcelSelectObjects != null)

9160

{

9161

handlerParcelSelectObjects(selectPacket.ParcelData.LocalID,

9162

Convert.ToInt32(selectPacket.ParcelData.ReturnType), returnIDs, this);

}

return true;

}

private bool HandleParcelObjectOwnersRequest(IClientAPI sender, Packet Pack)

9168

{

9169

ParcelObjectOwnersRequestPacket reqPacket = (ParcelObjectOwnersRequestPacket)Pack;

9170

9171

#region Packet Session and User Check

9172

if (m_checkPackets)

9173

{

9174

if (reqPacket.AgentData.SessionID != SessionId ||

9175

reqPacket.AgentData.AgentID != AgentId)

return true;

}

#endregion

ParcelObjectOwnerRequest handlerParcelObjectOwnerRequest = OnParcelObjectOwnerRequest;

9181

9182

if (handlerParcelObjectOwnerRequest != null)

9183

{

9184

handlerParcelObjectOwnerRequest(reqPacket.ParcelData.LocalID, this);

}

return true;

}

private bool HandleParcelGodForceOwner(IClientAPI sender, Packet Pack)

9191

{

9192

ParcelGodForceOwnerPacket godForceOwnerPacket = (ParcelGodForceOwnerPacket)Pack;

9193

9194

#region Packet Session and User Check

9195

if (m_checkPackets)

9196

{

9197

if (godForceOwnerPacket.AgentData.SessionID != SessionId ||

9198

godForceOwnerPacket.AgentData.AgentID != AgentId)

return true;

}

#endregion

ParcelGodForceOwner handlerParcelGodForceOwner = OnParcelGodForceOwner;

9204

if (handlerParcelGodForceOwner != null)

9205

{

9206

handlerParcelGodForceOwner(godForceOwnerPacket.Data.LocalID, godForceOwnerPacket.Data.OwnerID, this);

}

return true;

}

private bool HandleParcelRelease(IClientAPI sender, Packet Pack)

9212

{

9213

ParcelReleasePacket releasePacket = (ParcelReleasePacket)Pack;

9214

9215

#region Packet Session and User Check

9216

if (m_checkPackets)

9217

{

9218

if (releasePacket.AgentData.SessionID != SessionId ||

9219

releasePacket.AgentData.AgentID != AgentId)

return true;

}

#endregion

ParcelAbandonRequest handlerParcelAbandonRequest = OnParcelAbandonRequest;

9225

if (handlerParcelAbandonRequest != null)

9226

{

9227

handlerParcelAbandonRequest(releasePacket.Data.LocalID, this);

}

return true;

}

private bool HandleParcelReclaim(IClientAPI sender, Packet Pack)

9233

{

9234

ParcelReclaimPacket reclaimPacket = (ParcelReclaimPacket)Pack;

9235

9236

#region Packet Session and User Check

9237

if (m_checkPackets)

9238

{

9239

if (reclaimPacket.AgentData.SessionID != SessionId ||

9240

reclaimPacket.AgentData.AgentID != AgentId)

return true;

}

#endregion

ParcelReclaim handlerParcelReclaim = OnParcelReclaim;

9246

if (handlerParcelReclaim != null)

9247

{

9248

handlerParcelReclaim(reclaimPacket.Data.LocalID, this);

}

return true;

}

private bool HandleParcelReturnObjects(IClientAPI sender, Packet Pack)

9254

{

9255

ParcelReturnObjectsPacket parcelReturnObjects = (ParcelReturnObjectsPacket)Pack;

9256

9257

#region Packet Session and User Check

9258

if (m_checkPackets)

9259

{

9260

if (parcelReturnObjects.AgentData.SessionID != SessionId ||

9261

parcelReturnObjects.AgentData.AgentID != AgentId)

return true;

}

#endregion

UUID[] puserselectedOwnerIDs = new UUID[parcelReturnObjects.OwnerIDs.Length];

9267

for (int parceliterator = 0; parceliterator < parcelReturnObjects.OwnerIDs.Length; parceliterator++)

9268

puserselectedOwnerIDs[parceliterator] = parcelReturnObjects.OwnerIDs[parceliterator].OwnerID;

9269

9270

UUID[] puserselectedTaskIDs = new UUID[parcelReturnObjects.TaskIDs.Length];

9271

9272

for (int parceliterator = 0; parceliterator < parcelReturnObjects.TaskIDs.Length; parceliterator++)

9273

puserselectedTaskIDs[parceliterator] = parcelReturnObjects.TaskIDs[parceliterator].TaskID;

9274

9275

ParcelReturnObjectsRequest handlerParcelReturnObjectsRequest = OnParcelReturnObjectsRequest;

9276

if (handlerParcelReturnObjectsRequest != null)

9277

{

9278

                handlerParcelReturnObjectsRequest(parcelReturnObjects.ParcelData.LocalID, parcelReturnObjects.ParcelData.ReturnType, puserselectedOwnerIDs, puserselectedTaskIDs, this);

}

return true;

}

private bool HandleParcelSetOtherCleanTime(IClientAPI sender, Packet Pack)

9285

{

9286

ParcelSetOtherCleanTimePacket parcelSetOtherCleanTimePacket = (ParcelSetOtherCleanTimePacket)Pack;

9287

9288

#region Packet Session and User Check

9289

if (m_checkPackets)

9290

{

9291

if (parcelSetOtherCleanTimePacket.AgentData.SessionID != SessionId ||

9292

parcelSetOtherCleanTimePacket.AgentData.AgentID != AgentId)

return true;

}

#endregion

ParcelSetOtherCleanTime handlerParcelSetOtherCleanTime = OnParcelSetOtherCleanTime;

9298

if (handlerParcelSetOtherCleanTime != null)

9299

{

9300

handlerParcelSetOtherCleanTime(this,

9301

parcelSetOtherCleanTimePacket.ParcelData.LocalID,

9302

parcelSetOtherCleanTimePacket.ParcelData.OtherCleanTime);

}

return true;

}

private bool HandleLandStatRequest(IClientAPI sender, Packet Pack)

9308

{

9309

LandStatRequestPacket lsrp = (LandStatRequestPacket)Pack;

9310

9311

#region Packet Session and User Check

9312

if (m_checkPackets)

9313

{

9314

if (lsrp.AgentData.SessionID != SessionId ||

9315

lsrp.AgentData.AgentID != AgentId)

return true;

}

#endregion

GodLandStatRequest handlerLandStatRequest = OnLandStatRequest;

9321

if (handlerLandStatRequest != null)

9322

{

9323

                handlerLandStatRequest(lsrp.RequestData.ParcelLocalID, lsrp.RequestData.ReportType, lsrp.RequestData.RequestFlags, Utils.BytesToString(lsrp.RequestData.Filter), this);

}

return true;

}

private bool HandleParcelDwellRequest(IClientAPI sender, Packet Pack)

9329

{

9330

ParcelDwellRequestPacket dwellrq =

9331

(ParcelDwellRequestPacket)Pack;

9332

9333

#region Packet Session and User Check

9334

if (m_checkPackets)

9335

{

9336

if (dwellrq.AgentData.SessionID != SessionId ||

9337

dwellrq.AgentData.AgentID != AgentId)

return true;

}

#endregion

ParcelDwellRequest handlerParcelDwellRequest = OnParcelDwellRequest;

9343

if (handlerParcelDwellRequest != null)

9344

{

9345

handlerParcelDwellRequest(dwellrq.Data.LocalID, this);

}

return true;

}

#endregion Parcel related packets

9351

9352

#region Estate Packets

9353

9354

private bool HandleEstateOwnerMessage(IClientAPI sender, Packet Pack)

9355

{

9356

EstateOwnerMessagePacket messagePacket = (EstateOwnerMessagePacket)Pack;

9357

// m_log.InfoFormat("[LLCLIENTVIEW]: Packet: {0}", Utils.BytesToString(messagePacket.MethodData.Method));

9358

GodLandStatRequest handlerLandStatRequest;

9359

9360

#region Packet Session and User Check

9361

if (m_checkPackets)

9362

{

9363

if (messagePacket.AgentData.SessionID != SessionId ||

9364

messagePacket.AgentData.AgentID != AgentId)

return true;

}

#endregion

string method = Utils.BytesToString(messagePacket.MethodData.Method);

switch (method)

{

case "getinfo":

if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false))

9375

{

9376

OnDetailedEstateDataRequest(this, messagePacket.MethodData.Invoice);

9377

}

9378

return true;

9379

case "setregioninfo":

9380

if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false))

9381

{

9382

                        OnSetEstateFlagsRequest(convertParamStringToBool(messagePacket.ParamList[0].Parameter), convertParamStringToBool(messagePacket.ParamList[1].Parameter),

9383

                                                convertParamStringToBool(messagePacket.ParamList[2].Parameter), !convertParamStringToBool(messagePacket.ParamList[3].Parameter),

9384

                                                Convert.ToInt16(Convert.ToDecimal(Utils.BytesToString(messagePacket.ParamList[4].Parameter), Culture.NumberFormatInfo)),

9385

                                                (float)Convert.ToDecimal(Utils.BytesToString(messagePacket.ParamList[5].Parameter), Culture.NumberFormatInfo),

9386

                                                Convert.ToInt16(Utils.BytesToString(messagePacket.ParamList[6].Parameter)),

9387

                                                convertParamStringToBool(messagePacket.ParamList[7].Parameter), convertParamStringToBool(messagePacket.ParamList[8].Parameter));

9388

}

9389

return true;

9390

// case "texturebase":

9391

                //                                if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false))

9392

// {

9393

                //                                    foreach (EstateOwnerMessagePacket.ParamListBlock block in messagePacket.ParamList)

9394

// {

9395

// string s = Utils.BytesToString(block.Parameter);

9396

// string[] splitField = s.Split(' ');

9397

// if (splitField.Length == 2)

9398

// {

9399

// UUID tempUUID = new UUID(splitField[1]);

9400

                //                                            OnSetEstateTerrainBaseTexture(this, Convert.ToInt16(splitField[0]), tempUUID);

// }

// }

// }

// break;

case "texturedetail":

9406

if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false))

9407

{

9408

foreach (EstateOwnerMessagePacket.ParamListBlock block in messagePacket.ParamList)

9409

{

9410

string s = Utils.BytesToString(block.Parameter);

9411

string[] splitField = s.Split(' ');

9412

if (splitField.Length == 2)

9413

{

9414

Int16 corner = Convert.ToInt16(splitField[0]);

9415

UUID textureUUID = new UUID(splitField[1]);

9416

9417

OnSetEstateTerrainDetailTexture(this, corner, textureUUID);

}

}

}

return true;

case "textureheights":

9424

if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false))

9425

{

9426

foreach (EstateOwnerMessagePacket.ParamListBlock block in messagePacket.ParamList)

9427

{

9428

string s = Utils.BytesToString(block.Parameter);

9429

string[] splitField = s.Split(' ');

9430

if (splitField.Length == 3)

9431

{

9432

Int16 corner = Convert.ToInt16(splitField[0]);

9433

float lowValue = (float)Convert.ToDecimal(splitField[1], Culture.NumberFormatInfo);

9434

float highValue = (float)Convert.ToDecimal(splitField[2], Culture.NumberFormatInfo);

9435

9436

OnSetEstateTerrainTextureHeights(this, corner, lowValue, highValue);

}

}

}

return true;

case "texturecommit":

9442

OnCommitEstateTerrainTextureRequest(this);

9443

return true;

9444

case "setregionterrain":

9445

if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false))

9446

{

9447

if (messagePacket.ParamList.Length != 9)

9448

{

9449

                            m_log.Error("EstateOwnerMessage: SetRegionTerrain method has a ParamList of invalid length");

}

else

{

try

{

string tmp = Utils.BytesToString(messagePacket.ParamList[0].Parameter);

9456

if (!tmp.Contains(".")) tmp += ".00";

9457

float WaterHeight = (float)Convert.ToDecimal(tmp, Culture.NumberFormatInfo);

9458

tmp = Utils.BytesToString(messagePacket.ParamList[1].Parameter);

9459

if (!tmp.Contains(".")) tmp += ".00";

9460

float TerrainRaiseLimit = (float)Convert.ToDecimal(tmp, Culture.NumberFormatInfo);

9461

tmp = Utils.BytesToString(messagePacket.ParamList[2].Parameter);

9462

if (!tmp.Contains(".")) tmp += ".00";

9463

float TerrainLowerLimit = (float)Convert.ToDecimal(tmp, Culture.NumberFormatInfo);

9464

bool UseEstateSun = convertParamStringToBool(messagePacket.ParamList[3].Parameter);

9465

bool UseFixedSun = convertParamStringToBool(messagePacket.ParamList[4].Parameter);

9466

                                float SunHour = (float)Convert.ToDecimal(Utils.BytesToString(messagePacket.ParamList[5].Parameter), Culture.NumberFormatInfo);

9467

bool UseGlobal = convertParamStringToBool(messagePacket.ParamList[6].Parameter);

9468

bool EstateFixedSun = convertParamStringToBool(messagePacket.ParamList[7].Parameter);

9469

                                float EstateSunHour = (float)Convert.ToDecimal(Utils.BytesToString(messagePacket.ParamList[8].Parameter), Culture.NumberFormatInfo);

9470

9471

                                OnSetRegionTerrainSettings(WaterHeight, TerrainRaiseLimit, TerrainLowerLimit, UseEstateSun, UseFixedSun, SunHour, UseGlobal, EstateFixedSun, EstateSunHour);

9472

9473

}

9474

catch (Exception ex)

9475

{

9476

                                m_log.Error("EstateOwnerMessage: Exception while setting terrain settings: \n" + messagePacket + "\n" + ex);

}

}

}

return true;

case "restart":

if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false))

9484

{

9485

// There's only 1 block in the estateResetSim.. and that's the number of seconds till restart.

9486

foreach (EstateOwnerMessagePacket.ParamListBlock block in messagePacket.ParamList)

9487

{

9488

float timeSeconds;

9489

Utils.TryParseSingle(Utils.BytesToString(block.Parameter), out timeSeconds);

9490

timeSeconds = (int)timeSeconds;

9491

OnEstateRestartSimRequest(this, (int)timeSeconds);

}

}

return true;

case "estatechangecovenantid":

9497

if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false))

9498

{

9499

foreach (EstateOwnerMessagePacket.ParamListBlock block in messagePacket.ParamList)

9500

{

9501

UUID newCovenantID = new UUID(Utils.BytesToString(block.Parameter));

9502

OnEstateChangeCovenantRequest(this, newCovenantID);

}

}

return true;

case "estateaccessdelta": // Estate access delta manages the banlist and allow list too.

9507

if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false))

9508

{

9509

                        int estateAccessType = Convert.ToInt16(Utils.BytesToString(messagePacket.ParamList[1].Parameter));

9510

                        OnUpdateEstateAccessDeltaRequest(this, messagePacket.MethodData.Invoice, estateAccessType, new UUID(Utils.BytesToString(messagePacket.ParamList[2].Parameter)));

}

return true;

case "simulatormessage":

9515

if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false))

9516

{

9517

UUID invoice = messagePacket.MethodData.Invoice;

9518

UUID SenderID = new UUID(Utils.BytesToString(messagePacket.ParamList[2].Parameter));

9519

string SenderName = Utils.BytesToString(messagePacket.ParamList[3].Parameter);

9520

string Message = Utils.BytesToString(messagePacket.ParamList[4].Parameter);

9521

UUID sessionID = messagePacket.AgentData.SessionID;

9522

OnSimulatorBlueBoxMessageRequest(this, invoice, SenderID, sessionID, SenderName, Message);

9523

}

9524

return true;

9525

case "instantmessage":

9526

if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false))

9527

{

9528

if (messagePacket.ParamList.Length < 2)

9529

return true;

9530

9531

UUID invoice = messagePacket.MethodData.Invoice;

9532

UUID sessionID = messagePacket.AgentData.SessionID;

UUID SenderID;

string SenderName;

string Message;

if (messagePacket.ParamList.Length < 5)

9539

{

9540

SenderID = AgentId;

9541

SenderName = Utils.BytesToString(messagePacket.ParamList[0].Parameter);

9542

Message = Utils.BytesToString(messagePacket.ParamList[1].Parameter);

}

else

{

SenderID = new UUID(Utils.BytesToString(messagePacket.ParamList[2].Parameter));

9547

SenderName = Utils.BytesToString(messagePacket.ParamList[3].Parameter);

9548

Message = Utils.BytesToString(messagePacket.ParamList[4].Parameter);

9549

}

9550

9551

OnEstateBlueBoxMessageRequest(this, invoice, SenderID, sessionID, SenderName, Message);

9552

}

9553

return true;

9554

case "setregiondebug":

9555

if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false))

9556

{

9557

UUID invoice = messagePacket.MethodData.Invoice;

9558

UUID SenderID = messagePacket.AgentData.AgentID;

9559

bool scripted = convertParamStringToBool(messagePacket.ParamList[0].Parameter);

9560

bool collisionEvents = convertParamStringToBool(messagePacket.ParamList[1].Parameter);

9561

bool physics = convertParamStringToBool(messagePacket.ParamList[2].Parameter);

9562

9563

OnEstateDebugRegionRequest(this, invoice, SenderID, scripted, collisionEvents, physics);

9564

}

9565

return true;

9566

case "teleporthomeuser":

9567

if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false))

9568

{

9569

UUID invoice = messagePacket.MethodData.Invoice;

9570

UUID SenderID = messagePacket.AgentData.AgentID;

9571

UUID Prey;

9572

9573

UUID.TryParse(Utils.BytesToString(messagePacket.ParamList[1].Parameter), out Prey);

9574

9575

OnEstateTeleportOneUserHomeRequest(this, invoice, SenderID, Prey);

9576

}

9577

return true;

9578

case "teleporthomeallusers":

9579

if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false))

9580

{

9581

UUID invoice = messagePacket.MethodData.Invoice;

9582

UUID SenderID = messagePacket.AgentData.AgentID;

9583

OnEstateTeleportAllUsersHomeRequest(this, invoice, SenderID);

}

return true;

case "colliders":

handlerLandStatRequest = OnLandStatRequest;

9588

if (handlerLandStatRequest != null)

9589

{

9590

handlerLandStatRequest(0, 1, 0, "", this);

}

return true;

case "scripts":

handlerLandStatRequest = OnLandStatRequest;

9595

if (handlerLandStatRequest != null)

9596

{

9597

handlerLandStatRequest(0, 0, 0, "", this);

}

return true;

case "terrain":

if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false))

9602

{

9603

if (messagePacket.ParamList.Length > 0)

9604

{

9605

if (Utils.BytesToString(messagePacket.ParamList[0].Parameter) == "bake")

9606

{

9607

BakeTerrain handlerBakeTerrain = OnBakeTerrain;

9608

if (handlerBakeTerrain != null)

9609

{

9610

handlerBakeTerrain(this);

9611

}

9612

}

9613

if (Utils.BytesToString(messagePacket.ParamList[0].Parameter) == "download filename")

9614

{

9615

if (messagePacket.ParamList.Length > 1)

9616

{

9617

RequestTerrain handlerRequestTerrain = OnRequestTerrain;

9618

if (handlerRequestTerrain != null)

9619

{

9620

                                        handlerRequestTerrain(this, Utils.BytesToString(messagePacket.ParamList[1].Parameter));

}

}

}

if (Utils.BytesToString(messagePacket.ParamList[0].Parameter) == "upload filename")

9625

{

9626

if (messagePacket.ParamList.Length > 1)

9627

{

9628

RequestTerrain handlerUploadTerrain = OnUploadTerrain;

9629

if (handlerUploadTerrain != null)

9630

{

9631

                                        handlerUploadTerrain(this, Utils.BytesToString(messagePacket.ParamList[1].Parameter));

}

}

}

}

}

return true;

case "estatechangeinfo":

9643

if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false))

9644

{

9645

UUID invoice = messagePacket.MethodData.Invoice;

9646

UUID SenderID = messagePacket.AgentData.AgentID;

9647

UInt32 param1 = Convert.ToUInt32(Utils.BytesToString(messagePacket.ParamList[1].Parameter));

9648

UInt32 param2 = Convert.ToUInt32(Utils.BytesToString(messagePacket.ParamList[2].Parameter));

9649

9650

EstateChangeInfo handlerEstateChangeInfo = OnEstateChangeInfo;

9651

if (handlerEstateChangeInfo != null)

9652

{

9653

handlerEstateChangeInfo(this, invoice, SenderID, param1, param2);

}

}

return true;

case "telehub":

if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false))

9660

{

9661

UUID invoice = messagePacket.MethodData.Invoice;

9662

UUID SenderID = messagePacket.AgentData.AgentID;

9663

UInt32 param1 = 0u;

9664

9665

string command = (string)Utils.BytesToString(messagePacket.ParamList[0].Parameter);

9666

9667

if (command != "info ui")

{

try

{

param1 = Convert.ToUInt32(Utils.BytesToString(messagePacket.ParamList[1].Parameter));

}

catch

{

}

}

EstateManageTelehub handlerEstateManageTelehub = OnEstateManageTelehub;

9679

if (handlerEstateManageTelehub != null)

9680

{

9681

handlerEstateManageTelehub(this, invoice, SenderID, command, param1);

}

}

return true;

default:

m_log.WarnFormat(

"[LLCLIENTVIEW]: EstateOwnerMessage: Unknown method {0} requested for {1} in {2}",

9689

method, Name, Scene.Name);

9690

9691

for (int i = 0; i < messagePacket.ParamList.Length; i++)

9692

{

9693

EstateOwnerMessagePacket.ParamListBlock block = messagePacket.ParamList[i];

9694

string data = (string)Utils.BytesToString(block.Parameter);

9695

m_log.DebugFormat("[LLCLIENTVIEW]: Param {0}={1}", i, data);

}

return true;

}

//int parcelID, uint reportType, uint requestflags, string filter

9702

9703

//lsrp.RequestData.ParcelLocalID;

9704

//lsrp.RequestData.ReportType; // 1 = colliders, 0 = scripts

9705

//lsrp.RequestData.RequestFlags;

9706

//lsrp.RequestData.Filter;

9707

}

9708

9709

private bool HandleRequestRegionInfo(IClientAPI sender, Packet Pack)

9710

{

9711

RequestRegionInfoPacket.AgentDataBlock mPacket = ((RequestRegionInfoPacket)Pack).AgentData;

9712

9713

#region Packet Session and User Check

9714

if (m_checkPackets)

9715

{

9716

if (mPacket.SessionID != SessionId ||

9717

mPacket.AgentID != AgentId)

return true;

}

#endregion

RegionInfoRequest handlerRegionInfoRequest = OnRegionInfoRequest;

9723

if (handlerRegionInfoRequest != null)

9724

{

9725

handlerRegionInfoRequest(this);

}

return true;

}

private bool HandleEstateCovenantRequest(IClientAPI sender, Packet Pack)

9731

{

9732

9733

//EstateCovenantRequestPacket.AgentDataBlock epack =

9734

// ((EstateCovenantRequestPacket)Pack).AgentData;

9735

9736

EstateCovenantRequest handlerEstateCovenantRequest = OnEstateCovenantRequest;

9737

if (handlerEstateCovenantRequest != null)

9738

{

9739

handlerEstateCovenantRequest(this);

}

return true;

}

#endregion Estate Packets

#region GodPackets

private bool HandleRequestGodlikePowers(IClientAPI sender, Packet Pack)

9750

{

9751

RequestGodlikePowersPacket rglpPack = (RequestGodlikePowersPacket)Pack;

9752

RequestGodlikePowersPacket.RequestBlockBlock rblock = rglpPack.RequestBlock;

9753

UUID token = rblock.Token;

9754

9755

RequestGodlikePowersPacket.AgentDataBlock ablock = rglpPack.AgentData;

9756

9757

RequestGodlikePowers handlerReqGodlikePowers = OnRequestGodlikePowers;

9758

9759

if (handlerReqGodlikePowers != null)

9760

{

9761

handlerReqGodlikePowers(ablock.AgentID, ablock.SessionID, token, rblock.Godlike, this);

}

return true;

}

private bool HandleGodUpdateRegionInfoUpdate(IClientAPI client, Packet Packet)

9768

{

9769

GodUpdateRegionInfoPacket GodUpdateRegionInfo =

9770

(GodUpdateRegionInfoPacket)Packet;

9771

9772

GodUpdateRegionInfoUpdate handlerGodUpdateRegionInfo = OnGodUpdateRegionInfoUpdate;

9773

if (handlerGodUpdateRegionInfo != null)

9774

{

9775

handlerGodUpdateRegionInfo(this,

9776

GodUpdateRegionInfo.RegionInfo.BillableFactor,

9777

GodUpdateRegionInfo.RegionInfo.EstateID,

9778

GodUpdateRegionInfo.RegionInfo.RegionFlags,

9779

GodUpdateRegionInfo.RegionInfo.SimName,

9780

GodUpdateRegionInfo.RegionInfo.RedirectGridX,

9781

GodUpdateRegionInfo.RegionInfo.RedirectGridY);

return true;

}

return false;

}

private bool HandleSimWideDeletes(IClientAPI client, Packet Packet)

9788

{

9789

SimWideDeletesPacket SimWideDeletesRequest =

9790

(SimWideDeletesPacket)Packet;

9791

SimWideDeletesDelegate handlerSimWideDeletesRequest = OnSimWideDeletes;

9792

if (handlerSimWideDeletesRequest != null)

9793

{

9794

                handlerSimWideDeletesRequest(this, SimWideDeletesRequest.AgentData.AgentID,(int)SimWideDeletesRequest.DataBlock.Flags,SimWideDeletesRequest.DataBlock.TargetID);

return true;

}

return false;

}

private bool HandleGodlikeMessage(IClientAPI client, Packet Packet)

9801

{

9802

GodlikeMessagePacket GodlikeMessage =

9803

(GodlikeMessagePacket)Packet;

9804

9805

GodlikeMessage handlerGodlikeMessage = onGodlikeMessage;

9806

if (handlerGodlikeMessage != null)

9807

{

9808

handlerGodlikeMessage(this,

9809

GodlikeMessage.MethodData.Invoice,

9810

GodlikeMessage.MethodData.Method,

9811

GodlikeMessage.ParamList[0].Parameter);

return true;

}

return false;

}

private bool HandleSaveStatePacket(IClientAPI client, Packet Packet)

9818

{

9819

StateSavePacket SaveStateMessage =

9820

(StateSavePacket)Packet;

9821

SaveStateHandler handlerSaveStatePacket = OnSaveState;

9822

if (handlerSaveStatePacket != null)

9823

{

9824

handlerSaveStatePacket(this,SaveStateMessage.AgentData.AgentID);

return true;

}

return false;

}

private bool HandleGodKickUser(IClientAPI sender, Packet Pack)

9831

{

9832

GodKickUserPacket gkupack = (GodKickUserPacket)Pack;

9833

9834

if (gkupack.UserInfo.GodSessionID == SessionId && AgentId == gkupack.UserInfo.GodID)

9835

{

9836

GodKickUser handlerGodKickUser = OnGodKickUser;

9837

if (handlerGodKickUser != null)

9838

{

9839

handlerGodKickUser(gkupack.UserInfo.GodID, gkupack.UserInfo.GodSessionID,

9840

gkupack.UserInfo.AgentID, gkupack.UserInfo.KickFlags, gkupack.UserInfo.Reason);

}

}

else

{

SendAgentAlertMessage("Kick request denied", false);

9846

}

9847

//KickUserPacket kupack = new KickUserPacket();

9848

//KickUserPacket.UserInfoBlock kupackib = kupack.UserInfo;

9849

9850

//kupack.UserInfo.AgentID = gkupack.UserInfo.AgentID;

9851

//kupack.UserInfo.SessionID = gkupack.UserInfo.GodSessionID;

9852

9853

//kupack.TargetBlock.TargetIP = (uint)0;

9854

//kupack.TargetBlock.TargetPort = (ushort)0;

9855

//kupack.UserInfo.Reason = gkupack.UserInfo.Reason;

9856

9857

//OutPacket(kupack, ThrottleOutPacketType.Task);

9858

return true;

9859

}

9860

#endregion GodPackets

9861

9862

#region Economy/Transaction Packets

9863

9864

private bool HandleMoneyBalanceRequest(IClientAPI sender, Packet Pack)

9865

{

9866

MoneyBalanceRequestPacket moneybalancerequestpacket = (MoneyBalanceRequestPacket)Pack;

9867

9868

#region Packet Session and User Check

9869

if (m_checkPackets)

9870

{

9871

if (moneybalancerequestpacket.AgentData.SessionID != SessionId ||

9872

moneybalancerequestpacket.AgentData.AgentID != AgentId)

return true;

}

#endregion

MoneyBalanceRequest handlerMoneyBalanceRequest = OnMoneyBalanceRequest;

9878

9879

if (handlerMoneyBalanceRequest != null)

9880

{

9881

                handlerMoneyBalanceRequest(this, moneybalancerequestpacket.AgentData.AgentID, moneybalancerequestpacket.AgentData.SessionID, moneybalancerequestpacket.MoneyData.TransactionID);

}

return true;

}

private bool HandleEconomyDataRequest(IClientAPI sender, Packet Pack)

9887

{

9888

EconomyDataRequest handlerEconomoyDataRequest = OnEconomyDataRequest;

9889

if (handlerEconomoyDataRequest != null)

9890

{

9891

handlerEconomoyDataRequest(this);

}

return true;

}

private bool HandleRequestPayPrice(IClientAPI sender, Packet Pack)

9896

{

9897

RequestPayPricePacket requestPayPricePacket = (RequestPayPricePacket)Pack;

9898

9899

RequestPayPrice handlerRequestPayPrice = OnRequestPayPrice;

9900

if (handlerRequestPayPrice != null)

9901

{

9902

handlerRequestPayPrice(this, requestPayPricePacket.ObjectData.ObjectID);

}

return true;

}

private bool HandleObjectSaleInfo(IClientAPI sender, Packet Pack)

9907

{

9908

ObjectSaleInfoPacket objectSaleInfoPacket = (ObjectSaleInfoPacket)Pack;

9909

9910

#region Packet Session and User Check

9911

if (m_checkPackets)

9912

{

9913

if (objectSaleInfoPacket.AgentData.SessionID != SessionId ||

9914

objectSaleInfoPacket.AgentData.AgentID != AgentId)

return true;

}

#endregion

ObjectSaleInfo handlerObjectSaleInfo = OnObjectSaleInfo;

9920

if (handlerObjectSaleInfo != null)

9921

{

9922

foreach (ObjectSaleInfoPacket.ObjectDataBlock d

9923

in objectSaleInfoPacket.ObjectData)

9924

{

9925

handlerObjectSaleInfo(this,

9926

objectSaleInfoPacket.AgentData.AgentID,

9927

objectSaleInfoPacket.AgentData.SessionID,

d.LocalID,

d.SaleType,

d.SalePrice);

}

}

return true;

}

private bool HandleObjectBuy(IClientAPI sender, Packet Pack)

9936

{

9937

ObjectBuyPacket objectBuyPacket = (ObjectBuyPacket)Pack;

9938

9939

#region Packet Session and User Check

9940

if (m_checkPackets)

9941

{

9942

if (objectBuyPacket.AgentData.SessionID != SessionId ||

9943

objectBuyPacket.AgentData.AgentID != AgentId)

return true;

}

#endregion

ObjectBuy handlerObjectBuy = OnObjectBuy;

9949

9950

if (handlerObjectBuy != null)

9951

{

9952

foreach (ObjectBuyPacket.ObjectDataBlock d

9953

in objectBuyPacket.ObjectData)

9954

{

9955

handlerObjectBuy(this,

9956

objectBuyPacket.AgentData.AgentID,

9957

objectBuyPacket.AgentData.SessionID,

9958

objectBuyPacket.AgentData.GroupID,

9959

objectBuyPacket.AgentData.CategoryID,

d.ObjectLocalID,

d.SaleType,

d.SalePrice);

}

}

return true;

}

#endregion Economy/Transaction Packets

9969

9970

#region Script Packets

9971

private bool HandleGetScriptRunning(IClientAPI sender, Packet Pack)

9972

{

9973

GetScriptRunningPacket scriptRunning = (GetScriptRunningPacket)Pack;

9974

9975

GetScriptRunning handlerGetScriptRunning = OnGetScriptRunning;

9976

if (handlerGetScriptRunning != null)

9977

{

9978

handlerGetScriptRunning(this, scriptRunning.Script.ObjectID, scriptRunning.Script.ItemID);

}

return true;

}

private bool HandleSetScriptRunning(IClientAPI sender, Packet Pack)

9983

{

9984

SetScriptRunningPacket setScriptRunning = (SetScriptRunningPacket)Pack;

9985

9986

#region Packet Session and User Check

9987

if (m_checkPackets)

9988

{

9989

if (setScriptRunning.AgentData.SessionID != SessionId ||

9990

setScriptRunning.AgentData.AgentID != AgentId)

return true;

}

#endregion

SetScriptRunning handlerSetScriptRunning = OnSetScriptRunning;

9996

if (handlerSetScriptRunning != null)

9997

{

9998

                handlerSetScriptRunning(this, setScriptRunning.Script.ObjectID, setScriptRunning.Script.ItemID, setScriptRunning.Script.Running);

}

return true;

}

private bool HandleScriptReset(IClientAPI sender, Packet Pack)

10004

{

10005

ScriptResetPacket scriptResetPacket = (ScriptResetPacket)Pack;

10006

10007

#region Packet Session and User Check

10008

if (m_checkPackets)

10009

{

10010

if (scriptResetPacket.AgentData.SessionID != SessionId ||

10011

scriptResetPacket.AgentData.AgentID != AgentId)

return true;

}

#endregion

ScriptReset handlerScriptReset = OnScriptReset;

10017

if (handlerScriptReset != null)

10018

{

10019

handlerScriptReset(this, scriptResetPacket.Script.ObjectID, scriptResetPacket.Script.ItemID);

}

return true;

}

#endregion Script Packets

10025

10026

#region Gesture Managment

10027

10028

private bool HandleActivateGestures(IClientAPI sender, Packet Pack)

10029

{

10030

ActivateGesturesPacket activateGesturePacket = (ActivateGesturesPacket)Pack;

10031

10032

#region Packet Session and User Check

10033

if (m_checkPackets)

10034

{

10035

if (activateGesturePacket.AgentData.SessionID != SessionId ||

10036

activateGesturePacket.AgentData.AgentID != AgentId)

return true;

}

#endregion

ActivateGesture handlerActivateGesture = OnActivateGesture;

10042

if (handlerActivateGesture != null)

10043

{

10044

handlerActivateGesture(this,

10045

activateGesturePacket.Data[0].AssetID,

10046

activateGesturePacket.Data[0].ItemID);

10047

}

10048

else m_log.Error("Null pointer for activateGesture");

return true;

}

private bool HandleDeactivateGestures(IClientAPI sender, Packet Pack)

10053

{

10054

DeactivateGesturesPacket deactivateGesturePacket = (DeactivateGesturesPacket)Pack;

10055

10056

#region Packet Session and User Check

10057

if (m_checkPackets)

10058

{

10059

if (deactivateGesturePacket.AgentData.SessionID != SessionId ||

10060

deactivateGesturePacket.AgentData.AgentID != AgentId)

return true;

}

#endregion

DeactivateGesture handlerDeactivateGesture = OnDeactivateGesture;

10066

if (handlerDeactivateGesture != null)

10067

{

10068

handlerDeactivateGesture(this, deactivateGesturePacket.Data[0].ItemID);

}

return true;

}

private bool HandleObjectOwner(IClientAPI sender, Packet Pack)

10073

{

10074

ObjectOwnerPacket objectOwnerPacket = (ObjectOwnerPacket)Pack;

10075

10076

#region Packet Session and User Check

10077

if (m_checkPackets)

10078

{

10079

if (objectOwnerPacket.AgentData.SessionID != SessionId ||

10080

objectOwnerPacket.AgentData.AgentID != AgentId)

return true;

}

#endregion

List<uint> localIDs = new List<uint>();

10086

10087

foreach (ObjectOwnerPacket.ObjectDataBlock d in objectOwnerPacket.ObjectData)

10088

localIDs.Add(d.ObjectLocalID);

10089

10090

ObjectOwner handlerObjectOwner = OnObjectOwner;

10091

if (handlerObjectOwner != null)

10092

{

10093

                handlerObjectOwner(this, objectOwnerPacket.HeaderData.OwnerID, objectOwnerPacket.HeaderData.GroupID, localIDs);

}

return true;

}

#endregion Gesture Managment

10099

10100

private bool HandleAgentFOV(IClientAPI sender, Packet Pack)

10101

{

10102

AgentFOVPacket fovPacket = (AgentFOVPacket)Pack;

10103

10104

if (fovPacket.FOVBlock.GenCounter > m_agentFOVCounter)

10105

{

10106

m_agentFOVCounter = fovPacket.FOVBlock.GenCounter;

10107

AgentFOV handlerAgentFOV = OnAgentFOV;

10108

if (handlerAgentFOV != null)

10109

{

10110

handlerAgentFOV(this, fovPacket.FOVBlock.VerticalAngle);

}

}

return true;

}

#region unimplemented handlers

10117

10118

private bool HandleViewerStats(IClientAPI sender, Packet Pack)

10119

{

10120

// TODO: handle this packet

10121

//m_log.Warn("[CLIENT]: unhandled ViewerStats packet");

return true;

}

private bool HandleMapItemRequest(IClientAPI sender, Packet Pack)

10126

{

10127

MapItemRequestPacket mirpk = (MapItemRequestPacket)Pack;

10128

10129

#region Packet Session and User Check

10130

if (m_checkPackets)

10131

{

10132

if (mirpk.AgentData.SessionID != SessionId ||

10133

mirpk.AgentData.AgentID != AgentId)

return true;

}

#endregion

//m_log.Debug(mirpk.ToString());

10139

MapItemRequest handlerMapItemRequest = OnMapItemRequest;

10140

if (handlerMapItemRequest != null)

10141

{

10142

handlerMapItemRequest(this, mirpk.AgentData.Flags, mirpk.AgentData.EstateID,

10143

mirpk.AgentData.Godlike, mirpk.RequestData.ItemType,

10144

mirpk.RequestData.RegionHandle);

}

return true;

}

private bool HandleTransferAbort(IClientAPI sender, Packet Pack)

{

return true;

}

private bool HandleMuteListRequest(IClientAPI sender, Packet Pack)

10156

{

10157

MuteListRequestPacket muteListRequest =

10158

(MuteListRequestPacket)Pack;

10159

10160

#region Packet Session and User Check

10161

if (m_checkPackets)

10162

{

10163

if (muteListRequest.AgentData.SessionID != SessionId ||

10164

muteListRequest.AgentData.AgentID != AgentId)

return true;

}

#endregion

MuteListRequest handlerMuteListRequest = OnMuteListRequest;

10170

if (handlerMuteListRequest != null)

10171

{

10172

handlerMuteListRequest(this, muteListRequest.MuteData.MuteCRC);

}

else

{

SendUseCachedMuteList();

}

return true;

}

private bool HandleUpdateMuteListEntry(IClientAPI client, Packet Packet)

10182

{

10183

UpdateMuteListEntryPacket UpdateMuteListEntry =

10184

(UpdateMuteListEntryPacket)Packet;

10185

MuteListEntryUpdate handlerUpdateMuteListEntry = OnUpdateMuteListEntry;

10186

if (handlerUpdateMuteListEntry != null)

10187

{

10188

handlerUpdateMuteListEntry(this, UpdateMuteListEntry.MuteData.MuteID,

10189

Utils.BytesToString(UpdateMuteListEntry.MuteData.MuteName),

10190

UpdateMuteListEntry.MuteData.MuteType,

10191

UpdateMuteListEntry.AgentData.AgentID);

return true;

}

return false;

}

private bool HandleRemoveMuteListEntry(IClientAPI client, Packet Packet)

10198

{

10199

RemoveMuteListEntryPacket RemoveMuteListEntry =

10200

(RemoveMuteListEntryPacket)Packet;

10201

MuteListEntryRemove handlerRemoveMuteListEntry = OnRemoveMuteListEntry;

10202

if (handlerRemoveMuteListEntry != null)

10203

{

10204

handlerRemoveMuteListEntry(this,

10205

RemoveMuteListEntry.MuteData.MuteID,

10206

Utils.BytesToString(RemoveMuteListEntry.MuteData.MuteName),

10207

RemoveMuteListEntry.AgentData.AgentID);

return true;

}

return false;

}

private bool HandleUserReport(IClientAPI client, Packet Packet)

10214

{

10215

UserReportPacket UserReport =

10216

(UserReportPacket)Packet;

10217

10218

NewUserReport handlerUserReport = OnUserReport;

10219

if (handlerUserReport != null)

10220

{

10221

handlerUserReport(this,

10222

Utils.BytesToString(UserReport.ReportData.AbuseRegionName),

10223

UserReport.ReportData.AbuserID,

10224

UserReport.ReportData.Category,

10225

UserReport.ReportData.CheckFlags,

10226

Utils.BytesToString(UserReport.ReportData.Details),

10227

UserReport.ReportData.ObjectID,

10228

UserReport.ReportData.Position,

10229

UserReport.ReportData.ReportType,

10230

UserReport.ReportData.ScreenshotID,

10231

Utils.BytesToString(UserReport.ReportData.Summary),

10232

UserReport.AgentData.AgentID);

return true;

}

return false;

}

private bool HandleSendPostcard(IClientAPI client, Packet packet)

10239

{

10240

// SendPostcardPacket SendPostcard =

10241

// (SendPostcardPacket)packet;

10242

SendPostcard handlerSendPostcard = OnSendPostcard;

10243

if (handlerSendPostcard != null)

10244

{

10245

handlerSendPostcard(this);

return true;

}

return false;

}

private bool HandleUseCircuitCode(IClientAPI sender, Packet Pack)

{

return true;

}

private bool HandleAgentHeightWidth(IClientAPI sender, Packet Pack)

{

return true;

}

private bool HandleInventoryDescendents(IClientAPI sender, Packet Pack)

{

return true;

}

#endregion unimplemented handlers

10267

10268

#region Dir handlers

10269

10270

private bool HandleDirPlacesQuery(IClientAPI sender, Packet Pack)

10271

{

10272

DirPlacesQueryPacket dirPlacesQueryPacket = (DirPlacesQueryPacket)Pack;

10273

//m_log.Debug(dirPlacesQueryPacket.ToString());

10274

10275

#region Packet Session and User Check

10276

if (m_checkPackets)

10277

{

10278

if (dirPlacesQueryPacket.AgentData.SessionID != SessionId ||

10279

dirPlacesQueryPacket.AgentData.AgentID != AgentId)

return true;

}

#endregion

DirPlacesQuery handlerDirPlacesQuery = OnDirPlacesQuery;

10285

if (handlerDirPlacesQuery != null)

10286

{

10287

handlerDirPlacesQuery(this,

10288

dirPlacesQueryPacket.QueryData.QueryID,

10289

Utils.BytesToString(

10290

dirPlacesQueryPacket.QueryData.QueryText),

10291

(int)dirPlacesQueryPacket.QueryData.QueryFlags,

10292

(int)dirPlacesQueryPacket.QueryData.Category,

10293

Utils.BytesToString(

10294

dirPlacesQueryPacket.QueryData.SimName),

10295

dirPlacesQueryPacket.QueryData.QueryStart);

}

return true;

}

private bool HandleDirFindQuery(IClientAPI sender, Packet Pack)

10301

{

10302

DirFindQueryPacket dirFindQueryPacket = (DirFindQueryPacket)Pack;

10303

10304

#region Packet Session and User Check

10305

if (m_checkPackets)

10306

{

10307

if (dirFindQueryPacket.AgentData.SessionID != SessionId ||

10308

dirFindQueryPacket.AgentData.AgentID != AgentId)

return true;

}

#endregion

DirFindQuery handlerDirFindQuery = OnDirFindQuery;

10314

if (handlerDirFindQuery != null)

10315

{

10316

handlerDirFindQuery(this,

10317

dirFindQueryPacket.QueryData.QueryID,

10318

Utils.BytesToString(

10319

dirFindQueryPacket.QueryData.QueryText),

10320

dirFindQueryPacket.QueryData.QueryFlags,

10321

dirFindQueryPacket.QueryData.QueryStart);

}

return true;

}

private bool HandleDirLandQuery(IClientAPI sender, Packet Pack)

10327

{

10328

DirLandQueryPacket dirLandQueryPacket = (DirLandQueryPacket)Pack;

10329

10330

#region Packet Session and User Check

10331

if (m_checkPackets)

10332

{

10333

if (dirLandQueryPacket.AgentData.SessionID != SessionId ||

10334

dirLandQueryPacket.AgentData.AgentID != AgentId)

return true;

}

#endregion

DirLandQuery handlerDirLandQuery = OnDirLandQuery;

10340

if (handlerDirLandQuery != null)

10341

{

10342

handlerDirLandQuery(this,

10343

dirLandQueryPacket.QueryData.QueryID,

10344

dirLandQueryPacket.QueryData.QueryFlags,

10345

dirLandQueryPacket.QueryData.SearchType,

10346

dirLandQueryPacket.QueryData.Price,

10347

dirLandQueryPacket.QueryData.Area,

10348

dirLandQueryPacket.QueryData.QueryStart);

}

return true;

}

private bool HandleDirPopularQuery(IClientAPI sender, Packet Pack)

10354

{

10355

DirPopularQueryPacket dirPopularQueryPacket = (DirPopularQueryPacket)Pack;

10356

10357

#region Packet Session and User Check

10358

if (m_checkPackets)

10359

{

10360

if (dirPopularQueryPacket.AgentData.SessionID != SessionId ||

10361

dirPopularQueryPacket.AgentData.AgentID != AgentId)

return true;

}

#endregion

DirPopularQuery handlerDirPopularQuery = OnDirPopularQuery;

10367

if (handlerDirPopularQuery != null)

10368

{

10369

handlerDirPopularQuery(this,

10370

dirPopularQueryPacket.QueryData.QueryID,

10371

dirPopularQueryPacket.QueryData.QueryFlags);

}

return true;

}

private bool HandleDirClassifiedQuery(IClientAPI sender, Packet Pack)

10377

{

10378

DirClassifiedQueryPacket dirClassifiedQueryPacket = (DirClassifiedQueryPacket)Pack;

10379

10380

#region Packet Session and User Check

10381

if (m_checkPackets)

10382

{

10383

if (dirClassifiedQueryPacket.AgentData.SessionID != SessionId ||

10384

dirClassifiedQueryPacket.AgentData.AgentID != AgentId)

return true;

}

#endregion

DirClassifiedQuery handlerDirClassifiedQuery = OnDirClassifiedQuery;

10390

if (handlerDirClassifiedQuery != null)

10391

{

10392

handlerDirClassifiedQuery(this,

10393

dirClassifiedQueryPacket.QueryData.QueryID,

10394

Utils.BytesToString(

10395

dirClassifiedQueryPacket.QueryData.QueryText),

10396

dirClassifiedQueryPacket.QueryData.QueryFlags,

10397

dirClassifiedQueryPacket.QueryData.Category,

10398

dirClassifiedQueryPacket.QueryData.QueryStart);

}

return true;

}

private bool HandleEventInfoRequest(IClientAPI sender, Packet Pack)

10404

{

10405

EventInfoRequestPacket eventInfoRequestPacket = (EventInfoRequestPacket)Pack;

10406

10407

#region Packet Session and User Check

10408

if (m_checkPackets)

10409

{

10410

if (eventInfoRequestPacket.AgentData.SessionID != SessionId ||

10411

eventInfoRequestPacket.AgentData.AgentID != AgentId)

return true;

}

#endregion

if (OnEventInfoRequest != null)

10417

{

10418

OnEventInfoRequest(this, eventInfoRequestPacket.EventData.EventID);

}

return true;

}

#endregion

#region Calling Card

10426

10427

private bool HandleOfferCallingCard(IClientAPI sender, Packet Pack)

10428

{

10429

OfferCallingCardPacket offerCallingCardPacket = (OfferCallingCardPacket)Pack;

10430

10431

#region Packet Session and User Check

10432

if (m_checkPackets)

10433

{

10434

if (offerCallingCardPacket.AgentData.SessionID != SessionId ||

10435

offerCallingCardPacket.AgentData.AgentID != AgentId)

return true;

}

#endregion

if (OnOfferCallingCard != null)

10441

{

10442

OnOfferCallingCard(this,

10443

offerCallingCardPacket.AgentBlock.DestID,

10444

offerCallingCardPacket.AgentBlock.TransactionID);

}

return true;

}

private bool HandleAcceptCallingCard(IClientAPI sender, Packet Pack)

10450

{

10451

AcceptCallingCardPacket acceptCallingCardPacket = (AcceptCallingCardPacket)Pack;

10452

10453

#region Packet Session and User Check

10454

if (m_checkPackets)

10455

{

10456

if (acceptCallingCardPacket.AgentData.SessionID != SessionId ||

10457

acceptCallingCardPacket.AgentData.AgentID != AgentId)

return true;

}

#endregion

// according to http://wiki.secondlife.com/wiki/AcceptCallingCard FolderData should

10463

// contain exactly one entry

10464

if (OnAcceptCallingCard != null && acceptCallingCardPacket.FolderData.Length > 0)

10465

{

10466

OnAcceptCallingCard(this,

10467

acceptCallingCardPacket.TransactionBlock.TransactionID,

10468

acceptCallingCardPacket.FolderData[0].FolderID);

}

return true;

}

private bool HandleDeclineCallingCard(IClientAPI sender, Packet Pack)

10474

{

10475

DeclineCallingCardPacket declineCallingCardPacket = (DeclineCallingCardPacket)Pack;

10476

10477

#region Packet Session and User Check

10478

if (m_checkPackets)

10479

{

10480

if (declineCallingCardPacket.AgentData.SessionID != SessionId ||

10481

declineCallingCardPacket.AgentData.AgentID != AgentId)

return true;

}

#endregion

if (OnDeclineCallingCard != null)

10487

{

10488

OnDeclineCallingCard(this,

10489

declineCallingCardPacket.TransactionBlock.TransactionID);

}

return true;

}

#endregion Calling Card

#region Groups

private bool HandleActivateGroup(IClientAPI sender, Packet Pack)

10499

{

10500

ActivateGroupPacket activateGroupPacket = (ActivateGroupPacket)Pack;

10501

10502

#region Packet Session and User Check

10503

if (m_checkPackets)

10504

{

10505

if (activateGroupPacket.AgentData.SessionID != SessionId ||

10506

activateGroupPacket.AgentData.AgentID != AgentId)

return true;

}

#endregion

if (m_GroupsModule != null)

10512

{

10513

m_GroupsModule.ActivateGroup(this, activateGroupPacket.AgentData.GroupID);

10514

m_GroupsModule.SendAgentGroupDataUpdate(this);

}

return true;

}

private bool HandleGroupVoteHistoryRequest(IClientAPI client, Packet Packet)

10521

{

10522

GroupVoteHistoryRequestPacket GroupVoteHistoryRequest =

10523

(GroupVoteHistoryRequestPacket)Packet;

10524

GroupVoteHistoryRequest handlerGroupVoteHistoryRequest = OnGroupVoteHistoryRequest;

10525

if (handlerGroupVoteHistoryRequest != null)

10526

{

10527

                handlerGroupVoteHistoryRequest(this, GroupVoteHistoryRequest.AgentData.AgentID,GroupVoteHistoryRequest.AgentData.SessionID,GroupVoteHistoryRequest.GroupData.GroupID,GroupVoteHistoryRequest.TransactionData.TransactionID);

return true;

}

return false;

}

private bool HandleGroupActiveProposalsRequest(IClientAPI client, Packet Packet)

10534

{

10535

GroupActiveProposalsRequestPacket GroupActiveProposalsRequest =

10536

(GroupActiveProposalsRequestPacket)Packet;

10537

GroupActiveProposalsRequest handlerGroupActiveProposalsRequest = OnGroupActiveProposalsRequest;

10538

if (handlerGroupActiveProposalsRequest != null)

10539

{

10540

                handlerGroupActiveProposalsRequest(this, GroupActiveProposalsRequest.AgentData.AgentID,GroupActiveProposalsRequest.AgentData.SessionID,GroupActiveProposalsRequest.GroupData.GroupID,GroupActiveProposalsRequest.TransactionData.TransactionID);

return true;

}

return false;

}

private bool HandleGroupAccountDetailsRequest(IClientAPI client, Packet Packet)

10547

{

10548

GroupAccountDetailsRequestPacket GroupAccountDetailsRequest =

10549

(GroupAccountDetailsRequestPacket)Packet;

10550

GroupAccountDetailsRequest handlerGroupAccountDetailsRequest = OnGroupAccountDetailsRequest;

10551

if (handlerGroupAccountDetailsRequest != null)

10552

{

10553

                handlerGroupAccountDetailsRequest(this, GroupAccountDetailsRequest.AgentData.AgentID,GroupAccountDetailsRequest.AgentData.GroupID,GroupAccountDetailsRequest.MoneyData.RequestID,GroupAccountDetailsRequest.AgentData.SessionID);

return true;

}

return false;

}

private bool HandleGroupAccountSummaryRequest(IClientAPI client, Packet Packet)

10560

{

10561

GroupAccountSummaryRequestPacket GroupAccountSummaryRequest =

10562

(GroupAccountSummaryRequestPacket)Packet;

10563

GroupAccountSummaryRequest handlerGroupAccountSummaryRequest = OnGroupAccountSummaryRequest;

10564

if (handlerGroupAccountSummaryRequest != null)

10565

{

10566

                handlerGroupAccountSummaryRequest(this, GroupAccountSummaryRequest.AgentData.AgentID,GroupAccountSummaryRequest.AgentData.GroupID);

return true;

}

return false;

}

private bool HandleGroupTransactionsDetailsRequest(IClientAPI client, Packet Packet)

10573

{

10574

GroupAccountTransactionsRequestPacket GroupAccountTransactionsRequest =

10575

(GroupAccountTransactionsRequestPacket)Packet;

10576

GroupAccountTransactionsRequest handlerGroupAccountTransactionsRequest = OnGroupAccountTransactionsRequest;

10577

if (handlerGroupAccountTransactionsRequest != null)

10578

{

10579

                handlerGroupAccountTransactionsRequest(this, GroupAccountTransactionsRequest.AgentData.AgentID,GroupAccountTransactionsRequest.AgentData.GroupID,GroupAccountTransactionsRequest.MoneyData.RequestID,GroupAccountTransactionsRequest.AgentData.SessionID);

return true;

}

return false;

}

private bool HandleGroupTitlesRequest(IClientAPI sender, Packet Pack)

10586

{

10587

GroupTitlesRequestPacket groupTitlesRequest =

10588

(GroupTitlesRequestPacket)Pack;

10589

10590

#region Packet Session and User Check

10591

if (m_checkPackets)

10592

{

10593

if (groupTitlesRequest.AgentData.SessionID != SessionId ||

10594

groupTitlesRequest.AgentData.AgentID != AgentId)

return true;

}

#endregion

if (m_GroupsModule != null)

10600

{

10601

                GroupTitlesReplyPacket groupTitlesReply = (GroupTitlesReplyPacket)PacketPool.Instance.GetPacket(PacketType.GroupTitlesReply);

10602

10603

groupTitlesReply.AgentData =

10604

new GroupTitlesReplyPacket.AgentDataBlock();

10605

10606

groupTitlesReply.AgentData.AgentID = AgentId;

10607

groupTitlesReply.AgentData.GroupID =

10608

groupTitlesRequest.AgentData.GroupID;

10609

10610

groupTitlesReply.AgentData.RequestID =

10611

groupTitlesRequest.AgentData.RequestID;

10612

10613

List<GroupTitlesData> titles =

10614

m_GroupsModule.GroupTitlesRequest(this,

10615

groupTitlesRequest.AgentData.GroupID);

10616

10617

groupTitlesReply.GroupData =

10618

new GroupTitlesReplyPacket.GroupDataBlock[titles.Count];

10619

10620

int i = 0;

10621

foreach (GroupTitlesData d in titles)

10622

{

10623

groupTitlesReply.GroupData[i] =

10624

new GroupTitlesReplyPacket.GroupDataBlock();

10625

10626

groupTitlesReply.GroupData[i].Title =

10627

Util.StringToBytes256(d.Name);

10628

groupTitlesReply.GroupData[i].RoleID =

10629

d.UUID;

10630

groupTitlesReply.GroupData[i].Selected =

d.Selected;

i++;

}

OutPacket(groupTitlesReply, ThrottleOutPacketType.Task);

}

return true;

}

private bool HandleGroupProfileRequest(IClientAPI sender, Packet Pack)

10640

{

10641

GroupProfileRequestPacket groupProfileRequest =

10642

(GroupProfileRequestPacket)Pack;

10643

10644

#region Packet Session and User Check

10645

if (m_checkPackets)

10646

{

10647

if (groupProfileRequest.AgentData.SessionID != SessionId ||

10648

groupProfileRequest.AgentData.AgentID != AgentId)

return true;

}

#endregion

if (m_GroupsModule != null)

10654

{

10655

                GroupProfileReplyPacket groupProfileReply = (GroupProfileReplyPacket)PacketPool.Instance.GetPacket(PacketType.GroupProfileReply);

10656

10657

groupProfileReply.AgentData = new GroupProfileReplyPacket.AgentDataBlock();

10658

groupProfileReply.GroupData = new GroupProfileReplyPacket.GroupDataBlock();

10659

groupProfileReply.AgentData.AgentID = AgentId;

10660

10661

GroupProfileData d = m_GroupsModule.GroupProfileRequest(this,

10662

groupProfileRequest.GroupData.GroupID);

10663

10664

groupProfileReply.GroupData.GroupID = d.GroupID;

10665

groupProfileReply.GroupData.Name = Util.StringToBytes256(d.Name);

10666

groupProfileReply.GroupData.Charter = Util.StringToBytes1024(d.Charter);

10667

groupProfileReply.GroupData.ShowInList = d.ShowInList;

10668

groupProfileReply.GroupData.MemberTitle = Util.StringToBytes256(d.MemberTitle);

10669

groupProfileReply.GroupData.PowersMask = d.PowersMask;

10670

groupProfileReply.GroupData.InsigniaID = d.InsigniaID;

10671

groupProfileReply.GroupData.FounderID = d.FounderID;

10672

groupProfileReply.GroupData.MembershipFee = d.MembershipFee;

10673

groupProfileReply.GroupData.OpenEnrollment = d.OpenEnrollment;

10674

groupProfileReply.GroupData.Money = d.Money;

10675

groupProfileReply.GroupData.GroupMembershipCount = d.GroupMembershipCount;

10676

groupProfileReply.GroupData.GroupRolesCount = d.GroupRolesCount;

10677

groupProfileReply.GroupData.AllowPublish = d.AllowPublish;

10678

groupProfileReply.GroupData.MaturePublish = d.MaturePublish;

10679

groupProfileReply.GroupData.OwnerRole = d.OwnerRole;

10680

10681

OutPacket(groupProfileReply, ThrottleOutPacketType.Task);

}

return true;

}

private bool HandleGroupMembersRequest(IClientAPI sender, Packet Pack)

10686

{

10687

GroupMembersRequestPacket groupMembersRequestPacket =

10688

(GroupMembersRequestPacket)Pack;

10689

10690

#region Packet Session and User Check

10691

if (m_checkPackets)

10692

{

10693

if (groupMembersRequestPacket.AgentData.SessionID != SessionId ||

10694

groupMembersRequestPacket.AgentData.AgentID != AgentId)

return true;

}

#endregion

if (m_GroupsModule != null)

10700

{

10701

List<GroupMembersData> members =

10702

m_GroupsModule.GroupMembersRequest(this, groupMembersRequestPacket.GroupData.GroupID);

10703

10704

int memberCount = members.Count;

while (true)

{

int blockCount = members.Count;

10709

if (blockCount > 40)

10710

blockCount = 40;

10711

10712

                    GroupMembersReplyPacket groupMembersReply = (GroupMembersReplyPacket)PacketPool.Instance.GetPacket(PacketType.GroupMembersReply);

10713

10714

groupMembersReply.AgentData =

10715

new GroupMembersReplyPacket.AgentDataBlock();

10716

groupMembersReply.GroupData =

10717

new GroupMembersReplyPacket.GroupDataBlock();

10718

groupMembersReply.MemberData =

10719

new GroupMembersReplyPacket.MemberDataBlock[

10720

blockCount];

10721

10722

groupMembersReply.AgentData.AgentID = AgentId;

10723

groupMembersReply.GroupData.GroupID =

10724

groupMembersRequestPacket.GroupData.GroupID;

10725

groupMembersReply.GroupData.RequestID =

10726

groupMembersRequestPacket.GroupData.RequestID;

10727

groupMembersReply.GroupData.MemberCount = memberCount;

10728

10729

for (int i = 0; i < blockCount; i++)

10730

{

10731

GroupMembersData m = members[0];

10732

members.RemoveAt(0);

10733

10734

groupMembersReply.MemberData[i] =

10735

new GroupMembersReplyPacket.MemberDataBlock();

10736

groupMembersReply.MemberData[i].AgentID =

10737

m.AgentID;

10738

groupMembersReply.MemberData[i].Contribution =

10739

m.Contribution;

10740

groupMembersReply.MemberData[i].OnlineStatus =

10741

Util.StringToBytes256(m.OnlineStatus);

10742

groupMembersReply.MemberData[i].AgentPowers =

10743

m.AgentPowers;

10744

groupMembersReply.MemberData[i].Title =

10745

Util.StringToBytes256(m.Title);

10746

groupMembersReply.MemberData[i].IsOwner =

10747

m.IsOwner;

10748

}

10749

OutPacket(groupMembersReply, ThrottleOutPacketType.Task);

10750

if (members.Count == 0)

return true;

}

}

return true;

}

private bool HandleGroupRoleDataRequest(IClientAPI sender, Packet Pack)

10757

{

10758

GroupRoleDataRequestPacket groupRolesRequest =

10759

(GroupRoleDataRequestPacket)Pack;

10760

10761

#region Packet Session and User Check

10762

if (m_checkPackets)

10763

{

10764

if (groupRolesRequest.AgentData.SessionID != SessionId ||

10765

groupRolesRequest.AgentData.AgentID != AgentId)

return true;

}

#endregion

if (m_GroupsModule != null)

10771

{

10772

                GroupRoleDataReplyPacket groupRolesReply = (GroupRoleDataReplyPacket)PacketPool.Instance.GetPacket(PacketType.GroupRoleDataReply);

10773

10774

groupRolesReply.AgentData =

10775

new GroupRoleDataReplyPacket.AgentDataBlock();

10776

10777

groupRolesReply.AgentData.AgentID = AgentId;

10778

10779

groupRolesReply.GroupData =

10780

new GroupRoleDataReplyPacket.GroupDataBlock();

10781

10782

groupRolesReply.GroupData.GroupID =

10783

groupRolesRequest.GroupData.GroupID;

10784

10785

groupRolesReply.GroupData.RequestID =

10786

groupRolesRequest.GroupData.RequestID;

10787

10788

List<GroupRolesData> titles =

10789

m_GroupsModule.GroupRoleDataRequest(this,

10790

groupRolesRequest.GroupData.GroupID);

10791

10792

groupRolesReply.GroupData.RoleCount =

10793

titles.Count;

10794

10795

groupRolesReply.RoleData =

10796

new GroupRoleDataReplyPacket.RoleDataBlock[titles.Count];

10797

10798

int i = 0;

10799

foreach (GroupRolesData d in titles)

10800

{

10801

groupRolesReply.RoleData[i] =

10802

new GroupRoleDataReplyPacket.RoleDataBlock();

10803

10804

groupRolesReply.RoleData[i].RoleID =

10805

d.RoleID;

10806

groupRolesReply.RoleData[i].Name =

10807

Util.StringToBytes256(d.Name);

10808

groupRolesReply.RoleData[i].Title =

10809

Util.StringToBytes256(d.Title);

10810

groupRolesReply.RoleData[i].Description =

10811

Util.StringToBytes1024(d.Description);

10812

groupRolesReply.RoleData[i].Powers =

10813

d.Powers;

10814

groupRolesReply.RoleData[i].Members =

(uint)d.Members;

i++;

}

OutPacket(groupRolesReply, ThrottleOutPacketType.Task);

}

return true;

}

private bool HandleGroupRoleMembersRequest(IClientAPI sender, Packet Pack)

10826

{

10827

GroupRoleMembersRequestPacket groupRoleMembersRequest =

10828

(GroupRoleMembersRequestPacket)Pack;

10829

10830

#region Packet Session and User Check

10831

if (m_checkPackets)

10832

{

10833

if (groupRoleMembersRequest.AgentData.SessionID != SessionId ||

10834

groupRoleMembersRequest.AgentData.AgentID != AgentId)

return true;

}

#endregion

if (m_GroupsModule != null)

10840

{

10841

List<GroupRoleMembersData> mappings =

10842

m_GroupsModule.GroupRoleMembersRequest(this,

10843

groupRoleMembersRequest.GroupData.GroupID);

10844

10845

int mappingsCount = mappings.Count;

10846

10847

while (mappings.Count > 0)

10848

{

10849

int pairs = mappings.Count;

if (pairs > 32)

pairs = 32;

                    GroupRoleMembersReplyPacket groupRoleMembersReply = (GroupRoleMembersReplyPacket)PacketPool.Instance.GetPacket(PacketType.GroupRoleMembersReply);

10854

groupRoleMembersReply.AgentData =

10855

new GroupRoleMembersReplyPacket.AgentDataBlock();

10856

groupRoleMembersReply.AgentData.AgentID =

10857

AgentId;

10858

groupRoleMembersReply.AgentData.GroupID =

10859

groupRoleMembersRequest.GroupData.GroupID;

10860

groupRoleMembersReply.AgentData.RequestID =

10861

groupRoleMembersRequest.GroupData.RequestID;

10862

10863

groupRoleMembersReply.AgentData.TotalPairs =

10864

(uint)mappingsCount;

10865

10866

groupRoleMembersReply.MemberData =

10867

new GroupRoleMembersReplyPacket.MemberDataBlock[pairs];

10868

10869

for (int i = 0; i < pairs; i++)

10870

{

10871

GroupRoleMembersData d = mappings[0];

10872

mappings.RemoveAt(0);

10873

10874

groupRoleMembersReply.MemberData[i] =

10875

new GroupRoleMembersReplyPacket.MemberDataBlock();

10876

10877

groupRoleMembersReply.MemberData[i].RoleID =

10878

d.RoleID;

10879

groupRoleMembersReply.MemberData[i].MemberID =

d.MemberID;

}

OutPacket(groupRoleMembersReply, ThrottleOutPacketType.Task);

}

}

return true;

}

private bool HandleCreateGroupRequest(IClientAPI sender, Packet Pack)

10889

{

10890

CreateGroupRequestPacket createGroupRequest =

10891

(CreateGroupRequestPacket)Pack;

10892

10893

#region Packet Session and User Check

10894

if (m_checkPackets)

10895

{

10896

if (createGroupRequest.AgentData.SessionID != SessionId ||

10897

createGroupRequest.AgentData.AgentID != AgentId)

return true;

}

#endregion

if (m_GroupsModule != null)

10903

{

10904

m_GroupsModule.CreateGroup(this,

10905

Utils.BytesToString(createGroupRequest.GroupData.Name),

10906

Utils.BytesToString(createGroupRequest.GroupData.Charter),

10907

createGroupRequest.GroupData.ShowInList,

10908

createGroupRequest.GroupData.InsigniaID,

10909

createGroupRequest.GroupData.MembershipFee,

10910

createGroupRequest.GroupData.OpenEnrollment,

10911

createGroupRequest.GroupData.AllowPublish,

10912

createGroupRequest.GroupData.MaturePublish);

}

return true;

}

private bool HandleUpdateGroupInfo(IClientAPI sender, Packet Pack)

10917

{

10918

UpdateGroupInfoPacket updateGroupInfo =

10919

(UpdateGroupInfoPacket)Pack;

10920

10921

#region Packet Session and User Check

10922

if (m_checkPackets)

10923

{

10924

if (updateGroupInfo.AgentData.SessionID != SessionId ||

10925

updateGroupInfo.AgentData.AgentID != AgentId)

return true;

}

#endregion

if (m_GroupsModule != null)

10931

{

10932

m_GroupsModule.UpdateGroupInfo(this,

10933

updateGroupInfo.GroupData.GroupID,

10934

Utils.BytesToString(updateGroupInfo.GroupData.Charter),

10935

updateGroupInfo.GroupData.ShowInList,

10936

updateGroupInfo.GroupData.InsigniaID,

10937

updateGroupInfo.GroupData.MembershipFee,

10938

updateGroupInfo.GroupData.OpenEnrollment,

10939

updateGroupInfo.GroupData.AllowPublish,

10940

updateGroupInfo.GroupData.MaturePublish);

}

return true;

}

private bool HandleSetGroupAcceptNotices(IClientAPI sender, Packet Pack)

10946

{

10947

SetGroupAcceptNoticesPacket setGroupAcceptNotices =

10948

(SetGroupAcceptNoticesPacket)Pack;

10949

10950

#region Packet Session and User Check

10951

if (m_checkPackets)

10952

{

10953

if (setGroupAcceptNotices.AgentData.SessionID != SessionId ||

10954

setGroupAcceptNotices.AgentData.AgentID != AgentId)

return true;

}

#endregion

if (m_GroupsModule != null)

10960

{

10961

m_GroupsModule.SetGroupAcceptNotices(this,

10962

setGroupAcceptNotices.Data.GroupID,

10963

setGroupAcceptNotices.Data.AcceptNotices,

10964

setGroupAcceptNotices.NewData.ListInProfile);

}

return true;

}

private bool HandleGroupTitleUpdate(IClientAPI sender, Packet Pack)

10970

{

10971

GroupTitleUpdatePacket groupTitleUpdate =

10972

(GroupTitleUpdatePacket)Pack;

10973

10974

#region Packet Session and User Check

10975

if (m_checkPackets)

10976

{

10977

if (groupTitleUpdate.AgentData.SessionID != SessionId ||

10978

groupTitleUpdate.AgentData.AgentID != AgentId)

return true;

}

#endregion

if (m_GroupsModule != null)

10984

{

10985

m_GroupsModule.GroupTitleUpdate(this,

10986

groupTitleUpdate.AgentData.GroupID,

10987

groupTitleUpdate.AgentData.TitleRoleID);

}

return true;

}

private bool HandleParcelDeedToGroup(IClientAPI sender, Packet Pack)

10993

{

10994

ParcelDeedToGroupPacket parcelDeedToGroup = (ParcelDeedToGroupPacket)Pack;

10995

if (m_GroupsModule != null)

10996

{

10997

ParcelDeedToGroup handlerParcelDeedToGroup = OnParcelDeedToGroup;

10998

if (handlerParcelDeedToGroup != null)

10999

{

11000

handlerParcelDeedToGroup(parcelDeedToGroup.Data.LocalID, parcelDeedToGroup.Data.GroupID, this);

}

}

return true;

}

private bool HandleGroupNoticesListRequest(IClientAPI sender, Packet Pack)

11008

{

11009

GroupNoticesListRequestPacket groupNoticesListRequest =

11010

(GroupNoticesListRequestPacket)Pack;

11011

11012

#region Packet Session and User Check

11013

if (m_checkPackets)

11014

{

11015

if (groupNoticesListRequest.AgentData.SessionID != SessionId ||

11016

groupNoticesListRequest.AgentData.AgentID != AgentId)

return true;

}

#endregion

if (m_GroupsModule != null)

11022

{

11023

GroupNoticeData[] gn =

11024

m_GroupsModule.GroupNoticesListRequest(this,

11025

groupNoticesListRequest.Data.GroupID);

11026

11027

                GroupNoticesListReplyPacket groupNoticesListReply = (GroupNoticesListReplyPacket)PacketPool.Instance.GetPacket(PacketType.GroupNoticesListReply);

11028

groupNoticesListReply.AgentData =

11029

new GroupNoticesListReplyPacket.AgentDataBlock();

11030

groupNoticesListReply.AgentData.AgentID = AgentId;

11031

groupNoticesListReply.AgentData.GroupID = groupNoticesListRequest.Data.GroupID;

11032

11033

groupNoticesListReply.Data = new GroupNoticesListReplyPacket.DataBlock[gn.Length];

11034

11035

int i = 0;

11036

foreach (GroupNoticeData g in gn)

11037

{

11038

groupNoticesListReply.Data[i] = new GroupNoticesListReplyPacket.DataBlock();

11039

groupNoticesListReply.Data[i].NoticeID =

11040

g.NoticeID;

11041

groupNoticesListReply.Data[i].Timestamp =

11042

g.Timestamp;

11043

groupNoticesListReply.Data[i].FromName =

11044

Util.StringToBytes256(g.FromName);

11045

groupNoticesListReply.Data[i].Subject =

11046

Util.StringToBytes256(g.Subject);

11047

groupNoticesListReply.Data[i].HasAttachment =

11048

g.HasAttachment;

11049

groupNoticesListReply.Data[i].AssetType =

g.AssetType;

i++;

}

OutPacket(groupNoticesListReply, ThrottleOutPacketType.Task);

}

return true;

}

private bool HandleGroupNoticeRequest(IClientAPI sender, Packet Pack)

11060

{

11061

GroupNoticeRequestPacket groupNoticeRequest =

11062

(GroupNoticeRequestPacket)Pack;

11063

11064

#region Packet Session and User Check

11065

if (m_checkPackets)

11066

{

11067

if (groupNoticeRequest.AgentData.SessionID != SessionId ||

11068

groupNoticeRequest.AgentData.AgentID != AgentId)

return true;

}

#endregion

if (m_GroupsModule != null)

11074

{

11075

m_GroupsModule.GroupNoticeRequest(this,

11076

groupNoticeRequest.Data.GroupNoticeID);

}

return true;

}

private bool HandleGroupRoleUpdate(IClientAPI sender, Packet Pack)

11081

{

11082

GroupRoleUpdatePacket groupRoleUpdate =

11083

(GroupRoleUpdatePacket)Pack;

11084

11085

#region Packet Session and User Check

11086

if (m_checkPackets)

11087

{

11088

if (groupRoleUpdate.AgentData.SessionID != SessionId ||

11089

groupRoleUpdate.AgentData.AgentID != AgentId)

return true;

}

#endregion

if (m_GroupsModule != null)

11095

{

11096

foreach (GroupRoleUpdatePacket.RoleDataBlock d in

11097

groupRoleUpdate.RoleData)

11098

{

11099

m_GroupsModule.GroupRoleUpdate(this,

11100

groupRoleUpdate.AgentData.GroupID,

11101

d.RoleID,

11102

Utils.BytesToString(d.Name),

11103

Utils.BytesToString(d.Description),

11104

Utils.BytesToString(d.Title),

d.Powers,

d.UpdateType);

}

m_GroupsModule.NotifyChange(groupRoleUpdate.AgentData.GroupID);

}

return true;

}

private bool HandleGroupRoleChanges(IClientAPI sender, Packet Pack)

11113

{

11114

GroupRoleChangesPacket groupRoleChanges =

11115

(GroupRoleChangesPacket)Pack;

11116

11117

#region Packet Session and User Check

11118

if (m_checkPackets)

11119

{

11120

if (groupRoleChanges.AgentData.SessionID != SessionId ||

11121

groupRoleChanges.AgentData.AgentID != AgentId)

return true;

}

#endregion

if (m_GroupsModule != null)

11127

{

11128

foreach (GroupRoleChangesPacket.RoleChangeBlock d in

11129

groupRoleChanges.RoleChange)

11130

{

11131

m_GroupsModule.GroupRoleChanges(this,

11132

groupRoleChanges.AgentData.GroupID,

d.RoleID,

d.MemberID,

d.Change);

}

m_GroupsModule.NotifyChange(groupRoleChanges.AgentData.GroupID);

}

return true;

}

private bool HandleJoinGroupRequest(IClientAPI sender, Packet Pack)

11142

{

11143

JoinGroupRequestPacket joinGroupRequest =

11144

(JoinGroupRequestPacket)Pack;

11145

11146

#region Packet Session and User Check

11147

if (m_checkPackets)

11148

{

11149

if (joinGroupRequest.AgentData.SessionID != SessionId ||

11150

joinGroupRequest.AgentData.AgentID != AgentId)

return true;

}

#endregion

if (m_GroupsModule != null)

11156

{

11157

m_GroupsModule.JoinGroupRequest(this,

11158

joinGroupRequest.GroupData.GroupID);

}

return true;

}

private bool HandleLeaveGroupRequest(IClientAPI sender, Packet Pack)

11163

{

11164

LeaveGroupRequestPacket leaveGroupRequest =

11165

(LeaveGroupRequestPacket)Pack;

11166

11167

#region Packet Session and User Check

11168

if (m_checkPackets)

11169

{

11170

if (leaveGroupRequest.AgentData.SessionID != SessionId ||

11171

leaveGroupRequest.AgentData.AgentID != AgentId)

return true;

}

#endregion

if (m_GroupsModule != null)

11177

{

11178

m_GroupsModule.LeaveGroupRequest(this,

11179

leaveGroupRequest.GroupData.GroupID);

}

return true;

}

private bool HandleEjectGroupMemberRequest(IClientAPI sender, Packet Pack)

11184

{

11185

EjectGroupMemberRequestPacket ejectGroupMemberRequest =

11186

(EjectGroupMemberRequestPacket)Pack;

11187

11188

#region Packet Session and User Check

11189

if (m_checkPackets)

11190

{

11191

if (ejectGroupMemberRequest.AgentData.SessionID != SessionId ||

11192

ejectGroupMemberRequest.AgentData.AgentID != AgentId)

return true;

}

#endregion

if (m_GroupsModule != null)

11198

{

11199

foreach (EjectGroupMemberRequestPacket.EjectDataBlock e

11200

in ejectGroupMemberRequest.EjectData)

11201

{

11202

m_GroupsModule.EjectGroupMemberRequest(this,

11203

ejectGroupMemberRequest.GroupData.GroupID,

e.EjecteeID);

}

}

return true;

}

private bool HandleInviteGroupRequest(IClientAPI sender, Packet Pack)

11210

{

11211

InviteGroupRequestPacket inviteGroupRequest =

11212

(InviteGroupRequestPacket)Pack;

11213

11214

#region Packet Session and User Check

11215

if (m_checkPackets)

11216

{

11217

if (inviteGroupRequest.AgentData.SessionID != SessionId ||

11218

inviteGroupRequest.AgentData.AgentID != AgentId)

return true;

}

#endregion

if (m_GroupsModule != null)

11224

{

11225

foreach (InviteGroupRequestPacket.InviteDataBlock b in

11226

inviteGroupRequest.InviteData)

11227

{

11228

m_GroupsModule.InviteGroupRequest(this,

11229

inviteGroupRequest.GroupData.GroupID,

b.InviteeID,

b.RoleID);

}

}

return true;

}

#endregion Groups

private bool HandleStartLure(IClientAPI sender, Packet Pack)

11240

{

11241

StartLurePacket startLureRequest = (StartLurePacket)Pack;

11242

11243

#region Packet Session and User Check

11244

if (m_checkPackets)

11245

{

11246

if (startLureRequest.AgentData.SessionID != SessionId ||

11247

startLureRequest.AgentData.AgentID != AgentId)

return true;

}

#endregion

StartLure handlerStartLure = OnStartLure;

11253

if (handlerStartLure != null)

11254

handlerStartLure(startLureRequest.Info.LureType,

11255

Utils.BytesToString(

11256

startLureRequest.Info.Message),

11257

startLureRequest.TargetData[0].TargetID,

this);

return true;

}

private bool HandleTeleportLureRequest(IClientAPI sender, Packet Pack)

11262

{

11263

TeleportLureRequestPacket teleportLureRequest =

11264

(TeleportLureRequestPacket)Pack;

11265

11266

#region Packet Session and User Check

11267

if (m_checkPackets)

11268

{

11269

if (teleportLureRequest.Info.SessionID != SessionId ||

11270

teleportLureRequest.Info.AgentID != AgentId)

return true;

}

#endregion

TeleportLureRequest handlerTeleportLureRequest = OnTeleportLureRequest;

11276

if (handlerTeleportLureRequest != null)

11277

handlerTeleportLureRequest(

11278

teleportLureRequest.Info.LureID,

11279

teleportLureRequest.Info.TeleportFlags,

this);

return true;

}

private bool HandleClassifiedInfoRequest(IClientAPI sender, Packet Pack)

11284

{

11285

ClassifiedInfoRequestPacket classifiedInfoRequest =

11286

(ClassifiedInfoRequestPacket)Pack;

11287

11288

#region Packet Session and User Check

11289

if (m_checkPackets)

11290

{

11291

if (classifiedInfoRequest.AgentData.SessionID != SessionId ||

11292

classifiedInfoRequest.AgentData.AgentID != AgentId)

return true;

}

#endregion

ClassifiedInfoRequest handlerClassifiedInfoRequest = OnClassifiedInfoRequest;

11298

if (handlerClassifiedInfoRequest != null)

11299

handlerClassifiedInfoRequest(

11300

classifiedInfoRequest.Data.ClassifiedID,

this);

return true;

}

private bool HandleClassifiedInfoUpdate(IClientAPI sender, Packet Pack)

11305

{

11306

ClassifiedInfoUpdatePacket classifiedInfoUpdate =

11307

(ClassifiedInfoUpdatePacket)Pack;

11308

11309

#region Packet Session and User Check

11310

if (m_checkPackets)

11311

{

11312

if (classifiedInfoUpdate.AgentData.SessionID != SessionId ||

11313

classifiedInfoUpdate.AgentData.AgentID != AgentId)

return true;

}

#endregion

ClassifiedInfoUpdate handlerClassifiedInfoUpdate = OnClassifiedInfoUpdate;

11319

if (handlerClassifiedInfoUpdate != null)

11320

handlerClassifiedInfoUpdate(

11321

classifiedInfoUpdate.Data.ClassifiedID,

11322

classifiedInfoUpdate.Data.Category,

11323

Utils.BytesToString(

11324

classifiedInfoUpdate.Data.Name),

11325

Utils.BytesToString(

11326

classifiedInfoUpdate.Data.Desc),

11327

classifiedInfoUpdate.Data.ParcelID,

11328

classifiedInfoUpdate.Data.ParentEstate,

11329

classifiedInfoUpdate.Data.SnapshotID,

11330

new Vector3(

11331

classifiedInfoUpdate.Data.PosGlobal),

11332

classifiedInfoUpdate.Data.ClassifiedFlags,

11333

classifiedInfoUpdate.Data.PriceForListing,

this);

return true;

}

private bool HandleClassifiedDelete(IClientAPI sender, Packet Pack)

11338

{

11339

ClassifiedDeletePacket classifiedDelete =

11340

(ClassifiedDeletePacket)Pack;

11341

11342

#region Packet Session and User Check

11343

if (m_checkPackets)

11344

{

11345

if (classifiedDelete.AgentData.SessionID != SessionId ||

11346

classifiedDelete.AgentData.AgentID != AgentId)

return true;

}

#endregion

ClassifiedDelete handlerClassifiedDelete = OnClassifiedDelete;

11352

if (handlerClassifiedDelete != null)

11353

handlerClassifiedDelete(

11354

classifiedDelete.Data.ClassifiedID,

this);

return true;

}

private bool HandleClassifiedGodDelete(IClientAPI sender, Packet Pack)

11359

{

11360

ClassifiedGodDeletePacket classifiedGodDelete =

11361

(ClassifiedGodDeletePacket)Pack;

11362

11363

#region Packet Session and User Check

11364

if (m_checkPackets)

11365

{

11366

if (classifiedGodDelete.AgentData.SessionID != SessionId ||

11367

classifiedGodDelete.AgentData.AgentID != AgentId)

return true;

}

#endregion

ClassifiedDelete handlerClassifiedGodDelete = OnClassifiedGodDelete;

11373

if (handlerClassifiedGodDelete != null)

11374

handlerClassifiedGodDelete(

11375

classifiedGodDelete.Data.ClassifiedID,

this);

return true;

}

private bool HandleEventGodDelete(IClientAPI sender, Packet Pack)

11380

{

11381

EventGodDeletePacket eventGodDelete =

11382

(EventGodDeletePacket)Pack;

11383

11384

#region Packet Session and User Check

11385

if (m_checkPackets)

11386

{

11387

if (eventGodDelete.AgentData.SessionID != SessionId ||

11388

eventGodDelete.AgentData.AgentID != AgentId)

return true;

}

#endregion

EventGodDelete handlerEventGodDelete = OnEventGodDelete;

11394

if (handlerEventGodDelete != null)

11395

handlerEventGodDelete(

11396

eventGodDelete.EventData.EventID,

11397

eventGodDelete.QueryData.QueryID,

11398

Utils.BytesToString(

11399

eventGodDelete.QueryData.QueryText),

11400

eventGodDelete.QueryData.QueryFlags,

11401

eventGodDelete.QueryData.QueryStart,

this);

return true;

}

private bool HandleEventNotificationAddRequest(IClientAPI sender, Packet Pack)

11406

{

11407

EventNotificationAddRequestPacket eventNotificationAdd =

11408

(EventNotificationAddRequestPacket)Pack;

11409

11410

#region Packet Session and User Check

11411

if (m_checkPackets)

11412

{

11413

if (eventNotificationAdd.AgentData.SessionID != SessionId ||

11414

eventNotificationAdd.AgentData.AgentID != AgentId)

return true;

}

#endregion

EventNotificationAddRequest handlerEventNotificationAddRequest = OnEventNotificationAddRequest;

11420

if (handlerEventNotificationAddRequest != null)

11421

handlerEventNotificationAddRequest(

11422

eventNotificationAdd.EventData.EventID, this);

11423

return true;

11424

}

11425

private bool HandleEventNotificationRemoveRequest(IClientAPI sender, Packet Pack)

11426

{

11427

EventNotificationRemoveRequestPacket eventNotificationRemove =

11428

(EventNotificationRemoveRequestPacket)Pack;

11429

11430

#region Packet Session and User Check

11431

if (m_checkPackets)

11432

{

11433

if (eventNotificationRemove.AgentData.SessionID != SessionId ||

11434

eventNotificationRemove.AgentData.AgentID != AgentId)

return true;

}

#endregion

EventNotificationRemoveRequest handlerEventNotificationRemoveRequest = OnEventNotificationRemoveRequest;

11440

if (handlerEventNotificationRemoveRequest != null)

11441

handlerEventNotificationRemoveRequest(

11442

eventNotificationRemove.EventData.EventID, this);

11443

return true;

11444

}

11445

private bool HandleRetrieveInstantMessages(IClientAPI sender, Packet Pack)

11446

{

11447

RetrieveInstantMessagesPacket rimpInstantMessagePack = (RetrieveInstantMessagesPacket)Pack;

11448

11449

#region Packet Session and User Check

11450

if (m_checkPackets)

11451

{

11452

if (rimpInstantMessagePack.AgentData.SessionID != SessionId ||

11453

rimpInstantMessagePack.AgentData.AgentID != AgentId)

return true;

}

#endregion

RetrieveInstantMessages handlerRetrieveInstantMessages = OnRetrieveInstantMessages;

11459

if (handlerRetrieveInstantMessages != null)

11460

handlerRetrieveInstantMessages(this);

11461

return true;

11462

}

11463

private bool HandlePickDelete(IClientAPI sender, Packet Pack)

11464

{

11465

PickDeletePacket pickDelete =

11466

(PickDeletePacket)Pack;

11467

11468

#region Packet Session and User Check

11469

if (m_checkPackets)

11470

{

11471

if (pickDelete.AgentData.SessionID != SessionId ||

11472

pickDelete.AgentData.AgentID != AgentId)

return true;

}

#endregion

PickDelete handlerPickDelete = OnPickDelete;

11478

if (handlerPickDelete != null)

11479

handlerPickDelete(this, pickDelete.Data.PickID);

11480

return true;

11481

}

11482

private bool HandlePickGodDelete(IClientAPI sender, Packet Pack)

11483

{

11484

PickGodDeletePacket pickGodDelete =

11485

(PickGodDeletePacket)Pack;

11486

11487

#region Packet Session and User Check

11488

if (m_checkPackets)

11489

{

11490

if (pickGodDelete.AgentData.SessionID != SessionId ||

11491

pickGodDelete.AgentData.AgentID != AgentId)

return true;

}

#endregion

PickGodDelete handlerPickGodDelete = OnPickGodDelete;

11497

if (handlerPickGodDelete != null)

11498

handlerPickGodDelete(this,

11499

pickGodDelete.AgentData.AgentID,

11500

pickGodDelete.Data.PickID,

11501

pickGodDelete.Data.QueryID);

11502

return true;

11503

}

11504

private bool HandlePickInfoUpdate(IClientAPI sender, Packet Pack)

11505

{

11506

PickInfoUpdatePacket pickInfoUpdate =

11507

(PickInfoUpdatePacket)Pack;

11508

11509

#region Packet Session and User Check

11510

if (m_checkPackets)

11511

{

11512

if (pickInfoUpdate.AgentData.SessionID != SessionId ||

11513

pickInfoUpdate.AgentData.AgentID != AgentId)

return true;

}

#endregion

PickInfoUpdate handlerPickInfoUpdate = OnPickInfoUpdate;

11519

if (handlerPickInfoUpdate != null)

11520

handlerPickInfoUpdate(this,

11521

pickInfoUpdate.Data.PickID,

11522

pickInfoUpdate.Data.CreatorID,

11523

pickInfoUpdate.Data.TopPick,

11524

Utils.BytesToString(pickInfoUpdate.Data.Name),

11525

Utils.BytesToString(pickInfoUpdate.Data.Desc),

11526

pickInfoUpdate.Data.SnapshotID,

11527

pickInfoUpdate.Data.SortOrder,

11528

pickInfoUpdate.Data.Enabled);

11529

return true;

11530

}

11531

private bool HandleAvatarNotesUpdate(IClientAPI sender, Packet Pack)

11532

{

11533

AvatarNotesUpdatePacket avatarNotesUpdate =

11534

(AvatarNotesUpdatePacket)Pack;

11535

11536

#region Packet Session and User Check

11537

if (m_checkPackets)

11538

{

11539

if (avatarNotesUpdate.AgentData.SessionID != SessionId ||

11540

avatarNotesUpdate.AgentData.AgentID != AgentId)

return true;

}

#endregion

AvatarNotesUpdate handlerAvatarNotesUpdate = OnAvatarNotesUpdate;

11546

if (handlerAvatarNotesUpdate != null)

11547

handlerAvatarNotesUpdate(this,

11548

avatarNotesUpdate.Data.TargetID,

11549

Utils.BytesToString(avatarNotesUpdate.Data.Notes));

11550

return true;

11551

}

11552

private bool HandleAvatarInterestsUpdate(IClientAPI sender, Packet Pack)

11553

{

11554

AvatarInterestsUpdatePacket avatarInterestUpdate =

11555

(AvatarInterestsUpdatePacket)Pack;

11556

11557

#region Packet Session and User Check

11558

if (m_checkPackets)

11559

{

11560

if (avatarInterestUpdate.AgentData.SessionID != SessionId ||

11561

avatarInterestUpdate.AgentData.AgentID != AgentId)

return true;

}

#endregion

AvatarInterestUpdate handlerAvatarInterestUpdate = OnAvatarInterestUpdate;

11567

if (handlerAvatarInterestUpdate != null)

11568

handlerAvatarInterestUpdate(this,

11569

avatarInterestUpdate.PropertiesData.WantToMask,

11570

Utils.BytesToString(avatarInterestUpdate.PropertiesData.WantToText),

11571

avatarInterestUpdate.PropertiesData.SkillsMask,

11572

Utils.BytesToString(avatarInterestUpdate.PropertiesData.SkillsText),

11573

Utils.BytesToString(avatarInterestUpdate.PropertiesData.LanguagesText));

return true;

}

private bool HandleGrantUserRights(IClientAPI sender, Packet Pack)

11578

{

11579

GrantUserRightsPacket GrantUserRights =

11580

(GrantUserRightsPacket)Pack;

11581

#region Packet Session and User Check

11582

if (m_checkPackets)

11583

{

11584

if (GrantUserRights.AgentData.SessionID != SessionId ||

11585

GrantUserRights.AgentData.AgentID != AgentId)

return true;

}

#endregion

GrantUserFriendRights GrantUserRightsHandler = OnGrantUserRights;

11591

if (GrantUserRightsHandler != null)

11592

GrantUserRightsHandler(this,

11593

GrantUserRights.Rights[0].AgentRelated,

11594

GrantUserRights.Rights[0].RelatedRights);

return true;

}

private bool HandlePlacesQuery(IClientAPI sender, Packet Pack)

11600

{

11601

PlacesQueryPacket placesQueryPacket =

11602

(PlacesQueryPacket)Pack;

11603

11604

PlacesQuery handlerPlacesQuery = OnPlacesQuery;

11605

11606

if (handlerPlacesQuery != null)

11607

handlerPlacesQuery(placesQueryPacket.AgentData.QueryID,

11608

placesQueryPacket.TransactionData.TransactionID,

11609

Utils.BytesToString(

11610

placesQueryPacket.QueryData.QueryText),

11611

placesQueryPacket.QueryData.QueryFlags,

11612

(byte)placesQueryPacket.QueryData.Category,

11613

Utils.BytesToString(

11614

placesQueryPacket.QueryData.SimName),

this);

return true;

}

#endregion Packet Handlers

11620

11621

public void SendScriptQuestion(UUID taskID, string taskName, string ownerName, UUID itemID, int question)

11622

{

11623

            ScriptQuestionPacket scriptQuestion = (ScriptQuestionPacket)PacketPool.Instance.GetPacket(PacketType.ScriptQuestion);

11624

scriptQuestion.Data = new ScriptQuestionPacket.DataBlock();

11625

// TODO: don't create new blocks if recycling an old packet

11626

scriptQuestion.Data.TaskID = taskID;

11627

scriptQuestion.Data.ItemID = itemID;

11628

scriptQuestion.Data.Questions = question;

11629

scriptQuestion.Data.ObjectName = Util.StringToBytes256(taskName);

11630

scriptQuestion.Data.ObjectOwner = Util.StringToBytes256(ownerName);

11631

11632

OutPacket(scriptQuestion, ThrottleOutPacketType.Task);

}

/// <summary>

/// Handler called when we receive a logout packet.

11637

/// </summary>

11638

/// <param name="client"></param>

11639

/// <param name="packet"></param>

11640

/// <returns></returns>

11641

protected virtual bool HandleLogout(IClientAPI client, Packet packet)

11642

{

11643

if (packet.Type == PacketType.LogoutRequest)

11644

{

11645

if (((LogoutRequestPacket)packet).AgentData.SessionID != SessionId) return false;

11646

}

11647

11648

return Logout(client);

}

/// <summary>

///

/// </summary>

/// <param name="client"></param>

11655

/// <returns></returns>

11656

protected virtual bool Logout(IClientAPI client)

11657

{

11658

m_log.InfoFormat("[CLIENT]: Got a logout request for {0} in {1}", Name, Scene.RegionInfo.RegionName);

11659

11660

Action<IClientAPI> handlerLogout = OnLogout;

11661

11662

if (handlerLogout != null)

11663

{

11664

handlerLogout(client);

}

return true;

}

/// <summary>

/// </summary>

/// <remarks>

/// At the moment, we always reply that there is no cached texture.

11674

/// </remarks>

11675

/// <param name="simclient"></param>

11676

/// <param name="packet"></param>

11677

/// <returns></returns>

11678

protected bool HandleAgentTextureCached(IClientAPI simclient, Packet packet)

11679

{

11680

AgentCachedTexturePacket cachedtex = (AgentCachedTexturePacket)packet;

11681

11682

if (cachedtex.AgentData.SessionID != SessionId)

11683

return false;

11684

11685

List<CachedTextureRequestArg> requestArgs = new List<CachedTextureRequestArg>();

11686

11687

for (int i = 0; i < cachedtex.WearableData.Length; i++)

11688

{

11689

CachedTextureRequestArg arg = new CachedTextureRequestArg();

11690

arg.BakedTextureIndex = cachedtex.WearableData[i].TextureIndex;

11691

arg.WearableHashID = cachedtex.WearableData[i].ID;

11692

11693

requestArgs.Add(arg);

}

try

{

CachedTextureRequest handlerCachedTextureRequest = OnCachedTextureRequest;

11699

if (handlerCachedTextureRequest != null)

11700

{

11701

handlerCachedTextureRequest(simclient,cachedtex.AgentData.SerialNum,requestArgs);

11702

}

11703

}

11704

catch (Exception e)

11705

{

11706

m_log.ErrorFormat("[CLIENT VIEW]: AgentTextureCached packet handler threw an exception, {0}", e);

return false;

}

return true;

}

/// <summary>

/// Send a response back to a client when it asks the asset server (via the region server) if it has

11715

/// its appearance texture cached.

11716

/// </summary>

11717

/// <param name="avatar"></param>

11718

/// <param name="serial"></param>

11719

/// <param name="cachedTextures"></param>

11720

/// <returns></returns>

11721

        public void SendCachedTextureResponse(ISceneEntity avatar, int serial, List<CachedTextureResponseArg> cachedTextures)

11722

{

11723

ScenePresence presence = avatar as ScenePresence;

11724

if (presence == null)

11725

return;

11726

11727

            AgentCachedTextureResponsePacket cachedresp = (AgentCachedTextureResponsePacket)PacketPool.Instance.GetPacket(PacketType.AgentCachedTextureResponse);

11728

11729

// TODO: don't create new blocks if recycling an old packet

11730

cachedresp.AgentData.AgentID = m_agentId;

11731

cachedresp.AgentData.SessionID = m_sessionId;

11732

cachedresp.AgentData.SerialNum = serial;

11733

cachedresp.WearableData = new AgentCachedTextureResponsePacket.WearableDataBlock[cachedTextures.Count];

11734

11735

for (int i = 0; i < cachedTextures.Count; i++)

11736

{

11737

cachedresp.WearableData[i] = new AgentCachedTextureResponsePacket.WearableDataBlock();

11738

cachedresp.WearableData[i].TextureIndex = (byte)cachedTextures[i].BakedTextureIndex;

11739

cachedresp.WearableData[i].TextureID = cachedTextures[i].BakedTextureID;

11740

cachedresp.WearableData[i].HostName = new byte[0];

11741

}

11742

11743

cachedresp.Header.Zerocoded = true;

11744

OutPacket(cachedresp, ThrottleOutPacketType.Task);

11745

}

11746

11747

protected bool HandleMultipleObjUpdate(IClientAPI simClient, Packet packet)

11748

{

11749

MultipleObjectUpdatePacket multipleupdate = (MultipleObjectUpdatePacket)packet;

11750

11751

if (multipleupdate.AgentData.SessionID != SessionId)

11752

return false;

11753

11754

// m_log.DebugFormat(

11755

//                "[CLIENT]: Incoming MultipleObjectUpdatePacket contained {0} blocks", multipleupdate.ObjectData.Length);

11756

11757

Scene tScene = (Scene)m_scene;

11758

11759

for (int i = 0; i < multipleupdate.ObjectData.Length; i++)

11760

{

11761

MultipleObjectUpdatePacket.ObjectDataBlock block = multipleupdate.ObjectData[i];

11762

11763

// Can't act on Null Data

11764

if (block.Data != null)

11765

{

11766

uint localId = block.ObjectLocalID;

11767

SceneObjectPart part = tScene.GetSceneObjectPart(localId);

if (part == null)

{

// It's a ghost! tell the client to delete it from view.

11772

simClient.SendKillObject(new List<uint> { localId });

}

else

{

// m_log.DebugFormat(

11777

// "[CLIENT]: Processing block {0} type {1} for {2} {3}",

11778

// i, block.Type, part.Name, part.LocalId);

11779

11780

// // Do this once since fetch parts creates a new array.

11781

// SceneObjectPart[] parts = part.ParentGroup.Parts;

11782

// for (int j = 0; j < parts.Length; j++)

11783

// {

11784

// part.StoreUndoState();

11785

// parts[j].IgnoreUndoUpdate = true;

11786

// }

11787

11788

UpdatePrimGroupRotation handlerUpdatePrimGroupRotation;

11789

11790

switch (block.Type)

11791

{

11792

case 1:

11793

Vector3 pos1 = new Vector3(block.Data, 0);

11794

11795

UpdateVector handlerUpdatePrimSinglePosition = OnUpdatePrimSinglePosition;

11796

if (handlerUpdatePrimSinglePosition != null)

11797

{

11798

// m_log.Debug("new movement position is " + pos.X + " , " + pos.Y + " , " + pos.Z);

11799

handlerUpdatePrimSinglePosition(localId, pos1, this);

}

break;

case 2:

Quaternion rot1 = new Quaternion(block.Data, 0, true);

11805

11806

UpdatePrimSingleRotation handlerUpdatePrimSingleRotation = OnUpdatePrimSingleRotation;

11807

if (handlerUpdatePrimSingleRotation != null)

11808

{

11809

                                    // m_log.Info("new tab rotation is " + rot1.X + " , " + rot1.Y + " , " + rot1.Z + " , " + rot1.W);

11810

handlerUpdatePrimSingleRotation(localId, rot1, this);

}

break;

case 3:

Vector3 rotPos = new Vector3(block.Data, 0);

11816

Quaternion rot2 = new Quaternion(block.Data, 12, true);

11817

11818

                                UpdatePrimSingleRotationPosition handlerUpdatePrimSingleRotationPosition = OnUpdatePrimSingleRotationPosition;

11819

if (handlerUpdatePrimSingleRotationPosition != null)

11820

{

11821

                                    // m_log.Debug("new mouse rotation position is " + rotPos.X + " , " + rotPos.Y + " , " + rotPos.Z);

11822

                                    // m_log.Info("new mouse rotation is " + rot2.X + " , " + rot2.Y + " , " + rot2.Z + " , " + rot2.W);

11823

handlerUpdatePrimSingleRotationPosition(localId, rot2, rotPos, this);

}

break;

case 4:

case 20:

Vector3 scale4 = new Vector3(block.Data, 0);

11830

11831

UpdateVector handlerUpdatePrimScale = OnUpdatePrimScale;

11832

if (handlerUpdatePrimScale != null)

11833

{

11834

                                    //                                     m_log.Debug("new scale is " + scale4.X + " , " + scale4.Y + " , " + scale4.Z);

11835

handlerUpdatePrimScale(localId, scale4, this);

}

break;

case 5:

Vector3 scale1 = new Vector3(block.Data, 12);

11841

Vector3 pos11 = new Vector3(block.Data, 0);

11842

11843

handlerUpdatePrimScale = OnUpdatePrimScale;

11844

if (handlerUpdatePrimScale != null)

11845

{

11846

// m_log.Debug("new scale is " + scale.X + " , " + scale.Y + " , " + scale.Z);

11847

handlerUpdatePrimScale(localId, scale1, this);

11848

11849

handlerUpdatePrimSinglePosition = OnUpdatePrimSinglePosition;

11850

if (handlerUpdatePrimSinglePosition != null)

11851

{

11852

handlerUpdatePrimSinglePosition(localId, pos11, this);

}

}

break;

case 9:

Vector3 pos2 = new Vector3(block.Data, 0);

11859

11860

UpdateVector handlerUpdateVector = OnUpdatePrimGroupPosition;

11861

11862

if (handlerUpdateVector != null)

11863

{

11864

handlerUpdateVector(localId, pos2, this);

}

break;

case 10:

Quaternion rot3 = new Quaternion(block.Data, 0, true);

11870

11871

UpdatePrimRotation handlerUpdatePrimRotation = OnUpdatePrimGroupRotation;

11872

if (handlerUpdatePrimRotation != null)

11873

{

11874

                                    //  Console.WriteLine("new rotation is " + rot3.X + " , " + rot3.Y + " , " + rot3.Z + " , " + rot3.W);

11875

handlerUpdatePrimRotation(localId, rot3, this);

}

break;

case 11:

Vector3 pos3 = new Vector3(block.Data, 0);

11881

Quaternion rot4 = new Quaternion(block.Data, 12, true);

11882

11883

handlerUpdatePrimGroupRotation = OnUpdatePrimGroupMouseRotation;

11884

if (handlerUpdatePrimGroupRotation != null)

11885

{

11886

                                    //  m_log.Debug("new rotation position is " + pos.X + " , " + pos.Y + " , " + pos.Z);

11887

                                    // m_log.Debug("new group mouse rotation is " + rot4.X + " , " + rot4.Y + " , " + rot4.Z + " , " + rot4.W);

11888

handlerUpdatePrimGroupRotation(localId, pos3, rot4, this);

}

break;

case 12:

case 28:

Vector3 scale7 = new Vector3(block.Data, 0);

11894

11895

UpdateVector handlerUpdatePrimGroupScale = OnUpdatePrimGroupScale;

11896

if (handlerUpdatePrimGroupScale != null)

11897

{

11898

                                    //                                     m_log.Debug("new scale is " + scale7.X + " , " + scale7.Y + " , " + scale7.Z);

11899

handlerUpdatePrimGroupScale(localId, scale7, this);

}

break;

case 13:

Vector3 scale2 = new Vector3(block.Data, 12);

11905

Vector3 pos4 = new Vector3(block.Data, 0);

11906

11907

handlerUpdatePrimScale = OnUpdatePrimScale;

11908

if (handlerUpdatePrimScale != null)

11909

{

11910

//m_log.Debug("new scale is " + scale.X + " , " + scale.Y + " , " + scale.Z);

11911

handlerUpdatePrimScale(localId, scale2, this);

11912

11913

// Change the position based on scale (for bug number 246)

11914

handlerUpdatePrimSinglePosition = OnUpdatePrimSinglePosition;

11915

// m_log.Debug("new movement position is " + pos.X + " , " + pos.Y + " , " + pos.Z);

11916

if (handlerUpdatePrimSinglePosition != null)

11917

{

11918

handlerUpdatePrimSinglePosition(localId, pos4, this);

}

}

break;

case 29:

Vector3 scale5 = new Vector3(block.Data, 12);

11925

Vector3 pos5 = new Vector3(block.Data, 0);

11926

11927

handlerUpdatePrimGroupScale = OnUpdatePrimGroupScale;

11928

if (handlerUpdatePrimGroupScale != null)

11929

{

11930

// m_log.Debug("new scale is " + scale.X + " , " + scale.Y + " , " + scale.Z);

11931

part.StoreUndoState(true);

11932

part.IgnoreUndoUpdate = true;

11933

handlerUpdatePrimGroupScale(localId, scale5, this);

11934

handlerUpdateVector = OnUpdatePrimGroupPosition;

11935

11936

if (handlerUpdateVector != null)

11937

{

11938

handlerUpdateVector(localId, pos5, this);

11939

}

11940

11941

part.IgnoreUndoUpdate = false;

}

break;

case 21:

Vector3 scale6 = new Vector3(block.Data, 12);

11948

Vector3 pos6 = new Vector3(block.Data, 0);

11949

11950

handlerUpdatePrimScale = OnUpdatePrimScale;

11951

if (handlerUpdatePrimScale != null)

11952

{

11953

part.StoreUndoState(false);

11954

part.IgnoreUndoUpdate = true;

11955

11956

// m_log.Debug("new scale is " + scale.X + " , " + scale.Y + " , " + scale.Z);

11957

handlerUpdatePrimScale(localId, scale6, this);

11958

handlerUpdatePrimSinglePosition = OnUpdatePrimSinglePosition;

11959

if (handlerUpdatePrimSinglePosition != null)

11960

{

11961

handlerUpdatePrimSinglePosition(localId, pos6, this);

11962

}

11963

11964

part.IgnoreUndoUpdate = false;

}

break;

default:

                                m_log.Debug("[CLIENT]: MultipleObjUpdate recieved an unknown packet type: " + (block.Type));

break;

}

// for (int j = 0; j < parts.Length; j++)

11974

// parts[j].IgnoreUndoUpdate = false;

}

}

}

return true;

}

public void RequestMapLayer()

11983

{

11984

//should be getting the map layer from the grid server

11985

//send a layer covering the 800,800 - 1200,1200 area (should be covering the requested area)

11986

MapLayerReplyPacket mapReply = (MapLayerReplyPacket)PacketPool.Instance.GetPacket(PacketType.MapLayerReply);

11987

// TODO: don't create new blocks if recycling an old packet

11988

mapReply.AgentData.AgentID = AgentId;

11989

mapReply.AgentData.Flags = 0;

11990

mapReply.LayerData = new MapLayerReplyPacket.LayerDataBlock[1];

11991

mapReply.LayerData[0] = new MapLayerReplyPacket.LayerDataBlock();

11992

mapReply.LayerData[0].Bottom = 0;

11993

mapReply.LayerData[0].Left = 0;

11994

mapReply.LayerData[0].Top = 30000;

11995

mapReply.LayerData[0].Right = 30000;

11996

mapReply.LayerData[0].ImageID = new UUID("00000000-0000-1111-9999-000000000006");

11997

mapReply.Header.Zerocoded = true;

11998

OutPacket(mapReply, ThrottleOutPacketType.Land);

11999

}

12000

12001

public void RequestMapBlocksX(int minX, int minY, int maxX, int maxY)

12002

{

12003

/*

12004

IList simMapProfiles = m_gridServer.RequestMapBlocks(minX, minY, maxX, maxY);

12005

MapBlockReplyPacket mbReply = new MapBlockReplyPacket();

12006

mbReply.AgentData.AgentId = AgentId;

12007

int len;

12008

if (simMapProfiles == null)

12009

len = 0;

12010

else

12011

len = simMapProfiles.Count;

12012

12013

mbReply.Data = new MapBlockReplyPacket.DataBlock[len];

12014

int iii;

12015

for (iii = 0; iii < len; iii++)

12016

{

12017

Hashtable mp = (Hashtable)simMapProfiles[iii];

12018

mbReply.Data[iii] = new MapBlockReplyPacket.DataBlock();

12019

mbReply.Data[iii].Name = Util.UTF8.GetBytes((string)mp["name"]);

12020

mbReply.Data[iii].Access = System.Convert.ToByte(mp["access"]);

12021

mbReply.Data[iii].Agents = System.Convert.ToByte(mp["agents"]);

12022

mbReply.Data[iii].MapImageID = new UUID((string)mp["map-image-id"]);

12023

mbReply.Data[iii].RegionFlags = System.Convert.ToUInt32(mp["region-flags"]);

12024

mbReply.Data[iii].WaterHeight = System.Convert.ToByte(mp["water-height"]);

12025

mbReply.Data[iii].X = System.Convert.ToUInt16(mp["x"]);

12026

mbReply.Data[iii].Y = System.Convert.ToUInt16(mp["y"]);

12027

}

12028

this.OutPacket(mbReply, ThrottleOutPacketType.Land);

*/

}

/// <summary>

/// Sets the throttles from values supplied by the client

12034

/// </summary>

12035

/// <param name="throttles"></param>

12036

public void SetChildAgentThrottle(byte[] throttles)

12037

{

12038

m_udpClient.SetThrottles(throttles);

}

/// <summary>

/// Get the current throttles for this client as a packed byte array

12043

/// </summary>

12044

/// <param name="multiplier">Unused</param>

12045

/// <returns></returns>

12046

public byte[] GetThrottlesPacked(float multiplier)

12047

{

12048

return m_udpClient.GetThrottlesPacked(multiplier);

}

/// <summary>

/// Cruft?

/// </summary>

public virtual void InPacket(object NewPack)

12055

{

12056

throw new NotImplementedException();

}

/// <summary>

/// This is the starting point for sending a simulator packet out to the client

12061

/// </summary>

12062

/// <param name="packet">Packet to send</param>

12063

/// <param name="throttlePacketType">Throttling category for the packet</param>

12064

protected void OutPacket(Packet packet, ThrottleOutPacketType throttlePacketType)

12065

{

12066

#region BinaryStats

12067

LLUDPServer.LogPacketHeader(false, m_circuitCode, 0, packet.Type, (ushort)packet.Length);

12068

#endregion BinaryStats

12069

12070

OutPacket(packet, throttlePacketType, true);

}

/// <summary>

/// This is the starting point for sending a simulator packet out to the client

12075

/// </summary>

12076

/// <param name="packet">Packet to send</param>

12077

/// <param name="throttlePacketType">Throttling category for the packet</param>

12078

/// <param name="doAutomaticSplitting">True to automatically split oversized

12079

/// packets (the default), or false to disable splitting if the calling code

12080

/// handles splitting manually</param>

12081

protected void OutPacket(Packet packet, ThrottleOutPacketType throttlePacketType, bool doAutomaticSplitting)

12082

{

12083

OutPacket(packet, throttlePacketType, doAutomaticSplitting, null);

}

/// <summary>

/// This is the starting point for sending a simulator packet out to the client

12088

/// </summary>

12089

/// <param name="packet">Packet to send</param>

12090

/// <param name="throttlePacketType">Throttling category for the packet</param>

12091

/// <param name="doAutomaticSplitting">True to automatically split oversized

12092

/// packets (the default), or false to disable splitting if the calling code

12093

/// handles splitting manually</param>

12094

/// <param name="method">The method to be called in the event this packet is reliable

12095

/// and unacknowledged. The server will provide normal resend capability if you do not

12096

/// provide your own method.</param>

12097

        protected void OutPacket(Packet packet, ThrottleOutPacketType throttlePacketType, bool doAutomaticSplitting, UnackedPacketMethod method)

12098

{

12099

if (DebugPacketLevel > 0)

12100

{

12101

bool logPacket = true;

12102

12103

if (DebugPacketLevel <= 255

12104

&& (packet.Type == PacketType.SimStats || packet.Type == PacketType.SimulatorViewerTimeMessage))

12105

logPacket = false;

12106

12107

if (DebugPacketLevel <= 200

12108

&& (packet.Type == PacketType.ImagePacket

12109

|| packet.Type == PacketType.ImageData

12110

|| packet.Type == PacketType.LayerData

12111

|| packet.Type == PacketType.CoarseLocationUpdate))

12112

logPacket = false;

12113

12114

                if (DebugPacketLevel <= 100 && (packet.Type == PacketType.AvatarAnimation || packet.Type == PacketType.ViewerEffect))

12115

logPacket = false;

12116

12117

if (DebugPacketLevel <= 50

12118

&& (packet.Type == PacketType.ImprovedTerseObjectUpdate || packet.Type == PacketType.ObjectUpdate))

12119

logPacket = false;

12120

12121

if (DebugPacketLevel <= 25 && packet.Type == PacketType.ObjectPropertiesFamily)

logPacket = false;

if (logPacket)

m_log.DebugFormat(

"[CLIENT]: PACKET OUT to {0} ({1}) in {2} - {3}",

12127

Name, SceneAgent.IsChildAgent ? "child" : "root ", m_scene.RegionInfo.RegionName, packet.Type);

12128

}

12129

12130

m_udpServer.SendPacket(m_udpClient, packet, throttlePacketType, doAutomaticSplitting, method);

12131

}

12132

12133

protected void HandleAutopilot(Object sender, string method, List<String> args)

{

float locx = 0;

float locy = 0;

float locz = 0;

uint regionX = 0;

uint regionY = 0;

Utils.LongToUInts(m_scene.RegionInfo.RegionHandle, out regionX, out regionY);

12142

locx = Convert.ToSingle(args[0]) - (float)regionX;

12143

locy = Convert.ToSingle(args[1]) - (float)regionY;

12144

locz = Convert.ToSingle(args[2]);

12145

12146

Action<Vector3, bool, bool> handlerAutoPilotGo = OnAutoPilotGo;

12147

if (handlerAutoPilotGo != null)

12148

handlerAutoPilotGo(new Vector3(locx, locy, locz), false, false);

}

/// <summary>

/// Entryway from the client to the simulator. All UDP packets from the client will end up here

12153

/// </summary>

12154

/// <param name="Pack">OpenMetaverse.packet</param>

12155

public void ProcessInPacket(Packet packet)

12156

{

12157

if (DebugPacketLevel > 0)

12158

{

12159

bool logPacket = true;

12160

12161

if (DebugPacketLevel <= 255 && packet.Type == PacketType.AgentUpdate)

12162

logPacket = false;

12163

12164

if (DebugPacketLevel <= 200 && packet.Type == PacketType.RequestImage)

12165

logPacket = false;

12166

12167

                if (DebugPacketLevel <= 100 && (packet.Type == PacketType.ViewerEffect || packet.Type == PacketType.AgentAnimation))

12168

logPacket = false;

12169

12170

if (DebugPacketLevel <= 25 && packet.Type == PacketType.RequestObjectPropertiesFamily)

logPacket = false;

if (logPacket)

m_log.DebugFormat(

"[CLIENT]: PACKET IN from {0} ({1}) in {2} - {3}",

12176

Name, SceneAgent.IsChildAgent ? "child" : "root ", Scene.Name, packet.Type);

12177

}

12178

12179

if (!ProcessPacketMethod(packet))

12180

m_log.WarnFormat(

12181

"[CLIENT]: Unhandled packet {0} from {1} ({2}) in {3}. Ignoring.",

12182

packet.Type, Name, SceneAgent.IsChildAgent ? "child" : "root ", Scene.Name);

12183

}

12184

12185

private static PrimitiveBaseShape GetShapeFromAddPacket(ObjectAddPacket addPacket)

12186

{

12187

PrimitiveBaseShape shape = new PrimitiveBaseShape();

12188

12189

shape.PCode = addPacket.ObjectData.PCode;

12190

shape.State = addPacket.ObjectData.State;

12191

shape.PathBegin = addPacket.ObjectData.PathBegin;

12192

shape.PathEnd = addPacket.ObjectData.PathEnd;

12193

shape.PathScaleX = addPacket.ObjectData.PathScaleX;

12194

shape.PathScaleY = addPacket.ObjectData.PathScaleY;

12195

shape.PathShearX = addPacket.ObjectData.PathShearX;

12196

shape.PathShearY = addPacket.ObjectData.PathShearY;

12197

shape.PathSkew = addPacket.ObjectData.PathSkew;

12198

shape.ProfileBegin = addPacket.ObjectData.ProfileBegin;

12199

shape.ProfileEnd = addPacket.ObjectData.ProfileEnd;

12200

shape.Scale = addPacket.ObjectData.Scale;

12201

shape.PathCurve = addPacket.ObjectData.PathCurve;

12202

shape.ProfileCurve = addPacket.ObjectData.ProfileCurve;

12203

shape.ProfileHollow = addPacket.ObjectData.ProfileHollow;

12204

shape.PathRadiusOffset = addPacket.ObjectData.PathRadiusOffset;

12205

shape.PathRevolutions = addPacket.ObjectData.PathRevolutions;

12206

shape.PathTaperX = addPacket.ObjectData.PathTaperX;

12207

shape.PathTaperY = addPacket.ObjectData.PathTaperY;

12208

shape.PathTwist = addPacket.ObjectData.PathTwist;

12209

shape.PathTwistBegin = addPacket.ObjectData.PathTwistBegin;

12210

Primitive.TextureEntry ntex = new Primitive.TextureEntry(new UUID("89556747-24cb-43ed-920b-47caed15465f"));

12211

shape.TextureEntry = ntex.GetBytes();

12212

//shape.Textures = ntex;

return shape;

}

public ClientInfo GetClientInfo()

12217

{

12218

ClientInfo info = m_udpClient.GetClientInfo();

12219

12220

info.proxyEP = null;

12221

if (info.agentcircuit == null)

12222

info.agentcircuit = RequestClientInfo();

return info;

}

public void SetClientInfo(ClientInfo info)

12228

{

12229

m_udpClient.SetClientInfo(info);

12230

}

12231

12232

#region Media Parcel Members

12233

12234

public void SendParcelMediaCommand(uint flags, ParcelMediaCommandEnum command, float time)

12235

{

12236

ParcelMediaCommandMessagePacket commandMessagePacket = new ParcelMediaCommandMessagePacket();

12237

commandMessagePacket.CommandBlock.Flags = flags;

12238

commandMessagePacket.CommandBlock.Command = (uint)command;

12239

commandMessagePacket.CommandBlock.Time = time;

12240

12241

OutPacket(commandMessagePacket, ThrottleOutPacketType.Task);

12242

}

12243

12244

public void SendParcelMediaUpdate(string mediaUrl, UUID mediaTextureID,

12245

byte autoScale, string mediaType, string mediaDesc, int mediaWidth, int mediaHeight,

12246

byte mediaLoop)

12247

{

12248

ParcelMediaUpdatePacket updatePacket = new ParcelMediaUpdatePacket();

12249

updatePacket.DataBlock.MediaURL = Util.StringToBytes256(mediaUrl);

12250

updatePacket.DataBlock.MediaID = mediaTextureID;

12251

updatePacket.DataBlock.MediaAutoScale = autoScale;

12252

12253

updatePacket.DataBlockExtended.MediaType = Util.StringToBytes256(mediaType);

12254

updatePacket.DataBlockExtended.MediaDesc = Util.StringToBytes256(mediaDesc);

12255

updatePacket.DataBlockExtended.MediaWidth = mediaWidth;

12256

updatePacket.DataBlockExtended.MediaHeight = mediaHeight;

12257

updatePacket.DataBlockExtended.MediaLoop = mediaLoop;

12258

12259

OutPacket(updatePacket, ThrottleOutPacketType.Task);

}

#endregion

#region Camera

public void SendSetFollowCamProperties(UUID objectID, SortedDictionary<int, float> parameters)

12267

{

12268

            SetFollowCamPropertiesPacket packet = (SetFollowCamPropertiesPacket)PacketPool.Instance.GetPacket(PacketType.SetFollowCamProperties);

12269

packet.ObjectData.ObjectID = objectID;

12270

            SetFollowCamPropertiesPacket.CameraPropertyBlock[] camPropBlock = new SetFollowCamPropertiesPacket.CameraPropertyBlock[parameters.Count];

12271

uint idx = 0;

12272

foreach (KeyValuePair<int, float> pair in parameters)

12273

{

12274

                SetFollowCamPropertiesPacket.CameraPropertyBlock block = new SetFollowCamPropertiesPacket.CameraPropertyBlock();

12275

block.Type = pair.Key;

12276

block.Value = pair.Value;

12277

12278

camPropBlock[idx++] = block;

12279

}

12280

packet.CameraProperty = camPropBlock;

12281

OutPacket(packet, ThrottleOutPacketType.Task);

12282

}

12283

12284

public void SendClearFollowCamProperties(UUID objectID)

12285

{

12286

            ClearFollowCamPropertiesPacket packet = (ClearFollowCamPropertiesPacket)PacketPool.Instance.GetPacket(PacketType.ClearFollowCamProperties);

12287

packet.ObjectData.ObjectID = objectID;

12288

OutPacket(packet, ThrottleOutPacketType.Task);

}

#endregion

public void SetClientOption(string option, string value)

{

switch (option)

{

default:

break;

}

}

public string GetClientOption(string option)

{

switch (option)

{

default:

break;

}

return string.Empty;

12310

}

12311

12312

#region IClientCore

12313

12314

private readonly Dictionary<Type, object> m_clientInterfaces = new Dictionary<Type, object>();

12315

12316

/// <summary>

12317

/// Register an interface on this client, should only be called in the constructor.

12318

/// </summary>

12319

/// <typeparam name="T"></typeparam>

12320

/// <param name="iface"></param>

12321

protected void RegisterInterface<T>(T iface)

12322

{

12323

lock (m_clientInterfaces)

12324

{

12325

if (!m_clientInterfaces.ContainsKey(typeof(T)))

12326

{

12327

m_clientInterfaces.Add(typeof(T), iface);

}

}

}

public bool TryGet<T>(out T iface)

12333

{

12334

if (m_clientInterfaces.ContainsKey(typeof(T)))

12335

{

12336

iface = (T)m_clientInterfaces[typeof(T)];

12337

return true;

12338

}

12339

iface = default(T);

return false;

}

public T Get<T>()

{

return (T)m_clientInterfaces[typeof(T)];

12346

}

12347

12348

public void Disconnect(string reason)

12349

{

12350

Kick(reason);

12351

Thread.Sleep(1000);

Disconnect();

}

public void Disconnect()

{

Close();

}

#endregion

public void RefreshGroupMembership()

12363

{

12364

if (m_GroupsModule != null)

12365

{

12366

GroupMembershipData[] GroupMembership =

12367

m_GroupsModule.GetMembershipData(AgentId);

12368

12369

m_groupPowers.Clear();

12370

12371

if (GroupMembership != null)

12372

{

12373

for (int i = 0; i < GroupMembership.Length; i++)

12374

{

12375

m_groupPowers[GroupMembership[i].GroupID] = GroupMembership[i].GroupPowers;

}

}

}

}

public string Report()

12382

{

12383

return m_udpClient.GetStats();

12384

}

12385

12386

public string XReport(string uptime, string version)

12387

{

12388

return String.Empty;

12389

}

12390

12391

public OSDMap OReport(string uptime, string version)

12392

{

12393

return new OSDMap();

}

/// <summary>

/// Make an asset request to the asset service in response to a client request.

12398

/// </summary>

12399

/// <param name="transferRequest"></param>

12400

/// <param name="taskID"></param>

12401

protected void MakeAssetRequest(TransferRequestPacket transferRequest, UUID taskID)

12402

{

12403

UUID requestID = UUID.Zero;

12404

int sourceType = transferRequest.TransferInfo.SourceType;

12405

12406

if (sourceType == (int)SourceType.Asset)

12407

{

12408

requestID = new UUID(transferRequest.TransferInfo.Params, 0);

12409

}

12410

else if (sourceType == (int)SourceType.SimInventoryItem)

12411

{

12412

requestID = new UUID(transferRequest.TransferInfo.Params, 80);

12413

}

12414

else if (sourceType == (int)SourceType.SimEstate)

12415

{

12416

requestID = taskID;

12417

}

12418

12419

// m_log.DebugFormat(

12420

// "[LLCLIENTVIEW]: Received transfer request for {0} in {1} type {2} by {3}",

12421

// requestID, taskID, (SourceType)sourceType, Name);

12422

12423

m_assetService.Get(requestID.ToString(), transferRequest, AssetReceived);

}

/// <summary>

/// When we get a reply back from the asset service in response to a client request, send back the data.

12428

/// </summary>

12429

/// <param name="id"></param>

12430

/// <param name="sender"></param>

12431

/// <param name="asset"></param>

12432

protected void AssetReceived(string id, Object sender, AssetBase asset)

12433

{

12434

TransferRequestPacket transferRequest = (TransferRequestPacket)sender;

12435

12436

UUID requestID = UUID.Zero;

12437

byte source = (byte)SourceType.Asset;

12438

12439

AssetRequestToClient req = new AssetRequestToClient();

if (asset == null)

{

req.AssetInf = null;

12444

req.AssetRequestSource = source;

12445

req.IsTextureRequest = false;

12446

req.NumPackets = 0;

12447

req.Params = transferRequest.TransferInfo.Params;

12448

req.RequestAssetID = requestID;

12449

req.TransferRequestID = transferRequest.TransferInfo.TransferID;

12450

12451

SendAssetNotFound(req);

return;

}

if (transferRequest.TransferInfo.SourceType == (int)SourceType.Asset)

12456

{

12457

requestID = new UUID(transferRequest.TransferInfo.Params, 0);

12458

}

12459

else if (transferRequest.TransferInfo.SourceType == (int)SourceType.SimInventoryItem)

12460

{

12461

requestID = new UUID(transferRequest.TransferInfo.Params, 80);

12462

source = (byte)SourceType.SimInventoryItem;

12463

//m_log.Debug("asset request " + requestID);

12464

}

12465

12466

// Scripts cannot be retrieved by direct request

12467

if (transferRequest.TransferInfo.SourceType == (int)SourceType.Asset && asset.Type == 10)

12468

return;

12469

12470

// The asset is known to exist and is in our cache, so add it to the AssetRequests list

12471

req.AssetInf = asset;

12472

req.AssetRequestSource = source;

12473

req.IsTextureRequest = false;

12474

req.NumPackets = CalculateNumPackets(asset.Data);

12475

req.Params = transferRequest.TransferInfo.Params;

12476

req.RequestAssetID = requestID;

12477

req.TransferRequestID = transferRequest.TransferInfo.TransferID;

SendAsset(req);

}

/// <summary>

/// Calculate the number of packets required to send the asset to the client.

12484

/// </summary>

12485

/// <param name="data"></param>

12486

/// <returns></returns>

12487

private static int CalculateNumPackets(byte[] data)

12488

{

12489

const uint m_maxPacketSize = 600;

12490

int numPackets = 1;

if (data == null)

return 0;

if (data.LongLength > m_maxPacketSize)

12496

{

12497

// over max number of bytes so split up file

12498

long restData = data.LongLength - m_maxPacketSize;

12499

int restPackets = (int)((restData + m_maxPacketSize - 1) / m_maxPacketSize);

12500

numPackets += restPackets;

}

return numPackets;

}

public void SendRebakeAvatarTextures(UUID textureID)

12507

{

12508

RebakeAvatarTexturesPacket pack =

12509

(RebakeAvatarTexturesPacket)PacketPool.Instance.GetPacket(PacketType.RebakeAvatarTextures);

12510

12511

pack.TextureData = new RebakeAvatarTexturesPacket.TextureDataBlock();

12512

pack.TextureData.TextureID = textureID;

12513

OutPacket(pack, ThrottleOutPacketType.Task);

12514

}

12515

12516

public struct PacketProcessor

12517

{

12518

public PacketMethod method;

public bool Async;

}

public class AsyncPacketProcess

12523

{

12524

public bool result = false;

12525

public readonly LLClientView ClientView = null;

12526

public readonly Packet Pack = null;

12527

public readonly PacketMethod Method = null;

12528

public AsyncPacketProcess(LLClientView pClientview, PacketMethod pMethod, Packet pPack)

12529

{

12530

ClientView = pClientview;

Method = pMethod;

Pack = pPack;

}

}

public static OSD BuildEvent(string eventName, OSD eventBody)

12537

{

12538

OSDMap osdEvent = new OSDMap(2);

12539

osdEvent.Add("message", new OSDString(eventName));

12540

osdEvent.Add("body", eventBody);

return osdEvent;

}

        public void SendAvatarInterestsReply(UUID avatarID, uint wantMask, string wantText, uint skillsMask, string skillsText, string languages)

12546

{

12547

            AvatarInterestsReplyPacket packet = (AvatarInterestsReplyPacket)PacketPool.Instance.GetPacket(PacketType.AvatarInterestsReply);

12548

12549

packet.AgentData = new AvatarInterestsReplyPacket.AgentDataBlock();

12550

packet.AgentData.AgentID = AgentId;

12551

packet.AgentData.AvatarID = avatarID;

12552

12553

packet.PropertiesData = new AvatarInterestsReplyPacket.PropertiesDataBlock();

12554

packet.PropertiesData.WantToMask = wantMask;

12555

packet.PropertiesData.WantToText = Utils.StringToBytes(wantText);

12556

packet.PropertiesData.SkillsMask = skillsMask;

12557

packet.PropertiesData.SkillsText = Utils.StringToBytes(skillsText);

12558

packet.PropertiesData.LanguagesText = Utils.StringToBytes(languages);

12559

OutPacket(packet, ThrottleOutPacketType.Task);

12560

}

12561

12562

public void SendChangeUserRights(UUID agentID, UUID friendID, int rights)

12563

{

12564

            ChangeUserRightsPacket packet = (ChangeUserRightsPacket)PacketPool.Instance.GetPacket(PacketType.ChangeUserRights);

12565

12566

packet.AgentData = new ChangeUserRightsPacket.AgentDataBlock();

12567

packet.AgentData.AgentID = agentID;

12568

12569

packet.Rights = new ChangeUserRightsPacket.RightsBlock[1];

12570

packet.Rights[0] = new ChangeUserRightsPacket.RightsBlock();

12571

packet.Rights[0].AgentRelated = friendID;

12572

packet.Rights[0].RelatedRights = rights;

12573

12574

OutPacket(packet, ThrottleOutPacketType.Task);

12575

}

12576

12577

        public void SendTextBoxRequest(string message, int chatChannel, string objectname, UUID ownerID, string ownerFirstName, string ownerLastName, UUID objectId)

12578

{

12579

ScriptDialogPacket dialog = (ScriptDialogPacket)PacketPool.Instance.GetPacket(PacketType.ScriptDialog);

12580

dialog.Data.ObjectID = objectId;

12581

dialog.Data.ChatChannel = chatChannel;

12582

dialog.Data.ImageID = UUID.Zero;

12583

dialog.Data.ObjectName = Util.StringToBytes256(objectname);

12584

// this is the username of the *owner*

12585

dialog.Data.FirstName = Util.StringToBytes256(ownerFirstName);

12586

dialog.Data.LastName = Util.StringToBytes256(ownerLastName);

12587

dialog.Data.Message = Util.StringToBytes256(message);

12588

12589

ScriptDialogPacket.ButtonsBlock[] buttons = new ScriptDialogPacket.ButtonsBlock[1];

12590

buttons[0] = new ScriptDialogPacket.ButtonsBlock();

12591

buttons[0].ButtonLabel = Util.StringToBytes256("!!llTextBox!!");

12592

dialog.Buttons = buttons;

12593

12594

dialog.OwnerData = new ScriptDialogPacket.OwnerDataBlock[1];

12595

dialog.OwnerData[0] = new ScriptDialogPacket.OwnerDataBlock();

12596

dialog.OwnerData[0].OwnerID = ownerID;

12597

12598

OutPacket(dialog, ThrottleOutPacketType.Task);

12599

}

12600

12601

public void SendAgentTerseUpdate(ISceneEntity p)

12602

{

12603

if (p is ScenePresence)

12604

{

12605

// It turns out to get the agent to stop flying, you have to feed it stop flying velocities

12606

// There's no explicit message to send the client to tell it to stop flying.. it relies on the

12607

// velocity, collision plane and avatar height

12608

12609

// Add 1/6 the avatar's height to it's position so it doesn't shoot into the air

12610

// when the avatar stands up

12611

12612

ImprovedTerseObjectUpdatePacket.ObjectDataBlock block =

12613

CreateImprovedTerseBlock(p, false);

12614

12615

const float TIME_DILATION = 1.0f;

12616

ushort timeDilation = Utils.FloatToUInt16(TIME_DILATION, 0.0f, 1.0f);

12617

12618

ImprovedTerseObjectUpdatePacket packet

12619

= (ImprovedTerseObjectUpdatePacket)PacketPool.Instance.GetPacket(

12620

PacketType.ImprovedTerseObjectUpdate);

12621

12622

packet.RegionData.RegionHandle = m_scene.RegionInfo.RegionHandle;

12623

packet.RegionData.TimeDilation = timeDilation;

12624

packet.ObjectData = new ImprovedTerseObjectUpdatePacket.ObjectDataBlock[1];

12625

12626

packet.ObjectData[0] = block;

12627

12628

OutPacket(packet, ThrottleOutPacketType.Task, true);

12629

}

12630

12631

            //ControllingClient.SendAvatarTerseUpdate(new SendAvatarTerseData(m_rootRegionHandle, (ushort)(m_scene.TimeDilation * ushort.MaxValue), LocalId,

12632

            //        AbsolutePosition, Velocity, Vector3.Zero, m_bodyRot, new Vector4(0,0,1,AbsolutePosition.Z - 0.5f), m_uuid, null, GetUpdatePriority(ControllingClient)));

12633

}

12634

12635

public void SendPlacesReply(UUID queryID, UUID transactionID,

12636

PlacesReplyData[] data)

12637

{

12638

PlacesReplyPacket reply = null;

12639

PlacesReplyPacket.QueryDataBlock[] dataBlocks =

12640

new PlacesReplyPacket.QueryDataBlock[0];

12641

12642

for (int i = 0 ; i < data.Length ; i++)

12643

{

12644

PlacesReplyPacket.QueryDataBlock block =

12645

new PlacesReplyPacket.QueryDataBlock();

12646

12647

block.OwnerID = data[i].OwnerID;

12648

block.Name = Util.StringToBytes256(data[i].Name);

12649

block.Desc = Util.StringToBytes1024(data[i].Desc);

12650

block.ActualArea = data[i].ActualArea;

12651

block.BillableArea = data[i].BillableArea;

12652

block.Flags = data[i].Flags;

12653

block.GlobalX = data[i].GlobalX;

12654

block.GlobalY = data[i].GlobalY;

12655

block.GlobalZ = data[i].GlobalZ;

12656

block.SimName = Util.StringToBytes256(data[i].SimName);

12657

block.SnapshotID = data[i].SnapshotID;

12658

block.Dwell = data[i].Dwell;

12659

block.Price = data[i].Price;

12660

12661

if (reply != null && reply.Length + block.Length > 1400)

12662

{

12663

OutPacket(reply, ThrottleOutPacketType.Task);

12664

12665

reply = null;

12666

dataBlocks = new PlacesReplyPacket.QueryDataBlock[0];

}

if (reply == null)

{

reply = (PlacesReplyPacket)PacketPool.Instance.GetPacket(PacketType.PlacesReply);

12672

reply.AgentData = new PlacesReplyPacket.AgentDataBlock();

12673

reply.AgentData.AgentID = AgentId;

12674

reply.AgentData.QueryID = queryID;

12675

12676

reply.TransactionData = new PlacesReplyPacket.TransactionDataBlock();

12677

reply.TransactionData.TransactionID = transactionID;

12678

12679

reply.QueryData = dataBlocks;

12680

}

12681

12682

Array.Resize(ref dataBlocks, dataBlocks.Length + 1);

12683

dataBlocks[dataBlocks.Length - 1] = block;

12684

reply.QueryData = dataBlocks;

12685

}

12686

if (reply != null)

12687

OutPacket(reply, ThrottleOutPacketType.Task);

12688

}

12689

12690

public void SendRemoveInventoryItems(UUID[] items)

12691

{

12692

IEventQueue eq = Scene.RequestModuleInterface<IEventQueue>();

if (eq == null)

{

m_log.DebugFormat("[LLCLIENT]: Null event queue");

return;

}

OSDMap llsd = new OSDMap(3);

12701

12702

OSDMap AgentDataMap = new OSDMap(1);

12703

AgentDataMap.Add("AgentID", OSD.FromUUID(AgentId));

12704

AgentDataMap.Add("SessionID", OSD.FromUUID(SessionId));

12705

12706

OSDArray AgentData = new OSDArray(1);

12707

AgentData.Add(AgentDataMap);

12708

12709

llsd.Add("AgentData", AgentData);

12710

12711

OSDArray ItemData = new OSDArray();

12712

12713

foreach (UUID item in items)

12714

{

12715

OSDMap ItemDataMap = new OSDMap(2);

12716

ItemDataMap.Add("ItemID", OSD.FromUUID(item));

12717

ItemDataMap.Add("AgentID", OSD.FromUUID(AgentId));

12718

12719

ItemData.Add(ItemDataMap);

12720

}

12721

12722

llsd.Add("InventoryData", ItemData);

12723

12724

eq.Enqueue(BuildEvent("RemoveInventoryItem",

llsd), AgentId);

}

public void SendRemoveInventoryFolders(UUID[] folders)

12729

{

12730

IEventQueue eq = Scene.RequestModuleInterface<IEventQueue>();

if (eq == null)

{

m_log.DebugFormat("[LLCLIENT]: Null event queue");

return;

}

OSDMap llsd = new OSDMap(3);

12739

12740

OSDMap AgentDataMap = new OSDMap(1);

12741

AgentDataMap.Add("AgentID", OSD.FromUUID(AgentId));

12742

AgentDataMap.Add("SessionID", OSD.FromUUID(SessionId));

12743

12744

OSDArray AgentData = new OSDArray(1);

12745

AgentData.Add(AgentDataMap);

12746

12747

llsd.Add("AgentData", AgentData);

12748

12749

OSDArray FolderData = new OSDArray();

12750

12751

foreach (UUID folder in folders)

12752

{

12753

OSDMap FolderDataMap = new OSDMap(2);

12754

FolderDataMap.Add("FolderID", OSD.FromUUID(folder));

12755

FolderDataMap.Add("AgentID", OSD.FromUUID(AgentId));

12756

12757

FolderData.Add(FolderDataMap);

12758

}

12759

12760

llsd.Add("FolderData", FolderData);

12761

12762

eq.Enqueue(BuildEvent("RemoveInventoryFolder",

llsd), AgentId);

}

private byte[] EncodeU32(uint val)

12767

{

12768

byte[] ret = BitConverter.GetBytes(val);

12769

if (BitConverter.IsLittleEndian)

12770

Array.Reverse(ret);

return ret;

}

public void SendBulkUpdateInventory(InventoryFolderBase[] folders, InventoryItemBase[] items)

12775

{

12776

IEventQueue eq = Scene.RequestModuleInterface<IEventQueue>();

if (eq == null)

{

m_log.DebugFormat("[LLCLIENT]: Null event queue");

return;

}

OSDMap llsd = new OSDMap(3);

12785

12786

OSDMap AgentDataMap = new OSDMap(1);

12787

AgentDataMap.Add("AgentID", OSD.FromUUID(AgentId));

12788

AgentDataMap.Add("SessionID", OSD.FromUUID(SessionId));

12789

AgentDataMap.Add("TransactionID", OSD.FromUUID(UUID.Random()));

12790

12791

OSDArray AgentData = new OSDArray(1);

12792

AgentData.Add(AgentDataMap);

12793

12794

llsd.Add("AgentData", AgentData);

12795

12796

OSDArray FolderData = new OSDArray();

12797

12798

foreach (InventoryFolderBase folder in folders)

12799

{

12800

OSDMap FolderDataMap = new OSDMap(5);

12801

FolderDataMap.Add("FolderID", OSD.FromUUID(folder.ID));

12802

FolderDataMap.Add("AgentID", OSD.FromUUID(AgentId));

12803

FolderDataMap.Add("ParentID", OSD.FromUUID(folder.ParentID));

12804

FolderDataMap.Add("Type", OSD.FromInteger(folder.Type));

12805

FolderDataMap.Add("Name", OSD.FromString(folder.Name));

12806

12807

FolderData.Add(FolderDataMap);

12808

}

12809

12810

llsd.Add("FolderData", FolderData);

12811

12812

OSDArray ItemData = new OSDArray();

12813

12814

foreach (InventoryItemBase item in items)

12815

{

12816

OSDMap ItemDataMap = new OSDMap();

12817

12818

ItemDataMap.Add("ItemID", OSD.FromUUID(item.ID));

12819

ItemDataMap.Add("FolderID", OSD.FromUUID(item.Folder));

12820

12821

ItemDataMap.Add("CreatorID", OSD.FromUUID(item.CreatorIdAsUuid));

12822

ItemDataMap.Add("OwnerID", OSD.FromUUID(item.Owner));

12823

ItemDataMap.Add("GroupID", OSD.FromUUID(item.GroupID));

12824

ItemDataMap.Add("BaseMask", OSD.FromBinary(EncodeU32((uint)item.BasePermissions)));

12825

ItemDataMap.Add("OwnerMask", OSD.FromBinary(EncodeU32((uint)item.CurrentPermissions)));

12826

ItemDataMap.Add("GroupMask", OSD.FromBinary(EncodeU32((uint)item.GroupPermissions)));

12827

ItemDataMap.Add("EveryoneMask", OSD.FromBinary(EncodeU32((uint)item.EveryOnePermissions)));

12828

ItemDataMap.Add("NextOwnerMask", OSD.FromBinary(EncodeU32((uint)item.NextPermissions)));

12829

ItemDataMap.Add("GroupOwned", OSD.FromBoolean(item.GroupOwned));

12830

ItemDataMap.Add("AssetID", OSD.FromUUID(item.AssetID));

12831

ItemDataMap.Add("Type", OSD.FromInteger(item.AssetType));

12832

ItemDataMap.Add("InvType", OSD.FromInteger(item.InvType));

12833

ItemDataMap.Add("Flags", OSD.FromBinary(EncodeU32((uint)item.Flags)));

12834

ItemDataMap.Add("SaleType", OSD.FromInteger((byte)item.SaleType));

12835

ItemDataMap.Add("SalePrice", OSD.FromInteger(item.SalePrice));

12836

ItemDataMap.Add("Name", OSD.FromString(item.Name));

12837

ItemDataMap.Add("Description", OSD.FromString(item.Description));

12838

ItemDataMap.Add("CreationDate", OSD.FromInteger(item.CreationDate));

12839

12840

ItemDataMap.Add("CRC", OSD.FromBinary(EncodeU32(

12841

Helpers.InventoryCRC(1000, 0, (sbyte)item.InvType,

12842

(sbyte)item.AssetType, item.AssetID,

12843

item.GroupID, 100,

12844

item.Owner, item.CreatorIdAsUuid,

12845

item.ID, item.Folder,

12846

(uint)PermissionMask.All, 1, (uint)PermissionMask.All, (uint)PermissionMask.All,

12847

(uint)PermissionMask.All)

12848

)));

12849

ItemDataMap.Add("CallbackID", 0);

12850

12851

ItemData.Add(ItemDataMap);

12852

}

12853

12854

llsd.Add("ItemData", ItemData);

12855

12856

eq.Enqueue(BuildEvent("BulkUpdateInventory",

llsd), AgentId);

}

}

}

clockwerk-opensim-stable – Blame information for rev 1