Exemple #1
0
 public static void UpdateDownloadStatusSprite(PackageEntry packageEntry)
 {
     try {
         Assertion.NotNull(packageEntry, "packageEntry");
         var ugc = m_WorkshopDetails(packageEntry);
         if (!packageEntry.publishedFileId.IsValid() || !ugc.publishedFileId.IsValid())
         {
             //Log.Debug("[p0] entry name=" + packageEntry.entryName);
             RemoveDownloadStatusSprite(packageEntry);
         }
         else
         {
             var status = SteamUtilities.IsUGCUpToDate(ugc, out string reason);
             if (status == DownloadOK)
             {
                 //Log.Debug("[p1] entry name=" + packageEntry.entryName);
                 RemoveDownloadStatusSprite(packageEntry);
             }
             else
             {
                 //Log.Debug("[p2] entry name=" + packageEntry.entryName);
                 GetorCreateStatusPanel(packageEntry).StatusButton.SetStatus(status, reason);
             }
         }
         //Log.Succeeded();
     } catch (Exception ex) { ex.Log(); }
 }
 private Dictionary <string, string> GetPropertyDictionary(Metadata metadata, PackageEntry entry)
 {
     return(_mapper
            .GetPropertyPairs(metadata, entry)
            .GroupBy(x => x.Key)
            .ToDictionary(x => x.Key, x => x.First().Value));
 }
Exemple #3
0
        /// <summary>
        /// Initializes a new entryfile from a packageentry and whether or not we should convert this entryfile
        /// </summary>
        /// <param name="entry">the packageentry that this entryfile represents</param>
        /// <param name="convert">whether or not to convert this packageentry</param>
        public EntryFile(PackageEntry entry, string newExtension, bool convert)
        {
            this.entry = entry;
            extension  = newExtension ?? entry.TypeName;

            LoadData(convert);
        }
Exemple #4
0
 private static XmlDocument ReadXml(PackageEntry entry)
 {
     return((XmlDocument)AccountInstaller.ReadXmlMI.Invoke((object)null, new object[1]
     {
         (object)entry
     }));
 }
Exemple #5
0
        static void CheckPackage()
        {
            string filePath = Application.dataPath + "/../Library/PackageChecked";

            if (!File.Exists(filePath))
            {
                Debug.Log("[Auto Package] : Checking if required packages are included");

                var packageListFile = Directory.GetFiles(Application.dataPath, "PackageImportList.txt", SearchOption.AllDirectories);
                if (packageListFile.Length == 0)
                {
                    Debug.LogError("[Auto Package] : Couldn't find the packages list. Be sure there is a file called PackageImportList in your project");
                }
                else
                {
                    string packageListPath = packageListFile[0];
                    packageToAdd = new List <PackageEntry>();
                    string[] content = File.ReadAllLines(packageListPath);
                    foreach (var line in content)
                    {
                        var          split = line.Split('@');
                        PackageEntry entry = new PackageEntry();

                        entry.name    = split[0];
                        entry.version = split.Length > 1 ? split[1] : null;

                        packageToAdd.Add(entry);
                    }

                    File.WriteAllText(filePath, "Delete this to trigger a new auto package check");
                    listRequest = Client.List();
                    EditorApplication.update += Update;
                }
            }
        }
Exemple #6
0
        private void LoadPackage(int i, ClientHandler client, ContentManifestFile cmf)
        {
            PackageEntry entry = m_packageEntries[i];

            using (Stream packageStream = cmf.OpenFile(client, entry.m_packageGUID))
                using (BinaryReader packageReader = new BinaryReader(packageStream)) {
                    var package = packageReader.Read <PackageHeader>();
                    m_packages[i] = package;

                    if (package.m_recordCount == 0)
                    {
                        m_packageRecords[i] = new PackageRecord[0];
                        return;
                    }

                    if (package.m_bundleCount > 0)
                    {
                        packageStream.Position = package.m_offsetBundles;
                        m_packageBundles[i]    = packageReader.ReadArray <ulong>((int)package.m_bundleCount);
                    }

                    packageStream.Position = package.m_offsetRecords;
                    using (GZipStream decompressedStream = new GZipStream(packageStream, CompressionMode.Decompress))
                        using (BinaryReader decompressedReader = new BinaryReader(decompressedStream)) {
                            m_packageRecords[i] = decompressedReader.ReadArray <PackageRecord>((int)package.m_recordCount);
                        }
                }
        }
        //#endregion // new stuff

        public void CheckOnParentAndNode()
        {
            List <ContentReference> theList = new List <ContentReference>();
            var shirt        = _refConv.GetContentLink("Long Sleeve Shirt White Small_1");
            var noProdParent = _refConv.GetContentLink("PriceTest_1");
            var Pack         = _refConv.GetContentLink("SomePackage_1");
            var Prod         = _refConv.GetContentLink("Shirt-Long-Sleeve_1");
            var node         = _refConv.GetContentLink("Shirts_1");

            theList.Add(shirt);        // parent = node, ...typeId "Variation" ... no children
            theList.Add(noProdParent); // parent = node ...typeId "Variation" ... no children
            theList.Add(Pack);         // parent = node ...typeId "Package" ... no children
            theList.Add(Prod);         //parent = node...typeId ""...no children
            theList.Add(node);

            // check ...TypeId - string/int

            var rel = new NodeEntryRelation
            {
                // IsPrimary
                // TargetCatalog
            };

            var rel2 = new PackageEntry
            {
                //GroupName
                //Quantity
                //SortOrder
            };

            var stuff = _contentLoader.GetItems(theList, new LoaderOptions());

            foreach (var item in stuff)
            {
                var Parent = _contentLoader.Get <CatalogContentBase>(item.ParentLink);

                // new...
                var children = _contentLoader.GetChildren <CatalogContentBase>(item.ContentLink);

                var ii = item.GetOriginalType().Name; // "ShirtVariation" ... have FullName also

                if (item is EntryContentBase)         // use this, checks "the tree"
                {
                    var ParentPackages =              // Smashing on the node... of course - "Wrong base class"
                                         _contentLoader.Get <EntryContentBase>(item.ContentLink).GetParentPackages();

                    var ParentProducts =
                        _contentLoader.Get <EntryContentBase>(item.ContentLink).GetParentProducts();

                    var ParentEntries =
                        _contentLoader.Get <EntryContentBase>(item.ContentLink).GetParentEntries();

                    var ParentCategories =
                        _contentLoader.Get <EntryContentBase>(item.ContentLink).GetCategories();
                }
            }

            // Can do like this now, not tested yet
            //var children2 = _relationRepository.GetChildren<NodeEntryRelation>(parentLink);
        }
