Changed firmware_update definition to usb_boot

This commit contains only definition and name changes. The aim is to
be more descriptive.

Simply usb boot interface

In the current firmware_update module, there are a lot of assumptions
made to support use cases that probably never are going to be
implemented.

fwupdate: use `rockusb` driver for maskrom rk1 transfers

As a consequence, this enables functionality of `tpi advanced msd` for
rk1 nodes.

Closes turing-machines/BMC-Firmware#137

get latest on dependencies

streaming_data_service: fix get error msg deadlock

When an error occurs during a file transfer, method
`return_transfer_error` always falls back on the default error message
'transfer canceled'.

The issues is fixed by not holding the streaming_data_service state lock
when waiting for the error message to bubble up. This gives the
streaming_data_service the opportunity to update the error state.

data_transfer: accept URL as transfer sources

transfer data from an alternative source, HTTP, for firmware and flash
upgrades.

patch async-compression: make sure to exhaust reader

This commit makes sure that underlaying readers are exhausted.
This fixes a bug that sha256 validation was not triggered as the stream
was still ready to accept new data even though the decompressor which
was on a higher layer already communicated that the stream is EOF.

Next to that, some logging improvements are present in this commit

API: expose crc options

When initiating a file transfer (to flash a node or upgrade firmware) a
sha256 query parameter can now be passed that will be used to verify
integrity of the written image:

`/api/bmc?opt=set&type=flash&file=/my/file.img&node=1&sha256=74eea5165db`

A query option `skip_crc` can be passed to skip the crc validation step.
This step gets executed after writing the node. It reads back the whole
written area and compares this crc with the crc checksum of the written
data:

`/api/bmc?opt=set&type=flash&skip_crc`

streaming_data_service: improvements

* The BMC will restore USB and power state of the given node even if a
  transfer was aborted prematurely.
* The multi-part HTTP handler cancels the node flash process if a partial
  byte-stream was received.

xz decoding: calculate available memory

determine the amount of allocate-able memory before initializing the
decoder. This lowers the chance of running out of memory.

added xz decoder

xz decoding support is very unstable at the moment due to the high
demand of memory.

change read interface to AsyncRead

This work prepares the code base for easy integration with decoding
codec streams. Using `AsyncRead` means we can get rid off an extra
buffering step when using decompression

v2.0.5

pin_controller: fix clearing of boot pin

When toggling USB mode from flashing to another mode, the RPI_BOOT pin
is not cleared. This means that a given node does not boot when
restarted until this pin is cleared via an alternative way.

v2.0.4

USB route added 'flash' option to API

The boot pin state is added to the USB state, as its closely related to
the different roles a given node fulfills.

KEY_1 long press improvement.

Long pressing KEY_1 will execute the inverse power action of on normal press.
Prior, long pressing would always force all nodes on.
See the state table:

 | state             | long_press | All nodes |
 | :---------------- | :--------: | :-------: |
 | 0b0000            |  False     | On        |
 | 0b0111            |  False     | Off       |
 | 0b1111            |  False     | Off       |
 | 0b0000            |  True      | On        |
 | 0b0111            |  True      | On        |
 | 0b1111            |  True      | Off       |

bump patch version to v2.0.3

update clap dependency

streaming_data_service: wait for error state

wait up to a maximum of 5 seconds for the worker attached to the
streaming service to shutdown and return its error message.

improve Gzip implementation

makes use of the gzip encoder inside async_compression crate.
Return archive as streaming body.

created v2.0.2

add bmcd reload endpoint

added backup endpoint

Compresses filesystem overlay into a `tar.gz` and returns it as response.
Uses zlib for compression.

upgrade_worker: fix clippy

os upgrade: dont block runtime

schedule blocking `osupgrade` process call on designated thread.

streaming_data_service: cleanup

* updated implementation from `AsyncRead` to `AsyncBufRead`.
* moved CRC checker from reader half to writer half. see `WriteWatcher`
* split data_transfer into its own file.

format NodeId's with Display trait

In order for smooth API handling, align response json with UI text

tokio: remove patch, `take` fix landed in 1.34

rename firmware_runner to upgrade_worker

flash node: improve flashing performance

Decreased the flashing time from 16m to 6m40s.

Conducted a dd test locally on the BMC to determine the correct block
size for writing to a raspberry CM4.
Times measured using a 206Mb file:

512B     1m50.22s
512K     43.0s
1M       43.03s
4M       42.96s
8M       43.19s
16M      43.00s
32M      45.95s

Concluded 4M is the optimal blocksize.

Ran some tests writing `2023-05-03-raspios-bullseye-armhf-lite.img`
* using dd 4M                   => 6m23.86s
* using tpi with -l flag        => 6m22s
* using tpi over local network  => 6m40s

redirect_service: forward to correct port

