Beispiel #1
0
        private static void LogInfo(string content, WriteType type)
        {
            if (_canWriteLog == false)
            {
                return;
            }
            if (_sw == null)
            {
                throw new ArgumentNullException();
            }
            string title = null;

            if (type == WriteType.Warning)
            {
                title = "[Warning]";
            }
            else if (type == WriteType.Error)
            {
                title = "[Error]";
            }
            else
            {
                title = "[Operate]";
            }
            DateTime now = DateTime.Now;

            _sw.WriteLine("{0}{1} {2}", title, now.ToString("yyyy-MM-dd HH:mm:ss.fff"), content);
            _sw.Flush();
        }
Beispiel #2
0
 public CKernelWriter(Vehicle vehicle, Protocol protocol, WriteType writeType, ILogger logger)
 {
     this.vehicle   = vehicle;
     this.protocol  = protocol;
     this.writeType = writeType;
     this.logger    = logger;
 }
Beispiel #3
0
        private void writeGetterSetter(StreamWriter sw, List <Struct> cstructs, WriteType t)
        {
            foreach (Struct cstruct in cstructs)
            {
                if (t == WriteType.get)
                {
                    writeFunctionGetter(sw, cstruct, false, cstructs);
                }
                else
                {
                    writeFunctionSetter(sw, cstruct, false, cstructs);
                }
            }

            sw.WriteLine();

            foreach (Struct cstruct in cstructs)
            {
                if (t == WriteType.get)
                {
                    writeFunctionGetter(sw, cstruct, true, cstructs);
                    sw.WriteLine();
                }
                else
                {
                    writeFunctionSetter(sw, cstruct, true, cstructs);
                    sw.WriteLine();
                }
            }
        }
Beispiel #4
0
 private static void SetConsoleColorFromType(WriteType writeType)
 {
     switch (writeType)
     {
         case WriteType.Log:
             SysCon.ForegroundColor = ConsoleColor.Gray;
             break;
         case WriteType.Error:
             SysCon.ForegroundColor = ConsoleColor.Red;
             break;
         case WriteType.Warning:
             SysCon.ForegroundColor = ConsoleColor.Yellow;
             break;
         case WriteType.DB:
             SysCon.ForegroundColor = ConsoleColor.Magenta;
             break;
         case WriteType.CMD:
             SysCon.ForegroundColor = ConsoleColor.Green;
             break;
         case WriteType.System:
             SysCon.ForegroundColor = ConsoleColor.Cyan;
             break;
         default:
             SysCon.ForegroundColor = ConsoleColor.White;
             break;
     }
 }
Beispiel #5
0
 /// <summary>
 /// Compare the two operating system IDs, report on the ramifications, set a flag if the write should be halted.
 /// </summary>
 public static void ReportOperatingSystems(UInt32 fileOs, UInt32 pcmOs, WriteType writeType, ILogger logger, out bool shouldHalt)
 {
     shouldHalt = false;
     if (fileOs == pcmOs)
     {
         logger.AddUserMessage("PCM and image file are both operating system " + fileOs);
     }
     else
     {
         if ((writeType == WriteType.OsPlusCalibrationPlusBoot) || (writeType == WriteType.Full))
         {
             logger.AddUserMessage("Changing PCM to operating system " + fileOs);
         }
         else if (writeType == WriteType.TestWrite)
         {
             logger.AddUserMessage("PCM and image file are different operating systems.");
             logger.AddUserMessage("But we'll ignore that because this is just a test write.");
         }
         else
         {
             logger.AddUserMessage("Flashing this file could render your PCM unusable.");
             shouldHalt = true;
         }
     }
 }
    public static void WriteOnly(string outFileName, List <string> content, WriteType type = WriteType.TEXT)
    {
        if (string.IsNullOrEmpty(CDNResourceMoveConfig.Instance().logOutPath) || !Directory.Exists(CDNResourceMoveConfig.Instance().logOutPath))
        {
            Debug.LogError("write error !:" + CDNResourceMoveConfig.Instance().logOutPath);
            return;
        }
        string outputPath = CDNResourceMoveConfig.Instance().logOutPath + "/" + outFileName;

        string dir = Path.GetDirectoryName(outputPath);

        if (!Directory.Exists(dir))
        {
            Directory.CreateDirectory(dir);
        }
        if (type == WriteType.EXCEL)
        {
            ExcelIns ei = ExcelManager.GetExcel(outputPath + ".xls");
            ei.WriteSimpleList(content);
            //ei.GetWorkSheet();
        }
        else
        {
            outputPath = outputPath + ".txt";
            if (!File.Exists(outputPath))
            {
                FileStream fs1 = new FileStream(outputPath, FileMode.Create, FileAccess.Write);//创建写入文件
                fs1.Close();
            }
            System.IO.File.WriteAllLines(outputPath, content.ToArray());
        }
    }
        static void WriteMessage(string message = default, WriteType type = WriteType.Information, bool inline = false)
        {
            switch (type)
            {
            case WriteType.Information:
                ForegroundColor = ConsoleColor.Cyan;
                Write("[情報] ");
                break;

            case WriteType.Warning:
                ForegroundColor = ConsoleColor.Yellow;
                Write("[注意] ");
                break;

            case WriteType.Error:
                ForegroundColor = ConsoleColor.Red;
                Write("[警告] ");
                break;

            case WriteType.Memo:
                ForegroundColor = ConsoleColor.DarkBlue;
                Write("[メモ] ");
                break;

            case WriteType.Success:
                ForegroundColor = ConsoleColor.Green;
                Write("[成功] ");
                break;

            case WriteType.Failure:
                ForegroundColor = ConsoleColor.DarkRed;
                Write("[失敗] ");
                break;

            case WriteType.Input:
                ForegroundColor = ConsoleColor.DarkGray;
                Write("[入力] ");
                break;

            case WriteType.Select:
                ForegroundColor = ConsoleColor.DarkMagenta;
                Write("[選択] ");
                break;
            }

            if (message is string)
            {
                if (inline)
                {
                    Write(message);
                }
                else
                {
                    WriteLine(message);
                }
            }

            ResetColor();
        }
