private void ConfirmXferPacketHandler(Packet packet, LLAgent agent)
{
ConfirmXferPacketPacket confirm = (ConfirmXferPacketPacket)packet;
XferDownload download;
if (currentDownloads.TryGetValue(confirm.XferID.ID, out download))
{
// Send the next packet
SendXferPacketPacket xfer = new SendXferPacketPacket();
xfer.XferID.ID = confirm.XferID.ID;
int bytesRemaining = (int)(download.AssetData.Length - (download.PacketNum * 1000));
if (bytesRemaining > 1000)
{
xfer.DataPacket.Data = new byte[1000];
Buffer.BlockCopy(download.AssetData, (int)download.PacketNum * 1000, xfer.DataPacket.Data, 0, 1000);
xfer.XferID.Packet = download.PacketNum++;
}
else
{
// Last packet
xfer.DataPacket.Data = new byte[bytesRemaining];
Buffer.BlockCopy(download.AssetData, (int)download.PacketNum * 1000, xfer.DataPacket.Data, 0, bytesRemaining);
xfer.XferID.Packet = download.PacketNum | LAST_PACKET_MARKER;
lock (currentDownloads)
currentDownloads.Remove(confirm.XferID.ID);
m_log.Debug("Completing xfer download for: " + download.Filename);
}
m_udp.SendPacket(agent, xfer, ThrottleCategory.Asset, false);
}
}
/*private Packet ReplyTask(Packet packet, IPEndPoint sim)
* {
* Thread mythread = new Thread(new ThreadStart(delegate
* {
* ManualResetEvent finishevent = new ManualResetEvent(false);
* string filename = Utils.BytesToString(((ReplyTaskInventoryPacket)packet).InventoryData.Filename);
* ulong xferid = UUID.Random().GetULong();
* Dictionary<uint, byte[]> datapackets = new Dictionary<uint, byte[]>();
* bool datahasend = false;
* uint lastpacket = 0;
* PacketDelegate XferHandler = delegate(Packet packet3, IPEndPoint sim3)
* {
* SendXferPacketPacket xferpacket = (SendXferPacketPacket)packet3;
* if (xferpacket.XferID.ID == xferid)
* {
* uint packetnumber = xferpacket.XferID.Packet & 0x7FFFFFFF;
* if (!datapackets.ContainsKey(packetnumber))
* datapackets[packetnumber] = xferpacket.DataPacket.Data;
* if ((xferpacket.XferID.Packet & 0x80000000) != 0)
* {
* datahasend = true;
* lastpacket = packetnumber;
* }
* if (datahasend)
* {
* if (datapackets.Count == (lastpacket + 1))
* {
* int size = 0;
* foreach (KeyValuePair<uint, byte[]> kvp in datapackets)
* size += kvp.Value.Length;
* byte[] data = new byte[size - 4];
* int offset = 0;
* for (uint i = 0; i <= lastpacket; i++)
* {
* if (i == 0)
* {
* Buffer.BlockCopy(datapackets[i], 4, data, offset, datapackets[i].Length - 4);
* offset += datapackets[i].Length - 4;
* }
* else
* {
* Buffer.BlockCopy(datapackets[i], 0, data, offset, datapackets[i].Length);
* offset += datapackets[i].Length;
* }
* }
* ReceiveInventoryFile(Utils.BytesToString(data));
* finishevent.Set();
* }
* }
* }
* return packet3;
* };
* frame.proxy.AddDelegate(PacketType.SendXferPacket, Direction.Incoming, XferHandler);
* ManualResetEvent requestevent = new ManualResetEvent(false);
* PacketDelegate evtsetter = delegate(Packet packet2, IPEndPoint sim2)
* {
* if (Utils.BytesToString(((RequestXferPacket)packet2).XferID.Filename) == filename)
* {
* xferid = ((RequestXferPacket)packet2).XferID.ID;
* requestevent.Set();
* }
* return packet2;
* };
* frame.proxy.AddDelegate(PacketType.RequestXfer, Direction.Outgoing, evtsetter);
* bool needrequest = !requestevent.WaitOne(1000, false);
* frame.proxy.RemoveDelegate(PacketType.RequestXfer, Direction.Outgoing, evtsetter);
* if (needrequest)
* {
* RequestXferPacket request = new RequestXferPacket();
* request.XferID = new RequestXferPacket.XferIDBlock();
* request.XferID.ID = xferid;
* request.XferID.Filename = Utils.StringToBytes(filename);
* request.XferID.FilePath = 4;
* request.XferID.DeleteOnCompletion = true;
* request.XferID.UseBigPackets = false;
* request.XferID.VFileID = UUID.Zero;
* request.XferID.VFileType = -1;
* frame.proxy.InjectPacket(request, Direction.Outgoing);
* }
* finishevent.WaitOne(60000, false);
* frame.proxy.RemoveDelegate(PacketType.SendXferPacket, Direction.Incoming, XferHandler);
* }));
* mythread.Start();
* return packet;
*
* }*/
/*private void ReceiveInventoryFile(string data)
* {
* Console.Write("--------Received file:--------\n");
* Console.Write(data);
*
* //UUID magic = new UUID("3c115e51-04f4-523c-9fa6-98aff1034730");
* string[] lines = data.Split('\n');
* UUID creatorid = UUID.Zero;
* string type = "";
* string inv_type = "";
* string name = "";
* string description = "";
* bool got = false;
* foreach (string line in lines)
* {
* string L = line.Trim();
* if (L.StartsWith("inv_item"))
* {
* if (got)
* {
* //ReceiveAssetInfo(name, description, creatorid, type, inv_type);
* return;
* }
* else
* {
* got = true;
* creatorid = UUID.Zero;
* name = "";
* inv_type = "";
* description = "";
* }
* }
* else if (L.StartsWith("creator_id\t"))
* {
* creatorid = new UUID(L.Substring(11).Trim());
* }
* else if (L.StartsWith("desc\t"))
* {
* description = L.Substring(5).Trim().TrimEnd('|');
* }
* else if (L.StartsWith("type\t"))
* {
* type = L.Substring(5).Trim();
* }
* else if (L.StartsWith("inv_type\t"))
* {
* inv_type = L.Substring(9).Trim();
* }
* else if (L.StartsWith("name\t"))
* {
* name = L.Substring(5).Trim().TrimEnd('|');
* }
* }
* }*/
/*private Packet TrasferReq(Packet packet, IPEndPoint sim)
* {
* TransferRequestPacket trp = (TransferRequestPacket)packet;
* if (trp.TransferInfo.SourceType == 3)
* {
* /*smels
* Buffer.BlockCopy(frame.AgentID.GetBytes(), 0, paramField, 0, 16);
* Buffer.BlockCopy(frame.SessionID.GetBytes(), 0, paramField, 16, 16);
* Buffer.BlockCopy(item.OwnerID.GetBytes(), 0, paramField, 32, 16);
* Buffer.BlockCopy(UUID.Zero.GetBytes(), 0, paramField, 48, 16);
* Buffer.BlockCopy(item.UUID.GetBytes(), 0, paramField, 64, 16);
* Buffer.BlockCopy(item.AssetUUID.GetBytes(), 0, paramField, 80, 16);
* Buffer.BlockCopy(Helpers.IntToBytes((int)item.AssetType), 0, paramField, 96, 4);
* UUID itemid = new UUID(trp.TransferInfo.Params, 64);
* if (new List<string>(Directory.GetFiles("Scripts Cache")).Contains(itemid.ToString()))
* {
*
* using (StreamReader r = new StreamReader("Scripts Cache\\"+itemid.ToString()))
* {
* byte[] data = Utils.StringToBytes(r.ReadToEnd());
* TransferPacketPacket tpp = new TransferPacketPacket();
* tpp.TransferData.ChannelType = trp.TransferInfo.ChannelType;
* tpp.TransferData.Status = (int)StatusCode.Done;
* tpp.TransferData.Packet = 0;
* tpp.TransferData.TransferID = trp.TransferInfo.TransferID;
* tpp.TransferData.Data = data;
* proxy.InjectPacket(tpp, Direction.Incoming);
*
*
* TransferInfoPacket tip = new TransferInfoPacket();
* tip.TransferInfo = new TransferInfoPacket.TransferInfoBlock();
* tip.TransferInfo.Params = trp.TransferInfo.Params;
* tip.TransferInfo.Size = 0;
* tip.TransferInfo.Status = (int)StatusCode.OK;
* tip.TransferInfo.TargetType = 3;
* tip.TransferInfo.TransferID = trp.TransferInfo.TransferID ;
* tip.TransferInfo.ChannelType = 2;
* tip.Header.Reliable = true;
* proxy.InjectPacket(tip, Direction.Incoming);
* }
* }
*
*
* }
* return packet;
* }*/
private void ProcessRequest(RequestXferPacket requestRecived)
{
form.log("precesing the read request packet now", System.Drawing.Color.Green, System.Drawing.Color.Black);
currentuploads[requestRecived.XferID.ID].proxySending = true;
byte[][] datapackets = OpenBytecode(requestRecived.XferID.ID);
SendXferPacketPacket SendXferPacket;
OutgoingXfers.Add(requestRecived.XferID.ID, new lsotoolXfer(requestRecived.XferID.VFileID));
for (uint i = 0; i < (this.currentuploads[requestRecived.XferID.ID].size); i++)
{
SendXferPacket = new SendXferPacketPacket();
SendXferPacket.XferID = new SendXferPacketPacket.XferIDBlock();
this.currentuploads[requestRecived.XferID.ID].xferID = requestRecived.XferID.ID;
SendXferPacket.XferID.ID = requestRecived.XferID.ID;
SendXferPacket.XferID.Packet = i;
if (i == (this.currentuploads[requestRecived.XferID.ID].size - 1))
{
SendXferPacket.XferID.Packet = i | 0x80000000;
}
SendXferPacket.DataPacket = new SendXferPacketPacket.DataPacketBlock();
SendXferPacket.DataPacket.Data = datapackets[i];
OutgoingXfers[requestRecived.XferID.ID].Packets.Add(i, SendXferPacket);
}
// Start sending the new packets to the sim
OutgoingXfers[requestRecived.XferID.ID].PacketIndex = 0;
form.log("sent first packet with data\n" + Utils.BytesToString(OutgoingXfers[requestRecived.XferID.ID].Packets[0].DataPacket.Data), System.Drawing.Color.Yellow, System.Drawing.Color.DarkGreen);
proxy.InjectPacket(OutgoingXfers[requestRecived.XferID.ID].Packets[0], Direction.Outgoing);
//this.Scriptdata = OpenBytecode(fileDest);
}
private void RequestXferHandler(Packet packet, LLAgent agent)
{
RequestXferPacket request = (RequestXferPacket)packet;
string filename = Utils.BytesToString(request.XferID.Filename);
UUID taskInventoryID;
if (filename.StartsWith("inventory_") && filename.EndsWith(".tmp") && UUID.TryParse(filename.Substring(10, 36), out taskInventoryID))
{
// This is a request for a task inventory listing, which we generate on demand
ISceneEntity entity;
if (m_scene.TryGetEntity(taskInventoryID, out entity) && entity is LLPrimitive)
{
LLPrimitive prim = (LLPrimitive)entity;
byte[] assetData = Encoding.UTF8.GetBytes(prim.Inventory.GetTaskInventoryAsset());
SendXferPacketPacket xfer = new SendXferPacketPacket();
xfer.XferID.ID = request.XferID.ID;
if (assetData.Length < 1000)
{
xfer.XferID.Packet = 0 | LAST_PACKET_MARKER;
xfer.DataPacket.Data = new byte[assetData.Length + 4];
Utils.IntToBytes(assetData.Length, xfer.DataPacket.Data, 0);
Buffer.BlockCopy(assetData, 0, xfer.DataPacket.Data, 4, assetData.Length);
m_udp.SendPacket(agent, xfer, ThrottleCategory.Asset, false);
m_log.Debug("Completed single packet xfer download of " + filename);
}
else
{
xfer.XferID.Packet = 0;
xfer.DataPacket.Data = new byte[1000 + 4];
Utils.IntToBytes(assetData.Length, xfer.DataPacket.Data, 0);
Buffer.BlockCopy(assetData, 0, xfer.DataPacket.Data, 4, 1000);
// We don't need the entire XferDownload class, just the asset data and the current packet number
XferDownload download = new XferDownload();
download.AssetData = assetData;
download.PacketNum = 1;
download.Filename = filename;
lock (currentDownloads)
currentDownloads[request.XferID.ID] = download;
m_udp.SendPacket(agent, xfer, ThrottleCategory.Asset, false);
}
}
else
{
m_log.Warn("Could not find primitive " + taskInventoryID);
}
}
else
{
m_log.Warn("Got a RequestXfer for an unknown file: " + filename);
}
}
/// <summary>
/// Sends a packet of data to SL
/// </summary>
/// <param name="id"></param>
/// <param name="data">First xferpacket data must include a prefixed S32 for the length of the asset.</param>
/// <param name="packetNum"></param>
public static Packet SendXferPacket(ulong id, byte[] data, uint packetNum)
{
SendXferPacketPacket p = new SendXferPacketPacket();
p.DataPacket.Data = data;
p.XferID.ID = id;
p.XferID.Packet = (uint)packetNum;
return(p);
}
public void HandleXferPacket(SendXferPacketPacket xferPacket)
{
lock (this.transactions)
{
foreach (AssetTransaction trans in this.transactions.Values)
{
if (trans.XferID == xferPacket.XferID.ID)
{
if (trans.Asset.Data.Length > 1)
{
byte[] newArray = new byte[trans.Asset.Data.Length + xferPacket.DataPacket.Data.Length];
Array.Copy(trans.Asset.Data, 0, newArray, 0, trans.Asset.Data.Length);
Array.Copy(xferPacket.DataPacket.Data, 0, newArray, trans.Asset.Data.Length, xferPacket.DataPacket.Data.Length);
trans.Asset.Data = newArray;
}
else
{
byte[] newArray = new byte[xferPacket.DataPacket.Data.Length - 4];
Array.Copy(xferPacket.DataPacket.Data, 4, newArray, 0, xferPacket.DataPacket.Data.Length - 4);
trans.Asset.Data = newArray;
}
if ((xferPacket.XferID.Packet & 2147483648) != 0)
{
//end of transfer
trans.UploadComplete = true;
AssetUploadCompletePacket response = new AssetUploadCompletePacket();
response.AssetBlock.Type = trans.Asset.Type;
response.AssetBlock.Success = true;
response.AssetBlock.UUID = trans.TransactionID.Combine(this.ourClient.SecureSessionID);
this.ourClient.OutPacket(response);
m_assetCache.AddAsset(trans.Asset);
//check if we should add it to inventory
if (trans.AddToInventory)
{
// m_assetCache.AddAsset(trans.Asset);
m_inventoryCache.AddNewInventoryItem(this.ourClient, trans.InventFolder, trans.Asset);
}
}
break;
}
}
}
ConfirmXferPacketPacket confirmXfer = new ConfirmXferPacketPacket();
confirmXfer.XferID.ID = xferPacket.XferID.ID;
confirmXfer.XferID.Packet = xferPacket.XferID.Packet;
this.ourClient.OutPacket(confirmXfer);
}
private Packet ServerRequestsMyDataToStart(Packet packet, IPEndPoint sim)
{
RequestXferPacket requestRecived = (RequestXferPacket)packet;
/*SayToUser("vfile id is " + requestRecived.XferID.VFileID.UUID +
* " and id is " + requestRecived.XferID.ID.ToString()
+" and uploadid is "+ uploadID
+ " and special id is "+specialID
+" and filename is "+Utils.BytesToString(requestRecived.XferID.Filename)
+" and filepath is "+requestRecived.XferID.FilePath.ToString());
+
*/
if (grabbed == 0)
{
grabbed++;
Console.WriteLine("Server tells me to start data");
byte[][] datapackets = OpenBytecode(curentUpload.data);
SendXferPacketPacket SendXferPacket;
OutgoingXfers.Add(requestRecived.XferID.ID, new lsotoolXfer(requestRecived.XferID.VFileID));
for (uint i = 0; i < (curentUpload.size); i++)
{
SendXferPacket = new SendXferPacketPacket();
SendXferPacket.XferID = new SendXferPacketPacket.XferIDBlock();
SendXferPacket.XferID.ID = requestRecived.XferID.ID;
SendXferPacket.XferID.Packet = i;
if (i == (curentUpload.size - 1))
{
SendXferPacket.XferID.Packet = i | 0x80000000;
}
SendXferPacket.DataPacket = new SendXferPacketPacket.DataPacketBlock();
SendXferPacket.DataPacket.Data = datapackets[i];
OutgoingXfers[requestRecived.XferID.ID].Packets.Add(i, SendXferPacket);
}
// Start sending the new packets to the sim
OutgoingXfers[requestRecived.XferID.ID].PacketIndex = 0;
proxy.InjectPacket(OutgoingXfers[requestRecived.XferID.ID].Packets[0], Direction.Outgoing);
//this.Scriptdata = OpenBytecode(fileDest);
return(null);
}
return(packet);
}
private void SendNextUploadPacket(AssetUpload upload)
{
SendXferPacketPacket send = new SendXferPacketPacket();
send.XferID.ID = upload.XferID;
send.XferID.Packet = upload.PacketNum++;
if (send.XferID.Packet == 0)
{
// The first packet reserves the first four bytes of the data for the
// total length of the asset and appends 1000 bytes of data after that
send.DataPacket.Data = new byte[1004];
Buffer.BlockCopy(Helpers.IntToBytes(upload.Size), 0, send.DataPacket.Data, 0, 4);
Buffer.BlockCopy(upload.AssetData, 0, send.DataPacket.Data, 4, 1000);
upload.Transferred += 1000;
lock (Transfers)
{
Transfers.Remove(upload.AssetID);
Transfers[upload.ID] = upload;
}
}
else if ((send.XferID.Packet + 1) * 1000 < upload.Size)
{
// This packet is somewhere in the middle of the transfer, or a perfectly
// aligned packet at the end of the transfer
send.DataPacket.Data = new byte[1000];
Buffer.BlockCopy(upload.AssetData, upload.Transferred, send.DataPacket.Data, 0, 1000);
upload.Transferred += 1000;
}
else
{
// Special handler for the last packet which will be less than 1000 bytes
int lastlen = upload.Size - ((int)send.XferID.Packet * 1000);
send.DataPacket.Data = new byte[lastlen];
Buffer.BlockCopy(upload.AssetData, (int)send.XferID.Packet * 1000, send.DataPacket.Data, 0, lastlen);
send.XferID.Packet |= (uint)0x80000000; // This signals the final packet
upload.Transferred += lastlen;
}
Client.Network.SendPacket(send);
}
private void RequestXferHandler(Packet packet, LLAgent agent)
{
RequestXferPacket request = (RequestXferPacket)packet;
string filename = Utils.BytesToString(request.XferID.Filename);
UUID taskInventoryID;
if (filename.StartsWith("inventory_") && filename.EndsWith(".tmp") && UUID.TryParse(filename.Substring(10, 36), out taskInventoryID))
{
// This is a request for a task inventory listing, which we generate on demand
ISceneEntity entity;
if (m_scene.TryGetEntity(taskInventoryID, out entity) && entity is LLPrimitive)
{
LLPrimitive prim = (LLPrimitive)entity;
byte[] assetData = Encoding.UTF8.GetBytes(prim.Inventory.GetTaskInventoryAsset());
SendXferPacketPacket xfer = new SendXferPacketPacket();
xfer.XferID.ID = request.XferID.ID;
if (assetData.Length < 1000)
{
xfer.XferID.Packet = 0 | LAST_PACKET_MARKER;
xfer.DataPacket.Data = new byte[assetData.Length + 4];
Utils.IntToBytes(assetData.Length, xfer.DataPacket.Data, 0);
Buffer.BlockCopy(assetData, 0, xfer.DataPacket.Data, 4, assetData.Length);
m_udp.SendPacket(agent, xfer, ThrottleCategory.Asset, false);
m_log.Debug("Completed single packet xfer download of " + filename);
}
else
{
xfer.XferID.Packet = 0;
xfer.DataPacket.Data = new byte[1000 + 4];
Utils.IntToBytes(assetData.Length, xfer.DataPacket.Data, 0);
Buffer.BlockCopy(assetData, 0, xfer.DataPacket.Data, 4, 1000);
// We don't need the entire XferDownload class, just the asset data and the current packet number
XferDownload download = new XferDownload();
download.AssetData = assetData;
download.PacketNum = 1;
download.Filename = filename;
lock (currentDownloads)
currentDownloads[request.XferID.ID] = download;
m_udp.SendPacket(agent, xfer, ThrottleCategory.Asset, false);
}
}
else
{
m_log.Warn("Could not find primitive " + taskInventoryID);
}
}
else
{
m_log.Warn("Got a RequestXfer for an unknown file: " + filename);
}
}
private void ConfirmXferPacketHandler(Packet packet, LLAgent agent)
{
ConfirmXferPacketPacket confirm = (ConfirmXferPacketPacket)packet;
XferDownload download;
if (currentDownloads.TryGetValue(confirm.XferID.ID, out download))
{
// Send the next packet
SendXferPacketPacket xfer = new SendXferPacketPacket();
xfer.XferID.ID = confirm.XferID.ID;
int bytesRemaining = (int)(download.AssetData.Length - (download.PacketNum * 1000));
if (bytesRemaining > 1000)
{
xfer.DataPacket.Data = new byte[1000];
Buffer.BlockCopy(download.AssetData, (int)download.PacketNum * 1000, xfer.DataPacket.Data, 0, 1000);
xfer.XferID.Packet = download.PacketNum++;
}
else
{
// Last packet
xfer.DataPacket.Data = new byte[bytesRemaining];
Buffer.BlockCopy(download.AssetData, (int)download.PacketNum * 1000, xfer.DataPacket.Data, 0, bytesRemaining);
xfer.XferID.Packet = download.PacketNum | LAST_PACKET_MARKER;
lock (currentDownloads)
currentDownloads.Remove(confirm.XferID.ID);
m_log.Debug("Completing xfer download for: " + download.Filename);
}
m_udp.SendPacket(agent, xfer, ThrottleCategory.Asset, false);
}
}
/// <summary>
/// Sends a packet of data to SL
/// </summary>
/// <param name="id"></param>
/// <param name="data">First xferpacket data must include a prefixed S32 for the length of the asset.</param>
/// <param name="packetNum"></param>
public static Packet SendXferPacket(ulong id, byte[] data, uint packetNum)
{
SendXferPacketPacket p = new SendXferPacketPacket();
p.DataPacket.Data = data;
p.XferID.ID = id;
p.XferID.Packet = (uint)packetNum;
return p;
}
/*private Packet ReplyTask(Packet packet, IPEndPoint sim)
{
Thread mythread = new Thread(new ThreadStart(delegate
{
ManualResetEvent finishevent = new ManualResetEvent(false);
string filename = Utils.BytesToString(((ReplyTaskInventoryPacket)packet).InventoryData.Filename);
ulong xferid = UUID.Random().GetULong();
Dictionary<uint, byte[]> datapackets = new Dictionary<uint, byte[]>();
bool datahasend = false;
uint lastpacket = 0;
PacketDelegate XferHandler = delegate(Packet packet3, IPEndPoint sim3)
{
SendXferPacketPacket xferpacket = (SendXferPacketPacket)packet3;
if (xferpacket.XferID.ID == xferid)
{
uint packetnumber = xferpacket.XferID.Packet & 0x7FFFFFFF;
if (!datapackets.ContainsKey(packetnumber))
datapackets[packetnumber] = xferpacket.DataPacket.Data;
if ((xferpacket.XferID.Packet & 0x80000000) != 0)
{
datahasend = true;
lastpacket = packetnumber;
}
if (datahasend)
{
if (datapackets.Count == (lastpacket + 1))
{
int size = 0;
foreach (KeyValuePair<uint, byte[]> kvp in datapackets)
size += kvp.Value.Length;
byte[] data = new byte[size - 4];
int offset = 0;
for (uint i = 0; i <= lastpacket; i++)
{
if (i == 0)
{
Buffer.BlockCopy(datapackets[i], 4, data, offset, datapackets[i].Length - 4);
offset += datapackets[i].Length - 4;
}
else
{
Buffer.BlockCopy(datapackets[i], 0, data, offset, datapackets[i].Length);
offset += datapackets[i].Length;
}
}
ReceiveInventoryFile(Utils.BytesToString(data));
finishevent.Set();
}
}
}
return packet3;
};
frame.proxy.AddDelegate(PacketType.SendXferPacket, Direction.Incoming, XferHandler);
ManualResetEvent requestevent = new ManualResetEvent(false);
PacketDelegate evtsetter = delegate(Packet packet2, IPEndPoint sim2)
{
if (Utils.BytesToString(((RequestXferPacket)packet2).XferID.Filename) == filename)
{
xferid = ((RequestXferPacket)packet2).XferID.ID;
requestevent.Set();
}
return packet2;
};
frame.proxy.AddDelegate(PacketType.RequestXfer, Direction.Outgoing, evtsetter);
bool needrequest = !requestevent.WaitOne(1000, false);
frame.proxy.RemoveDelegate(PacketType.RequestXfer, Direction.Outgoing, evtsetter);
if (needrequest)
{
RequestXferPacket request = new RequestXferPacket();
request.XferID = new RequestXferPacket.XferIDBlock();
request.XferID.ID = xferid;
request.XferID.Filename = Utils.StringToBytes(filename);
request.XferID.FilePath = 4;
request.XferID.DeleteOnCompletion = true;
request.XferID.UseBigPackets = false;
request.XferID.VFileID = UUID.Zero;
request.XferID.VFileType = -1;
frame.proxy.InjectPacket(request, Direction.Outgoing);
}
finishevent.WaitOne(60000, false);
frame.proxy.RemoveDelegate(PacketType.SendXferPacket, Direction.Incoming, XferHandler);
}));
mythread.Start();
return packet;
}*/
/*private void ReceiveInventoryFile(string data)
{
Console.Write("--------Received file:--------\n");
Console.Write(data);
//UUID magic = new UUID("3c115e51-04f4-523c-9fa6-98aff1034730");
string[] lines = data.Split('\n');
UUID creatorid = UUID.Zero;
string type = "";
string inv_type = "";
string name = "";
string description = "";
bool got = false;
foreach (string line in lines)
{
string L = line.Trim();
if (L.StartsWith("inv_item"))
{
if (got)
{
//ReceiveAssetInfo(name, description, creatorid, type, inv_type);
return;
}
else
{
got = true;
creatorid = UUID.Zero;
name = "";
inv_type = "";
description = "";
}
}
else if (L.StartsWith("creator_id\t"))
{
creatorid = new UUID(L.Substring(11).Trim());
}
else if (L.StartsWith("desc\t"))
{
description = L.Substring(5).Trim().TrimEnd('|');
}
else if (L.StartsWith("type\t"))
{
type = L.Substring(5).Trim();
}
else if (L.StartsWith("inv_type\t"))
{
inv_type = L.Substring(9).Trim();
}
else if (L.StartsWith("name\t"))
{
name = L.Substring(5).Trim().TrimEnd('|');
}
}
}*/
/*private Packet TrasferReq(Packet packet, IPEndPoint sim)
{
TransferRequestPacket trp = (TransferRequestPacket)packet;
if (trp.TransferInfo.SourceType == 3)
{
/*smels
Buffer.BlockCopy(frame.AgentID.GetBytes(), 0, paramField, 0, 16);
Buffer.BlockCopy(frame.SessionID.GetBytes(), 0, paramField, 16, 16);
Buffer.BlockCopy(item.OwnerID.GetBytes(), 0, paramField, 32, 16);
Buffer.BlockCopy(UUID.Zero.GetBytes(), 0, paramField, 48, 16);
Buffer.BlockCopy(item.UUID.GetBytes(), 0, paramField, 64, 16);
Buffer.BlockCopy(item.AssetUUID.GetBytes(), 0, paramField, 80, 16);
Buffer.BlockCopy(Helpers.IntToBytes((int)item.AssetType), 0, paramField, 96, 4);
UUID itemid = new UUID(trp.TransferInfo.Params, 64);
if (new List<string>(Directory.GetFiles("Scripts Cache")).Contains(itemid.ToString()))
{
using (StreamReader r = new StreamReader("Scripts Cache\\"+itemid.ToString()))
{
byte[] data = Utils.StringToBytes(r.ReadToEnd());
TransferPacketPacket tpp = new TransferPacketPacket();
tpp.TransferData.ChannelType = trp.TransferInfo.ChannelType;
tpp.TransferData.Status = (int)StatusCode.Done;
tpp.TransferData.Packet = 0;
tpp.TransferData.TransferID = trp.TransferInfo.TransferID;
tpp.TransferData.Data = data;
proxy.InjectPacket(tpp, Direction.Incoming);
TransferInfoPacket tip = new TransferInfoPacket();
tip.TransferInfo = new TransferInfoPacket.TransferInfoBlock();
tip.TransferInfo.Params = trp.TransferInfo.Params;
tip.TransferInfo.Size = 0;
tip.TransferInfo.Status = (int)StatusCode.OK;
tip.TransferInfo.TargetType = 3;
tip.TransferInfo.TransferID = trp.TransferInfo.TransferID ;
tip.TransferInfo.ChannelType = 2;
tip.Header.Reliable = true;
proxy.InjectPacket(tip, Direction.Incoming);
}
}
}
return packet;
}*/
private void ProcessRequest(RequestXferPacket requestRecived)
{
form.log("precesing the read request packet now", System.Drawing.Color.Green, System.Drawing.Color.Black);
currentuploads[requestRecived.XferID.ID].proxySending = true;
byte[][] datapackets = OpenBytecode(requestRecived.XferID.ID);
SendXferPacketPacket SendXferPacket;
OutgoingXfers.Add(requestRecived.XferID.ID, new lsotoolXfer(requestRecived.XferID.VFileID));
for (uint i = 0; i < (this.currentuploads[requestRecived.XferID.ID].size); i++)
{
SendXferPacket = new SendXferPacketPacket();
SendXferPacket.XferID = new SendXferPacketPacket.XferIDBlock();
this.currentuploads[requestRecived.XferID.ID].xferID = requestRecived.XferID.ID;
SendXferPacket.XferID.ID = requestRecived.XferID.ID;
SendXferPacket.XferID.Packet = i;
if (i == (this.currentuploads[requestRecived.XferID.ID].size - 1))
SendXferPacket.XferID.Packet = i | 0x80000000;
SendXferPacket.DataPacket = new SendXferPacketPacket.DataPacketBlock();
SendXferPacket.DataPacket.Data = datapackets[i];
OutgoingXfers[requestRecived.XferID.ID].Packets.Add(i, SendXferPacket);
}
// Start sending the new packets to the sim
OutgoingXfers[requestRecived.XferID.ID].PacketIndex = 0;
form.log("sent first packet with data\n" + Utils.BytesToString(OutgoingXfers[requestRecived.XferID.ID].Packets[0].DataPacket.Data), System.Drawing.Color.Yellow, System.Drawing.Color.DarkGreen);
proxy.InjectPacket(OutgoingXfers[requestRecived.XferID.ID].Packets[0], Direction.Outgoing);
//this.Scriptdata = OpenBytecode(fileDest);
}
public void HandleXferPacket(SendXferPacketPacket xferPacket)
{
lock (this.transactions)
{
foreach (AssetTransaction trans in this.transactions.Values)
{
if (trans.XferID == xferPacket.XferID.ID)
{
if (trans.Asset.Data.Length > 1)
{
byte[] newArray = new byte[trans.Asset.Data.Length + xferPacket.DataPacket.Data.Length];
Array.Copy(trans.Asset.Data, 0, newArray, 0, trans.Asset.Data.Length);
Array.Copy(xferPacket.DataPacket.Data, 0, newArray, trans.Asset.Data.Length, xferPacket.DataPacket.Data.Length);
trans.Asset.Data = newArray;
}
else
{
byte[] newArray = new byte[xferPacket.DataPacket.Data.Length - 4];
Array.Copy(xferPacket.DataPacket.Data, 4, newArray, 0, xferPacket.DataPacket.Data.Length - 4);
trans.Asset.Data = newArray;
}
if ((xferPacket.XferID.Packet & 2147483648) != 0)
{
//end of transfer
trans.UploadComplete = true;
AssetUploadCompletePacket response = new AssetUploadCompletePacket();
response.AssetBlock.Type = trans.Asset.Type;
response.AssetBlock.Success = true;
response.AssetBlock.UUID = trans.TransactionID.Combine(this.ourClient.SecureSessionID);
this.ourClient.OutPacket(response);
m_assetCache.AddAsset(trans.Asset);
//check if we should add it to inventory
if (trans.AddToInventory)
{
// m_assetCache.AddAsset(trans.Asset);
m_inventoryCache.AddNewInventoryItem(this.ourClient, trans.InventFolder, trans.Asset);
}
}
break;
}
}
}
ConfirmXferPacketPacket confirmXfer = new ConfirmXferPacketPacket();
confirmXfer.XferID.ID = xferPacket.XferID.ID;
confirmXfer.XferID.Packet = xferPacket.XferID.Packet;
this.ourClient.OutPacket(confirmXfer);
}
private void SendXferPacketHandler(Packet packet, Simulator simulator)
{
SendXferPacketPacket xfer = (SendXferPacketPacket)packet;
// Lame ulong to LLUUID conversion, please go away Xfer system
LLUUID transferID = new LLUUID(xfer.XferID.ID);
Transfer transfer;
XferDownload download = null;
if (Transfers.TryGetValue(transferID, out transfer))
{
download = (XferDownload)transfer;
// Apply a mask to get rid of the "end of transfer" bit
uint packetNum = xfer.XferID.Packet & 0x0FFFFFFF;
// Check for out of order packets, possibly indicating a resend
if (packetNum != download.PacketNum)
{
if (packetNum == download.PacketNum - 1)
{
Client.DebugLog("Resending Xfer download confirmation for packet " + packetNum);
SendConfirmXferPacket(download.XferID, packetNum);
}
else
{
Client.Log("Out of order Xfer packet in a download, got " + packetNum + " expecting " + download.PacketNum,
Helpers.LogLevel.Warning);
}
return;
}
if (packetNum == 0)
{
// This is the first packet received in the download, the first four bytes are a network order size integer
download.Size = (int)Helpers.BytesToUIntBig(xfer.DataPacket.Data);
download.AssetData = new byte[download.Size];
Buffer.BlockCopy(xfer.DataPacket.Data, 4, download.AssetData, 0, xfer.DataPacket.Data.Length - 4);
download.Transferred += xfer.DataPacket.Data.Length - 4;
}
else
{
Buffer.BlockCopy(xfer.DataPacket.Data, 0, download.AssetData, 1000 * (int)packetNum, xfer.DataPacket.Data.Length);
download.Transferred += xfer.DataPacket.Data.Length;
}
// Increment the packet number to the packet we are expecting next
download.PacketNum++;
// Confirm receiving this packet
SendConfirmXferPacket(download.XferID, packetNum);
if ((xfer.XferID.Packet & 0x80000000) != 0)
{
// This is the last packet in the transfer
if (!String.IsNullOrEmpty(download.Filename))
{
Client.DebugLog("Xfer download for asset " + download.Filename + " completed");
}
else
{
Client.DebugLog("Xfer download for asset " + download.VFileID.ToString() + " completed");
}
download.Success = true;
lock (Transfers) Transfers.Remove(download.ID);
if (OnXferReceived != null)
{
try { OnXferReceived(download); }
catch (Exception e) { Client.Log(e.ToString(), Helpers.LogLevel.Error); }
}
}
}
}
private Packet ServerRequestsMyDataToStart(Packet packet, IPEndPoint sim)
{
RequestXferPacket requestRecived = (RequestXferPacket)packet;
/*SayToUser("vfile id is " + requestRecived.XferID.VFileID.UUID +
" and id is " + requestRecived.XferID.ID.ToString()
+" and uploadid is "+ uploadID
+ " and special id is "+specialID
+" and filename is "+Utils.BytesToString(requestRecived.XferID.Filename)
+" and filepath is "+requestRecived.XferID.FilePath.ToString());
*/
if (grabbed == 0)
{
grabbed++;
Console.WriteLine("Server tells me to start data");
byte[][] datapackets = OpenBytecode(curentUpload.data);
SendXferPacketPacket SendXferPacket;
OutgoingXfers.Add(requestRecived.XferID.ID, new lsotoolXfer(requestRecived.XferID.VFileID));
for (uint i = 0; i < (curentUpload.size); i++)
{
SendXferPacket = new SendXferPacketPacket();
SendXferPacket.XferID = new SendXferPacketPacket.XferIDBlock();
SendXferPacket.XferID.ID = requestRecived.XferID.ID;
SendXferPacket.XferID.Packet = i;
if (i == (curentUpload.size - 1))
SendXferPacket.XferID.Packet = i | 0x80000000;
SendXferPacket.DataPacket = new SendXferPacketPacket.DataPacketBlock();
SendXferPacket.DataPacket.Data = datapackets[i];
OutgoingXfers[requestRecived.XferID.ID].Packets.Add(i, SendXferPacket);
}
// Start sending the new packets to the sim
OutgoingXfers[requestRecived.XferID.ID].PacketIndex = 0;
proxy.InjectPacket(OutgoingXfers[requestRecived.XferID.ID].Packets[0], Direction.Outgoing);
//this.Scriptdata = OpenBytecode(fileDest);
return null;
}
return packet;
}
/*private bool UploadStart(CapsRequest capReq, CapsStage stage)
* {
* Console.WriteLine(capReq.ToString());
* Console.WriteLine("drrr");
* Console.WriteLine(capReq.Request.ToString());
*
* //RequestXferPacket requestRecived = (RequestXferPacket)Packet.BuildPacket("RequestXfer", (OpenMetaverse.StructuredData.LLSDMap)capReq.Response);
*
* return false;
* }*/
/*private Packet OutDialogFromViewer(Packet packet, IPEndPoint sim)
* {
* ScriptDialogReplyPacket DialogFromViewer = (ScriptDialogReplyPacket)packet;
* if (handeledViewerOutput(Utils.BytesToString(DialogFromViewer.Data.ButtonLabel).Trim().ToLower()) == "die")
* return null;
*
* return packet;
* }
*
* public string handeledViewerOutput(string mssage)
* {
*
* if (mssage.ToLower().Contains(this.brand.ToLower() + "-on"))
* {
* Enabled = true;
* //form.setBox(Enabled);
*
* SendUserAlert("AwesomeSauce Enabled");
* return "die";
* }
* else if (mssage.ToLower().Contains(this.brand.ToLower() + "-off"))
* {
* Enabled = false;
*
* SendUserAlert("AwesomeSauce Disabled");
* //form.setBox(Enabled);
* return "die";
* }
* else if (mssage.ToLower().Contains(this.brand.ToLower() + "-help"))
* {
* SayToUser("Thanks for using the AwesomeSauce script text remover system :).\n" + "To make it work, just enable it and upload scripts in no mono\n"+
* "You have to use DisableCaps.dll to UpdateScriptTask, and UpdateScriptAgent. (put them into the dropped side, and tp or relog)\n"+
* "Then, just add \"//(COMPILE_PROTECTED)\"at the top of your script, and the rest is automatic.\n"+
* "Your script wil be saved to your hard drive, and the server script will contain the top three lines of it only"+
* "(maybe put copywright comments there)");
* }
* else if (mssage.ToLower().Contains(this.brand.ToLower() + "-about"))
* {
* SayToUser("This program was made by LordGregGreg for the purpose of allowing\nscripts to be uploaded without their text.\nMight be good for securty if you don't trust sl to keep your perms right");
* SayToUser("Special Thanks to \"Philip Linden\" (yeah, thats not his actual sl name)\n" +
* "and Darling Brody for ideas and motivation\n"+
* "and the OpenMetaverse project, and all it's contributors.");
*
* }
* else if (mssage.ToLower().Contains(this.brand.ToLower() + "-"))
* {
* SendUserDialog(this.brand + "", "AwesomeSauce", "Messenger", "What do you want me to do?", new string[] { this.brand+"-ON", this.brand+"-OFF", this.brand+"-HELP", this.brand+"-ABOUT" });
* return "die";
* }
*
* return "go";
* }
* private Packet OutChatFromViewerHandler(Packet packet, IPEndPoint sim)
* {
* ChatFromViewerPacket ChatFromViewer = (ChatFromViewerPacket)packet;
* string message = Utils.BytesToString(ChatFromViewer.ChatData.Message);
* if (handeledViewerOutput(message) == "die")
* {
* return null;
* }
* return packet;
*
* }*/
private Packet ClientSentThisScript(Packet packet, IPEndPoint sim)
{
if (packet.Header.Resent)
{
return(packet);
}
SendXferPacketPacket sxpp = (SendXferPacketPacket)packet;
int start = 0;
if (currentuploads.ContainsKey(sxpp.XferID.ID))
{
if (currentuploads[sxpp.XferID.ID].proxySending)
{
Console.WriteLine("we are already sending this script, dont need its data");
return(null);
}
if (currentuploads[sxpp.XferID.ID].curentdatalenght == 0)
{
Console.WriteLine("This was the first packet");
byte [] temp = new byte[sxpp.DataPacket.Data.Length];
Buffer.BlockCopy(sxpp.DataPacket.Data, 4, temp, 0, sxpp.DataPacket.Data.Length - 4);
string script = Utils.BytesToString(temp);
string[] lines = script.Split('\n');
if (lines[0].Contains("(COMPILE_PROTECTED)"))
{
form.log("We got a script meant to be protected!", System.Drawing.Color.DarkBlue, System.Drawing.Color.Black);
frame.SendUserAlert("Uploading Script Protected");
start = 4;
}
else
{
form.log("This Script was not meant to be protected ABANDON SHIP!", System.Drawing.Color.DarkBlue, System.Drawing.Color.Black);
currentuploads.Remove(sxpp.XferID.ID);
if (OutgoingXfers.ContainsKey(sxpp.XferID.ID))
{
OutgoingXfers.Remove(sxpp.XferID.ID);
}
return(packet);
}
}
form.log("We got a script packet sent from client with the actual stuff, get it!", System.Drawing.Color.DarkBlue, System.Drawing.Color.Black);
Buffer.BlockCopy(sxpp.DataPacket.Data, start, currentuploads[sxpp.XferID.ID].oldscriptdata,
currentuploads[sxpp.XferID.ID].curentdatalenght, sxpp.DataPacket.Data.Length - start);
currentuploads[sxpp.XferID.ID].curentdatalenght += sxpp.DataPacket.Data.Length - start;
if ((sxpp.XferID.Packet & 0x80000000) != 0)
{
form.log("we got the final packet sent from viewer to server, going to start upload now", System.Drawing.Color.Blue, System.Drawing.Color.Black);
currentuploads[sxpp.XferID.ID].oldmaxsize = currentuploads[sxpp.XferID.ID].curentdatalenght;
if (requests2Process.ContainsKey(sxpp.XferID.ID))
{
ProcessRequest(requests2Process[sxpp.XferID.ID]);
requests2Process.Remove(sxpp.XferID.ID);
}
//last packet
}
ConfirmXferPacketPacket fakeConf = new ConfirmXferPacketPacket();
fakeConf.XferID.ID = sxpp.XferID.ID;
fakeConf.XferID.Packet = sxpp.XferID.Packet;
proxy.InjectPacket(fakeConf, Direction.Incoming);
return(null);//block the packets the cliet is sending
} //Console.WriteLine("Not one we are loking for");
return(packet);
}
void SendXferPacketHandler(Packet packet, Agent agent)
{
SendXferPacketPacket xfer = (SendXferPacketPacket)packet;
Asset asset;
if (CurrentUploads.TryGetValue(xfer.XferID.ID, out asset))
{
if (asset.AssetData == null)
{
if (xfer.XferID.Packet != 0)
{
Logger.Log(String.Format("Received Xfer packet {0} before the first packet!",
xfer.XferID.Packet), Helpers.LogLevel.Error);
return;
}
uint size = Utils.BytesToUInt(xfer.DataPacket.Data);
asset.AssetData = new byte[size];
Buffer.BlockCopy(xfer.DataPacket.Data, 4, asset.AssetData, 0, xfer.DataPacket.Data.Length - 4);
// Confirm the first upload packet
ConfirmXferPacketPacket confirm = new ConfirmXferPacketPacket();
confirm.XferID.ID = xfer.XferID.ID;
confirm.XferID.Packet = xfer.XferID.Packet;
server.UDP.SendPacket(agent.AgentID, confirm, PacketCategory.Asset);
}
else
{
Buffer.BlockCopy(xfer.DataPacket.Data, 0, asset.AssetData, (int)xfer.XferID.Packet * 1000,
xfer.DataPacket.Data.Length);
// Confirm this upload packet
ConfirmXferPacketPacket confirm = new ConfirmXferPacketPacket();
confirm.XferID.ID = xfer.XferID.ID;
confirm.XferID.Packet = xfer.XferID.Packet;
server.UDP.SendPacket(agent.AgentID, confirm, PacketCategory.Asset);
if ((xfer.XferID.Packet & (uint)0x80000000) != 0)
{
// Asset upload finished
Logger.DebugLog(String.Format("Completed Xfer upload of asset {0} ({1}", asset.AssetID, asset.AssetType));
lock (CurrentUploads)
CurrentUploads.Remove(xfer.XferID.ID);
StoreAsset(asset);
AssetUploadCompletePacket complete = new AssetUploadCompletePacket();
complete.AssetBlock.Success = true;
complete.AssetBlock.Type = (sbyte)asset.AssetType;
complete.AssetBlock.UUID = asset.AssetID;
server.UDP.SendPacket(agent.AgentID, complete, PacketCategory.Asset);
}
}
}
else
{
Logger.DebugLog("Received a SendXferPacket for an unknown upload");
}
}
private void SendXferPacketHandler(Packet packet, LLAgent agent)
{
SendXferPacketPacket xfer = (SendXferPacketPacket)packet;
uint packetID = xfer.XferID.Packet & ~LAST_PACKET_MARKER;
bool lastPacket = (xfer.XferID.Packet & LAST_PACKET_MARKER) != 0;
Asset asset;
if (currentUploads.TryGetValue(xfer.XferID.ID, out asset))
{
if (packetID == 0)
{
uint size = Utils.BytesToUInt(xfer.DataPacket.Data);
asset.Data = new byte[size];
Buffer.BlockCopy(xfer.DataPacket.Data, 4, asset.Data, 0, xfer.DataPacket.Data.Length - 4);
// Confirm the first upload packet
ConfirmXferPacketPacket confirm = new ConfirmXferPacketPacket();
confirm.XferID.ID = xfer.XferID.ID;
confirm.XferID.Packet = xfer.XferID.Packet;
m_udp.SendPacket(agent, confirm, ThrottleCategory.Asset, false);
}
else if (asset.Data != null)
{
AssetType type = (AssetType)LLUtil.ContentTypeToLLAssetType(asset.ContentType);
Buffer.BlockCopy(xfer.DataPacket.Data, 0, asset.Data, (int)packetID * 1000, xfer.DataPacket.Data.Length);
// Confirm this upload packet
ConfirmXferPacketPacket confirm = new ConfirmXferPacketPacket();
confirm.XferID.ID = xfer.XferID.ID;
confirm.XferID.Packet = xfer.XferID.Packet;
m_udp.SendPacket(agent, confirm, ThrottleCategory.Asset, false);
if (lastPacket)
{
// Asset upload finished
lock (currentUploads)
currentUploads.Remove(xfer.XferID.ID);
if (type != AssetType.LSLBytecode)
{
// Store the uploaded asset
m_log.DebugFormat("Storing uploaded asset {0} ({1})", asset.ID, asset.ContentType);
if (!m_assets.StoreAsset(asset))
{
m_log.ErrorFormat("Failed to store uploaded asset {0} ({1})", asset.ID, asset.ContentType);
}
}
else
{
m_log.Debug("Ignoring LSL bytecode upload " + asset.ID);
}
AssetUploadCompletePacket complete = new AssetUploadCompletePacket();
complete.AssetBlock.Success = true;
complete.AssetBlock.Type = (sbyte)type;
complete.AssetBlock.UUID = asset.ID;
m_udp.SendPacket(agent, complete, ThrottleCategory.Asset, false);
}
}
else
{
m_log.Error("Received SendXferPacket #" + xfer.XferID.Packet + " when asset.AssetData is still null");
}
}
else
{
m_log.Debug("Received a SendXferPacket for an unknown upload");
}
}
public bool XferAsset(SendXferPacketPacket xfer)
{
if (connected)
{
AssetReceiver assReceiver = null;
lock (assetReceivers)
foreach (AssetReceiver assr in assetReceivers.Values)
if (xfer.XferID.ID == assr.XferID)
assReceiver = assr;
if (assReceiver == null)
{
//Console.WriteLine("[UserInventory]: Could not find asser receiver for Xfer " + xfer.XferID.ID);
return false;
}
assReceiver.GetDataPacket(xfer.XferID.Packet, xfer.DataPacket.Data);
if ((xfer.XferID.Packet & 0x80000000) != 0) // last one, it seems
{
UUID assRecvrID = assReceiver.transferID;
lock (assetReceivers)
assetReceivers.Remove(assRecvrID);
Console.WriteLine("[UserInventory]: Asset Xfer finished, removed asset receiver");
}
return true;
}
return false;
}
private void SendNextUploadPacket(AssetUpload upload)
{
SendXferPacketPacket send = new SendXferPacketPacket();
send.XferID.ID = upload.XferID;
send.XferID.Packet = upload.PacketNum++;
if (send.XferID.Packet == 0)
{
// The first packet reserves the first four bytes of the data for the
// total length of the asset and appends 1000 bytes of data after that
send.DataPacket.Data = new byte[1004];
Buffer.BlockCopy(Utils.IntToBytes(upload.Size), 0, send.DataPacket.Data, 0, 4);
Buffer.BlockCopy(upload.AssetData, 0, send.DataPacket.Data, 4, 1000);
upload.Transferred += 1000;
lock (Transfers)
{
Transfers.Remove(upload.AssetID);
Transfers[upload.ID] = upload;
}
}
else if ((send.XferID.Packet + 1) * 1000 < upload.Size)
{
// This packet is somewhere in the middle of the transfer, or a perfectly
// aligned packet at the end of the transfer
send.DataPacket.Data = new byte[1000];
Buffer.BlockCopy(upload.AssetData, upload.Transferred, send.DataPacket.Data, 0, 1000);
upload.Transferred += 1000;
}
else
{
// Special handler for the last packet which will be less than 1000 bytes
int lastlen = upload.Size - ((int)send.XferID.Packet * 1000);
send.DataPacket.Data = new byte[lastlen];
Buffer.BlockCopy(upload.AssetData, (int)send.XferID.Packet * 1000, send.DataPacket.Data, 0, lastlen);
send.XferID.Packet |= (uint)0x80000000; // This signals the final packet
upload.Transferred += lastlen;
}
Client.Network.SendPacket(send);
}
public void RequestXferInventory(SimClient simClient, ulong xferID)
{
//will only currently work if the total size of the inventory data array is under about 1000 bytes
SendXferPacketPacket send = new SendXferPacketPacket();
send.XferID.ID = xferID;
send.XferID.Packet = 1 + 2147483648;
send.DataPacket.Data = this.ConvertInventoryToBytes();
simClient.OutPacket(send);
}