Exemple #8
0
 internal AssemblyTreeNode(LoadedAssembly assembly, PackageEntry packageEntry)
 {
     this.LoadedAssembly = assembly ?? throw new ArgumentNullException(nameof(assembly));
     this.LazyLoading    = true;
     this.PackageEntry   = packageEntry;
     Init();
 }
Exemple #9
0
        private static void Extract(string[] args)
        {
            string output = args.FirstOrDefault();

            ulong[] guids = args.Skip(1).Select(x => ulong.Parse(x, NumberStyles.HexNumber)).ToArray();
            if (string.IsNullOrWhiteSpace(output))
            {
                return;
            }

            Dictionary <ulong, PackageRecord[]> records      = new Dictionary <ulong, PackageRecord[]>();
            Dictionary <ulong, PackageRecord[]> totalRecords = new Dictionary <ulong, PackageRecord[]>();
            Dictionary <ulong, PackageHeader>   packages     = new Dictionary <ulong, PackageHeader>();

            ApplicationPackageManifest apm = TankHandler.m_packageManifest;

            for (int i = 0; i < apm.m_packageEntries.Length; ++i)
            {
                PackageEntry entry = apm.m_packageEntries[i];
                if (guids.Contains(teResourceGUID.LongKey(entry.m_packageGUID)) || guids.Contains(teResourceGUID.Index(entry.m_packageGUID)))
                {
                    packages[entry.m_packageGUID] = apm.m_packages[i];
                    records[entry.m_packageGUID]  = apm.m_packageRecords[i];
                }
                totalRecords[entry.m_packageGUID] = apm.m_packageRecords[i];
            }

            foreach (ulong key in records.Keys)
            {
                Save(output, key, records[key]);
            }
        }
Exemple #10
0
 public static void RemoveDownloadStatusSprite(PackageEntry packageEntry)
 {
     try {
         Assertion.NotNull(packageEntry, "packageEntry");
         Destroy(GetStatusPanel(packageEntry)?.gameObject);
         //Log.Succeeded();
     } catch (Exception ex) { ex.Log(); }
 }
Exemple #11
0
 public override void Put(PackageEntry entry)
 {
     this._skipAll = (bool)typeof(Sitecore.Install.Security.AccountInstaller).GetField("_skipAll", BindingFlags.Instance | BindingFlags.NonPublic).GetValue((object)this);
     if (this._skipAll)
     {
         return;
     }
     string[] strArray = entry.Key.Split('/');
     if (strArray[0] != "security")
     {
         return;
     }
     if (!AccountInstaller.ContextUserHasEnoughRights())
     {
         JobContext.Alert(Translate.Text("You do not have enough permissions to install security accounts"));
         this._skipAll = true;
     }
     else if (strArray.Length < 3)
     {
         Log.Error(string.Format("Bad entry key '{0}'", (object)entry.Key), (object)this);
     }
     else
     {
         if (strArray.Length > 3)
         {
             string domainName = strArray[2];
             if (!DomainManager.DomainExists(domainName))
             {
                 this.UIEvents.ShowWarning(string.Format(Translate.Text("Unable to create the user '{0}' because domain '{1}' doesn't exist."), (object)AccountInstaller.GetAccountName(entry.Key), (object)domainName), "domain doesn't exist" + domainName);
                 return;
             }
         }
         string str = strArray[1];
         try
         {
             if (str == "users")
             {
                 this.InstallUser(entry);
             }
             else if (str == "roles")
             {
                 this.InstallRole(entry);
             }
             else
             {
                 Log.Error(string.Format("Unexpected account type '{0}'", (object)entry.Key), (object)this);
             }
         }
         catch (ThreadAbortException)
         {
             throw;
         }
         catch (Exception ex)
         {
             Log.Error(string.Format("Error installing entry '{0}'", (object)entry.Key), ex, (object)this);
         }
     }
 }
        public void DefaultConstructor_InitializesDefaultValues()
        {
            var packageEntry = new PackageEntry();

            Assert.Null(packageEntry.FullName);
            Assert.Null(packageEntry.Name);
            Assert.Equal(0, packageEntry.CompressedLength);
            Assert.Equal(0, packageEntry.Length);
        }