Beispiel #8
0
 public void Write(IDictionary <TMeta, TSet> items, WriteType writeType = WriteType.Update)
 {
     foreach (KeyValuePair <TMeta, TSet> item in items)
     {
         TSession session = GetOrCreate(item.Key);
         session.Write(item.Value, writeType);
     }
 }
Beispiel #9
0
    public static void Display(string theText, WriteType outputMethod)
    {
        switch (outputMethod)
        {
        case WriteType.ToFile: WriteToFile(theText); break;

        case WriteType.ToScreen: WriteToScreen(theText); break;
        }
    }
        /// <summary>
        /// Write the Lines to Library
        /// </summary>
        /// <param name="type">Write Type</param>
        protected virtual void WriteLines(WriteType type)
        {
            ////check if a nuclide is selected
            //if (matchedNuclidesGrid.SelectedRows.Count <= 0)
            //    return;

            try
            {
                //get the nuclides to write to the library
                DataRow nuc         = SelectedNuclide.Row;
                bool    isPhotoPeak = (string)nuc["NAME"] != "S.E." && (string)nuc["NAME"] != "D.E." && !((string)nuc["NAME"]).Contains("Sum");

                //check if the nuclide has a half-life that is too long
                if (nuc["HALF_LIFE_UNIT"].ToString().Equals("y") && (double)nuc["HALF_LIFE"] / (31557600 * 1E6) > Int32.MaxValue)
                {
                    throw new ArgumentException($"The Half-life for " + (string)nuc["NAME"] + " is too large to be supported. It will not be added to the library");
                }

                //get the lines to write to the library
                if (isPhotoPeak)
                {
                    DataTable writeLines;
                    switch (type)
                    {
                    case WriteType.All:
                        writeLines = Lines.ToTable();
                        break;

                    case WriteType.Matched:
                        writeLines = Lines.ToTable().Select("MATCHED = True").CopyToDataTable();
                        break;

                    case WriteType.Selected:
                        writeLines = matches.Lines.Clone();
                        foreach (DataRowView line in SelectedLines)
                        {
                            writeLines.ImportRow(line.Row);
                        }
                        break;

                    default:
                        writeLines = matches.Lines.Select().CopyToDataTable();
                        break;
                    }
                    //write the nuclides to the library
                    libGen.WriteNuclide(nuc, writeLines, CombineLinesCallback);
                }
                //set the persistent matches
                matches.SetPersistentMatches();
            }
            catch (Exception ex)
            {
                DialogViewModel dialogViewModel = new DialogViewModel($"There was an exeption while writing to the library:\n {ex.Message}", "Library Exception", true);
                dialogService.ShowDialog(dialogViewModel);
            }
        }
 /// <summary>
 /// Write an index row of key pair of <param name="rowPrimaryKey"> <param name="rowLocation"> using the WriteType <param name="type">.
 /// </summary>
 /// <param name="rowPrimaryKey">
 /// Primary key for row.
 /// </param>
 /// <param name="rowLocation">
 /// The location of the row with <param name="rowPrimaryKey"> in the database.
 /// </param>
 /// <param name="type">
 /// The kind of row write to perform.
 /// </param>
 private void WriteIndexRow(int rowPrimaryKey, int rowLocation, WriteType type)
 {
     // If we're moving an index within the index file (rellocating), set the stream position appropriately.
     if (type == WriteType.IndexRowMove)
     {
         IndexStream.Position = (rowLocation - 1) * INDEX_ROW_BYTE_SIZE;
     }
     // Write the index values.
     IndexWriter.Write(rowPrimaryKey);
     IndexWriter.Write(rowLocation);
 }
        public void Dev2PutRawOperation_Constructor_TakesContentsAndWriteTypeEnum()
        {
            //------------Setup for test--------------------------
            const WriteType WriteType = WriteType.AppendBottom;
            const string    Contents  = "Some test";
            //------------Execute Test---------------------------
            var dev2PutRawOperation = new Dev2PutRawOperationTO(WriteType, Contents);

            //------------Assert Results-------------------------
            Assert.IsNotNull(dev2PutRawOperation);
        }
