Пример #1
0
        public static void Execute(ProgramExecutionOptions options)
        {
            if (ProgramUtil.ShowHelpIfNeeded(options))
            {
                return;
            }

            if (CommandLineUtil.ValidateArguments(options.ParsedArguments, Validations))
            {
                Pair <string, string> pathArg;

                // no need to validate this because the argument is required
                CommandLineUtil.TryGetArgumentByName(options.ParsedArguments, PathArgName, out pathArg);
                var path = pathArg.Value;

                bool openOnTerminal = CommandLineUtil.ArgumentExists(options.ParsedArguments, TerminalArgName);

                HashFile file;
                HashDir  dir;
                if (FileSystem.FileExistsAndIsAvailable(path, out file))
                {
                    var permission = FileSystem.GetAccessPermission(file);
                    if (permission < AccessPermission.Editable)
                    {
                        var msg = "You don't have permission to open this file.";
                        msg = TextUtil.Error(msg);
                        TerminalUtil.ShowText(msg);
                    }
                    else
                    {
                        switch (file.FileType)
                        {
                        case HashFileType.Text:
                            var textFile = file.Content as TextFile;
                            OpenTextFile(file, textFile, openOnTerminal);
                            break;

                        case HashFileType.Image:
                            var imageFile = file.Content as ImageFile;
                            OpenImageFile(file, imageFile, openOnTerminal);
                            break;

                        default:
                            DebugUtil.Error(string.Format("The open program can't open file type: {0}", file.FileType));
                            break;
                        }
                    }
                }
                else
                {
                    string msg;
                    if (FileSystem.DirExists(path, out dir))
                    {
                        msg = "The path '{0}' points to a directory. Please use 'cd {0}' to navigate to that directory.";
                    }
                    else
                    {
                        msg = "The path '{0}' points to nowhere. Please supply a valida path.";
                    }

                    msg = string.Format(msg, path);
                    msg = TextUtil.Error(msg);
                    TerminalUtil.ShowText(msg);
                }
            }
            else
            {
                string msg = "Please supply a file path.";
                msg = TextUtil.Error(msg);
                TerminalUtil.ShowText(msg);
            }
        }
Пример #2
0
        /// <summary>
        /// Executes the dir program.
        /// </summary>
        public static void Execute(ProgramExecutionOptions options)
        {
            if (ProgramUtil.ShowHelpIfNeeded(options))
            {
                return;
            }

            HashDir currentDir = null;

            if (options.ParsedArguments.Count == 0)
            {
                currentDir = DataHolder.DeviceData.CurrentDevice.FileSystem.CurrentDir;
            }
            else
            {
                var desiredDirPath = options.ParsedArguments[0].Value;
                if (!FileSystem.DirExists(desiredDirPath, out currentDir))
                {
                    string msg;

                    HashFile file;
                    if (FileSystem.FileExistsAndIsAvailable(desiredDirPath, out file))
                    {
                        msg = string.Format("The path '{0}' points to a file. Use 'open {0}' to open this file.",
                                            desiredDirPath);
                    }
                    else
                    {
                        msg = string.Format("The path '{0}' points nowhere. Please supply a valid path.",
                                            desiredDirPath);
                    }

                    msg = TextUtil.Error(msg);
                    TerminalUtil.ShowText(msg);
                    return;
                }
            }

            var childs = FileSystem.GetAllAvailableChild(currentDir);
            var files  = FileSystem.GetAvailableFilesFromDir(currentDir);

            if (childs.Count == 0 && files.Count == 0)
            {
                var txt = "EMPTY DIRECTORY!";
                txt = TextUtil.ApplyNGUIColor(txt, LineColor);
                TerminalUtil.ShowText(txt);
            }
            else
            {
                TerminalUtil.StartTextBatch();

                TerminalUtil.ShowText(HeaderLine.FormattedText);

                for (int i = 0; i < childs.Count; i++)
                {
                    var child = childs[i];
                    var line  = CreateLine(child.Name, "DIRECTORY", string.Empty, LineColor, TextModifiers.Italic);
                    TerminalUtil.ShowText(line.FormattedText);
                }

                for (int i = 0; i < files.Count; i++)
                {
                    var file = files[i];

                    var status = FileSystem.GetStatusString(file.Status);
                    var line   = CreateLine(file.FullName, "FILE", status, LineColor, TextModifiers.Italic);
                    TerminalUtil.ShowText(line.FormattedText);
                }

                TerminalUtil.EndTextBatch();
            }
        }
Пример #3
0
 public static void ShowErrorMessage(string msg)
 {
     msg = TextUtil.Error(msg);
     TerminalUtil.ShowText(msg);
 }