Exemple #13
0
        /// <summary>
        /// Grants access to the database.
        /// </summary>
        private void GrantOnly()
        {
            PackageEntry  schemaFile  = package["/Schema/Schema.sql"];
            PackageEntry  delProcFile = package["/Schema/DeleteProcs.sql"];
            PackageEntry  grantFile   = package["/Schema/GrantAccess.sql"];
            PackageEntry  funcFolder  = package["/Funcs"];
            PackageEntry  procFolder  = package["/Procs"];
            string        script;
            string        cs;
            SqlConnection sqlCon;

            QueryDisposition[] qd;

            if (schemaFile == null || !schemaFile.IsFile)
            {
                throw new InvalidOperationException("Invalid Database Package: /Schema/Schema.sql missing.");
            }

            if (delProcFile == null || !delProcFile.IsFile)
            {
                throw new InvalidOperationException("Invalid Database Package: /Schema/DeleteProcs.sql missing.");
            }

            if (grantFile == null || !grantFile.IsFile)
            {
                throw new InvalidOperationException("Invalid Database Package: /Schema/GrantAccess.sql missing.");
            }

            cs     = string.Format("server={0};database={1};{2}", server, database, dbParams.AdminSecurity);
            sqlCon = new SqlConnection(cs);
            sqlCon.Open();

            try
            {
                // Grant access to the application account

                if (account == null)
                {
                    script = Helper.FromAnsi(grantFile.GetContents());
                    script = script.Replace("%account%", account);
                    qd     = new SqlScriptRunner(script).Run(sqlCon, true);

                    for (int i = 0; i < qd.Length; i++)
                    {
                        if (qd[i].Message != null)
                        {
                            throw new InvalidOperationException(qd[i].Message);
                        }
                    }
                }
            }
            finally
            {
                sqlCon.Close();
            }
        }
Exemple #14
0
        public static EntryStatusPanel GetStatusPanel(PackageEntry packageEntry)
        {
            var ret = packageEntry?.GetComponentInChildren <EntryStatusPanel>();

            if (!ret || !ret.enabled)
            {
                ret = null;
            }
            return(ret);//.LogRet(CurrentMethod(1, packageEntry?.entryName));
        }
Exemple #15
0
 private static void ConvertCPackageEntry(
     NativeEnvironment e,
     PackageEntry src,
     CPackageEntry *dst)
 {
     dst->offset    = src.Offset;
     dst->length    = src.Length;
     dst->bytes     = src.Bytes == null ? null : e.Pin(src.Bytes);
     dst->type      = src.Type;
     dst->full_path = e.ToCString(src.FullPath);
 }
Exemple #16
0
        public static byte[] Decrypt(byte[] entryBytes, byte[] keySeed, PackageEntry entry)
        {
            var iv_key = Sha256(
                entry.ToArray()
                .Concat(keySeed)
                .ToArray());
            var tmp = new byte[entryBytes.Length];

            AesCbcCfb128Decrypt(tmp, entryBytes, tmp.Length, iv_key.Skip(16).Take(16).ToArray(), iv_key.Take(16).ToArray());
            return(tmp);
        }
Exemple #17
0
        private static void ExtractEntry(PackageEntry entry, ref string outputDirectory)
        {
            if (Program.Closing)
            {
                Environment.Exit(0);
            }

            // save raw
            var filePathWithoutExtension = _options.SingleDir
                ? Path.Combine(outputDirectory, entry.Name)
                : Path.Combine(outputDirectory, entry.DirectoryPath, entry.Name);

            var filePath = filePathWithoutExtension + entry.Extension;

            Directory.CreateDirectory(Path.GetDirectoryName(filePathWithoutExtension));

            if (!_options.Overwrite && File.Exists(filePath))
            {
                Console.WriteLine($"* Skipping, already exists: {filePath}");
            }
            else
            {
                Console.WriteLine($"* Extracting: {entry.FullPath}");

                File.WriteAllBytes(filePath, entry.Bytes);
            }

            // decompile and save
            if (_options.NoTexDecompile || entry.Type != EntryType.Tex)
            {
                return;
            }


            var tex = LoadTex(entry.Bytes, entry.FullPath);

            if (tex == null)
            {
                return;
            }

            try
            {
                TexPreviewWriter.WriteTexture(tex, filePathWithoutExtension, _options.Overwrite);
                var jsonInfo = _texJsonInfoGenerator.GenerateInfo(tex);
                File.WriteAllText($"{filePathWithoutExtension}.tex-json", jsonInfo);
            }
            catch (Exception e)
            {
                Console.WriteLine("Failed to write texture");
                Console.WriteLine(e);
            }
        }
 public void AddFile(PackageEntry macro)
 {
     if (macro.Name.Length <= 32)
     {
         fileEntries.Enqueue(macro);
     }
     else
     {
         NotifyDetails(String.Format("Error :> Filename overflow :> \"{0}\"", macro.Name));
         HasErrors = true;
     }
 }