The redirect service was not taking into account an explicitly configured
HTTP port. Resulting i a redirect that was not resolvable.
By parsing the configured port in the destination location, browsers now
can forward correctly requests to port 80.

expose additional endpoint

Exposes 2 additional endpoints in the API. Intended to serve the BMC-UI.
It sorts version related strings in a 'about' call and info about your
specific board into 'info'

v2.0.1 include fixes during RC1 testing

Simplify power state

Previously, an attempt was made to make a power controller with a on
and off state. The "on" state had a sub-state where nodes could be
activated, they were participating in the on/off state
toggling. Power commands to nodes that were 'deactivated` were omitted.

After some trial and error, its concluded that for the end user its
confusing as:
* there is no real way to detect if a module is inserted at a slot and
  therefore can be labeled as active. As a fallback it was up to the
  user to flag a given node as active.
* there was no easy way to see if a node was/is active and to what state
  it will go when an global on or off command was given

The global power state is removed and the interface is simplified.
* on restart the previous power-state prior reboot is restored
* pressing KEY_1 will toggle all nodes on if 3 or less nodes are powered
  on
* pressing KEY_1 when all nodes are off will turn all nodes on
* pressing KEY_1 when all nodes are on will turn all nodes off
* long press KEY_1 will force every node to on
* the API does not cache a global state, command `on --node 1` will turn
  node 1 on etc

persistency: improve logging, decrease write timeout

decrease write timeout. Actual caching is handled by linux filesystem.

ban_patrol: simplify ban deadline

Improvements to simplify deadline logic. The time the user is banned
from authenticating in case of exceeding the authentication threshold

Update default_config.yaml

Add trailing backslash to www path

serial: replace custom ring buffer impl with a crate

Fixes turing-machines/BMC-Firmware#135

bring back info logging of `bmcd` module

fix typo in reboot API query

move the default www directory to /srv/bmcd/www

According FHS:
'/srv – this directory should contain data that is served by the system'

Expose more daemon configuration to config file

in particular:
* port
* www dir
* enable/disable http redirect

authentication: auto reload users

Reload the internal cache when an users are added or removed. This
prevents granting stale users access the API + UI.

Implementation is based on `inotify` subsystem.

fix unit-test ban_patrol

auth: ban consecutive failed requests

Consecutive unauthenticated requests that exceed a given threshold will
be banned for a given period before they are allowed to make any new
request. Every consecutive failed attempt exponentially increases the
cool down period in which the peer is blocked from authenticate itself
up to a upper limit.

config: added authentication group

default_config is updated with the exposed values and a description is
added.

humantime: convert durations into human readable

fix power init

bmc_application: restore power and usb settings

This commit contains 2 improvements:
* Internal operations are not triggering persistency updates anymore.
  Minimizing flash wear.
* After a flash command the power and USB settings are restored to their
  previous values

expose reboot over API

v2.0.0

stub: adjust `get_device_path` signature to original

usbboot: move searching from `/dev/disk/by-id` to `/sys/block`

After turing-machines/BMC-Firmware@1193ce32 [1] mdev replaced eudev, and
with it directory of symlinks /dev/disk/by-id stopped being generated.
Work around this by searching in /sys/block instead.

[1]: https://github.com/turing-machines/BMC-Firmware/commit/1193ce329f952297ab9604238097523839a2c287

streaming_data_service: improve error message

When the channel closes which the sender uses to transport the file
data. Ask the `StreamingDataService` what the current error state is
rather then just responding to the client with a generic answer.

do not run clippy on all features

Feature "stubbed" is meant for development purposes.

Update README.md

added stubs

Stubs can be enabled with compiling feature flag 'stubbed'
* gpio controllers dont do anything
* serial returns static content
* firmware_update writes to /tmp/stubbed_device
* usb filtering is omitted

cleanup module directories of hal

sanitize module layout files

added a clippy lint to only allow self named modules files

update dependencies and remove pinned rockusb commit

auth: default to Basic WWW-Authenticate header

authentication_context: fix failing unit-tests

auth: format authorization denied based on scheme

When responding with an unauthorized response, make sure that the
correct header is returned based on the scheme used.

Only a "realm" attribute is used when the scheme is unknown or not
parse-able.

auth: fix clippy and fmt

auth: ask for `Basic` authentication scheme

This causes browsers to ask and use authentication credentials

toggle `RPI_BOOT` signal instead of keeping it high

This way we can support a wider range of compute modules for image upgrade.
In particular, on an Orange-Pi(RK3566), the RPI_BOOT pin is connected to short
the MMC clock. This forces the device to go into Maskrom mode. Keeping the
RPI_BOOT pin logically means that its impossible for this device to
write anything to MMC.

firmware_update: cleanup error and logging

* Cleaned up the async logging/state component. Error information should
  flow back via `FwUdateError`.
