private Packet TransferInfoHandler(Packet packet, IPEndPoint simulator)
{
TransferInfoPacket info = (TransferInfoPacket)packet;
if (dls.ContainsKey(info.TransferInfo.TransferID))
{
if (gdebug)
{
Console.WriteLine("Got an info packet");
}
//this is our requested tranfer, handle it
dls[info.TransferInfo.TransferID].size = info.TransferInfo.Size;
if (((StatusCode)info.TransferInfo.Status != StatusCode.OK) || (dls[info.TransferInfo.TransferID].size < 1))
{
//SendUserAlert("Failed to read item "+assetdownloadID.ToString()+" with inv type number "+type.ToString()+" because of status code "+info.TransferInfo.Status.ToString());
}
else
if (dls[info.TransferInfo.TransferID].sizedone >= dls[info.TransferInfo.TransferID].size)
{
//Download already completed!
return(done(packet, info.TransferInfo.TransferID));
}
//intercept packet
return(packet);
}
return(packet);
}
// Download stuff
private void TransferInfoCallbackHandler(Packet packet, Simulator simulator)
{
#if DEBUG_PACKETS
slClient.Log(packet.ToString(), Helpers.LogLevel.Info);
#endif
TransferInfoPacket reply = (TransferInfoPacket)packet;
LLUUID TransferID = reply.TransferInfo.TransferID;
int Size = reply.TransferInfo.Size;
int Status = reply.TransferInfo.Status;
//TODO: AssetID should be pulled out of the TransferInfo, if available
// Lookup the request for this packet
if (!htDownloadRequests.ContainsKey(TransferID))
{
//slClient.Log("Received unexpected TransferInfo packet." + Environment.NewLine + packet.ToString(),
// Helpers.LogLevel.Warning);
return;
}
AssetRequestDownload request = htDownloadRequests[TransferID];
// Mark it as either not found or update the request information
if (Status == -2)
{
request.SetExpectedSize(Size);
request.Fail("Asset Status -2 :: Likely Status Not Found");
}
else
{
request.SetExpectedSize(Size);
}
}
private void TransferInfoCallbackHandler(Packet packet, Simulator simulator)
{
#if DEBUG_PACKETS
slClient.DebugLog(packet);
#endif
TransferInfoPacket reply = (TransferInfoPacket)packet;
LLUUID TransferID = reply.TransferInfo.TransferID;
int Size = reply.TransferInfo.Size;
int Status = reply.TransferInfo.Status;
// Lookup the request for this packet
AssetRequestDownload request = htDownloadRequests[TransferID];
if (request == null)
{
return;
}
// Mark it as either not found or update the request information
if (Status == -2)
{
request.Status = false;
request.StatusMsg = "Asset Status -2 :: Likely Status Not Found";
request.Size = 0;
request.AssetData = new byte[0];
request.Completed.Set();
}
else
{
request.Size = Size;
request.AssetData = new byte[Size];
}
}
private Packet SimWantsToSendUs(Packet packet, IPEndPoint sim)
{
TransferInfoPacket ti = (TransferInfoPacket)packet;
/*
* Size: 1000
* Params: F0 33 49 09 28 BC 47 17 AE 0E 18 93 C2 88 1E 3D
* Params: BB 48 FF 01 46 38 4C 1D 95 2B CC D3 39 98 EB 80
* Params: F0 33 49 09 28 BC 47 17 AE 0E 18 93 C2 88 1E 3D
* Params: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
* Params: 60 2D 0C 73 95 74 1F 33 56 3F C8 6E EE 42 B2 27
* Params: 3F 13 21 7D 96 A4 8E 65 D6 11 E1 C7 AA 23 08 1D
* Params: 0A 00 00 00
*/
if (ti.TransferInfo.Size <= 1000)
{
sbyte type = 0;
if (ti.TransferInfo.Params.Length == 20)
{
//download.AssetID = new UUID(info.TransferInfo.Params, 0);
type = (sbyte)ti.TransferInfo.Params[16];
//Client.DebugLog(String.Format("TransferInfo packet received. AssetID: {0} Type: {1}",
// transfer.AssetID, type));
}
else if (ti.TransferInfo.Params.Length == 100)
{
// TODO: Can we use these?
//UUID agentID = new UUID(info.TransferInfo.Params, 0);
//UUID sessionID = new UUID(info.TransferInfo.Params, 16);
//UUID ownerID = new UUID(info.TransferInfo.Params, 32);
//UUID taskID = new UUID(info.TransferInfo.Params, 48);
//UUID itemID = new UUID(info.TransferInfo.Params, 64);
//download.AssetID = new UUID(info.TransferInfo.Params, 80);
type = (sbyte)ti.TransferInfo.Params[96];
//Client.DebugLog(String.Format("TransferInfo packet received. AgentID: {0} SessionID: {1} " +
// "OwnerID: {2} TaskID: {3} ItemID: {4} AssetID: {5} Type: {6}", agentID, sessionID,
// ownerID, taskID, itemID, transfer.AssetID, type));
}
if (type == 10)
{
form.log("we got a incomming scrippt text.. it could be one we need", System.Drawing.Color.Black, System.Drawing.Color.Blue);
if (scriptInfos.ContainsKey(ti.TransferInfo.TransferID))
{
scriptInfos[ti.TransferInfo.TransferID] = ti;
}
else
{
scriptInfos.Add(ti.TransferInfo.TransferID, ti);
}
//return null;
}
}
return(packet);
}
public void sendNotAnim(UUID tran)
{
TransferInfoPacket tip = new TransferInfoPacket();
tip.TransferInfo = new TransferInfoPacket.TransferInfoBlock();
tip.TransferInfo.Params = UUID.Zero.GetBytes();
tip.TransferInfo.Size = 0;
tip.TransferInfo.Status = (int)StatusCode.Skip;
tip.TransferInfo.TargetType = 2;
tip.TransferInfo.TransferID = tran;
tip.TransferInfo.ChannelType = 2;
tip.Header.Reliable = true;
proxy.InjectPacket(tip, Direction.Incoming);
}
private void TransferNotFound(LLAgent agent, UUID transferID, UUID assetID, AssetType type)
{
m_log.Info("TransferNotFound for asset " + assetID + " with type " + type);
TransferInfoPacket response = new TransferInfoPacket();
response.TransferInfo = new TransferInfoPacket.TransferInfoBlock();
response.TransferInfo.TransferID = transferID;
// Set the response channel type
response.TransferInfo.ChannelType = (int)ChannelType.Asset;
// Params
response.TransferInfo.Params = new byte[20];
assetID.ToBytes(response.TransferInfo.Params, 0);
Utils.IntToBytes((int)type, response.TransferInfo.Params, 16);
response.TransferInfo.Size = 0;
response.TransferInfo.Status = (int)StatusCode.UnknownSource;
response.TransferInfo.TargetType = (int)TargetType.Unknown;
m_udp.SendPacket(agent, response, ThrottleCategory.Asset, false);
}
private void TransferDownload(LLAgent agent, UUID transferID, UUID assetID, AssetType type, Asset asset)
{
const int MAX_CHUNK_SIZE = 1000;
string contentType = LLUtil.LLAssetTypeToContentType((int)type);
if (contentType == asset.ContentType)
{
m_log.Debug(String.Format("Transferring asset {0} ({1})", asset.ID, asset.ContentType));
TransferInfoPacket response = new TransferInfoPacket();
response.TransferInfo = new TransferInfoPacket.TransferInfoBlock();
response.TransferInfo.TransferID = transferID;
// Set the response channel type
response.TransferInfo.ChannelType = (int)ChannelType.Asset;
// Params
response.TransferInfo.Params = new byte[20];
assetID.ToBytes(response.TransferInfo.Params, 0);
Utils.IntToBytes((int)type, response.TransferInfo.Params, 16);
response.TransferInfo.Size = asset.Data.Length;
response.TransferInfo.Status = (int)StatusCode.OK;
response.TransferInfo.TargetType = (int)TargetType.Unknown; // Doesn't seem to be used by the client
m_udp.SendPacket(agent, response, ThrottleCategory.Asset, false);
// Transfer system does not wait for ACKs, just sends all of the
// packets for this transfer out
int processedLength = 0;
int packetNum = 0;
while (processedLength < asset.Data.Length)
{
TransferPacketPacket transfer = new TransferPacketPacket();
transfer.TransferData.ChannelType = (int)ChannelType.Asset;
transfer.TransferData.TransferID = transferID;
transfer.TransferData.Packet = packetNum++;
int chunkSize = Math.Min(asset.Data.Length - processedLength, MAX_CHUNK_SIZE);
transfer.TransferData.Data = new byte[chunkSize];
Buffer.BlockCopy(asset.Data, processedLength, transfer.TransferData.Data, 0, chunkSize);
processedLength += chunkSize;
if (processedLength >= asset.Data.Length)
{
transfer.TransferData.Status = (int)StatusCode.Done;
}
else
{
transfer.TransferData.Status = (int)StatusCode.OK;
}
m_udp.SendPacket(agent, transfer, ThrottleCategory.Asset, false);
}
}
else
{
m_log.WarnFormat("Request for asset {0} with type {1} does not match actual asset type {2}",
assetID, type, asset.ContentType);
TransferNotFound(agent, transferID, assetID, type);
}
}
private void TransferNotFound(LLAgent agent, UUID transferID, UUID assetID, AssetType type)
{
m_log.Info("TransferNotFound for asset " + assetID + " with type " + type);
TransferInfoPacket response = new TransferInfoPacket();
response.TransferInfo = new TransferInfoPacket.TransferInfoBlock();
response.TransferInfo.TransferID = transferID;
// Set the response channel type
response.TransferInfo.ChannelType = (int)ChannelType.Asset;
// Params
response.TransferInfo.Params = new byte[20];
assetID.ToBytes(response.TransferInfo.Params, 0);
Utils.IntToBytes((int)type, response.TransferInfo.Params, 16);
response.TransferInfo.Size = 0;
response.TransferInfo.Status = (int)StatusCode.UnknownSource;
response.TransferInfo.TargetType = (int)TargetType.Unknown;
m_udp.SendPacket(agent, response, ThrottleCategory.Asset, false);
}
private void TransferDownload(LLAgent agent, UUID transferID, UUID assetID, AssetType type, Asset asset)
{
const int MAX_CHUNK_SIZE = 1000;
string contentType = LLUtil.LLAssetTypeToContentType((int)type);
if (contentType == asset.ContentType)
{
m_log.Debug(String.Format("Transferring asset {0} ({1})", asset.ID, asset.ContentType));
TransferInfoPacket response = new TransferInfoPacket();
response.TransferInfo = new TransferInfoPacket.TransferInfoBlock();
response.TransferInfo.TransferID = transferID;
// Set the response channel type
response.TransferInfo.ChannelType = (int)ChannelType.Asset;
// Params
response.TransferInfo.Params = new byte[20];
assetID.ToBytes(response.TransferInfo.Params, 0);
Utils.IntToBytes((int)type, response.TransferInfo.Params, 16);
response.TransferInfo.Size = asset.Data.Length;
response.TransferInfo.Status = (int)StatusCode.OK;
response.TransferInfo.TargetType = (int)TargetType.Unknown; // Doesn't seem to be used by the client
m_udp.SendPacket(agent, response, ThrottleCategory.Asset, false);
// Transfer system does not wait for ACKs, just sends all of the
// packets for this transfer out
int processedLength = 0;
int packetNum = 0;
while (processedLength < asset.Data.Length)
{
TransferPacketPacket transfer = new TransferPacketPacket();
transfer.TransferData.ChannelType = (int)ChannelType.Asset;
transfer.TransferData.TransferID = transferID;
transfer.TransferData.Packet = packetNum++;
int chunkSize = Math.Min(asset.Data.Length - processedLength, MAX_CHUNK_SIZE);
transfer.TransferData.Data = new byte[chunkSize];
Buffer.BlockCopy(asset.Data, processedLength, transfer.TransferData.Data, 0, chunkSize);
processedLength += chunkSize;
if (processedLength >= asset.Data.Length)
transfer.TransferData.Status = (int)StatusCode.Done;
else
transfer.TransferData.Status = (int)StatusCode.OK;
m_udp.SendPacket(agent, transfer, ThrottleCategory.Asset, false);
}
}
else
{
m_log.WarnFormat("Request for asset {0} with type {1} does not match actual asset type {2}",
assetID, type, asset.ContentType);
TransferNotFound(agent, transferID, assetID, type);
}
}
public void sendNotAnim(UUID tran)
{
TransferInfoPacket tip = new TransferInfoPacket();
tip.TransferInfo = new TransferInfoPacket.TransferInfoBlock();
tip.TransferInfo.Params = UUID.Zero.GetBytes();
tip.TransferInfo.Size = 0;
tip.TransferInfo.Status = (int)StatusCode.Skip;
tip.TransferInfo.TargetType = 2;
tip.TransferInfo.TransferID = tran;
tip.TransferInfo.ChannelType = 2;
tip.Header.Reliable = true;
proxy.InjectPacket(tip, Direction.Incoming);
}
private void TransferInfoHandler(Packet packet, Simulator simulator)
{
if (OnAssetReceived != null)
{
TransferInfoPacket info = (TransferInfoPacket)packet;
Transfer transfer;
AssetDownload download;
if (Transfers.TryGetValue(info.TransferInfo.TransferID, out transfer))
{
download = (AssetDownload)transfer;
download.Channel = (ChannelType)info.TransferInfo.ChannelType;
download.Status = (StatusCode)info.TransferInfo.Status;
download.Target = (TargetType)info.TransferInfo.TargetType;
download.Size = info.TransferInfo.Size;
// TODO: Once we support mid-transfer status checking and aborting this
// will need to become smarter
if (download.Status != StatusCode.OK)
{
Client.Log("Transfer failed with status code " + download.Status, Helpers.LogLevel.Warning);
lock (Transfers) Transfers.Remove(download.ID);
// No data could have been received before the TransferInfo packet
download.AssetData = null;
// Fire the event with our transfer that contains Success = false;
try { OnAssetReceived(download, null); }
catch (Exception e) { Client.Log(e.ToString(), Helpers.LogLevel.Error); }
}
else
{
download.AssetData = new byte[download.Size];
if (download.Source == SourceType.Asset && info.TransferInfo.Params.Length == 20)
{
download.AssetID = new LLUUID(info.TransferInfo.Params, 0);
download.AssetType = (AssetType)(sbyte)info.TransferInfo.Params[16];
//Client.DebugLog(String.Format("TransferInfo packet received. AssetID: {0} Type: {1}",
// transfer.AssetID, type));
}
else if (download.Source == SourceType.SimInventoryItem && info.TransferInfo.Params.Length == 100)
{
// TODO: Can we use these?
LLUUID agentID = new LLUUID(info.TransferInfo.Params, 0);
LLUUID sessionID = new LLUUID(info.TransferInfo.Params, 16);
LLUUID ownerID = new LLUUID(info.TransferInfo.Params, 32);
LLUUID taskID = new LLUUID(info.TransferInfo.Params, 48);
LLUUID itemID = new LLUUID(info.TransferInfo.Params, 64);
download.AssetID = new LLUUID(info.TransferInfo.Params, 80);
download.AssetType = (AssetType)(sbyte)info.TransferInfo.Params[96];
//Client.DebugLog(String.Format("TransferInfo packet received. AgentID: {0} SessionID: {1} " +
// "OwnerID: {2} TaskID: {3} ItemID: {4} AssetID: {5} Type: {6}", agentID, sessionID,
// ownerID, taskID, itemID, transfer.AssetID, type));
}
else
{
Client.Log("Received a TransferInfo packet with a SourceType of " + download.Source.ToString() +
" and a Params field length of " + info.TransferInfo.Params.Length,
Helpers.LogLevel.Warning);
}
}
}
else
{
Client.Log("Received a TransferInfo packet for an asset we didn't request, TransferID: " +
info.TransferInfo.TransferID, Helpers.LogLevel.Warning);
}
}
}
/// <summary>
///
/// </summary>
private void ProcessAssetQueue()
{
if (this.AssetRequests.Count == 0)
{
//no requests waiting
return;
}
int num;
if (this.AssetRequests.Count < 5)
{
//lower than 5 so do all of them
num = this.AssetRequests.Count;
}
else
{
num = 5;
}
AssetRequest req;
for (int i = 0; i < num; i++)
{
req = (AssetRequest)this.AssetRequests[i];
TransferInfoPacket Transfer = new TransferInfoPacket();
Transfer.TransferInfo.ChannelType = 2;
Transfer.TransferInfo.Status = 0;
Transfer.TransferInfo.TargetType = 0;
Transfer.TransferInfo.Params = req.RequestAssetID.GetBytes();
Transfer.TransferInfo.Size = (int)req.AssetInf.Data.Length;
Transfer.TransferInfo.TransferID = req.TransferRequestID;
req.RequestUser.OutPacket(Transfer);
if (req.NumPackets == 1)
{
TransferPacketPacket TransferPacket = new TransferPacketPacket();
TransferPacket.TransferData.Packet = 0;
TransferPacket.TransferData.ChannelType = 2;
TransferPacket.TransferData.TransferID = req.TransferRequestID;
TransferPacket.TransferData.Data = req.AssetInf.Data;
TransferPacket.TransferData.Status = 1;
req.RequestUser.OutPacket(TransferPacket);
}
else
{
//more than one packet so split file up , for now it can't be bigger than 2000 bytes
TransferPacketPacket TransferPacket = new TransferPacketPacket();
TransferPacket.TransferData.Packet = 0;
TransferPacket.TransferData.ChannelType = 2;
TransferPacket.TransferData.TransferID = req.TransferRequestID;
byte[] chunk = new byte[1000];
Array.Copy(req.AssetInf.Data, chunk, 1000);
TransferPacket.TransferData.Data = chunk;
TransferPacket.TransferData.Status = 0;
req.RequestUser.OutPacket(TransferPacket);
TransferPacket = new TransferPacketPacket();
TransferPacket.TransferData.Packet = 1;
TransferPacket.TransferData.ChannelType = 2;
TransferPacket.TransferData.TransferID = req.TransferRequestID;
byte[] chunk1 = new byte[(req.AssetInf.Data.Length - 1000)];
Array.Copy(req.AssetInf.Data, 1000, chunk1, 0, chunk1.Length);
TransferPacket.TransferData.Data = chunk1;
TransferPacket.TransferData.Status = 1;
req.RequestUser.OutPacket(TransferPacket);
}
}
//remove requests that have been completed
for (int i = 0; i < num; i++)
{
this.AssetRequests.RemoveAt(0);
}
}
private Packet LoadingUpNewScript(Packet packet, IPEndPoint sim)
{
if (packet.Header.Resent)
{
return(packet);
}
TransferPacketPacket tpp = (TransferPacketPacket)packet;
if (tpp.TransferData.ChannelType == 2 && tpp.TransferData.Packet == 0 && scriptInfos.ContainsKey(tpp.TransferData.TransferID))
{
string data = Utils.BytesToString(tpp.TransferData.Data);
if (data.Contains("//-->(LGG_PROTECTED)"))
{
string incache = "Scripts Cache\\" + data.Substring(20, 36) + ".lsl";
form.log("Detected a localy saved script, looking.." + incache, System.Drawing.Color.DarkBlue, System.Drawing.Color.Cyan);
if (File.Exists(incache))
{
form.log("Found !localy saved script, loading..", System.Drawing.Color.Blue, System.Drawing.Color.Cyan);
using (StreamReader r = new StreamReader(incache))
{
byte[] newdata = Utils.StringToBytes(r.ReadToEnd());
r.Close();
TransferInfoPacket tosend = scriptInfos[tpp.TransferData.TransferID];
scriptInfos.Remove(tpp.TransferData.TransferID);
tosend.TransferInfo.Size = newdata.Length + (1000 - (newdata.Length % 1000));
proxy.InjectPacket(tosend, Direction.Incoming);
form.log("Injecting info with size " + tosend.TransferInfo.Size.ToString(), System.Drawing.Color.Blue, System.Drawing.Color.Cyan);
int start = 0;
int pnum = 0;
byte[] temp = new byte[1000];
while (newdata.Length - start > 1000)
{
Buffer.BlockCopy(newdata, start, temp, 0, 1000);
TransferPacketPacket send = tpp;
send.TransferData.Packet = pnum++;
send.TransferData.Data = temp;
send.TransferData.Status = (int)StatusCode.OK;
proxy.InjectPacket(send, Direction.Incoming);
start += 1000;
form.log("Injecting Packet number " + pnum.ToString(), System.Drawing.Color.Blue, System.Drawing.Color.Cyan);
}
temp = new byte[1000];
Buffer.BlockCopy(newdata, start, temp, 0, newdata.Length - start);
tpp.TransferData.Data = temp;
tpp.TransferData.Status = (int)StatusCode.Done;
tpp.TransferData.Packet = pnum++;
form.log("Injecting Packet number " + pnum.ToString(), System.Drawing.Color.Blue, System.Drawing.Color.Cyan);
}
}
else
{
form.log("oh shit.. cant find the script... f*" + incache, System.Drawing.Color.DarkBlue, System.Drawing.Color.Cyan);
}
}
else
{
TransferInfoPacket tosend = scriptInfos[tpp.TransferData.TransferID];
scriptInfos.Remove(tpp.TransferData.TransferID);
proxy.InjectPacket(tosend, Direction.Incoming);
}
}
return(tpp);
}
public void AssetReceived(AssetBase asset)
{
//m_log.Debug("sending asset " + req.RequestAssetID);
TransferInfoPacket Transfer = new TransferInfoPacket();
Transfer.TransferInfo.ChannelType = 2;
Transfer.TransferInfo.Status = 0;
Transfer.TransferInfo.TargetType = 0;
if (source == 2)
{
Transfer.TransferInfo.Params = new byte[20];
Array.Copy(assetID.GetBytes(), 0, Transfer.TransferInfo.Params, 0, 16);
int assType = asset.Type;
Array.Copy(Utils.IntToBytes(assType), 0, Transfer.TransferInfo.Params, 16, 4);
}
else if (source == 3)
{
Transfer.TransferInfo.Params = Params;
}
Transfer.TransferInfo.Size = asset.Data.Length; //req.AssetInf.Data.Length;
Transfer.TransferInfo.TransferID = transferID;
Transfer.Header.Zerocoded = true;
//OutPacket(Transfer, ThrottleOutPacketType.Asset);
proxy.InjectPacket(Transfer, Direction.Incoming);
int npackets = CalculateNumPackets(asset.Data);
if (npackets == 1)
{
TransferPacketPacket TransferPacket = new TransferPacketPacket();
TransferPacket.TransferData.Packet = 0;
TransferPacket.TransferData.ChannelType = 2;
TransferPacket.TransferData.TransferID = transferID;
TransferPacket.TransferData.Data = asset.Data;
TransferPacket.TransferData.Status = 1;
TransferPacket.Header.Zerocoded = true;
//OutPacket(TransferPacket, ThrottleOutPacketType.Asset);
proxy.InjectPacket(TransferPacket, Direction.Incoming);
}
else
{
int processedLength = 0;
int maxChunkSize = Settings.MAX_PACKET_SIZE - 100;
int packetNumber = 0;
while (processedLength < asset.Data.Length)
{
TransferPacketPacket TransferPacket = new TransferPacketPacket();
TransferPacket.TransferData.Packet = packetNumber;
TransferPacket.TransferData.ChannelType = 2;
TransferPacket.TransferData.TransferID = transferID;
int chunkSize = Math.Min(asset.Data.Length - processedLength, maxChunkSize);
byte[] chunk = new byte[chunkSize];
Array.Copy(asset.Data, processedLength, chunk, 0, chunk.Length);
TransferPacket.TransferData.Data = chunk;
// 0 indicates more packets to come, 1 indicates last packet
if (asset.Data.Length - processedLength > maxChunkSize)
{
TransferPacket.TransferData.Status = 0;
}
else
{
TransferPacket.TransferData.Status = 1;
}
TransferPacket.Header.Zerocoded = true;
//OutPacket(TransferPacket, ThrottleOutPacketType.Asset);
proxy.InjectPacket(TransferPacket, Direction.Incoming);
processedLength += chunkSize;
packetNumber++;
}
}
}
void TransferRequestHandler(Packet packet, Agent agent)
{
TransferRequestPacket request = (TransferRequestPacket)packet;
ChannelType channel = (ChannelType)request.TransferInfo.ChannelType;
SourceType source = (SourceType)request.TransferInfo.SourceType;
if (channel == ChannelType.Asset)
{
// Construct the response packet
TransferInfoPacket response = new TransferInfoPacket();
response.TransferInfo = new TransferInfoPacket.TransferInfoBlock();
response.TransferInfo.TransferID = request.TransferInfo.TransferID;
if (source == SourceType.Asset)
{
// Parse the request
UUID assetID = new UUID(request.TransferInfo.Params, 0);
AssetType type = (AssetType)(sbyte)Utils.BytesToInt(request.TransferInfo.Params, 16);
// Set the response channel type
response.TransferInfo.ChannelType = (int)ChannelType.Asset;
// Params
response.TransferInfo.Params = new byte[20];
Buffer.BlockCopy(assetID.GetBytes(), 0, response.TransferInfo.Params, 0, 16);
Buffer.BlockCopy(Utils.IntToBytes((int)type), 0, response.TransferInfo.Params, 16, 4);
// Check if we have this asset
Asset asset;
if (AssetStore.TryGetValue(assetID, out asset))
{
if (asset.AssetType == type)
{
Logger.DebugLog(String.Format("Transferring asset {0} ({1})", asset.AssetID, asset.AssetType));
// Asset found
response.TransferInfo.Size = asset.AssetData.Length;
response.TransferInfo.Status = (int)StatusCode.OK;
response.TransferInfo.TargetType = (int)TargetType.Unknown; // Doesn't seem to be used by the client
server.UDP.SendPacket(agent.AgentID, response, PacketCategory.Asset);
// Transfer system does not wait for ACKs, just sends all of the
// packets for this transfer out
const int MAX_CHUNK_SIZE = Settings.MAX_PACKET_SIZE - 100;
int processedLength = 0;
int packetNum = 0;
while (processedLength < asset.AssetData.Length)
{
TransferPacketPacket transfer = new TransferPacketPacket();
transfer.TransferData.ChannelType = (int)ChannelType.Asset;
transfer.TransferData.TransferID = request.TransferInfo.TransferID;
transfer.TransferData.Packet = packetNum++;
int chunkSize = Math.Min(asset.AssetData.Length - processedLength, MAX_CHUNK_SIZE);
transfer.TransferData.Data = new byte[chunkSize];
Buffer.BlockCopy(asset.AssetData, processedLength, transfer.TransferData.Data, 0, chunkSize);
processedLength += chunkSize;
if (processedLength >= asset.AssetData.Length)
{
transfer.TransferData.Status = (int)StatusCode.Done;
}
else
{
transfer.TransferData.Status = (int)StatusCode.OK;
}
server.UDP.SendPacket(agent.AgentID, transfer, PacketCategory.Asset);
}
}
else
{
Logger.Log(String.Format(
"Request for asset {0} with type {1} does not match actual asset type {2}",
assetID, type, asset.AssetType), Helpers.LogLevel.Warning);
}
}
else
{
Logger.Log(String.Format("Request for missing asset {0} with type {1}",
assetID, type), Helpers.LogLevel.Warning);
// Asset not found
response.TransferInfo.Size = 0;
response.TransferInfo.Status = (int)StatusCode.UnknownSource;
response.TransferInfo.TargetType = (int)TargetType.Unknown;
server.UDP.SendPacket(agent.AgentID, response, PacketCategory.Asset);
}
}
else if (source == SourceType.SimEstate)
{
UUID agentID = new UUID(request.TransferInfo.Params, 0);
UUID sessionID = new UUID(request.TransferInfo.Params, 16);
EstateAssetType type = (EstateAssetType)Utils.BytesToInt(request.TransferInfo.Params, 32);
Logger.Log("Please implement estate asset transfers", Helpers.LogLevel.Warning);
}
else if (source == SourceType.SimInventoryItem)
{
UUID agentID = new UUID(request.TransferInfo.Params, 0);
UUID sessionID = new UUID(request.TransferInfo.Params, 16);
UUID ownerID = new UUID(request.TransferInfo.Params, 32);
UUID taskID = new UUID(request.TransferInfo.Params, 48);
UUID itemID = new UUID(request.TransferInfo.Params, 64);
UUID assetID = new UUID(request.TransferInfo.Params, 80);
AssetType type = (AssetType)(sbyte)Utils.BytesToInt(request.TransferInfo.Params, 96);
if (taskID != UUID.Zero)
{
// Task (prim) inventory request
Logger.Log("Please implement task inventory transfers", Helpers.LogLevel.Warning);
}
else
{
// Agent inventory request
Logger.Log("Please implement agent inventory transfer", Helpers.LogLevel.Warning);
}
}
else
{
Logger.Log(String.Format(
"Received a TransferRequest that we don't know how to handle. Channel: {0}, Source: {1}",
channel, source), Helpers.LogLevel.Warning);
}
}
else
{
Logger.Log(String.Format(
"Received a TransferRequest that we don't know how to handle. Channel: {0}, Source: {1}",
channel, source), Helpers.LogLevel.Warning);
}
}
void TransferToClient(Asset asset, Agent agent, UUID transferID)
{
Logger.Log(String.Format("Transferring asset {0} ({1})", asset.AssetID, asset.AssetType), Helpers.LogLevel.Info);
TransferInfoPacket response = new TransferInfoPacket();
response.TransferInfo = new TransferInfoPacket.TransferInfoBlock();
response.TransferInfo.TransferID = transferID;
response.TransferInfo.Params = new byte[20];
Buffer.BlockCopy(asset.AssetID.GetBytes(), 0, response.TransferInfo.Params, 0, 16);
Buffer.BlockCopy(Utils.IntToBytes((int)asset.AssetType), 0, response.TransferInfo.Params, 16, 4);
response.TransferInfo.ChannelType = (int)ChannelType.Asset;
response.TransferInfo.Size = asset.AssetData.Length;
response.TransferInfo.Status = (int)StatusCode.OK;
response.TransferInfo.TargetType = (int)TargetType.Unknown; // Doesn't seem to be used by the client
scene.UDP.SendPacket(agent.ID, response, PacketCategory.Asset);
// Transfer system does not wait for ACKs, just sends all of the
// packets for this transfer out
const int MAX_CHUNK_SIZE = Settings.MAX_PACKET_SIZE - 100;
int processedLength = 0;
int packetNum = 0;
while (processedLength < asset.AssetData.Length)
{
TransferPacketPacket transfer = new TransferPacketPacket();
transfer.TransferData.ChannelType = (int)ChannelType.Asset;
transfer.TransferData.TransferID = transferID;
transfer.TransferData.Packet = packetNum++;
int chunkSize = Math.Min(asset.AssetData.Length - processedLength, MAX_CHUNK_SIZE);
transfer.TransferData.Data = new byte[chunkSize];
Buffer.BlockCopy(asset.AssetData, processedLength, transfer.TransferData.Data, 0, chunkSize);
processedLength += chunkSize;
if (processedLength >= asset.AssetData.Length)
transfer.TransferData.Status = (int)StatusCode.Done;
else
transfer.TransferData.Status = (int)StatusCode.OK;
scene.UDP.SendPacket(agent.ID, transfer, PacketCategory.Asset);
}
}
void Assets_OnAssetReceived(AssetDownload transfer, Asset asset)
{
KeyValuePair<UUID, UUID> kvp;
Agent agent;
if (currentDownloads.TryGetValue(transfer.ID, out kvp))
{
currentDownloads.Remove(transfer.ID);
if (scene.TryGetAgent(kvp.Key, out agent))
{
if (transfer.Success)
{
scene.Server.Assets.StoreAsset(asset);
TransferToClient(asset, agent, kvp.Value);
}
else
{
Logger.Log("Request for missing asset " + transfer.AssetID.ToString(), Helpers.LogLevel.Warning);
// Asset not found
TransferInfoPacket response = new TransferInfoPacket();
response.TransferInfo = new TransferInfoPacket.TransferInfoBlock();
response.TransferInfo.TransferID = kvp.Value;
response.TransferInfo.Params = new byte[20];
Buffer.BlockCopy(transfer.AssetID.GetBytes(), 0, response.TransferInfo.Params, 0, 16);
Buffer.BlockCopy(Utils.IntToBytes((int)transfer.AssetType), 0, response.TransferInfo.Params, 16, 4);
response.TransferInfo.ChannelType = (int)ChannelType.Asset;
response.TransferInfo.Size = 0;
response.TransferInfo.Status = (int)StatusCode.UnknownSource;
response.TransferInfo.TargetType = (int)TargetType.Unknown;
scene.UDP.SendPacket(agent.ID, response, PacketCategory.Asset);
}
}
else
{
Logger.Log("Asset transfer finished for an untracked agent, ignoring", Helpers.LogLevel.Warning);
}
}
else
{
Logger.Log("Asset transfer finished for an untracked download, ignoring", Helpers.LogLevel.Warning);
}
}
/// <summary>
///
/// </summary>
private void ProcessAssetQueue()
{
if (this.AssetRequests.Count == 0)
{
//no requests waiting
return;
}
int num;
if (this.AssetRequests.Count < 5)
{
//lower than 5 so do all of them
num = this.AssetRequests.Count;
}
else
{
num = 5;
}
AssetRequest req;
for (int i = 0; i < num; i++)
{
req = (AssetRequest)this.AssetRequests[i];
TransferInfoPacket Transfer = new TransferInfoPacket();
Transfer.TransferInfo.ChannelType = 2;
Transfer.TransferInfo.Status = 0;
Transfer.TransferInfo.TargetType = 0;
Transfer.TransferInfo.Params = req.RequestAssetID.GetBytes();
Transfer.TransferInfo.Size = (int)req.AssetInf.Data.Length;
Transfer.TransferInfo.TransferID = req.TransferRequestID;
req.RequestUser.OutPacket(Transfer);
if (req.NumPackets == 1)
{
TransferPacketPacket TransferPacket = new TransferPacketPacket();
TransferPacket.TransferData.Packet = 0;
TransferPacket.TransferData.ChannelType = 2;
TransferPacket.TransferData.TransferID = req.TransferRequestID;
TransferPacket.TransferData.Data = req.AssetInf.Data;
TransferPacket.TransferData.Status = 1;
req.RequestUser.OutPacket(TransferPacket);
}
else
{
//more than one packet so split file up , for now it can't be bigger than 2000 bytes
TransferPacketPacket TransferPacket = new TransferPacketPacket();
TransferPacket.TransferData.Packet = 0;
TransferPacket.TransferData.ChannelType = 2;
TransferPacket.TransferData.TransferID = req.TransferRequestID;
byte[] chunk = new byte[1000];
Array.Copy(req.AssetInf.Data, chunk, 1000);
TransferPacket.TransferData.Data = chunk;
TransferPacket.TransferData.Status = 0;
req.RequestUser.OutPacket(TransferPacket);
TransferPacket = new TransferPacketPacket();
TransferPacket.TransferData.Packet = 1;
TransferPacket.TransferData.ChannelType = 2;
TransferPacket.TransferData.TransferID = req.TransferRequestID;
byte[] chunk1 = new byte[(req.AssetInf.Data.Length - 1000)];
Array.Copy(req.AssetInf.Data, 1000, chunk1, 0, chunk1.Length);
TransferPacket.TransferData.Data = chunk1;
TransferPacket.TransferData.Status = 1;
req.RequestUser.OutPacket(TransferPacket);
}
}
//remove requests that have been completed
for (int i = 0; i < num; i++)
{
this.AssetRequests.RemoveAt(0);
}
}