Beispiel #13
0
 public static void SetLogFileName(WriteType writeType, bool useTempFolder = false)
 {
     try
     {
         string logFolder = CreateLogFolder(useTempFolder);
         string fileName  = string.Format("{0}.log", GetProgramName());
         if (writeType == WriteType.CreateNew)
         {
             string[] existingLogFiles = Directory.GetFiles(logFolder, string.Format("{0}*.log", GetProgramName()));
             if (existingLogFiles.Length != 0)
             {
                 int maxLogFileNumber = 0;
                 foreach (string logFile in existingLogFiles)
                 {
                     string[] sep = new string[1];
                     sep[0] = GetProgramName();
                     string[] logNumbers = logFile.Split(sep, StringSplitOptions.RemoveEmptyEntries);
                     foreach (string workingNumber in logNumbers)
                     {
                         string num = workingNumber.ToUpper().Replace(".LOG", "");
                         if (int.TryParse(num, out int n))
                         {
                             if (n > maxLogFileNumber)
                             {
                                 maxLogFileNumber = n;
                             }
                         }
                     }
                 }
                 fileName = string.Format("{0}{1}.log", GetProgramName(), maxLogFileNumber + 1);
             }
         }
         LogFile = new FileInfo(Path.Combine(logFolder, fileName));
         Debug.WriteLine(string.Format("Logfile name: {0}", LogFile.FullName));
         string initial = string.Format("\r\nLog start: {0}\r\n----------------------\r\n", DateTime.Now.ToString("MM/dd/yyyy HH:mm:ss"));
         if (writeType == WriteType.OverWrite)
         {
             File.WriteAllText(LogFile.FullName, initial);
         }
         else
         {
             File.AppendAllText(LogFile.FullName, initial);
         }
     }
     catch (Exception e)
     {
         Debug.WriteLine("Exception occured during SetLogFileName: " + e.Message);
         if (WriteToConsole)
         {
             Console.WriteLine("Exception occured during SetLogFileName: " + e.Message);
         }
     }
 }
        public void Dev2PutRawOperationTO_Constructor_GivenParameter_ShouldSetProperties()
        {
            //------------Setup for test--------------------------
            const WriteType WriteType = WriteType.AppendBottom;
            const string    Contents  = "Some test";
            //------------Execute Test---------------------------
            var dev2PutRawOperation = new Dev2PutRawOperationTO(WriteType, Contents);

            //------------Assert Results-------------------------
            Assert.AreEqual(WriteType, dev2PutRawOperation.WriteType);
            Assert.AreEqual(Contents, dev2PutRawOperation.FileContents);
        }
Beispiel #15
0
 /// <summary>
 /// This takes ownership of the random number generator.
 /// </summary>
 public DelegateEnvironment(Random rand, int verbose       = 0,
                            MessageSensitivity sensitivity = MessageSensitivity.All, int conc = 0,
                            WriteType outWriter            = null, WriteType errWriter = null)
     : base(rand, verbose > 0, conc, nameof(DelegateEnvironment))
 {
     Contracts.CheckValueOrNull(outWriter);
     Contracts.CheckValueOrNull(errWriter);
     Contracts.CheckParam(verbose >= 0 && verbose <= 4, nameof(verbose), "verbose must be in [[0, 4]]");
     _outErrWriter     = new OutErrLogWriter(this, new LogWriter(outWriter), new LogWriter(errWriter), verbose);
     _sensitivityFlags = sensitivity;
     _verbose          = verbose;
     AddListener <ChannelMessage>(PrintMessage);
 }
Beispiel #16
0
        private void writeGetterSetter(StreamWriter sw, List <CStruct> cstructs, WriteType t)
        {
            /*string[] whiteList = new string[] {
             *  "OMX_PARAM_PORTDEFINITIONTYPE" ,
             *  "OMX_AUDIO_PORTDEFINITIONTYPE",
             *  "OMX_VIDEO_PORTDEFINITIONTYPE",
             *  "OMX_IMAGE_PORTDEFINITIONTYPE",
             *  "OMX_OTHER_PORTDEFINITIONTYPE",
             *  "OMX_VIDEO_PARAM_PORTFORMATTYPE"
             * };*/
            foreach (CStruct cstruct in cstructs)
            {
                //if (!whiteList.Contains(cstruct.name)) continue;
                if (blackList.Contains(cstruct.name))
                {
                    continue;
                }

                if (t == WriteType.get)
                {
                    writeFunctionGetter(sw, cstruct, false, cstructs);
                }
                else
                {
                    writeFunctionSetter(sw, cstruct, false, cstructs);
                }
            }

            sw.WriteLine();

            foreach (CStruct cstruct in cstructs)
            {
                //if (!whiteList.Contains(cstruct.name)) continue;
                if (blackList.Contains(cstruct.name))
                {
                    continue;
                }

                if (t == WriteType.get)
                {
                    writeFunctionGetter(sw, cstruct, true, cstructs);
                    sw.WriteLine();
                }
                else
                {
                    writeFunctionSetter(sw, cstruct, true, cstructs);
                    sw.WriteLine();
                }
            }
        }
Beispiel #17
0
        /// <summary>
        /// 将 System.Object 写入 HTTP 响应流。
        /// </summary>
        /// <param name="obj">要写入 HTTP 输出流的 System.Object。</param>
        /// <param name="contentType">返回客户端的类型</param>
        public async Task WriteAsync(object obj, WriteType contentType)
        {
            if (Response != null)
            {
                if (obj == null)
                {
                    obj = string.Empty;
                }
                bool isstr = obj.GetType() == typeof(string);

                switch (contentType)
                {
                case WriteType.Html:
                    SetContentType("text/html");
                    await Response.WriteAsync(obj.ToString());

                    break;

                case WriteType.Json:
                    SetContentType("application/json");
                    await Response.WriteAsync(isstr?obj.ToString() : obj.ToJson(routeData.JsonOptions));

                    break;

                case WriteType.Xml:
                    SetContentType("application/xml");
                    await Response.WriteAsync(obj.ToString());

                    break;

                case WriteType.Text:
                    SetContentType("text/plain");
                    await Response.WriteAsync(obj.ToString());

                    break;
                }
            }
            else
            {
                throw new System.Exception("请在{Ashx注入后}调用方法,使用。");
            }
        }