Exemple #19
0
        static EntryStatusPanel Create(PackageEntry packageEntry)
        {
            Log.Called();
            Assertion.Assert(packageEntry, "packageEntry");
            var topPanel = packageEntry.GetComponent <UIPanel>();

            Assertion.Assert(topPanel, "topPanel");
            var ret = topPanel.AddUIComponent <EntryStatusPanel>();

            ret.StatusButton.UGCDetails = m_WorkshopDetails(packageEntry);
            return(ret);//.LogRet(ThisMethod);
        }
        public void AddPackageAsync(PackageEntry package)
        {
            BsonDocument bd = package.ToBsonDocument();

            Console.WriteLine($"adding package: {package.Package}");
            m_Packagecollection.InsertOneAsync(bd);
            ObjectId id = bd["_id"].AsObjectId;

            Sha1Db.Instance.AddHashAsync(package.Sha1, id);
            Md5Db.Instance.AddHashAsync(package.Md5Sum, id);
            Sha256Db.Instance.AddHashAsync(package.Sha256, id);
        }
        public void Constructor_WithValidArguments_InitializesInstance()
        {
            using (var zipArchive = CreateZipArchive())
            {
                var zipArchiveEntry = zipArchive.Entries[0];

                var packageEntry = new PackageEntry(zipArchiveEntry);

                Assert.Equal(zipArchiveEntry.FullName, packageEntry.FullName);
                Assert.Equal(zipArchiveEntry.Name, packageEntry.Name);
                Assert.Equal(zipArchiveEntry.CompressedLength, packageEntry.CompressedLength);
                Assert.Equal(zipArchiveEntry.Length, packageEntry.Length);
            }
        }
        public void JsonSerialization_ReturnsCorrectJson()
        {
            var packageEntry = new PackageEntry()
            {
                FullName         = "a/b",
                Name             = "b",
                CompressedLength = 2,
                Length           = 1
            };

            var json = JsonConvert.SerializeObject(packageEntry);

            Assert.Equal("{\"fullName\":\"a/b\",\"name\":\"b\",\"length\":1,\"compressedLength\":2}", json);
        }
		void SaveEntry(ITextOutput output, PackageEntry entry, string targetFileName)
		{
			output.Write(entry.Name + ": ");
			using Stream stream = entry.TryOpenStream();
			if (stream == null)
			{
				output.WriteLine("Could not open stream!");
				return;
			}

			stream.Position = 0;
			using FileStream fileStream = new FileStream(targetFileName, FileMode.OpenOrCreate);
			stream.CopyTo(fileStream);
			output.WriteLine("Written to " + targetFileName);
		}
 public override void Put(PackageEntry entry)
 {
     this._skipAll = (bool)typeof(Sitecore.Install.Security.AccountInstaller).GetField("_skipAll", BindingFlags.Instance | BindingFlags.NonPublic).GetValue((object)this);
     if (this._skipAll)
         return;
     string[] strArray = entry.Key.Split('/');
     if (strArray[0] != "security")
         return;
     if (!AccountInstaller.ContextUserHasEnoughRights())
     {
         JobContext.Alert(Translate.Text("You do not have enough permissions to install security accounts"));
         this._skipAll = true;
     }
     else if (strArray.Length < 3)
     {
         Log.Error(string.Format("Bad entry key '{0}'", (object)entry.Key), (object)this);
     }
     else
     {
         if (strArray.Length > 3)
         {
             string domainName = strArray[2];
             if (!DomainManager.DomainExists(domainName))
             {
                 this.UIEvents.ShowWarning(string.Format(Translate.Text("Unable to create the user '{0}' because domain '{1}' doesn't exist."), (object)AccountInstaller.GetAccountName(entry.Key), (object)domainName), "domain doesn't exist" + domainName);
                 return;
             }
         }
         string str = strArray[1];
         try
         {
             if (str == "users")
                 this.InstallUser(entry);
             else if (str == "roles")
                 this.InstallRole(entry);
             else
                 Log.Error(string.Format("Unexpected account type '{0}'", (object)entry.Key), (object)this);
         }
         catch (ThreadAbortException)
         {
             throw;
         }
         catch (Exception ex)
         {
             Log.Error(string.Format("Error installing entry '{0}'", (object)entry.Key), ex, (object)this);
         }
     }
 }
