mirror of
https://github.com/Djeeberjr/fw-anwesenheit.git
synced 2025-07-30 05:24:17 +00:00
init v2
This commit is contained in:
parent
732411cd50
commit
43e964b5a0
14
.cargo/config.toml
Normal file
14
.cargo/config.toml
Normal file
@ -0,0 +1,14 @@
|
||||
[target.riscv32imac-unknown-none-elf]
|
||||
runner = "espflash flash --monitor --chip esp32c6"
|
||||
|
||||
[build]
|
||||
rustflags = [
|
||||
# Required to obtain backtraces (e.g. when using the "esp-backtrace" crate.)
|
||||
# NOTE: May negatively impact performance of produced code
|
||||
"-C", "force-frame-pointers",
|
||||
]
|
||||
|
||||
target = "riscv32imac-unknown-none-elf"
|
||||
|
||||
[unstable]
|
||||
build-std = ["alloc", "core"]
|
||||
Binary file not shown.
Binary file not shown.
BIN
3d_print/LWL.3mf
BIN
3d_print/LWL.3mf
Binary file not shown.
Binary file not shown.
2403
Cargo.lock
generated
2403
Cargo.lock
generated
File diff suppressed because it is too large
Load Diff
84
Cargo.toml
84
Cargo.toml
@ -3,24 +3,72 @@ name = "fw-anwesenheit"
|
||||
version = "0.1.0"
|
||||
edition = "2024"
|
||||
|
||||
[features]
|
||||
default = []
|
||||
mock_pi = [] # Enable mocking of the rpi hardware
|
||||
[[bin]]
|
||||
name = "fw-anwesenheit"
|
||||
path = "./src/bin/main.rs"
|
||||
test = false
|
||||
doctest = false
|
||||
bench = false
|
||||
|
||||
[dependencies]
|
||||
chrono = { version = "0.4.40", features = ["serde"] }
|
||||
gpio = "0.4.1"
|
||||
regex = "1.11.1"
|
||||
serde = { version = "1.0.219", features = ["derive"] }
|
||||
serde_json = "1.0.140"
|
||||
rocket = { version = "0.5.1", features = ["json"] }
|
||||
tokio = { version = "1.44.2", features = ["full"] }
|
||||
rust-embed = "8.7.0"
|
||||
log = "0.4.27"
|
||||
simplelog = "0.12.2"
|
||||
rppal = { version = "0.22.1", features = ["hal"] }
|
||||
smart-leds = "0.3"
|
||||
ws2812-spi = "0.3"
|
||||
rgb = "0.8.50"
|
||||
anyhow = "1.0.98"
|
||||
embassy-net = { version = "0.7.0", features = [
|
||||
"dhcpv4",
|
||||
"medium-ethernet",
|
||||
"tcp",
|
||||
"udp",
|
||||
] }
|
||||
embedded-io = "0.6.1"
|
||||
embedded-io-async = "0.6.1"
|
||||
esp-alloc = "0.8.0"
|
||||
esp-hal = { version = "1.0.0-beta.1", features = ["esp32c6", "unstable"] }
|
||||
smoltcp = { version = "0.12.0", default-features = false, features = [
|
||||
"medium-ethernet",
|
||||
"multicast",
|
||||
"proto-dhcpv4",
|
||||
"proto-dns",
|
||||
"proto-ipv4",
|
||||
"socket-dns",
|
||||
"socket-icmp",
|
||||
"socket-raw",
|
||||
"socket-tcp",
|
||||
"socket-udp",
|
||||
] }
|
||||
# for more networking protocol support see https://crates.io/crates/edge-net
|
||||
bleps = { git = "https://github.com/bjoernQ/bleps", package = "bleps", rev = "a5148d8ae679e021b78f53fd33afb8bb35d0b62e", features = [
|
||||
"async",
|
||||
"macros",
|
||||
] }
|
||||
critical-section = "1.2.0"
|
||||
embassy-executor = { version = "0.7.0", features = ["task-arena-size-20480"] }
|
||||
embassy-time = { version = "0.4.0", features = ["generic-queue-8"] }
|
||||
esp-hal-embassy = { version = "0.9.0", features = ["esp32c6"] }
|
||||
esp-wifi = { version = "0.15.0", features = [
|
||||
"wifi",
|
||||
"builtin-scheduler",
|
||||
"esp-alloc",
|
||||
"esp32c6",
|
||||
"log-04",
|
||||
] }
|
||||
heapless = { version = "0.8.0", default-features = false }
|
||||
static_cell = { version = "2.1.0", features = ["nightly"] }
|
||||
esp-println = { version = "0.15.0", features = ["esp32c6", "log-04"] }
|
||||
log = { version = "0.4" }
|
||||
edge-dhcp = { version = "0.6.0", features = ["log"] }
|
||||
edge-nal = "0.5.0"
|
||||
edge-nal-embassy = { version = "0.6.0", features = ["log"] }
|
||||
picoserve = { version = "0.16.0", features = ["embassy", "log"] }
|
||||
|
||||
|
||||
[profile.dev]
|
||||
# Rust debug is too slow.
|
||||
# For debug builds always builds with some optimization
|
||||
opt-level = "s"
|
||||
|
||||
[profile.release]
|
||||
codegen-units = 1 # LLVM can perform better optimizations using a single thread
|
||||
debug = 2
|
||||
debug-assertions = false
|
||||
incremental = false
|
||||
lto = 'fat'
|
||||
opt-level = 's'
|
||||
overflow-checks = false
|
||||
|
||||
61
Makefile
61
Makefile
@ -1,61 +0,0 @@
|
||||
PACKAGE_NAME := fwa
|
||||
VERSION := 1.0
|
||||
ARCH := armhf
|
||||
BUILD_DIR := build
|
||||
DEB_DIR := $(BUILD_DIR)/$(PACKAGE_NAME)-$(VERSION)
|
||||
BIN_DIR := $(DEB_DIR)/usr/local/bin
|
||||
SERVICE_DIR := $(DEB_DIR)/lib/systemd/system
|
||||
CONFIG_DIR := $(DEB_DIR)/etc
|
||||
PM3_DIR := $(DEB_DIR)/usr/share/pm3
|
||||
|
||||
.PHONY: all build clean package prepare_package
|
||||
|
||||
all: package
|
||||
|
||||
build: $(BUILD_DIR)/fwa
|
||||
|
||||
$(BUILD_DIR)/fwa: web/dist
|
||||
cross build --release --target arm-unknown-linux-gnueabihf
|
||||
cp ./target/arm-unknown-linux-gnueabihf/release/fw-anwesenheit $@
|
||||
|
||||
prepare_package: $(DEB_DIR)/DEBIAN $(BIN_DIR)/fwa
|
||||
mkdir -p $(SERVICE_DIR)
|
||||
cp ./service/fwa.service $(SERVICE_DIR)/
|
||||
cp ./service/fwa-fail.service $(SERVICE_DIR)/
|
||||
|
||||
mkdir -p $(CONFIG_DIR)
|
||||
cp ./service/fwa.env $(CONFIG_DIR)/
|
||||
|
||||
mkdir -p $(PM3_DIR)
|
||||
cp -r ./pre-compiled/* $(PM3_DIR)/
|
||||
|
||||
mkdir -p $(DEB_DIR)/var/lib/fwa/
|
||||
|
||||
$(BIN_DIR)/fwa: $(BUILD_DIR)/fwa
|
||||
mkdir -p $(BIN_DIR)
|
||||
cp $< $@
|
||||
|
||||
|
||||
$(DEB_DIR)/DEBIAN:
|
||||
mkdir -p $(DEB_DIR)/DEBIAN
|
||||
echo "Package: $(PACKAGE_NAME)" > $(DEB_DIR)/DEBIAN/control
|
||||
echo "Version: $(VERSION)" >> $(DEB_DIR)/DEBIAN/control
|
||||
echo "Section: utils" >> $(DEB_DIR)/DEBIAN/control
|
||||
echo "Priority: optional" >> $(DEB_DIR)/DEBIAN/control
|
||||
echo "Architecture: $(ARCH)" >> $(DEB_DIR)/DEBIAN/control
|
||||
echo "Depends: libc6 (>= 2.28)" >> $(DEB_DIR)/DEBIAN/control
|
||||
echo "Maintainer: Niklas Kapelle <niklas@kapelle.org>" >> $(DEB_DIR)/DEBIAN/control
|
||||
echo "Description: Feuerwehr anwesenheit" >> $(DEB_DIR)/DEBIAN/control
|
||||
|
||||
echo "/etc/fwa.env" > $(DEB_DIR)/DEBIAN/conffiles
|
||||
|
||||
web/dist:
|
||||
(cd web && npm run build)
|
||||
|
||||
package: prepare_package
|
||||
dpkg-deb --build $(DEB_DIR)
|
||||
|
||||
clean:
|
||||
cargo clean
|
||||
rm -rf web/dist
|
||||
rm -rf $(BUILD_DIR)
|
||||
40
build.rs
Normal file
40
build.rs
Normal file
@ -0,0 +1,40 @@
|
||||
fn main() {
|
||||
linker_be_nice();
|
||||
// make sure linkall.x is the last linker script (otherwise might cause problems with flip-link)
|
||||
println!("cargo:rustc-link-arg=-Tlinkall.x");
|
||||
}
|
||||
|
||||
fn linker_be_nice() {
|
||||
let args: Vec<String> = std::env::args().collect();
|
||||
if args.len() > 1 {
|
||||
let kind = &args[1];
|
||||
let what = &args[2];
|
||||
|
||||
match kind.as_str() {
|
||||
"undefined-symbol" => match what.as_str() {
|
||||
"_defmt_timestamp" => {
|
||||
eprintln!();
|
||||
eprintln!("💡 `defmt` not found - make sure `defmt.x` is added as a linker script and you have included `use defmt_rtt as _;`");
|
||||
eprintln!();
|
||||
}
|
||||
"_stack_start" => {
|
||||
eprintln!();
|
||||
eprintln!("💡 Is the linker script `linkall.x` missing?");
|
||||
eprintln!();
|
||||
}
|
||||
_ => (),
|
||||
},
|
||||
// we don't have anything helpful for "missing-lib" yet
|
||||
_ => {
|
||||
std::process::exit(1);
|
||||
}
|
||||
}
|
||||
|
||||
std::process::exit(0);
|
||||
}
|
||||
|
||||
println!(
|
||||
"cargo:rustc-link-arg=--error-handling-script={}",
|
||||
std::env::current_exe().unwrap().display()
|
||||
);
|
||||
}
|
||||
24
buzzer.py
24
buzzer.py
@ -1,24 +0,0 @@
|
||||
import RPi.GPIO as GPIO
|
||||
import time
|
||||
|
||||
BUZZER_PIN = 26
|
||||
|
||||
def beep(frequency, duration):
|
||||
pwm = GPIO.PWM(BUZZER_PIN, frequency)
|
||||
pwm.start(50) # 50 % duty cycle
|
||||
time.sleep(duration)
|
||||
pwm.stop()
|
||||
|
||||
def main():
|
||||
GPIO.setmode(GPIO.BCM)
|
||||
GPIO.setup(BUZZER_PIN, GPIO.OUT)
|
||||
|
||||
try:
|
||||
beep(523, 0.3) # C5
|
||||
beep(659, 0.3) # E5
|
||||
beep(784, 0.3) # G5
|
||||
finally:
|
||||
GPIO.cleanup()
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
File diff suppressed because one or more lines are too long
|
Before Width: | Height: | Size: 13 KiB |
@ -1,34 +0,0 @@
|
||||
@startuml
|
||||
actor user
|
||||
|
||||
|
||||
main -> pm3 :start
|
||||
loop
|
||||
pm3 -> pm3 : look for HITAG
|
||||
end
|
||||
|
||||
user -> pm3 :show HITAG
|
||||
|
||||
pm3 -> parser : parse ID
|
||||
parser -> pm3 : return ID
|
||||
|
||||
pm3 --> main : send ID
|
||||
|
||||
loop
|
||||
main -> main : look for IDs
|
||||
end
|
||||
|
||||
main -> idstore : send ID
|
||||
idstore -> System : ask for day
|
||||
alt
|
||||
System -> idstore : return attendence_day
|
||||
else
|
||||
create collections attendence_day
|
||||
idstore -> attendence_day : create new attendence_day
|
||||
|
||||
end
|
||||
|
||||
idstore -> attendence_day : add ID
|
||||
attendence_day -> system : save json
|
||||
|
||||
@enduml
|
||||
23
pm3_mock.sh
23
pm3_mock.sh
@ -1,23 +0,0 @@
|
||||
#!/usr/bin/env bash
|
||||
|
||||
generate_random_hex() {
|
||||
openssl rand -hex 4 | tr '[:lower:]' '[:upper:]'
|
||||
}
|
||||
|
||||
output_hotspot_id() {
|
||||
echo "[+] UID.... C1532B57"
|
||||
}
|
||||
|
||||
trap 'output_hotspot_id' SIGUSR1
|
||||
|
||||
echo "Proxmark 3 mock script"
|
||||
echo "Outputs a random ID every 1 to 5 seconds"
|
||||
|
||||
while true; do
|
||||
random_id=$(generate_random_hex)
|
||||
echo "[+] UID.... $random_id"
|
||||
if (( RANDOM % 2 == 0 )); then
|
||||
echo "[+] UID.... $random_id"
|
||||
fi
|
||||
sleep "$((RANDOM % 5 + 1))"
|
||||
done
|
||||
Binary file not shown.
Binary file not shown.
550
pre-compiled/pm3
550
pre-compiled/pm3
@ -1,550 +0,0 @@
|
||||
#!/usr/bin/env bash
|
||||
|
||||
# Usage: run option -h to get help
|
||||
|
||||
# BT auto detection
|
||||
# Shall we look for white HC-06-USB dongle ?
|
||||
FINDBTDONGLE=true
|
||||
# Shall we look for rfcomm interface ?
|
||||
FINDBTRFCOMM=true
|
||||
# Shall we look for registered BT device ? (Linux only)
|
||||
FINDBTDIRECT=true
|
||||
|
||||
PM3PATH=$(dirname "$0")
|
||||
EVALENV=""
|
||||
FULLIMAGE="fullimage.elf"
|
||||
BOOTIMAGE="bootrom.elf"
|
||||
|
||||
#Skip check if --list is used
|
||||
if [ ! "$1" == "--list" ]; then
|
||||
# try pm3 dirs in current repo workdir
|
||||
if [ -d "$PM3PATH/client/" ]; then
|
||||
if [ -x "$PM3PATH/client/proxmark3" ]; then
|
||||
CLIENT="$PM3PATH/client/proxmark3"
|
||||
elif [ -x "$PM3PATH/client/build/proxmark3" ]; then
|
||||
CLIENT="$PM3PATH/client/build/proxmark3"
|
||||
else
|
||||
echo >&2 "[!!] In devel workdir but no executable found, did you compile it?"
|
||||
exit 1
|
||||
fi
|
||||
# try install dir
|
||||
elif [ -x "$PM3PATH/proxmark3" ]; then
|
||||
CLIENT="$PM3PATH/proxmark3"
|
||||
else
|
||||
# hope it's installed somehow, still not sure where fw images and pm3.py are...
|
||||
CLIENT="proxmark3"
|
||||
fi
|
||||
fi
|
||||
|
||||
# LeakSanitizer suppressions
|
||||
if [ -e .lsan_suppressions ]; then
|
||||
EVALENV+=" LSAN_OPTIONS=suppressions=.lsan_suppressions"
|
||||
fi
|
||||
if [ "$EVALENV" != "" ]; then
|
||||
EVALENV="export $EVALENV"
|
||||
fi
|
||||
PM3LIST=()
|
||||
SHOWLIST=false
|
||||
|
||||
function get_pm3_list_Linux {
|
||||
N=$1
|
||||
PM3LIST=()
|
||||
if [ ! -c "/dev/tty0" ]; then
|
||||
echo >&2 "[!!] Script cannot access /dev/ttyXXX files, insufficient privileges"
|
||||
exit 1
|
||||
fi
|
||||
for DEV in $(find /dev/ttyACM* 2>/dev/null); do
|
||||
if command -v udevadm >/dev/null; then
|
||||
# WSL1 detection
|
||||
if udevadm info -q property -n "$DEV" | grep -q "ID_VENDOR=proxmark.org"; then
|
||||
PM3LIST+=("$DEV")
|
||||
if [ ${#PM3LIST[*]} -ge "$N" ]; then
|
||||
return
|
||||
fi
|
||||
fi
|
||||
fi
|
||||
# WSL2 with usbipd detection - doesn't report same things as WSL1
|
||||
if grep -q "proxmark.org" "/sys/class/tty/${DEV#/dev/}/../../../manufacturer" 2>/dev/null; then
|
||||
if echo "${PM3LIST[*]}" | grep -qv "${DEV}"; then
|
||||
PM3LIST+=("$DEV")
|
||||
if [ ${#PM3LIST[*]} -ge "$N" ]; then
|
||||
return
|
||||
fi
|
||||
fi
|
||||
fi
|
||||
done
|
||||
if $FINDBTDONGLE; then
|
||||
# check if the HC-06-USB white dongle is present (still, that doesn't tell us if it's paired with a Proxmark3...)
|
||||
for DEV in $(find /dev/ttyUSB* 2>/dev/null); do
|
||||
if command -v udevadm >/dev/null; then
|
||||
if udevadm info -q property -n "$DEV" | grep -q "ID_MODEL=CP2104_USB_to_UART_Bridge_Controller"; then
|
||||
PM3LIST+=("$DEV")
|
||||
if [ ${#PM3LIST[*]} -ge "$N" ]; then
|
||||
return
|
||||
fi
|
||||
fi
|
||||
else
|
||||
if grep -q "DRIVER=cp210x" "/sys/class/tty/${DEV#/dev/}/../../uevent" 2>/dev/null; then
|
||||
PM3LIST+=("$DEV")
|
||||
if [ ${#PM3LIST[*]} -ge "$N" ]; then
|
||||
return
|
||||
fi
|
||||
fi
|
||||
fi
|
||||
done
|
||||
fi
|
||||
if $FINDBTRFCOMM; then
|
||||
# check if the MAC of a Proxmark3 was bound to a local rfcomm interface
|
||||
# (on OSes without deprecated rfcomm and hcitool, the loop will be simply skipped)
|
||||
for DEVMAC in $(rfcomm -a 2>/dev/null | grep " 20:19:0[45]" | sed 's/^\(.*\): \([0-9:]*\) .*/\1@\2/'); do
|
||||
DEV=${DEVMAC/@*/}
|
||||
MAC=${DEVMAC/*@/}
|
||||
# check which are Proxmark3 and, side-effect, if they're actually present
|
||||
if hcitool name "$MAC" | grep -q "PM3"; then
|
||||
PM3LIST+=("/dev/$DEV")
|
||||
if [ ${#PM3LIST[*]} -ge "$N" ]; then
|
||||
return
|
||||
fi
|
||||
fi
|
||||
done
|
||||
fi
|
||||
if $FINDBTDIRECT; then
|
||||
# check if the MAC of a Proxmark3 was registered in the known devices
|
||||
for MAC in $(dbus-send --system --print-reply --type=method_call --dest='org.bluez' '/' org.freedesktop.DBus.ObjectManager.GetManagedObjects 2>/dev/null|\
|
||||
awk '/"Address"/{getline;gsub(/"/,"",$3);a=$3}/Name/{getline;if (/PM3_RDV4/ || /Proxmark3 SE/) print a}'); do
|
||||
PM3LIST+=("bt:$MAC")
|
||||
done
|
||||
# we don't probe the device so there is no guarantee the device is actually present
|
||||
fi
|
||||
}
|
||||
|
||||
function get_pm3_list_macOS {
|
||||
N=$1
|
||||
PM3LIST=()
|
||||
for DEV in $(ioreg -r -c "IOUSBHostDevice" -l | awk -F '"' '
|
||||
$2=="USB Vendor Name"{b=($4=="proxmark.org")}
|
||||
b==1 && $2=="IODialinDevice"{print $4}'); do
|
||||
PM3LIST+=("$DEV")
|
||||
if [ ${#PM3LIST[*]} -ge "$N" ]; then
|
||||
return
|
||||
fi
|
||||
done
|
||||
}
|
||||
|
||||
function get_pm3_list_Windows {
|
||||
N=$1
|
||||
PM3LIST=()
|
||||
|
||||
# Normal SERIAL PORTS (COM)
|
||||
for DEV in $(wmic /locale:ms_409 path Win32_SerialPort Where "PNPDeviceID LIKE '%VID_9AC4&PID_4B8F%' Or PNPDeviceID LIKE '%VID_2D2D&PID_504D%'" Get DeviceID 2>/dev/null | awk -b '/^COM/{print $1}'); do
|
||||
DEV=${DEV/ */}
|
||||
#prevent soft bricking when using pm3-flash-all on an outdated bootloader
|
||||
if [ $(basename -- "$0") = "pm3-flash-all" ]; then
|
||||
line=$(wmic /locale:ms_409 path Win32_SerialPort Where "DeviceID='$DEV'" Get PNPDeviceID 2>/dev/null | awk -b '/^USB/{print $1}');
|
||||
if [[ ! $line =~ ^"USB\VID_9AC4&PID_4B8F\ICEMAN" ]]; then
|
||||
echo -e "\033[0;31m[!] Using pm3-flash-all on an oudated bootloader, use pm3-flash-bootrom first!"
|
||||
exit 1
|
||||
fi
|
||||
fi
|
||||
PM3LIST+=("$DEV")
|
||||
if [ ${#PM3LIST[*]} -ge "$N" ]; then
|
||||
return
|
||||
fi
|
||||
done
|
||||
|
||||
#BT direct SERIAL PORTS (COM)
|
||||
if $FINDBTRFCOMM; then
|
||||
for DEV in $(wmic /locale:ms_409 path Win32_PnPEntity Where "Caption LIKE '%Bluetooth%(COM%'" Get Name 2> /dev/null | awk -b 'match($0,/(COM[0-9]+)/,m){print m[1]}'); do
|
||||
DEV=${DEV/ */}
|
||||
PM3LIST+=("$DEV")
|
||||
if [ ${#PM3LIST[*]} -ge "$N" ]; then
|
||||
return
|
||||
fi
|
||||
done
|
||||
fi
|
||||
|
||||
#white BT dongle SERIAL PORTS (COM)
|
||||
if $FINDBTDONGLE; then
|
||||
for DEV in $(wmic /locale:ms_409 path Win32_SerialPort Where "PNPDeviceID LIKE '%VID_10C4&PID_EA60%'" Get DeviceID 2>/dev/null | awk -b '/^COM/{print $1}'); do
|
||||
DEV=${DEV/ */}
|
||||
PM3LIST+=("$DEV")
|
||||
if [ ${#PM3LIST[*]} -ge "$N" ]; then
|
||||
return
|
||||
fi
|
||||
done
|
||||
fi
|
||||
}
|
||||
|
||||
function get_pm3_list_WSL {
|
||||
N=$1
|
||||
PM3LIST=()
|
||||
|
||||
# Normal SERIAL PORTS (COM)
|
||||
for DEV in $($PSHEXE -command "Get-CimInstance -ClassName Win32_serialport | Where-Object {\$_.PNPDeviceID -like '*VID_9AC4&PID_4B8F*' -or \$_.PNPDeviceID -like '*VID_2D2D&PID_504D*'} | Select -expandproperty DeviceID" 2>/dev/null); do
|
||||
DEV=$(echo $DEV | tr -dc '[:print:]')
|
||||
_comport=$DEV
|
||||
DEV=$(echo $DEV | sed -nr 's#^COM([0-9]+)\b#/dev/ttyS\1#p')
|
||||
# ttyS counterpart takes some more time to appear
|
||||
if [ -e "$DEV" ]; then
|
||||
|
||||
#prevent soft bricking when using pm3-flash-all on an outdated bootloader
|
||||
if [ $(basename -- "$0") = "pm3-flash-all" ]; then
|
||||
line=$($PSHEXE -command "Get-CimInstance -ClassName Win32_serialport | Where-Object {\$_.DeviceID -eq '$_comport'} | Select -expandproperty PNPDeviceID" 2>/dev/null | tr -dc '[:print:]');
|
||||
if [[ ! $line =~ ^"USB\VID_9AC4&PID_4B8F\ICEMAN" ]]; then
|
||||
echo -e "\033[0;31m[!] Using pm3-flash-all on an oudated bootloader, use pm3-flash-bootrom first!"
|
||||
exit 1
|
||||
fi
|
||||
fi
|
||||
PM3LIST+=("$DEV")
|
||||
if [ ! -w "$DEV" ]; then
|
||||
echo "[!] Let's give users read/write access to $DEV"
|
||||
sudo chmod 666 "$DEV"
|
||||
fi
|
||||
if [ ${#PM3LIST[*]} -ge "$N" ]; then
|
||||
return
|
||||
fi
|
||||
fi
|
||||
done
|
||||
|
||||
#BT direct SERIAL PORTS (COM)
|
||||
if $FINDBTRFCOMM; then
|
||||
for DEV in $($PSHEXE -command "Get-CimInstance -ClassName Win32_PnPEntity | Where-Object Caption -like 'Standard Serial over Bluetooth link (COM*' | Select Name" 2> /dev/null | sed -nr 's#.*\bCOM([0-9]+)\b.*#/dev/ttyS\1#p'); do
|
||||
# ttyS counterpart takes some more time to appear
|
||||
if [ -e "$DEV" ]; then
|
||||
PM3LIST+=("$DEV")
|
||||
if [ ! -w "$DEV" ]; then
|
||||
echo "[!] Let's give users read/write access to $DEV"
|
||||
sudo chmod 666 "$DEV"
|
||||
fi
|
||||
if [ ${#PM3LIST[*]} -ge "$N" ]; then
|
||||
return
|
||||
fi
|
||||
fi
|
||||
|
||||
done
|
||||
fi
|
||||
|
||||
#white BT dongle SERIAL PORTS (COM)
|
||||
if $FINDBTDONGLE; then
|
||||
for DEV in $($PSHEXE -command "Get-CimInstance -ClassName Win32_serialport | Where-Object PNPDeviceID -like '*VID_10C4&PID_EA60*' | Select DeviceID" 2>/dev/null | sed -nr 's#^COM([0-9]+)\b#/dev/ttyS\1#p'); do
|
||||
# ttyS counterpart takes some more time to appear
|
||||
if [ -e "$DEV" ]; then
|
||||
PM3LIST+=("$DEV")
|
||||
if [ ! -w "$DEV" ]; then
|
||||
echo "[!] Let's give users read/write access to $DEV"
|
||||
sudo chmod 666 "$DEV"
|
||||
fi
|
||||
if [ ${#PM3LIST[*]} -ge "$N" ]; then
|
||||
return
|
||||
fi
|
||||
fi
|
||||
|
||||
done
|
||||
fi
|
||||
}
|
||||
|
||||
SCRIPT=$(basename -- "$0")
|
||||
|
||||
if [ "$SCRIPT" = "pm3" ]; then
|
||||
CMD() { eval "$EVALENV"; $CLIENT "$@"; }
|
||||
HELP() {
|
||||
cat << EOF
|
||||
|
||||
Quick helper script for proxmark3 client when working with a Proxmark3 device
|
||||
|
||||
Description:
|
||||
The usage is the same as for the proxmark3 client, with the following differences:
|
||||
* the correct port name will be automatically guessed;
|
||||
* the script will wait for a Proxmark3 to be connected (same as option -w of the client).
|
||||
You can also specify a first option -n N to access the Nth Proxmark3 connected.
|
||||
To see a list of available ports, use --list.
|
||||
|
||||
Usage:
|
||||
$SCRIPT [-n <N>] [<any other proxmark3 client option>]
|
||||
$SCRIPT [--list] [-h|--help] [-hh|--helpclient]
|
||||
$SCRIPT [-o|--offline]
|
||||
|
||||
|
||||
Arguments:
|
||||
-h/--help this help
|
||||
-hh/--helpclient proxmark3 client help (the script will forward these options)
|
||||
--list list all detected com ports
|
||||
-n <N> connect device referred to the N:th number on the --list output
|
||||
-o/--offline shortcut to use directly the proxmark3 client without guessing ports
|
||||
|
||||
Samples:
|
||||
./$SCRIPT -- Auto detect/ select com port in the following order BT, USB/CDC, BT DONGLE
|
||||
./$SCRIPT -p /dev/ttyACM0 -- connect to port /dev/ttyACM0
|
||||
./$SCRIPT -n 2 -- use second item from the --list output
|
||||
./$SCRIPT -c 'lf search' -i -- run command and stay in client once completed
|
||||
|
||||
|
||||
EOF
|
||||
}
|
||||
elif [ "$SCRIPT" = "pm3-flash" ]; then
|
||||
FINDBTDONGLE=false
|
||||
FINDBTRFCOMM=false
|
||||
FINDBTDIRECT=false
|
||||
CMD() {
|
||||
ARGS=("--port" "$1" "--flash")
|
||||
shift;
|
||||
while [ "$1" != "" ]; do
|
||||
if [ "$1" == "-b" ]; then
|
||||
ARGS+=("--unlock-bootloader")
|
||||
elif [ "$1" == "--force" ]; then
|
||||
ARGS+=("--force")
|
||||
else
|
||||
ARGS+=("--image" "$1")
|
||||
fi
|
||||
shift;
|
||||
done
|
||||
$CLIENT "${ARGS[@]}";
|
||||
}
|
||||
HELP() {
|
||||
cat << EOF
|
||||
Quick helper script for flashing a Proxmark3 device via USB
|
||||
|
||||
Description:
|
||||
The usage is similar to the old proxmark3-flasher binary, except that the correct port name will be automatically guessed.
|
||||
You can also specify a first option -n N to access the Nth Proxmark3 connected on USB.
|
||||
If this doesn't work, you'll have to use manually the proxmark3 client, see "$CLIENT -h".
|
||||
To see a list of available ports, use --list.
|
||||
|
||||
Usage:
|
||||
$SCRIPT [-n <N>] [-b] image.elf [image.elf...]
|
||||
$SCRIPT --list
|
||||
|
||||
Options:
|
||||
-b Enable flashing of bootloader area (DANGEROUS)
|
||||
|
||||
Example:
|
||||
$SCRIPT -b bootrom.elf fullimage.elf
|
||||
EOF
|
||||
}
|
||||
elif [ "$SCRIPT" = "pm3-flash-all" ]; then
|
||||
FINDBTDONGLE=false
|
||||
FINDBTRFCOMM=false
|
||||
FINDBTDIRECT=false
|
||||
|
||||
|
||||
CMD() {
|
||||
ARGS=("--port" "$1" "--flash" "--unlock-bootloader" "--image" "$BOOTIMAGE" "--image" "$FULLIMAGE")
|
||||
shift;
|
||||
while [ "$1" != "" ]; do
|
||||
if [ "$1" == "--force" ]; then
|
||||
ARGS+=("--force")
|
||||
fi
|
||||
shift;
|
||||
done
|
||||
$CLIENT "${ARGS[@]}";
|
||||
}
|
||||
HELP() {
|
||||
cat << EOF
|
||||
Quick helper script for flashing a Proxmark3 device via USB
|
||||
|
||||
Description:
|
||||
The correct port name will be automatically guessed and the stock bootloader and firmware image will be flashed.
|
||||
You can also specify a first option -n N to access the Nth Proxmark3 connected on USB.
|
||||
If this doesn't work, you'll have to use manually the proxmark3 client, see "$CLIENT -h".
|
||||
To see a list of available ports, use --list.
|
||||
|
||||
Usage:
|
||||
$SCRIPT [-n <N>]
|
||||
$SCRIPT --list
|
||||
EOF
|
||||
}
|
||||
elif [ "$SCRIPT" = "pm3-flash-fullimage" ]; then
|
||||
FINDBTDONGLE=false
|
||||
FINDBTRFCOMM=false
|
||||
FINDBTDIRECT=false
|
||||
CMD() {
|
||||
ARGS=("--port" "$1" "--flash" "--image" "$FULLIMAGE")
|
||||
shift;
|
||||
while [ "$1" != "" ]; do
|
||||
if [ "$1" == "--force" ]; then
|
||||
ARGS+=("--force")
|
||||
fi
|
||||
shift;
|
||||
done
|
||||
$CLIENT "${ARGS[@]}";
|
||||
}
|
||||
HELP() {
|
||||
cat << EOF
|
||||
Quick helper script for flashing a Proxmark3 device via USB
|
||||
|
||||
Description:
|
||||
The correct port name will be automatically guessed and the stock firmware image will be flashed.
|
||||
You can also specify a first option -n N to access the Nth Proxmark3 connected on USB.
|
||||
If this doesn't work, you'll have to use manually the proxmark3 client, see "$CLIENT -h".
|
||||
To see a list of available ports, use --list.
|
||||
|
||||
Usage:
|
||||
$SCRIPT [-n <N>]
|
||||
$SCRIPT --list
|
||||
EOF
|
||||
}
|
||||
elif [ "$SCRIPT" = "pm3-flash-bootrom" ]; then
|
||||
FINDBTDONGLE=false
|
||||
FINDBTRFCOMM=false
|
||||
FINDBTDIRECT=false
|
||||
CMD() {
|
||||
ARGS=("--port" "$1" "--flash" "--unlock-bootloader" "--image" "$BOOTIMAGE")
|
||||
shift;
|
||||
while [ "$1" != "" ]; do
|
||||
if [ "$1" == "--force" ]; then
|
||||
ARGS+=("--force")
|
||||
fi
|
||||
shift;
|
||||
done
|
||||
$CLIENT "${ARGS[@]}";
|
||||
}
|
||||
HELP() {
|
||||
cat << EOF
|
||||
Quick helper script for flashing a Proxmark3 device via USB
|
||||
|
||||
Description:
|
||||
The correct port name will be automatically guessed and the stock bootloader will be flashed.
|
||||
You can also specify a first option -n N to access the Nth Proxmark3 connected on USB.
|
||||
If this doesn't work, you'll have to use manually the proxmark3 client, see "$CLIENT -h".
|
||||
To see a list of available ports, use --list.
|
||||
|
||||
Usage:
|
||||
$SCRIPT [-n <N>]
|
||||
$SCRIPT --list
|
||||
EOF
|
||||
}
|
||||
else
|
||||
echo >&2 "[!!] Script ran under unknown name, abort: $SCRIPT"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# priority to the help options
|
||||
for ARG; do
|
||||
if [ "$ARG" == "-h" ] || [ "$ARG" == "--help" ]; then
|
||||
HELP
|
||||
exit 0
|
||||
fi
|
||||
if [ "$ARG" == "-hh" ] || [ "$ARG" == "--helpclient" ]; then
|
||||
CMD "-h"
|
||||
exit 0
|
||||
fi
|
||||
done
|
||||
|
||||
# if offline, bypass the script and forward all other args
|
||||
for ARG; do
|
||||
shift
|
||||
if [ "$ARG" == "-o" ] || [ "$ARG" == "--offline" ]; then
|
||||
CMD "$@"
|
||||
exit $?
|
||||
fi
|
||||
set -- "$@" "$ARG"
|
||||
done
|
||||
|
||||
# if a port is already provided, let's just run the command as such
|
||||
for ARG; do
|
||||
shift
|
||||
if [ "$ARG" == "-p" ]; then
|
||||
CMD "$@"
|
||||
exit $?
|
||||
fi
|
||||
set -- "$@" "$ARG"
|
||||
done
|
||||
|
||||
if [ "$1" == "--list" ]; then
|
||||
shift
|
||||
if [ "$1" != "" ]; then
|
||||
echo >&2 "[!!] Option --list must be used alone"
|
||||
exit 1
|
||||
fi
|
||||
SHOWLIST=true
|
||||
fi
|
||||
|
||||
# Number of the Proxmark3 we're interested in
|
||||
N=1
|
||||
if [ "$1" == "-n" ]; then
|
||||
shift
|
||||
if [ "$1" -ge 1 ] && [ "$1" -lt 10 ]; then
|
||||
N=$1
|
||||
shift
|
||||
else
|
||||
echo >&2 "[!!] Option -n requires a number between 1 and 9, got \"$1\""
|
||||
exit 1
|
||||
fi
|
||||
fi
|
||||
|
||||
HOSTOS=$(uname | awk '{print toupper($0)}')
|
||||
if [ "$HOSTOS" = "LINUX" ]; then
|
||||
# Detect when running under WSL1 (but exclude WSL2)
|
||||
if uname -a | grep -qi Microsoft && uname -a | grep -qvi WSL2; then
|
||||
# First try finding it using the PATH environment variable
|
||||
PSHEXE=$(command -v powershell.exe 2>/dev/null)
|
||||
|
||||
# If it fails (such as if WSLENV is not set), try using the default installation path
|
||||
if [ -z "$PSHEXE" ]; then
|
||||
PSHEXE=/mnt/c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe
|
||||
fi
|
||||
|
||||
# Finally test if PowerShell is working
|
||||
if ! "$PSHEXE" exit >/dev/null 2>&1; then
|
||||
echo >&2 "[!!] Cannot run powershell.exe, are you sure your WSL is authorized to run Windows processes? (cf WSL interop flag)"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
GETPM3LIST=get_pm3_list_WSL
|
||||
else
|
||||
GETPM3LIST=get_pm3_list_Linux
|
||||
fi
|
||||
elif [ "$HOSTOS" = "DARWIN" ]; then
|
||||
GETPM3LIST=get_pm3_list_macOS
|
||||
elif [[ "$HOSTOS" =~ MINGW(32|64)_NT* ]]; then
|
||||
GETPM3LIST=get_pm3_list_Windows
|
||||
else
|
||||
echo >&2 "[!!] Host OS not recognized, abort: $HOSTOS"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
if $SHOWLIST; then
|
||||
# Probe for up to 9 devs
|
||||
$GETPM3LIST 9
|
||||
if [ ${#PM3LIST} -lt 1 ]; then
|
||||
echo >&2 "[!!] No port found"
|
||||
exit 1
|
||||
fi
|
||||
n=1
|
||||
for DEV in "${PM3LIST[@]}"
|
||||
do
|
||||
echo "$n: $DEV"
|
||||
n=$((n+1))
|
||||
done
|
||||
exit 0
|
||||
fi
|
||||
|
||||
# Wait till we get at least N Proxmark3 devices
|
||||
$GETPM3LIST "$N"
|
||||
if [ ${#PM3LIST} -lt "$N" ]; then
|
||||
echo >&2 "[=] Waiting for Proxmark3 to appear..."
|
||||
fi
|
||||
while true; do
|
||||
if [ ${#PM3LIST[*]} -ge "$N" ]; then
|
||||
break
|
||||
fi
|
||||
sleep .1
|
||||
$GETPM3LIST "$N"
|
||||
done
|
||||
|
||||
if [ ${#PM3LIST} -lt "$N" ]; then
|
||||
HELP() {
|
||||
cat << EOF
|
||||
[!!] No port found, abort
|
||||
|
||||
[?] Hint: try '$SCRIPT --list' to see list of available ports, and use the -n command like below
|
||||
[?] $SCRIPT [-n <N>]
|
||||
|
||||
EOF
|
||||
}
|
||||
HELP
|
||||
exit 1
|
||||
fi
|
||||
|
||||
CMD "${PM3LIST[$((N-1))]}" "$@"
|
||||
exit $?
|
||||
@ -1,4 +0,0 @@
|
||||
#!/usr/bin/env bash
|
||||
|
||||
PM3PATH=$(dirname "$0")
|
||||
. "$PM3PATH/pm3"
|
||||
@ -1,4 +0,0 @@
|
||||
#!/usr/bin/env bash
|
||||
|
||||
PM3PATH=$(dirname "$0")
|
||||
. "$PM3PATH/pm3"
|
||||
@ -1,4 +0,0 @@
|
||||
#!/usr/bin/env bash
|
||||
|
||||
PM3PATH=$(dirname "$0")
|
||||
. "$PM3PATH/pm3"
|
||||
@ -1,4 +0,0 @@
|
||||
#!/usr/bin/env bash
|
||||
|
||||
PM3PATH=$(dirname "$0")
|
||||
. "$PM3PATH/pm3"
|
||||
Binary file not shown.
4
rust-toolchain.toml
Normal file
4
rust-toolchain.toml
Normal file
@ -0,0 +1,4 @@
|
||||
[toolchain]
|
||||
channel = "nightly"
|
||||
components = ["rust-src"]
|
||||
targets = ["riscv32imac-unknown-none-elf"]
|
||||
@ -1,19 +0,0 @@
|
||||
[Unit]
|
||||
Description=Failure state for fwa.service
|
||||
Requires=local-fs.target
|
||||
After=local-fs.target
|
||||
StartLimitIntervalSec=500
|
||||
StartLimitBurst=5
|
||||
|
||||
[Service]
|
||||
Type=simple
|
||||
ExecStart=/usr/local/bin/fwa --error
|
||||
Restart=on-failure
|
||||
RestartSec=5
|
||||
User=root
|
||||
Group=root
|
||||
WorkingDirectory=/var/lib/fwa
|
||||
EnvironmentFile=/etc/fwa.env
|
||||
|
||||
[Install]
|
||||
WantedBy=multi-user.target
|
||||
@ -1,5 +0,0 @@
|
||||
PM3_BIN=/usr/share/pm3/pm3
|
||||
LOG_LEVEL=warn
|
||||
HOTSPOT_IDS=578B5DF2;c1532b57
|
||||
HOTSPOT_SSID=fwa
|
||||
HOTSPOT_PW=a9LG2kUVrsRRVUo1
|
||||
@ -1,20 +0,0 @@
|
||||
[Unit]
|
||||
Description=Feuerwehr Anwesenheit Service
|
||||
Requires=local-fs.target
|
||||
After=local-fs.target
|
||||
StartLimitIntervalSec=500
|
||||
StartLimitBurst=5
|
||||
OnFailure= fwa-fail.service
|
||||
|
||||
[Service]
|
||||
Type=simple
|
||||
ExecStart=/usr/local/bin/fwa
|
||||
Restart=on-failure
|
||||
RestartSec=5
|
||||
User=root
|
||||
Group=root
|
||||
WorkingDirectory=/var/lib/fwa
|
||||
EnvironmentFile=/etc/fwa.env
|
||||
|
||||
[Install]
|
||||
WantedBy=multi-user.target
|
||||
275
src/bin/main.rs
Normal file
275
src/bin/main.rs
Normal file
@ -0,0 +1,275 @@
|
||||
#![no_std]
|
||||
#![no_main]
|
||||
#![feature(type_alias_impl_trait)]
|
||||
#![feature(impl_trait_in_assoc_type)]
|
||||
|
||||
use core::net::Ipv4Addr;
|
||||
use core::str::FromStr;
|
||||
|
||||
use embassy_executor::Spawner;
|
||||
use embassy_net::{Ipv4Cidr, Runner, Stack, StackResources, StaticConfigV4};
|
||||
use embassy_time::{Duration, Timer};
|
||||
use esp_hal::clock::CpuClock;
|
||||
use esp_hal::gpio::{Output, OutputConfig};
|
||||
use esp_hal::peripherals::{GPIO1, GPIO2, UART1};
|
||||
use esp_hal::timer::systimer::SystemTimer;
|
||||
use esp_hal::timer::timg::TimerGroup;
|
||||
use esp_hal::uart::{Config, Uart};
|
||||
use esp_println::logger::init_logger;
|
||||
use esp_wifi::wifi::{
|
||||
AccessPointConfiguration, Configuration, WifiController, WifiDevice, WifiEvent, WifiState,
|
||||
};
|
||||
use log::{debug, info};
|
||||
use picoserve::routing::get;
|
||||
use picoserve::{AppBuilder, AppRouter};
|
||||
use static_cell::make_static;
|
||||
|
||||
#[panic_handler]
|
||||
fn panic(_: &core::panic::PanicInfo) -> ! {
|
||||
loop {}
|
||||
}
|
||||
|
||||
extern crate alloc;
|
||||
|
||||
#[esp_hal_embassy::main]
|
||||
async fn main(spawner: Spawner) {
|
||||
// ------------------- init ---------------------------
|
||||
let config = esp_hal::Config::default().with_cpu_clock(CpuClock::max());
|
||||
let peripherals = esp_hal::init(config);
|
||||
|
||||
info!("starting up...");
|
||||
|
||||
esp_alloc::heap_allocator!(size: 72 * 1024);
|
||||
|
||||
let timer0 = SystemTimer::new(peripherals.SYSTIMER);
|
||||
esp_hal_embassy::init(timer0.alarm0);
|
||||
|
||||
init_logger(log::LevelFilter::Debug);
|
||||
|
||||
let timer1 = TimerGroup::new(peripherals.TIMG0);
|
||||
let mut rng = esp_hal::rng::Rng::new(peripherals.RNG);
|
||||
|
||||
debug!("set wlan antenna..");
|
||||
let mut rf_switch = Output::new(
|
||||
peripherals.GPIO3,
|
||||
esp_hal::gpio::Level::Low,
|
||||
OutputConfig::default(),
|
||||
);
|
||||
|
||||
rf_switch.set_low();
|
||||
|
||||
Timer::after_secs(1).await;
|
||||
|
||||
let mut antenna_mode = Output::new(
|
||||
peripherals.GPIO14,
|
||||
esp_hal::gpio::Level::Low,
|
||||
OutputConfig::default(),
|
||||
);
|
||||
|
||||
antenna_mode.set_low();
|
||||
|
||||
Timer::after_secs(1).await;
|
||||
|
||||
// Setup wifi deivce
|
||||
debug!("setup wifi..");
|
||||
let esp_wifi_ctrl =
|
||||
make_static!(esp_wifi::init(timer1.timer0, rng).unwrap());
|
||||
let (controller, interfaces) = esp_wifi::wifi::new(esp_wifi_ctrl, peripherals.WIFI).unwrap();
|
||||
// let wifi_interface = interfaces.sta;
|
||||
let wifi_ap = interfaces.ap;
|
||||
|
||||
let gw_ip_addr_str = "192.168.2.1";
|
||||
let gw_ip_addr = Ipv4Addr::from_str(gw_ip_addr_str).expect("failed to parse gateway ip");
|
||||
|
||||
let config = embassy_net::Config::ipv4_static(StaticConfigV4 {
|
||||
address: Ipv4Cidr::new(gw_ip_addr, 24),
|
||||
gateway: Some(gw_ip_addr),
|
||||
dns_servers: Default::default(),
|
||||
});
|
||||
|
||||
let seed = (rng.random() as u64) << 32 | rng.random() as u64;
|
||||
|
||||
// Init network stack
|
||||
let (stack, runner) = embassy_net::new(
|
||||
wifi_ap,
|
||||
config,
|
||||
make_static!(StackResources::<3>::new()),
|
||||
seed,
|
||||
);
|
||||
|
||||
debug!("Setup complete. Running network tasks");
|
||||
|
||||
spawner.spawn(connection(controller)).ok();
|
||||
spawner.spawn(net_task(runner)).ok();
|
||||
spawner.spawn(run_dhcp(stack, gw_ip_addr_str)).ok();
|
||||
spawner
|
||||
.spawn(rfid_reader_task(
|
||||
peripherals.UART1,
|
||||
peripherals.GPIO1,
|
||||
peripherals.GPIO2,
|
||||
))
|
||||
.ok();
|
||||
|
||||
loop {
|
||||
if stack.is_link_up() {
|
||||
break;
|
||||
}
|
||||
Timer::after(Duration::from_millis(500)).await;
|
||||
if stack.is_config_up() {
|
||||
break;
|
||||
}
|
||||
Timer::after(Duration::from_millis(500)).await;
|
||||
}
|
||||
|
||||
debug!("Starting webserver");
|
||||
|
||||
let app = make_static!(AppProps.build_app());
|
||||
|
||||
let config = make_static!(picoserve::Config::new(picoserve::Timeouts {
|
||||
start_read_request: Some(Duration::from_secs(5)),
|
||||
persistent_start_read_request: Some(Duration::from_secs(1)),
|
||||
read_request: Some(Duration::from_secs(1)),
|
||||
write: Some(Duration::from_secs(1)),
|
||||
}));
|
||||
|
||||
let _ = spawner.spawn(webserver_task(0, stack, app, config));
|
||||
}
|
||||
|
||||
struct AppProps;
|
||||
|
||||
impl AppBuilder for AppProps {
|
||||
type PathRouter = impl picoserve::routing::PathRouter;
|
||||
|
||||
fn build_app(self) -> picoserve::Router<Self::PathRouter> {
|
||||
picoserve::Router::new().route("/", get(|| async move { "Hello World" }))
|
||||
}
|
||||
}
|
||||
|
||||
#[embassy_executor::task]
|
||||
async fn webserver_task(
|
||||
id: usize,
|
||||
stack: embassy_net::Stack<'static>,
|
||||
app: &'static AppRouter<AppProps>,
|
||||
config: &'static picoserve::Config<Duration>,
|
||||
) -> ! {
|
||||
let mut tcp_rx_buffer = [0u8; 1024];
|
||||
let mut tcp_tx_buffer = [0u8; 1024];
|
||||
let mut http_buffer = [0u8; 2048];
|
||||
|
||||
picoserve::listen_and_serve(
|
||||
id,
|
||||
app,
|
||||
config,
|
||||
stack,
|
||||
80,
|
||||
&mut tcp_rx_buffer,
|
||||
&mut tcp_tx_buffer,
|
||||
&mut http_buffer,
|
||||
)
|
||||
.await
|
||||
}
|
||||
|
||||
#[embassy_executor::task]
|
||||
async fn run_dhcp(stack: Stack<'static>, gw_ip_addr: &'static str) {
|
||||
debug!("start dhcp");
|
||||
use core::net::{Ipv4Addr, SocketAddrV4};
|
||||
|
||||
use edge_dhcp::{
|
||||
io::{self, DEFAULT_SERVER_PORT},
|
||||
server::{Server, ServerOptions},
|
||||
};
|
||||
use edge_nal::UdpBind;
|
||||
use edge_nal_embassy::{Udp, UdpBuffers};
|
||||
|
||||
let ip = Ipv4Addr::from_str(gw_ip_addr).expect("dhcp task failed to parse gw ip");
|
||||
|
||||
let mut buf = [0u8; 1500];
|
||||
|
||||
let mut gw_buf = [Ipv4Addr::UNSPECIFIED];
|
||||
|
||||
let buffers = UdpBuffers::<3, 1024, 1024, 10>::new();
|
||||
let unbound_socket = Udp::new(stack, &buffers);
|
||||
let mut bound_socket = unbound_socket
|
||||
.bind(core::net::SocketAddr::V4(SocketAddrV4::new(
|
||||
Ipv4Addr::UNSPECIFIED,
|
||||
DEFAULT_SERVER_PORT,
|
||||
)))
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
loop {
|
||||
_ = io::server::run(
|
||||
&mut Server::<_, 64>::new_with_et(ip),
|
||||
&ServerOptions::new(ip, Some(&mut gw_buf)),
|
||||
&mut bound_socket,
|
||||
&mut buf,
|
||||
)
|
||||
.await
|
||||
.inspect_err(|e| log::warn!("DHCP server error: {e:?}"));
|
||||
Timer::after(Duration::from_millis(500)).await;
|
||||
}
|
||||
}
|
||||
|
||||
#[embassy_executor::task]
|
||||
async fn net_task(mut runner: Runner<'static, WifiDevice<'static>>) {
|
||||
runner.run().await;
|
||||
}
|
||||
|
||||
#[embassy_executor::task]
|
||||
async fn connection(mut controller: WifiController<'static>) {
|
||||
debug!("start connection task");
|
||||
debug!("Device capabilities: {:?}", controller.capabilities());
|
||||
loop {
|
||||
match esp_wifi::wifi::wifi_state() {
|
||||
WifiState::ApStarted => {
|
||||
// wait until we're no longer connected
|
||||
controller.wait_for_event(WifiEvent::ApStop).await;
|
||||
Timer::after(Duration::from_millis(5000)).await
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
if !matches!(controller.is_started(), Ok(true)) {
|
||||
let client_config = Configuration::AccessPoint(AccessPointConfiguration {
|
||||
ssid: "esp-wifi".try_into().unwrap(),
|
||||
..Default::default()
|
||||
});
|
||||
controller.set_configuration(&client_config).unwrap();
|
||||
debug!("Starting wifi");
|
||||
controller.start_async().await.unwrap();
|
||||
debug!("Wifi started!");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[embassy_executor::task]
|
||||
async fn rfid_reader_task(uart1: UART1<'static>, gpio1: GPIO1<'static>, gpio2: GPIO2<'static>) {
|
||||
debug!("init rfid reader..");
|
||||
|
||||
let uart1_block_result = Uart::new(uart1, Config::default().with_baudrate(9600));
|
||||
let mut nfc_reader = match uart1_block_result {
|
||||
Ok(block) => block.with_rx(gpio1).with_tx(gpio2).into_async(),
|
||||
Err(e) => {
|
||||
log::error!("Failed to initialize UART: {:?}", e);
|
||||
return;
|
||||
}
|
||||
};
|
||||
|
||||
let mut uart_buffer = [0u8; 64];
|
||||
|
||||
loop {
|
||||
debug!("Looking for NFC...");
|
||||
match nfc_reader.read_async(&mut uart_buffer).await {
|
||||
Ok(n) => {
|
||||
let mut hex_str = heapless::String::<128>::new();
|
||||
for byte in &uart_buffer[..n] {
|
||||
core::fmt::Write::write_fmt(&mut hex_str, format_args!("{:02X} ", byte)).ok();
|
||||
}
|
||||
info!("Read {} bytes from UART: {}", n, hex_str);
|
||||
}
|
||||
Err(e) => {
|
||||
log::error!("Error reading from UART: {:?}", e);
|
||||
}
|
||||
}
|
||||
Timer::after(Duration::from_millis(200)).await;
|
||||
}
|
||||
}
|
||||
@ -1,37 +0,0 @@
|
||||
use anyhow::Result;
|
||||
use rppal::pwm::{Channel, Polarity, Pwm};
|
||||
use std::time::Duration;
|
||||
use tokio::time::sleep;
|
||||
|
||||
use crate::hardware::Buzzer;
|
||||
|
||||
const DEFAULT_PWM_CHANNEL_BUZZER: Channel = Channel::Pwm0; //PWM0 = GPIO18/Physical pin 12
|
||||
|
||||
pub struct GPIOBuzzer {
|
||||
pwm: Pwm,
|
||||
}
|
||||
|
||||
impl GPIOBuzzer {
|
||||
pub fn new_from_channel(channel: Channel) -> Result<Self, rppal::pwm::Error> {
|
||||
// Enable with dummy values; we'll set frequency/duty in the tone method
|
||||
let duty_cycle: f64 = 0.5;
|
||||
let pwm = Pwm::with_frequency(channel, 1000.0, duty_cycle, Polarity::Normal, true)?;
|
||||
pwm.disable()?;
|
||||
|
||||
Ok(GPIOBuzzer { pwm })
|
||||
}
|
||||
|
||||
pub fn new_default() -> Result<Self, rppal::pwm::Error> {
|
||||
Self::new_from_channel(DEFAULT_PWM_CHANNEL_BUZZER)
|
||||
}
|
||||
}
|
||||
|
||||
impl Buzzer for GPIOBuzzer {
|
||||
async fn modulated_tone(&mut self, frequency_hz: f64, duration: Duration) -> Result<()> {
|
||||
self.pwm.set_frequency(frequency_hz, 0.5)?; // 50% duty cycle (square wave)
|
||||
self.pwm.enable()?;
|
||||
sleep(duration).await;
|
||||
self.pwm.disable()?;
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
@ -1,131 +0,0 @@
|
||||
use anyhow::{Result, anyhow};
|
||||
use log::{trace, warn};
|
||||
use std::env;
|
||||
use tokio::process::Command;
|
||||
|
||||
use crate::hardware::Hotspot;
|
||||
|
||||
const SSID: &str = "fwa";
|
||||
const CON_NAME: &str = "fwa-hotspot";
|
||||
const PASSWORD: &str = "a9LG2kUVrsRRVUo1";
|
||||
const IPV4_ADDRES: &str = "192.168.4.1/24";
|
||||
|
||||
/// NetworkManager Hotspot
|
||||
pub struct NMHotspot {
|
||||
ssid: String,
|
||||
con_name: String,
|
||||
password: String,
|
||||
ipv4: String,
|
||||
}
|
||||
|
||||
impl NMHotspot {
|
||||
pub fn new_from_env() -> Result<Self> {
|
||||
let ssid = env::var("HOTSPOT_SSID").unwrap_or(SSID.to_owned());
|
||||
let password = env::var("HOTSPOT_PW").unwrap_or_else(|_| {
|
||||
warn!("HOTSPOT_PW not set. Using default password");
|
||||
PASSWORD.to_owned()
|
||||
});
|
||||
|
||||
if password.len() < 8 {
|
||||
return Err(anyhow!("Hotspot password to short"));
|
||||
}
|
||||
|
||||
Ok(NMHotspot {
|
||||
ssid,
|
||||
con_name: CON_NAME.to_owned(),
|
||||
password,
|
||||
ipv4: IPV4_ADDRES.to_owned(),
|
||||
})
|
||||
}
|
||||
|
||||
async fn create_hotspot(&self) -> Result<()> {
|
||||
let cmd = Command::new("nmcli")
|
||||
.args(["device", "wifi", "hotspot"])
|
||||
.arg("con-name")
|
||||
.arg(&self.con_name)
|
||||
.arg("ssid")
|
||||
.arg(&self.ssid)
|
||||
.arg("password")
|
||||
.arg(&self.password)
|
||||
.output()
|
||||
.await?;
|
||||
|
||||
trace!("nmcli (std): {}", String::from_utf8_lossy(&cmd.stdout));
|
||||
trace!("nmcli (err): {}", String::from_utf8_lossy(&cmd.stderr));
|
||||
|
||||
if !cmd.status.success() {
|
||||
return Err(anyhow!("nmcli command had non-zero exit code"));
|
||||
}
|
||||
|
||||
let cmd = Command::new("nmcli")
|
||||
.arg("connection")
|
||||
.arg("modify")
|
||||
.arg(&self.con_name)
|
||||
.arg("ipv4.method")
|
||||
.arg("shared")
|
||||
.arg("ipv4.addresses")
|
||||
.arg(&self.ipv4)
|
||||
.output()
|
||||
.await?;
|
||||
|
||||
if !cmd.status.success() {
|
||||
return Err(anyhow!("nmcli command had non-zero exit code"));
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Checks if the connection already exists
|
||||
async fn exists(&self) -> Result<bool> {
|
||||
let cmd = Command::new("nmcli")
|
||||
.args(["connection", "show"])
|
||||
.arg(&self.con_name)
|
||||
.output()
|
||||
.await?;
|
||||
|
||||
trace!("nmcli (std): {}", String::from_utf8_lossy(&cmd.stdout));
|
||||
trace!("nmcli (err): {}", String::from_utf8_lossy(&cmd.stderr));
|
||||
|
||||
Ok(cmd.status.success())
|
||||
}
|
||||
}
|
||||
|
||||
impl Hotspot for NMHotspot {
|
||||
async fn enable_hotspot(&self) -> Result<()> {
|
||||
if !self.exists().await? {
|
||||
self.create_hotspot().await?;
|
||||
}
|
||||
|
||||
let cmd = Command::new("nmcli")
|
||||
.args(["connection", "up"])
|
||||
.arg(&self.con_name)
|
||||
.output()
|
||||
.await?;
|
||||
|
||||
trace!("nmcli (std): {}", String::from_utf8_lossy(&cmd.stdout));
|
||||
trace!("nmcli (err): {}", String::from_utf8_lossy(&cmd.stderr));
|
||||
|
||||
if !cmd.status.success() {
|
||||
return Err(anyhow!("nmcli command had non-zero exit code"));
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn disable_hotspot(&self) -> Result<()> {
|
||||
let cmd = Command::new("nmcli")
|
||||
.args(["connection", "down"])
|
||||
.arg(&self.con_name)
|
||||
.output()
|
||||
.await?;
|
||||
|
||||
trace!("nmcli (std): {}", String::from_utf8_lossy(&cmd.stdout));
|
||||
trace!("nmcli (err): {}", String::from_utf8_lossy(&cmd.stderr));
|
||||
|
||||
if !cmd.status.success() {
|
||||
return Err(anyhow!("nmcli command had non-zero exit code"));
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
@ -24,22 +24,3 @@ pub trait Buzzer {
|
||||
) -> impl Future<Output = Result<()>> + std::marker::Send;
|
||||
}
|
||||
|
||||
pub trait Hotspot {
|
||||
fn enable_hotspot(&self) -> impl std::future::Future<Output = Result<()>> + std::marker::Send;
|
||||
|
||||
fn disable_hotspot(&self) -> impl std::future::Future<Output = Result<()>> + std::marker::Send;
|
||||
}
|
||||
|
||||
/// Create a struct to manage the hotspot
|
||||
/// Respects the `mock_pi` flag.
|
||||
pub fn create_hotspot() -> Result<impl Hotspot> {
|
||||
#[cfg(feature = "mock_pi")]
|
||||
{
|
||||
Ok(mock::MockHotspot {})
|
||||
}
|
||||
|
||||
#[cfg(not(feature = "mock_pi"))]
|
||||
{
|
||||
hotspot::NMHotspot::new_from_env()
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,33 +0,0 @@
|
||||
use anyhow::Result;
|
||||
use rppal::spi::{Bus, Mode, SlaveSelect, Spi};
|
||||
use smart_leds::SmartLedsWrite;
|
||||
use ws2812_spi::Ws2812;
|
||||
|
||||
use crate::hardware::StatusLed;
|
||||
|
||||
const SPI_CLOCK_SPEED: u32 = 3_800_000;
|
||||
|
||||
pub struct SpiLed {
|
||||
controller: Ws2812<Spi>,
|
||||
}
|
||||
|
||||
impl SpiLed {
|
||||
pub fn new() -> Result<Self, rppal::spi::Error> {
|
||||
let spi = Spi::new(Bus::Spi0, SlaveSelect::Ss0, SPI_CLOCK_SPEED, Mode::Mode0)?;
|
||||
let controller = Ws2812::new(spi);
|
||||
Ok(SpiLed { controller })
|
||||
}
|
||||
}
|
||||
|
||||
impl StatusLed for SpiLed {
|
||||
fn turn_off(&mut self) -> Result<()> {
|
||||
self.controller
|
||||
.write(vec![rgb::RGB8::new(0, 0, 0)].into_iter())?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn turn_on(&mut self, color: rgb::RGB8) -> Result<()> {
|
||||
self.controller.write(vec![color].into_iter())?;
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
1
src/lib.rs
Normal file
1
src/lib.rs
Normal file
@ -0,0 +1 @@
|
||||
#![no_std]
|
||||
@ -1,25 +0,0 @@
|
||||
use std::env;
|
||||
|
||||
use log::LevelFilter;
|
||||
use simplelog::{ConfigBuilder, SimpleLogger};
|
||||
|
||||
pub fn setup_logger() {
|
||||
let log_level = env::var("LOG_LEVEL")
|
||||
.ok()
|
||||
.and_then(|level| level.parse::<LevelFilter>().ok())
|
||||
.unwrap_or({
|
||||
if cfg!(debug_assertions) {
|
||||
LevelFilter::Debug
|
||||
} else {
|
||||
LevelFilter::Warn
|
||||
}
|
||||
});
|
||||
|
||||
let config = ConfigBuilder::new()
|
||||
.set_target_level(LevelFilter::Off)
|
||||
.set_location_level(LevelFilter::Off)
|
||||
.set_thread_level(LevelFilter::Off)
|
||||
.build();
|
||||
|
||||
let _ = SimpleLogger::init(log_level, config);
|
||||
}
|
||||
192
src/main.rs
192
src/main.rs
@ -1,192 +0,0 @@
|
||||
#![allow(dead_code)]
|
||||
|
||||
use anyhow::Result;
|
||||
use feedback::{Feedback, FeedbackImpl};
|
||||
use log::{error, info, warn};
|
||||
use std::{
|
||||
env::{self, args},
|
||||
sync::Arc,
|
||||
time::Duration,
|
||||
};
|
||||
use tally_id::TallyID;
|
||||
use tokio::{
|
||||
fs,
|
||||
signal::unix::{SignalKind, signal},
|
||||
sync::{
|
||||
Mutex,
|
||||
broadcast::{self, Receiver, Sender},
|
||||
},
|
||||
try_join,
|
||||
};
|
||||
use webserver::start_webserver;
|
||||
|
||||
use crate::{hardware::{create_hotspot, Hotspot}, pm3::run_pm3, store::IDStore, webserver::{spawn_idle_watcher, ActivityNotifier}};
|
||||
|
||||
mod feedback;
|
||||
mod hardware;
|
||||
mod pm3;
|
||||
mod logger;
|
||||
mod tally_id;
|
||||
mod webserver;
|
||||
mod store;
|
||||
|
||||
const STORE_PATH: &str = "./data.json";
|
||||
|
||||
async fn run_webserver<H>(
|
||||
store: Arc<Mutex<IDStore>>,
|
||||
id_channel: Sender<String>,
|
||||
hotspot: Arc<Mutex<H>>,
|
||||
user_feedback: Arc<Mutex<FeedbackImpl>>,
|
||||
) -> Result<()>
|
||||
where
|
||||
H: Hotspot + Send + Sync + 'static,
|
||||
{
|
||||
let activity_channel = spawn_idle_watcher(Duration::from_secs(60 * 30), move || {
|
||||
info!("No activity on webserver. Disabling hotspot");
|
||||
let cloned_hotspot = hotspot.clone();
|
||||
let cloned_user_feedback = user_feedback.clone();
|
||||
tokio::spawn(async move {
|
||||
let _ = cloned_hotspot.lock().await.disable_hotspot().await;
|
||||
cloned_user_feedback
|
||||
.lock()
|
||||
.await
|
||||
.set_device_status(feedback::DeviceStatus::Ready);
|
||||
});
|
||||
});
|
||||
|
||||
let notifier = ActivityNotifier {
|
||||
sender: activity_channel,
|
||||
};
|
||||
|
||||
start_webserver(store, id_channel, notifier).await?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn load_or_create_store() -> Result<IDStore> {
|
||||
if fs::try_exists(STORE_PATH).await? {
|
||||
info!("Loading data from file");
|
||||
IDStore::new_from_json(STORE_PATH).await
|
||||
} else {
|
||||
info!("No data file found. Creating empty one.");
|
||||
Ok(IDStore::new())
|
||||
}
|
||||
}
|
||||
|
||||
fn get_hotspot_enable_ids() -> Vec<TallyID> {
|
||||
let hotspot_ids: Vec<TallyID> = env::var("HOTSPOT_IDS")
|
||||
.map(|ids| ids.split(";").map(|id| TallyID(id.to_owned())).collect())
|
||||
.unwrap_or_default();
|
||||
|
||||
if hotspot_ids.is_empty() {
|
||||
warn!(
|
||||
"HOTSPOT_IDS is not set or empty. You will not be able to activate the hotspot via a tally!"
|
||||
);
|
||||
}
|
||||
|
||||
hotspot_ids
|
||||
}
|
||||
|
||||
async fn handle_ids_loop(
|
||||
mut id_channel: Receiver<String>,
|
||||
hotspot_enable_ids: Vec<TallyID>,
|
||||
id_store: Arc<Mutex<IDStore>>,
|
||||
hotspot: Arc<Mutex<impl Hotspot>>,
|
||||
user_feedback: Arc<Mutex<FeedbackImpl>>,
|
||||
) -> Result<()> {
|
||||
while let Ok(tally_id_string) = id_channel.recv().await {
|
||||
let tally_id = TallyID(tally_id_string);
|
||||
|
||||
if hotspot_enable_ids.contains(&tally_id) {
|
||||
info!("Enableing hotspot");
|
||||
let hotspot_enable_result = hotspot.lock().await.enable_hotspot().await;
|
||||
|
||||
match hotspot_enable_result {
|
||||
Ok(_) => {
|
||||
user_feedback
|
||||
.lock()
|
||||
.await
|
||||
.set_device_status(feedback::DeviceStatus::HotspotEnabled);
|
||||
}
|
||||
Err(e) => {
|
||||
error!("Hotspot: {e}");
|
||||
}
|
||||
}
|
||||
|
||||
// TODO: Should the ID be added anyway or ignored ?
|
||||
}
|
||||
|
||||
if id_store.lock().await.add_id(tally_id) {
|
||||
info!("Added new id to current day");
|
||||
|
||||
user_feedback.lock().await.success().await;
|
||||
|
||||
if let Err(e) = id_store.lock().await.export_json(STORE_PATH).await {
|
||||
error!("Failed to save id store to file: {e}");
|
||||
user_feedback.lock().await.failure().await;
|
||||
// TODO: How to handle a failure to save ?
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn enter_error_state(feedback: Arc<Mutex<FeedbackImpl>>, hotspot: Arc<Mutex<impl Hotspot>>) {
|
||||
let _ = feedback.lock().await.activate_error_state().await;
|
||||
let _ = hotspot.lock().await.enable_hotspot().await;
|
||||
|
||||
let mut sigterm = signal(SignalKind::terminate()).unwrap();
|
||||
sigterm.recv().await;
|
||||
}
|
||||
|
||||
#[tokio::main]
|
||||
async fn main() -> Result<()> {
|
||||
logger::setup_logger();
|
||||
|
||||
info!("Starting application");
|
||||
|
||||
let user_feedback = Arc::new(Mutex::new(Feedback::new()?));
|
||||
let hotspot = Arc::new(Mutex::new(create_hotspot()?));
|
||||
|
||||
let error_flag_set = args().any(|e| e == "--error" || e == "-e");
|
||||
if error_flag_set {
|
||||
error!("Error flag set. Entering error state");
|
||||
enter_error_state(user_feedback.clone(), hotspot).await;
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
let store: Arc<Mutex<IDStore>> = Arc::new(Mutex::new(load_or_create_store().await?));
|
||||
let hotspot_enable_ids = get_hotspot_enable_ids();
|
||||
|
||||
let (tx, rx) = broadcast::channel::<String>(32);
|
||||
let sse_tx = tx.clone();
|
||||
|
||||
let pm3_handle = run_pm3(tx);
|
||||
|
||||
user_feedback.lock().await.startup().await;
|
||||
|
||||
let loop_handle = handle_ids_loop(
|
||||
rx,
|
||||
hotspot_enable_ids,
|
||||
store.clone(),
|
||||
hotspot.clone(),
|
||||
user_feedback.clone(),
|
||||
);
|
||||
|
||||
let webserver_handle = run_webserver(
|
||||
store.clone(),
|
||||
sse_tx,
|
||||
hotspot.clone(),
|
||||
user_feedback.clone(),
|
||||
);
|
||||
|
||||
let run_result = try_join!(pm3_handle, loop_handle, webserver_handle);
|
||||
|
||||
if let Err(e) = run_result {
|
||||
error!("Failed to run application: {e}");
|
||||
return Err(e);
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
@ -1,4 +0,0 @@
|
||||
mod runner;
|
||||
mod parser;
|
||||
|
||||
pub use runner::run_pm3;
|
||||
@ -1,10 +0,0 @@
|
||||
use regex::Regex;
|
||||
|
||||
/// Parses the output of PM3 finds the read IDs
|
||||
/// Example input: `[+] UID.... 3112B710`
|
||||
pub fn parse_line(line: &str) -> Option<String> {
|
||||
let regex = Regex::new(r"(?m)^\[\+\] UID.... (.*)$").unwrap();
|
||||
let result = regex.captures(line);
|
||||
|
||||
result.map(|c| c.get(1).unwrap().as_str().to_owned())
|
||||
}
|
||||
@ -1,95 +0,0 @@
|
||||
use anyhow::{Result, anyhow};
|
||||
use log::{debug, info, trace, warn};
|
||||
use std::env;
|
||||
use std::process::Stdio;
|
||||
use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
|
||||
use tokio::process::Command;
|
||||
use tokio::select;
|
||||
use tokio::signal::unix::{SignalKind, signal};
|
||||
use tokio::sync::broadcast;
|
||||
|
||||
/// Runs the pm3 binary and monitors it's output
|
||||
/// The pm3 binary is ether set in the env var PM3_BIN or found in the path
|
||||
/// The ouput is parsed and send via the `tx` channel
|
||||
pub async fn run_pm3(tx: broadcast::Sender<String>) -> Result<()> {
|
||||
kill_orphans().await;
|
||||
|
||||
let pm3_path = match env::var("PM3_BIN") {
|
||||
Ok(path) => path,
|
||||
Err(_) => {
|
||||
info!("PM3_BIN not set. Using default value");
|
||||
"pm3".to_owned()
|
||||
}
|
||||
};
|
||||
|
||||
let mut cmd = Command::new("stdbuf")
|
||||
.arg("-oL")
|
||||
.arg(pm3_path)
|
||||
.arg("-c")
|
||||
.arg("lf hitag reader -@")
|
||||
.stdout(Stdio::piped())
|
||||
.stderr(Stdio::null())
|
||||
.stdin(Stdio::piped())
|
||||
.spawn()?;
|
||||
|
||||
let stdout = cmd.stdout.take().ok_or(anyhow!("Failed to get stdout"))?;
|
||||
let mut stdin = cmd.stdin.take().ok_or(anyhow!("Failed to get stdin"))?;
|
||||
|
||||
let mut reader = BufReader::new(stdout).lines();
|
||||
|
||||
let mut sigterm = signal(SignalKind::terminate())?;
|
||||
|
||||
let child_handle = tokio::spawn(async move {
|
||||
let mut last_id: String = "".to_owned();
|
||||
while let Some(line) = reader.next_line().await.unwrap_or(None) {
|
||||
trace!("PM3: {line}");
|
||||
if let Some(uid) = super::parser::parse_line(&line) {
|
||||
if last_id == uid {
|
||||
let _ = tx.send(uid.clone());
|
||||
}
|
||||
last_id = uid;
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
select! {
|
||||
_ = child_handle => {}
|
||||
_ = sigterm.recv() => {
|
||||
debug!("Graceful shutdown of PM3");
|
||||
let _ = stdin.write_all(b"\n").await;
|
||||
let _ = stdin.flush().await;
|
||||
}
|
||||
};
|
||||
|
||||
let status = cmd.wait().await?;
|
||||
|
||||
// We use the exit code here because status.success() is false if the child was terminated by a
|
||||
// signal
|
||||
let code = status.code().unwrap_or(0);
|
||||
|
||||
if code == 0 {
|
||||
Ok(())
|
||||
} else {
|
||||
Err(anyhow!("PM3 exited with a non-zero exit code: {code}"))
|
||||
}
|
||||
}
|
||||
|
||||
/// Kills any open pm3 instances
|
||||
/// Also funny name. hehehe.
|
||||
async fn kill_orphans() {
|
||||
let kill_result = Command::new("pkill")
|
||||
.arg("-KILL")
|
||||
.arg("-x")
|
||||
.arg("proxmark3")
|
||||
.output()
|
||||
.await;
|
||||
|
||||
match kill_result {
|
||||
Ok(_) => {
|
||||
debug!("Successfully killed orphaned pm3 instances");
|
||||
}
|
||||
Err(e) => {
|
||||
warn!("Failed to kill pm3 orphans: {e} Continuing anyway");
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,46 +0,0 @@
|
||||
use std::time::Duration;
|
||||
|
||||
use log::error;
|
||||
use rocket::{
|
||||
Data, Request,
|
||||
fairing::{Fairing, Info, Kind},
|
||||
};
|
||||
use tokio::{sync::mpsc, time::timeout};
|
||||
|
||||
pub struct ActivityNotifier {
|
||||
pub sender: mpsc::Sender<()>,
|
||||
}
|
||||
|
||||
#[rocket::async_trait]
|
||||
impl Fairing for ActivityNotifier {
|
||||
fn info(&self) -> Info {
|
||||
Info {
|
||||
name: "Keeps track of time since the last request",
|
||||
kind: Kind::Request | Kind::Response,
|
||||
}
|
||||
}
|
||||
|
||||
async fn on_request(&self, _: &mut Request<'_>, _: &mut Data<'_>) {
|
||||
error!("on_request");
|
||||
let _ = self.sender.try_send(());
|
||||
}
|
||||
}
|
||||
|
||||
pub fn spawn_idle_watcher<F>(idle_duration: Duration, mut on_idle: F) -> mpsc::Sender<()>
|
||||
where
|
||||
F: FnMut() + Send + 'static,
|
||||
{
|
||||
let (tx, mut rx) = mpsc::channel::<()>(100);
|
||||
|
||||
tokio::spawn(async move {
|
||||
loop {
|
||||
let idle = timeout(idle_duration, rx.recv()).await;
|
||||
if idle.is_err() {
|
||||
// No activity received in the duration
|
||||
on_idle();
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
tx
|
||||
}
|
||||
@ -1,6 +0,0 @@
|
||||
mod server;
|
||||
mod activity_fairing;
|
||||
|
||||
pub use activity_fairing::{ActivityNotifier,spawn_idle_watcher};
|
||||
pub use server::start_webserver;
|
||||
|
||||
@ -1,142 +0,0 @@
|
||||
use log::{error, info, warn};
|
||||
use rocket::http::Status;
|
||||
use rocket::response::stream::{Event, EventStream};
|
||||
use rocket::serde::json::Json;
|
||||
use rocket::{Config, Shutdown, State, post};
|
||||
use rocket::{get, http::ContentType, response::content::RawHtml, routes};
|
||||
use rust_embed::Embed;
|
||||
use serde::Deserialize;
|
||||
use std::borrow::Cow;
|
||||
use std::env;
|
||||
use std::ffi::OsStr;
|
||||
use std::sync::Arc;
|
||||
use tokio::select;
|
||||
use tokio::sync::Mutex;
|
||||
use tokio::sync::broadcast::Sender;
|
||||
|
||||
use crate::store::{IDMapping, IDStore, Name};
|
||||
use crate::tally_id::TallyID;
|
||||
use crate::webserver::ActivityNotifier;
|
||||
|
||||
#[derive(Embed)]
|
||||
#[folder = "web/dist"]
|
||||
struct Asset;
|
||||
|
||||
#[derive(Deserialize)]
|
||||
struct NewMapping {
|
||||
id: String,
|
||||
name: Name,
|
||||
}
|
||||
|
||||
pub async fn start_webserver(
|
||||
store: Arc<Mutex<IDStore>>,
|
||||
sse_broadcaster: Sender<String>,
|
||||
fairing: ActivityNotifier,
|
||||
) -> Result<(), rocket::Error> {
|
||||
let port = match env::var("HTTP_PORT") {
|
||||
Ok(port) => port.parse().unwrap_or_else(|_| {
|
||||
warn!("Failed to parse HTTP_PORT. Using default 80");
|
||||
80
|
||||
}),
|
||||
Err(_) => 80,
|
||||
};
|
||||
|
||||
let config = Config {
|
||||
address: "0.0.0.0".parse().unwrap(), // Listen on all interfaces
|
||||
port,
|
||||
..Config::default()
|
||||
};
|
||||
|
||||
rocket::custom(config)
|
||||
.attach(fairing)
|
||||
.mount(
|
||||
"/",
|
||||
routes![
|
||||
static_files,
|
||||
index,
|
||||
export_csv,
|
||||
id_event,
|
||||
get_mapping,
|
||||
add_mapping
|
||||
],
|
||||
)
|
||||
.manage(store)
|
||||
.manage(sse_broadcaster)
|
||||
.launch()
|
||||
.await?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[get("/")]
|
||||
fn index() -> Option<RawHtml<Cow<'static, [u8]>>> {
|
||||
let asset = Asset::get("index.html")?;
|
||||
Some(RawHtml(asset.data))
|
||||
}
|
||||
|
||||
#[get("/<file..>")]
|
||||
fn static_files(file: std::path::PathBuf) -> Option<(ContentType, Vec<u8>)> {
|
||||
let filename = file.display().to_string();
|
||||
let asset = Asset::get(&filename)?;
|
||||
let content_type = file
|
||||
.extension()
|
||||
.and_then(OsStr::to_str)
|
||||
.and_then(ContentType::from_extension)
|
||||
.unwrap_or(ContentType::Bytes);
|
||||
|
||||
Some((content_type, asset.data.into_owned()))
|
||||
}
|
||||
|
||||
#[get("/api/idevent")]
|
||||
fn id_event(sse_broadcaster: &State<Sender<String>>, shutdown: Shutdown) -> EventStream![] {
|
||||
let mut rx = sse_broadcaster.subscribe();
|
||||
EventStream! {
|
||||
loop {
|
||||
select! {
|
||||
msg = rx.recv() => {
|
||||
if let Ok(id) = msg {
|
||||
yield Event::data(id);
|
||||
}
|
||||
}
|
||||
_ = &mut shutdown.clone() => {
|
||||
// Shutdown signal received, exit the loop
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[get("/api/csv")]
|
||||
async fn export_csv(manager: &State<Arc<Mutex<IDStore>>>) -> Result<String, Status> {
|
||||
info!("Exporting CSV");
|
||||
match manager.lock().await.export_csv() {
|
||||
Ok(csv) => Ok(csv),
|
||||
Err(e) => {
|
||||
error!("Failed to generate csv: {e}");
|
||||
Err(Status::InternalServerError)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[get("/api/mapping")]
|
||||
async fn get_mapping(store: &State<Arc<Mutex<IDStore>>>) -> Json<IDMapping> {
|
||||
Json(store.lock().await.mapping.clone())
|
||||
}
|
||||
|
||||
#[post("/api/mapping", format = "json", data = "<new_mapping>")]
|
||||
async fn add_mapping(store: &State<Arc<Mutex<IDStore>>>, new_mapping: Json<NewMapping>) -> Status {
|
||||
if new_mapping.id.is_empty()
|
||||
|| new_mapping.name.first.is_empty()
|
||||
|| new_mapping.name.last.is_empty()
|
||||
{
|
||||
return Status::BadRequest;
|
||||
}
|
||||
|
||||
store
|
||||
.lock()
|
||||
.await
|
||||
.mapping
|
||||
.add_mapping(TallyID(new_mapping.id.clone()), new_mapping.name.clone());
|
||||
|
||||
Status::Created
|
||||
}
|
||||
Loading…
x
Reference in New Issue
Block a user