Пример #4
0
        public static void Execute(ProgramExecutionOptions options)
        {
            if (ProgramUtil.ShowHelpIfNeeded(options))
            {
                return;
            }

            if (CommandLineUtil.ValidateArguments(options.ParsedArguments, Validations))
            {
                Pair <string, string> pathArg     = CommandLineUtil.FindArgumentByName(options.ParsedArguments, PathArgName);
                Pair <string, string> passwordArg = CommandLineUtil.FindArgumentByName(options.ParsedArguments, PasswordArgName);

                var path     = pathArg.Value;
                var password = passwordArg.Value;

                HashFile file = FileSystem.FindFileByPath(path);
                if (file == null)
                {
                    var msg = string.Format("The path '{0}' is not a valid file path.", path);
                    ShowErrorMessage(msg);
                }
                else
                {
                    if (file.Status != FileStatus.Encrypted)
                    {
                        var msg = string.Format("The file '{0}' is not encrypt. You can open it using 'open {0}'", path);
                        msg = TextUtil.ApplyNGUIColor(msg, Constants.Colors.Success);
                        TerminalUtil.ShowText(msg);
                    }
                    else
                    {
                        var filePassword = file.Password;
                        if (string.Equals(password, filePassword))
                        {
                            var msg = string.Format("File '{0}' decrypted successfully. Use 'open {0}' to open the file.", path);
                            msg = TextUtil.ApplyNGUIColor(msg, Constants.Colors.Success);
                            TerminalUtil.ShowText(msg);
                            FileSystem.ChangeFileStatus(file, FileStatus.Normal);
                        }
                        else
                        {
                            var msg = "Invalid password.";
                            ShowErrorMessage(msg);
                        }
                    }
                }
            }
            else
            {
                var pathResult     = (int)PathValidation.ValidationResult;
                var passwordResult = (int)PasswordValidation.ValidationResult;
                if (MathUtil.ContainsFlag(pathResult, (int)ArgValidationResult.NotFound) ||
                    MathUtil.ContainsFlag(pathResult, (int)ArgValidationResult.EmptyValue))
                {
                    var msg = "You need to supply a path. Please use 'help cracker' for more info.";
                    ShowErrorMessage(msg);
                }
                else if (MathUtil.ContainsFlag(passwordResult, (int)ArgValidationResult.NotFound) ||
                         MathUtil.ContainsFlag(passwordResult, (int)ArgValidationResult.EmptyValue))
                {
                    var msg = "You need to supply a password. Please use 'help cracker' for more info.";
                    ShowErrorMessage(msg);
                }
            }
        }
Пример #5
0
        public static void Execute(ProgramExecutionOptions options)
        {
            if (ProgramUtil.ShowHelpIfNeeded(options))
            {
                return;
            }

            bool      everythingOk = true;
            int       count        = 0;
            ClearMode mode         = ClearMode.Top;

            if (options.ParsedArguments.Count == 0)
            {
                count = DataHolder.TerminalData.AllEntries.Count;
            }
            else if (CommandLineUtil.ValidateArguments(options.ParsedArguments, Validations))
            {
                Pair <string, string> modeArg;
                Pair <string, string> countArg;

                bool modePresent =
                    CommandLineUtil.TryGetArgumentByName(options.ParsedArguments, ModeArgName, out modeArg);
                bool countPresent =
                    CommandLineUtil.TryGetArgumentByName(options.ParsedArguments, CountArgName, out countArg);

                if (modePresent && !countPresent)
                {
                    var msg = "You need to supply the number of line to clear when using the mode argument.";
                    msg = TextUtil.Error(msg);
                    TerminalUtil.ShowText(msg);
                    everythingOk = false;
                }

                if (countPresent && !modePresent)
                {
                    var msg =
                        "You need to supply the mode argument when removing a specific quantity of lines.";
                    msg = TextUtil.Error(msg);
                    TerminalUtil.ShowText(msg);
                    everythingOk = false;
                }

                if (everythingOk)
                {
                    if (!MiscUtil.TryParseEnum(modeArg.Value, out mode))
                    {
                        var msg = string.Format("'{0}' is not a valid clear mode. It must be either 'top' or 'down'.",
                                                modeArg.Value);
                        msg = TextUtil.Error(msg);
                        TerminalUtil.ShowText(msg);
                        everythingOk = false;
                    }
                    else if (!int.TryParse(countArg.Value, out count))
                    {
                        var msg = string.Format("'{0}' is not a valid number of lines!", countArg.Value);
                        msg = TextUtil.Error(msg);
                        TerminalUtil.ShowText(msg);
                        everythingOk = false;
                    }
                }
            }
            else
            {
                everythingOk = false;

                var modeResult  = ModeValidation.ValidationResult;
                var countResult = CountValidation.ValidationResult;

                if (MathUtil.ContainsFlag((int)modeResult, (int)ArgValidationResult.EmptyValue))
                {
                    var msg = "The 'mode' argument must be either 'top' or 'down'.";
                    msg = TextUtil.Error(msg);
                    TerminalUtil.ShowText(msg);
                }
                else if (MathUtil.ContainsFlag((int)modeResult, (int)ArgValidationResult.Duplicated))
                {
                    var msg = "Please supply only one 'mode' argument.";
                    msg = TextUtil.Error(msg);
                    TerminalUtil.ShowText(msg);
                }
            }

            if (everythingOk)
            {
                if (mode == ClearMode.Bottom)
                {
                    TerminalUtil.RemoveTextEntries(count, TerminalEntryRemoveType.NewerEntries);
                }
                else
                {
                    TerminalUtil.RemoveTextEntries(count, TerminalEntryRemoveType.OlderEntries);
                }
            }
        }