Exemple #25
0
        private static void Convert(string[] args)
        {
            string output = args.FirstOrDefault();

            ulong[] guids = args.Skip(1).Select(x => ulong.Parse(x, NumberStyles.HexNumber)).ToArray();
            if (string.IsNullOrWhiteSpace(output))
            {
                return;
            }

            Dictionary <ulong, PackageRecord[]> records  = new Dictionary <ulong, PackageRecord[]>();
            Dictionary <ulong, PackageHeader>   packages = new Dictionary <ulong, PackageHeader>();

            var apm = TankHandler.m_packageManifest;

            for (int i = 0; i < apm.m_packageEntries.Length; ++i)
            {
                PackageEntry entry = apm.m_packageEntries[i];
                if (!guids.Contains(teResourceGUID.LongKey(entry.m_packageGUID)) && !guids.Contains(teResourceGUID.Index(entry.m_packageGUID)) && !guids.Contains(entry.m_packageGUID))
                {
                    continue;
                }
                packages[entry.m_packageGUID] = apm.m_packages[i];
                records[entry.m_packageGUID]  = apm.m_packageRecords[i];
            }

            ICLIFlags flags = FlagParser.Parse <ExtractFlags>();

            void Body(ulong key)
            {
                DataTool.FindLogic.Combo.ComboInfo info = new DataTool.FindLogic.Combo.ComboInfo();
                string dest = Path.Combine(output, teResourceGUID.AsString(key));

                foreach (PackageRecord record in records[key])
                {
                    DataTool.FindLogic.Combo.Find(info, record.m_GUID);
                }

                var context = new DataTool.SaveLogic.Combo.SaveContext(info);

                DataTool.SaveLogic.Combo.Save(flags, dest, context);
                context.Wait();
            }

            Parallel.ForEach(records.Keys, Body);
        }
Exemple #26
0
        Func <IPackage> LoadPackage(PackageEntry packageEntry)
        {
            return(() =>
            {
                var response = _client.CreateRequest(packageEntry.PackageHref).Get().Send();
                if (response.Entity == null)
                {
                    return null;
                }
                var tempFile = _fileSystem.CreateTempFile();
                var tempDirectory = _fileSystem.CreateTempDirectory();
                using (var tempStream = tempFile.OpenWrite())
                    NuGetConverter.Convert(response.Entity.Stream, tempStream);

                return new CachedZipPackage(this, tempFile, tempDirectory).Load();
            });
        }
Exemple #27
0
        private static void SearchType(IEnumerable <string> args)
        {
            ulong[] guids = args.Select(x => ulong.Parse(x, NumberStyles.HexNumber)).ToArray();

            ApplicationPackageManifest apm = TankHandler.m_packageManifest;

            for (int i = 0; i < apm.m_packageEntries.Length; ++i)
            {
                PackageEntry    entry   = apm.m_packageEntries[i];
                PackageRecord[] records = apm.m_packageRecords[i];

                foreach (PackageRecord record in records.Where(x => guids.Contains(teResourceGUID.Type(x.m_GUID))))
                {
                    Log("Found {0} in package {1:X12}", teResourceGUID.AsString(record.m_GUID), teResourceGUID.LongKey(entry.m_packageGUID));
                }
            }
        }
Exemple #28
0
        private static void Info(IEnumerable <string> args)
        {
            ulong[] guids = args.Select(x => ulong.Parse(x, NumberStyles.HexNumber)).ToArray();

            ApplicationPackageManifest apm = TankHandler.m_packageManifest;

            for (int i = 0; i < apm.m_packageEntries.Length; ++i)
            {
                PackageEntry entry = apm.m_packageEntries[i];
                if (!guids.Contains(teResourceGUID.LongKey(entry.m_packageGUID)) && !guids.Contains(teResourceGUID.Index(entry.m_packageGUID)))
                {
                    continue;
                }
                Log("Package {0:X12}:", teResourceGUID.LongKey(entry.m_packageGUID));
                Log("\tUnknowns: {0}, {1}", entry.m_unknown1, entry.m_unknown2);
                Log("\t{0} records", apm.m_packageRecords[i].Length);
            }
        }
Exemple #29
0
        private static void SearchType(string[] args)
        {
            ulong[] guids = args.Select(x => ulong.Parse(x, NumberStyles.HexNumber)).ToArray();

            foreach (ApplicationPackageManifest apm in Root.APMFiles)
            {
                for (int i = 0; i < apm.PackageEntries.Length; ++i)
                {
                    PackageEntry    entry   = apm.PackageEntries[i];
                    PackageRecord[] records = apm.Records[i];

                    foreach (PackageRecord record in records.Where(x => guids.Contains(teResourceGUID.Type(x.GUID))))
                    {
                        Log("Found {0} in package {1:X12}", teResourceGUID.AsString(record.GUID), teResourceGUID.LongKey(entry.PackageGUID));
                    }
                }
            }
        }
Exemple #30
0
        protected new void InstallUser(PackageEntry entry)
        {
            string accountName = AccountInstaller.GetAccountName(entry.Key);

            if (User.Exists(accountName))
            {
                Log.Info(string.Format("Installing of entry '{0}' was skipped. User already exists.", (object)accountName), (object)this);
                this.UIEvents.ShowWarning(string.Format(Translate.Text("User '{0}' will not be installed since the user already exists."), (object)accountName), "user already exists");
            }
            else
            {
                XmlDocument xml = AccountInstaller.ReadXml(entry);
                if (!Context.User.IsAdministrator && this.TryingToInstallAdmin(xml, accountName))
                {
                    return;
                }
                string password = AccountInstaller.GetPassword(xml);
                User   user     = (User)null;
                try
                {
                    user = User.Create(accountName, password);
                    this.SetUserProfile(user, xml);
                    this.SetUserProperties(user, xml);
                    this.SetUserRoles(user, xml);
                }
                catch (Exception ex)
                {
                    try
                    {
                        if ((Account)user != (Account)null)
                        {
                            user.Delete();
                        }
                    }
                    catch
                    {
                    }
                    Log.Error(string.Format("Failed to install the user '{0}'", (object)accountName), ex, (object)this);
                    throw;
                }
                Log.Info(string.Format("User '{0}' has been installed successfully", (object)user.Name), (object)this);
            }
        }