Beispiel #18
0
 private string PrepareLine(WriteType type, Exception exception, string message)
 {
     if (exception != null)
     {
         return(string.Format("{0} {1} {2} {3} {4}\r\n{5}\r\n",
                              DateTime.Now.ToShortDateString(),
                              DateTime.Now.ToShortTimeString(),
                              Enum.GetName(typeof(WriteType), type),
                              message,
                              exception.Message,
                              exception.StackTrace));
     }
     else
     {
         return(string.Format("{0} {1} {2} {3}",
                              DateTime.Now.ToShortDateString(),
                              DateTime.Now.ToShortTimeString(),
                              Enum.GetName(typeof(WriteType), type),
                              message));
     }
 }
Beispiel #19
0
 private void InternalWrite(WriteType type, Exception exception, string message)
 {
     try
     {
         lock (_locker)
         {
             var logDir = Path.Combine(global::Android.OS.Environment.ExternalStorageDirectory.AbsolutePath, "LazuriteLogs");
             if (!Directory.Exists(logDir))
             {
                 Directory.CreateDirectory(logDir);
             }
             var logPath = Path.Combine(logDir, _logFileName);
             if (!File.Exists(logPath))
             {
                 File.Create(logPath);
             }
             if (new FileInfo(logPath).Length > 1024 * 1024 * 1024) //1mb
             {
                 File.WriteAllText(logPath, PrepareLine(type, exception, message));
             }
             else
             {
                 File.AppendAllLines(logPath, new[] { PrepareLine(type, exception, message) });
             }
         }
     }
     catch (Exception e)
     {
         try
         {
             AlertDialog.Builder alert = new AlertDialog.Builder(Application.Context);
             alert.SetMessage("Ошибка при записи в лог: " + e.Message);
             alert.Show();
         }
         catch
         {
             //mega crutch
         }
     }
 }
Beispiel #20
0
        public WriterBase GetWriter(WriteType writerType, TextControl textControl)
        {
            var writer = default(WriterBase);

            switch (writerType)
            {
            case WriteType.Instant:
                writer = _writers[typeof(InstantWriter)];
                break;

            case WriteType.CharByChar:
                writer = _writers[typeof(CharByCharWriter)];
                break;

            default:
                Debug.LogError($"Type: {writerType} is not in the factory.");
                return(null);
            }

            writer.SetTextControl(textControl);

            return(writer);
        }
Beispiel #21
0
        /// <summary>
        /// 将 System.Object 写入 HTTP 响应流。
        /// </summary>
        /// <param name="obj">要写入 HTTP 输出流的 System.Object。</param>
        /// <param name="contentType">返回客户端的类型</param>
        public void Write(object obj, WriteType contentType)
        {
            WriteAsync(obj, contentType).Wait();

            //if (Response != null)
            //{
            //    if (obj == null)
            //    {
            //        obj = string.Empty;
            //    }
            //    bool isstr = obj.GetType() == typeof(string);

            //    switch (contentType)
            //    {
            //        case WriteType.Html:
            //            SetContentType("text/html");
            //            Response.Write(obj.ToString());
            //            break;
            //        case WriteType.Json:
            //            SetContentType("application/json");
            //            Response.Write(isstr ? obj.ToString() : obj.ToJson());
            //            break;
            //        case WriteType.Xml:
            //            SetContentType("application/xml");
            //            Response.Write(obj.ToString());
            //            break;
            //        case WriteType.Text:
            //            SetContentType("text/plain");
            //            Response.Write(obj.ToString());
            //            break;
            //    }
            //}
            //else
            //{
            //    throw new System.Exception("请在{Ashx注入后}调用方法,使用。");
            //}
        }
Beispiel #22
0
        public void InitializeWriteType()
        {
            string columnType = GetType();

            switch (columnType)
            {
            case "int":
            case "decimal":
                WriteType = WriteType.Default;
                break;

            case "DateTime":
                WriteType = WriteType.Default;
                break;

            case "bool":
                WriteType = WriteType.Checkbox;
                break;

            default:
                WriteType = WriteType.Default;
                break;
            }
        }
 /// <summary>
 /// Write the row <param name="row"> with primary key <param name="primaryKey"> using the WriteType <param name="type">.
 /// </summary>
 /// <param name="row">
 /// Row to write.
 /// </param>
 /// <param name="primaryKey">
 /// Primary key of row to write.
 /// </param>
 /// <param name="type">
 /// The kind of row write to perform.
 /// </param>
 private void WriteRow(Row row, int primaryKey, WriteType type)
 {
     // If we're not udating an existing row. I.e. moving a row, writing a new row or deleting a row.
     if (type != WriteType.RowUpdate)
     {
         if (type != WriteType.NewRowWrite)
         {
             // Set the database stream to the location of the row
             DataBaseStream.Position = (Index [row.PrimaryKey] - 1) * ROW_BYTE_SIZE + HEADER_BYTE_SIZE;
         }
         // If the row is deleted, only write to it's status and leave the method.
         if (type == WriteType.RowDelete)
         {
             DataBaseWriter.Write(row.Status);
             return;
         }
         // Write the row's status and primary key.
         DataBaseWriter.Write(row.Status);
         DataBaseWriter.Write(primaryKey);
         // If it's a new row, write the new row's data and return from the method.
         if (type == WriteType.NewRowWrite)
         {
             DataBaseWriter.Write(row.NewTextData.PadRight(20, (char)0).ToCharArray());
             DataBaseWriter.Write(row.NewNumberData);
             return;
         }
     }
     // If the row is being updated, set the database stream to the rows data locaton
     if (type == WriteType.RowUpdate)
     {
         DataBaseStream.Position = (Index [row.PrimaryKey] - 1) * ROW_BYTE_SIZE + HEADER_BYTE_SIZE + ROW_DATA_LOCATION;
     }
     // Write the row data. This will happen for rows being moved or updated.
     DataBaseWriter.Write(row.TextData.PadRight(20, (char)0).ToCharArray());
     DataBaseWriter.Write(row.NumberData);
 }
        public static void Write(WriteType type, string message, params object[] args)
        {
            var template = string.Format(" \t{0}:->{1} \t\t \t", type, message);

            Console.WriteLine(string.Format(template, args));
        }
 public Dev2PutRawOperationTO(WriteType writeType, string contents)
 {
     WriteType = writeType;
     FileContents = contents;
 }
