Git - git-format-patch Documentation

Samsung and updates

Lately, updates (especially monthly security updates) have been a hot topic for Samsung Galaxy owners, especially S8/S8+ and Note8 owners. Since there seems to be lots of misinformation flying around, lots of obtuseness, et cetera... So let's clear it up.
Update lifecycle
First, security updates. The life of a security update is pretty simple:
The thing is, security updates are NOT available from the very start to other manufacturers. Only Google has it, and they can test it for a month - since it only affects 4-6 devices, that have little to no changes compared to AOSP.
Manufacturers on the other hand severely modify AOSP to incorporate their own framework, their own softwares, features, etc. - which means even further adaptation is required, should a security update touch something they have heavily modified.
Perfect example is Samsung and the September security update. The update consists mainly of the Blueborne patch, and some smaller fixes, mainly on subsystems Samsung has already replaced.
Samsung opted to not "release" the September update. The main reason? The Samsung Bluetooth stack is considerably different from the AOSP one. Samsung heavily modified it, thus 1:1 adopting it was not possible. Samsung had to make their own solution based on Google's fixes, which they did, quite fast actually. However since they took a completely different approach, the September security patch update was never really merged as-is, thus, the patch date stayed 1st August, which caused quite the commotion.
Update rollouts
This is the trickier one. Samsung has two way to update: either a full firmware update (FFU), or firmware over the air (FOTA). FFU is a full flash of the new firmware, replacing the data bit by bit on the device. FOTA is basically a delta patch (a delta patch is a small file that contains changes between firmware versions, it's basically a diff of the two files. Name comes from physics, where change is denoted by Δ - delta).
FOTA updates are delivered directly to the devices, and are usually small in size (few hundred megabytes tops) - this also depends on the amount of files added, and of course, the amount of binary differences between files.
FFU on the other hand is done through ODIN mode, where the full firmware image (in the case of the S8/S8+/Note8, over 6GB!) is downloaded and flashed on the device. This includes pretty low-level stuff too, such as bootloader updates (FOTA most often won't update bootloader, only if it is of crucial importance - since it can result in a brick, should there be an error. FOTA updates are meant for production, FFU is meant for service centers and savvier users). It also allows wiping the device completely, and in certain cases, even re-partitioning (this is the most dangerous thing to do, since the PIT - Partition Information Table - file, if mis-flashed, can result in a complete brick only revivable in a service center). Re-partitioning could possibly allow us to have the same A/B update mechanism as the Pixels - with the required negative effect of losing another 6GB of storage, approximately.
Now, let's talk about firmware rollouts. I will only take the S8/S8+/Note8 international models into account, since I only have experience with those (if you have a firm grasp on how Samsung updates US models, please, do write in detail about it, and I will include it in this description).
An update, once it's tested and ready for release, is uploaded to Samsung's own firmware delivery network (FDN). Samsung has multiple FDNs, one for internal use (called Fenrir), and one specific for public releases (used by KIES, SamFirm, etc.). Of course, we only have access to the official one.
Basically when an update becomes available, FOTA is the first to be released, in a staged manner. Usually the first CSC to receive an update is the Netherlands unlocked (PHN). Then further CSCs (mostly Germany, France, UK, Italy, Spain, Austria) receive it, gradually. This is so if there's a slight bug that went through testing, Samsung can stop the rollout before millions of devices are affected. Also it helps distributing server loads.
After the first FOTA release, FFU is also released for the same CSC. This can happen slightly before, or even days after the FOTA rollout. Since most European CSC is contained in the common, shared OMX CSC (which contains almost all carrier firmwares, sans Vodafone), you can e.g. flash the PHN release and still have everything working. Of course OTAs won't arrive faster, since they're tied to the active CSC, which won't change.
This staged rollout means that some people get it WAY sooner than others. And it's quite annoying to read at EVERY.FREAKING.POST that people post "I got nothing on my {so and so} device". Honestly, since it's staged rollout, of course there won't be an update out for you just yet!
Instead, if you're brave (and savvy) enough, you can grab the latest FFU, which rolls out a few hours after the FOTA, and flash the whole thing on your device. You'll need the latest ODIN, SamFirm, a Windows PC, and a few hours of time for it to download (depending on your internet speed, I was able to stress Samsung's servers to provide up to 50MB/s, yes, megaBYTES per second). Flashing only takes a few minutes.
Downloading the latest firmware
The easiest way to grab the truly latest firmware is SamFirm. It's a small Windows app, running it requires the .Net 3.5 framework (which shouldn't be an issue as long as you're on Windows 7 or newer).
Just download the latest release (0.3.6), enter your model and region (CSC), check the Auto box (it is so it grabs the latest firmware automatically, otherwise you'd need to enter firmware version manually), and hit Check Update. It will run a check and give you a nice little result:
Checking firmware for SM-G950F/PHN/G950FXXU1AQI9/G950FOXM1AQI9/G950FXXU1AQI9/G950FXXU1AQI9 Error: Could not send BinaryInform. Status code 200/400 Request was invalid. Are you sure the input data is correct? Checking firmware for SM-G950F/PHN/G950FXXU1AQF7/G950FOXM1AQF7/G950FXXU1AQF7/G950FXXU1AQF7 Model: SM-G950F Version: G950FXXU1AQI7/G950FOXM1AQI7/G950FXXU1AQI7/G950FXXU1AQI7 OS: Nougat(Android 7.0) Filename: Size: 3491364336 bytes LogicValue: k7eqvjd1vp888xqm 
Now, this is the latest as of writing this article - the PHN firmware that was released today. What you see in the first two lines is is that it tried to grab the AQI9 firmware, but while the entry is there, the actual content is not yet available.
In such cases the tool will try to grab the next latest firmware, which is AQI7, then provides some details (file name, size, and the LogicValue that is used for decoding).
After these steps, the right side of the app will fill out with all the info - firmware name, version, size, etc.
Make sure you check the Check CRC32 and Decrypt automatically checkboxes, then click Download. It will ask you where to save the firmware, then will begin downloading it. Once it finishes, it checks if the firmware is intact (CRC32 check), and decrypts it.
The result is a simple ZIP file with all the firmware bits. Extract it for flashing.
Flashing the firmware
So you got your hands on all the fancypants .tar.md5 firmware files, and want to flash them on your phone, eh?
Well first things first, make sure it IS for your model. If you flash a different model's firmware, it CAN or even WILL result in a brick. So unless you know what you're doing - stop right now.
To flash the firmware, you'll need a PC with the latest Odin. There is a Java-based version for macOS and Linux, but I'm yet to get it working, so stick with Windows.
Download the latest Odin (3.12.7 at the time of writing this post), extract it and run it. It will load up with a nice little interface, which might be overwhelming at first. DO NOT TOUCH ANYTHING BUT WHAT THIS POST TELLS YOU TO. Otherwise you will end up with a brick.
Default settings are good as-is, so all you need is loading the firmware bits. On the bottom left side of Odin, you'll see a column of buttons: BL, AP, CP, CSC. You'll need all four filled out before you can flash.
Match up the firmware bits you have with the buttons. It's quite obvious: BL_{firmware version here}.tar.md5 for BL, AP_{firmware version here}.tar.md5 for AP, CP_{firmware version here}.tar.md5 for CP, and here it gets tricky - you have two CSC files! One of them is CSC_{firmware version here}.tar.md5, and the other is HOME_CSC_{firmware version here}.tar.md5. CSCwill reset your phone to factory defaults while keeping internal storage info (/sdcard stuff), HOME_CSC will keep all data. Stick with the latter.
Clicking each button will bring up a file selection window, just make sure you open the appropriate files, as explained in the previous paragraph. It will check file integrity, and during that the app might seem as if it froze, but don't worry, sit back and let it do its job. When its done, it will unfreeze and you'll be able to add the rest of the files.
When that's done, it's time to put your phone into download mode. For this, hold the power, volume down and Bixby buttons until the phone reboots and you're presented a blue-ish green screen. Make sure you release the buttons as soon as this screen appears, otherwise it will take Vol Down as a separate command and quit from the download mode entry screen!
On this entry screen you'll see two options: Continue (Vol Up), and Cancel (Vol Down). Press volume up, this will put your phone into Download Mode (ODIN Mode). Then connect it to your PC, and it should show up in Odin in the first rectangle of the top row of empty rectangles.
Now, all you need to do is press Start, sit back, and let it do its job! The phone will reboot a few times, finalize the update, and boot back into standard mode.
So now that you know HOW and WHY Samsung updates work as they do, I hope I was successful in getting a bit of knowledge out there as to why Samsung missed out on the September patch, or why it takes them 2-3 weeks to have a security patch rolling out.
submitted by fonix232 to GalaxyS8 [link] [comments]

Rustc 1.13.0 (and nightly) infinite loops while compiling some code.

I made some changes to clap-rs, and when I try to build it with cargo build it hangs indefinitely. Since clap-rs normally takes a few seconds for my system to build, I suspect I have hit a compiler bug (whether or not my code is valid).
The patch is below. You can apply it with git am . (Please ignore the LICENSE-MIT change, it's required by my employer).
From 87fa3c9571a8cbde89904e81a1014320b315c4a9 Mon Sep 17 00:00:00 2001 From: Johnathan Van Why  Date: Mon, 14 Nov 2016 23:33:04 -0800 Subject: [PATCH 1/1] Attempt to solve issue #738 (Clone constraints added that broke backwards-compatibility without a major version number increment), plus a LICENSE file fix to give correct copyright attribution. I am unsure how to add Google Inc to given that is autogenerated. We should find a way to include Google Inc into instead of LICENSE-MIT. --- LICENSE-MIT | 2 +- src/app/ | 6 +++--- src/app/ | 18 ++++++++---------- 3 files changed, 12 insertions(+), 14 deletions(-) diff --git a/LICENSE-MIT b/LICENSE-MIT index 5acedf0..8323ecb 100644 --- a/LICENSE-MIT +++ b/LICENSE-MIT @@ -1,6 +1,6 @@ The MIT License (MIT) -Copyright (c) 2015-2016 Kevin B. Knapp +Copyright (c) 2015-2016 Kevin B. Knapp, other clap-rs contributors, and Google Inc Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal diff --git a/src/app/ b/src/app/ index 7dcb931..5d94dc3 100644 --- a/src/app/ +++ b/src/app/ @@ -1250,7 +1250,7 @@ impl<'a, 'b> App<'a, 'b> { /// [`AppSettings::NoBinaryName`]: ./enum.AppSettings.html#variant.NoBinaryName pub fn get_matches_from(mut self, itr: I) -> ArgMatches<'a> where I: IntoIterator, - T: Into + Clone + T: Into { self.get_matches_from_safe_borrow(itr).unwrap_or_else(|e| { // Otherwise, write to stderr and exit @@ -1292,7 +1292,7 @@ impl<'a, 'b> App<'a, 'b> { /// [`AppSettings::NoBinaryName`]: ./enum.AppSettings.html#variant.NoBinaryName pub fn get_matches_from_safe(mut self, itr: I) -> ClapResult> where I: IntoIterator, - T: Into + Clone + T: Into { self.get_matches_from_safe_borrow(itr) } @@ -1320,7 +1320,7 @@ impl<'a, 'b> App<'a, 'b> { /// [`AppSettings::NoBinaryName`]: ./enum.AppSettings.html#variant.NoBinaryName pub fn get_matches_from_safe_borrow(&mut self, itr: I) -> ClapResult> where I: IntoIterator, - T: Into + Clone + T: Into { // If there are global arguments, or settings we need to propgate them down to subcommands // before parsing incase we run into a subcommand diff --git a/src/app/ b/src/app/ index 60fa4b4..edfe301 100644 --- a/src/app/ +++ b/src/app/ @@ -705,7 +705,7 @@ impl<'a, 'b> Parser<'a, 'b> it: &mut Peekable) -> ClapResult<()> where I: Iterator, - T: Into + Clone + T: Into { debugln!("fn=get_matches_with;"); // Verify all positional assertions pass @@ -718,8 +718,8 @@ impl<'a, 'b> Parser<'a, 'b> let mut subcmd_name: Option = None; let mut needs_val_of: Option<&str> = None; let mut pos_counter = 1; - while let Some(arg) = { - let arg_os = arg.into(); + let mut it_os =|cmdline_arg| cmdline_arg.into()).peekable(); + while let Some(arg_os) = { debugln!("Begin parsing '{:?}' ({:?})", arg_os, &*arg_os.as_bytes()); // Is this a new argument, or values from a previous option? @@ -787,7 +787,7 @@ impl<'a, 'b> Parser<'a, 'b> if pos_sc { if &*arg_os == "help" && self.is_set(AppSettings::NeedsSubcommandHelp) { - try!(self.parse_help_subcommand(it)); + try!(self.parse_help_subcommand(&mut it_os)); } subcmd_name = Some(arg_os.to_str().expect(INVALID_UTF8).to_owned()); break; @@ -812,8 +812,7 @@ impl<'a, 'b> Parser<'a, 'b> if self.is_set(AppSettings::LowIndexMultiplePositional) && pos_counter == (self.positionals.len() - 1) { sdebugln!("Found"); - if let Some(na) = it.peek() { - let n = (*na).clone().into(); + if let Some(n) = it_os.peek() { if is_new_arg(&n) || self.possible_subcommand(&n) || suggestions::did_you_mean(&n.to_string_lossy(), self.subcommands @@ -847,8 +846,7 @@ impl<'a, 'b> Parser<'a, 'b> // Collect the external subcommand args let mut sc_m = ArgMatcher::new(); - while let Some(v) = { - let a = v.into(); + while let Some(a) = { if a.to_str().is_none() && !self.settings.is_set(AppSettings::StrictUtf8) { return Err(Error::invalid_utf8(&*self.create_current_usage(matcher), self.color())); @@ -940,7 +938,7 @@ impl<'a, 'b> Parser<'a, 'b> .next() .expect(INTERNAL_ERROR_MSG) }; - try!(self.parse_subcommand(sc_name, matcher, it)); + try!(self.parse_subcommand(sc_name, matcher, &mut it_os)); } else if self.is_set(AppSettings::SubcommandRequired) { let bn = self.meta.bin_name.as_ref().unwrap_or(&; return Err(Error::missing_subcommand(bn, @@ -1009,7 +1007,7 @@ impl<'a, 'b> Parser<'a, 'b> it: &mut Peekable) -> ClapResult<()> where I: Iterator, - T: Into + Clone + T: Into { use std::fmt::Write; debugln!("fn=parse_subcommand;"); -- 2.1.4 
submitted by FlyingPiranhas to rust [link] [comments]

Pes Mobile 2020 Patch Malaysia(Terengganu FC) - YouTube CARA MENAMBAH ATAU TARIK DATA PESERTA DIDIK BARU DI DAPODIK 2021 Visual Patch - Binary Software Patch Maker for Windows Programmers

Search the world's information, including webpages, images, videos and more. Google has many special features to help you find exactly what you're looking for. The commands diff and patch form a powerful combination. They are widely used to get differences between original files and updated files in such a way that other people who only have the original files can turn them into the updated files with just a single patch file that contains only the differences. This tutorial […] Whilst it does not avoid the actual diff of other files, if your goal is to produce a patch file, or similar then you can use filterdiff from the patchutils package, e.g. to patch only your .py changes: diff -ruNp /path/1 /path/2 | filterdiff -i "*.py" | tee /path/to/file.patch YaDT - Yet another Diff Tool. It is another front-end for diff and in earlier versions diff3 utility. With YaDT you can compare and merge 2 and/or 3 files. YaDT is written on Tcl/Tk and wrapped in a single executable file with the help of sdx and tclkit. diff and cvs utilities are embedded inside YaDT. Also, YaDT supports Git and Mercurial diff -ruN orig/ new/ > file.patch # -r == recursive, so do subdirectories # -u == unified style, if your system lacks it or if recipient # may not have it, use "-c" # -N == treat absent files as empty If a person has the orig/ directory, they can recreate the new one by running patch. To Recreate the new folder from old folder and patch file:

[index] [21456] [12283] [26863] [14805] [4635] [4551] [10239] [19892] [8351] [16720]

Pes Mobile 2020 Patch Malaysia(Terengganu FC) - YouTube

Pes Mobile 2020 Patch Malaysia(Terengganu FC) ... Best Binary Options Strategy 2020 - 2 Minute Strategy LIVE TRAINING! ... Build iOS and Android Apps with Google's Flutter & Dart - Duration: 3:22 ... MATCH 2 RRQ VS EVOS MPLI EL CLASICO ... Must-Have Google Chrome Extensions for Teachers - Duration: 12:03. ... Best Binary Options Strategy 2020 - 2 Minute Strategy LIVE TRAINING! ... Visual Patch® 3.7 was created specifically for software developers who need to build secure, compact and reliable binary patches for their software products. It features state-of-the-art DeltaMAX ...

Flag Counter