Exemple #31
0
        private static void Extract(string[] args)
        {
            string output = args.FirstOrDefault();

            ulong[] guids = args.Skip(1).Select(x => ulong.Parse(x, NumberStyles.HexNumber)).ToArray();
            if (string.IsNullOrWhiteSpace(output))
            {
                return;
            }

            Dictionary <ulong, PackageRecord[]> records      = new Dictionary <ulong, PackageRecord[]>();
            Dictionary <ulong, PackageRecord[]> totalRecords = new Dictionary <ulong, PackageRecord[]>();
            Dictionary <ulong, ulong[]>         siblings     = new Dictionary <ulong, ulong[]>();
            Dictionary <ulong, Package>         packages     = new Dictionary <ulong, Package>();

            foreach (ApplicationPackageManifest apm in (CASC.Root as OwRootHandler).APMFiles)
            {
                for (int i = 0; i < apm.PackageEntries.Length; ++i)
                {
                    PackageEntry entry = apm.PackageEntries[i];
                    if (guids.Contains(GUID.LongKey(entry.PackageGUID)) || guids.Contains(GUID.Index(entry.PackageGUID)))
                    {
                        packages[entry.PackageGUID] = apm.Packages[i];
                        siblings[entry.PackageGUID] = apm.PackageSiblings[i];
                        records[entry.PackageGUID]  = apm.Records[i];
                    }
                    totalRecords[entry.PackageGUID] = apm.Records[i];
                }
            }

            foreach (ulong key in records.Keys)
            {
                Save(output, key, records[key]);
                foreach (ulong sibling in siblings[key])
                {
                    if (totalRecords.ContainsKey(sibling))
                    {
                        Save(output, key, sibling, totalRecords[sibling]);
                    }
                }
            }
        }
Exemple #32
0
        private static void Convert(string[] args)
        {
            string output = args.FirstOrDefault();

            ulong[] guids = args.Skip(1).Select(x => ulong.Parse(x, NumberStyles.HexNumber)).ToArray();
            if (string.IsNullOrWhiteSpace(output))
            {
                return;
            }

            Dictionary <ulong, PackageRecord[]> records  = new Dictionary <ulong, PackageRecord[]>();
            Dictionary <ulong, Package>         packages = new Dictionary <ulong, Package>();

            foreach (ApplicationPackageManifest apm in Root.APMFiles)
            {
                for (int i = 0; i < apm.PackageEntries.Length; ++i)
                {
                    PackageEntry entry = apm.PackageEntries[i];
                    if (guids.Contains(teResourceGUID.LongKey(entry.PackageGUID)) || guids.Contains(teResourceGUID.Index(entry.PackageGUID)))
                    {
                        packages[entry.PackageGUID] = apm.Packages[i];
                        records[entry.PackageGUID]  = apm.Records[i];
                    }
                }
            }

            ICLIFlags flags = FlagParser.Parse <ExtractFlags>();

            MapCMF();
            LoadGUIDTable();
            Sound.WwiseBank.GetReady();
            Parallel.ForEach(records.Keys, (key) =>
            {
                DataTool.FindLogic.Combo.ComboInfo info = new DataTool.FindLogic.Combo.ComboInfo();
                string dest = Path.Combine(output, teResourceGUID.AsString(key));
                foreach (PackageRecord record in records[key])
                {
                    DataTool.FindLogic.Combo.Find(info, record.GUID);
                }
                DataTool.SaveLogic.Combo.Save(flags, dest, info);
            });
        }
