public static uint ComputePartitionArrayCRC32(Disk disk, GuidPartitionTableHeader header)
{
int sectorsToRead = (int)Math.Ceiling((double)header.NumberOfPartitionEntries * header.SizeOfPartitionEntry / disk.BytesPerSector);
byte[] buffer = disk.ReadSectors((long)header.PartitionEntriesLBA, sectorsToRead);
return(CRC32.Compute(buffer));
}
private static List <GuidPartitionEntry> ReadEntriesFromDisk(Disk disk, GuidPartitionTableHeader header)
{
int bufferLength = (int)(header.NumberOfPartitionEntries * header.SizeOfPartitionEntry);
int sectorsToRead = (int)Math.Ceiling((double)bufferLength / disk.BytesPerSector);
byte[] buffer = disk.ReadSectors((long)header.PartitionEntriesLBA, sectorsToRead);
if (buffer.Length > bufferLength)
{
buffer = ByteReader.ReadBytes(buffer, 0, bufferLength);
}
uint expectedCRC32 = CRC32.Compute(buffer);
if (header.PartitionArrayCRC32 != expectedCRC32)
{
return(null);
}
int offset = 0;
List <GuidPartitionEntry> result = new List <GuidPartitionEntry>();
for (int index = 0; index < header.NumberOfPartitionEntries; index++)
{
GuidPartitionEntry entry = new GuidPartitionEntry(buffer, offset);
entry.EntryIndex = index;
// Unused entries use Guid.Empty as PartitionTypeGuid
if (entry.PartitionTypeGuid != Guid.Empty)
{
result.Add(entry);
}
offset += (int)header.SizeOfPartitionEntry;
}
return(result);
}
public void CRC32TestSimplePasses()
{
var IEND = new byte[] { 0x49, 0x45, 0x4e, 0x44 };
var crc = CRC32.Compute(IEND, 0, 4);
Assert.AreEqual(crc, 0xAE426082, "IEND chunk's CRC");
}
/// <summary>Used internally by the netcode to send unconnected messages.</summary>
private async Task <int> SendAsync(PacketType type, IPEndPoint remote, IWritable message)
{
// Buffers allocated by the allocator
byte[] compress = null;
Writer writer = null;
try {
// Write message
writer = new Writer(Allocator, 5);
message?.Write(writer);
ArraySegment <byte> packet = new ArraySegment <byte>(writer.Buffer, 5, writer.Position - 5);
// Create flags
PacketFlags flags = PacketFlags.None;
// Compress
if (Config.Compression)
{
int max = Compressor.MaxCompressedLength(packet.Count) + packet.Offset;
compress = Allocator.CreateMessage(max);
int len = Compressor.Compress(packet, compress, packet.Offset);
if (len <= 0)
{
throw new InvalidOperationException(string.Format(
"Compressing {0} bytes returned {1} bytes", packet.Count, len
));
}
else if (len < packet.Count)
{
packet = new ArraySegment <byte>(compress, packet.Offset, len);
flags |= PacketFlags.Compressed;
}
}
// Write CRC32
if (Config.CRC32)
{
uint crc32 = CRC32.Compute(packet.Array, packet.Offset, packet.Count);
Serializer.Write32(packet.Array, packet.Offset - 4, crc32);
packet = new ArraySegment <byte>(packet.Array, packet.Offset - 4, packet.Count + 4);
flags |= PacketFlags.Verified;
}
// Write header
packet.Array[packet.Offset - 1] = (byte)(((byte)type) | ((byte)flags));
packet = new ArraySegment <byte>(packet.Array, packet.Offset - 1, packet.Count + 1);
// Send
return(await SendSocketAsync(remote, packet.Array, packet.Offset, packet.Count));
} catch (Exception exception) {
// Notify listener about the exception
Listener.OnHostException(remote, exception);
throw;
} finally {
// Return the allocated buffers back to the allocator
writer?.Dispose();
Allocator.ReturnMessage(ref compress);
}
}
public void TestCRC32()
{
var data = Encoding.ASCII.GetBytes("abcdefg");
Assert.AreEqual((uint)0x312A6AA6, CRC32.Compute(data));
data = Encoding.ASCII.GetBytes("abcdefg12345678");
Assert.AreEqual(0x9AE0DAAF, CRC32.Compute(data, 7, 8));
}
public Market(SystemBody body, string code)
{
this.entries = new Dictionary <int, MarketEntry>();
ulong systemId = body.SystemId;
int seed = Math.Abs(CRC32.Compute(systemId.ToString() + code));
//int seed = (int)(body.SystemBodyId | (int)((systemId >> 16) & 0xFFFFFFFF));
Random rand = new Random(seed);
double timeBase = DateTime.Now.Subtract(new DateTime(2011, 1, 1)).TotalHours;
double pfluctuation = 1.5 + Math.Sin(timeBase / 2);
double qfluctuation = 1.5 + Math.Cos(timeBase);
foreach (var tGood in TradeGood.Goods)
{
double quantity;
double baseQuantity = (double)tGood.BaseQuantity;
//int overTech = (int)body.StarSystem.TechLevel - tGood.MinTechLevel;
int overTech = 10;
bool mainP = overTech > 10;
if (tGood.MainOrigin.Count > 0)
{
mainP &= tGood.MainOrigin.Contains(body.BodyType);
}
if (!mainP)
{
quantity = rand.Next(0, (int)baseQuantity / 8);
}
else
{
quantity = rand.Next((int)baseQuantity / 8, (int)baseQuantity * 2);
if (tGood.MinTechLevel > 0)
{
quantity *= 1 + (overTech * 0.1);
}
}
quantity *= qfluctuation;
double actBasePrice = pfluctuation * tGood.BasePrice;
double bQ = quantity / baseQuantity;
double f = Math.Pow(3, (-(bQ - 1))) + 0.1;
var currPrice = f * actBasePrice;
MarketEntry entry = new MarketEntry(tGood, (int)currPrice, actBasePrice, (int)quantity);
this.entries.Add(tGood.TradeGoodId, entry);
}
}
protected void SpawnInhibitor(string name)
{
uint netId = BuildingProvider.BUILDING_NETID_X | CRC32.Compute(Encoding.ASCII.GetBytes(name));
Inhibitor inhibitor = new Inhibitor(netId, BuildingRecord.GetBuildingRecord(this.Game.Map.Id, name), Game.Map.Record.GetObject(name));
inhibitor.DefineGame(Game);
Game.AddUnitToTeam(inhibitor, BuildingProvider.Instance.GetTeamId(name));
Game.Map.AddUnit(inhibitor);
}
protected void SpawnNexus(string name)
{
uint netId = BuildingProvider.BUILDING_NETID_X | CRC32.Compute(Encoding.ASCII.GetBytes(name));
Nexus nexus = new Nexus(netId, BuildingRecord.GetBuildingRecord(this.Game.Map.Id, name), Game.Map.Record.GetObject(name));
nexus.DefineGame(Game);
Game.AddUnitToTeam(nexus, BuildingProvider.Instance.GetTeamId(name));
Game.Map.AddUnit(nexus);
}
private void LoadUpdateXMLOK(Dictionary <string, UpdateFileInfo> _dic, int _remoteVersion, Func <string, string> _fixFun, Action _callBack)
{
int loadNum = _dic.Count;
foreach (KeyValuePair <string, UpdateFileInfo> pair in _dic)
{
string path = pair.Key;
UpdateFileInfo info = pair.Value;
string url = _fixFun(info.path + path);
Action <WWW> callBack = delegate(WWW obj) {
if (obj.error != null)
{
SuperDebug.Log("文件热更新失败 文件名:" + obj.url);
return;
}
UInt32 crc = CRC32.Compute(obj.bytes);
if (crc != info.crc)
{
SuperDebug.Log("文件热更新CRC比对错误 文件名:" + obj.url);
return;
}
SystemIO.SaveFile(Application.persistentDataPath + "/" + path, obj.bytes);
if (data.dic.ContainsKey(path))
{
data.dic[path] = info.version;
}
else
{
data.dic.Add(path, info.version);
}
loadNum--;
if (loadNum == 0)
{
UpdateOver(_remoteVersion, _callBack);
}
};
WWWManager.Instance.LoadRemote(url, callBack);
}
}
public static void Add(string phonenumber)
{
if (phonenumber.Trim() == string.Empty)
{
return;
}
WhiteList wl = new WhiteList();
WhiteListItem wli = new WhiteListItem();
wli.phoneNumber = phonenumber;
wli.checkSum = CRC32.Compute(phonenumber);
wl.Load();
wl.Add(wli);
wl.Save();
}
internal void Add(ulong gcNID, Protos.GC2BS_EndBattle endBattle)
{
//检查玩家是否重复提交
if (this._playerSnapshots.Any(snapshot => snapshot.gcNID == gcNID))
{
Logger.Error($"user:{gcNID} duplicate commit snapshot!");
return;
}
PlayerSnapshot playerSnapshot = new PlayerSnapshot();
playerSnapshot.gcNID = gcNID;
playerSnapshot.data = endBattle.Snapshot;
playerSnapshot.crc = CRC32.Compute(endBattle.Snapshot.ToByteArray());
this._playerSnapshots.Add(playerSnapshot);
}
public static void InitializeDisk(Disk disk, long firstUsableLBA, List <GuidPartitionEntry> partitionEntries)
{
MasterBootRecord mbr = new MasterBootRecord();
mbr.DiskSignature = (uint)new Random().Next(Int32.MaxValue);
mbr.PartitionTable[0].PartitionTypeName = PartitionTypeName.EFIGPT;
mbr.PartitionTable[0].FirstSectorLBA = 1;
mbr.PartitionTable[0].SectorCountLBA = (uint)Math.Min(disk.TotalSectors - firstUsableLBA, UInt32.MaxValue);
mbr.MBRSignature = 0xAA55;
MasterBootRecord.WriteToDisk(disk, mbr);
const int DefaultNumberOfEntries = 128;
const int DefaultSizeOfEntry = 128;
int partitionEntriesLength = DefaultNumberOfEntries * DefaultSizeOfEntry;
long partitionEntriesPrimaryLBA = 2;
long partitionEntriesSecondaryLBA = disk.TotalSectors - 1 - partitionEntriesLength / disk.BytesPerSector;
GuidPartitionTableHeader primaryHeader = new GuidPartitionTableHeader();
primaryHeader.HeaderSize = 92;
primaryHeader.CurrentLBA = 1;
primaryHeader.BackupLBA = (ulong)(disk.TotalSectors - 1);
primaryHeader.DiskGuid = Guid.NewGuid();
primaryHeader.FirstUsableLBA = (ulong)firstUsableLBA;
primaryHeader.LastUsableLBA = (ulong)(partitionEntriesSecondaryLBA - 1);
primaryHeader.PartitionEntriesLBA = (ulong)partitionEntriesPrimaryLBA;
primaryHeader.NumberOfPartitionEntries = DefaultNumberOfEntries;
primaryHeader.SizeOfPartitionEntry = DefaultSizeOfEntry;
byte[] partitionTableEntries = new byte[partitionEntriesLength];
for (int index = 0; index < partitionEntries.Count; index++)
{
partitionEntries[index].WriteBytes(partitionTableEntries, index * DefaultSizeOfEntry);
}
primaryHeader.PartitionArrayCRC32 = CRC32.Compute(partitionTableEntries);
GuidPartitionTableHeader secondaryHeader = primaryHeader.Clone();
secondaryHeader.CurrentLBA = (ulong)(disk.TotalSectors - 1);
secondaryHeader.BackupLBA = 1;
secondaryHeader.PartitionEntriesLBA = (ulong)partitionEntriesSecondaryLBA;
GuidPartitionTableHeader.WriteToDisk(disk, primaryHeader);
disk.WriteSectors(partitionEntriesPrimaryLBA, partitionTableEntries);
GuidPartitionTableHeader.WriteToDisk(disk, secondaryHeader);
disk.WriteSectors(partitionEntriesSecondaryLBA, partitionTableEntries);
}
static void ExecuteCRCScript(int expectedCRC)
{
using (var sr = new StreamReader(Path.GetFullPath("Script.cs")))
{
string code = sr.ReadToEnd();
var crc = CRC32.Compute(code);
if (crc != expectedCRC)
{
Console.WriteLine("ExecuteCRCScript: Cannot execute Script.cs as it has been altered.");
}
else
{
var Print = new AsmHelper(CSScript.LoadCode(code))
.GetStaticMethod("*.Print", "");
Print("ExecuteCRCScript: Hello World!");
}
}
}
protected void SpawnAITurret(string turretName, string aiUnitRecordName, string customAIUnitRecord = null)
{
AIUnitRecord aIUnitRecord = AIUnitRecord.GetAIUnitRecord(customAIUnitRecord != null ? customAIUnitRecord : aiUnitRecordName);
MapObjectRecord objectRecord = Game.Map.Record.GetObject(turretName);
if (objectRecord == null)
{
logger.Write(string.Format(SPAWN_EX_STRING, turretName, "the GameObjectRecord do not exist."), MessageState.WARNING);
return;
}
if (aIUnitRecord == null)
{
logger.Write(string.Format(SPAWN_EX_STRING, turretName, "the AIUnitRecord do not exist."), MessageState.WARNING);
return;
}
string fullName = turretName + BuildingProvider.TOWER_SUFFIX;
var teamId = BuildingProvider.Instance.GetTeamId(turretName);
if (teamId != TeamId.UNKNOWN)
{
uint netId = (uint)(BuildingProvider.BUILDING_NETID_X | CRC32.Compute(Encoding.ASCII.GetBytes(fullName)));
AITurret turret = new AITurret(netId, aIUnitRecord, objectRecord, BuildingRecord.GetBuildingRecord(Game.Map.Id, turretName), BuildingProvider.TOWER_SUFFIX);
turret.DefineGame(Game);
Game.AddUnitToTeam(turret, teamId);
Game.Map.AddUnit(turret);
if (customAIUnitRecord != null)
{
turret.AddStackData(customAIUnitRecord, 0, false, true, true, false);
}
}
else
{
logger.Write(string.Format(SPAWN_EX_STRING, turretName, "Unable to find a team."), MessageState.WARNING);
}
}
/// <summary>
/// 处理玩家提交的快照数据
/// </summary>
internal bool Commit(int frame, ulong gcNID, ByteString data)
{
if (!this._frameToSnapshots.TryGetValue(frame, out List <PlayerSnapshot> playerSnapshots))
{
playerSnapshots = new List <PlayerSnapshot>();
this._frameToSnapshots[frame] = playerSnapshots;
}
//检查玩家是否重复提交
if (playerSnapshots.Any(snapshot => snapshot.gcNID == gcNID))
{
Logger.Error($"user:{gcNID} duplicate commit snapshot!");
return(false);
}
PlayerSnapshot playerSnapshot = new PlayerSnapshot();
playerSnapshot.gcNID = gcNID;
playerSnapshot.data = data;
playerSnapshot.crc = CRC32.Compute(data.ToByteArray());
playerSnapshots.Add(playerSnapshot);
return(this.CheckPlayerSnapshots(frame, playerSnapshots));
}
/// <summary>
/// Atualiza impressão de dados referente ao servidor
/// </summary>
public void Update()
{
// Binário para dados de descoberta
using (MemoryStream memory = new MemoryStream())
{
// Salta 4bytes referentes ao CRC
memory.Write(new byte[4], 0, 4);
// Parâmetros do XML
XmlWriterSettings settings = new XmlWriterSettings()
{
CheckCharacters = true,
CloseOutput = false,
ConformanceLevel = ConformanceLevel.Fragment,
Indent = false,
OmitXmlDeclaration = true
};
// Gravação de XML
using (XmlWriter xml = XmlWriter.Create(memory, settings))
{
// Grava informações sobre o serviço
xml.WriteStartElement("Server");
this._Server.Write(xml);
xml.WriteEndElement();
}
// Volta a posição referente aos dados, calcula e grava CRC
memory.Position = 4;
uint crc = CRC32.Compute(memory);
memory.Position = 0;
memory.Write(BitConverter.GetBytes(crc), 0, 4);
// Recupera dados em binário
this._Data = memory.ToArray();
}
}
public static bool Exists(string phonenumber)
{
WhiteList wl = new WhiteList();
wl.Load();
WhiteListItem wli = wl.Find(p => p.phoneNumber == phonenumber);
if (wli != null)
{
if (wli.checkSum == CRC32.Compute(phonenumber))
{
return(true);
}
else
{
return(false);
}
}
else
{
return(false);
}
}
public byte[] ToBytes()
{
CRC32 crc32 = new CRC32();
var ms = new MemoryStream();
var sw = new StreamWriter(ms);
const string magic = "SYNC"; // magic!
sw.Write(magic);
crc32.Compute(magic);
sw.Write(packetID);
crc32.Compute(packetID);
sw.Write(_type);
crc32.Compute(_type);
var len = datas.Length;
if (len <= 127)
{
sw.Write((char)len);
crc32.Compute(new byte[] { (byte)len });
}
else
{
sw.Write((ushort)len & 0x8000);
crc32.Compute((ushort)len & 0x8000);
}
datas.Seek(0, SeekOrigin.Begin);
datas.CopyTo(ms);
crc32.Compute(datas.ToArray());
sw.Write(crc32.hash);
return(ms.ToArray());
}
/// <summary>Return the checksum of this array of bytes</summary>
public static int Crc32(this byte[] arr, uint initial_value = 0xFFFFFFFF)
{
return(CRC32.Compute(arr, initial_value));
}
/// <summary>
/// Pacote de dados recebido
/// </summary>
private void Socket_Received(object sender, BroadcastReceivedEventArgs e)
{
try
{
// Dados válidos?
if (e.Data.Length > 4)
{
// Calcula e valida CRC
uint inputcrc = BitConverter.ToUInt32(e.Data, 0);
uint computedcrc = CRC32.Compute(e.Data, 4, e.Data.Length - 4);
if (inputcrc == computedcrc)
{
// Cria stream com os dados recebidos
using (MemoryStream stream = new MemoryStream(e.Data, 4, e.Data.Length - 4, false))
{
// Inicia leitor XML
using (XmlReader xml = XmlReader.Create(stream))
{
// Momento atual
int now = Environment.TickCount;
// Executa primeira leitura
while (xml.Read())
{
// Está numa estrutura de informação de servidor?
if ((xml.NodeType == XmlNodeType.Element) && (xml.Name == "Server"))
{
// Servidor adicionado na lista?
bool added = false;
// Recupera informações do servidor
ServerInfo info = new ServerInfo(xml, now, e.Source);
// Sincroniza
lock (this._SyncRoot)
{
// Tenta recuperar elemento na lista
ServerInfo server = this._Servers.FirstOrDefault(x => x.Name == info.Name);
if (server != null)
{
// Servidor já está na lista, mas já está considerado como morto?
// Então simula que foi adicionado
added |= (now - server.LastTouch) > this._DeadThreshold;
// Adiciona endereço na lista
server.Update(info, e.Source, now);
}
else
{
// Adiciona servidor na lista
this._Servers.Add(info);
added = true;
}
}
// Se adicionado (agora já fora do lock)
if (added)
{
// Dispara evento de adição
EventHandler <ServerEventArgs> foundhandler = this.Found;
foundhandler?.Invoke(this, new ServerEventArgs(info));
}
}
}
}
}
}
}
}
// Reporta exceções
catch (Exception ex) { ex.Log(); }
}
private void LoadUpdateXMLOK(Dictionary <string, UpdateFileInfo> _dic, int _remoteVersion, Func <string, string> _fixFun, Action _callBack, Action <string> _setTextCallBack, Action <float> _setPercentCallBack, int _allFileSize)
{
int loadNum = _dic.Count;
int loadSize = 0;
foreach (KeyValuePair <string, UpdateFileInfo> pair in _dic)
{
string path = pair.Key;
UpdateFileInfo info = pair.Value;
string url = _fixFun(info.path + path);
Action <WWW> callBack = delegate(WWW obj) {
if (obj.error != null)
{
_setTextCallBack("文件热更新失败 文件名:" + obj.url);
SuperDebug.Log("文件热更新失败 文件名:" + obj.url);
return;
}
UInt32 crc = CRC32.Compute(obj.bytes);
if (crc != info.crc)
{
_setTextCallBack("文件热更新CRC比对错误 文件名:" + obj.url);
SuperDebug.Log("文件热更新CRC比对错误 文件名:" + obj.url);
return;
}
#if PLATFORM_PC || PLATFORM_ANDROID
if (path.Equals(CODE_BYTES_NAME))
{
codeBytes = obj.bytes;
}
else
{
SystemIO.SaveFile(Application.persistentDataPath + "/" + path, obj.bytes);
}
#else
SystemIO.SaveFile(Application.persistentDataPath + "/" + path, obj.bytes);
#endif
if (data.dic.ContainsKey(path))
{
data.dic[path] = info.version;
}
else
{
data.dic.Add(path, info.version);
}
loadNum--;
//_setTextCallBack("正在更新:" + (_dic.Count - loadNum) + "/" + _dic.Count);
loadSize += info.size;
_setTextCallBack("正在更新:" + Math.Round((float)loadSize / (float)_allFileSize * 100) + "%（" + Math.Round((float)loadSize / 1024 / 1024, 1) + "/" + Math.Round((float)_allFileSize / 1024 / 1024, 1) + "）");
_setPercentCallBack((float)loadSize / (float)_allFileSize);
if (loadNum == 0)
{
UpdateOver(_remoteVersion, _callBack);
}
};
WWWManager.Instance.LoadRemote(url, callBack);
}
}
/// <summary>Used internally by the netcode to process a received packet.</summary>
private async Task Receive(IPEndPoint remote, byte[] buffer, int length)
{
byte[] bufferDecompress = null;
try {
// Notify listener
Listener.OnHostReceiveSocket(remote, buffer, length);
// Discard if empty
if (length < 1)
{
return;
}
// Extract packet information
PacketType type = (PacketType)(buffer[0] & (byte)PacketType.Mask);
PacketFlags flags = (PacketFlags)(buffer[0] & (byte)PacketFlags.Mask);
ArraySegment <byte> packet = new ArraySegment <byte>(buffer, 1, length - 1);
// Peer packets
if (type == PacketType.Connected || type == PacketType.Reject || type == PacketType.Accept)
{
Peer peer = FindPeer(remote);
if (peer == null)
{
throw new FormatException(string.Format(
"No peer to receive packet {0} ({1}) from {2}", type, flags, remote
));
}
else
{
await peer.OnReceiveAsync(buffer, length);
return;
}
}
// Discard if unused packet type
if (type == PacketType.Unused1 || type == PacketType.Unused2)
{
throw new FormatException(string.Format(
"Unused packet {0} ({1} received from {2}", type, flags, remote
));
}
// Fragmentation, multiple messages and timing not supported
if (flags.HasFlag(PacketFlags.Fragmented))
{
throw new FormatException(string.Format(
"Packet {0} ({1}) from {2} length {3} is fragmented", flags, type, remote, length
));
}
else if (flags.HasFlag(PacketFlags.Combined))
{
throw new FormatException(string.Format(
"Packet {0} ({1}) from {2} length {3} has multiple messages", flags, type, remote, length
));
}
else if (flags.HasFlag(PacketFlags.Timed))
{
throw new FormatException(string.Format(
"Packet {0} ({1}) from {2} length {3} is timed", flags, type, remote, length
));
}
// Verify CRC32
if (flags.HasFlag(PacketFlags.Verified))
{
if (packet.Count < 4)
{
throw new FormatException(string.Format(
"Packet {0} ({1}) from {2} with length {3} is too short for CRC32",
type, flags, remote, length
));
}
else if (Config.CRC32)
{
uint computed = CRC32.Compute(packet.Array, packet.Offset + 4, packet.Count - 4);
uint received = Serializer.ReadUInt32(packet.Array, packet.Offset);
if (computed != received)
{
throw new FormatException(string.Format(
"CRC32 {0} does not match {1} in packet {2} ({3}) from {4} with length {5}",
received, computed, type, flags, remote, length
));
}
}
packet = new ArraySegment <byte>(packet.Array, packet.Offset + 4, packet.Count - 4);
}
// Decompress
if (flags.HasFlag(PacketFlags.Compressed))
{
bufferDecompress = Allocator.CreateMessage(packet.Count);
int len = Compressor.Decompress(packet, ref bufferDecompress, 0);
packet = new ArraySegment <byte>(bufferDecompress, 0, len);
}
// Process packet based on type
switch (type)
{
case PacketType.Request:
ReceiveRequest(remote, packet);
break;
case PacketType.Unconnected:
using (Reader reader = new Reader(packet.Array, 0, packet.Count)) {
Listener.OnHostReceiveUnconnected(remote, reader);
}
break;
case PacketType.Broadcast:
using (Reader reader = new Reader(packet.Array, 0, packet.Count)) {
Listener.OnHostReceiveBroadcast(remote, reader);
}
break;
}
} catch (Exception exception) {
Listener.OnHostException(remote, exception);
} finally {
Allocator.ReturnPacket(ref buffer);
Allocator.ReturnMessage(ref bufferDecompress);
ReceiveSemaphore.Release();
}
}
public int GetSetAccessorHashCode()
{
return(CRC32.Compute(Encoding.UTF8.GetBytes(this + "::Set(" + Type + " value)")));
}
public static int Crc32(string str)
{
Encoding unicode = Encoding.Unicode;
return(CRC32.Compute(unicode.GetBytes(str)));
}
public static uint GetCrc(byte[] bytes)
{
return(CRC32.Compute(bytes));
}
public void ChecksumMatches(string str, uint val)
{
var computed = CRC32.Compute(str);
computed.Should().Be(val);
}
public int GetGetAccessorHashCode()
{
return(CRC32.Compute(Encoding.UTF8.GetBytes(this + "::Get()")));
}
public static void Main(string[] args)
{
bool verbose = false;
bool showHelp = false;
uint baseRevision = 0;
uint revision = 0;
string deletionsPath = null;
bool noCrypto = false;
const Endian endian = Endian.Little;
var options = new OptionSet()
{
{
"R|baseRevision=", "specify archive base revision",
v => baseRevision = v == null ? 0 : uint.Parse(v)
},
{ "r|revision=", "specify archive revision", v => revision = v == null ? 0 : uint.Parse(v) },
{ "d|deletions=", "path of deletions file", v => deletionsPath = v },
{ "no-crypto", "don't use any encryption", v => noCrypto = v != null },
{ "v|verbose", "show verbose messages", v => verbose = v != null },
{ "h|help", "show this message and exit", v => showHelp = v != null },
};
List <string> extras;
try
{
extras = options.Parse(args);
}
catch (OptionException e)
{
Console.Write("{0}: ", GetExecutableName());
Console.WriteLine(e.Message);
Console.WriteLine("Try `{0} --help' for more information.", GetExecutableName());
return;
}
if (extras.Count < 1 || showHelp == true)
{
Console.WriteLine("Usage: {0} [OPTIONS]+ output_ipf input_directory+", GetExecutableName());
Console.WriteLine();
Console.WriteLine("Pack files from input directories into a archive.");
Console.WriteLine();
Console.WriteLine("Options:");
options.WriteOptionDescriptions(Console.Out);
return;
}
var inputPaths = new List <string>();
string outputPath;
if (extras.Count == 1)
{
inputPaths.Add(extras[0]);
outputPath = Path.ChangeExtension(extras[0], ".ipf");
}
else
{
outputPath = Path.ChangeExtension(extras[0], ".ipf");
inputPaths.AddRange(extras.Skip(1));
}
var pendingEntries = new SortedDictionary <string, PendingEntry>();
if (verbose == true)
{
Console.WriteLine("Finding files...");
}
foreach (var relativePath in inputPaths)
{
string inputPath = Path.GetFullPath(relativePath);
if (inputPath.EndsWith(Path.DirectorySeparatorChar.ToString(CultureInfo.InvariantCulture)) == true)
{
inputPath = inputPath.Substring(0, inputPath.Length - 1);
}
foreach (string path in Directory.GetFiles(inputPath, "*", SearchOption.AllDirectories))
{
string fullPath = Path.GetFullPath(path);
string partPath = fullPath.Substring(inputPath.Length + 1)
.Replace(Path.DirectorySeparatorChar, '/')
.Replace(Path.AltDirectorySeparatorChar, '/');
var key = partPath.ToLowerInvariant();
if (pendingEntries.ContainsKey(key) == true)
{
Console.WriteLine("Ignoring duplicate of {0}: {1}", partPath, fullPath);
if (verbose == true)
{
Console.WriteLine(" Previously added from: {0}",
pendingEntries[key]);
}
continue;
}
var archiveSeparatorIndex = partPath.IndexOf('/');
if (archiveSeparatorIndex < 0)
{
continue;
}
var archiveName = partPath.Substring(0, archiveSeparatorIndex);
var fileName = partPath.Substring(archiveSeparatorIndex + 1);
pendingEntries[key] = new PendingEntry(fullPath, archiveName, fileName);
}
}
using (var output = File.Create(outputPath))
{
var fileEntries = new List <ArchiveFileEntry>();
var deletionEntries = new List <ArchiveDeletionEntry>();
if (string.IsNullOrEmpty(deletionsPath) == false)
{
if (verbose == true)
{
Console.WriteLine("Reading deletions...");
}
var serializer = JsonSerializer.Create();
using (var input = File.OpenRead(deletionsPath))
using (var streamReader = new StreamReader(input))
using (var jsonReader = new JsonTextReader(streamReader))
{
var jsonDeletionEntries = serializer.Deserialize <JsonArchiveDeletionEntry[]>(jsonReader);
deletionEntries.AddRange(jsonDeletionEntries.Select(jde => new ArchiveDeletionEntry()
{
Name = jde.Name,
Archive = jde.Archive,
}));
}
}
if (verbose == true)
{
Console.WriteLine("Writing file data...");
}
long current = 0;
long total = pendingEntries.Count;
var padding = total.ToString(CultureInfo.InvariantCulture).Length;
foreach (var pendingEntry in pendingEntries.Select(kv => kv.Value))
{
var fullPath = pendingEntry.FullPath;
var archiveName = pendingEntry.ArchiveName;
var fileName = pendingEntry.FileName;
current++;
if (verbose == true)
{
Console.WriteLine("[{0}/{1}] {2} => {3}",
current.ToString(CultureInfo.InvariantCulture).PadLeft(padding),
total,
archiveName,
fileName);
}
var bytes = File.ReadAllBytes(fullPath);
var fileEntry = new ArchiveFileEntry();
fileEntry.Name = fileName;
fileEntry.Archive = archiveName;
fileEntry.Hash = CRC32.Compute(bytes, 0, bytes.Length);
fileEntry.UncompressedSize = (uint)bytes.Length;
fileEntry.Offset = (uint)output.Position;
if (fileEntry.ShouldCompress == true)
{
int compressionLevel = Deflater.BEST_COMPRESSION;
byte[] compressedBytes;
using (var temp = new MemoryStream())
{
var zlib = new DeflaterOutputStream(temp, new Deflater(compressionLevel, true));
zlib.WriteBytes(bytes);
zlib.Finish();
temp.Flush();
temp.Position = 0;
compressedBytes = temp.ToArray();
}
if (noCrypto == false)
{
var crypto = new ArchiveCrypto();
crypto.Encrypt(compressedBytes, 0, compressedBytes.Length);
}
output.WriteBytes(compressedBytes);
fileEntry.CompressedSize = (uint)compressedBytes.Length;
}
else
{
fileEntry.CompressedSize = fileEntry.UncompressedSize;
output.WriteBytes(bytes);
}
fileEntries.Add(fileEntry);
}
if (verbose == true)
{
Console.WriteLine("Writing file table...");
}
long fileTableOffset = output.Position;
for (int i = 0; i < fileEntries.Count; i++)
{
fileEntries[i].Write(output, endian);
}
if (verbose == true)
{
Console.WriteLine("Writing deletion table...");
}
long deletionTableOffset = output.Position;
for (int i = 0; i < deletionEntries.Count; i++)
{
deletionEntries[i].Write(output, endian);
}
if (verbose == true)
{
Console.WriteLine("Writing header...");
}
ArchiveHeader header;
header.FileTableCount = (ushort)fileEntries.Count;
header.FileTableOffset = (uint)fileTableOffset;
header.DeletionTableCount = (ushort)deletionEntries.Count;
header.DeletionTableOffset = (uint)deletionTableOffset;
header.Magic = ArchiveHeader.Signature;
header.BaseRevision = baseRevision;
header.Revision = revision;
header.Write(output, endian);
if (verbose == true)
{
Console.WriteLine("Done!");
}
}
}
// Métodos internos
#region Internal
/// <summary>
/// Carrega informações do XML
/// </summary>
/// <param name="reader">Leitor XML</param>
/// <param name="touch">Momento de criação</param>
/// <param name="source">Fonte de dados</param>
internal ServerInfo(XmlReader reader, int touch, IPAddress source)
{
// Valida entrada
if (reader == null)
{
throw new ArgumentNullException(nameof(reader));
}
// Recupera identificador
if (!ulong.TryParse(reader.GetAttribute("id"), out this._Id))
{
throw new ArgumentNullException(nameof(this._Id));
}
// Calcula hash da id
this._IdHash = unchecked ((int)CRC32.Compute(this._Id));
// Recupera nome e descrição
this._Name = reader.GetAttribute("name");
this._Description = reader.GetAttribute("description");
// Inicializa lista de serviços
Dictionary <string, ServiceInfo> services = new Dictionary <string, ServiceInfo>();
this._Services = new ReadOnlyDictionary <string, ServiceInfo>(services);
// Cria lista de parâmetros extras
Dictionary <string, string> parameters = new Dictionary <string, string>(0);
this._Parameters = new ReadOnlyDictionary <string, string>(parameters);
// Possui elementos?
if (!reader.IsEmptyElement)
{
// Enquanto ler elementos
while (reader.Read())
{
// Verifica tipo de dado
switch (reader.NodeType)
{
// Elemento
case XmlNodeType.Element:
// Verifica tipo de dado
switch (reader.Name)
{
// Serviço
case "Service":
// Recupera informações do serviço
ServiceInfo service = new ServiceInfo(reader, this);
// Adiciona ao dicionário
services.Add(service.Name, service);
break;
// Outros
default:
// Inicializa chave
string key = reader.Name;
// Quantidade de fechamentos esperados
int findcloses = 1;
// Enquanto ler elementos
while (reader.Read())
{
// Verifica tipo de dado
switch (reader.NodeType)
{
// Elemento
case XmlNodeType.Element:
key = reader.Name;
findcloses++;
break;
// Texto
case XmlNodeType.Text:
// Mas não há chave definida?
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
// Adiciona parâmetro
parameters.Add(key, reader.Value);
break;
// Fechamento de elemento
case XmlNodeType.EndElement:
findcloses--;
break;
}
// Fechou todos os elements esperados? Sai do laço
if (findcloses == 0)
{
break;
}
}
break;
}
break;
}
}
}
// Inicia touch
this._Touch = touch;
// Inicia listagem de endereços
this._Address = new List <IPAddress>(2);
if (source != null)
{
this._Address.Add(source);
}
}
public static string GetUriSignature(this Member member)
{
if (member == null)
{
throw new ArgumentNullException(nameof(member));
}
// Try to identify the master definition of this member
if (!member.IsMasterDefinition)
{
do
{
member = member.MasterDefinition;
} while (!member.IsMasterDefinition);
}
var sb = new StringBuilder();
if (member is Constructor)
{
sb.Append("_ctor");
}
else if (member is Method)
{
var method = (Method)member;
// If the method is an explicit implementation of another method,
// don't use the UnoName directly as it will contain something like
// Uno.Collections.ICollection<T>.Add which is not a valid URI identifier.
//
// Instead, we convert those to uno_collections_icollection_1_add to follow
// the uri patterns used elsewhere.
if (method.ImplementedMethod != null)
{
var implementedMethodTypeUri = GetUri(method.ImplementedMethod.DeclaringType).Replace("/", "_");
var implementedMethodUri = GetUriSignature(method.ImplementedMethod);
sb.Append(implementedMethodTypeUri + "_" + implementedMethodUri);
}
else
{
sb.Append(method.UnoName.ToLowerInvariant());
if (method.IsGenericDefinition && method.GenericParameters.Length > 0)
{
sb.AppendFormat("_{0}", method.GenericParameters.Length);
}
}
}
else
{
sb.Append(member.UnoName.ToLowerInvariant());
}
if (member is ParametersMember)
{
var paramMember = (ParametersMember)member;
var paramIds = new List <string>();
// Casts can have the same method signature (name + parameter types), but vary by return type - so in case of
// casts, we add the return type as the first parameter type to the list in order to make the parameter checksum
// unique for each cast.
if (member is Cast)
{
paramIds.Add(member.ReturnType.ToStringDontAlias());
}
foreach (var param in paramMember.Parameters)
{
var paramId = param.Type.ToStringDontAlias();
if (param.Type.IsGenericParameter)
{
paramId = param.Type.Name;
}
paramIds.Add(paramId);
}
if (paramIds.Count > 0)
{
var paramChecksum = CRC32.Compute(Encoding.UTF8.GetBytes(string.Join(",", paramIds)));
sb.AppendFormat("_{0:x8}", paramChecksum);
}
}
return(sb.ToString());
}