Beispiel #26
0
        private char GetCharForLine(WriteType Type)
        {
            if (Type.Equals(WriteType.Outgoing))
            {
                return '»';
            }

            return '«';
        }
Beispiel #27
0
 /// <summary>
 /// Create an PutRawOperationTo object
 /// </summary>
 /// <returns></returns>
 public static Dev2PutRawOperationTO CreatePutRawOperationTO(WriteType writeType, string contents)
 {
     return(new Dev2PutRawOperationTO(writeType, contents));
 }
Beispiel #28
0
        /// <summary>
        /// Write changes to the PCM's flash memory.
        /// </summary>
        private async void write_BackgroundThread(WriteType writeType)
        {
            using (new AwayMode())
            {
                try
                {
                    this.currentWriteType = writeType;

                    if (this.Vehicle == null)
                    {
                        // This shouldn't be possible - it would mean the buttons
                        // were enabled when they shouldn't be.
                        return;
                    }

                    this.cancellationTokenSource = new CancellationTokenSource();

                    string path = null;
                    this.Invoke((MethodInvoker) delegate()
                    {
                        this.DisableUserInput();
                        this.cancelButton.Enabled = true;

                        path = this.ShowOpenDialog();
                    });

                    if (path == null)
                    {
                        return;
                    }

                    this.AddUserMessage(path);

                    byte[] image;
                    using (Stream stream = File.OpenRead(path))
                    {
                        image = new byte[stream.Length];
                        int bytesRead = await stream.ReadAsync(image, 0, (int)stream.Length);

                        if (bytesRead != stream.Length)
                        {
                            // If this happens too much, we should try looping rather than reading the whole file in one shot.
                            this.AddUserMessage("Unable to load file.");
                            return;
                        }
                    }

                    // Sanity checks.
                    FileValidator validator = new FileValidator(image, this);
                    if (!validator.IsValid())
                    {
                        this.AddUserMessage("This file is corrupt. It would render your PCM unusable.");
                        return;
                    }

                    UInt32 kernelVersion = 0;
                    bool   needUnlock;
                    int    keyAlgorithm               = 1;
                    UInt32 pcmOperatingSystemId       = 0;
                    bool   needToCheckOperatingSystem = writeType != WriteType.Full;

                    this.AddUserMessage("Requesting operating system ID...");
                    Response <uint> osidResponse = await this.Vehicle.QueryOperatingSystemId(this.cancellationTokenSource.Token);

                    if (osidResponse.Status == ResponseStatus.Success)
                    {
                        pcmOperatingSystemId = osidResponse.Value;
                        PcmInfo info = new PcmInfo(pcmOperatingSystemId);
                        keyAlgorithm = info.KeyAlgorithm;
                        needUnlock   = true;

                        if (needToCheckOperatingSystem && !validator.IsSameOperatingSystem(pcmOperatingSystemId))
                        {
                            this.AddUserMessage("Flashing this file could render your PCM unusable.");
                            return;
                        }

                        needToCheckOperatingSystem = false;
                    }
                    else
                    {
                        if (this.cancellationTokenSource.Token.IsCancellationRequested)
                        {
                            return;
                        }

                        this.AddUserMessage("Operating system request failed, checking for a live kernel...");

                        kernelVersion = await this.Vehicle.GetKernelVersion();

                        if (kernelVersion == 0)
                        {
                            this.AddUserMessage("Checking for recovery mode...");
                            bool recoveryMode = await this.Vehicle.IsInRecoveryMode();

                            if (recoveryMode)
                            {
                                this.AddUserMessage("PCM is in recovery mode.");
                                needUnlock = true;
                            }
                            else
                            {
                                this.AddUserMessage("PCM is not responding to OSID, kernel version, or recovery mode checks.");
                                this.AddUserMessage("Unlock may not work, but we'll try...");
                                needUnlock = true;
                            }
                        }
                        else
                        {
                            needUnlock = false;

                            this.AddUserMessage("Kernel version: " + kernelVersion.ToString("X8"));

                            this.AddUserMessage("Asking kernel for the PCM's operating system ID...");
                            if (needToCheckOperatingSystem && !await this.Vehicle.IsSameOperatingSystemAccordingToKernel(validator, this.cancellationTokenSource.Token))
                            {
                                this.AddUserMessage("Flashing this file could render your PCM unusable.");
                                return;
                            }

                            needToCheckOperatingSystem = false;
                        }
                    }

                    await this.Vehicle.SuppressChatter();

                    if (needUnlock)
                    {
                        bool unlocked = await this.Vehicle.UnlockEcu(keyAlgorithm);

                        if (!unlocked)
                        {
                            this.AddUserMessage("Unlock was not successful.");
                            return;
                        }

                        this.AddUserMessage("Unlock succeeded.");
                    }

                    DateTime start = DateTime.Now;

                    CKernelWriter writer = new CKernelWriter(
                        this.Vehicle,
                        new Protocol(),
                        this);

                    await writer.Write(
                        image,
                        writeType,
                        kernelVersion,
                        validator,
                        needToCheckOperatingSystem,
                        this.cancellationTokenSource.Token);

                    this.AddUserMessage("Elapsed time " + DateTime.Now.Subtract(start));
                }
                catch (IOException exception)
                {
                    this.AddUserMessage(exception.ToString());
                }
                finally
                {
                    this.currentWriteType = WriteType.None;

                    this.Invoke((MethodInvoker) delegate()
                    {
                        this.EnableUserInput();
                        this.cancelButton.Enabled = false;
                    });

                    // The token / token-source can only be cancelled once, so we need to make sure they won't be re-used.
                    this.cancellationTokenSource = null;
                }
            }
        }