Exemple #33
0
        public AFSPackageLoader(ExStream exs, String title = null)
            : base(exs)
        {
            if (StreamTools.ReadASCII(m_bs, 4) != "AFS\0") throw new InvalidDataException();
            Int32 fcount = StreamTools.ReadI32(m_bs, BitSequence.LittleEndian);
            List<PackageEntry> files = new List<PackageEntry>();

            for (int i = 0; i < fcount; i++)
            {
                PackageEntry macro = new PackageEntry();
                macro.Offset = StreamTools.ReadI32(m_bs, BitSequence.LittleEndian);
                macro.Length = StreamTools.ReadI32(m_bs, BitSequence.LittleEndian);
                files.Add(macro);
            }

            Int32 indx_start = StreamTools.ReadI32(m_bs, BitSequence.LittleEndian);
            Int32 indx_len = m_bs.ReadInt(BitSequence.LittleEndian);

            m_bs.Position = indx_start;

            for (int i = 0; i < fcount; i++)
            {
                files[i].Name = StreamTools.ReadASCII(m_bs, 0x20).Replace("\0", "");

                Int16 f_dy = StreamTools.ReadI16(m_bs, BitSequence.LittleEndian);
                Int16 f_dd = StreamTools.ReadI16(m_bs, BitSequence.LittleEndian);
                Int16 f_dm = StreamTools.ReadI16(m_bs, BitSequence.LittleEndian);
                Int16 f_th = StreamTools.ReadI16(m_bs, BitSequence.LittleEndian);
                Int16 f_tm = StreamTools.ReadI16(m_bs, BitSequence.LittleEndian);
                Int16 f_ts = StreamTools.ReadI16(m_bs, BitSequence.LittleEndian);
                Int32 f_rsize = StreamTools.ReadI32(m_bs, BitSequence.LittleEndian);

                files[i].SetAdditionalProperty("Date", new DateTime(f_dy, f_dd, f_dm, f_th, f_tm, f_ts));
                files[i].SetAdditionalProperty("Data", f_rsize.ToString());
            }

            foreach (PackageEntry entry in files)
            { PushEntry(entry); GetInputStream(entry); }

            m_root.Title = title;
        }
        /// <summary>
        /// Adds a node to the tree based on the passed file information. This is useful when building a directory-based tree.
        /// </summary>
        /// <param name="file">File entry.</param>
        public void AddFileNode(PackageEntry file)
        {
            TreeNode currentNode = null;

            if (file.DirectoryName != null)
            {
                var subPaths = file.DirectoryName.Split(Package.DirectorySeparatorChar);

                foreach (var subPath in subPaths)
                {
                    if (currentNode == null)
                    {
                        currentNode = Nodes[subPath] ?? Nodes.Add(subPath, subPath, @"_folder", @"_folder");
                    }
                    else
                    {
                        currentNode = currentNode.Nodes[subPath] ?? currentNode.Nodes.Add(subPath, subPath, @"_folder", @"_folder");
                    }

                    currentNode.Tag = new TreeViewFolder(file.DirectoryName, currentNode.Nodes.Count + 1); //is this enough?
                }
            }

            var fileName = file.GetFileName();
            var ext = ExtensionIconList[file.TypeName];

            if (currentNode == null)
            {
                currentNode = Nodes.Add(fileName, fileName, ext, ext);
            }
            else
            {
                currentNode = currentNode.Nodes.Add(fileName, fileName, ext, ext);
            }

            currentNode.Tag = file; //so we can use it later
        }
 public void ExtractSingle(PackageEntry entry, String path)
 {
     String dir = Path.GetFileDirectory(path);
     if (dir != "" && !System.IO.Directory.Exists(dir)) System.IO.Directory.CreateDirectory(dir);
     ExtractSingleInner(entry, path);
 }
 public abstract void SetEntryLengthInPhysicalFileDB(PackageEntry entry, Int64 value);
 protected override void PushEntry(PackageEntry f, PackageEntry dir)
 {
     base.PushEntry(f, dir);
     m_sortedEntries.Add(f, f.Offset);
 }
Exemple #38
0
 public Stream GetContent(PackageEntry entry)
 {
     Stream parentStream;
     var offset = dataStart + entry.Offset + SegmentStream.GetOverallNestedOffset(s, out parentStream);
     var path = ((FileStream)parentStream).Name;
     return new SegmentStream(File.OpenRead(path), offset, entry.Length);
 }
        protected virtual void PushEntry(PackageEntry f, PackageEntry dir)
        {
            PushEntryToDir(f, dir);

            Int32 n = m_entries.Count;
            m_entries.Add(f);
            m_map.Add(f, n);
        }
        protected void PushEntryToDir(PackageEntry f, PackageEntry dir)
        {
            String d = "";
            String tn = f.Name;
            if (f.Name.Contains("\\") || f.Name.Contains("/"))
            { d = Path.PopFirstDir(ref tn); f.Name = tn; }

            if (d == "")
            {
                dir.SubEntries.Add(f);
                dir.SubEntriesMap.Add(f.Name, f);
                f.Parent = dir;
            }
            else
            {
                if (!dir.SubEntriesMap.ContainsKey(d))
                {
                    PackageEntry dir_entry = PackageEntry.CreateDir(d);
                    dir.SubEntries.Add(dir_entry);
                    dir.SubEntriesMap.Add(dir_entry.Name, dir_entry);
                    dir_entry.Parent = dir;
                }
                PushEntryToDir(f, dir.SubEntriesMap[d]);
            }
        }
 //============================
 public static Queue<PackageEntry> BuildFileList(string bpath, string path, Queue<PackageEntry> q)
 {
     string[] sfs = System.IO.Directory.GetFiles(path);
     foreach (string ds in sfs)
     {
         FileInfo fi = new FileInfo(ds);
         PackageEntry entry = new PackageEntry();
         entry.Name = Path.GetRelativePath(ds, bpath);
         entry.Length = fi.Length;
         entry.SetAdditionalProperty("Date", fi.LastWriteTime);
         entry.SetAdditionalProperty("Data", new ExStream(ds, FileMode.Open, FileAccess.Read));
         q.Enqueue(entry);
     }
     string[] sds = System.IO.Directory.GetDirectories(path);
     foreach (string dds in sds)
     {
         q = BuildFileList(bpath, dds, q);
     }
     return q;
 }
 public void ExtractMultiple(PackageEntry[] entries, String[] paths)
 {
     if (entries.Length != paths.Length) throw new ArgumentException();
     for (int i = 0; i < paths.Length; i++)
     {
         String dir = Path.GetFileDirectory(paths[i]);
         if (dir != "" && !System.IO.Directory.Exists(dir)) System.IO.Directory.CreateDirectory(dir);
     }
     ExtractMultipleInner(entries, paths);
 }
 protected virtual void PushEntry(PackageEntry f)
 {
     PushEntry(f, m_root);
 }
 public void Extract(PackageEntry entry, ExStreamBase exs)
 {
     if (entry.Type != PackageEntry.EntryType.File) throw new InvalidOperationException("PackageBase.Extract(...) :> Cannot directly extract directories");
     ExtractInner(entry, exs);
 }
 protected virtual ExPartStream GetInputStreamInner(PackageEntry entry)
 {
     return new ExPartStream(m_bs, new Range() { Lower = entry.Offset, Length = entry.Length }, System.IO.FileAccess.Read);
 }
