public virtual PackageHeader CreatePackageHeader(byte[] data, int offset, int length)
{
#if DEBUG_CORE
Debug.Log("[PackageFactory CreatePackageHeader] create package header start", Unity.Debug.LogLevel.Socket);
#endif
if (length >= HeaderSize())
{
PackageHeader head = new PackageHeader();
if (head.Unserial(data, offset))
{
#if DEBUG_CORE
Debug.Log("[PackageFactory CreatePackageHeader] create package header success", Unity.Debug.LogLevel.Socket);
#endif
return(head);
}
}
#if DEBUG_CORE
Debug.Log("[PackageFactory CreatePackageHeader] create package header failed", Unity.Debug.LogLevel.Socket);
#endif
return(null);
}
public void Add(
string name,
int packageDuesInMonth,
bool isActive,
bool isOpenEnd,
decimal freezeFee,
IEnumerable <PackageDetailViewModel> detail)
{
var head = new PackageHeader();
head.Name = name;
head.PackageDuesInMonth = packageDuesInMonth;
head.IsActive = isActive;
head.OpenEnd = isOpenEnd;
head.FreezeFee = freezeFee;
EntityHelper.SetAuditFieldForInsert(head, principal.Identity.Name);
context.Add(head);
foreach (PackageDetailViewModel detailLine in detail)
{
var obj = new PackageDetail();
obj.ItemID = detailLine.ItemID;
obj.PackageID = detailLine.PackageID;
obj.Quantity = detailLine.Quantity;
obj.UnitPrice = detailLine.UnitPrice;
obj.UnitName = detailLine.UnitName;
obj.PackageHeader = head;
context.Add(obj);
}
context.SaveChanges();
}
public static void GenerateHashlist(string workingPath, PackageDatabase bundleDB)
{
List <string> bundles = Directory.EnumerateFiles(workingPath, "all_*.bundle").ToList();
foreach (string file in bundles)
{
if (file.EndsWith("_h.bundle"))
{
continue;
}
PackageHeader bundle = new PackageHeader(file);
foreach (PackageFileEntry be in bundle.Entries)
{
DatabaseEntry ne = bundleDB.EntryFromID(be.ID);
if (ne == null)
{
continue;
}
if (ne._path == 0x9234DD22C60D71B8 && ne._extension == 0x9234DD22C60D71B8)
{
GenerateHashlist(workingPath, Path.Combine(workingPath, file.Replace("_h", "")), be);
return;
}
}
}
}
public void Update(
int id,
string name,
int packageDuesInMonth,
bool isActive,
bool isOpenEnd,
decimal freezeFee,
IEnumerable <PackageDetailViewModel> detail)
{
context.Delete(
context.PackageDetails.Where(row => row.PackageID == id));
PackageHeader head = context.PackageHeaders.Single(row => row.ID == id);
head.Name = name;
head.PackageDuesInMonth = packageDuesInMonth;
head.IsActive = isActive;
head.OpenEnd = isOpenEnd;
head.FreezeFee = freezeFee;
EntityHelper.SetAuditFieldForUpdate(head, principal.Identity.Name);
foreach (PackageDetailViewModel detailLine in detail)
{
var obj = new PackageDetail();
obj.ItemID = detailLine.ItemID;
obj.PackageID = detailLine.PackageID;
obj.Quantity = detailLine.Quantity;
obj.UnitPrice = detailLine.UnitPrice;
obj.UnitName = detailLine.UnitName;
obj.PackageHeader = head;
context.Add(obj);
}
context.SaveChanges();
}
/// <summary>
/// Closes the package, optionally leaving the output stream open.
/// </summary>
/// <param name="leaveOutputOpen"><c>true</c> to leave the output stream open.</param>
public void Close(bool leaveOutputOpen)
{
if (packageOut != null)
{
// Append the terminating entry.
new PackageEntry(this).Serialize(packageOut);
// Before we close the package, we need to compute the MD5
// hash of everything after the header in the output stream
// and update the hash in the header.
var header = new PackageHeader();
packageOut.Position = cbHeader;
header.Hash = MD5Hasher.Compute(packageOut, packageOut.Length - cbHeader);
packageOut.Position = 0;
header.Seralize(packageOut);
if (!leaveOutputOpen)
{
packageOut.Close();
}
packageOut = null;
}
if (packageIn != null)
{
packageIn.Close();
packageIn = null;
}
}
/// <summary>
/// Saves this instance, aka overwrites the file header.
/// </summary>
public void Save()
{
var head = new FileHeader
{
Signature = PackCommon.Header,
Revision = (uint)Revision,
EntryCount = Count,
Path = Root,
Ft1 = Created.ToFileTime(),
Ft2 = Modified.ToFileTime()
};
var pkgHead = new PackageHeader
{
EntryCount = Count,
InfoHeaderSize = 0,
DataSectionSize = (uint)(_source.Length - _dataStart),
BlankSize = 0,
Zero = new byte[16]
};
var infos = new List <Tuple <byte[], PackageItemInfo> >();
foreach (var e in _entries.Values)
{
var info = new PackageItemInfo
{
CompressedSize = e.SizeInPack,
DecompressedSize = e.DecompressedSize,
IsCompressed = e.IsCompressed,
Offset = (uint)e.DataOffset,
Seed = e.CryptoSeed,
CreationTime = e.CreatedDate.ToFileTime(),
CreationTime2 = e.CreatedDate.ToFileTime(),
LastAccessTime = e.AccessDate.ToFileTime(),
ModifiedTime = e.ModifiedDate.ToFileTime(),
ModifiedTime2 = e.ModifiedDate.ToFileTime(),
};
var bytes = PackCommon.EncodeName(e.Name.PadRight(e.MaxNameLength, '\0'));
infos.Add(Tuple.Create(bytes, info));
pkgHead.InfoHeaderSize += bytes.Length + StructUtil.SizeOf <PackageItemInfo>();
}
pkgHead.BlankSize = (int)(_dataStart -
(StructUtil.SizeOf <FileHeader>() + StructUtil.SizeOf <PackageHeader>() +
pkgHead.InfoHeaderSize));
pkgHead.InfoHeaderSize += pkgHead.BlankSize;
_source.Position = 0;
head.WriteToStream(_source);
pkgHead.WriteToStream(_source);
foreach (var i in infos)
{
_source.Write(i.Item1, 0, i.Item1.Length);
i.Item2.WriteToStream(_source);
}
}
public void Update(
int id,
string name,
int packageDuesInMonth,
bool isActive,
bool isOpenEnd,
decimal freezeFee,
IEnumerable <PackageDetailViewModel> detail)
{
ctx.PackageDetails.DeleteAllOnSubmit(
ctx.PackageDetails.Where(row => row.PackageID == id));
PackageHeader head = ctx.PackageHeaders.Single(row => row.ID == id);
head.Name = name;
head.PackageDuesInMonth = packageDuesInMonth;
head.IsActive = isActive;
head.OpenEnd = isOpenEnd;
head.FreezeFee = freezeFee;
EntityHelper.SetAuditFieldForUpdate(head, HttpContext.Current.User.Identity.Name);
foreach (PackageDetailViewModel item in detail)
{
PackageDetail obj = new PackageDetail();
obj.ItemID = item.ItemID;
obj.PackageID = item.PackageID;
obj.Quantity = item.Quantity;
obj.UnitPrice = item.UnitPrice;
head.PackageDetails.Add(obj);
ctx.PackageDetails.InsertOnSubmit(obj);
}
ctx.SubmitChanges();
}
protected void gvwMaster_RowCommand(object sender, GridViewCommandEventArgs e)
{
try
{
if (e.CommandName == "EditRow")
{
int id = Convert.ToInt32(e.CommandArgument);
RowID = id;
mvwForm.SetActiveView(viwAddEdit);
PackageHeader package = packageProvider.Get(id);
ddlDuesInMonth.SelectedValue = package.PackageDuesInMonth.ToString();
txtName.Text = package.Name;
chkIsActive.Checked = package.IsActive;
Detail = packageProvider.GetDetail(id).ToList();
chkOpenEnd.Checked = package.OpenEnd;
txtFreezeFee.Text = Convert.ToString(package.FreezeFee);
RefreshDetail();
txtName.Focus();
}
else if (e.CommandName == "DefineClass")
{
int id = Convert.ToInt32(e.CommandArgument);
RowID = id;
mvwForm.SetActiveView(viwAddEdit2);
RefreshActiveClassInPackages();
}
}
catch (Exception ex)
{
mvwForm.SetActiveView(viwRead);
WebFormHelper.SetLabelTextWithCssClass(lblMessage, ex.Message, LabelStyleNames.ErrorMessage);
}
}
public void PrintMigratedWithFailure(PackageHeader oldPkg, PackageHeader newPkg,
Dictionary <string, object> oldProperties, Dictionary <string, object> newProperties)
{
XmlElement pkg = result.CreateElement("package");
XmlAttribute name = result.CreateAttribute("name");
name.Value = oldPkg.name;
pkg.Attributes.Append(name);
result.SelectSingleNode("PackagesMigrationReport/MigratedWithFailure").AppendChild(pkg);
XmlElement oldPs = result.CreateElement("oldProperties");
XmlElement newPs = result.CreateElement("newProperties");
foreach (KeyValuePair <string, object> entry in oldProperties)
{
XmlElement prop = result.CreateElement(entry.Key);
XmlAttribute oldVal = result.CreateAttribute("oldValue");
XmlAttribute newVal = result.CreateAttribute("newValue");
oldVal.Value = entry.Value.ToString();
newVal.Value = newProperties[entry.Key].ToString();
prop.Attributes.Append(oldVal);
prop.Attributes.Append(newVal);
pkg.AppendChild(prop);
}
result.Save(resultXmlPath);
}
//package unserial
public Package CreatePackage(byte[] data, int offset, int length)
{
#if DEBUG_CORE
Debug.Log("[PackageFactory CreatePackage] create package start, length:" + length.ToString(), Unity.Debug.LogLevel.Socket);
#endif
if (data.Length >= (offset + length))
{
PackageHeader header = this.CreatePackageHeader(data, offset, length);
if (header != null && (length - HeaderSize()) >= header.Length)
{
int dataLen = header.Length;
#if DEBUG_CORE
Debug.Log("[PackageFactory CreatePackage] create package success, message id: " + header.MessageId.ToString() + " body length:" + header.Length.ToString(), Unity.Debug.LogLevel.Socket);
#endif
Package p = this.CreatePackage();
p.Header = header;
p.Data = new byte[dataLen]; //必须提交取出header.Length,因在把其设置到package时，它的Length会被旧data重写
Array.Copy(data, offset + HeaderSize(), p.Data, 0, header.Length);
return(p);
}
}
#if DEBUG_CORE
Debug.Log("[PackageFactory CreatePackage] create package failed", Unity.Debug.LogLevel.Socket);
#endif
return(null);
}
public void BuildEntries(PackageHeader header, PackageDatabase db)
{
this.treeBundleEntries.Children.Clear();
this.treeReferenceEntries.Children.Clear();
this.ClearEntryFields();
this.Title = String.Format("{0} - Bundle Inspector", header.Name.ToString());
this.lookup_db = db;
foreach (PackageFileEntry entry in header.Entries)
{
DatabaseEntry db_ent = db.EntryFromID(entry.ID);
string path = db_ent != null?General.GetFullFilepath(db_ent, db) : entry.ID.ToString();
this.treeBundleEntries.Children.Add(
new TreeItem {
Text = path, Tag = entry
}
);
}
foreach (PackageFooterEntry entry in header.References)
{
this.treeReferenceEntries.Children.Add(
new TreeItem {
Text = String.Format("{0}.{1}", entry.Path.ToString(), entry.Extension.ToString()), Tag = entry
}
);
}
}
/// <summary>
/// Writes a package header with a zeroed MD5 hash. We'll come back
/// and update this when we compute the hash during <see cref="Close()" />.
/// </summary>
private void Create()
{
var header = new PackageHeader();
packageOut.SetLength(0);
header.Seralize(packageOut);
cbHeader = (int)packageOut.Position;
}
public void LoadPackages(string filename)
{
this.CurrentProgressString = "Beginning Operation";
this.PackageHeaders = new SortedDictionary <Idstring, PackageHeader>();
this.CurrentProgressString = "Loading Existing Hashes";
App.Instance.LoadHashlists();
this.CurrentProgressString = "Loading Database";
//Load Bundle Database
this.BundleDB = new PackageDatabase(filename);
this.CurrentProgressString = "Loading Hashlist";
General.LoadHashlist(this.WorkingDirectory, this.BundleDB);
this.CurrentProgressString = "Registering File Entries";
Dictionary <uint, FileEntry> fileEntries = this.DatabaseEntryToFileEntry(this.BundleDB.GetDatabaseEntries());
this.CurrentProgressString = "Loading Packages";
List <string> files = Directory.EnumerateFiles(this.WorkingDirectory, "*.bundle").ToList();
for (int i = 0; i < files.Count; i++)
{
string file = files[i];
if (file.EndsWith("_h.bundle"))
{
continue;
}
PackageHeader bundle = new PackageHeader();
if (!bundle.Load(file))
{
continue;
}
this.CurrentProgressString = String.Format("Loading Package {0}/{1}", i, files.Count);
this.AddBundleEntriesToFileEntries(fileEntries, bundle.Entries);
this.PackageHeaders.Add(bundle.Name, bundle);
}
this.CurrentProgressString = "Registring Folder Layout";
this.Root = new FolderItem(fileEntries)
{
Path = "assets", Name = "assets"
};
foreach (FileEntry entry in fileEntries.Values)
{
this.RawFiles.Add(new Tuple <Idstring, Idstring, Idstring> (entry._path, entry._language, entry._extension), entry);
}
this.finishedLoad = true;
HashIndex.Clear();
GC.Collect();
this.CurrentProgressString = "Finishing";
}
public void ExtractBundle(PackageHeader bundle, string bundle_id)
{
string bundle_file = Path.Combine(StaticStorage.settings.AssetsFolder, bundle_id + ".bundle");
if (!File.Exists(bundle_file))
{
string error_message = "Bundle file does not exist.";
MessageBox.Show(error_message);
TextWriteLine(error_message);
return;
}
using (FileStream fs = new FileStream(bundle_file, FileMode.Open, FileAccess.Read))
{
using (BinaryReader br = new BinaryReader(fs))
{
for (; current_bundle_progress < current_bundle_total_progress; current_bundle_progress++)
{
PackageFileEntry be = bundle.Entries[(int)current_bundle_progress];
if (this.terminate)
{
break;
}
string path = Path.Combine(extract_folder, this.GetFileName(be));
if (StaticStorage.settings.IgnoreExistingFiles && File.Exists(path))
{
continue;
}
string folder = Path.GetDirectoryName(path);
if (!String.IsNullOrWhiteSpace(folder) && !Directory.Exists(folder))
{
Directory.CreateDirectory(folder);
}
if (be.Length == 0 && File.Exists(path))
{
continue;
}
fs.Position = be.Address;
byte[] data;
if (be.Length == -1)
{
data = br.ReadBytes((int)(fs.Length - fs.Position));
}
else
{
data = br.ReadBytes((int)be.Length);
}
File.WriteAllBytes(path, data);
}
}
}
}
protected byte[] AddHeader(byte[] data)
{
byte[] re;
int length = data.Length;
byte[] len = ByteConverter.Int2Byte(length);
re = PackageHeader.Concat(len).Concat(data).ToArray();
return(re);
}
public void TestViewPackageDetailsCommand()
{
// Arrange
string packageToOpen = "Sample View Extension";
List <User> packageAuthor = new List <User> {
new User {
_id = "1", username = "******"
}
};
string packageDescription = "Dynamo sample view extension.";
PackageDetailsViewExtension.PackageManagerClientViewModel = ViewModel.PackageManagerClientViewModel;
PackageHeader packageHeader = new PackageHeader
{
_id = null,
name = packageToOpen,
versions = PackageVersions,
latest_version_update = System.DateTime.Now,
num_versions = PackageVersions.Count,
comments = null,
num_comments = 0,
latest_comment = null,
votes = 0,
downloads = 0,
repository_url = null,
site_url = null,
banned = false,
deprecated = false,
@group = null,
engine = null,
license = null,
used_by = null,
host_dependencies = Hosts,
num_dependents = 0,
description = packageDescription,
maintainers = packageAuthor,
keywords = null
};
PackageManagerSearchElement packageManagerSearchElement = new PackageManagerSearchElement(packageHeader);
PackageDetailsViewExtension.OpenPackageDetails(packageManagerSearchElement);
PackageDetailsView packageDetailsView = PackageDetailsViewExtension.PackageDetailsView;
Assert.IsInstanceOf <PackageDetailsViewModel>(packageDetailsView.DataContext);
PackageDetailsViewModel packageDetailsViewModel = packageDetailsView.DataContext as PackageDetailsViewModel;
// Act
PackageDetailsViewExtension.PackageManagerClientViewModel
.DynamoViewModel
.OnViewExtensionOpenWithParameterRequest("Package Details", packageManagerSearchElement);
// Assert
Assert.AreEqual(packageToOpen, packageDetailsViewModel.PackageName);
Assert.AreEqual(packageAuthor.First().username, packageDetailsViewModel.PackageAuthorName);
Assert.AreEqual(packageDescription, packageDetailsViewModel.PackageDescription);
}
/// <summary>
/// Outputs the pack file to the given stream.
/// </summary>
/// <param name="dst">The DST.</param>
public void SaveTo(Stream dst)
{
var head = new FileHeader
{
Signature = PackCommon.Header,
Revision = Revision,
EntryCount = _entries.Count,
Path = Root,
Ft1 = DateTime.UtcNow.ToFileTimeUtc(),
Ft2 = DateTime.UtcNow.ToFileTimeUtc()
};
var pkgHead = new PackageHeader
{
EntryCount = _entries.Count,
InfoHeaderSize = 0,
DataSectionSize = (uint)_bodyStream.Position,
BlankSize = 0,
Zero = new byte[16]
};
var infos = new List <Tuple <byte[], PackageItemInfo> >();
foreach (var e in _entries)
{
var info = new PackageItemInfo()
{
CompressedSize = e.SizeInPack,
DecompressedSize = e.DecompressedSize,
IsCompressed = e.IsCompressed,
Offset = (uint)e.DataOffset,
Seed = e.CryptoSeed,
CreationTime = e.CreatedDate.ToFileTime(),
CreationTime2 = e.CreatedDate.ToFileTime(),
ModifiedTime = e.ModifiedDate.ToFileTime(),
ModifiedTime2 = e.ModifiedDate.ToFileTime(),
LastAccessTime = e.AccessDate.ToFileTime()
};
var bytes = PackCommon.EncodeName(e.Name);
infos.Add(Tuple.Create(bytes, info));
pkgHead.InfoHeaderSize += bytes.Length + StructUtil.SizeOf <PackageItemInfo>();
}
head.WriteToStream(dst);
pkgHead.WriteToStream(dst);
foreach (var i in infos)
{
dst.Write(i.Item1, 0, i.Item1.Length);
i.Item2.WriteToStream(dst);
}
_bodyStream.Position = 0;
_bodyStream.CopyTo(dst);
}
private void ReadHeader(PackageHeader packageHeader)
{
if (packageHeader?.Created != null)
{
DateTime dateTime;
if (DateTime.TryParse(packageHeader.Created.Value, out dateTime))
{
Document.CreatedOn = dateTime;
}
}
}
/// <summary>
/// Adds a PackageHeader, recently downloaded from the Package Manager, to Search
/// </summary>
/// <param name="packageHeader">A PackageHeader object</param>
public void Add(PackageHeader packageHeader)
{
var searchEle = new PackageManagerSearchElement(packageHeader);
SearchDictionary.Add(searchEle, searchEle.Name);
if (packageHeader.keywords != null && packageHeader.keywords.Count > 0)
{
SearchDictionary.Add(searchEle, packageHeader.keywords);
}
SearchDictionary.Add(searchEle, searchEle.Description);
}
private void Init(Stream input)
{
if (input.Length < 0x100)
{
throw new Exception(
"Invalid Savedata!\nData is too short for it to be valid, please select a valid save file");
}
long val = input.ReadInt32(true);
if (val != (long)PackageHeader.Mc02)
{
input.Position -= 4;
val = input.ReadInt64(true);
if (val != (long)PackageHeader.Fb)
{
throw new Exception("Invalid Package Header!");
}
}
PackageHeader = (PackageHeader)val;
bool isbigendian = PackageHeader == PackageHeader.Mc02;
if (PackageHeader == PackageHeader.Mc02)
{
InitMcPackage(input);
}
else
{
InitFbPackage(input);
}
uint hash = input.ReadUInt32(isbigendian);
Header = input.ReadBytes(HeaderLength - 4);
var crc = new DA3CRC();
if (crc.Compute(Header) != hash)
{
throw new Exception(
"Header data did not pass intergrity check!\nPlease choose a valid unmodified save to proceed");
}
hash = input.ReadUInt32(isbigendian);
var data = input.ReadBytes(DataLength - 4);
uint xhash = crc.Compute(data);
if (hash != xhash)
{
throw new Exception(
"Save data did not pass the intergrity check!\nPlease choose a valid unmodified save to proceed");
}
var xio = new DAIIO(data, isbigendian);
DataStructure = new SaveDataStructure().Read(xio);
xio.Close();
}
public void TestOpenDependencyDetails()
{
// Arrange
string packageToOpen = "Sample View Extension";
string packageAuthor = "DynamoTeam";
string packageDescription = "Dynamo sample view extension.";
PackageDetailsViewExtension.PackageManagerClientViewModel = ViewModel.PackageManagerClientViewModel;
PackageHeader packageHeader = new PackageHeader
{
_id = null,
name = string.Empty,
versions = PackageVersions,
latest_version_update = System.DateTime.Now,
num_versions = PackageVersions.Count,
comments = null,
num_comments = 0,
latest_comment = null,
votes = 0,
downloads = 0,
repository_url = null,
site_url = null,
banned = false,
deprecated = false,
@group = null,
engine = null,
license = null,
used_by = null,
host_dependencies = Hosts,
num_dependents = 0,
description = null,
maintainers = UsersList,
keywords = null
};
PackageManagerSearchElement packageManagerSearchElement = new PackageManagerSearchElement(packageHeader);
PackageDetailsViewExtension.OpenPackageDetails(packageManagerSearchElement);
PackageDetailsView packageDetailsView = PackageDetailsViewExtension.PackageDetailsView;
Assert.IsInstanceOf <PackageDetailsViewModel>(packageDetailsView.DataContext);
PackageDetailsViewModel packageDetailsViewModel = packageDetailsView.DataContext as PackageDetailsViewModel;
// Act
packageDetailsViewModel.OpenDependencyDetails(packageToOpen);
// Assert
PackageDetailsView newPackageDetailsView = PackageDetailsViewExtension.PackageDetailsView;
PackageDetailsViewModel newPackageDetailsViewModel = newPackageDetailsView.DataContext as PackageDetailsViewModel;
Assert.AreEqual(packageToOpen, newPackageDetailsViewModel.PackageName);
Assert.AreEqual(packageAuthor, newPackageDetailsViewModel.PackageAuthorName);
Assert.AreEqual(packageDescription, newPackageDetailsViewModel.PackageDescription);
}
void btnInspectPackage_Click(object sender, EventArgs e)
{
if (this._focused_package != null)
{
PackageHeader package = this.Browser.PackageHeaders[this._focused_package];
new PackageInspector(package, this.Browser.BundleDB).Show();
}
else
{
MessageBox.Show("You must select a package to inspect!", "Further Action Required!", MessageBoxType.Information);
}
}
//[System.Web.Services.WebMethod]
//public static void PM_LoadPackageDetail(string contractNo)
//{
// using (FitnessDataContext ctx = new FitnessDataContext())
// {
// ContractProvider contractProvider = new ContractProvider(ctx);
// PackageProvider packageProvider = new PackageProvider(ctx);
// PackageHeader pkg = contractProvider.GetPackageInContract(contractNo);
// IEnumerable<PackageDetailViewModel> package = packageProvider.GetDetail(pkg.ID);
// page._PackageDetail = package.ToList();
// page.gvwPackage.DataSource = package;
// page.gvwPackage.DataBind();
// page.CalculateTotalInvoiceAndPayment();
// page.txtNotes.Text = contractNo;
// }
//}
private void LoadPackageDetail()
{
PackageHeader pkg = contractProvider.GetPackageInContract(txtContractNo.Text);
IEnumerable <PackageDetailViewModel> package = packageProvider.GetDetail(pkg.ID);
_PackageDetail = package.ToList();
gvwPackage.DataSource = package;
gvwPackage.DataBind();
CalculateTotalInvoiceAndPayment();
lblPackage.Text = pkg.Name;
}
public void execute()
{
var browser = Utils.CurrentWindow;
using (StreamWriter file = new StreamWriter("packages.txt"))
{
foreach (var pair in browser.PackageHeaders)
{
PackageHeader package = pair.Value;
if (package.Name.HasUnHashed)
{
file.WriteLine("@" + package.Name);
Console.WriteLine("Current pacakge " + package.Name.UnHashed);
}
else
{
Console.WriteLine("Current pacakge " + package.Name.Hashed);
Console.WriteLine("[Warning] no unhashed name, cannot add this pacakge to the list.");
}
foreach (PackageFileEntry entry in package.Entries)
{
Idstring path = browser.DB.EntryFromID(entry.ID).Path;
Idstring ext = browser.DB.EntryFromID(entry.ID).Extension;
if (path.HasUnHashed)
{
if (package.Name.HasUnHashed)
{
file.WriteLine(path.UnHashed + "." + ext.UnHashed);
}
else
{
Console.WriteLine("File " + path.Hashed + " has no unhashed name, cannot add to the list.");
}
}
}
}
file.WriteLine("@other");
foreach (var pair in HashIndex.Hashes)
{
if (pair.Value.HasUnHashed)
{
string unhashed = pair.Value.UnHashed;
if (!unhashed.Contains("/") && !unhashed.Contains("PassThroughGP") && !unhashed.Contains("pln_") && !unhashed.Contains("achievement_"))
{
file.WriteLine(unhashed);
}
}
}
};
}
/// ------------------------------------------------------------------------------
/// <summary>
/// 发送消息
/// </summary>
/// ------------------------------------------------------------------------------
public void SendMessage(PackageHeader pMsg)
{
if (mClient != null)
{
mSendBuffer.Flush();
// 序列消息到 stream 中
pMsg.serialize(ref mSendBuffer);
// 序列到网络中
mClient.GetStream().Write(mSendBuffer.ToBytes(), 0, mSendBuffer.Writelength());
mClient.GetStream().Flush();
}
}
public override void WriteBundle(PackageHeader header, string bundle_id)
{
if (ListOptions.BundleInfo.Count == 0)
{
return;
}
this.Output.AppendLine();
for (int i = 0; i < this.ListOptions.BundleInfo.Count; i++)
{
ListBundleOption opt = this.ListOptions.BundleInfo[i];
this.Output.Append((i == 0 ? "" : ",") + "\"" + opt.StringFunc(Parent, header, bundle_id) + "\"");
}
this.WriteEmptyBundleColumns = false;
}
public virtual void WriteBundle(PackageHeader header, string bundle_id)
{
if (ListOptions.BundleInfo.Count == 0)
{
return;
}
this.Output.AppendLine();
for (int i = 0; i < this.ListOptions.BundleInfo.Count; i++)
{
ListBundleOption opt = this.ListOptions.BundleInfo[i];
this.Output.Append((i == 0 ? "" : " - ") + opt.StringFunc(Parent, header, bundle_id));
}
this.Output.AppendLine((this.ListOptions.EntryInfo.Count > 0 ? ":" : ""));
}
/// <summary>
/// Reads the package infos.
/// </summary>
/// <param name="packageHeader">The package header.</param>
/// <exception cref="System.Exception">Entry ' + name + ' is corrupted!</exception>
private void ReadPackageInfos(PackageHeader packageHeader)
{
var infoHeader = new byte[packageHeader.InfoHeaderSize];
_source.Read(infoHeader, 0, infoHeader.Length);
var ptr = 0;
for (var i = 0; i < packageHeader.EntryCount; i++)
{
int nameSectionLength;
if (infoHeader[ptr] < 4)
{
nameSectionLength = 0x10 * (infoHeader[ptr] + 1);
}
else if (infoHeader[ptr] == 4)
{
nameSectionLength = 0x60;
}
else
{
nameSectionLength = BitConverter.ToInt32(infoHeader, ptr + 1) + 5;
}
var lengthSize = (infoHeader[ptr] > 4 ? 5 : 1);
var nameStart = ptr + lengthSize;
var maxNameLength = nameSectionLength - lengthSize - 1; // 1 for the trailing \0, which we don't care about.
var name = Encoding.UTF8.GetString(infoHeader, nameStart, maxNameLength).TrimEnd('\0');
ptr += nameSectionLength;
var info = infoHeader.GetStruct <PackageItemInfo>(ptr);
if (info.Zero != 0)
{
throw new Exception("Entry '" + name + "' is corrupted!");
}
_entries[name.NormalizePath()] = new PackEntry(info, name, maxNameLength);
ptr += StructUtil.SizeOf <PackageItemInfo>();
}
}
/// <summary>
/// Add Package Header to Package
/// </summary>
public void CreateHeader()
{
PackageHeader header = new PackageHeader();
header.XPDLVersion = new XPDLVersion()
{
Value = XpdlInfo.Version
};
header.Vendor = new Vendor()
{
Value = Assembly.GetExecutingAssembly().GetName().Name
};
//To Utc date time format
header.Created = new Created()
{
Value = XpdlInfo.GetUtcDateTime(_document.CreatedOn)
};
Package.PackageHeader = header;
}
public void FilterFuturePackages_IEnumerableTuplePackageHeaderPackageVersion_ReturnsCorrectResults()
{
var pkgVersion063 = new PackageVersion()
{
engine_version = "0.6.3"
};
var pkgVersion080 = new PackageVersion()
{
engine_version = "0.8.0"
};
var pkg063 = new PackageHeader()
{
name = "063",
versions = new List<PackageVersion>()
{
pkgVersion063
}
};
var pkg080 = new PackageHeader()
{
name = "080",
versions = new List<PackageVersion>()
{
pkgVersion080
}
};
var pkgList = new List<Tuple<PackageHeader, PackageVersion>>()
{
new Tuple<PackageHeader, PackageVersion>(pkg063, pkgVersion063),
new Tuple<PackageHeader, PackageVersion>(pkg080, pkgVersion080),
};
var dynamoVersion = Version.Parse("0.7.1");
var filteredPkgList = pkgList.FilterFuturePackages(dynamoVersion);
Assert.AreEqual(1, filteredPkgList.Count());
Assert.AreEqual("080", filteredPkgList.First().Item1.name);
}
public void FilterFuturePackages_IEnumerableTuplePackageHeaderPackageVersion_ReturnsCorrectResults()
{
var pkgVersion063 = new PackageVersion()
{
engine_version = "0.6.3"
};
var pkgVersion080 = new PackageVersion()
{
engine_version = "0.8.0"
};
var pkg063 = new PackageHeader()
{
name = "063",
versions = new List <PackageVersion>()
{
pkgVersion063
}
};
var pkg080 = new PackageHeader()
{
name = "080",
versions = new List <PackageVersion>()
{
pkgVersion080
}
};
var pkgList = new List <Tuple <PackageHeader, PackageVersion> >()
{
new Tuple <PackageHeader, PackageVersion>(pkg063, pkgVersion063),
new Tuple <PackageHeader, PackageVersion>(pkg080, pkgVersion080),
};
var dynamoVersion = Version.Parse("0.7.1");
var filteredPkgList = pkgList.FilterFuturePackages(dynamoVersion);
Assert.AreEqual(1, filteredPkgList.Count());
Assert.AreEqual("080", filteredPkgList.First().Item1.name);
}
public string Decrypt(string path)
{
FileStream readerStream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
Reader reader = new Reader(readerStream, Endian.Big);
PackageData = ReadHeader(reader);
if (!IsValidPKG(PackageData))
return "";
switch (PackageData.pkg_type)
{
case 0x01:
AESKeys = PKG_PS3;
break;
case 0x02:
AESKeys = PKG_PSP;
break;
default:
return "";
}
return DecryptWrite(path, reader);
}
/// <summary>
/// Adds a PackageHeader, recently downloaded from the Package Manager, to Search
/// </summary>
/// <param name="packageHeader">A PackageHeader object</param>
public void Add(PackageHeader packageHeader)
{
var searchEle = new PackageManagerSearchElement(packageHeader);
SearchDictionary.Add(searchEle, searchEle.Name);
if (packageHeader.keywords != null && packageHeader.keywords.Count > 0)
SearchDictionary.Add(searchEle, packageHeader.keywords);
SearchDictionary.Add(searchEle, searchEle.Description);
SearchAndUpdateResultsSync(SearchText);
}
protected void ReceiverLoop()
{
byte[] packageHeaderBuff = new byte[packageHeaderSize], packagePayloadBuff = null;
int packageBytesRead = 0, expectedSize = -1, amnt = 0;
PackageHeader lastHeader = new PackageHeader();
while (!Disposed)
{
packageBytesRead = 0;
expectedSize = -1;
amnt = 0;
packagePayloadBuff = null;
while (true)
{
if (packagePayloadBuff == null)
// No payload buffer means we're reading a header.
try
{
//Console.WriteLine("HEADER Receipt start.");
//stream.BeginRead(packageHeaderBuff, 0, packageHeaderSize, LowStartGettingPackages_Callback, null);
//amnt = stream.Read(packageHeaderBuff, 0, packageHeaderSize);
amnt = streamOut.Read(packageHeaderBuff, packageBytesRead, packageHeaderSize - packageBytesRead);
}
catch (ObjectDisposedException x)
{
_CheckIfStopped(x);
return;
}
catch (Exception x)
{
_OnPipeFailure(x, false, null);
return;
}
else
try
{
//Console.WriteLine("PAYLOAD Receipt start.");
//stream.BeginRead(packagePayloadBuff, packageBytesRead - packageHeaderSize, expectedSize - packageBytesRead, LowStartGettingPackages_Callback, ar.AsyncState);
amnt = streamOut.Read(packagePayloadBuff, packageBytesRead - packageHeaderSize, expectedSize - packageBytesRead);
}
catch (ObjectDisposedException x)
{
_CheckIfStopped(x);
return;
}
catch (Exception x)
{
_OnPipeFailure(x, false, null);
return;
}
if (amnt == 0)
{
_CheckIfStopped(null);
return;
}
packageBytesRead += amnt;
__addReceived(amnt);
if (packageBytesRead == packageHeaderSize)
{
Struct_mapping.ByteArrayToStructure(packageHeaderBuff, ref lastHeader);
uint len = lastHeader.Size;
expectedSize = (int)len + packageHeaderSize;
packagePayloadBuff = new byte[len];
}
if (packageBytesRead == expectedSize)
{
try
{
OnInternalPackageReceived(new Package(lastHeader, packagePayloadBuff));
}
finally
{
packagePayloadBuff = null;
// Getting ready to receive the next package header here.
}
break;
}
}
}
}//*/
public PackageHeader ReadHeader(Reader reader)
{
PackageHeader header = new PackageHeader();
header.magic = reader.ReadBytes(0x04);
Array.Reverse(header.magic);
reader.Position = 0x07;
header.pkg_type = reader.ReadByte();
reader.Position = 0x08;
header.pkg_info_offset = reader.ReadUInt32();
reader.Position = 0x0C;
header.pkg_info_count = reader.ReadUInt32();
reader.Position = 0x10;
header.header_size = reader.ReadUInt32();
reader.Position = 0x14;
header.item_count = reader.ReadUInt32();
reader.Position = 0x18;
header.total_size = reader.ReadUInt64();
reader.Position = 0x20;
header.data_offset = reader.ReadUInt64();
reader.Position = 0x28;
header.data_size = reader.ReadUInt64();
reader.Position = 0x30;
header.contentid = reader.ReadString(0x24);
reader.Position = 0x60;
header.digest = reader.ReadBytes(0x10);
Array.Reverse(header.digest);
reader.Position = 0x70;
header.pkg_data_riv = reader.ReadBytes(0x10);
Array.Reverse(header.pkg_data_riv);
reader.Position = 0x80;
header.header_cmac_hash = reader.ReadBytes(0x10);
Array.Reverse(header.header_cmac_hash);
reader.Position = 0x90;
header.header_npdrm_signature = reader.ReadBytes(0x28);
Array.Reverse(header.header_npdrm_signature);
reader.Position = 0xB8;
header.header_sha1_hash = reader.ReadBytes(0x08);
Array.Reverse(header.header_sha1_hash);
return header;
}
public string GetFolderName(PackageHeader header)
{
string[] contentid = header.contentid.Split('-');
return contentid[1].Replace("_00", "");
}
public static bool IsValidPKG(PackageHeader header)
{
byte[] magic = header.magic;
if (magic[0] == 0x7F && magic[1] == 0x50 && magic[2] == 0x4B && magic[3] == 0x47) // Check String
return true;
return false;
}
