There's a race condition between Erlang processing the exit code and it processing the messages that get sent to it. For example, fwup can fail and send an error message up. fwup will exit after it does this, but Erlang may handle the process exit first and lose the error message. That's not helpful.

The fix to this is to pass the --exit-handshake option to fwup. If this is done, then after fwup reports OK or ER, it will sent a CTRL+Z character (this part doesn't matter with framing), and then it will call read() and wait for Erlang to send something back to it. That's the handshake. All Erlang needs to do is send a byte (anything works) back to fwup after it gets an OK or ER. Then fwup will exit knowing that Erlang safely got the error or success message.

To summarize, the change is:

1. Pass --exit-handshake when calling fwup
2. Send a character to the port after receiving an OK or ER

After sending the character, it's ok to finish up completely. I don't think there's a need to wait for fwup to exit since you'll know that the exit code is 0 if the last message is OK or 1 if ER. Also, closing the port will also satisfy the handshake from fwup's point of view.

Another note is that it would be really bad for fwup to exit without sending an OK or ER. That would be a bad bug in fwup if that ever happens, so it's worth adding an ugly log message blaming fwup.

Since fwup can process a file path directly, it would be nice to use that rather than asking users to do something like:

{:ok, fwup} = Fwup.stream(self(), args)

new_firmwmare_path
|> File.stream!([:bytes], 4096)
|> Stream.map(fn chunk ->
   Fwup.send_chunk(fwup, chunk)
end)
|> Stream.run()

This should also be faster.