Beispiel #29
0
        public void ScretchLine(string Line, WriteType Type)
        {
            using (TextWriter Writer = this.Writer)
            {
                lock (Writer)
                {
                    string Format = string.Format(" [{0}] {1} {2}", DateTime.Now.ToShortTimeString(), GetCharForLine(Type), Line);

                    Writer.WriteLine(Format);

                    BrickEngine.GetMemoryWriter().ImportLine(Format);
                }
            }

            PaintLogger.Clear();
        }
 public Dev2PutRawOperationTO(WriteType writeType, string contents)
 {
     WriteType    = writeType;
     FileContents = contents;
 }
 /// <summary>
 /// Create an PutRawOperationTo object
 /// </summary>
 /// <returns></returns>
 public static Dev2PutRawOperationTO CreatePutRawOperationTO(WriteType writeType, string contents)
 {
     return new Dev2PutRawOperationTO(writeType, contents);
 }
Beispiel #32
0
 public static Dev2PutRawOperationTO CreatePutRawOperationTO(WriteType writeType, string contents, bool fileContentsAsBase64 = false) => new Dev2PutRawOperationTO(writeType, contents, fileContentsAsBase64);
 public static void Write(WriteType type, string message, params object[] args)
 {
     message = message.Replace("{","{{").Replace("}","}}");
     var template = string.Format(" \t{0}:->{1} \t\t \t", type, message);
     Console.WriteLine(string.Format(template, args));
 }
Beispiel #34
0
        /// <summary>
        /// Write changes to the PCM's flash memory, or just test writing (Without
        /// making changes) to evaluate the connection quality.
        /// </summary>
        public async Task <bool> Write(
            byte[] image,
            WriteType writeType,
            UInt32 kernelVersion,
            FileValidator validator,
            bool needToCheckOperatingSystem,
            CancellationToken cancellationToken)
        {
            bool success = false;

            try
            {
                await this.vehicle.SendToolPresentNotification();

                this.vehicle.ClearDeviceMessageQueue();

                // TODO: install newer version if available.
                if (kernelVersion == 0)
                {
                    // switch to 4x, if possible. But continue either way.
                    // if the vehicle bus switches but the device does not, the bus will need to time out to revert back to 1x, and the next steps will fail.
                    if (!await this.vehicle.VehicleSetVPW4x(VpwSpeed.FourX))
                    {
                        this.logger.AddUserMessage("Stopping here because we were unable to switch to 4X.");
                        return(false);
                    }

                    Response <byte[]> response = await this.vehicle.LoadKernelFromFile("write-kernel.bin");

                    if (response.Status != ResponseStatus.Success)
                    {
                        logger.AddUserMessage("Failed to load kernel from file.");
                        return(false);
                    }

                    if (cancellationToken.IsCancellationRequested)
                    {
                        return(false);
                    }

                    // TODO: instead of this hard-coded address, get the base address from the PcmInfo object.
                    if (!await this.vehicle.PCMExecute(response.Value, 0xFF8000, cancellationToken))
                    {
                        logger.AddUserMessage("Failed to upload kernel to PCM");

                        return(false);
                    }

                    logger.AddUserMessage("Kernel uploaded to PCM succesfully.");
                }

                if (needToCheckOperatingSystem)
                {
                    if (!await this.vehicle.IsSameOperatingSystemAccordingToKernel(validator, cancellationToken))
                    {
                        this.logger.AddUserMessage("Flashing this file could render your PCM unusable.");
                        return(false);
                    }
                }

                success = await this.Write(cancellationToken, image, writeType);

                // We only do cleanup after a successful write.
                // If the kernel remains running, the user can try to flash again without rebooting and reloading.
                // TODO: kernel version should be stored at a fixed location in the bin file.
                // TODO: app should check kernel version (not just "is present") and reload only if version is lower than version in kernel file.
                if (success)
                {
                    await this.vehicle.Cleanup();
                }

                return(success);
            }
            catch (Exception exception)
            {
                if (!success)
                {
                    switch (writeType)
                    {
                    case WriteType.None:
                    case WriteType.Compare:
                    case WriteType.TestWrite:
                        await this.vehicle.Cleanup();

                        this.logger.AddUserMessage("Something has gone wrong. Please report this error.");
                        this.logger.AddUserMessage("Errors during comparisons or test writes indicate a");
                        this.logger.AddUserMessage("problem with the PCM, interface, cable, or app. Don't");
                        this.logger.AddUserMessage("try to do any actual writing until you are certain that");
                        this.logger.AddUserMessage("the underlying problem has been completely corrected.");
                        break;

                    default:
                        this.logger.AddUserMessage("Something went wrong. " + exception.Message);
                        this.logger.AddUserMessage("Do not power off the PCM! Do not exit this program!");
                        this.logger.AddUserMessage("Try flashing again. If errors continue, seek help online.");
                        break;
                    }

                    this.logger.AddUserMessage("https://pcmhacking.net/forums/viewtopic.php?f=42&t=6080");
                    this.logger.AddUserMessage(string.Empty);
                    this.logger.AddUserMessage(exception.ToString());
                }

                return(success);
            }
        }