* Flattened the `SUPPORTED_DEVICES` and `SUPPORTED_MSD_DEVICES`. All
  official supported devices need to be able to run as MSD. If
  there are any technical reasons why this is not feasible an appropriate
  error response is sufficient to differentiate between supported and
  not supported MSD devices.

streaming_data_service:

* Includes patch for tokio::io::Take which caused overflows when
  steaming files over 4GB
* Decreased lock contention of the streaming_data_service state by
  exposing the "Sender" of the data. (`take_sender()`)
* Upgraded from peer validation to handle validation. Only data that is
  send to the correct handle endpoint is allowed.
* various fixes and improvements

show buildroot info in `other` API endpoint

streaming_data_service: added write progress

The status endpoint returns now the amount of bytes written to a given
node. e.g. `http://<HOST>/api/bmc?opt=get&type=flash`

streaming_data_service: added support for local file writes

streaming_data_service: improve logging of service

fix cargo-cross

fix the missing Openssl dependency that caused a build failure if cargo
cross was used. Updated the README to reflect the changes

GH-52 implemented os_update

Added logic to execute a os_update

streaming_data_service: removed receiverReader

* Removed our custom receiverReader and replaced it with a tokio variant
* moved transfer_context to its own file
* amount of bytes written is now returned in the status object of
  `TransferContext`
* other small improvements

firmware_runner: resolve technical debt pt.3

Prevent tokio::io::copy from stalling by making the reader exhaustive

Update README.md

remove the package parameter. which is obsoleted now.

persistency: during shutdown only write if changed

Only write the binary persistency file if it was actually dirty

firmware_runner: resolve technical debt pt.2

* In this commit the custom copy function is replaced with a
plain `tokio::io::copy`. This function is more efficient as in that it
can copy with arbitrary read/write sizes and doesnt enforce
`.write_exact`.
* An `CrCReader` is introduced that hooks into the `AsyncRead` reads to
  calculate a crc checksum.
* This copy flow can still be aborted with an "cancel" signal

firmware_runner: resolve technical debt

Condensed writing/reading mechanism inside `firmware_runner` to one
function, `copy_with_crc`. Next iteration a better implementation is
desired for reporting process.

restructure bmcd workspace

* flattened the workspace by squasing `tpi_rs` into `bmcd`. `tpi_rs` was
  the remainders of a library that was statically compiled into the
  legacy bmc C application.
* moved around some files. Tried to group modules and files by feature.

remove c_interface module

This module was an temporary glue layer in order to develop new code in
the legacy bmc binary. Since we have a new bmc daemon, this code can be
buried.

 flash_service: Generalize logic

 This commit extracts flash related logic out of the flash_service
 until we are left with a generic service that can receive large
 binary data.

fix regression in test-suite

persistency: maturing component

* Implemented a fallback mechanism when the database binary is
  corrupted. In this case the binary will be omitted and overwritten
  with an default store on successive write-backs of the store to disk
* Improved fatal error messages on erroneous `.get()` and `.set()`
  calls.
* Created a new config file item: `write_timeout`. Controls the write
  timeout of the persistency. More information inside
  `default_config.yaml`

CI: add cargo-deny

* Verify use of FOSS licenses.
* added copyright header to **/*.rs files

Merge pull request #53 from turing-machines/feature/serial

tpi_rs: add serial handlers

Merge branch 'master' into feature/serial

 Gh-10 rework pin controller

Rework to accommodate changes in the Linux subsystem by #49.

serial: rework the ownership

The serial workers synchronize communication by:
* a channel for writes.
* shares the 'RingBuffer' implementation for reads.

 Implement token and basic authentication

NOTE: this Service is not resilient against brute-force attacks in such
it does not implement rate limiting on authentication nor authorization
requests.

* Uses Linux users to authorize requests.
* no authorization roles or scopes are implemented yet.
* token based authentication is implemented with the Redfish session
  login authentication in mind. That is, when we would implement Redfish
  it should be easy to append the current implementation
* token timeout gets reset on every use of the token.
* basic authentication: The authentication service expects a
  'Authorization' header containing the following format: 'Basic <base64
  encoded as <username:password>>'

run `cargo fmt`

serial: add `encoding` parameter

serial: move `RingBuffer` to its own module

flash_service: stability and improvements

* added a API call so a client can ask the current status of the
  `FlashService`
* fixes regarding cancelling of the node flash
* cleanup of code

Node reset: implement simulated reset

Node reset GPIO's are not connected on the board. Therefore remove
related logic and implement a simulated reset by toggling the power of
a given node.

legacy API: support USB routes to BMC

added "usb_boot" operation

* split the usbboot pin functionality from the usb configuration and
  gave it its separate routine call.
* usb_boot pin is now exposed over the API via opt=set&type=usb_boot

tpi_rs: add serial handlers

Fixes #22