Exemple #46
0
 internal virtual void InitFrom(PackageEntry entry)
 {
     this.Name = entry.Name;
 }
 protected virtual void ExtractSingleInner(PackageEntry entry, String path)
 {
     using (ExStream exs = new ExStream(path, System.IO.FileMode.Create))
     {
         Extract(entry, exs);
     }
 }
Exemple #48
0
 public Stream LoadPackage(PackageEntry packageEntry)
 {
     throw new NotSupportedException();
 }
 protected virtual void ExtractMultipleInner(PackageEntry[] entries, String[] paths)
 {
     for (int i = 0; i < entries.Length - 1; i++)
     {
         ExtractSingle(entries[i], paths[i]);
     }
 }
Exemple #50
0
 public override void SetEntryLengthInPhysicalFileDB(PackageEntry entry, long value)
 {
     Int32 index = m_map[entry];
     Int64 pos = index * 12 + 8;
     m_bs.Position = pos;
     m_bs.WriteInt((int)value, BitSequence.LittleEndian);
 }
 protected virtual void ExtractInner(PackageEntry entry, ExStreamBase exs)
 {
     using (ExPartStream fout = new ExPartStream(m_bs, new Range() { Lower = entry.Offset, Length = entry.Length }))
     {
         fout.WriteTo(exs);
     }
 }
Exemple #52
0
 public override long GetEntryLengthInPhysicalFileDB(PackageEntry entry)
 {
     Int32 index = m_map[entry];
     Int64 pos = index * 12 + 8;
     m_bs.Position = pos;
     return m_bs.ReadInt(BitSequence.LittleEndian);
 }
 public ExPartStream GetInputStream(PackageEntry entry)
 {
     if (entry.Type != PackageEntry.EntryType.File) throw new InvalidOperationException("PackageBase.Extract(...) :> Cannot directly extract directories");
     return GetInputStreamInner(entry);
 }
   private static XmlDocument ReadXml(PackageEntry entry)
   {
       return (XmlDocument)AccountInstaller.ReadXmlMI.Invoke((object)null, new object[1]
 {
   (object) entry
 });
   }
 public abstract Int64 GetEntryLengthInPhysicalFileDB(PackageEntry entry);
 protected new void InstallUser(PackageEntry entry)
 {
     string accountName = AccountInstaller.GetAccountName(entry.Key);
     if (User.Exists(accountName))
     {
         Log.Info(string.Format("Installing of entry '{0}' was skipped. User already exists.", (object)accountName), (object)this);
         this.UIEvents.ShowWarning(string.Format(Translate.Text("User '{0}' will not be installed since the user already exists."), (object)accountName), "user already exists");
     }
     else
     {
         XmlDocument xml = AccountInstaller.ReadXml(entry);
         if (!Context.User.IsAdministrator && this.TryingToInstallAdmin(xml, accountName))
             return;
         string password = AccountInstaller.GetPassword(xml);
         User user = (User)null;
         try
         {
             user = User.Create(accountName, password);
             this.SetUserProfile(user, xml);
             this.SetUserProperties(user, xml);
             this.SetUserRoles(user, xml);
         }
         catch (Exception ex)
         {
             try
             {
                 if ((Account)user != (Account)null)
                     user.Delete();
             }
             catch
             {
             }
             Log.Error(string.Format("Failed to install the user '{0}'", (object)accountName), ex, (object)this);
             throw;
         }
         Log.Info(string.Format("User '{0}' has been installed successfully", (object)user.Name), (object)this);
     }
 }
Exemple #57
0
        public Stream GetContent(PackageEntry entry)
        {
            Stream parentStream;
            var baseOffset = dataStart + entry.Offset;
            var nestedOffset = baseOffset + SegmentStream.GetOverallNestedOffset(s, out parentStream);

            // Special case FileStream - instead of creating an in-memory copy,
            // just reference the portion of the on-disk file that we need to save memory.
            // We use GetType instead of 'is' here since we can't handle any derived classes of FileStream.
            if (parentStream.GetType() == typeof(FileStream))
            {
                var path = ((FileStream)parentStream).Name;
                return new SegmentStream(File.OpenRead(path), nestedOffset, entry.Length);
            }

            // For all other streams, create a copy in memory.
            // This uses more memory but is the only way in general to ensure the returned streams won't clash.
            s.Seek(baseOffset, SeekOrigin.Begin);
            return new MemoryStream(s.ReadBytes((int)entry.Length));
        }