Beispiel #35
0
        /// <summary>
        /// Write the calibration blocks.
        /// </summary>
        private async Task <bool> Write(CancellationToken cancellationToken, byte[] image, WriteType writeType)
        {
            await this.vehicle.SendToolPresentNotification();

            BlockType relevantBlocks;

            switch (writeType)
            {
            case WriteType.Compare:
                relevantBlocks = BlockType.All;
                break;

            case WriteType.TestWrite:
                relevantBlocks = BlockType.Calibration;
                break;

            case WriteType.Calibration:
                relevantBlocks = BlockType.Calibration;
                break;

            case WriteType.Parameters:
                relevantBlocks = BlockType.Parameter;
                break;

            case WriteType.OsAndCalibration:
                relevantBlocks = BlockType.Calibration | BlockType.OperatingSystem;
                break;

            case WriteType.Full:
                // Overwriting parameter blocks would break the EBCM pairing,
                // which is not what most users want. They just want a new OS
                // and the calibration to go along with it.
                //
                // The cast seems redundant, but C# converts the enum values
                // to ints when it does arithmetic.
                relevantBlocks = (BlockType)(BlockType.All - BlockType.Parameter);
                break;

            default:
                throw new InvalidDataException("Unsuppported operation type: " + writeType.ToString());
            }

            // Which flash chip?
            await this.vehicle.SendToolPresentNotification();

            await this.vehicle.SetDeviceTimeout(TimeoutScenario.ReadProperty);

            Query <UInt32> chipIdQuery = this.vehicle.CreateQuery <UInt32>(
                this.protocol.CreateFlashMemoryTypeQuery,
                this.protocol.ParseFlashMemoryType,
                cancellationToken);
            Response <UInt32> chipIdResponse = await chipIdQuery.Execute();

            if (chipIdResponse.Status != ResponseStatus.Success)
            {
                logger.AddUserMessage("Unable to determine which flash chip is in this PCM");
                return(false);
            }

            // TODO: Move the device types lookup to a function in Misc/FlashChips.cs
            // known chips in the P01 and P59
            // http://ftp1.digi.com/support/documentation/jtag_v410_flashes.pdf
            string Amd     = "AMD";               // 0001
            string Intel   = "Intel";             // 0089
            string I4471   = "28F400B5-B 512Kb";  // 4471
            string A2258   = "Am29F800B 1Mbyte";  // 2258
            string I889D   = "28F800B5-B 1Mbyte"; // 889D
            string unknown = "unknown";           // default case

            logger.AddUserMessage("Flash memory ID code: " + chipIdResponse.Value.ToString("X8"));

            switch ((chipIdResponse.Value >> 16))
            {
            case 0x0001: logger.AddUserMessage("Flash memory manufactuer: " + Amd);
                break;

            case 0x0089: logger.AddUserMessage("Flash memory manufactuer: " + Intel);
                break;

            default: logger.AddUserMessage("Flash memory manufactuer: " + unknown);
                break;
            }

            switch (chipIdResponse.Value & 0xFFFF)
            {
            case 0x4471: logger.AddUserMessage("Flash memory type: " + I4471);
                break;

            case 0x2258: logger.AddUserMessage("Flash memory type: " + A2258);
                break;

            case 0x889D: logger.AddUserMessage("Flash memory type: " + I889D);
                break;

            default: logger.AddUserMessage("Flash memory type: " + unknown);
                break;
            }

            await this.vehicle.SendToolPresentNotification();

            IList <MemoryRange> ranges = FlashChips.GetMemoryRanges(chipIdResponse.Value, this.logger);

            if (ranges == null)
            {
                return(false);
            }

            CKernelVerifier verifier = new CKernelVerifier(
                image,
                ranges,
                this.vehicle,
                this.protocol,
                this.logger);

            bool allRangesMatch = false;
            bool writeAttempted = false;

            for (int attempt = 1; attempt <= 5; attempt++)
            {
                if (await verifier.CompareRanges(
                        ranges,
                        image,
                        relevantBlocks,
                        cancellationToken))
                {
                    allRangesMatch = true;

                    // Don't stop here if the user just wants to test their cable.
                    if (writeType == WriteType.TestWrite)
                    {
                        if (attempt == 1)
                        {
                            this.logger.AddUserMessage("Beginning test.");
                        }
                    }
                    else
                    {
                        this.logger.AddUserMessage("All ranges are identical.");
                        return(true);
                    }
                }

                if ((writeType == WriteType.TestWrite) && (attempt > 1))
                {
                    // TODO: the app should know if any errors were encountered. The user shouldn't need to check.
                    this.logger.AddUserMessage("Test complete. Were any errors logged above?");
                    return(true);
                }

                // Stop now if the user only requested a comparison.
                if (writeType == WriteType.Compare)
                {
                    this.logger.AddUserMessage("Note that mismatched Parameter blocks are to be expected.");
                    this.logger.AddUserMessage("Parameter data can change every time the PCM is used.");
                    return(true);
                }

                writeAttempted = true;

                // Erase and rewrite the required memory ranges.
                await this.vehicle.SetDeviceTimeout(TimeoutScenario.Maximum);

                foreach (MemoryRange range in ranges)
                {
                    // We'll send a tool-present message during the erase request.
                    if ((range.ActualCrc == range.DesiredCrc) && (writeType != WriteType.TestWrite))
                    {
                        continue;
                    }

                    if ((range.Type & relevantBlocks) == 0)
                    {
                        continue;
                    }

                    this.logger.AddUserMessage(
                        string.Format(
                            "Processing range {0:X6}-{1:X6}",
                            range.Address,
                            range.Address + (range.Size - 1)));

                    if (writeType == WriteType.TestWrite)
                    {
                        this.logger.AddUserMessage("Pretending to erase.");
                    }
                    else
                    {
                        if (!await this.EraseMemoryRange(range, cancellationToken))
                        {
                            return(false);
                        }
                    }

                    if (writeType == WriteType.TestWrite)
                    {
                        this.logger.AddUserMessage("Pretending to write...");
                    }
                    else
                    {
                        this.logger.AddUserMessage("Writing...");
                    }

                    await this.vehicle.SendToolPresentNotification();

                    await WriteMemoryRange(
                        range,
                        image,
                        writeType == WriteType.TestWrite,
                        cancellationToken);
                }
            }

            if (!writeAttempted)
            {
                this.logger.AddUserMessage("Assertion failed. WriteAttempted should be true.");
            }

            if (allRangesMatch)
            {
                this.logger.AddUserMessage("Flash successful!");
                return(true);
            }

            this.logger.AddUserMessage("===============================================");
            this.logger.AddUserMessage("THE CHANGES WERE -NOT- WRITTEN SUCCESSFULLY");
            this.logger.AddUserMessage("===============================================");

            if (writeType == WriteType.Calibration)
            {
                this.logger.AddUserMessage("Erasing Calibration to force recovery mode.");
                this.logger.AddUserMessage("");

                foreach (MemoryRange range in ranges)
                {
                    if (range.Type == BlockType.Calibration)
                    {
                        await this.EraseMemoryRange(range, cancellationToken);
                    }
                }
            }

            if (cancellationToken.IsCancellationRequested)
            {
                this.logger.AddUserMessage("");
                this.logger.AddUserMessage("The operation was cancelled.");
                this.logger.AddUserMessage("This PCM is probably not usable in its current state.");
                this.logger.AddUserMessage("");
            }
            else
            {
                this.logger.AddUserMessage("This may indicate a hardware problem on the PCM.");
                this.logger.AddUserMessage("We tried, and re-tried, and it still didn't work.");
                this.logger.AddUserMessage("");
                this.logger.AddUserMessage("Please start a new thread at pcmhacking.net, and");
                this.logger.AddUserMessage("include the contents of the debug tab.");
                this.RequestDebugLogs(cancellationToken);
            }

            return(false);
        }
Beispiel #36
0
        public async Task WriteTests(int[][] writes, WriteType writeType)
        {
            await RunClientServer(
                async clientConnection =>
            {
                await using QuicStream stream = clientConnection.OpenUnidirectionalStream();

                foreach (int[] bufferLengths in writes)
                {
                    switch (writeType)
                    {
                    case WriteType.SingleBuffer:
                        foreach (int bufferLength in bufferLengths)
                        {
                            await stream.WriteAsync(new byte[bufferLength]);
                        }
                        break;

                    case WriteType.GatheredBuffers:
                        var buffers = bufferLengths
                                      .Select(bufferLength => new ReadOnlyMemory <byte>(new byte[bufferLength]))
                                      .ToArray();
                        await stream.WriteAsync(buffers);
                        break;

                    case WriteType.GatheredSequence:
                        var firstSegment          = new BufferSegment(new byte[bufferLengths[0]]);
                        BufferSegment lastSegment = firstSegment;

                        foreach (int bufferLength in bufferLengths.Skip(1))
                        {
                            lastSegment = lastSegment.Append(new byte[bufferLength]);
                        }

                        var buffer = new ReadOnlySequence <byte>(firstSegment, 0, lastSegment, lastSegment.Memory.Length);
                        await stream.WriteAsync(buffer);
                        break;

                    default:
                        Debug.Fail("Unknown write type.");
                        break;
                    }
                }

                stream.Shutdown();
                await stream.ShutdownCompleted();
            },
                async serverConnection =>
            {
                await using QuicStream stream = await serverConnection.AcceptStreamAsync();

                var buffer        = new byte[4096];
                int receivedBytes = 0, totalBytes = 0;

                while ((receivedBytes = await stream.ReadAsync(buffer)) != 0)
                {
                    totalBytes += receivedBytes;
                }

                int expectedTotalBytes = writes.SelectMany(x => x).Sum();
                Assert.Equal(expectedTotalBytes, totalBytes);

                stream.Shutdown();
                await stream.ShutdownCompleted();
            });
        }
 public static void Write(WriteType type, string message, params object[] args)
 {
     var template = string.Format(" \t{0}:->{1} \t\t \t", type, message);
     Console.WriteLine(string.Format(template, args));
 }
Beispiel #38
0
 public static void WriteLine(WriteType writeType, string @out, params object[] args)
 {
     SetConsoleColorFromType(writeType);
     SysCon.WriteLine(@out, args);
     SetConsoleColorFromType();
 }