Merge branch 'master' of github.com:thirtythreeforty/neolink into mqtt_cmd

This commit is contained in:
QuantumEntangledAndy committed 2022-01-17 15:59:11 +07:00
commit e436b27e63
82 files changed
+5108 -1314

No files matched your search

+11
View File
@@ -41,3 +41,14 @@ jobs:
- name: rustfmt
run: |
cargo +nightly fmt --all -- --check
check_lua:
name: Luacheck
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v1
- name: Run luacheck
uses: nebularg/actions-luacheck@v1
with:
files: 'dissector/baichuan.lua'
args: --globals Dissector Proto ProtoField base ByteArray DESEGMENT_ONE_MORE_SEGMENT DissectorTable
Generated
+203 -259
View File
@@ -35,9 +35,9 @@ dependencies = [
[[package]]
name = "aho-corasick"
version = "0.7.15"
version = "0.7.18"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7404febffaa47dac81aa44dba71523c9d069b1bdc50a77db41195149e17f68e5"
checksum = "1e37cfd5e7657ada45f742d6e99ca5788580b5c529dc78faf11ece6dc702656f"
dependencies = [
"memchr",
]
@@ -48,7 +48,7 @@ version = "0.11.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ee49baf6cb617b853aa8d93bf420db2383fab46d314482ca2803b40d5fde979b"
dependencies = [
"winapi",
"winapi 0.3.9",
]
[[package]]
@@ -64,15 +64,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "23b62fc65de8e4e7f52534fb52b0f3ed04746ae267519eef2a83941e8085068b"
[[package]]
name = "async-channel"
version = "1.6.1"
name = "assert_matches"
version = "1.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2114d64672151c0c5eaa5e131ec84a74f06e1e559830dabba01ca30605d66319"
dependencies = [
"concurrent-queue",
"event-listener",
"futures-core",
]
checksum = "9b34d609dfbaf33d6889b2b7106d3ca345eacad44200913df5ba02bfd31d2ba9"
[[package]]
name = "atty"
@@ -82,7 +77,7 @@ checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
dependencies = [
"hermit-abi",
"libc",
"winapi",
"winapi 0.3.9",
]
[[package]]
@@ -97,12 +92,6 @@ version = "0.2.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a4521f3e3d031370679b3b140beb36dfe4801b09ac77e30c61941f97df3ef28b"
[[package]]
name = "base64"
version = "0.13.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "904dfeac50f3cdaba28fc6f57fdcddb75f49ed61346676a78c4ffe55877802fd"
[[package]]
name = "bitflags"
version = "1.2.1"
@@ -134,22 +123,16 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "65c1bf4a04a88c54f589125563643d773f3254b5c38571395e2b591c693bbc81"
[[package]]
name = "bytes"
version = "1.0.1"
name = "byteorder"
version = "1.4.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b700ce4376041dcd0a327fd0097c41095743c4c8af8887265942faf1100bd040"
checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"
[[package]]
name = "cache-padded"
name = "c_linked_list"
version = "1.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "631ae5198c9be5e753e5cc215e1bd73c2b466a3565173db433f52bb9d3e66dba"
[[package]]
name = "cc"
version = "1.0.69"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e70cc2f62c6ce1868963827bd677764c62d07c3d9a3e1fb1177ee1a9ab199eb2"
checksum = "4964518bd3b4a8190e832886cdc0da9794f12e8e6c1613a9e90ff331c4c8724b"
[[package]]
name = "cfb-mode"
@@ -206,13 +189,10 @@ dependencies = [
]
[[package]]
name = "concurrent-queue"
version = "1.2.2"
name = "const-sha1"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "30ed07550be01594c6026cff2a1d7fe9c8f683caa798e12b68694ac9e88286a3"
dependencies = [
"cache-padded",
]
checksum = "fb58b6451e8c2a812ad979ed1d83378caa5e927eef2622017a45f251457c2c9d"
[[package]]
name = "const_fn"
@@ -226,6 +206,15 @@ version = "0.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "396de984970346b0d9e93d1415082923c679e5ae5c3ee3dcbd104f5610af126b"
[[package]]
name = "crc32fast"
version = "1.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "81156fece84ab6a9f2afdb109ce3ae577e42b1228441eded99bd77f627953b1a"
dependencies = [
"cfg-if 1.0.0",
]
[[package]]
name = "crossbeam"
version = "0.7.3"
@@ -357,18 +346,6 @@ dependencies = [
"synstructure",
]
[[package]]
name = "event-listener"
version = "2.5.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f7531096570974c3a9dcf9e4b8e1cede1ec26cf5046219fb3b9d897503b9be59"
[[package]]
name = "fnv"
version = "1.0.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
[[package]]
name = "form_urlencoded"
version = "1.0.1"
@@ -443,6 +420,12 @@ dependencies = [
"slab",
]
[[package]]
name = "gcc"
version = "0.3.55"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8f5f3913fa0bfe7ee1fd8248b6b9f42a5af4b9d65ec2dd2c3c26132b950ecfc2"
[[package]]
name = "generic-array"
version = "0.14.4"
@@ -453,6 +436,39 @@ dependencies = [
"version_check",
]
[[package]]
name = "get_if_addrs"
version = "0.5.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "abddb55a898d32925f3148bd281174a68eeb68bbfd9a5938a57b18f506ee4ef7"
dependencies = [
"c_linked_list",
"get_if_addrs-sys",
"libc",
"winapi 0.2.8",
]
[[package]]
name = "get_if_addrs-sys"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0d04f9fb746cf36b191c00f3ede8bde9c8e64f9f4b05ae2694a9ccf5e3f5ab48"
dependencies = [
"gcc",
"libc",
]
[[package]]
name = "getrandom"
version = "0.2.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7fcd999463524c52659517fe2cea98493cfe485d10565e7b0fb07dbba7ad2753"
dependencies = [
"cfg-if 1.0.0",
"libc",
"wasi",
]
[[package]]
name = "gio"
version = "0.14.0"
@@ -480,7 +496,7 @@ dependencies = [
"gobject-sys",
"libc",
"system-deps",
"winapi",
"winapi 0.3.9",
]
[[package]]
@@ -760,17 +776,6 @@ dependencies = [
"libc",
]
[[package]]
name = "http"
version = "0.2.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "527e8c9ac747e28542699a951517aa9a6945af506cd1f2e1b53a576c17b6cc11"
dependencies = [
"bytes",
"fnv",
"itoa",
]
[[package]]
name = "humantime"
version = "2.1.0"
@@ -841,15 +846,6 @@ version = "0.4.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dd25036021b0de88a0aff6b850051563c6516d0bf53f8638938edbb9de732736"
[[package]]
name = "js-sys"
version = "0.3.52"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ce791b7ca6638aae45be056e068fc756d871eb3b3b10b8efa62d1c9cec616752"
dependencies = [
"wasm-bindgen",
]
[[package]]
name = "lazy_static"
version = "1.4.0"
@@ -875,6 +871,19 @@ version = "0.2.98"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "320cfe77175da3a483efed4bc0adc1968ca050b098ce4f2f1c13a56626128790"
[[package]]
name = "local-ip-address"
version = "0.4.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8b143c6ef86e36328caa40a7578e95d1544aca8a1740235fd2b416a69441a5c7"
dependencies = [
"libc",
"memalloc",
"neli",
"thiserror",
"windows",
]
[[package]]
name = "log"
version = "0.4.14"
@@ -903,10 +912,16 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "490cc448043f947bae3cbee9c203358d62dbee0db12107a74be5c30ccfd09771"
[[package]]
name = "memchr"
version = "2.3.4"
name = "memalloc"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0ee1c47aaa256ecabcaea351eae4a9b01ef39ed810004e298d2511ed284b1525"
checksum = "df39d232f5c40b0891c10216992c2f250c054105cb1e56f0fc9032db6203ecc1"
[[package]]
name = "memchr"
version = "2.4.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "308cc39be01b73d0d18f82a0e7b2a3df85245f84af96fdddc5d202d27e47b86a"
[[package]]
name = "memoffset"
@@ -917,53 +932,32 @@ dependencies = [
"autocfg",
]
[[package]]
name = "mio"
version = "0.7.13"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8c2bdb6314ec10835cd3293dd268473a835c02b7b352e788be788b3c6ca6bb16"
dependencies = [
"libc",
"log",
"miow",
"ntapi",
"winapi",
]
[[package]]
name = "miow"
version = "0.3.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b9f1c5b025cda876f66ef43a113f91ebc9f4ccef34843000e0adf6ebbab84e21"
dependencies = [
"winapi",
]
[[package]]
name = "mqttbytes"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d710573f2144656d97b82b7ad85c464a1c35ae065278fbee545d40034ec1de5a"
dependencies = [
"bytes",
]
[[package]]
name = "muldiv"
version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b5136edda114182728ccdedb9f5eda882781f35fa6e80cc360af12a8932507f3"
[[package]]
name = "neli"
version = "0.5.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9053554eb5dcb7e10d9cdab1206965bde870eed5d0d341532ca035e3ba221508"
dependencies = [
"byteorder",
"libc",
]
[[package]]
name = "neolink"
version = "0.4.0"
dependencies = [
"aes",
"anyhow",
"byte-slice-cast",
"cfb-mode",
"cookie-factory",
"crossbeam",
"crossbeam-channel 0.5.1",
"env_logger",
"err-derive",
"gstreamer",
@@ -977,12 +971,10 @@ dependencies = [
"neolink_core",
"nom",
"regex",
"rumqttc",
"serde",
"socket2",
"structopt",
"time",
"tokio",
"toml",
"validator",
"validator_derive",
@@ -996,14 +988,22 @@ name = "neolink_core"
version = "0.4.0"
dependencies = [
"aes",
"assert_matches",
"cfb-mode",
"cookie-factory",
"crc32fast",
"crossbeam-channel 0.5.1",
"env_logger",
"err-derive",
"get_if_addrs",
"indoc",
"lazy_static",
"local-ip-address",
"log",
"md5",
"nom",
"rand",
"regex",
"socket2",
"time",
"xml-rs",
@@ -1013,9 +1013,9 @@ dependencies = [
[[package]]
name = "nom"
version = "6.2.1"
version = "6.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9c5c51b9083a3c620fa67a2a635d1ce7d95b897e957d6b28ff9a5da960a103a6"
checksum = "e7413f999671bd4745a7b624bd370a569fb6bc574b23c83a3c5ed2e453f3d5e2"
dependencies = [
"bitvec",
"funty",
@@ -1024,15 +1024,6 @@ dependencies = [
"version_check",
]
[[package]]
name = "ntapi"
version = "0.3.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3f6bb902e437b6d86e03cce10a7e2af662292c5dfef23b65899ea3ac9354ad44"
dependencies = [
"winapi",
]
[[package]]
name = "num-integer"
version = "0.1.44"
@@ -1106,10 +1097,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3831453b3449ceb48b6d9c7ad7c96d5ea673e9b470a1dc578c2ce6521230884c"
[[package]]
name = "pollster"
version = "0.2.4"
name = "ppv-lite86"
version = "0.2.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bb20dcc30536a1508e75d47dd0e399bb2fe7354dcf35cda9127f2bf1ed92e30e"
checksum = "ac74c624d6b2d21f425f752262f42188365d7b8ff1aff74c82e45136510a4857"
[[package]]
name = "pretty-hex"
@@ -1182,10 +1173,50 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "941ba9d78d8e2f7ce474c015eea4d9c6d25b6a3327f9832ee29a4de27f91bbb8"
[[package]]
name = "regex"
version = "1.4.6"
name = "rand"
version = "0.8.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2a26af418b574bd56588335b3a3659a65725d4e636eb1016c2f9e3b38c7cc759"
checksum = "2e7573632e6454cf6b99d7aac4ccca54be06da05aca2ef7423d22d27d4d4bcd8"
dependencies = [
"libc",
"rand_chacha",
"rand_core",
"rand_hc",
]
[[package]]
name = "rand_chacha"
version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
dependencies = [
"ppv-lite86",
"rand_core",
]
[[package]]
name = "rand_core"
version = "0.6.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d34f1408f55294453790c48b2f1ebbb1c5b4b7563eb1f418bcfcfdbb06ebb4e7"
dependencies = [
"getrandom",
]
[[package]]
name = "rand_hc"
version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d51e9f596de227fda2ea6c84607f5558e196eeaf43c986b724ba4fb8fdf497e7"
dependencies = [
"rand_core",
]
[[package]]
name = "regex"
version = "1.5.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d07a8629359eb56f1e2fb1652bb04212c072a87ba68546a04065d525673ac461"
dependencies = [
"aho-corasick",
"memchr",
@@ -1198,39 +1229,6 @@ version = "0.6.25"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f497285884f3fcff424ffc933e56d7cbca511def0c9831a7f9b5f6153e3cc89b"
[[package]]
name = "ring"
version = "0.16.20"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3053cf52e236a3ed746dfc745aa9cacf1b791d846bdaf412f60a8d7d6e17c8fc"
dependencies = [
"cc",
"libc",
"once_cell",
"spin",
"untrusted",
"web-sys",
"winapi",
]
[[package]]
name = "rumqttc"
version = "0.8.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bd4cf48aa8588d907fc835c47fbc8ef01dc30552467fbf0123cd794f77fd2072"
dependencies = [
"async-channel",
"bytes",
"http",
"log",
"mqttbytes",
"pollster",
"thiserror",
"tokio",
"tokio-rustls",
"webpki",
]
[[package]]
name = "rustc_version"
version = "0.2.3"
@@ -1240,19 +1238,6 @@ dependencies = [
"semver",
]
[[package]]
name = "rustls"
version = "0.19.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "35edb675feee39aec9c99fa5ff985081995a06d594114ae14cbe797ad7b7a6d7"
dependencies = [
"base64",
"log",
"ring",
"sct",
"webpki",
]
[[package]]
name = "rustversion"
version = "1.0.5"
@@ -1271,16 +1256,6 @@ version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
[[package]]
name = "sct"
version = "0.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b362b83898e0e69f38515b82ee15aa80636befe47c3b6d3d89a911e78fc228ce"
dependencies = [
"ring",
"untrusted",
]
[[package]]
name = "semver"
version = "0.9.0"
@@ -1353,15 +1328,9 @@ checksum = "122e570113d28d773067fab24266b66753f6ea915758651696b6e35e49f88d6e"
dependencies = [
"cfg-if 1.0.0",
"libc",
"winapi",
"winapi 0.3.9",
]
[[package]]
name = "spin"
version = "0.5.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6e63cff320ae2c57904679ba7cb63280a3dc4613885beafb148ee7bf9aa9042d"
[[package]]
name = "standback"
version = "0.2.17"
@@ -1571,7 +1540,7 @@ dependencies = [
"stdweb",
"time-macros",
"version_check",
"winapi",
"winapi 0.3.9",
]
[[package]]
@@ -1612,44 +1581,6 @@ version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cda74da7e1a664f795bb1f8a87ec406fb89a02522cf6e50620d016add6dbbf5c"
[[package]]
name = "tokio"
version = "1.9.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4b7b349f11a7047e6d1276853e612d152f5e8a352c61917887cc2169e2366b4c"
dependencies = [
"autocfg",
"bytes",
"libc",
"memchr",
"mio",
"pin-project-lite",
"tokio-macros",
"winapi",
]
[[package]]
name = "tokio-macros"
version = "1.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "54473be61f4ebe4efd09cec9bd5d16fa51d70ea0192213d754d2d500457db110"
dependencies = [
"proc-macro2",
"quote",
"syn",
]
[[package]]
name = "tokio-rustls"
version = "0.22.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bc6844de72e57df1980054b38be3a9f4702aba4858be64dd700181a8a6d0e1b6"
dependencies = [
"rustls",
"tokio",
"webpki",
]
[[package]]
name = "toml"
version = "0.5.8"
@@ -1707,12 +1638,6 @@ version = "0.1.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f14ee04d9415b52b3aeab06258a3f07093182b88ba0f9b8d203f211a7a7d41c7"
[[package]]
name = "untrusted"
version = "0.7.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a156c684c91ea7d62626509bce3cb4e1d9ed5c4d978f7b4352658f96a4c26b4a"
[[package]]
name = "url"
version = "2.2.2"
@@ -1774,10 +1699,16 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5fecdca9a5291cc2b8dcf7dc02453fee791a280f3743cb0905f8822ae463b3fe"
[[package]]
name = "wasm-bindgen"
version = "0.2.75"
name = "wasi"
version = "0.10.2+wasi-snapshot-preview1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b608ecc8f4198fe8680e2ed18eccab5f0cd4caaf3d83516fa5fb2e927fda2586"
checksum = "fd6fbd9a79829dd1ad0cc20627bf1ed606756a7f77edff7b66b7064f9cb327c6"
[[package]]
name = "wasm-bindgen"
version = "0.2.74"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d54ee1d4ed486f78874278e63e4069fc1ab9f6a18ca492076ffb90c5eb2997fd"
dependencies = [
"cfg-if 1.0.0",
"wasm-bindgen-macro",
@@ -1785,9 +1716,9 @@ dependencies = [
[[package]]
name = "wasm-bindgen-backend"
version = "0.2.75"
version = "0.2.74"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "580aa3a91a63d23aac5b6b267e2d13cb4f363e31dce6c352fca4752ae12e479f"
checksum = "3b33f6a0694ccfea53d94db8b2ed1c3a8a4c86dd936b13b9f0a15ec4a451b900"
dependencies = [
"bumpalo",
"lazy_static",
@@ -1800,9 +1731,9 @@ dependencies = [
[[package]]
name = "wasm-bindgen-macro"
version = "0.2.75"
version = "0.2.74"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "171ebf0ed9e1458810dfcb31f2e766ad6b3a89dbda42d8901f2b268277e5f09c"
checksum = "088169ca61430fe1e58b8096c24975251700e7b1f6fd91cc9d59b04fb9b18bd4"
dependencies = [
"quote",
"wasm-bindgen-macro-support",
@@ -1810,9 +1741,9 @@ dependencies = [
[[package]]
name = "wasm-bindgen-macro-support"
version = "0.2.75"
version = "0.2.74"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6c2657dd393f03aa2a659c25c6ae18a13a4048cebd220e147933ea837efc589f"
checksum = "be2241542ff3d9f241f5e2cb6dd09b37efe786df8851c54957683a49f0987a97"
dependencies = [
"proc-macro2",
"quote",
@@ -1823,29 +1754,15 @@ dependencies = [
[[package]]
name = "wasm-bindgen-shared"
version = "0.2.75"
version = "0.2.74"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2e0c4a743a309662d45f4ede961d7afa4ba4131a59a639f29b0069c3798bbcc2"
checksum = "d7cff876b8f18eed75a66cf49b65e7f967cb354a7aa16003fb55dbfd25b44b4f"
[[package]]
name = "web-sys"
version = "0.3.52"
name = "winapi"
version = "0.2.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "01c70a82d842c9979078c772d4a1344685045f1a5628f677c2b2eab4dd7d2696"
dependencies = [
"js-sys",
"wasm-bindgen",
]
[[package]]
name = "webpki"
version = "0.21.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b8e38c0608262c46d4a56202ebabdeb094cef7e560ca7a226c6bf055188aa4ea"
dependencies = [
"ring",
"untrusted",
]
checksum = "167dc9d6949a9b857f3451275e911c3f44255842c1f7a76f33c55103a909087a"
[[package]]
name = "winapi"
@@ -1869,7 +1786,7 @@ version = "0.1.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178"
dependencies = [
"winapi",
"winapi 0.3.9",
]
[[package]]
@@ -1878,6 +1795,33 @@ version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
[[package]]
name = "windows"
version = "0.18.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "68088239696c06152844eadc03d262f088932cce50c67e4ace86e19d95e976fe"
dependencies = [
"const-sha1",
"windows_gen",
"windows_macros",
]
[[package]]
name = "windows_gen"
version = "0.18.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cf583322dc423ee021035b358e535015f7fd163058a31e2d37b99a939141121d"
[[package]]
name = "windows_macros"
version = "0.18.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "58acfb8832e9f707f8997bd161e537a1c1f603e60a5bd9c3cf53484fdcc998f3"
dependencies = [
"syn",
"windows_gen",
]
[[package]]
name = "wyz"
version = "0.2.0"
+1
View File
@@ -42,3 +42,4 @@ byte-slice-cast = "1.0.0"
rumqttc = "0.8.0"
tokio = { version = "1.0", features = ["rt", "macros", "io-util"] }
crossbeam-channel = "0.5.1"
anyhow = "1.0.42"
+105 -50
View File
@@ -29,7 +29,39 @@ Currently it has been tested on the following cameras:
Neolink does not support other cameras such as the RLC-420, since they already
[provide native RTSP](https://support.reolink.com/hc/en-us/articles/360007010473-How-to-Live-View-Reolink-Cameras-via-VLC-Media-Player).
## Installation
## Usage
1. First, write a configuration yaml file describing your cameras. See the
Configuration section below or the provided sample config.
2. Launch Neolink:
```bash
neolink rtsp --config=your_config.yaml
```
3. Then, connect your RTSP viewer to `rtsp://127.0.0.1:8554/your_camera_name`!
### Additional commands
Neolink also has some additional command line tools
for controlling the camera. They are all used through neolink subcommands like this:
```bash
neolink subcommand --config=...
```
The currently supported subcommands are
- **rtsp**: The standard neolink rtsp bridge
- **status-light**: Control the LED status light
- **reboot**: Reboot a camera
- **talk**: Enable talk back through either the microphone or by
reading a sound file.
For a full list of commands use `neolink help`, or use
`neolink help <subcommand>` for details on a subcommand of interest.
## Download & Installation
In the future Neolink will be much easier to install.
For now, follow these steps.
@@ -39,8 +71,8 @@ Builds are provided for the following platforms:
- macOS x86_64 ([download][macos-ci-download])
- Ubuntu x86_64 ([download][ubuntu-ci-download])
- Debian x86 ([download][debian-x86-ci-download])
- Debian aarch64 ([download][debian-aarch-ci-download])
- Debian armhf ([download][debian-armhf-ci-download])
- Debian aarch64 (Raspberry Pi 64-bit) ([download][debian-aarch-ci-download])
- Debian armhf (Raspberry Pi 32-bit) ([download][debian-armhf-ci-download])
- Arch Linux ([AUR](https://aur.archlinux.org/packages/neolink-git/))
- Docker x86 (see below)
@@ -49,6 +81,18 @@ Builds are provided for the following platforms:
1. [Install Gstreamer][gstreamer] from the most recent MSI installer on Windows,
or your package manager on Linux.
On Ubuntu/Debian machines gstreamer can be installed with:
```bash
sudo apt install \
libgstrtspserver-1.0-0 \
libgstreamer1.0-0 \
libgstreamer-plugins-bad1.0-0 \
gstreamer1.0-plugins-good \
gstreamer1.0-plugins-bad
```
2. If you are using Windows, add the following to your `PATH` environment variable:
```
@@ -58,12 +102,18 @@ or your package manager on Linux.
**Note:** If you use Chocolatey to install Gstreamer, it does this
automatically.
3. Download and extract a [prebuilt binary from continuous integration][ci-download]
(click on the topmost commit for the most recent build).
3. Download and unpack Neolink from the links above.
1. Note: you can also click on [this link][ci-download] to see all historical builds.
You will need to be logged in to GitHub to download directly from the builds page.
You will need to be logged in to GitHub to download directly from the builds page (wget doesn't work)
Ubuntu/Debian/Raspberry Pi OS example:
```bash
unzip release-arm64-buster.zip
sudo cp neolink /usr/local/bin/
sudo chmod +x /usr/local/bin/neolink
```
4. Write a configuration file for your cameras. See the section below.
5. Launch Neolink from a shell, passing your configuration file:
@@ -107,29 +157,62 @@ docker run \
thirtythreeforty/neolink
```
Here is an example docker-compose:
```yml
---
version: "2"
services:
neolink:
image: thirtythreeforty/neolink
container_name: neolink
ports:
- 8554:8554
volumes:
- $PWD/neolink.toml:/etc/neolink.toml
restart: unless-stopped
```
The Docker image is "best effort" and intended for advanced users; questions
about running Docker are outside the scope of Neolink.
If you use a battery-powered camera (or other UDP-only camera) you will need to either
use `--net=host` or setup a [macvlan](https://docs.docker.com/network/macvlan/)
for the docker image that supports UDP broadcast.
This is because UDP requires that udp broadcast messages are transmitted across
the docker network interface, however this is [not possible in the default
bridging mode](https://github.com/docker/for-linux/issues/637)
## Configuration
**Note**: for a more comprehensive setup tutorial, refer to the
[Blue Iris setup walkthrough in `docs/`][blue-iris-setup] (which is probably
also helpful even with other NVR software).
**Note**: more comprehensive setup details for linux based devices is provided in
[docs/unix_setup.md][unix-setup]
**Note**: instructions for also setting up a (systemd based) service for linux
based devices is provided in [docs/unix_service.md][unix-service]
[blue-iris-setup]: docs/Setting%20Up%20Neolink%20For%20Use%20With%20Blue%20Iris.md
[unix-setup]: docs/unix_setup.md
[unix-service]: docs/unix_service.md
Copy and modify the `sample_config.toml` to specify the address, username, and
password for each camera (if there is no password, you can omit that line).
The default credentials for some cameras is username `admin` password `123456`.
- For a non battery powered camera you need to provide the address field with the
ip and port (default 9000).
- For a battery powered camera you need to provide the uid field with the
camera's UID. In this case your network must support UDP.
Battery cameras exclusively use this UDP mode so you must always use a UID.
Each `[[cameras]]` block creates a new camera; the `name` determines the RTSP
path you should connect your client to.
Currently Neolink cannot auto-detect cameras like the official clients do; you
must specify their IP addresses directly.
By default the H265 video format is used. Some cameras, for example E1, provide
H264 streams. To use these you must specify `format = "h264"` in the
`[[cameras]]` config. Soon this will be auto-detected, and you will not have to know or care about
the format.
By default, the HD stream is available at the RTSP path `/name` or
`/name/mainStream`, and the SD stream is available at `/name/subStream`.
@@ -144,16 +227,16 @@ You can modify this by changing the `bind` and the `bind_port` parameter.
You only need one `bind`/`bind_port` setting at the top of the config file.
You can enable `rtsps` (TLS) by adding a `certificate = "/path/to/pem"` to the
top section of the config file. This PEM should contain by the certificate
top section of the config file. This PEM should contain the certificate
and the key used for the server. If TLS is enabled all connections must use
`rtsps`. You can also control client side TLS with the config option
`rtsps`. You can also use client side TLS with the config option
`tls_client_auth = "none|request|require"`; in this case the client should
present a certificate signed by the server's CA.
TLS is disabled by default.
You can password-protect the Neolink server by adding `[[users]]` sections to
the configuration file:
the configuration file, but this is not secure without also using TLS:
```
[[users]]
@@ -186,11 +269,13 @@ You can change the Neolink log level by setting the `RUST_LOG` environment
variable (not in the configuration file) to one of `error`, `warn`, `info`,
`debug`, or `trace`:
- On sh:
```sh
set RUST_LOG=debug
```
On Linux:
- On Bash:
```bash
export RUST_LOG=debug
@@ -246,7 +331,7 @@ been upgraded several times.
The modern variant uses obfuscated XML commands and sends ordinary H.265 or
H.264 video streams encapsulated in a custom header.
More details about the on-the-wire protocol will come later.
More details of the on-the-wire protocol are provided in [`dissector/`](dissector/).
### Baichuan dissector
@@ -255,6 +340,7 @@ directory.
It dissects the BC header and also allows viewing the deobfuscated XML in
command messages.
(It cannot deobfuscate newer messages that use AES encryption.)
To use it, copy or symlink it into your Wireshark plugin directory; typically
this is `~/.local/lib/wireshark/plugins/` under Linux.
@@ -262,37 +348,6 @@ Currently the dissector does not attempt to decode the Baichuan "extension"
messages except `binaryData`.
This will change in the future as reverse engineering needs require.
## Additional Commands
Neolink also has some additional command line tools
for controlling the camera. They are all used through neolink subcommands like this:
```bash
neolink subcommand --config=...
```
The currently supported subcommands are
- **rtsp**: The standard neolink rtsp bridge
- **status-light**: A command to control the LED status light
- **reboot**: Will reboot a camera
- **talk**: Will enable talk back through either the microphone or by
reading a sound file.
For a full list of commands please use
```bash
neolink help
```
For further details on the subcommands please use the following
where `<subcommand>` is replaced with the subcommand of interest
```bash
neolink help <subcommand>
```
## License
Neolink is free software, released under the GNU Affero General Public License
+9 -1
View File
@@ -9,16 +9,24 @@ edition = "2018"
aes = "0.6"
cfb-mode = "0.6"
cookie-factory = "0.3"
crc32fast = "1.2.1"
crossbeam-channel = "0.5.1"
err-derive = "0.2"
get_if_addrs = "0.5.3"
lazy_static = "1.4"
local-ip-address = "0.4.4"
log = { version = "0.4" }
md5 = "0.7"
nom = "6.1.2"
rand = "0.8.4"
regex = "1.5.4"
socket2 = "0.3"
time = "0.2"
xml-rs = "0.8"
yaserde = "0.3.16"
yaserde_derive = "0.3.16"
xml-rs = "0.8"
[dev-dependencies]
assert_matches = "1.5.0"
env_logger = "*"
indoc = "0.3"
+319 -134
View File
@@ -1,10 +1,12 @@
use super::model::*;
use super::xml::{BcPayloads, BcXml};
use super::xml_crypto;
use crate::RX_TIMEOUT;
use err_derive::Error;
use nom::IResult;
use nom::{bytes::streaming::take, combinator::*, number::streaming::*, sequence::*};
use std::io::Read;
use time::OffsetDateTime;
/// The error types used during deserialisation
#[derive(Debug, Error)]
@@ -48,17 +50,20 @@ where
Err(e) => return Err(e.into()),
};
let start_time = OffsetDateTime::now_utc();
loop {
match (&mut rdr)
.take(to_read.get() as u64)
.read_to_end(&mut input)
{
Ok(0) => {
return Err(std::io::Error::new(
std::io::ErrorKind::UnexpectedEof,
"Read returned 0 bytes",
)
.into());
if (OffsetDateTime::now_utc() - start_time) > RX_TIMEOUT {
return Err(std::io::Error::new(
std::io::ErrorKind::UnexpectedEof,
"Read returned 0 bytes",
)
.into());
}
}
Ok(_) => break,
Err(e) if e.kind() == std::io::ErrorKind::WouldBlock => {
@@ -232,150 +237,330 @@ fn bc_header(buf: &[u8]) -> IResult<&[u8], BcHeader> {
))
}
#[test]
fn test_bc_modern_login() {
let sample = include_bytes!("samples/model_sample_modern_login.bin");
#[cfg(test)]
mod tests {
use super::*;
use crate::bc::xml::*;
use assert_matches::assert_matches;
let encryption_protocol =
std::sync::Arc::new(std::sync::Mutex::new(EncryptionProtocol::BCEncrypt));
let mut context = BcContext::new(encryption_protocol);
#[test]
fn test_bc_modern_login() {
let sample = include_bytes!("samples/model_sample_modern_login.bin");
let (buf, header) = bc_header(&sample[..]).unwrap();
let (_, body) = bc_body(&mut context, &header, buf).unwrap();
assert_eq!(header.msg_id, 1);
assert_eq!(header.body_len, 145);
assert_eq!(header.channel_id, 0);
assert_eq!(header.stream_type, 0);
assert_eq!(header.payload_offset, None);
assert_eq!(header.response_code, 0xdd01);
assert_eq!(header.class, 0x6614);
match body {
BcBody::ModernMsg(ModernMsg {
payload:
Some(BcPayloads::BcXml(BcXml {
encryption: Some(encryption),
..
})),
..
}) => assert_eq!(encryption.nonce, "9E6D1FCB9E69846D"),
_ => panic!(),
}
}
let encryption_protocol =
std::sync::Arc::new(std::sync::Mutex::new(EncryptionProtocol::BCEncrypt));
let mut context = BcContext::new(encryption_protocol);
#[test]
fn test_bc_legacy_login() {
let sample = include_bytes!("samples/model_sample_legacy_login.bin");
let encryption_protocol =
std::sync::Arc::new(std::sync::Mutex::new(EncryptionProtocol::BCEncrypt));
let mut context = BcContext::new(encryption_protocol);
let (buf, header) = bc_header(&sample[..]).unwrap();
let (_, body) = bc_body(&mut context, &header, buf).unwrap();
assert_eq!(header.msg_id, 1);
assert_eq!(header.body_len, 1836);
assert_eq!(header.channel_id, 0);
assert_eq!(header.stream_type, 0);
assert_eq!(header.payload_offset, None);
assert_eq!(header.response_code, 0xdc01);
assert_eq!(header.class, 0x6514);
match body {
BcBody::LegacyMsg(LegacyMsg::LoginMsg { username, password }) => {
assert_eq!(username, "21232F297A57A5A743894A0E4A801FC\0");
assert_eq!(password, EMPTY_LEGACY_PASSWORD);
let (buf, header) = bc_header(&sample[..]).unwrap();
let (_, body) = bc_body(&mut context, &header, buf).unwrap();
assert_eq!(header.msg_id, 1);
assert_eq!(header.body_len, 145);
assert_eq!(header.channel_id, 0);
assert_eq!(header.stream_type, 0);
assert_eq!(header.payload_offset, None);
assert_eq!(header.response_code, 0xdd01);
assert_eq!(header.class, 0x6614);
match body {
BcBody::ModernMsg(ModernMsg {
payload:
Some(BcPayloads::BcXml(BcXml {
encryption: Some(encryption),
..
})),
..
}) => assert_eq!(encryption.nonce, "9E6D1FCB9E69846D"),
_ => panic!(),
}
_ => panic!(),
}
}
#[test]
fn test_bc_modern_login_failed() {
let sample = include_bytes!("samples/modern_login_failed.bin");
#[test]
// This is an 0xdd03 encryption from an Argus 2
//
// It is currently unsupported
fn test_03_enc_login() {
let sample = include_bytes!("samples/battery_enc.bin");
let encryption_protocol =
std::sync::Arc::new(std::sync::Mutex::new(EncryptionProtocol::BCEncrypt));
let mut context = BcContext::new(encryption_protocol);
let encryption_protocol =
std::sync::Arc::new(std::sync::Mutex::new(EncryptionProtocol::BCEncrypt));
let mut context = BcContext::new(encryption_protocol);
let (buf, header) = bc_header(&sample[..]).unwrap();
let (_, body) = bc_body(&mut context, &header, buf).unwrap();
assert_eq!(header.msg_id, 1);
assert_eq!(header.body_len, 0);
assert_eq!(header.channel_id, 0);
assert_eq!(header.stream_type, 0);
assert_eq!(header.payload_offset, Some(0x0));
assert_eq!(header.response_code, 0x190); // 400
assert_eq!(header.class, 0x0000);
match body {
BcBody::ModernMsg(ModernMsg {
extension: None,
payload: None,
}) => {}
_ => panic!(),
let (buf, header) = bc_header(&sample[..]).unwrap();
assert!(bc_body(&mut context, &header, buf).is_err());
// It should error because we don't support it
//
// The following would be its contents if we
// did support it (maybe one day :) left it here
// for then)
//
//
// let (_, body) = bc_body(&mut context, &header, buf).unwrap();
// assert_eq!(header.msg_id, 1);
// assert_eq!(header.body_len, 175);
// assert_eq!(header.channel_id, 0);
// assert_eq!(header.stream_type, 0);
// assert_eq!(header.payload_offset, None);
// assert_eq!(header.response_code, 0xdd03);
// assert_eq!(header.class, 0x6614);
// match body {
// BcBody::ModernMsg(ModernMsg {
// payload:
// Some(BcPayloads::BcXml(BcXml {
// encryption: Some(encryption),
// ..
// })),
// ..
// }) => assert_eq!(encryption.nonce, "0-AhnEZyUg6eKrJFIWgXPF"),
// _ => panic!(),
// }
}
}
#[test]
fn test_bc_modern_login_success() {
let sample = include_bytes!("samples/modern_login_success.bin");
#[test]
fn test_bc_legacy_login() {
let sample = include_bytes!("samples/model_sample_legacy_login.bin");
let encryption_protocol =
std::sync::Arc::new(std::sync::Mutex::new(EncryptionProtocol::BCEncrypt));
let mut context = BcContext::new(encryption_protocol);
let encryption_protocol =
std::sync::Arc::new(std::sync::Mutex::new(EncryptionProtocol::BCEncrypt));
let mut context = BcContext::new(encryption_protocol);
let (buf, header) = bc_header(&sample[..]).unwrap();
let (_, body) = bc_body(&mut context, &header, buf).unwrap();
assert_eq!(header.msg_id, 1);
assert_eq!(header.body_len, 2949);
assert_eq!(header.channel_id, 0);
assert_eq!(header.stream_type, 0);
assert_eq!(header.payload_offset, Some(0x0));
assert_eq!(header.response_code, 0xc8); // 200
assert_eq!(header.class, 0x0000);
// Previously, we were not handling payload_offset == 0 (no bin offset) correctly.
// Test that we decoded XML and no binary.
match body {
BcBody::ModernMsg(ModernMsg {
extension: None,
payload: Some(_),
}) => {}
_ => panic!(),
}
}
#[test]
fn test_bc_binary_mode() {
let sample1 = include_bytes!("samples/modern_video_start1.bin");
let sample2 = include_bytes!("samples/modern_video_start2.bin");
let encryption_protocol =
std::sync::Arc::new(std::sync::Mutex::new(EncryptionProtocol::BCEncrypt));
let mut context = BcContext::new(encryption_protocol);
let msg1 = Bc::deserialize(&mut context, &sample1[..]).unwrap();
match msg1.body {
BcBody::ModernMsg(ModernMsg {
extension:
Some(Extension {
binary_data: Some(1),
..
}),
payload: Some(BcPayloads::Binary(bin)),
}) => {
assert_eq!(bin.len(), 32);
let (buf, header) = bc_header(&sample[..]).unwrap();
let (_, body) = bc_body(&mut context, &header, buf).unwrap();
assert_eq!(header.msg_id, 1);
assert_eq!(header.body_len, 1836);
assert_eq!(header.channel_id, 0);
assert_eq!(header.stream_type, 0);
assert_eq!(header.payload_offset, None);
assert_eq!(header.response_code, 0xdc01);
assert_eq!(header.class, 0x6514);
match body {
BcBody::LegacyMsg(LegacyMsg::LoginMsg { username, password }) => {
assert_eq!(username, "21232F297A57A5A743894A0E4A801FC\0");
assert_eq!(password, EMPTY_LEGACY_PASSWORD);
}
_ => panic!(),
}
_ => panic!(),
}
context.in_bin_mode.insert(msg1.meta.msg_num);
let msg2 = Bc::deserialize(&mut context, &sample2[..]).unwrap();
match msg2.body {
BcBody::ModernMsg(ModernMsg {
extension: None,
payload: Some(BcPayloads::Binary(bin)),
}) => {
assert_eq!(bin.len(), 30344);
#[test]
fn test_bc_modern_login_failed() {
let sample = include_bytes!("samples/modern_login_failed.bin");
let encryption_protocol =
std::sync::Arc::new(std::sync::Mutex::new(EncryptionProtocol::BCEncrypt));
let mut context = BcContext::new(encryption_protocol);
let (buf, header) = bc_header(&sample[..]).unwrap();
let (_, body) = bc_body(&mut context, &header, buf).unwrap();
assert_eq!(header.msg_id, 1);
assert_eq!(header.body_len, 0);
assert_eq!(header.channel_id, 0);
assert_eq!(header.stream_type, 0);
assert_eq!(header.payload_offset, Some(0x0));
assert_eq!(header.response_code, 0x190); // 400
assert_eq!(header.class, 0x0000);
match body {
BcBody::ModernMsg(ModernMsg {
extension: None,
payload: None,
}) => {}
_ => panic!(),
}
_ => panic!(),
}
#[test]
fn test_bc_modern_login_success() {
let sample = include_bytes!("samples/modern_login_success.bin");
let encryption_protocol =
std::sync::Arc::new(std::sync::Mutex::new(EncryptionProtocol::BCEncrypt));
let mut context = BcContext::new(encryption_protocol);
let (buf, header) = bc_header(&sample[..]).unwrap();
let (_, body) = bc_body(&mut context, &header, buf).unwrap();
assert_eq!(header.msg_id, 1);
assert_eq!(header.body_len, 2949);
assert_eq!(header.channel_id, 0);
assert_eq!(header.stream_type, 0);
assert_eq!(header.payload_offset, Some(0x0));
assert_eq!(header.response_code, 0xc8); // 200
assert_eq!(header.class, 0x0000);
// Previously, we were not handling payload_offset == 0 (no bin offset) correctly.
// Test that we decoded XML and no binary.
match body {
BcBody::ModernMsg(ModernMsg {
extension: None,
payload: Some(_),
}) => {}
_ => panic!(),
}
}
#[test]
fn test_bc_binary_mode() {
let sample1 = include_bytes!("samples/modern_video_start1.bin");
let sample2 = include_bytes!("samples/modern_video_start2.bin");
let encryption_protocol =
std::sync::Arc::new(std::sync::Mutex::new(EncryptionProtocol::BCEncrypt));
let mut context = BcContext::new(encryption_protocol);
let msg1 = Bc::deserialize(&mut context, &sample1[..]).unwrap();
match msg1.body {
BcBody::ModernMsg(ModernMsg {
extension:
Some(Extension {
binary_data: Some(1),
..
}),
payload: Some(BcPayloads::Binary(bin)),
}) => {
assert_eq!(bin.len(), 32);
}
_ => panic!(),
}
context.in_bin_mode.insert(msg1.meta.msg_num);
let msg2 = Bc::deserialize(&mut context, &sample2[..]).unwrap();
match msg2.body {
BcBody::ModernMsg(ModernMsg {
extension: None,
payload: Some(BcPayloads::Binary(bin)),
}) => {
assert_eq!(bin.len(), 30344);
}
_ => panic!(),
}
}
#[test]
// B800 seems to have a different header to the E1 and swann cameras
// the stream_type and message_num do not seem to set in the offical clients
//
// They also have extra streams
fn test_bc_b800_externstream() {
let sample = include_bytes!("samples/xml_externstream_b800.bin");
let encryption_protocol =
std::sync::Arc::new(std::sync::Mutex::new(EncryptionProtocol::BCEncrypt));
let mut context = BcContext::new(encryption_protocol);
let e = Bc::deserialize(&mut context, &sample[..]);
assert_matches!(
e,
Ok(Bc {
meta:
BcMeta {
msg_id: 3,
channel_id: 0x8c,
stream_type: 0,
response_code: 0,
msg_num: 0,
class: 0x6414,
},
body:
BcBody::ModernMsg(ModernMsg {
extension: None,
payload:
Some(BcPayloads::BcXml(BcXml {
preview:
Some(Preview {
version,
channel_id: 0,
handle: 1024,
stream_type,
}),
..
})),
}),
}) if version == "1.1" && stream_type == "externStream"
);
}
#[test]
// B800 seems to have a different header to the E1 and swann cameras
// the stream_type and message_num do not seem to set in the offical clients
//
// They also have extra streams
fn test_bc_b800_substream() {
let sample = include_bytes!("samples/xml_substream_b800.bin");
let encryption_protocol =
std::sync::Arc::new(std::sync::Mutex::new(EncryptionProtocol::BCEncrypt));
let mut context = BcContext::new(encryption_protocol);
let e = Bc::deserialize(&mut context, &sample[..]);
assert_matches!(
e,
Ok(Bc {
meta:
BcMeta {
msg_id: 3,
channel_id: 143,
stream_type: 0,
response_code: 0,
msg_num: 0,
class: 0x6414,
},
body:
BcBody::ModernMsg(ModernMsg {
extension: None,
payload:
Some(BcPayloads::BcXml(BcXml {
preview:
Some(Preview {
version,
channel_id: 0,
handle: 256,
stream_type,
}),
..
})),
}),
}) if version == "1.1" && stream_type == "subStream"
);
}
#[test]
// B800 seems to have a different header to the E1 and swann cameras
// the stream_type and message_num do not seem to set in the offical clients
//
// They also have extra streams
fn test_bc_b800_mainstream() {
let sample = include_bytes!("samples/xml_mainstream_b800.bin");
let encryption_protocol =
std::sync::Arc::new(std::sync::Mutex::new(EncryptionProtocol::BCEncrypt));
let mut context = BcContext::new(encryption_protocol);
let e = Bc::deserialize(&mut context, &sample[..]);
assert_matches!(
e,
Ok(Bc {
meta:
BcMeta {
msg_id: 3,
channel_id: 138,
stream_type: 0,
response_code: 0,
msg_num: 0,
class: 0x6414,
},
body:
BcBody::ModernMsg(ModernMsg {
extension: None,
payload:
Some(BcPayloads::BcXml(BcXml {
preview:
Some(Preview {
version,
channel_id: 0,
handle: 0,
stream_type,
}),
..
})),
}),
}) if version == "1.1" && stream_type == "mainStream"
);
}
}
+6 -4
View File
@@ -36,6 +36,8 @@ pub const MSG_ID_TALK: u32 = 202;
pub const MSG_ID_GET_LED_STATUS: u32 = 208;
/// Setting the LED status is done with this ID
pub const MSG_ID_SET_LED_STATUS: u32 = 209;
/// UDP Keep alive
pub const MSG_ID_UDP_KEEP_ALIVE: u32 = 234;
/// An empty password in legacy format
pub const EMPTY_LEGACY_PASSWORD: &str =
@@ -57,7 +59,7 @@ pub struct Bc {
#[allow(clippy::large_enum_variant)]
pub enum BcBody {
/// Legacy is unsupported except for login where it is used
/// to negociate the initial login and upgrade to modern
/// to negotiate the initial login and upgrade to modern
LegacyMsg(LegacyMsg),
/// Modern is the current reolink protocol it is mostly
/// xml based
@@ -68,7 +70,7 @@ pub enum BcBody {
///
/// The first payload is extension which describes the second payload. If the
/// `payload_offset` is `0` then their is no `extension` (usually because it has
/// already been negociated in a previous message) and it is `None`
/// already been negotiated in a previous message) and it is `None`
///
/// The second payload contains the actual data of interest and is all bytes after
/// the `payload_offset` up to the `body_len`. If `payload_offset`
@@ -157,7 +159,7 @@ pub(super) struct BcSendInfo {
/// These are the encyption modes supported by the camera
///
/// The mode is negociated during login
/// The mode is negotiated during login
#[derive(Debug, Clone)]
pub enum EncryptionProtocol {
/// Older camera use no encryption
@@ -165,7 +167,7 @@ pub enum EncryptionProtocol {
/// Camera/Firmwares before 2021 use BCEncrypt which is a simple XOr
BCEncrypt,
/// Latest cameras/firmwares use Aes with the key derived from
/// the camera's password and the negociated NONCE
/// the camera's password and the negotiated NONCE
Aes(Option<[u8; 16]>),
}
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
+1 -1
View File
@@ -98,7 +98,7 @@ pub struct Encryption {
#[yaserde(rename = "type")]
/// The hashing algorithm used. Only observed the value of "md5"
pub type_: String,
/// The nonce used to negociate the login and to generate the AES key
/// The nonce used to negotiate the login and to generate the AES key
pub nonce: String,
}
+125 -38
View File
@@ -1,38 +1,36 @@
use self::connection::BcConnection;
use crate::{bc, bcmedia};
use log::*;
use std::convert::TryInto;
use std::net::ToSocketAddrs;
use std::sync::atomic::{AtomicU16, Ordering};
use std::time::Duration;
use Md5Trunc::*;
mod binarysub;
mod connection;
mod errors;
pub(crate) mod filesub;
mod ledstate;
mod login;
mod logout;
mod motion;
mod ping;
mod reboot;
mod resolution;
mod stream;
mod talk;
mod time;
mod version;
pub use binarysub::BinarySubscriber;
use super::RX_TIMEOUT;
use bc::model::*;
pub(crate) use connection::*;
pub use errors::Error;
pub use ledstate::LightState;
pub use motion::{MotionOutput, MotionOutputError, MotionStatus};
pub use stream::{StreamOutput, StreamOutputError};
pub use resolution::*;
pub use stream::{Stream, StreamOutput, StreamOutputError};
type Result<T> = std::result::Result<T, Error>;
const RX_TIMEOUT: Duration = Duration::from_secs(5);
impl<'a> From<std::sync::mpsc::RecvTimeoutError> for Error {
fn from(k: std::sync::mpsc::RecvTimeoutError) -> Self {
match k {
@@ -69,6 +67,7 @@ impl Credentials {
impl Drop for BcCamera {
fn drop(&mut self) {
debug!("Dropping camera");
self.disconnect();
}
}
@@ -79,8 +78,7 @@ impl BcCamera {
///
/// # Parameters
///
/// * `host` - The address of the camera either ip address or hostname string is ok but
/// [`std::net::SocketAddr`] is fine too
/// * `host` - The address of the camera either ip address or hostname string
///
/// * `channel_id` - The channel ID this is usually zero unless using a NVR
///
@@ -93,33 +91,124 @@ impl BcCamera {
Ok(iter) => iter,
Err(_) => return Err(Error::AddrResolutionError),
};
for addr in addr_iter {
debug!("Trying {}", addr);
let conn = match BcConnection::new(addr, RX_TIMEOUT) {
Ok(conn) => conn,
Err(err) => match err {
connection::Error::Communication(ref err) => {
debug!("Assuming timeout from {}", err);
continue;
}
err => return Err(err.into()),
},
};
debug!("Success: {}", addr);
return Ok(Self {
connection: Some(conn),
message_num: AtomicU16::new(0),
channel_id,
logged_in: false,
credentials: None,
});
if let Ok(cam) = Self::new(SocketAddrOrUid::SocketAddr(addr), channel_id) {
return Ok(cam);
}
}
Err(Error::Timeout)
}
///
/// Create a new camera interface with this uid and channel ID
///
/// # Parameters
///
/// * `uid` - The uid of the camera
///
/// * `channel_id` - The channel ID this is usually zero unless using a NVR
///
/// # Returns
///
/// returns either an error or the camera
///
pub fn new_with_uid(uid: &str, channel_id: u8) -> Result<Self> {
Self::new(SocketAddrOrUid::Uid(uid.to_string()), channel_id)
}
///
/// Create a new camera interface with this address/uid and channel ID
///
/// This method will first perform hostname resolution on the address
/// then fallback to uid if that resolution fails.
///
/// Be aware that it is possible (although unlikely) that there is
/// a dns entry with the same address as the uid. If uncertain use
/// one of the other methods.
///
/// # Parameters
///
/// * `host` - The address of the camera either ip address, hostname string, or uid
///
/// * `channel_id` - The channel ID this is usually zero unless using a NVR
///
/// # Returns
///
/// returns either an error or the camera
///
pub fn new_with_addr_or_uid<T: ToSocketAddrsOrUid>(host: T, channel_id: u8) -> Result<Self> {
let addr_iter = match host.to_socket_addrs_or_uid() {
Ok(iter) => iter,
Err(_) => return Err(Error::AddrResolutionError),
};
for addr_or_uid in addr_iter {
if let Ok(cam) = Self::new(addr_or_uid, channel_id) {
return Ok(cam);
}
}
Err(Error::Timeout)
}
///
/// Create a new camera interface with this address/uid and channel ID
///
/// # Parameters
///
/// * `addr` - An enum of [`SocketAddrOrUid`] that contains the address
///
/// * `channel_id` - The channel ID this is usually zero unless using a NVR
///
/// # Returns
///
/// returns either an error or the camera
///
pub fn new(addr: SocketAddrOrUid, channel_id: u8) -> Result<Self> {
let source = match addr {
SocketAddrOrUid::SocketAddr(addr) => {
debug!("Trying address {}", addr);
BcSource::new_tcp(addr, RX_TIMEOUT)?
}
SocketAddrOrUid::Uid(uid) => {
debug!("Trying uid {}", uid);
BcSource::new_udp(&uid, RX_TIMEOUT)?
}
};
let conn = BcConnection::new(source)?;
debug!("Success");
let me = Self {
connection: Some(conn),
message_num: AtomicU16::new(0),
channel_id,
logged_in: false,
credentials: None,
};
if let Some(conn) = &me.connection {
if conn.is_udp() {
let keep_alive_msg = Bc {
meta: BcMeta {
msg_id: MSG_ID_UDP_KEEP_ALIVE,
channel_id: me.channel_id,
msg_num: me.new_message_num(),
stream_type: 0,
response_code: 0,
class: 0x6414,
},
body: BcBody::ModernMsg(ModernMsg {
..Default::default()
}),
};
conn.set_keep_alive_msg(keep_alive_msg);
}
}
Ok(me)
}
/// This method will get a new message number and increment the message count atomically
pub fn new_message_num(&self) -> u16 {
self.message_num.fetch_add(1, Ordering::Relaxed)
@@ -128,13 +217,11 @@ impl BcCamera {
/// This will drop the connection. It will try to send the logout request to the camera
/// first
pub fn disconnect(&mut self) {
// Stop polling now. We don't need it for a disconnect
// and if we don't then another we might get a deserialise
// error from another thread that polls and needs the login.
//
// It will also ensure that when we drop the connection we don't
// get an error for read retrun zero bytes.
if let Some(connection) = &self.connection {
// Stop polling now. We don't need it for a disconnect
//
// It will also ensure that when we drop the connection we don't
// get an error for read return zero bytes from the polling thread;
connection.stop_polling();
if let Err(err) = self.logout() {
warn!("Could not log out, ignoring: {}", err);
@@ -180,7 +267,7 @@ fn md5_string(input: &str, trunc: Md5Trunc) -> String {
}
/// This is a convience function to make an AES key from the login password and the NONCE
/// negociated during login
/// negotiated during login
pub fn make_aes_key(nonce: &str, passwd: &str) -> [u8; 16] {
let key_phrase = format!("{}-{}", nonce, passwd);
let key_phrase_hash = format!("{:X}\0", md5::compute(&key_phrase))
@@ -1,16 +1,17 @@
use super::{BcSource, BcSubscription, Error, Result, TcpSource};
use crate::bc;
use crate::bc::model::*;
use err_derive::Error;
use log::*;
use socket2::{Domain, Socket, Type};
use std::collections::btree_map::Entry;
use std::collections::BTreeMap;
use std::error::Error as StdErr; // Just need the traits
use std::net::{Shutdown, SocketAddr, TcpStream};
use std::io::{Error as IoError, Read, Write};
use std::net::{SocketAddr, TcpStream};
use std::sync::mpsc::{channel, Receiver, Sender};
use std::sync::{atomic::AtomicBool, atomic::Ordering, Arc, Mutex};
use std::thread::JoinHandle;
use std::time::Duration;
use std::time::{Duration, Instant};
/// A shareable connection to a camera. Handles serialization of messages. To send/receive, call
/// .[subscribe()] with a message ID. You can use the BcSubscription to send or receive only
@@ -18,55 +19,37 @@ use std::time::Duration;
///
/// There can be only one subscriber per kind of message at a time.
pub struct BcConnection {
connection: Arc<Mutex<TcpStream>>,
sink: Arc<Mutex<BcSource>>,
subscribers: Arc<Mutex<BTreeMap<u32, Sender<Bc>>>>,
rx_thread: Option<JoinHandle<()>>,
// Arc<Mutex<EncryptionProtocol>> because it is shared between context
// and connection for deserialisation and serialistion respectivly
encryption_protocol: Arc<Mutex<EncryptionProtocol>>,
poll_abort: Arc<AtomicBool>,
}
pub struct BcSubscription<'a> {
pub rx: Receiver<Bc>,
msg_id: u32,
conn: &'a BcConnection,
}
type Result<T> = std::result::Result<T, Error>;
#[derive(Debug, Error)]
pub enum Error {
#[error(display = "Communication error")]
Communication(#[error(source)] std::io::Error),
#[error(display = "Deserialization error")]
Deserialization(#[error(source)] bc::de::Error),
#[error(display = "Serialization error")]
Serialization(#[error(source)] bc::ser::Error),
#[error(display = "Simultaneous subscription")]
SimultaneousSubscription { msg_id: u32 },
keep_alive_msg: Arc<Mutex<Option<Bc>>>,
}
impl BcConnection {
pub fn new(addr: SocketAddr, timeout: Duration) -> Result<BcConnection> {
let tcp_conn = connect_to(addr, timeout)?;
pub fn new(source: BcSource) -> Result<Self> {
let subscribers: Arc<Mutex<BTreeMap<u32, Sender<Bc>>>> = Default::default();
let mut subs = subscribers.clone();
let conn = tcp_conn.try_clone()?;
let encryption_protocol = Arc::new(Mutex::new(EncryptionProtocol::Unencrypted));
let connections_encryption_protocol = encryption_protocol.clone();
let poll_abort = Arc::new(AtomicBool::new(false));
let poll_abort_rx = poll_abort.clone();
let mut conn = source.try_clone()?;
let keep_alive_msg: Arc<Mutex<Option<Bc>>> = Arc::new(Mutex::new(None));
let connections_keep_alive_msg = keep_alive_msg.clone();
let rx_thread = std::thread::spawn(move || {
let keep_alive_encryption_protocol = connections_encryption_protocol.clone();
let mut context = BcContext::new(connections_encryption_protocol);
let mut result;
let mut last_keep_alive = Instant::now();
let keep_alive_time = Duration::from_millis(500);
loop {
result = BcConnection::poll(&mut context, &conn, &mut subs);
result = Self::poll(&mut context, &conn, &mut subs, &connections_keep_alive_msg);
if poll_abort_rx.load(Ordering::Relaxed) {
break; // Poll has been aborted by request usally during disconnect
}
@@ -79,39 +62,78 @@ impl BcConnection {
}
break;
}
// Send a udp keep alive if set
if last_keep_alive.elapsed() > keep_alive_time {
last_keep_alive = Instant::now();
if let Ok(lock) = connections_keep_alive_msg.try_lock() {
if let Some(keep_alive_msg) = lock.as_ref() {
let _ = keep_alive_msg
.serialize(&conn, &keep_alive_encryption_protocol.lock().unwrap());
let _ = conn.flush();
}
}
}
}
});
Ok(BcConnection {
connection: Arc::new(Mutex::new(tcp_conn)),
sink: Arc::new(Mutex::new(source)),
subscribers,
rx_thread: Some(rx_thread),
encryption_protocol,
poll_abort,
keep_alive_msg,
})
}
pub fn stop_polling(&self) {
self.poll_abort.store(true, Ordering::Relaxed);
}
pub(super) fn send(&self, bc: Bc) -> Result<()> {
bc.serialize(&*self.sink.lock().unwrap(), &self.get_encrypted())?;
let _ = self.sink.lock().unwrap().flush();
Ok(())
}
pub fn subscribe(&self, msg_id: u32) -> Result<BcSubscription> {
let (tx, rx) = channel();
match self.subscribers.lock().unwrap().entry(msg_id) {
Entry::Vacant(vac_entry) => vac_entry.insert(tx),
Entry::Occupied(_) => return Err(Error::SimultaneousSubscription { msg_id }),
};
Ok(BcSubscription {
rx,
conn: self,
msg_id,
})
Ok(BcSubscription::new(rx, msg_id, self))
}
pub fn unsubscribe(&self, msg_id: u32) -> Result<()> {
self.subscribers.lock().unwrap().remove(&msg_id);
Ok(())
}
pub fn set_keep_alive_msg(&self, msg: Bc) {
*self.keep_alive_msg.lock().unwrap() = Some(msg);
}
pub fn set_encrypted(&self, value: EncryptionProtocol) {
*(self.encryption_protocol.lock().unwrap()) = value;
}
pub fn get_encrypted(&self) -> EncryptionProtocol {
(*self.encryption_protocol.lock().unwrap()).clone()
}
pub fn is_udp(&self) -> bool {
self.sink.lock().unwrap().is_udp()
}
fn poll(
context: &mut BcContext,
connection: &TcpStream,
connection: &BcSource,
subscribers: &mut Arc<Mutex<BTreeMap<u32, Sender<Bc>>>>,
connections_keep_alive_msg: &Arc<Mutex<Option<Bc>>>,
) -> Result<()> {
// Don't hold the lock during deserialization so we don't poison the subscribers mutex if
// something goes wrong
let response = Bc::deserialize(context, connection).map_err(|err| {
// If the connection hangs up, hang up on all subscribers
subscribers.lock().unwrap().clear();
@@ -129,31 +151,28 @@ impl BcConnection {
}
}
Entry::Vacant(_) => {
debug!("Ignoring uninteresting message ID {}", msg_id);
trace!("Contents: {:?}", response);
if msg_id != MSG_ID_UDP_KEEP_ALIVE {
debug!("Ignoring uninteresting message ID {}", msg_id);
trace!("Contents: {:?}", response);
} else {
// This is a keep alive message let see what the camera says about it
if response.meta.response_code != 200 {
// Camera dosen't support the current keep alive message stop sending them
if let Ok(mut lock) = connections_keep_alive_msg.try_lock() {
*lock = None;
}
}
}
}
}
Ok(())
}
pub fn stop_polling(&self) {
self.poll_abort.store(true, Ordering::Relaxed);
}
pub fn set_encrypted(&self, value: EncryptionProtocol) {
*(self.encryption_protocol.lock().unwrap()) = value;
}
pub fn get_encrypted(&self) -> EncryptionProtocol {
(*self.encryption_protocol.lock().unwrap()).clone()
}
}
impl Drop for BcConnection {
fn drop(&mut self) {
debug!("Shutting down BcConnection...");
let _ = self.connection.lock().unwrap().shutdown(Shutdown::Both);
match self
.rx_thread
.take()
@@ -169,41 +188,3 @@ impl Drop for BcConnection {
}
}
}
impl<'a> BcSubscription<'a> {
pub fn send(&self, bc: Bc) -> Result<()> {
assert!(bc.meta.msg_id == self.msg_id);
bc.serialize(
&*self.conn.connection.lock().unwrap(),
&self.conn.get_encrypted(),
)?;
Ok(())
}
}
/// Makes it difficult to avoid unsubscribing when you're finished
impl<'a> Drop for BcSubscription<'a> {
fn drop(&mut self) {
self.conn.subscribers.lock().unwrap().remove(&self.msg_id);
}
}
/// Helper to create a TcpStream with a connect timeout
fn connect_to(addr: SocketAddr, timeout: Duration) -> Result<TcpStream> {
let socket = match addr {
SocketAddr::V4(_) => Socket::new(Domain::ipv4(), Type::stream(), None)?,
SocketAddr::V6(_) => {
let s = Socket::new(Domain::ipv6(), Type::stream(), None)?;
s.set_only_v6(false)?;
s
}
};
socket.set_keepalive(Some(timeout))?;
socket.set_read_timeout(Some(timeout))?;
socket.set_write_timeout(Some(timeout))?;
socket.connect_timeout(&addr.into(), timeout)?;
Ok(socket.into_tcp_stream())
}
@@ -0,0 +1,176 @@
use super::{Result, TcpSource, UdpSource};
use std::io::{Error as IoError, ErrorKind, Read, Write};
use std::net::SocketAddr;
use std::sync::{Arc, Mutex};
use std::time::Duration;
type IoResult<T> = std::result::Result<T, IoError>;
pub enum BcSource {
Tcp(Mutex<TcpSource>),
Udp(Mutex<UdpSource>),
}
impl BcSource {
pub fn is_udp(&self) -> bool {
matches!(self, BcSource::Udp(_))
}
pub fn new_tcp(addr: SocketAddr, timeout: Duration) -> Result<Self> {
let source = TcpSource::new(addr, timeout)?;
Ok(BcSource::Tcp(Mutex::new(source)))
}
pub fn new_udp(uid: &str, timeout: Duration) -> Result<Self> {
let source = UdpSource::new(uid, timeout)?;
Ok(BcSource::Udp(Mutex::new(source)))
}
pub fn try_clone(&self) -> IoResult<Self> {
match self {
BcSource::Tcp(source) => match &mut source.try_lock() {
Ok(locked) => Ok(BcSource::Tcp(Mutex::new(locked.try_clone()?))),
Err(_) => Err(IoError::new(
ErrorKind::WouldBlock,
"Unable to lock tcp for clone",
)),
},
BcSource::Udp(source) => match &mut source.try_lock() {
Ok(locked) => Ok(BcSource::Udp(Mutex::new(locked.try_clone()?))),
Err(_) => Err(IoError::new(
ErrorKind::WouldBlock,
"Unable to lock udp for clone",
)),
},
}
}
}
impl Read for BcSource {
fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> {
match self {
BcSource::Tcp(source) => match &mut source.get_mut() {
Ok(locked) => Ok(locked.read(buf)?),
Err(_) => Err(IoError::new(
ErrorKind::WouldBlock,
"Unable to lock tcp for read",
)),
},
BcSource::Udp(source) => match &mut source.get_mut() {
Ok(locked) => Ok(locked.read(buf)?),
Err(_) => Err(IoError::new(
ErrorKind::WouldBlock,
"Unable to lock udp for read",
)),
},
}
}
}
impl Read for &BcSource {
fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> {
match self {
BcSource::Tcp(source) => match &mut source.try_lock() {
Ok(locked) => Ok(locked.read(buf)?),
Err(_) => Err(IoError::new(
ErrorKind::WouldBlock,
"Unable to lock tcp for &read",
)),
},
BcSource::Udp(source) => match &mut source.try_lock() {
Ok(locked) => Ok(locked.read(buf)?),
Err(_) => Err(IoError::new(
ErrorKind::WouldBlock,
"Unable to lock udp for &read",
)),
},
}
}
}
impl Write for BcSource {
fn write(&mut self, buf: &[u8]) -> IoResult<usize> {
match self {
BcSource::Tcp(source) => match &mut source.get_mut() {
Ok(locked) => Ok(locked.write(buf)?),
Err(_) => Err(IoError::new(
ErrorKind::WouldBlock,
"Unable to lock tcp for write",
)),
},
BcSource::Udp(source) => match &mut source.get_mut() {
Ok(locked) => Ok(locked.write(buf)?),
Err(_) => Err(IoError::new(
ErrorKind::WouldBlock,
"Unable to lock udp for write",
)),
},
}
}
fn flush(&mut self) -> IoResult<()> {
match self {
BcSource::Tcp(source) => match &mut source.get_mut() {
Ok(locked) => Ok(locked.flush()?),
Err(_) => Err(IoError::new(
ErrorKind::WouldBlock,
"Unable to lock tcp for flush",
)),
},
BcSource::Udp(source) => match &mut source.get_mut() {
Ok(locked) => Ok(locked.flush()?),
Err(_) => Err(IoError::new(
ErrorKind::WouldBlock,
"Unable to lock tcp udp for flush",
)),
},
}
}
}
impl Write for &BcSource {
fn write(&mut self, buf: &[u8]) -> IoResult<usize> {
match self {
BcSource::Tcp(source) => match &mut source.try_lock() {
Ok(locked) => Ok(locked.write(buf)?),
Err(_) => Err(IoError::new(
ErrorKind::WouldBlock,
"Unable to lock tcp for write",
)),
},
BcSource::Udp(source) => match &mut source.try_lock() {
Ok(locked) => Ok(locked.write(buf)?),
Err(_) => Err(IoError::new(
ErrorKind::WouldBlock,
"Unable to lock udp for write",
)),
},
}
}
fn flush(&mut self) -> IoResult<()> {
match self {
BcSource::Tcp(source) => match &mut source.try_lock() {
Ok(locked) => Ok(locked.flush()?),
Err(_) => Err(IoError::new(
ErrorKind::WouldBlock,
"Unable to lock tcp for &flush",
)),
},
BcSource::Udp(source) => match &mut source.try_lock() {
Ok(locked) => Ok(locked.flush()?),
Err(_) => Err(IoError::new(
ErrorKind::WouldBlock,
"Unable to lock udp for &flush",
)),
},
}
}
}
@@ -0,0 +1,29 @@
use super::{BcConnection, Result};
use crate::bc::model::*;
use std::sync::mpsc::Receiver;
pub struct BcSubscription<'a> {
pub rx: Receiver<Bc>,
msg_id: u32,
conn: &'a BcConnection,
}
impl<'a> BcSubscription<'a> {
pub fn new(rx: Receiver<Bc>, msg_id: u32, conn: &'a BcConnection) -> BcSubscription<'a> {
BcSubscription { rx, msg_id, conn }
}
pub fn send(&self, bc: Bc) -> Result<()> {
assert!(bc.meta.msg_id == self.msg_id);
self.conn.send(bc)?;
Ok(())
}
}
/// Makes it difficult to avoid unsubscribing when you're finished
impl<'a> Drop for BcSubscription<'a> {
fn drop(&mut self) {
// It's fine if we can't unsubscribe as that means we already have
let _ = self.conn.unsubscribe(self.msg_id);
}
}
@@ -1,4 +1,7 @@
use super::{connection::BcSubscription, RX_TIMEOUT};
use super::{
super::{connection::BcSubscription, RX_TIMEOUT},
BcConnection,
};
use crate::bc::model::*;
use std::{
io::{BufRead, Error, ErrorKind, Read},
@@ -0,0 +1,70 @@
#![allow(unused_imports)]
//! This module handles connections and subscribers
//!
//! This includes a tcp and udp connections. As well
//! as subscribers to binary streams that are encoded
//! in the bc packets.
//!
use crate::bc;
use crate::bc::model::*;
use crate::bcudp;
use err_derive::Error;
use log::*;
use socket2::{Domain, Socket, Type};
use std::collections::btree_map::Entry;
use std::collections::BTreeMap;
use std::error::Error as StdErr; // Just need the traits
use std::net::{SocketAddr, TcpStream};
use std::sync::mpsc::{channel, Receiver, RecvError, Sender};
use std::sync::{atomic::AtomicBool, atomic::Ordering, Arc, Mutex};
use std::thread::JoinHandle;
use std::time::Duration;
mod bcconn;
mod bcsource;
mod bcsub;
mod binarysub;
mod filesub;
mod tcpconn;
mod udpconn;
pub(crate) use self::{
bcconn::BcConnection, bcsource::BcSource, bcsub::BcSubscription, binarysub::BinarySubscriber,
filesub::FileSubscriber, tcpconn::TcpSource, udpconn::UdpSource,
};
#[derive(Debug, Error)]
pub enum Error {
#[error(display = "Communication error")]
Communication(#[error(source)] std::io::Error),
#[error(display = "Communication Reciever error")]
RecvCommunication(#[error(source)] RecvError),
#[error(display = "Deserialization error")]
Deserialization(#[error(source)] bc::de::Error),
#[error(display = "Serialization error")]
Serialization(#[error(source)] bc::ser::Error),
#[error(display = "UDP Deserialization error")]
UdpDeserialization(#[error(source)] bcudp::de::Error),
#[error(display = "UDP Serialization error")]
UdpSerialization(#[error(source)] bcudp::ser::Error),
#[error(display = "Simultaneous subscription")]
SimultaneousSubscription { msg_id: u32 },
#[error(display = "Timeout")]
Timeout,
#[error(display = "This connection type in unsupported")]
UnsupportedConnection,
#[error(display = "Camera Not Findable")]
ConnectionUnavaliable,
}
type Result<T> = std::result::Result<T, Error>;
@@ -0,0 +1,69 @@
use super::{BcSubscription, Error, Result};
use crate::bc;
use crate::bc::model::*;
use log::*;
use socket2::{Domain, Socket, Type};
use std::collections::btree_map::Entry;
use std::collections::BTreeMap;
use std::error::Error as StdErr; // Just need the traits
use std::io::{Error as IoError, Read, Write};
use std::net::{SocketAddr, TcpStream};
use std::sync::mpsc::{channel, Receiver, Sender};
use std::sync::{atomic::AtomicBool, atomic::Ordering, Arc, Mutex};
use std::thread::JoinHandle;
use std::time::Duration;
type IoResult<T> = std::result::Result<T, IoError>;
pub struct TcpSource {
stream: TcpStream,
}
impl TcpSource {
pub fn new(addr: SocketAddr, timeout: Duration) -> Result<TcpSource> {
let tcp_conn = connect_to(addr, timeout)?;
Ok(Self { stream: tcp_conn })
}
pub fn try_clone(&self) -> IoResult<Self> {
Ok(Self {
stream: self.stream.try_clone()?,
})
}
}
impl Read for TcpSource {
fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> {
self.stream.read(buf)
}
}
impl Write for TcpSource {
fn write(&mut self, buf: &[u8]) -> IoResult<usize> {
self.stream.write(buf)
}
fn flush(&mut self) -> IoResult<()> {
self.stream.flush()
}
}
/// Helper to create a TcpStream with a connect timeout
fn connect_to(addr: SocketAddr, timeout: Duration) -> Result<TcpStream> {
let socket = match addr {
SocketAddr::V4(_) => Socket::new(Domain::ipv4(), Type::stream(), None)?,
SocketAddr::V6(_) => {
let s = Socket::new(Domain::ipv6(), Type::stream(), None)?;
s.set_only_v6(false)?;
s
}
};
socket.set_keepalive(Some(timeout))?;
socket.set_read_timeout(Some(timeout))?;
socket.set_write_timeout(Some(timeout))?;
socket.connect_timeout(&addr.into(), timeout)?;
Ok(socket.into_tcp_stream())
}
@@ -0,0 +1,25 @@
use std::sync::{
atomic::{AtomicBool, Ordering},
Arc,
};
#[derive(Clone)]
pub struct AbortHandle {
aborted: Arc<AtomicBool>,
}
impl AbortHandle {
pub fn new() -> Self {
Self {
aborted: Arc::new(AtomicBool::new(false)),
}
}
pub fn abort(&self) {
self.aborted.store(true, Ordering::Relaxed);
}
pub fn is_aborted(&self) -> bool {
self.aborted.load(Ordering::Relaxed)
}
}
@@ -0,0 +1,572 @@
use super::{aborthandle::AbortHandle, Error, Result, MTU, P2P_RELAY_HOSTNAMES, WAIT_TIME};
use crate::bcudp::{model::*, xml::*};
use local_ip_address::local_ip;
use log::*;
use rand::{seq::SliceRandom, thread_rng, Rng};
use std::io::{Error as IoError, ErrorKind, Result as IoResult};
use std::net::{Ipv4Addr, SocketAddr, ToSocketAddrs, UdpSocket};
use std::time::Duration;
use time::OffsetDateTime;
pub struct UdpDiscover {
pub client_id: i32,
pub camera_id: i32,
pub mtu: u32,
pub address: SocketAddr,
}
impl UdpDiscover {
// Sends data on a UDP socket until aborted or max retries reached
fn retrying_send_to<T: ToSocketAddrs>(
socket: &UdpSocket,
buf: &[u8],
addr: T,
) -> IoResult<(usize, AbortHandle)> {
let addr = addr
.to_socket_addrs()?
.next()
.ok_or_else(|| IoError::new(ErrorKind::NotFound, Error::ConnectionUnavaliable))?;
Self::retrying_send_to_multi(socket, buf, &[addr])
}
// Sends data to multiple destinations using a UDP socket
// until aborted or max retries reached
fn retrying_send_to_multi<T: ToSocketAddrs>(
socket: &UdpSocket,
buf: &[u8],
addrs: &[T],
) -> IoResult<(usize, AbortHandle)> {
let handle = AbortHandle::new();
let addrs: Vec<SocketAddr> = addrs
.iter()
.map(|a| {
a.to_socket_addrs()
.ok()
.and_then(|mut a_iter| a_iter.next())
})
.flatten()
.collect();
let mut bytes_send = 0;
for addr in addrs.iter() {
bytes_send = socket.send_to(buf, &addr)?;
}
let thread_buffer = buf.to_vec();
let thread_handle = handle.clone();
let thread_socket = socket.try_clone()?;
let thread_addr: Vec<SocketAddr> = addrs;
const MAX_RETRIES: usize = 10;
std::thread::spawn(move || {
std::thread::sleep(WAIT_TIME);
for _ in 0..MAX_RETRIES {
if thread_handle.is_aborted() {
break;
}
for addr in thread_addr.iter() {
let _ = thread_socket.send_to(&thread_buffer[..], &addr);
}
std::thread::sleep(WAIT_TIME);
}
});
Ok((bytes_send, handle))
}
// Performs local discovery
//
// This involves broadcasting a C2dC
// Bc Discovery packet to ports 2015 and 2018
// and awaiting a D2cCr reply
fn discover_from_uuid_local(socket: &UdpSocket, uid: &str, timeout: Duration) -> Result<Self> {
let mut rng = thread_rng();
// If tid is too large it will overflow during encrypt so we just use a random u8
let tid: u32 = (rng.gen::<u8>()) as u32;
let client_id: i32 = rng.gen();
let local_addr = socket.local_addr()?;
let port = local_addr.port();
let mtu = MTU;
let msg = BcUdp::Discovery(UdpDiscovery {
tid,
payload: UdpXml {
c2d_c: Some(C2dC {
uid: uid.to_string(),
cli: ClientList { port: port as u32 },
cid: client_id,
mtu,
debug: false,
os: "MAC".to_string(),
}),
..Default::default()
},
});
let mut buf = vec![];
msg.serialize(&mut buf)?;
let mut broadcasts = vec![Ipv4Addr::BROADCAST];
for iface in get_if_addrs::get_if_addrs()?.iter() {
if let get_if_addrs::IfAddr::V4(ifacev4) = &iface.addr {
if let Some(broadcast) = ifacev4.broadcast.as_ref() {
broadcasts.push(*broadcast);
}
}
}
let ports: [u16; 2] = [2015, 2018];
let destinations: Vec<(Ipv4Addr, u16)> = broadcasts
.iter()
.map(|&addr| {
ports
.iter()
.map(|&port| (addr, port))
.collect::<Vec<(Ipv4Addr, u16)>>()
})
.flatten()
.collect();
debug!("Broadcasting to: {:?}", destinations);
let (amount_sent, abort) = Self::retrying_send_to_multi(socket, &buf[..], &destinations)?;
assert_eq!(amount_sent, buf.len());
let start_time = OffsetDateTime::now_utc();
let camera_address;
let camera_id;
loop {
if (OffsetDateTime::now_utc() - start_time) <= timeout {
let mut buf = vec![0; mtu as usize];
if let Ok((bytes_read, socket_addr)) = socket.recv_from(&mut buf) {
match BcUdp::deserialize(&buf[0..bytes_read]) {
Ok(BcUdp::Discovery(UdpDiscovery {
tid: _,
payload:
UdpXml {
d2c_c_r: Some(D2cCr { did, cid, .. }),
..
},
})) if cid == client_id => {
abort.abort();
camera_address = socket_addr;
camera_id = did;
break;
}
Ok(smt) => debug!("Udp Discovery got this unexpected BcUdp {:?}", smt),
Err(_) => debug!(
"Udp Discovery got this unexpected binary: {:?}",
&buf[0..bytes_read]
),
}
}
} else {
abort.abort();
return Err(Error::Timeout);
}
}
// Ensure we didn't forget to abort the sending
abort.abort();
// Actual connection time!
socket.connect(camera_address)?;
Ok(UdpDiscover {
address: camera_address,
client_id,
camera_id,
mtu,
})
}
// This function will contact the p2p relay servers
//
// It will ask each of the servers for details on a specific UID
//
// On success it returns the M2cQr that the p2p relay
// server has about the UID
fn get_register(
uid: &str,
socket: &UdpSocket,
timeout: Duration,
tid: u32,
// client_id: u32,
) -> Result<M2cQr> {
// let local_addr = socket.local_addr()?;
// let local_port = local_addr.port();
let mtu = MTU;
for p2p_relay in P2P_RELAY_HOSTNAMES.iter() {
debug!("Trying register: {}", p2p_relay);
let msg = BcUdp::Discovery(UdpDiscovery {
tid,
payload: UdpXml {
c2m_q: Some(C2mQ {
uid: uid.to_string(),
os: "MAC".to_string(),
}),
..Default::default()
},
});
let mut buf = vec![];
msg.serialize(&mut buf)?;
let (amount_sent, abort) =
Self::retrying_send_to(socket, &buf[..], format!("{}:9999", p2p_relay))?;
assert_eq!(amount_sent, buf.len());
let start_time = OffsetDateTime::now_utc();
loop {
if (OffsetDateTime::now_utc() - start_time) <= timeout {
let mut buf = vec![0; mtu as usize];
if let Ok((bytes_read, _)) = socket.recv_from(&mut buf) {
match BcUdp::deserialize(&buf[0..bytes_read]) {
Ok(BcUdp::Discovery(UdpDiscovery {
tid: _,
payload:
UdpXml {
m2c_q_r: Some(m2c_q_r),
..
},
})) if m2c_q_r.reg.port == 0 || m2c_q_r.reg.ip.is_empty() => {
// This register is empty
// Sometimes a registery will return a M2cQr but it's port and addr
// will be 0
// In this case we ignore this server and contact another
abort.abort();
break;
}
Ok(BcUdp::Discovery(UdpDiscovery {
tid: _,
payload:
UdpXml {
m2c_q_r: Some(m2c_q_r),
..
},
})) => {
abort.abort();
return Ok(m2c_q_r);
}
Ok(smt) => debug!("Udp Discovery got this unexpected BcUdp {:?}", smt),
Err(_) => debug!(
"Udp Discovery got this unexpected binary: {:?}",
&buf[0..bytes_read]
),
}
}
} else {
abort.abort();
// This p2p server didn't have the data we need try another
break;
}
}
}
debug!("All registers tried");
Err(Error::ConnectionUnavaliable)
}
// This will start remote discovery against the reolink p2p servers
//
// It has the following stages
// - Contact the p2p register: This will get the register, relay and log server ip addresses
// - Register the client ip address to the register (This can probably be used for NAT holepunching if the camera
// tries to connect to us using this data)
// - The register will return the camera ip/port and SID
// - Connect to the camera using register's provided ip/port and negotiate a cid and did
// - Send a message to the reolink log server that we will connect locally
// - Send a message to the camera that we could connect remotely
fn discover_from_uuid_remote(
socket: &UdpSocket,
uid: &str,
timeout: Duration,
) -> Result<UdpDiscover> {
let local_addr = socket.local_addr()?;
let local_port = local_addr.port();
let mut rng = thread_rng();
// If tid is too large it will overflow during encrypt so we just use a random u8
let tid: u32 = (rng.gen::<u8>()) as u32;
let mtu = MTU;
let client_id: i32 = rng.gen();
let m2c_q_r = Self::get_register(uid, socket, timeout, tid)?;
debug!("Got this information from the register: {:?}", m2c_q_r);
let register_address = m2c_q_r.reg;
let relay_address = m2c_q_r.relay;
let log_address = m2c_q_r.log;
// let device_address = m2c_q_r.t;
let default_local_address = local_ip().expect("There to be a local ip");
debug!("Register address found: {:?}", register_address);
debug!("Registering this address: {:?}", default_local_address);
let local_family = if local_addr.ip().is_ipv4() { 4 } else { 6 };
let msg = BcUdp::Discovery(UdpDiscovery {
tid,
payload: UdpXml {
c2r_c: Some(C2rC {
uid: uid.to_string(),
cli: IpPort {
ip: default_local_address.to_string(),
port: local_port,
},
relay: relay_address,
cid: client_id,
family: local_family,
debug: false,
os: "MAC".to_string(),
}),
..Default::default()
},
});
let mut buf = vec![];
msg.serialize(&mut buf)?;
let (amount_sent, abort) = Self::retrying_send_to(
socket,
&buf[..],
format!("{}:{}", register_address.ip, register_address.port),
)?;
assert_eq!(amount_sent, buf.len());
let device_sid;
let dev_loc;
let start_time = OffsetDateTime::now_utc();
loop {
if (OffsetDateTime::now_utc() - start_time) <= timeout {
let mut buf = vec![0; mtu as usize];
if let Ok((bytes_read, _)) = socket.recv_from(&mut buf) {
match BcUdp::deserialize(&buf[0..bytes_read]) {
// Got camera data from register
Ok(BcUdp::Discovery(UdpDiscovery {
tid: _,
payload:
UdpXml {
r2c_t: Some(R2cT { dev, cid, sid, .. }),
..
},
})) if cid == client_id && !dev.ip.is_empty() && dev.port > 0 => {
abort.abort();
// Make a local request to the camera with the dev info
device_sid = sid;
dev_loc = dev;
break;
}
Ok(BcUdp::Discovery(UdpDiscovery {
tid: _,
payload:
UdpXml {
r2c_t: Some(R2cT { cid, .. }),
..
},
})) if cid == client_id => {
// Got a reply but the ip/port was empty please wait
}
Ok(smt) => debug!("Udp Discovery got this unexpected BcUdp {:?}", smt),
Err(_) => debug!(
"Udp Discovery got this unexpected binary: {:?}",
&buf[0..bytes_read]
),
}
}
} else {
abort.abort();
return Err(Error::Timeout);
}
}
debug!("Register revealed address as SID: {:?}", device_sid);
debug!("Register revealed address as IP: {:?}", dev_loc);
// ensure abort
abort.abort();
let msg = BcUdp::Discovery(UdpDiscovery {
tid,
payload: UdpXml {
c2d_t: Some(C2dT {
sid: device_sid,
cid: client_id,
mtu,
conn: "local".to_string(),
}),
..Default::default()
},
});
let mut buf = vec![];
msg.serialize(&mut buf)?;
let (amount_sent, abort) =
Self::retrying_send_to(socket, &buf[..], format!("{}:{}", dev_loc.ip, dev_loc.port))?;
assert_eq!(amount_sent, buf.len());
let device_id;
let start_time = OffsetDateTime::now_utc();
loop {
if (OffsetDateTime::now_utc() - start_time) <= timeout {
let mut buf = vec![0; mtu as usize];
if let Ok((bytes_read, _)) = socket.recv_from(&mut buf) {
match BcUdp::deserialize(&buf[0..bytes_read]) {
// Got camera data from camera
Ok(BcUdp::Discovery(UdpDiscovery {
tid: _,
payload:
UdpXml {
d2c_t: Some(D2cT { cid, did, .. }),
..
},
})) if cid == client_id => {
device_id = did;
break;
}
// Got camera data from camera CFM
Ok(BcUdp::Discovery(UdpDiscovery {
tid: _,
payload:
UdpXml {
d2c_cfm: Some(D2cCfm { cid, did, .. }),
..
},
})) if cid == client_id => {
device_id = did;
break;
}
// Got camera data from camera disc
Ok(BcUdp::Discovery(UdpDiscovery {
tid: _,
payload:
UdpXml {
d2c_disc: Some(D2cDisc { cid, did, .. }),
..
},
})) if cid == client_id => {
device_id = did;
break;
}
Ok(smt) => debug!("Udp Discovery got this unexpected BcUdp {:?}", smt),
Err(_) => debug!(
"Udp Discovery got this unexpected binary: {:?}",
&buf[0..bytes_read]
),
}
}
} else {
abort.abort();
return Err(Error::Timeout);
}
}
debug!("Got device ID as: {:?}", device_id);
// Ensure aborted
abort.abort();
// Announce to the log that we will connect locally
let msg = BcUdp::Discovery(UdpDiscovery {
tid,
payload: UdpXml {
c2r_cfm: Some(C2rCfm {
sid: device_sid,
cid: client_id,
did: device_id,
conn: "local".to_string(),
rsp: 0,
}),
..Default::default()
},
});
let mut buf = vec![];
msg.serialize(&mut buf)?;
// Just let this retry to max limit as we don't get a reply
let (amount_sent, _) = Self::retrying_send_to(
socket,
&buf[..],
format!("{}:{}", log_address.ip, log_address.port),
)?;
assert_eq!(amount_sent, buf.len());
// Announce a map type connection (I think this means we could connect remotely)
let msg = BcUdp::Discovery(UdpDiscovery {
tid,
payload: UdpXml {
c2d_t: Some(C2dT {
sid: device_sid,
cid: client_id,
mtu,
conn: "map".to_string(),
}),
..Default::default()
},
});
let mut buf = vec![];
msg.serialize(&mut buf)?;
// Just let this retry to max limit as we don't get a reply
let (amount_sent, _) =
Self::retrying_send_to(socket, &buf[..], format!("{}:{}", dev_loc.ip, dev_loc.port))?;
assert_eq!(amount_sent, buf.len());
let camera_address: SocketAddr = format!("{}:{}", dev_loc.ip, dev_loc.port)
.to_socket_addrs()?
.next()
.ok_or(Error::ConnectionUnavaliable)?;
socket.connect(camera_address)?;
Ok(UdpDiscover {
address: camera_address,
client_id,
camera_id: device_id,
mtu,
})
}
pub fn discover_from_uuid(
socket: &UdpSocket,
uid: &str,
timeout: Duration,
allow_remote: bool,
) -> Result<Self> {
match Self::discover_from_uuid_local(socket, uid, timeout) {
Err(Error::Timeout) if allow_remote => {
info!("Trying remote discovery against reolink servers");
Self::discover_from_uuid_remote(socket, uid, timeout)
}
Ok(result) => Ok(result),
Err(e) => Err(e),
}
}
pub fn send_client_disconnect(&self, socket: &UdpSocket) {
if let Ok(addr) = socket.peer_addr() {
let mut rng = thread_rng();
let tid: u32 = (rng.gen::<u8>()) as u32;
let bcudp_msg = BcUdp::Discovery(UdpDiscovery {
tid,
payload: UdpXml {
c2d_disc: Some(C2dDisc {
cid: self.client_id,
did: self.camera_id,
}),
..Default::default()
},
});
let mut buf = vec![];
let buf = bcudp_msg
.serialize(&mut buf)
.expect("Unable to serliaze udp disconnect");
let _ = Self::retrying_send_to(socket, buf, addr);
}
}
}
@@ -0,0 +1,326 @@
/// The module will handle a udp connection
///
/// Because of the complexity it is seperated into modules
///
/// discover module handles the initial handshake which discovers
/// the ip from the uid and reconnects
///
/// transmit handles the sending and recieving of data through the socket
/// this includes the BcUdp wrapping and the acknoledgements
///
use super::{Error, Result};
use crossbeam_channel::{unbounded, Receiver, RecvTimeoutError, Sender};
use lazy_static::lazy_static;
use log::*;
use rand::{seq::SliceRandom, thread_rng, Rng};
use std::{
io::{BufRead, Error as IoError, ErrorKind, Read, Result as IoResult, Write},
net::{SocketAddr, UdpSocket},
sync::Arc,
time::Duration,
};
use time::OffsetDateTime;
mod aborthandle;
mod discover;
mod transmit;
use aborthandle::*;
use discover::*;
use transmit::*;
// How long to set the socket wait
// This is kept short so as to not block the read and write parts
const SOCKET_WAIT_TIME: Duration = Duration::from_millis(50);
// How long to wait between retransmits when no reply is recieved
const WAIT_TIME: Duration = Duration::from_millis(500);
// The maximum data size including header
//
// TODO: Maybe use path mtu discovery (although reolinks seems to just use this constant)
const MTU: u32 = 1030;
lazy_static! {
static ref P2P_RELAY_HOSTNAMES: [&'static str; 10] = [
"p2p.reolink.com",
"p2p1.reolink.com",
"p2p2.reolink.com",
"p2p3.reolink.com",
"p2p6.reolink.com",
"p2p7.reolink.com",
"p2p8.reolink.com",
"p2p9.reolink.com",
"p2p14.reolink.com",
"p2p15.reolink.com",
];
}
pub struct UdpSource {
outgoing: Sender<Vec<u8>>,
incoming: Receiver<Vec<u8>>,
aborter: AbortHandle,
timeout: Duration,
mtu: u32,
read_buffer: Buffered,
write_buffer: Buffered,
}
impl UdpSource {
pub fn new(uid: &str, timeout: Duration) -> Result<Self> {
let (outgoing, from_outgoing) = unbounded();
let (to_incoming, incoming) = unbounded();
let aborter = AbortHandle::new();
Self::start_polling(uid, timeout, &aborter, to_incoming, from_outgoing)?;
Ok(Self {
outgoing,
incoming,
aborter,
timeout,
mtu: MTU,
read_buffer: Default::default(),
write_buffer: Default::default(),
})
}
fn start_polling(
uid: &str,
timeout: Duration,
aborter: &AbortHandle,
to_incoming: Sender<Vec<u8>>,
from_outgoing: Receiver<Vec<u8>>,
) -> Result<()> {
let socket = Self::get_socket(SOCKET_WAIT_TIME)?;
let allow_remote = true;
let discovery_result = Arc::new(UdpDiscover::discover_from_uuid(
&socket,
uid,
timeout,
allow_remote,
)?);
socket.connect(discovery_result.address)?;
let transmit = Arc::new(UdpTransmit::new());
let thread_aborter = aborter.clone();
let thread_transmit = transmit.clone();
let thread_socket = socket.try_clone()?;
let thread_discovery_result = discovery_result.clone();
// Poll Read
std::thread::spawn(move || {
while !thread_aborter.is_aborted() {
if let Err(err) = thread_transmit.poll_read(
&thread_socket,
&(*thread_discovery_result),
&to_incoming,
) {
if !thread_aborter.is_aborted() {
match err {
TransmitError::Disc => {
error!("Camera requested disconnect");
thread_aborter.abort();
}
e => {
error!("Error during Udp Transmit: {:?}", e);
thread_aborter.abort();
}
}
}
}
}
error!("Udp read poll aborted");
// We send client disconnect here
thread_discovery_result.send_client_disconnect(&thread_socket);
});
let thread_aborter = aborter.clone();
let thread_socket = socket.try_clone()?;
let thread_transmit = transmit;
let thread_discovery_result = discovery_result;
// Poll Write
std::thread::spawn(move || {
while !thread_aborter.is_aborted() {
if let Err(err) = thread_transmit.poll_write(
&thread_socket,
&(*thread_discovery_result),
&from_outgoing,
) {
if !thread_aborter.is_aborted() {
match err {
TransmitError::Disc => {
error!("Camera requested disconnect");
thread_aborter.abort();
}
e => {
error!("Error during Udp Transmit: {:?}", e);
thread_aborter.abort();
}
}
}
}
}
error!("Udp write poll aborted");
});
Ok(())
}
pub fn try_clone(&self) -> IoResult<Self> {
Ok(Self {
outgoing: self.outgoing.clone(),
incoming: self.incoming.clone(),
aborter: self.aborter.clone(),
timeout: self.timeout,
mtu: self.mtu,
// New buffer so they don't pollute each other
read_buffer: Default::default(),
write_buffer: Default::default(),
})
}
fn stop_polling(&self) {
self.aborter.abort();
}
fn get_socket(timeout: Duration) -> Result<UdpSocket> {
// Select a random port to bind to
let mut ports: Vec<u16> = (53500..54000).into_iter().collect();
let mut rng = thread_rng();
ports.shuffle(&mut rng);
let addrs: Vec<_> = ports
.iter()
.map(|&port| SocketAddr::from(([0, 0, 0, 0], port)))
.collect();
let socket = UdpSocket::bind(&addrs[..])?;
socket.set_read_timeout(Some(timeout))?;
socket.set_write_timeout(Some(timeout))?;
socket.set_nonblocking(false)?;
socket.set_broadcast(true)?;
Ok(socket)
}
}
// Ensuring polling stops
impl Drop for UdpSource {
fn drop(&mut self) {
self.stop_polling();
}
}
#[derive(Default)]
struct Buffered {
buffer: Vec<u8>,
consumed: usize,
}
impl Read for UdpSource {
fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> {
if self.aborter.is_aborted() {
return Err(IoError::new(
ErrorKind::ConnectionAborted,
"Connection dropped",
));
}
let buffer = self.fill_buf()?;
let amt = std::cmp::min(buf.len(), buffer.len());
// First check if the amount of bytes we want to read is small:
// `copy_from_slice` will generally expand to a call to `memcpy`, and
// for a single byte the overhead is significant.
if amt == 1 {
buf[0] = buffer[0];
} else {
buf[..amt].copy_from_slice(&buffer[..amt]);
}
self.consume(amt);
Ok(amt)
}
}
impl BufRead for UdpSource {
fn fill_buf(&mut self) -> IoResult<&[u8]> {
const CLEAR_CONSUMED_AT: usize = 1024;
// This is a trade off between caching too much dead memory
// and calling the drain method too often
if self.read_buffer.consumed > CLEAR_CONSUMED_AT {
let _ = self
.read_buffer
.buffer
.drain(0..self.read_buffer.consumed)
.collect::<Vec<u8>>();
self.read_buffer.consumed = 0;
}
if self.read_buffer.buffer.len() <= self.read_buffer.consumed {
// Get next packet of the read queue
match self.incoming.recv_timeout(self.timeout) {
Ok(buf) => self.read_buffer.buffer.extend(buf),
Err(RecvTimeoutError::Timeout) => {
return Err(IoError::new(
ErrorKind::UnexpectedEof,
"Connection timedout when reading from udp channel",
));
}
Err(RecvTimeoutError::Disconnected) => {
return Err(IoError::new(
ErrorKind::UnexpectedEof,
"Connection dropped when reading from udp channel",
));
}
}
}
Ok(&self.read_buffer.buffer.as_slice()[self.read_buffer.consumed..])
}
fn consume(&mut self, amt: usize) {
assert!(self.read_buffer.consumed + amt <= self.read_buffer.buffer.len());
self.read_buffer.consumed += amt;
}
}
const UDPDATA_HEADER_SIZE: usize = 20;
impl Write for UdpSource {
fn write(&mut self, buf: &[u8]) -> IoResult<usize> {
if self.aborter.is_aborted() {
return Err(IoError::new(
std::io::ErrorKind::ConnectionAborted,
"Connection dropped",
));
}
self.write_buffer.buffer.extend(buf.to_vec());
if self.write_buffer.buffer.len() > self.mtu as usize - UDPDATA_HEADER_SIZE {
let _ = self.flush();
}
Ok(buf.len())
}
fn flush(&mut self) -> IoResult<()> {
if self.aborter.is_aborted() {
return Err(IoError::new(
std::io::ErrorKind::ConnectionAborted,
"Connection dropped",
));
}
for chunk in self
.write_buffer
.buffer
.chunks(self.mtu as usize - UDPDATA_HEADER_SIZE)
{
if self.outgoing.send(chunk.to_vec()).is_err() {
return Err(IoError::new(
std::io::ErrorKind::ConnectionAborted,
"Connection dropped",
));
}
}
self.write_buffer.buffer.clear();
Ok(())
}
}
@@ -0,0 +1,345 @@
/// This module handles the data from Bc->BcUdp->UdpSocket
///
/// - It recieves Bc as Vec<u8> (after serialize)
/// - It wraps it in BcUdp packet
/// - It retransmits when camera dosen't acknoledge
/// - It sends UdpAck to acknoledge recieved packets
///
use super::{aborthandle::AbortHandle, discover::UdpDiscover, SOCKET_WAIT_TIME, WAIT_TIME};
use crate::bcudp::{model::*, xml::*};
use crossbeam_channel::{Receiver, SendError, Sender, TryRecvError};
use err_derive::Error;
use log::*;
use std::collections::HashMap;
use std::io::{Error as IoError, ErrorKind};
use std::net::UdpSocket;
use std::sync::{
atomic::{AtomicU32, Ordering},
Mutex,
};
use time::OffsetDateTime;
#[derive(Debug, Error)]
pub enum TransmitError {
/// Error raised when IO fails such as when the connection is lost
#[error(display = "Io error")]
Io(#[error(source)] IoError),
/// Error raised when socket recv IO fails such as when the connection is lost
#[error(display = "Socket Recv error")]
SocketRecv { err: std::io::Error },
/// Error raised when socker IO fails such as when the connection is lost
#[error(display = "Socket Send error")]
SocketSend { err: std::io::Error },
/// Error raised when camera sends a disconnect request
#[error(display = "Camera Requested Disconnected")]
Disc,
/// Error raised during deserlization
#[error(display = "BcUdp Deserialization error")]
BcUdpDeserialization(#[error(source)] crate::bcudp::de::Error),
/// Error raised during serlization
#[error(display = "BcUdp Serialization error")]
BcUdpSerialization(#[error(source)] crate::bcudp::ser::Error),
/// Error raised during send
#[error(display = "BcUdp Send to Channel Failed")]
BcUdpSend(#[error(source)] SendError<Vec<u8>>),
/// Error raised during recv
#[error(display = "BcUdp Recv from Channel Failed")]
BcUdpRecv(#[error(source)] TryRecvError),
}
type Result<T> = std::result::Result<T, TransmitError>;
pub struct UdpTransmit {
client_recieved: ClientRecieved,
client_sent: ClientSent,
}
#[derive(Default)]
struct ClientSent {
buffer: Mutex<HashMap<u32, Vec<u8>>>,
last_sent: Mutex<Option<u32>>,
}
impl ClientSent {
fn get_next_packet_id(&self) -> u32 {
let mut lock = self.last_sent.lock().unwrap();
if let Some(current) = lock.as_ref() {
*lock = Some(current + 1);
} else {
*lock = Some(0);
}
lock.unwrap()
}
fn register_payload(&self, packet_id: u32, payload: Vec<u8>) {
self.buffer
.lock()
.unwrap()
.entry(packet_id)
.or_insert(payload);
}
// fn acknoledge_to(&self, packet_id: u32) {
// self.buffer.lock().unwrap().retain(|&k, _| k > packet_id);
// }
//
// fn acknoledge_these(&self, packet_ids: Vec<u32>) {
// let locked = self.buffer.lock().unwrap();
// for packet_id in packet_ids {
// let _ = locked.remove(&packet_id);
// }
// }
// This function translates the `UdpAck` payload directly
fn acknoledge_from_ack_data(&self, start: u32, payload: Vec<u8>) {
let mut locked = self.buffer.lock().unwrap();
locked.retain(|&k, _| k > start);
for (idx, &value) in payload.iter().enumerate() {
let packet_id = (start + 1) + idx as u32;
if value > 0 {
locked.remove(&packet_id);
}
}
}
fn lock(&self) -> ClientSentLocked {
ClientSentLocked::new(self)
}
}
struct ClientSentLocked<'a> {
locked: std::sync::MutexGuard<'a, HashMap<u32, Vec<u8>>>,
}
impl<'a> ClientSentLocked<'a> {
fn new(source: &'a ClientSent) -> Self {
let locked = source.buffer.lock().unwrap();
Self { locked }
}
fn needs_resend(&self) -> ResendIter {
ResendIter {
iter: self.locked.iter(),
}
}
}
struct ResendIter<'a> {
iter: std::collections::hash_map::Iter<'a, u32, Vec<u8>>,
}
impl<'a> std::iter::Iterator for ResendIter<'a> {
type Item = (u32, &'a Vec<u8>);
fn next(&mut self) -> Option<Self::Item> {
let (k, v) = self.iter.next()?;
Some((*k, v))
}
}
#[derive(Default)]
struct ClientRecieved {
buffer: Mutex<HashMap<u32, Vec<u8>>>,
consumed: Mutex<Option<u32>>,
}
impl ClientRecieved {
// Consume all contigious packets
fn consume(&self) -> Vec<Vec<u8>> {
let mut locked = self.buffer.lock().unwrap();
let mut results = vec![];
if locked.keys().max().is_some() {
// Just check there is some data
let mut packet_id_loc = self.consumed.lock().unwrap();
let mut next_packet_id = packet_id_loc.map(|v| v + 1).unwrap_or(0);
while let Some(payload) = locked.remove(&next_packet_id) {
*packet_id_loc = Some(next_packet_id);
results.push(payload);
next_packet_id = packet_id_loc.unwrap() + 1;
}
}
results
}
// Revieve a new packet only update if entry is new
fn receive(&self, packet_id: u32, payload: Vec<u8>) {
let mut locked = self.buffer.lock().unwrap();
let _ = locked.entry(packet_id).or_insert(payload);
}
// This gets the needed payload to form a `UdpAck` packet
fn get_needed_packets(&self) -> Option<(u32, Vec<u8>)> {
let locked = self.buffer.lock().unwrap();
let packet_id_loc = self.consumed.lock().unwrap();
// If this is none we have recieved no packets so we cannot
// ack anything anyways. Just return None
let mut start = packet_id_loc.as_ref().copied()?;
// Find the last contigous packet
while locked.contains_key(&(start + 1)) {
start += 1;
}
// Find last packet in buffer
let vec = if let Some(end) = locked.keys().max() {
let mut vec = vec![];
// From last contiguous packet to last recieved packet
// create a payload of `00` (unreceived) and `01` (received)
// that can be used to form the `UdpAck` packet
for i in (start + 1)..(end + 1) {
if locked.contains_key(&i) {
vec.push(1)
} else {
vec.push(0)
}
}
vec
} else {
vec![]
};
Some((start, vec))
}
}
impl UdpTransmit {
pub fn new() -> Self {
Self {
client_recieved: Default::default(),
client_sent: Default::default(),
}
}
pub fn poll_read(
&self,
socket: &UdpSocket,
discovery_result: &UdpDiscover,
send_to_incoming: &Sender<Vec<u8>>,
) -> Result<()> {
// Handle recv from `socket` and send to `send_to_incoming`
let mut buf = vec![0; discovery_result.mtu as usize];
match socket.recv(&mut buf) {
Ok(amount_recv) => {
let bcudp_msg = BcUdp::deserialize(&buf[0..amount_recv])?;
match bcudp_msg {
BcUdp::Discovery(UdpDiscovery {
payload:
UdpXml {
d2c_disc: Some(D2cDisc { cid, did }),
..
},
..
}) if cid == discovery_result.client_id
&& did == discovery_result.camera_id =>
{
// Camera sent a disconnect
// Reply with C2D_Disc and end
discovery_result.send_client_disconnect(socket);
return Err(TransmitError::Disc);
}
BcUdp::Discovery(packet) => {
debug!("Got unexpected discovery packet: {:?}", packet)
}
BcUdp::Ack(UdpAck {
connection_id,
packet_id,
payload,
}) if connection_id == discovery_result.client_id => {
self.client_sent
.acknoledge_from_ack_data(packet_id, payload);
}
BcUdp::Ack(UdpAck { .. }) => {
debug!("Got a UdpAck for another client id");
}
BcUdp::Data(UdpData {
connection_id: cid,
packet_id,
payload,
}) if cid == discovery_result.client_id => {
trace!("Recieving UdpData packet {}", packet_id);
self.client_recieved.receive(packet_id, payload);
for next_payload in self.client_recieved.consume().drain(..) {
send_to_incoming.send(next_payload)?;
}
}
BcUdp::Data(UdpData { .. }) => {
debug!("Got UdpData for another client id");
}
}
}
Err(e) if e.kind() == ErrorKind::WouldBlock || e.kind() == ErrorKind::TimedOut => {
// Just a timeout
}
Err(e) => {
// Should stop
return Err(TransmitError::SocketRecv { err: e });
}
}
Ok(())
}
pub fn poll_write(
&self,
socket: &UdpSocket,
discovery_result: &UdpDiscover,
get_from_outgoing: &Receiver<Vec<u8>>,
) -> Result<()> {
// Handle Retransmit
for (_, payload) in self.client_sent.lock().needs_resend() {
socket
.send(payload)
.map_err(|e| TransmitError::SocketSend { err: e })?;
std::thread::sleep(SOCKET_WAIT_TIME);
}
// Handle recv from `send_to_incoming` and send to `socket`
match get_from_outgoing.try_recv() {
Ok(payload) => {
let packet_id = self.client_sent.get_next_packet_id();
let bcudp_msg = BcUdp::Data(UdpData {
connection_id: discovery_result.camera_id,
packet_id,
payload,
});
let mut buf = vec![];
bcudp_msg.serialize(&mut buf)?;
socket
.send(&buf)
.map_err(|e| TransmitError::SocketSend { err: e })?;
self.client_sent.register_payload(packet_id, buf);
}
Err(TryRecvError::Empty) => {}
Err(e) => return Err(e.into()),
}
// Handle acknoledgment
let client_wants = self.client_recieved.get_needed_packets();
if let Some((client_wants, also_wants)) = client_wants {
let bcack_msg = BcUdp::Ack(UdpAck {
connection_id: discovery_result.camera_id,
packet_id: client_wants,
payload: also_wants,
});
let mut buf = vec![];
bcack_msg.serialize(&mut buf)?;
socket
.send(&buf)
.map_err(|e| TransmitError::SocketSend { err: e })?;
}
std::thread::sleep(SOCKET_WAIT_TIME);
Ok(())
}
}
+1 -1
View File
@@ -35,7 +35,7 @@ impl BcCamera {
channel_id: self.channel_id,
msg_num: self.new_message_num(),
stream_type: 0,
response_code: 0xdc03,
response_code: 0xdc02,
class: 0x6514,
},
body: BcBody::LegacyMsg(LegacyMsg::LoginMsg {
+187
View File
@@ -0,0 +1,187 @@
//! This is a helper module to resolve either to a UID or a SockerAddr
use log::*;
use std::{
io::Error,
net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6, ToSocketAddrs},
};
/// Used to return either the SocketAddr or the UID
pub enum SocketAddrOrUid {
/// When the result is a addr it will be this
SocketAddr(SocketAddr),
/// When the result is a UID
Uid(String),
}
/// An extension of ToSocketAddrs that will also resolve to a camera UID
pub trait ToSocketAddrsOrUid: ToSocketAddrs {
/// The return type of the function
type UidIter: Iterator<Item = SocketAddrOrUid>;
/// This handles the actual resolution. It should first check the
/// normal [.to_socket_addrs()] and if that fails it should check
/// if it looks like a uid
fn to_socket_addrs_or_uid(&self) -> Result<Self::UidIter, Error>;
}
impl ToSocketAddrsOrUid for SocketAddr {
type UidIter = std::vec::IntoIter<SocketAddrOrUid>;
fn to_socket_addrs_or_uid(&self) -> Result<Self::UidIter, Error> {
Ok(self
.to_socket_addrs()?
.map(SocketAddrOrUid::SocketAddr)
.collect::<Vec<_>>()
.into_iter())
}
}
impl ToSocketAddrsOrUid for str {
type UidIter = std::vec::IntoIter<SocketAddrOrUid>;
fn to_socket_addrs_or_uid(&self) -> Result<Self::UidIter, Error> {
match self.to_socket_addrs() {
Ok(addrs) => Ok(addrs
.map(SocketAddrOrUid::SocketAddr)
.collect::<Vec<_>>()
.into_iter()),
Err(e) => {
debug!("Trying as uid");
let re = regex::Regex::new(r"^[0-9A-Za-z]+$").unwrap();
if re.is_match(self) {
Ok(vec![SocketAddrOrUid::Uid(self.to_string())].into_iter())
} else {
debug!("Regex fails {:?} => {:?} ", re, self);
Err(e)
}
}
}
}
}
impl ToSocketAddrsOrUid for String {
type UidIter = std::vec::IntoIter<SocketAddrOrUid>;
fn to_socket_addrs_or_uid(&self) -> Result<Self::UidIter, Error> {
match self.to_socket_addrs() {
Ok(addrs) => Ok(addrs
.map(SocketAddrOrUid::SocketAddr)
.collect::<Vec<_>>()
.into_iter()),
Err(e) => {
debug!("Trying as uid");
let re = regex::Regex::new(r"^[0-9A-Za-z]+$").unwrap();
if re.is_match(self) {
Ok(vec![SocketAddrOrUid::Uid(self.to_string())].into_iter())
} else {
debug!("Regex fails {:?} => {:?} ", re, self);
Err(e)
}
}
}
}
}
impl ToSocketAddrsOrUid for (&str, u16) {
type UidIter = std::vec::IntoIter<SocketAddrOrUid>;
fn to_socket_addrs_or_uid(&self) -> Result<Self::UidIter, Error> {
Ok(self
.to_socket_addrs()?
.map(SocketAddrOrUid::SocketAddr)
.collect::<Vec<_>>()
.into_iter())
}
}
impl ToSocketAddrsOrUid for (IpAddr, u16) {
type UidIter = std::vec::IntoIter<SocketAddrOrUid>;
fn to_socket_addrs_or_uid(&self) -> Result<Self::UidIter, Error> {
Ok(self
.to_socket_addrs()?
.map(SocketAddrOrUid::SocketAddr)
.collect::<Vec<_>>()
.into_iter())
}
}
impl ToSocketAddrsOrUid for (String, u16) {
type UidIter = std::vec::IntoIter<SocketAddrOrUid>;
fn to_socket_addrs_or_uid(&self) -> Result<Self::UidIter, Error> {
Ok(self
.to_socket_addrs()?
.map(SocketAddrOrUid::SocketAddr)
.collect::<Vec<_>>()
.into_iter())
}
}
impl ToSocketAddrsOrUid for (Ipv4Addr, u16) {
type UidIter = std::vec::IntoIter<SocketAddrOrUid>;
fn to_socket_addrs_or_uid(&self) -> Result<Self::UidIter, Error> {
Ok(self
.to_socket_addrs()?
.map(SocketAddrOrUid::SocketAddr)
.collect::<Vec<_>>()
.into_iter())
}
}
impl ToSocketAddrsOrUid for (Ipv6Addr, u16) {
type UidIter = std::vec::IntoIter<SocketAddrOrUid>;
fn to_socket_addrs_or_uid(&self) -> Result<Self::UidIter, Error> {
Ok(self
.to_socket_addrs()?
.map(SocketAddrOrUid::SocketAddr)
.collect::<Vec<_>>()
.into_iter())
}
}
impl ToSocketAddrsOrUid for SocketAddrV4 {
type UidIter = std::vec::IntoIter<SocketAddrOrUid>;
fn to_socket_addrs_or_uid(&self) -> Result<Self::UidIter, Error> {
Ok(self
.to_socket_addrs()?
.map(SocketAddrOrUid::SocketAddr)
.collect::<Vec<_>>()
.into_iter())
}
}
impl ToSocketAddrsOrUid for SocketAddrV6 {
type UidIter = std::vec::IntoIter<SocketAddrOrUid>;
fn to_socket_addrs_or_uid(&self) -> Result<Self::UidIter, Error> {
Ok(self
.to_socket_addrs()?
.map(SocketAddrOrUid::SocketAddr)
.collect::<Vec<_>>()
.into_iter())
}
}
impl<'a> ToSocketAddrsOrUid for &'a [SocketAddr] {
type UidIter = std::vec::IntoIter<SocketAddrOrUid>;
fn to_socket_addrs_or_uid(&self) -> Result<Self::UidIter, Error> {
Ok(self
.to_socket_addrs()?
.map(SocketAddrOrUid::SocketAddr)
.collect::<Vec<_>>()
.into_iter())
}
}
impl<T: ToSocketAddrsOrUid + ?Sized> ToSocketAddrsOrUid for &T {
type UidIter = T::UidIter;
fn to_socket_addrs_or_uid(&self) -> Result<Self::UidIter, Error> {
(&**self).to_socket_addrs_or_uid()
}
}
+56 -9
View File
@@ -21,6 +21,20 @@ pub trait StreamOutput {
fn stream_recv(&mut self, media: BcMedia) -> StreamOutputError;
}
/// The stream names supported by BC
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub enum Stream {
/// This is the HD stream
Main,
/// This is the SD stream
Sub,
/// This stream represents a balance between SD and HD
///
/// It is only avaliable on some camera. If the camera dosen't
/// support it the stream will be the same as the SD stream
Extern,
}
impl BcCamera {
///
/// Starts the video stream
@@ -29,13 +43,16 @@ impl BcCamera {
///
/// * `data_outs` - This should be a struct that implements the [`StreamOutput`] trait
///
/// * `stream_name` - The name of the stream either `"mainStream"` for HD or `"subStream"` for SD
/// * `stream_name` - This is a [`Stream`] that controls the stream to request from the camera.
/// Selecting [`Stream::Main`] will select the HD stream.
/// Selecting [`Stream::Sub`] will select the SD stream.
/// Selecting [`Stream::Extern`] will select the medium quality stream (only on some camera)
///
/// # Returns
///
/// This will block forever or return an error when the camera connection is dropped
///
pub fn start_video<Outputs>(&self, data_outs: &mut Outputs, stream_name: &str) -> Result<()>
pub fn start_video<Outputs>(&self, data_outs: &mut Outputs, stream_name: Stream) -> Result<()>
where
Outputs: StreamOutput,
{
@@ -45,18 +62,48 @@ impl BcCamera {
.expect("Must be connected to start video");
let sub_video = connection.subscribe(MSG_ID_VIDEO)?;
let stream_num = match stream_name {
"mainStream" => 0,
"subStream" => 1,
_ => 0,
// On an E1 and swann cameras:
// - mainStream always has a value of 0
// - subStream always has a value of 1
// - There is no externStram
// On a B800:
// - mainStream is 0
// - subStream is 0
// - externStream is 0
let stream_code = match stream {
Stream::Main => 0,
Stream::Sub => 1,
Stream::Extern => 0,
};
// Theses are the numbers used with the offical client
// On an E1 and swann cameras:
// - mainStream always has a value of 0
// - subStream always has a value of 1
// - There is no externStram
// On a B800:
// - mainStream is 0
// - subStream is 256
// - externStram is 1024
let handle = match stream {
Stream::Main => 0,
Stream::Sub => 256,
Stream::Extern => 1024,
};
let stream_name = match stream {
Stream::Main => "mainStream",
Stream::Sub => "subStream",
Stream::Extern => "externStream",
}
.to_string();
let start_video = Bc::new_from_xml(
BcMeta {
msg_id: MSG_ID_VIDEO,
channel_id: self.channel_id,
msg_num: self.new_message_num(),
stream_type: stream_num,
stream_type: stream_code,
response_code: 0,
class: 0x6414, // IDK why
},
@@ -64,8 +111,8 @@ impl BcCamera {
preview: Some(Preview {
version: xml_ver(),
channel_id: self.channel_id,
handle: 0,
stream_type: stream_name.to_string(),
handle,
stream_type: stream_name,
}),
..Default::default()
},
+34 -14
View File
@@ -1,9 +1,11 @@
use super::model::BcMediaIframe;
use super::model::*;
use crate::RX_TIMEOUT;
use err_derive::Error;
use nom::IResult;
use nom::{combinator::*, named, number::streaming::*, take, take_str};
use std::io::Read;
use time::OffsetDateTime;
// PAD_SIZE: Media packets use 8 byte padding
const PAD_SIZE: u32 = 8;
@@ -50,15 +52,33 @@ where
Err(e) => return Err(e.into()),
};
if 0 == (&mut rdr)
.take(to_read.get() as u64)
.read_to_end(&mut input)?
{
return Err(std::io::Error::new(
std::io::ErrorKind::UnexpectedEof,
"Read returned 0 bytes",
)
.into());
let start_time = OffsetDateTime::now_utc();
loop {
match (&mut rdr)
.take(to_read.get() as u64)
.read_to_end(&mut input)
{
Ok(0) => {
if (OffsetDateTime::now_utc() - start_time) > RX_TIMEOUT {
return Err(std::io::Error::new(
std::io::ErrorKind::UnexpectedEof,
"Read returned 0 bytes",
)
.into());
}
}
Ok(_) => break,
Err(e)
if e.kind() == std::io::ErrorKind::WouldBlock
|| e.kind() == std::io::ErrorKind::TimedOut =>
{
// This is a temporaily unavaliable resource
// We should just wait and try again
}
Err(e) => {
return Err(e.into());
}
}
}
}
}
@@ -76,8 +96,8 @@ fn bcmedia(buf: &[u8]) -> IResult<&[u8], BcMedia> {
*x,
MAGIC_HEADER_BCMEDIA_INFO_V1
| MAGIC_HEADER_BCMEDIA_INFO_V2
| MAGIC_HEADER_BCMEDIA_IFRAME
| MAGIC_HEADER_BCMEDIA_PFRAME
| MAGIC_HEADER_BCMEDIA_IFRAME..=MAGIC_HEADER_BCMEDIA_IFRAME_LAST
| MAGIC_HEADER_BCMEDIA_PFRAME..=MAGIC_HEADER_BCMEDIA_PFRAME_LAST
| MAGIC_HEADER_BCMEDIA_AAC
| MAGIC_HEADER_BCMEDIA_ADPCM
)
@@ -92,11 +112,11 @@ fn bcmedia(buf: &[u8]) -> IResult<&[u8], BcMedia> {
let (buf, payload) = bcmedia_info_v2(buf)?;
Ok((buf, BcMedia::InfoV2(payload)))
}
MAGIC_HEADER_BCMEDIA_IFRAME => {
MAGIC_HEADER_BCMEDIA_IFRAME..=MAGIC_HEADER_BCMEDIA_IFRAME_LAST => {
let (buf, payload) = bcmedia_iframe(buf)?;
Ok((buf, BcMedia::Iframe(payload)))
}
MAGIC_HEADER_BCMEDIA_PFRAME => {
MAGIC_HEADER_BCMEDIA_PFRAME..=MAGIC_HEADER_BCMEDIA_PFRAME_LAST => {
let (buf, payload) = bcmedia_pframe(buf)?;
Ok((buf, BcMedia::Pframe(payload)))
}
@@ -312,7 +332,7 @@ fn bcmedia_adpcm(buf: &[u8]) -> IResult<&[u8], BcMediaAdpcm> {
#[cfg(test)]
mod tests {
use super::Error;
use crate::bc_protocol::filesub::FileSubscriber;
use crate::bc_protocol::FileSubscriber;
use crate::bcmedia::model::*;
use env_logger::Env;
use log::*;
+4
View File
@@ -103,7 +103,9 @@ pub struct BcMediaInfoV2 {
// unknown: u16
}
// IFrame magics include the channel number in them
pub(super) const MAGIC_HEADER_BCMEDIA_IFRAME: u32 = 0x63643030;
pub(super) const MAGIC_HEADER_BCMEDIA_IFRAME_LAST: u32 = 0x63643039;
/// Video Types for I/PFrame
#[derive(Debug)]
@@ -132,7 +134,9 @@ pub struct BcMediaIframe {
pub data: Vec<u8>,
}
// PFrame magics include the channel number in them
pub(super) const MAGIC_HEADER_BCMEDIA_PFRAME: u32 = 0x63643130;
pub(super) const MAGIC_HEADER_BCMEDIA_PFRAME_LAST: u32 = 0x63643139;
/// This is a BcMedia video PFrame.
#[derive(Debug)]
+20
View File
@@ -0,0 +1,20 @@
use crc32fast::Hasher;
pub(crate) fn calc_crc(payload: &[u8]) -> u32 {
// Bc uses a non standard crc.
//
// It uses the polynomial 0x04c11db7
// It uses the inital value or 0x00000000
// It uses the xorout of 0x00000000
//
// The crc32fast has an odd behavior were it bitwise negates
// the initial value before the loop. In order to have
// an effective initial value of 0x00000000 we need to provide
// the value 0xffffffff
let mut hasher = Hasher::new_with_initial(0xffffffff);
hasher.update(payload);
// crc32fast uses the algorithm CRC-32/ISO-HDLC
// This has an xorout of 0xffffffff
// we must undo this xorout
hasher.finalize() ^ 0xffffffff_u32
}
+369
View File
@@ -0,0 +1,369 @@
use super::{crc::calc_crc, model::*, xml::*, xml_crypto::decrypt};
use crate::RX_TIMEOUT;
use err_derive::Error;
use nom::IResult;
use nom::{
combinator::*,
error::{make_error, ErrorKind},
number::streaming::*,
take, Err,
};
use std::io::Read;
use time::OffsetDateTime;
/// The error types used during deserialisation
#[derive(Debug, Error)]
pub enum Error {
/// A Nom parsing error usually a malformed packet
#[error(display = "Parsing error")]
NomError(String),
/// An IO error such as the stream being dropped
#[error(display = "I/O error")]
IoError(#[error(source)] std::io::Error),
}
type NomErrorType<'a> = nom::error::Error<&'a [u8]>;
impl<'a> From<nom::Err<NomErrorType<'a>>> for Error {
fn from(k: nom::Err<NomErrorType<'a>>) -> Self {
let reason = match k {
nom::Err::Error(e) => format!("Nom Error: {:?}", e),
nom::Err::Failure(e) => format!("Nom Error: {:?}", e),
_ => "Unknown Nom error".to_string(),
};
Error::NomError(reason)
}
}
fn read_from_reader<P, O, E, R>(mut parser: P, mut rdr: R) -> Result<O, E>
where
R: Read,
E: for<'a> From<nom::Err<NomErrorType<'a>>> + From<std::io::Error>,
P: FnMut(&[u8]) -> nom::IResult<&[u8], O>,
{
let mut input: Vec<u8> = Vec::new();
loop {
let to_read = match parser(&input) {
Ok((_, parsed)) => return Ok(parsed),
Err(nom::Err::Incomplete(needed)) => {
match needed {
nom::Needed::Unknown => std::num::NonZeroUsize::new(1).unwrap(), // read one byte
nom::Needed::Size(len) => len,
}
}
Err(e) => return Err(e.into()),
};
let start_time = OffsetDateTime::now_utc();
loop {
match (&mut rdr)
.take(to_read.get() as u64)
.read_to_end(&mut input)
{
Ok(0) => {
if (OffsetDateTime::now_utc() - start_time) > RX_TIMEOUT {
return Err(std::io::Error::new(
std::io::ErrorKind::UnexpectedEof,
"Read returned 0 bytes",
)
.into());
}
}
Ok(_) => break,
Err(e) if e.kind() == std::io::ErrorKind::WouldBlock => {
// This is a temporaily unavaliable resource
// We should just wait and try again
}
Err(e) => {
return Err(e.into());
}
}
}
}
}
impl BcUdp {
pub(crate) fn deserialize<R: Read>(r: R) -> Result<BcUdp, Error> {
// Throw away the nom-specific return types
read_from_reader(|reader| bcudp(reader), r)
}
}
fn bcudp(buf: &[u8]) -> IResult<&[u8], BcUdp> {
let (buf, magic) = verify(le_u32, |x| {
matches!(
*x,
MAGIC_HEADER_UDP_NEGO | MAGIC_HEADER_UDP_ACK | MAGIC_HEADER_UDP_DATA
)
})(buf)?;
match magic {
MAGIC_HEADER_UDP_NEGO => {
let (buf, payload) = udp_disc(buf)?;
Ok((buf, BcUdp::Discovery(payload)))
}
MAGIC_HEADER_UDP_ACK => {
let (buf, payload) = udp_ack(buf)?;
Ok((buf, BcUdp::Ack(payload)))
}
MAGIC_HEADER_UDP_DATA => {
let (buf, payload) = udp_data(buf)?;
Ok((buf, BcUdp::Data(payload)))
}
_ => unreachable!(),
}
}
fn udp_disc(buf: &[u8]) -> IResult<&[u8], UdpDiscovery> {
let (buf, payload_size) = le_u32(buf)?;
let (buf, _unknown_a) = verify(le_u32, |&x| x == 1)(buf)?;
let (buf, tid) = le_u32(buf)?;
let (buf, checksum) = le_u32(buf)?;
let (buf, enc_data_slice) = take!(buf, payload_size)?;
let actual_checksum = calc_crc(enc_data_slice);
assert_eq!(checksum, actual_checksum);
let decrypted_payload = decrypt(tid, enc_data_slice);
let payload = UdpXml::try_parse(decrypted_payload.as_slice())
.map_err(|_| Err::Error(make_error(buf, ErrorKind::MapRes)))?;
let data = UdpDiscovery { tid, payload };
Ok((buf, data))
}
fn udp_ack(buf: &[u8]) -> IResult<&[u8], UdpAck> {
let (buf, connection_id) = le_i32(buf)?;
let (buf, _unknown_a) = verify(le_u32, |&x| x == 0)(buf)?;
let (buf, _unknown_b) = verify(le_u32, |&x| x == 0)(buf)?;
let (buf, packet_id) = le_u32(buf)?; // This is the point at which the camera has contigious
// packets to
let (buf, _unknown) = le_u32(buf)?;
let (buf, payload_size) = le_u32(buf)?;
let (buf, payload) = if payload_size > 0 {
let (buf, t_payload) = take!(buf, payload_size)?; // It is a binary payload of
// `00 01 01 01 01 00 01`
// This is a truth map of missing packets
// since last contigious packet_id up
// to the last packet we sent and it recieved
(buf, t_payload.to_vec())
} else {
(buf, vec![])
};
let data = UdpAck {
connection_id,
packet_id,
payload,
};
Ok((buf, data))
}
fn udp_data(buf: &[u8]) -> IResult<&[u8], UdpData> {
let (buf, connection_id) = le_i32(buf)?;
let (buf, _unknown_a) = verify(le_u32, |&x| x == 0)(buf)?;
let (buf, packet_id) = le_u32(buf)?;
let (buf, payload_size) = le_u32(buf)?;
let (buf, payload) = take!(buf, payload_size)?;
let data = UdpData {
connection_id,
packet_id,
payload: payload.to_vec(),
};
Ok((buf, data))
}
#[cfg(test)]
mod tests {
use super::Error;
use crate::bc_protocol::FileSubscriber;
use crate::bcudp::model::*;
use crate::bcudp::xml::*;
use assert_matches::assert_matches;
use env_logger::Env;
use log::*;
use std::io::ErrorKind;
use std::path::PathBuf;
fn init() {
let _ = env_logger::Builder::from_env(Env::default().default_filter_or("info"))
.is_test(true)
.try_init();
}
fn sample(name: &str) -> PathBuf {
let dir = std::env::current_dir().unwrap(); // This is crate root during cargo test
dir.join("src").join("bcudp").join("samples").join(name)
}
#[test]
// Tests the decoding of a UdpDiscovery with a discovery xml
fn test_nego_disconnect() {
init();
let mut subsciber = FileSubscriber::from_files(vec![sample("udp_negotiate_disc.bin")]);
let e = BcUdp::deserialize(&mut subsciber);
assert_matches!(
e,
Ok(BcUdp::Discovery(UdpDiscovery {
tid: 96,
payload: UdpXml {
c2d_disc: Some(C2dDisc {
cid: 82000,
did: 80,
}),
..
},
}))
);
}
#[test]
// Tests the decoding of a UdpDiscovery with a Camera Transmission xml
fn test_nego_cam_transmission() {
init();
let mut subsciber = FileSubscriber::from_files(vec![sample("udp_negotiate_camt.bin")]);
let e = BcUdp::deserialize(&mut subsciber);
assert_matches!(
e,
Ok(BcUdp::Discovery(UdpDiscovery {
tid: 113,
payload: UdpXml {
d2c_t: Some(D2cT {
sid: 62098713,
conn: conn_str,
cid: 82001,
did: 96,
}),
..
},
})) if &conn_str == "local"
);
}
#[test]
// Tests the decoding of a UdpDiscovery with a Client Transmission xml
fn test_nego_client_transmission() {
init();
let mut subsciber = FileSubscriber::from_files(vec![sample("udp_negotiate_clientt.bin")]);
let e = BcUdp::deserialize(&mut subsciber);
assert_matches!(
e,
Ok(BcUdp::Discovery(UdpDiscovery {
tid: 1101,
payload: UdpXml {
c2d_t: Some(C2dT {
sid: 62098713,
conn: conn_str,
cid: 82001,
mtu: 1350,
}),
..
},
})) if &conn_str == "local"
);
}
#[test]
// Tests the decoding of a UdpDiscovery with a Camera CFM xml
fn test_nego_cfm() {
init();
let mut subsciber = FileSubscriber::from_files(vec![sample("udp_negotiate_camcfm.bin")]);
let e = BcUdp::deserialize(&mut subsciber);
assert_matches!(
e,
Ok(BcUdp::Discovery(UdpDiscovery {
tid: 1101,
payload: UdpXml {
d2c_cfm: Some(D2cCfm {
sid: 62098713,
conn: conn_str,
rsp: 0,
cid: 82001,
did: 96,
time_r: 0,
}),
..
},
})) if &conn_str == "local"
);
}
#[test]
// Tests the decoding of an acknoledge packet
fn test_ack() {
init();
let mut subsciber = FileSubscriber::from_files(vec![sample("udp_ack.bin")]);
let e = BcUdp::deserialize(&mut subsciber);
assert_matches!(
e,
Ok(BcUdp::Ack(UdpAck {
connection_id: 80,
packet_id: 2439,
..
}))
);
}
#[test]
// Tests the decoding of an data packet
fn test_data() {
init();
let mut subsciber = FileSubscriber::from_files(vec![sample("udp_data.bin")]);
let e = BcUdp::deserialize(&mut subsciber);
assert_matches!(
e,
Ok(BcUdp::Data(UdpData {
connection_id: 82000,
packet_id: 2439,
payload: payload_data
})) if payload_data.len() == 1176
);
}
#[test]
// Tests the decoding of multiple packets
fn test_multi_packets() {
init();
let mut subsciber = FileSubscriber::from_files(vec![
sample("udp_multi_0.bin"),
sample("udp_multi_1.bin"),
sample("udp_multi_2.bin"),
sample("udp_multi_3.bin"),
sample("udp_multi_4.bin"),
sample("udp_multi_5.bin"),
sample("udp_multi_6.bin"),
sample("udp_multi_7.bin"),
sample("udp_multi_8.bin"),
sample("udp_multi_9.bin"),
]);
// Should derealise all of this
loop {
let e = BcUdp::deserialize(&mut subsciber);
match e {
Err(Error::IoError(e)) if e.kind() == ErrorKind::UnexpectedEof => {
// Reach end of files
break;
}
Err(e) => {
error!("{:?}", e);
panic!();
}
Ok(_) => {}
}
}
}
}
+34
View File
@@ -0,0 +1,34 @@
//! This module contains the protocol for dealing with UDP.
//!
//! There are three types of packets
//!
//! - Discovery
//! - Ack
//! - Data
//!
//! ---
//!
//! **Discovery**: Deals with setting up the initial connection and including their
//! connection IDs and the MTU
//!
//! ---
//!
//! **Ack**: Is sent after every packet is recieved
//!
//! ---
//!
//! **Data**: Contains a Bc packet payload. This is a stream and one Bc Packet may
//! be split accross multiple UDP Data packets
//!
mod crc;
/// Functions to deserialize udp packets
pub mod de;
/// Contains the model describing the top level structures
pub mod model;
/// Functions to serialize udp packets
pub mod ser;
/// Contains the udp related xml payloads
pub mod xml;
// Constains routines to de/encrypt udp xml
mod xml_crypto;
+92
View File
@@ -0,0 +1,92 @@
//! The BcUdp Model
//!
use super::xml::*;
/// Top level udp packet
#[derive(Debug, PartialEq, Eq)]
pub enum BcUdp {
/// Packet from the negotiate stage when connection info is exchanged
Discovery(UdpDiscovery),
/// Packet to acknowledge receipt of a data packet
Ack(UdpAck),
/// Packet containing the data (or part of the data) of a Bc packet
Data(UdpData),
}
/// Magic for the UDP Discovery packet
pub const MAGIC_HEADER_UDP_NEGO: u32 = 0x2a87cf3a;
/// The Discovery packet is sent and received to init a connection
#[derive(Debug, PartialEq, Eq)]
pub struct UdpDiscovery {
// The packet also contains these header fields not deserialized into this struct:
// 4 Bytes Magic
// 4 Byte payload size
// 4 Bytes unknown always `01000000`
/// The transmission id is unique to a message and used as an encryption key
pub tid: u32,
// The checksum of the payload
// pub checksum: u32,
/// The payload
pub payload: UdpXml,
}
/// Magic for the UDP Ack packet
pub const MAGIC_HEADER_UDP_ACK: u32 = 0x2a87cf20;
/// Send to acknoledge a [`UdpData`] packet. If this is not sent then the camera will
/// resend the packet
#[derive(Debug, PartialEq, Eq)]
pub struct UdpAck {
/// The connection ID
///
/// This is negotiated during [`UdpDiscovery`] as cid for the client and did for the camera
///
/// When receiving from the camera it will be cid
///
/// When sending to the camera it should be did
///
/// We use i32 because when we send the connection id to the reolink
/// register and then download the same connection id from the register_address
/// it comes back in an xml that is encoded as i32 (i.e. can be negative string)
pub connection_id: i32,
// Unknown 4 bytes always 0
/// The ID of the last data packet [`UdpData`]
pub packet_id: u32,
// 2 Bytes Unknown: Observed values `00000000`, `d6010000`, `d7160000` `09e00000`
// Unknown but seems to change randomly every second
// 2 Bytes size of a payload
//
/// Payload of `00 01 01 01 01` where `01` is added after every repeat
///
/// This is a truth table of packets after `packet_id` that have not been recieved
pub payload: Vec<u8>,
}
/// Magic for the UDP Data packet
pub const MAGIC_HEADER_UDP_DATA: u32 = 0x2a87cf10;
/// Contains the data of a [`crate::bc::model::Bc`] packet
#[derive(Debug, PartialEq, Eq)]
pub struct UdpData {
/// The connection ID of the other party
///
/// This is negotiated during [`UdpDiscovery`] as cid for the client and did for the camera
///
/// When receiving from the camera it will be cid
///
/// When sending to the camera it should be did
///
/// We use i32 because when we send the connection id to the reolink
/// register and then download the same connection id from the register_address
/// it comes back in an xml that is encoded as i32 (i.e. can be negative string)
pub connection_id: i32,
// Unknown 4 bytes always 0
/// The ID of the data packet
pub packet_id: u32,
// Unknown 4 bytes always 0
// 4 Byte payload size
/// The payload
pub payload: Vec<u8>,
}
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
@@ -0,0 +1,8 @@
<P2P>
<D2C_T>
<sid>62097899</sid>
<conn>local</conn>
<cid>82000</cid>
<did>80</did>
</D2C_T>
</P2P>
+190
View File
@@ -0,0 +1,190 @@
use super::{crc::calc_crc, model::*, xml_crypto::encrypt};
use cookie_factory::bytes::*;
use cookie_factory::sequence::tuple;
use cookie_factory::{combinator::*, gen};
use cookie_factory::{GenError, SerializeFn};
use err_derive::Error;
use log::error;
use std::io::Write;
/// The error types used during serialisation
#[derive(Debug, Error)]
pub enum Error {
/// A Cookie Factor GenError
#[error(display = "Cookie GenError")]
GenError(#[error(source)] GenError),
}
impl BcUdp {
pub(crate) fn serialize<W: Write>(&self, buf: W) -> Result<W, Error> {
let (buf, _) = match &self {
BcUdp::Discovery(payload) => {
let xml_payload = encrypt(payload.tid, &payload.payload.serialize(vec![]).unwrap());
gen(bcudp_disc(payload, &xml_payload), buf)?
}
BcUdp::Ack(payload) => {
let binary_payload = &payload.payload;
gen(bcudp_ack(payload, binary_payload), buf)?
}
BcUdp::Data(payload) => {
let binary_payload = &payload.payload;
gen(bcudp_data(payload, binary_payload), buf)?
}
};
Ok(buf)
}
}
fn bcudp_disc<'a, W: 'a + Write>(
payload: &'a UdpDiscovery,
xml_payload: &'a [u8],
) -> impl SerializeFn<W> + 'a {
let checksum = calc_crc(xml_payload);
tuple((
le_u32(MAGIC_HEADER_UDP_NEGO),
le_u32(xml_payload.len() as u32),
le_u32(1),
le_u32(payload.tid),
le_u32(checksum),
slice(xml_payload),
))
}
fn bcudp_ack<'a, W: 'a + Write>(
payload: &'a UdpAck,
binary_payload: &'a [u8],
) -> impl SerializeFn<W> + 'a {
tuple((
le_u32(MAGIC_HEADER_UDP_ACK),
le_i32(payload.connection_id),
le_u32(0),
le_u32(0),
le_u32(payload.packet_id),
le_u32(0),
le_u32(binary_payload.len() as u32),
slice(binary_payload),
))
}
fn bcudp_data<'a, W: 'a + Write>(
payload: &'a UdpData,
binary_payload: &'a [u8],
) -> impl SerializeFn<W> + 'a {
tuple((
le_u32(MAGIC_HEADER_UDP_DATA),
le_i32(payload.connection_id),
le_u32(0),
le_u32(payload.packet_id),
le_u32(binary_payload.len() as u32),
slice(binary_payload),
))
}
#[cfg(test)]
mod tests {
use crate::bcudp::model::*;
use env_logger::Env;
fn init() {
let _ = env_logger::Builder::from_env(Env::default().default_filter_or("info"))
.is_test(true)
.try_init();
}
#[test]
// Tests the decoding of a UdpDiscovery with a discovery xml
fn test_nego_disconnect() {
init();
let sample = include_bytes!("samples/udp_negotiate_disc.bin");
let msg = BcUdp::deserialize(&sample[..]).unwrap();
let ser_buf = msg.serialize(vec![]).unwrap();
let msg2 = BcUdp::deserialize::<&[u8]>(ser_buf.as_ref()).unwrap();
assert_eq!(msg, msg2);
// Raw samples don't quite match exactly
// because the yaserde for xml puts spaces and new lines in different places
// then the raw data from the camera so we skip this last assert
//assert_eq!(&sample[..], ser_buf.as_slice());
}
#[test]
// Tests the decoding of a UdpDiscovery with a Camera Transmission xml
fn test_nego_cam_transmission() {
init();
let sample = include_bytes!("samples/udp_negotiate_camt.bin");
let msg = BcUdp::deserialize(&sample[..]).unwrap();
let ser_buf = msg.serialize(vec![]).unwrap();
let msg2 = BcUdp::deserialize::<&[u8]>(ser_buf.as_ref()).unwrap();
assert_eq!(msg, msg2);
// Raw samples don't quite match exactly
// because the yaserde for xml puts spaces and new lines in different places
// then the raw data from the camera so we skip this last assert
//assert_eq!(&sample[..], ser_buf.as_slice());
}
#[test]
// Tests the decoding of a UdpDiscovery with a Client Transmission xml
fn test_nego_client_transmission() {
init();
let sample = include_bytes!("samples/udp_negotiate_clientt.bin");
let msg = BcUdp::deserialize(&sample[..]).unwrap();
let ser_buf = msg.serialize(vec![]).unwrap();
let msg2 = BcUdp::deserialize::<&[u8]>(ser_buf.as_ref()).unwrap();
assert_eq!(msg, msg2);
// Raw samples don't quite match exactly
// because the yaserde for xml puts spaces and new lines in different places
// then the raw data from the camera so we skip this last assert
//assert_eq!(&sample[..], ser_buf.as_slice());
}
#[test]
// Tests the decoding of a UdpDiscovery with a Camera CFM xml
fn test_nego_cfm() {
init();
let sample = include_bytes!("samples/udp_negotiate_camcfm.bin");
let msg = BcUdp::deserialize(&sample[..]).unwrap();
let ser_buf = msg.serialize(vec![]).unwrap();
let msg2 = BcUdp::deserialize::<&[u8]>(ser_buf.as_ref()).unwrap();
assert_eq!(msg, msg2);
// Raw samples don't quite match exactly
// because the yaserde for xml puts spaces and new lines in different places
// then the raw data from the camera so we skip this last assert
//assert_eq!(&sample[..], ser_buf.as_slice());
}
#[test]
// Tests the decoding of an acknoledge packet
fn test_ack() {
init();
let sample = include_bytes!("samples/udp_ack.bin");
let msg = BcUdp::deserialize(&sample[..]).unwrap();
let ser_buf = msg.serialize(vec![]).unwrap();
let msg2 = BcUdp::deserialize::<&[u8]>(ser_buf.as_ref()).unwrap();
assert_eq!(msg, msg2);
assert_eq!(&sample[..], ser_buf.as_slice());
}
#[test]
// Tests the decoding of an data packet
fn test_data() {
init();
let sample = include_bytes!("samples/udp_data.bin");
let msg = BcUdp::deserialize(&sample[..]).unwrap();
let ser_buf = msg.serialize(vec![]).unwrap();
let msg2 = BcUdp::deserialize::<&[u8]>(ser_buf.as_ref()).unwrap();
assert_eq!(msg, msg2);
assert_eq!(&sample[..], ser_buf.as_slice());
}
}
+292
View File
@@ -0,0 +1,292 @@
// YaSerde currently macro-expands names like __type__value from type_
use std::io::{Read, Write};
// YaSerde is currently naming the traits and the derive macros identically
use yaserde::{ser::Config, YaDeserialize, YaSerialize};
use yaserde_derive::{YaDeserialize, YaSerialize};
/// The top level of the UDP xml is P2P
#[derive(PartialEq, Eq, Default, Debug, YaDeserialize, YaSerialize)]
#[yaserde(rename = "P2P")]
pub struct UdpXml {
/// C2D_S xml Discovery of any client
#[yaserde(rename = "C2D_S")]
pub c2d_s: Option<C2dS>,
/// C2D_S xml Discovery of client with a UID
#[yaserde(rename = "C2D_C")]
pub c2d_c: Option<C2dC>,
/// D2C_C_C xml Reply from discovery
#[yaserde(rename = "D2C_C_R")]
pub d2c_c_r: Option<D2cCr>,
/// D2C_T xml
#[yaserde(rename = "D2C_T")]
pub d2c_t: Option<D2cT>,
/// C2D_T xml
#[yaserde(rename = "C2D_T")]
pub c2d_t: Option<C2dT>,
/// D2C_CFM xml
#[yaserde(rename = "D2C_CFM")]
pub d2c_cfm: Option<D2cCfm>,
/// C2D_DISC xml Disconnect
#[yaserde(rename = "C2D_DISC")]
pub c2d_disc: Option<C2dDisc>,
/// D2C_DISC xml Disconnect
#[yaserde(rename = "D2C_DISC")]
pub d2c_disc: Option<D2cDisc>,
/// C2M_Q xml client to middle man query
#[yaserde(rename = "C2M_Q")]
pub c2m_q: Option<C2mQ>,
/// M2C_Q_R xml middle man to client query reply
#[yaserde(rename = "M2C_Q_R")]
pub m2c_q_r: Option<M2cQr>,
/// C2R_C xml client to register connect
#[yaserde(rename = "C2R_C")]
pub c2r_c: Option<C2rC>,
/// R2C_T xml register to clinet with device ID etc
#[yaserde(rename = "R2C_T")]
pub r2c_t: Option<R2cT>,
/// C2R_CFM xml client to register CFM
#[yaserde(rename = "C2R_CFM")]
pub c2r_cfm: Option<C2rCfm>,
}
impl UdpXml {
pub(crate) fn try_parse(s: impl Read) -> Result<Self, String> {
yaserde::de::from_reader(s)
}
pub(crate) fn serialize<W: Write>(&self, w: W) -> Result<W, String> {
yaserde::ser::serialize_with_writer(self, w, &Config::default())
}
}
/// C2D_S xml
///
/// The camera will send binary data to port 3000
/// to whoever it gets this message from
///
/// It should be broadcasted to port 2015
#[derive(PartialEq, Eq, Default, Debug, YaDeserialize, YaSerialize)]
pub struct C2dS {
/// The destination to reply to
pub to: PortList,
}
/// Port list xml
#[derive(PartialEq, Eq, Default, Debug, YaDeserialize, YaSerialize)]
pub struct PortList {
/// Port to open udp connections with
pub port: u32,
}
/// C2D_C xml
///
/// This will start a connection with any camera that has this UID
/// It should be broadcasted to port 2018
#[derive(PartialEq, Eq, Default, Debug, YaDeserialize, YaSerialize)]
pub struct C2dC {
/// UID of the camera the client wants to connect with
pub uid: String,
/// Cli contains the udp port to communicate on
pub cli: ClientList,
/// The cid is the client ID
pub cid: i32,
/// Maximum transmission size,
pub mtu: u32,
/// Debug mode. Purpose unknown
pub debug: bool,
/// Os of the machine known values are `"MAC"`, `"WIN"`
#[yaserde(rename = "p")]
pub os: String,
}
/// Client List xml
#[derive(PartialEq, Eq, Default, Debug, YaDeserialize, YaSerialize)]
pub struct ClientList {
/// Port to start udp communication with
pub port: u32,
}
/// D2C_C_R xml
///
/// This will start a connection with any camera that has this UID
/// It should be broadcasted to port 2018
#[derive(PartialEq, Eq, Default, Debug, YaDeserialize, YaSerialize)]
pub struct D2cCr {
/// Called timer but not sure what it is a timer of
pub timer: Timer,
/// Unknown
pub rsp: u32,
/// Client ID
pub cid: i32,
/// Camera ID
pub did: i32,
}
/// Timer provided by D2C_C_R
#[derive(PartialEq, Eq, Default, Debug, YaDeserialize, YaSerialize)]
pub struct Timer {
/// Unknown
def: u32,
/// Unknown
hb: u32,
/// Unknown
hbt: u32,
}
/// C2D_DISC xml
#[derive(PartialEq, Eq, Default, Debug, YaDeserialize, YaSerialize)]
pub struct C2dDisc {
/// The client connection ID
pub cid: i32,
/// The camera connection ID
pub did: i32,
}
/// D2C_DISC xml
#[derive(PartialEq, Eq, Default, Debug, YaDeserialize, YaSerialize)]
pub struct D2cDisc {
/// The client connection ID
pub cid: i32,
/// The camera connection ID
pub did: i32,
}
/// D2C_T xml
#[derive(PartialEq, Eq, Default, Debug, YaDeserialize, YaSerialize)]
pub struct D2cT {
/// The camera SID
pub sid: u32,
/// Type of connection observed values are `"local"`
pub conn: String,
/// The client connection ID
pub cid: i32,
/// The camera connection ID
pub did: i32,
}
/// C2D_T xml
#[derive(PartialEq, Eq, Default, Debug, YaDeserialize, YaSerialize)]
pub struct C2dT {
/// The camera SID
pub sid: u32,
/// Type of connection observed values are `"local"`
pub conn: String,
/// The client connection ID
pub cid: i32,
/// Maximum size in bytes of a transmission
pub mtu: u32,
}
/// C2M_Q xml
///
/// This is from client to a reolink middle man server
///
/// It should be sent to a reolink p2p sever on port 9999
#[derive(PartialEq, Eq, Default, Debug, YaDeserialize, YaSerialize)]
pub struct C2mQ {
/// UID to look up
pub uid: String,
/// Os of the machine known values are `"MAC"`, `"WIN"`
#[yaserde(rename = "p")]
pub os: String,
}
/// M2C_Q_R xml
///
/// This is from middle man reolink server to client
///
#[derive(PartialEq, Eq, Default, Debug, YaDeserialize, YaSerialize)]
pub struct M2cQr {
/// The register server location
pub reg: IpPort,
/// The relay server location
pub relay: IpPort,
/// The log server location
pub log: IpPort,
/// The camera location
pub t: IpPort,
}
/// Used as part of M2C_Q_R to provide the host and port
///
/// of the register, relay and log servers
#[derive(PartialEq, Eq, Default, Debug, YaDeserialize, YaSerialize)]
pub struct IpPort {
/// Ip of the service
pub ip: String,
/// Port of the service
pub port: u16,
}
/// C2R_C xml
///
/// This is from client to the register reolink server
///
#[derive(PartialEq, Eq, Default, Debug, YaDeserialize, YaSerialize)]
pub struct C2rC {
/// The UID to register connecition request with
pub uid: String,
/// The location of the client
pub cli: IpPort,
/// The location of the relay server
pub relay: IpPort,
/// The client id
pub cid: i32,
/// Debug setting. Unknown purpose observed values are `0`
pub debug: bool,
/// Inet family. Observed values `4`
pub family: u8,
/// Os of the machine known values are `"MAC"`, `"WIN"`
#[yaserde(rename = "p")]
pub os: String,
}
/// R2C_T xml
///
/// This is from register reolink server to clinet with device ip and did etc
///
#[derive(PartialEq, Eq, Default, Debug, YaDeserialize, YaSerialize)]
pub struct R2cT {
/// The location of the camera
pub dev: IpPort,
/// The client id
pub cid: i32,
/// The camera SID
pub sid: u32,
}
/// D2C_CFM xml
///
/// Device to client, with connection started from middle man server
#[derive(PartialEq, Eq, Default, Debug, YaDeserialize, YaSerialize)]
pub struct D2cCfm {
/// The camera SID
pub sid: u32,
/// Type of connection observed values are `"local"`
pub conn: String,
/// Unknown known values are `0`
pub rsp: u32,
/// The client connection ID
pub cid: i32,
/// The camera connection ID
pub did: i32,
/// The time but only value that has been observed is `0
pub time_r: u32,
}
/// C2R_CFM xml
///
/// Client to register
#[derive(PartialEq, Eq, Default, Debug, YaDeserialize, YaSerialize)]
pub struct C2rCfm {
/// The camera SID
pub sid: u32,
/// Type of connection observed values are `"local"`
pub conn: String,
/// Unknown known values are `0`
pub rsp: u32,
/// The client connection ID
pub cid: i32,
/// The camera connection ID
pub did: i32,
}
+34
View File
@@ -0,0 +1,34 @@
const XML_KEY: [u32; 8] = [
0x1f2d3c4b, 0x5a6c7f8d, 0x38172e4b, 0x8271635a, 0x863f1a2b, 0xa5c6f7d8, 0x8371e1b4, 0x17f2d3a5,
];
pub(crate) fn decrypt(offset: u32, buf: &[u8]) -> Vec<u8> {
let key = XML_KEY
.iter()
.map(|i| (i + offset).to_le_bytes())
.flatten()
.cycle();
buf.iter().zip(key).map(|(byte, key)| key ^ byte).collect()
}
pub(crate) fn encrypt(offset: u32, buf: &[u8]) -> Vec<u8> {
decrypt(offset, buf)
}
#[test]
fn test_udp_xml_crypto() {
let sample = include_bytes!("samples/xml_crypto_sample1.bin");
let should_be = include_bytes!("samples/xml_crypto_sample1_plaintext.bin");
let decrypted = decrypt(87, &sample[..]);
assert_eq!(decrypted, &should_be[..]);
}
#[test]
fn test_udp_xml_crypto_roundtrip() {
let zeros: [u8; 256] = [0; 256];
let decrypted = encrypt(0, &zeros[..]);
let encrypted = decrypt(0, &decrypted[..]);
assert_eq!(encrypted, &zeros[..]);
}
+4
View File
@@ -30,8 +30,12 @@ pub mod bc;
pub mod bc_protocol;
/// Contains low level structures and formats for the media substream
pub mod bcmedia;
/// Contains low level structures and formats for the udpstream
pub mod bcudp;
/// This is the top level error structure of the library
///
/// Most commands will either return their `Ok(result)` or this `Err(Error)`
pub use bc_protocol::Error;
pub(crate) const RX_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(5);
+462 -82
View File
@@ -2,23 +2,35 @@
-- Copy/symlink it into ~/.local/lib/wireshark/plugins/ and restart Wireshark; it should
-- automatically attempt to decode TCP connections on port 9000.
bc_protocol = Proto("Baichuan", "Baichuan/Reolink IP Camera Protocol")
local bc_protocol = Proto("Baichuan", "Baichuan/Reolink IP Camera Protocol")
magic_bytes = ProtoField.int32("baichuan.magic", "magic", base.DEC)
message_id = ProtoField.int32("baichuan.msg_id", "messageId", base.DEC)
message_len = ProtoField.int32("baichuan.msg_len", "messageLen", base.DEC)
xml_enc_offset = ProtoField.int8("baichuan.xml_encryption_offset", "xmlEncryptionOffset", base.DEC)
encrypt_xml = ProtoField.bool("baichuan.encrypt_xml", "encrypt_xml", base.NONE)
channel_id = ProtoField.int8("baichuan.channel_id", "channel_id", base.DEC)
stream_id = ProtoField.int8("baichuan.stream_id", "streamID", base.DEC)
unknown = ProtoField.int8("baichuan.unknown", "unknown", base.DEC)
msg_handle = ProtoField.int8("baichuan.message_handle", "messageHandle", base.DEC)
status_code = ProtoField.int16("baichuan.status_code", "status_code", base.DEC)
message_class = ProtoField.int32("baichuan.msg_class", "messageClass", base.DEC)
f_payload_offset = ProtoField.int32("baichuan.payload_offset", "binOffset", base.DEC)
f_bin_offset = ProtoField.int32("baichuan.bin_offset", "binOffset", base.DEC)
username = ProtoField.string("baichuan.username", "username", base.ASCII)
password = ProtoField.string("baichuan.password", "password", base.ASCII)
local magic_bytes = ProtoField.int32("baichuan.magic", "magic", base.DEC)
local message_id = ProtoField.int32("baichuan.msg_id", "messageId", base.DEC)
local message_len = ProtoField.int32("baichuan.msg_len", "messageLen", base.DEC)
local xml_enc_offset = ProtoField.int8("baichuan.xml_encryption_offset", "xmlEncryptionOffset", base.DEC)
local encrypt_xml = ProtoField.bool("baichuan.encrypt_xml", "encrypt_xml", base.NONE)
local channel_id = ProtoField.int8("baichuan.channel_id", "channel_id", base.DEC)
local stream_id = ProtoField.int8("baichuan.stream_id", "streamID", base.DEC)
local unknown = ProtoField.int8("baichuan.unknown", "unknown", base.DEC)
local msg_handle = ProtoField.int8("baichuan.message_handle", "messageHandle", base.DEC)
local status_code = ProtoField.int16("baichuan.status_code", "status_code", base.DEC)
local message_class = ProtoField.int32("baichuan.msg_class", "messageClass", base.DEC)
local f_bin_offset = ProtoField.int32("baichuan.bin_offset", "binOffset", base.DEC)
local username = ProtoField.string("baichuan.username", "username", base.ASCII)
local password = ProtoField.string("baichuan.password", "password", base.ASCII)
-- UDP Related content
local udp_magic = ProtoField.int32("baichuan.udp_magic", "udp_magic", base.DEC)
local udp_type = ProtoField.int8("baichuan.udp_type", "udp_type", base.DEC)
local udp_message_id = ProtoField.int8("baichuan.udp_message_id", "udp_message_id", base.DEC)
local udp_connection_id = ProtoField.int32("baichuan.udp_connection_id", "udp_connection_id", base.DEC)
local udp_unknown = ProtoField.int32("baichuan.udp_unknown", "udp_unknown", base.DEC)
local udp_tid = ProtoField.int32("baichuan.udp_tid", "udp_tid", base.DEC)
local udp_checksum = ProtoField.int32("baichuan.udp_checksum", "udp_checksum", base.DEC)
local udp_packet_count = ProtoField.int32("baichuan.udp_packet_count", "udp_packet_count", base.DEC)
local udp_last_ack_packet = ProtoField.int32("baichuan.udp_last_ack_packet", "udp_last_ack_packet", base.DEC)
local udp_ack_payload_size = ProtoField.int32("baichuan.udp_ack_payload_size", "ack_payload_size", base.DEC)
local udp_size = ProtoField.int32("baichuan.udp_size", "udp_size", base.DEC)
bc_protocol.fields = {
magic_bytes,
@@ -32,13 +44,23 @@ bc_protocol.fields = {
encrypt_xml,
status_code,
message_class,
f_payload_offset,
f_bin_offset,
username,
password,
udp_magic,
udp_type,
udp_message_id,
udp_connection_id,
udp_unknown,
udp_tid,
udp_checksum,
udp_packet_count,
udp_last_ack_packet,
udp_ack_payload_size,
udp_size,
}
message_types = {
local message_types = {
[1]="login", -- <Encryption> <LoginUser>/<LoginNet> <DeviceInfo>/<StreamInfoList>
[2]="logout",
[3]="<Preview> (video)",
@@ -141,21 +163,21 @@ message_types = {
[274]="<findAlarmVideo>",
}
message_classes = {
local message_classes = {
[0x6514]="legacy",
[0x6614]="modern",
[0x6414]="modern",
[0x0000]="modern",
}
header_lengths = {
local header_lengths = {
[0x6514]=20,
[0x6614]=20,
[0x6414]=24,
[0x0000]=24,
}
function xml_encrypt(ba, offset)
local function xml_decrypt(ba, offset)
local key = "\031\045\060\075\090\105\120\255" -- 1f, 2d, 3c, 4b, 5a, 69, 78 ,ff
local e = ByteArray.new()
e:set_size(ba:len())
@@ -165,13 +187,9 @@ function xml_encrypt(ba, offset)
return e
end
function get_header_len(buffer)
local function get_header_len(buffer)
local magic = buffer(0, 4):le_uint()
if magic == 0x0abcdef0 then
-- Client <-> BC
elseif magic == 0x0fedcba0 then
-- BC <-> BC
else
if magic ~= 0x0abcdef0 and magic ~= 0x0fedcba0 then
-- Unknown magic
return -1 -- No header found
end
@@ -179,19 +197,18 @@ function get_header_len(buffer)
return header_len
end
function get_header(buffer)
local function get_header(buffer)
-- bin_offset is either nil (no binary data) or nonzero
-- TODO: bin_offset is actually stateful!
local bin_offset = nil
local status_code = nil
local encrypt_xml = nil
local return_code = nil
local encr_xml = nil
local header_len = header_lengths[buffer(18, 2):le_uint()]
local msg_type = buffer(4, 4):le_uint()
if header_len == 24 then
bin_offset = buffer(20, 4):le_uint() -- if NHD-805/806 legacy protocol 30 30 30 30 aka "0000"
status_code = buffer(16, 2):le_uint()
return_code = buffer(16, 2):le_uint()
else
encrypt_xml = buffer(16, 1):le_uint()
encr_xml = buffer(16, 1):le_uint()
end
local msg_type = buffer(4, 4):le_uint()
local stream_text = "HD (Clear)"
@@ -203,23 +220,23 @@ function get_header(buffer)
msg_type = buffer(4, 4):le_uint(),
msg_type_str = message_types[msg_type] or "unknown",
msg_len = buffer(8, 4):le_uint(),
encrypt_xml = encrypt_xml,
encrypt_xml = encr_xml,
channel_id = buffer(12, 1):le_uint(),
enc_offset = buffer(12, 1):le_uint(),
stream_type = stream_text,
unknown = buffer(14, 1):le_uint(),
msg_handle = buffer(15, 1):le_uint(),
msg_cls = buffer(18, 2):le_uint(),
status_code = status_code,
status_code = return_code,
class = message_classes[buffer(18, 2):le_uint()],
header_len = header_lengths[buffer(18, 2):le_uint()],
bin_offset = bin_offset,
}
end
function process_header(buffer, headers_tree)
local function process_header(buffer, headers_tree)
local header_data = get_header(buffer)
local header = headers_tree:add(bc_protocol, buffer(0, header_len),
local header = headers_tree:add(bc_protocol, buffer(0, header_data.header_len),
"Baichuan Message Header, length: " .. header_data.header_len .. ", type " .. header_data.msg_type)
local stream_text = " HD (Clear)"
if buffer(13, 1):le_uint() == 1 then
@@ -247,10 +264,10 @@ function process_header(buffer, headers_tree)
else
header:add_le(encrypt_xml, buffer(16, 1))
end
return header_len
return header_data.header_len
end
function process_body(header, body_buffer, bc_subtree, pinfo)
local function process_body(header, body_buffer, bc_subtree, pinfo)
if header.msg_len == 0 then
return
end
@@ -273,9 +290,9 @@ function process_body(header, body_buffer, bc_subtree, pinfo)
local body_tvb = xml_buffer:tvb("Meta Payload")
body:add(body_tvb(), "Meta Payload")
if xml_len >= 4 then
if xml_encrypt(xml_buffer(0,5):bytes(), header.enc_offset):raw() == "<?xml" then -- Encrypted xml found
if xml_decrypt(xml_buffer(0,5):bytes(), header.enc_offset):raw() == "<?xml" then -- Encrypted xml found
local ba = xml_buffer:bytes()
local decrypted = xml_encrypt(ba, header.enc_offset)
local decrypted = xml_decrypt(ba, header.enc_offset)
body_tvb = decrypted:tvb("Decrypted XML (in Meta Payload)")
-- Create a tree item that, when clicked, automatically shows the tab we just created
body:add(body_tvb(), "Decrypted XML (in Meta Payload)")
@@ -293,11 +310,11 @@ function process_body(header, body_buffer, bc_subtree, pinfo)
local bin_len = header.msg_len - header.bin_offset
if bin_len > 0 then
local binary_buffer = body_buffer(header.bin_offset, bin_len) -- Don't extend beyond msg size
body_tvb = binary_buffer:tvb("Main Payload");
local body_tvb = binary_buffer:tvb("Main Payload");
body:add(body_tvb(), "Main Payload")
if bin_len > 4 then
if xml_encrypt(binary_buffer(0,5):bytes(), header.enc_offset):raw() == "<?xml" then -- Encrypted xml found
local decrypted = xml_encrypt(binary_buffer:bytes(), header.enc_offset)
if xml_decrypt(binary_buffer(0,5):bytes(), header.enc_offset):raw() == "<?xml" then -- Encrypted xml found
local decrypted = xml_decrypt(binary_buffer:bytes(), header.enc_offset)
body_tvb = decrypted:tvb("Decrypted XML (in Main Payload)")
-- Create a tree item that, when clicked, automatically shows the tab we just created
body:add(body_tvb(), "Decrypted XML (in Main Payload)")
@@ -314,10 +331,160 @@ function process_body(header, body_buffer, bc_subtree, pinfo)
end
end
function bc_protocol.dissector(buffer, pinfo, tree)
length = buffer:len()
if length == 0 then return end
-- UDP CONTENT
local udp_fragments = {}
local function rshift(x, by)
return math.floor(x / 2 ^ by)
end
local function udp_decrypt(data, tid)
local result = ByteArray.new()
result:set_size(data:len())
local key = {
0x1f2d3c4b, 0x5a6c7f8d,
0x38172e4b, 0x8271635a,
0x863f1a2b, 0xa5c6f7d8,
0x8371e1b4, 0x17f2d3a5
}
for i=1, 8 do
key[i] = key[i] + tid
end
local i = data:len() + 3
if i < 0 then
i = data:len() + 6
end
for x=0, rshift(i, 2) do
local index = bit32.band(x, 7)
local xor_key_word = key[index + 1]
for b=0, 3 do
local byte_index = x * 4 + b
local val = data:get_index(byte_index)
local key_byte = bit32.extract(xor_key_word, b*8, 8)
val = bit32.bxor(key_byte, val)
result:set_index(byte_index, val)
if byte_index >= data:len() - 1 then
return result
end
end
end
return result
end
local function get_udp_header_len(buffer)
local udpmagic = buffer(1, 3):le_uint()
if not udpmagic == 0x2a87cf then
return 0
else
local udptype = buffer(0, 1):le_uint()
if udptype == 0x3a then
return 20
elseif udptype == 0x31 then
return 20
elseif udptype == 0x20 then
return 28
elseif udptype == 0x10 then
return 20
else
return -1
end
end
end
local function get_udp_header(buffer)
local udp_class = buffer(0, 1):le_uint()
local l_udp_magic = buffer(1, 3):le_uint()
local length = get_udp_header_len(buffer)
local l_udp_size = nil
local udp_unknown1 = nil
local l_udp_tid = nil
local l_udp_checksum = nil
local udp_unknown2 = nil
local udp_unknown3 = nil
local udp_unknown4 = nil
local l_udp_last_ack_packet = nil
local l_udp_ack_payload_size = nil
local l_udp_connection_id = nil
local l_udp_packet_count = nil
if udp_class == 0x3a then
l_udp_size = buffer(4, 4):le_uint()
udp_unknown1 = buffer(8, 4):le_uint()
l_udp_tid = buffer(12, 4):le_uint()
l_udp_checksum = buffer(16, 4):le_uint()
elseif udp_class == 0x31 then
l_udp_size = buffer(4, 4):le_uint()
udp_unknown1 = buffer(8, 4):le_uint()
l_udp_tid = buffer(12, 4):le_uint()
l_udp_checksum = buffer(16, 4):le_uint()
elseif udp_class == 0x20 then
l_udp_connection_id = buffer(4, 4):le_uint()
udp_unknown1 = buffer(8, 4):le_uint()
udp_unknown2 = buffer(12, 4):le_uint()
l_udp_last_ack_packet = buffer(16, 4):le_uint()
udp_unknown3 = buffer(20, 4):le_uint()
l_udp_ack_payload_size = buffer(24, 4):le_uint()
elseif udp_class == 0x10 then
l_udp_connection_id = buffer(4, 4):le_uint()
udp_unknown1 = buffer(8, 4):le_uint()
l_udp_packet_count = buffer(12, 4):le_uint()
l_udp_size = buffer(16, 4):le_uint()
end
return {
length = length,
class = udp_class,
magic = l_udp_magic,
payload_size = l_udp_size,
unknown1 = udp_unknown1,
unknown2 = udp_unknown2,
unknown3 = udp_unknown3,
unknown4 = udp_unknown4,
tid = l_udp_tid,
checksum = l_udp_checksum,
connection_id = l_udp_connection_id,
packet_count = l_udp_packet_count,
last_ack_packet = l_udp_last_ack_packet,
ack_payload_size = l_udp_ack_payload_size
}
end
local function process_udp_header(buffer, headers_tree)
local header_data = get_udp_header(buffer)
local header = headers_tree:add(bc_protocol, buffer(0, header_data.length),
"Baichuan UDP Header, length: " .. header_data.length .. ", type " .. header_data.class)
header:add_le(udp_magic, buffer(0,4))
header:add_le(udp_type, buffer(0,1))
if header_data.class == 0x3a then
header:add_le(udp_size, buffer(4, 4))
header:add_le(udp_unknown,buffer(8, 4))
header:add_le(udp_tid, buffer(12, 4))
header:add_le(udp_checksum, buffer(16, 4))
elseif header_data.class == 0x31 then
header:add_le(udp_size, buffer(4, 4))
header:add_le(udp_unknown,buffer(8, 4))
header:add_le(udp_tid, buffer(12, 4))
header:add_le(udp_checksum, buffer(16, 4))
elseif header_data.class == 0x20 then
header:add_le(udp_connection_id, buffer(4, 4))
header:add_le(udp_unknown, buffer(8, 4))
header:add_le(udp_unknown, buffer(12, 4))
header:add_le(udp_last_ack_packet, buffer(16, 4))
header:add_le(udp_unknown, buffer(20, 4))
header:add_le(udp_ack_payload_size, buffer(24, 4))
elseif header_data.class == 0x10 then
header:add_le(udp_connection_id, buffer(4, 4))
header:add_le(udp_unknown, buffer(8, 4))
header:add_le(udp_packet_count, buffer(12, 4))
header:add_le(udp_size, buffer(16, 4))
end
return header_data.length
end
local function process_bc_message(buffer, pinfo, tree)
pinfo.cols.protocol = bc_protocol.name
local sub_buffer = buffer
@@ -327,48 +494,20 @@ function bc_protocol.dissector(buffer, pinfo, tree)
local continue_loop = true
while ( continue_loop )
do
-- Get min bytes for a magic and header len
if sub_buffer:len() < 20 then
-- Need more bytes but we don't have a header to learn how many bytes
pinfo.desegment_len = DESEGMENT_ONE_MORE_SEGMENT
pinfo.desegment_offset = 0
pinfo.cols['info'] = "Need more header"
return
end
local header_len = get_header_len(sub_buffer(0, nil))
header_len = get_header_len(sub_buffer(0, nil))
if header_len >= 0 then
pinfo.cols['info'] = "Valid header"
-- Valid magic and header found
-- Ensure min bytes for full header
if sub_buffer:len() < header_len then
pinfo.cols['info'] = "Need even more header"
-- Need more bytes
pinfo.desegment_len = header_len - sub_buffer:len()
pinfo.desegment_offset = 0
return buffer:len()
end
local header = get_header(sub_buffer(0, nil))
table.insert(table_msg_type_str, header.msg_type_str)
table.insert(table_msg_type, header.msg_type)
-- Get full header and body
local full_body_len = header.msg_len + header.header_len
if sub_buffer:len() < full_body_len then
-- need more bytes,
-- from https://wiki.wireshark.org/Lua/Dissectors#TCP_reassembly
pinfo.cols['info'] = "Need more body: " .. sub_buffer:len() .. " expected " .. full_body_len
pinfo.desegment_len = full_body_len - sub_buffer:len()
pinfo.desegment_offset = 0
return buffer:len()
end
local remaining = sub_buffer:len() - header.header_len
local bc_subtree = tree:add(bc_protocol, sub_buffer(0, header.msg_len),
local bc_subtree = tree:add(bc_protocol, sub_buffer(0, header.full_body_len),
"Baichuan IP Camera Protocol, " .. header.msg_type_str .. ":" .. header.msg_type .. " message")
process_header(sub_buffer, bc_subtree)
if header.header_len < sub_buffer:len() then
@@ -382,19 +521,260 @@ function bc_protocol.dissector(buffer, pinfo, tree)
if remaining == 0 then
continue_loop = false
else
pinfo.cols['info'] = "Another packet"
sub_buffer = sub_buffer(full_body_len, nil)
end
else
pinfo.cols['info'] = "Invalid magic"
return -- Not a valid header
return
end
end
local msg_type_strs = table.concat(table_msg_type_str, ",")
local msg_types = table.concat(table_msg_type, ",")
pinfo.cols['info'] = msg_type_strs .. ", type " .. msg_types
return
end
DissectorTable.get("tcp.port"):add(9000, bc_protocol)
DissectorTable.get("tcp.port"):add(52941, bc_protocol) -- change to your own custom port
local function is_complete_bc_message(buffer)
local length = buffer:len()
if length == 0 then
return "DONE"
end
local sub_buffer = buffer
local continue_loop = true
while ( continue_loop )
do
-- Get min bytes for a magic and header len
if sub_buffer:len() < 20 then
-- Need more bytes but we don't have a header to learn how many bytes
return "+1"
end
local header_len = get_header_len(sub_buffer(0, nil))
if header_len >= 0 then
-- Valid magic and header found
-- Ensure min bytes for full header
if sub_buffer:len() < header_len then
-- Need more bytes
return header_len - sub_buffer:len()
end
local header = get_header(sub_buffer(0, nil))
-- Get full header and body
local full_body_len = header.msg_len + header.header_len
if sub_buffer:len() < full_body_len then
return full_body_len - sub_buffer:len()
end
local remaining = sub_buffer:len() - header.header_len
if header.header_len < sub_buffer:len() then
local body_buffer = sub_buffer(header.header_len, nil)
remaining = body_buffer:len() - header.msg_len
end
-- Remaning bytes?
if remaining == 0 then
continue_loop = false
else
sub_buffer = sub_buffer(full_body_len, sub_buffer:len() - full_body_len)
end
else
return "NOMAGIC"
end
end
return "DONE"
end
local function udp_reassemple(udp_header, subbuffer, more, pinfo, tree)
-- Cache udp message for later lookup
local con_id = udp_header.connection_id
if udp_fragments[con_id] == nil then
udp_fragments[con_id] = {}
end
local mess_id = udp_header.packet_count
if udp_fragments[con_id][mess_id] == nil then
udp_fragments[con_id][mess_id] = {}
end
udp_fragments[con_id][mess_id]['result'] = more
udp_fragments[con_id][mess_id]['message_id'] = mess_id
udp_fragments[con_id][mess_id]['buffer'] = subbuffer:bytes()
-- Go backwards from current ID until:
-- I hit a result that is not NOMAGIC
-- Can be myself
local start_idx = mess_id
local start_fragment = udp_fragments[con_id][start_idx]
while start_fragment.result == "NOMAGIC" do
start_idx = start_idx -1
start_fragment = udp_fragments[con_id][start_idx]
if start_fragment == nil then
break
end
end
if start_fragment ~= nil then -- Found a starting fragment
local needed = start_fragment.result
if needed == "DONE" then
if start_fragment.message_id == udp_header.packet_count then
process_bc_message(start_fragment.buffer:tvb(), pinfo, tree)
end
elseif needed == "+1" then
-- Cannot handle in UDP...
-- Only happens in off chance not enough data for
-- even the header
-- Never observed to date
return
else
-- pinfo.cols['info'] = "SEARCHING"
local next_id = start_fragment.message_id + 1
local reassembled = ByteArray.new()
local total_packet = 1
reassembled = reassembled .. start_fragment.buffer
local target_len = reassembled:len() + start_fragment.result
while reassembled:len() < target_len do
local next_fragment = udp_fragments[con_id][next_id]
if next_fragment ~= nil then
reassembled = reassembled .. next_fragment.buffer
total_packet = total_packet + 1
else
break
end
end
if reassembled:len() >= target_len then
start_fragment.result = "DONE"
process_bc_message(reassembled:tvb("Reassembled UDP"), pinfo, tree)
end
end
end
end
function bc_protocol.init ()
udp_fragments = {}
end
function bc_protocol.dissector(buffer, pinfo, tree)
local subbuffer = nil
local udp_header = nil
if pinfo.can_desegment == 0 then -- UDP
local udp_header_len = get_udp_header_len(buffer)
if udp_header_len > 0 then
udp_header = get_udp_header(buffer(0, udp_header_len))
process_udp_header(buffer(0, udp_header_len), tree)
if udp_header.class == 0x3a then
local decrypted_bytes = udp_decrypt(buffer(udp_header_len, nil):bytes(), udp_header.tid)
local decryped_tvb = decrypted_bytes:tvb("UDP Decrypted Message")
local subtree = tree:add(bc_protocol, decryped_tvb, "UDP Message Data")
Dissector.get("xml"):call(decryped_tvb, pinfo, subtree)
pinfo.cols.protocol = bc_protocol.name .. " UDP Heartbeat"
elseif udp_header.class == 0x31 then
pinfo.cols.protocol = bc_protocol.name .. " UDP Relay"
elseif udp_header.class == 0x20 then
pinfo.cols.protocol = bc_protocol.name .. " UDP ACK"
if udp_header.ack_payload_size > 0 then
tree:add(bc_protocol, buffer(28,udp_header.ack_payload_size), "BcUdp Ack Payload")
end
else
subbuffer = buffer(udp_header_len, nil)
end
else
subbuffer = buffer(udp_header_len, nil)
end
else
subbuffer = buffer
end
if subbuffer ~= nil then
local more = is_complete_bc_message(subbuffer)
if pinfo.can_desegment == 1 then -- TCP can use the desegment method
if more == "DONE" then
process_bc_message(subbuffer, pinfo, tree)
return
elseif more == "+1" then
pinfo.desegment_len = DESEGMENT_ONE_MORE_SEGMENT
pinfo.desegment_offset = 0
return subbuffer:len()
elseif more == "NOMAGIC" then
return
else
pinfo.desegment_len = more
pinfo.desegment_offset = 0
return subbuffer:len()
end
else -- UDP can not use the desegment method, must reassemble manually
if udp_header ~= nil then
if udp_header.class == 0x10 then -- Continuable udp class
udp_reassemple(udp_header, subbuffer, more, pinfo, tree)
end
end
end
end
end
--- END UDP CONTENT
local added_udp_ports = {}
local function heuristic_checker_udp(buffer, pinfo, tree)
-- guard for length
local length = buffer:len()
if length < 4 then return false end
local potential_magic = buffer(0,4):le_uint()
if potential_magic ~= 0x2a87cf3a and
potential_magic ~= 0x2a87cf20 and
potential_magic ~= 0x2a87cf10 and
potential_magic ~= 0x2a87cf31 then
return false
end
if added_udp_ports[pinfo.dst_port] == nil then
table.insert(added_udp_ports, pinfo.dst_port)
DissectorTable.get("udp.port"):add(pinfo.dst_port, bc_protocol)
end
if added_udp_ports[pinfo.src_port] == nil then
table.insert(added_udp_ports, pinfo.src_port)
DissectorTable.get("udp.port"):add(pinfo.src_port, bc_protocol)
end
bc_protocol.dissector(buffer, pinfo, tree)
return true
end
local added_tcp_ports = {}
local function heuristic_checker_tcp(buffer, pinfo, tree)
-- guard for length
local length = buffer:len()
if length < 4 then return false end
local potential_magic = buffer(0,4):le_uint()
if potential_magic ~= 0x0abcdef0 and
potential_magic ~= 0x0fedcba0 then
return false
end
if added_tcp_ports[pinfo.dst_port] == nil then
table.insert(added_tcp_ports, pinfo.dst_port)
DissectorTable.get("tcp.port"):add(pinfo.dst_port, bc_protocol)
end
if added_tcp_ports[pinfo.src_port] == nil then
table.insert(added_tcp_ports, pinfo.src_port)
DissectorTable.get("tcp.port"):add(pinfo.src_port, bc_protocol)
end
bc_protocol.dissector(buffer, pinfo, tree)
return true
end
bc_protocol:register_heuristic("udp", heuristic_checker_udp)
bc_protocol:register_heuristic("tcp", heuristic_checker_tcp)
-- DissectorTable.get("tcp.port"):add(53959, bc_protocol) -- change to your own custom port
-- DissectorTable.get("udp.port"):add(2000, bc_protocol)
-- DissectorTable.get("udp.port"):add(2015, bc_protocol)
-- DissectorTable.get("udp.port"):add(2018, bc_protocol)
-- DissectorTable.get("udp.port"):add(2000, bc_protocol)
-- DissectorTable.get("udp.port"):add(9999, bc_protocol)
+161 -144
View File
File diff suppressed because it is too large. Load diff
+69 -36
View File
@@ -16,9 +16,9 @@ Each message has the general format:
The header has the format:
| magic | message id | message length | encryption offset | encrypt | unknown | message class |
|--------------|--------------|----------------|-------------------|---------|---------|---------------|
| f0 de bc 0a | 01 00 00 00 | 2c 07 00 00 | 00 00 00 01 | 01 | dc | 14 65 |
| magic | message id | message length | encryption offset | encrypt | message class |
|--------------|--------------|----------------|-------------------|------------|---------------|
| f0 de bc 0a | 01 00 00 00 | 2c 07 00 00 | 00 00 00 01 | 01 dc | 14 65 |
- Magic 4 bytes
- ID 4 bytes
@@ -30,9 +30,9 @@ The header has the format:
Or
| Magic | Message ID | Message Length | Encryption Offset | Status Code | Message Class | Binary Offset |
|--------------|--------------|----------------|-------------------|-------------------|---------------|---------------|
| f0 de bc 0a | 01 00 00 00 | 28 01 00 00 | 00 00 00 01 | c8 00 | 14 64 | 00 00 00 00 |
| Magic | Message ID | Message Length | Encryption Offset | Status Code | Message Class | Payload Offset |
|--------------|--------------|----------------|-------------------|-------------------|---------------|----------------|
| f0 de bc 0a | 01 00 00 00 | 28 01 00 00 | 00 00 00 01 | c8 00 | 14 64 | 00 00 00 00 |
- Magic 4 bytes
@@ -97,17 +97,24 @@ message_handle 1 byte - client increments per request, replies use request handl
#### Encryption Flag
This flag is 0 for unencrypted or non zero for encrypted.
Client will send the number `0xXXdc` and the server will reply `0xXXdd`.
Where `XX` is one of the following.
Clients should decide to use encryption or not based on this byte that the
camera sent during login. Then should use that same setting for all further
messages with the camera.
- 0 Unencrypted
- 1 BC Encryption
- 2 AES Encryption (Camera)
- 3 AES Encryption (Client)
#### Unknown
`dc` means this encryption protol or lower. So `0x01dc` means BC on no encryption
whereas `0x03dc` means AES, BC or Unencrypted.
The purpose of this byte is unknown.
Observed - `dc` = client request, `dd` = device reply
If you figure out what it does please submit a PR.
`dd` is the reply that the camera sends to the `dc` request. It is the chosen
protocol that will be used.
**Note:** When requesting AES the client sends `0x03dc` and the camera replies `0x02dc`.
We are not sure why.
Encryption is negotiated in the login request.
#### Status Code
@@ -129,20 +136,13 @@ and header lengths are known.
- 0x0000: "modern" 24 bytes
#### Binary offset
#### Payload offset
For messages that contain the binary offset field this represents where to start
the binary part of the message. The total length of XML + binary is equal
to the message length in the header so Binary Offset is
total_length - this_offset. Where as this field also represents the end of the
XML part of the message.
Some messages seems to not set this field correctly. For example message ID 1
sets this to zero meaning that all data in the message is binary, however
it contains XML. This best way to tell is this is binary or XML is to check the
message ID and determine from there. Alternatively you could look for `<xml?` at
the beginning of the message (although may need to decrypt first for this to
work)
For messages that contain the payload offset field this represents where to start
the payload part of the message. The total length of the message
(extension XML + payload) is equal to the message length in the header
so Payload Offset is total_length - this_offset. Where as this field also represents the end of the
extension XML part of the message.
# Login
@@ -189,10 +189,12 @@ streamType can be either
channelId is part of the NVR when multiple cameras use the same IP. In this
case each camera has its own channelId.
Not sure what handle does.
The `handle` is used when multiple streams are requested in a single login.
This number should be unique for each stream. If not then that stream
(Clear or Fluent) will not work until the camera is reset.
The reply is first a message with the following xml
The reply is first a message with the following Extension Xml
```xml
<?xml version="1.0" encoding="UTF-8" ?>
@@ -203,7 +205,7 @@ The reply is first a message with the following xml
After which all message bodies of type id 3 are binary.
The binary represents a stream of data. It can be interrupted by packet
The binary represents a stream of data that can be interrupted by packet
boundaries. Clients should create a buffer and pop bytes for processing when
complete media packets are received. Media packets descriptions can be found in
the [docs](dissector/mediapacket.md)
@@ -213,9 +215,9 @@ the [docs](dissector/mediapacket.md)
Other data can be received from the camera by sending the appropriate header to
the camera. For example sending the header for ID 78
| Magic | Message ID | Message Length | Encryption Offset | Status Code | Message Class | Binary Offset |
|--------------|--------------|----------------|-------------------|-------------------|---------------|---------------|
| f0 de bc 0a | 4e 00 00 00 | d3 00 00 00 | 08 db 9c 00 | c8 00 | 00 00 | 00 00 00 00 |
| Magic | Message ID | Message Length | Encryption Offset | Status Code | Message Class | Payload Offset |
|--------------|--------------|----------------|-------------------|-------------------|---------------|----------------|
| f0 de bc 0a | 4e 00 00 00 | d3 00 00 00 | 08 db 9c 00 | c8 00 | 00 00 | 00 00 00 00 |
The camera will reply with an xml with brightness and contrast
@@ -236,9 +238,9 @@ Some message IDs also require input along with the request header. For example
ID 151 which is the users ability info requires the header
| Magic | Message ID | Message Length | Encryption Offset | Status Code | Message Class | Binary Offset |
|--------------|--------------|----------------|-------------------|-------------------|---------------|---------------|
| f0 de bc 0a | 97 00 00 00 | a7 00 00 00 | 00 00 00 02 | 00 00 | 14 64 | a7 00 00 00 |
| Magic | Message ID | Message Length | Encryption Offset | Status Code | Message Class | Payload Offset |
|--------------|--------------|----------------|-------------------|-------------------|---------------|----------------|
| f0 de bc 0a | 97 00 00 00 | a7 00 00 00 | 00 00 00 02 | 00 00 | 14 64 | a7 00 00 00 |
and the body of
@@ -255,3 +257,34 @@ abilities you want to know about.
Details of expected formats should be found from the
[docs](dissector/messages.md)
#### AES Encryption
If the encryption flag returned from the camera is `0x02dd` then AES encryption will be used.
The cameras use AES cfb128 with an IV of `0123456789abcdef` the key is made as follows
- Concatenated the `NONCE` from login with a `-` then with your plain text password
- MD5 Hash this concatenated string
- Represent the hash as hex string in all caps
- Take the first 16 characters as the encryption key
Here is an example:
```rust
use aes::Aes128;
use cfb_mode::cipher::{NewStreamCipher, StreamCipher};
use cfb_mode::Cfb;
const IV: &[u8] = b"0123456789abcdef";
let key_phrase = format!("{}-{}", nonce, passwd);
let key_phrase_hash = format!("{:X}\0", md5::compute(&key_phrase))
.to_uppercase()
.into_bytes();
let key = key_phrase_hash[0..16];
let mut decrypted = encrypted.to_vec();
Cfb::<Aes128>::new(key.into(), IV.into()).decrypt(&mut decrypted);
return decrypted;
```
+297
View File
@@ -0,0 +1,297 @@
# BcUDP
This document describes the UDP protocol. UDP, unlike TCP, is lossy, there
is no guarantee that all packets sent will be received or that they are received
in the same order. As such the protocol involves sending meta data back and forth
where the camera and client acknowledge packets they have received.
Additionally the UDP max data size is smaller so packets will be split more
perhaps even several UDP packets per BC message, whereas in TCP the Bc messages were
always in one TCP packet.
# Packets Types
There are three types of UDP packets with their own header
- UDP Discovery: These packets have the magic `3acf872a` and contain encrypted
xml about the connection that will be used
- UDP Ack: These packets have the magic `20cf872a` they are header only and
contain acknowledgement of packets
- UDP Data: These packets contain part of a BC messagse with a special UDP
header that describes the udp message number, to help reassemble
the packets. They have the magic: `10cf872a`
# UDP Discovery
These messages are sent as part of the initial connection discovery.
It is a sequence of messages with different xmls.
If there is no reply is received within 500ms the last message is resent.
## Header 20 Bytes
- 4 Bytes magic: `3acf872a`
- 4 Bytes data size: Size in bytes of payload
- 4 Bytes unknown: Always `01000000` for for UDP Discovery
- 4 Bytes Transmission ID: The unique ID of the transmission, every successful
round trip of Discovery it is incremented.
The number is the same for the same transmission
and may be used to identify repeated messages.
It is also used for the encryption.
- 4 Bytes Checksum: The checksum of the payload encrypted payload
The checksum can be calculated with a polynomial of `0x04c11db7`, an init value
of `0x00000000` and an xorout of `0x00000000`.
## Payload
- The XML payloads are encrypted with a simple xor algorithm. See the full
source in neolink for details.
## Start Discovery payload
Client send this packet as a broadcast on 255.255.255.255 on port 2015
to init a connection
```xml
<P2P>
<C2D_S>
<to>
<port>57268</port>
</to>
</C2D_S>
</P2P>
```
It also sends this binary on port 2000 as a broadcast
```
aaaa0000
```
---
**Camera Replies with Binary**
Camera replies with binary data to port 3000
This data seems to include the
- Camera name
- ip address
- TCP port
- Camera UID
**Tcp camera**
If the camera supports tcp the client will use this binary data to open a
standard tcp bc connection
**Udp Camera**
If the camera supports UDP the client will send the following xml packet
as a broadcast on 255.255.255.255 on port 2018/2015
**Known UID**
If the UID is already known you can skip to this step.
```xml
<P2P>
<C2D_C>
<uid>95270000YGAKNWKJ</uid>
<cli>
<port>24862</port>
</cli>
<cid>849013</cid>
<mtu>1350</mtu>
<debug>0</debug>
<p>MAC</p>
</C2D_C>
</P2P>
```
**Both**
A camera can do both of the above. In this case it will try to login
to both udp and tcp. Then the udp will disconnect.
---
## D2C_C_R Payload Camera
Camera replies with this payload on the port specified in `C2D_C`
```xml
<P2P>
<D2C_C_R>
<timer>
<def>3000</def>
<hb>10000</hb>
<hbt>60000</hbt>
</timer>
<rsp>0</rsp>
<cid>849013</cid>
<did>192</did>
</D2C_C_R>
</P2P>
```
- **timer** Unknown timer of some sort`
- **rsp**: Unknown
- **cid**: The connection ID of the client
- **did**: The connection ID of the camera
## T Payload Client
Client then replies with this.
```xml
<P2P>
<C2D_T>
<sid>62097899</sid>
<conn>local</conn>
<cid>82000</cid>
<mtu>1350</mtu>
</C2D_T>
</P2P>
```
- **sid**: ID of the camera
- **conn**: Type of connection only observed `local` value
- **cid**: The connection ID of the client
- **did**: The connection ID of the camera
- **mtu**: The maximum transmission unit of the connection. Which is the
largest packet size in bytes
## T Payload Camera
Camera replies with this payload on the port specified in `C2D_C`
```xml
<P2P>
<D2C_T>
<sid>62097899</sid>
<conn>local</conn>
<cid>82000</cid>
<did>528</did>
</D2C_T>
</P2P>
```
**Login**
The client can now login over UDP
## Dissconnect
After a message ID 02 (logout) the client send this
```xml
<P2P>
<C2D_DISC>
<cid>82000</cid>
<did>80</did>
</C2D_DISC>
</P2P>
```
- **cid**: The connection ID of the client
- **did**: The connection ID of the camera
The camera also send it but with a `D2C_DISC` tag
## Other
Some cameras seem to also send this before login
```xml
<P2P>
<D2C_CFM>
<sid>62097899</sid>
<conn>local</conn>
<rsp>0</rsp>
<cid>82000</cid>
<did>80</did>
<time_r>0</time_r>
</D2C_CFM>
</P2P>
```
- **sid**: ID of the camera
- **conn**: Type of connection only observed `local` value
- **rsp**: Unknown always 0
- **cid**: The connection ID of the client
- **did**: The connection ID of the camera
- **time_r**: Should be the time but it is always 0
# UDP Ack
These messages are sent to acknowledge receipt of message
## Header 28 Bytes
- 4 Bytes magic: `20cf872a`
- 4 Bytes Connection ID: This is the connection ID negotiated during UDP Discovery
- 4 Bytes unknown: Always `00000000` for for UDP Ack
- 4 Bytes unknown: Always `00000000` for for UDP Ack
- 4 Bytes Last Packet ID: Last received packet id
- 4 Bytes Unknown: Observed values `00000000`, `d6010000`, `d7160000` `09e00000` **NEEDS INFO**
- Payload Size
- Paload
**To Investigate:**
- Why does the unknown byte change. It starts at zero and remains that way
for a second. Then seems to change and remain at the new value for another second.
This may be some metric such as average ttl for the last second, or some calculation
of the jitter
Here's an example of a UDP Ack payload (size 203 bytes)
```hex
0000 00 01 01 01 01 01 01 01 01 01 01 01 00 01 01 01
0010 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01
0020 01 01 01 01 00 01 01 01 01 01 01 01 01 01 01 01
0030 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01
0040 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01
0050 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01
0060 01 01 01 01 01 01 00 01 01 01 01 01 01 01 01 01
0070 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01
0080 01 01 01 01 01 01 01 01 01 01 00 01 01 01 01 01
0090 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01
00a0 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01
00b0 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01
00c0 01 01 01 01 01 01 01 01 01 01 01 01
```
The payload is a truth table. If the packet ID in header is 50
then the first byte corresponds to packet id 51, the second 52
etc etc. If the byte if `00` then the camera will resend that packet
If this payload is allowed to grow to ~ 205 bytes the camera sends a
disconnect request and drops the connection
# UDP Data
UDP data packets contain the BC packets with an extra header.
Whenever a packet is received a UDP Ack is sent. If the sender of the packet
does not get the Ack within 1000ms it resends the packet
## Header 20 Bytes
- 4 Bytes magic: `10cf872a`
- 4 Bytes Connection ID: This is the connection ID negotiated during UDP Discovery
- 4 Bytes unknown: Always `00000000` for for UDP Data
- 4 Bytes Packet ID: The ID of the packet mono-atomically increases for each new packet
- 4 Bytes Payload Size: Size of UDP payload in bytes
## Payload
The payload is a standard Bc Packet
Binary file not shown.

Before

Width:  |  Height:  |  Size: 92 KiB

After

Width:  |  Height:  |  Size: 155 KiB

-1
View File
@@ -42,7 +42,6 @@ Here are some examples for commands of package managers
libgstrtspserver-1.0-0 \
libgstreamer1.0-0 \
libgstreamer-plugins-bad1.0-0 \
libgstreamer-plugins-good1.0-0 \
gstreamer1.0-plugins-good \
gstreamer1.0-plugins-bad
```
+13 -3
View File
@@ -14,7 +14,7 @@ bind = "0.0.0.0"
# Choose if the client is required to provide a certificate signed by the server's CA.
# none|requested|required - default none
# tls_client_auth = "required"
# tls_client_auth = "required"
# You can password protect the rtsp server mount points by adding users
# like the following me and someone. If you do not add [[users]]
@@ -35,6 +35,9 @@ name = "driveway"
username = "admin"
password = "12345678"
address = "192.168.1.187:9000"
# If you use a battery camera: **Instead** of an `address` supply the uid
# as follows
# uid = "ABCD01234567890EFG"
# By default any of the users can connect (or anyone at all if no users are specfied)
# You can uncomment the following to permit only specfic users
@@ -50,7 +53,14 @@ name = "storage shed"
username = "admin"
password = "987654321"
address = "192.168.1.245:9000"
# If you use a battery camera: **Instead** of an `address` supply the uid
# as follows
# uid = "ABCD01234567890EFG"
# If you use an NVR that relays several camera connections you can choose which
# camera to connect to with by setting the `channel_id`
#
# By default channel_id = 0. Eg the first connected camera on the device
# Note this counts from 0. An 8 channel NVR would have channels 0 through 7
# channel_id = 1
# **Note**: that unlike in the offical client the numbering starts from 0 not 1.
# An 8 channel NVR would have channels 0 through 7
# channel_id = 0
+10 -3
View File
@@ -1,11 +1,18 @@
use structopt::StructOpt;
use std::path::PathBuf;
use structopt::{clap::AppSettings, StructOpt};
/// A standards-compliant bridge to Reolink IP cameras
#[derive(StructOpt, Debug)]
#[structopt(name = "neolink")]
#[structopt(
name = "neolink",
setting(AppSettings::ArgRequiredElseHelp),
setting(AppSettings::UnifiedHelpMessage)
)]
pub struct Opt {
#[structopt(short, long, global(true), parse(from_os_str))]
pub config: Option<PathBuf>,
#[structopt(subcommand)]
pub cmd: Command,
pub cmd: Option<Command>,
}
#[derive(StructOpt, Debug)]
+19 -2
View File
@@ -7,7 +7,8 @@ use validator::{Validate, ValidationError};
use validator_derive::Validate;
lazy_static! {
static ref RE_STREAM_SRC: Regex = Regex::new(r"^(mainStream|subStream|both)$").unwrap();
static ref RE_STREAM_SRC: Regex =
Regex::new(r"^(mainStream|subStream|externStream|both|all)$").unwrap();
static ref RE_TLS_CLIENT_AUTH: Regex = Regex::new(r"^(none|request|require)$").unwrap();
}
@@ -40,11 +41,15 @@ pub(crate) struct Config {
}
#[derive(Debug, Deserialize, Validate, Clone)]
#[validate(schema(function = "validate_camera_config"))]
pub(crate) struct CameraConfig {
pub(crate) name: String,
#[serde(rename = "address")]
pub(crate) camera_addr: String,
pub(crate) camera_addr: Option<String>,
#[serde(rename = "uid")]
pub(crate) camera_uid: Option<String>,
pub(crate) username: String,
pub(crate) password: Option<String>,
@@ -114,3 +119,15 @@ fn validate_username(name: &str) -> Result<(), ValidationError> {
}
Ok(())
}
fn validate_camera_config(camera_config: &CameraConfig) -> Result<(), ValidationError> {
match (&camera_config.camera_addr, &camera_config.camera_uid) {
(None, None) => Err(ValidationError::new(
"Either camera address or uid must be given",
)),
(Some(_), Some(_)) => Err(ValidationError::new(
"Must provide either camera address or uid not both",
)),
_ => Ok(()),
}
}
+33 -11
View File
@@ -7,22 +7,26 @@
//! It contains sub commands for running an rtsp proxy which can be used on Reolink cameras
//! that do not nativly support RTSP.
//!
use anyhow::{Context, Result};
use env_logger::Env;
use log::*;
use std::fs;
use structopt::StructOpt;
use validator::Validate;
mod cmdline;
mod errors;
mod config;
mod mqtt;
mod reboot;
mod rtsp;
mod statusled;
mod talk;
mod utils;
use cmdline::{Command, Opt};
use errors::Error;
use config::Config;
fn main() -> Result<(), Error> {
fn main() -> Result<()> {
env_logger::Builder::from_env(Env::default().default_filter_or("info")).init();
info!(
@@ -33,18 +37,36 @@ fn main() -> Result<(), Error> {
let opt = Opt::from_args();
let conf_path = opt.config.context("Must supply --config file")?;
let config: Config = toml::from_str(
&fs::read_to_string(&conf_path)
.with_context(|| format!("Failed to read {:?}", conf_path))?,
)
.with_context(|| format!("Failed to parse the {:?} config file", conf_path))?;
config
.validate()
.with_context(|| format!("Failed to validate the {:?} config file", conf_path))?;
match opt.cmd {
Command::Rtsp(opts) => {
rtsp::main(opts)?;
None => {
warn!(
"Deprecated command line option. Please use: `neolink rtsp --config={:?}`",
config
);
rtsp::main(rtsp::Opt {}, config)?;
}
Command::StatusLight(opts) => {
statusled::main(opts)?;
Some(Command::Rtsp(opts)) => {
rtsp::main(opts, config)?;
}
Command::Reboot(opts) => {
reboot::main(opts)?;
Some(Command::StatusLight(opts)) => {
statusled::main(opts, config)?;
}
Command::Talk(opts) => {
talk::main(opts)?;
Some(Command::Reboot(opts)) => {
reboot::main(opts, config)?;
}
Some(Command::Talk(opts)) => {
talk::main(opts, config)?;
}
Command::Mqtt(opts) => {
mqtt::main(opts)?;
-4
View File
@@ -1,12 +1,8 @@
use std::path::PathBuf;
use structopt::StructOpt;
/// The reboot command will reboot the camera
#[derive(StructOpt, Debug)]
pub struct Opt {
/// The path to the config file
#[structopt(short, long, parse(from_os_str))]
pub config: PathBuf,
/// The name of the camera to change the lights of. Must be a name in the config
pub camera: String,
}
-29
View File
@@ -1,29 +0,0 @@
use serde::Deserialize;
use std::clone::Clone;
use validator::Validate;
use validator_derive::Validate;
#[derive(Debug, Deserialize, Validate, Clone)]
pub(crate) struct Config {
#[validate]
pub(crate) cameras: Vec<CameraConfig>,
}
#[derive(Debug, Deserialize, Validate, Clone)]
pub(crate) struct CameraConfig {
pub(crate) name: String,
#[serde(rename = "address")]
pub(crate) camera_addr: String,
pub(crate) username: String,
pub(crate) password: Option<String>,
#[validate(range(min = 0, max = 31, message = "Invalid channel", code = "channel_id"))]
#[serde(default = "default_channel_id")]
pub(crate) channel_id: u8,
}
fn default_channel_id() -> u8 {
0
}
-20
View File
@@ -1,20 +0,0 @@
use err_derive::Error;
/// The main error for the reboot subcommand
#[derive(Debug, Error)]
#[allow(clippy::large_enum_variant)]
pub enum Error {
/// Raised when the config file fails to deserlize
#[error(display = "Configuration parsing error")]
Config(#[error(source)] toml::de::Error),
/// Raised when `neolink_core` raises an error
#[error(display = "Communication error")]
Protocol(#[error(source)] neolink_core::Error),
/// Raised when there is an IO error such as unable to find
/// config file
#[error(display = "I/O error")]
Io(#[error(source)] std::io::Error),
/// Raised when the config file fails validataion
#[error(display = "Validation error")]
Validation(#[error(source)] validator::ValidationErrors),
}
+8 -40
View File
@@ -11,54 +11,22 @@
/// neolink reboot --config=config.toml CameraName
/// ```
///
use log::*;
use neolink_core::bc_protocol::BcCamera;
use std::fs;
use validator::Validate;
use anyhow::{Context, Result};
mod cmdline;
mod config;
mod errors;
use super::config::Config;
use crate::utils::find_and_connect;
pub(crate) use cmdline::Opt;
use config::Config;
pub(crate) use errors::Error;
/// Entry point for the reboot subcommand
///
/// Opt is the command line options
pub fn main(opt: Opt) -> Result<(), Error> {
let config: Config = toml::from_str(&fs::read_to_string(opt.config)?)?;
config.validate()?;
let mut cam_found = false;
for camera_config in &config.cameras {
if opt.camera == camera_config.name {
cam_found = true;
info!(
"{}: Connecting to camera at {}",
camera_config.name, camera_config.camera_addr
);
let mut camera =
BcCamera::new_with_addr(&camera_config.camera_addr, camera_config.channel_id)?;
info!("{}: Logging in", camera_config.name);
camera.login(&camera_config.username, camera_config.password.as_deref())?;
info!("{}: Connected and logged in", camera_config.name);
camera.reboot()?;
}
}
if !cam_found {
error!(
"No camera with the name {} was found in the config",
opt.camera
);
}
pub(crate) fn main(opt: Opt, config: Config) -> Result<()> {
let camera = find_and_connect(&config, &opt.camera)?;
camera
.reboot()
.context("Could not send reboot command to the camera")?;
Ok(())
}
+1 -6
View File
@@ -1,10 +1,5 @@
use std::path::PathBuf;
use structopt::StructOpt;
/// The rtsp command will serve all cameras in the config over the rtsp protocol
#[derive(StructOpt, Debug)]
pub struct Opt {
/// The path to the config file
#[structopt(short, long, parse(from_os_str))]
pub config: PathBuf,
}
pub struct Opt {}
-23
View File
@@ -1,23 +0,0 @@
use err_derive::Error;
/// The main error for the rtsp subcommand
#[derive(Debug, Error)]
#[allow(clippy::large_enum_variant)]
pub enum Error {
/// Raised when the config file fails to deserlize
#[error(display = "Configuration parsing error")]
Config(#[error(source)] toml::de::Error),
/// Raised when `neolink_core` raises an error
#[error(display = "Communication error")]
Protocol(#[error(source)] neolink_core::Error),
/// Raised when there is an IO error such as unable to find
/// config file
#[error(display = "I/O error")]
Io(#[error(source)] std::io::Error),
/// Raised when the config file fails validataion
#[error(display = "Validation error")]
Validation(#[error(source)] validator::ValidationErrors),
// Raised when there is an ADPCM decoding error
// #[error(display = "ADPCM Decoding Error")]
// AdpcmDecoding(&'static str),
}
+59 -31
View File
@@ -28,35 +28,28 @@
/// neolink rtsp --config=config.toml
/// ```
///
use anyhow::{Context, Result};
use log::*;
use neolink_core::bc_protocol::BcCamera;
use neolink_core::bc_protocol::{BcCamera, Stream};
use std::collections::HashSet;
use std::fs;
use std::sync::Arc;
use std::time::Duration;
use validator::Validate;
// mod adpcm;
/// The command line parameters for this subcommand
mod cmdline;
mod config;
/// The errors this subcommand can raise
mod errors;
mod gst;
use super::config::{CameraConfig, Config, UserConfig};
use crate::utils::AddressOrUid;
pub(crate) use cmdline::Opt;
use config::{CameraConfig, Config, UserConfig};
pub(crate) use errors::Error;
use gst::{GstOutputs, RtspServer, TlsAuthenticationMode};
/// Entry point for the rtsp subcommand
///
/// Opt is the command line options
pub fn main(opt: Opt) -> Result<(), Error> {
let config: Config = toml::from_str(&fs::read_to_string(opt.config)?)?;
config.validate()?;
pub(crate) fn main(_opt: Opt, config: Config) -> Result<()> {
let rtsp = &RtspServer::new();
set_up_tls(&config, rtsp);
@@ -83,7 +76,7 @@ pub fn main(opt: Opt) -> Result<(), Error> {
get_permitted_users(config.users.as_slice(), &arc_cam.permitted_users);
// Set up each main and substream according to all the RTSP mount paths we support
if ["both", "mainStream"].iter().any(|&e| e == arc_cam.stream) {
if ["all", "both", "mainStream"].iter().any(|&e| e == arc_cam.stream) {
let paths = &[
&*format!("/{}", arc_cam.name),
&*format!("/{}/mainStream", arc_cam.name),
@@ -92,16 +85,25 @@ pub fn main(opt: Opt) -> Result<(), Error> {
.add_stream(paths, &permitted_users)
.unwrap();
let main_camera = arc_cam.clone();
s.spawn(move |_| camera_loop(&*main_camera, "mainStream", &mut outputs, true));
s.spawn(move |_| camera_loop(&*main_camera, Stream::Main, &mut outputs, true));
}
if ["both", "subStream"].iter().any(|&e| e == arc_cam.stream) {
if ["all", "both", "subStream"].iter().any(|&e| e == arc_cam.stream) {
let paths = &[&*format!("/{}/subStream", arc_cam.name)];
let mut outputs = rtsp
.add_stream(paths, &permitted_users)
.unwrap();
let sub_camera = arc_cam.clone();
let manage = arc_cam.stream == "subStream";
s.spawn(move |_| camera_loop(&*sub_camera, "subStream", &mut outputs, manage));
s.spawn(move |_| camera_loop(&*sub_camera, Stream::Sub, &mut outputs, manage));
}
if ["all", "externStream"].iter().any(|&e| e == arc_cam.stream) {
let paths = &[&*format!("/{}/externStream", arc_cam.name)];
let mut outputs = rtsp
.add_stream(paths, &permitted_users)
.unwrap();
let sub_camera = arc_cam.clone();
let manage = arc_cam.stream == "externStream";
s.spawn(move |_| camera_loop(&*sub_camera, Stream::Extern, &mut outputs, manage));
}
}
@@ -114,7 +116,7 @@ pub fn main(opt: Opt) -> Result<(), Error> {
fn camera_loop(
camera_config: &CameraConfig,
stream_name: &str,
stream_name: Stream,
outputs: &mut GstOutputs,
manage: bool,
) -> Result<(), Error> {
@@ -156,7 +158,8 @@ fn camera_loop(
struct CameraErr {
connected: bool,
err: neolink_core::Error,
login_fail: bool,
err: anyhow::Error,
}
fn set_up_tls(config: &Config, rtsp: &RtspServer) {
@@ -206,13 +209,24 @@ fn get_permitted_users<'a>(
fn camera_main(
camera_config: &CameraConfig,
stream_name: &str,
stream_name: Stream,
outputs: &mut GstOutputs,
manage: bool,
) -> Result<(), CameraErr> {
let mut connected = false;
let mut login_fail = false;
(|| {
let mut camera = BcCamera::new_with_addr(&camera_config.camera_addr, camera_config.channel_id)?;
let camera_addr =
AddressOrUid::new(&camera_config.camera_addr, &camera_config.camera_uid).unwrap();
let mut camera =
camera_addr.connect_camera(camera_config.channel_id)
.with_context(|| {
format!(
"Failed to connect to camera {} at {} on channel {}",
camera_config.name, camera_addr, camera_config.channel_id
)
})?;
if camera_config.timeout.is_some() {
warn!("The undocumented `timeout` config option has been removed and is no longer needed.");
warn!("Please update your config file.");
@@ -220,31 +234,45 @@ fn camera_main(
info!(
"{}: Connecting to camera at {}",
camera_config.name, camera_config.camera_addr
camera_config.name, camera_addr
);
camera.login(&camera_config.username, camera_config.password.as_deref())?;
info!("{}: Logging in", camera_config.name);
camera.login(&camera_config.username, camera_config.password.as_deref()).map_err(|e|
{
if let neolink_core::Error::AuthFailed = e {
login_fail = true;
}
e
}
).with_context(|| format!("Failed to login to {}", camera_config.name))?;
connected = true;
info!("{}: Connected and logged in", camera_config.name);
if manage {
do_camera_management(&mut camera, camera_config)?;
do_camera_management(&mut camera, camera_config).context("Failed to manage the camera settings")?;
}
let stream_display_name = match stream_name {
Stream::Main => "Main Stream (Clear)",
Stream::Sub => "Sub Stream (Fluent)",
Stream::Extern => "Extern Stream (Balanced)",
};
info!(
"{}: Starting video stream {}",
camera_config.name, stream_name
camera_config.name, stream_display_name
);
camera.start_video(outputs, stream_name)
})()
.map_err(|err| CameraErr { connected, err })
camera.start_video(outputs, stream_name).with_context(|| format!("Error while streaming {}", camera_config.name))
})().map_err(|e| CameraErr{
connected,
login_fail,
err: e,
})
}
fn do_camera_management(
camera: &mut BcCamera,
camera_config: &CameraConfig,
) -> Result<(), neolink_core::Error> {
fn do_camera_management(camera: &mut BcCamera, camera_config: &CameraConfig) -> Result<()> {
let cam_time = camera.get_time()?;
if let Some(time) = cam_time {
info!(
+6 -7
View File
@@ -1,21 +1,20 @@
use super::errors::ParseOnOffError;
use std::path::PathBuf;
use anyhow::{anyhow, Result};
use structopt::StructOpt;
fn onoff_parse(src: &str) -> Result<bool, ParseOnOffError> {
fn onoff_parse(src: &str) -> Result<bool> {
match src {
"true" | "on" | "yes" => Ok(true),
"false" | "off" | "no" => Ok(false),
_ => Err(ParseOnOffError),
_ => Err(anyhow!(
"Could not understand {}, check your input, should be true/false, on/off or yes/no",
src
)),
}
}
/// The status-light command will control the blue status light on the camera
#[derive(StructOpt, Debug)]
pub struct Opt {
/// The path to the config file
#[structopt(short, long, parse(from_os_str))]
pub config: PathBuf,
/// The name of the camera to change the lights of. Must be a name in the config
pub camera: String,
/// Whether to turn the light on or off
-29
View File
@@ -1,29 +0,0 @@
use serde::Deserialize;
use std::clone::Clone;
use validator::Validate;
use validator_derive::Validate;
#[derive(Debug, Deserialize, Validate, Clone)]
pub(crate) struct Config {
#[validate]
pub(crate) cameras: Vec<CameraConfig>,
}
#[derive(Debug, Deserialize, Validate, Clone)]
pub(crate) struct CameraConfig {
pub(crate) name: String,
#[serde(rename = "address")]
pub(crate) camera_addr: String,
pub(crate) username: String,
pub(crate) password: Option<String>,
#[validate(range(min = 0, max = 31, message = "Invalid channel", code = "channel_id"))]
#[serde(default = "default_channel_id")]
pub(crate) channel_id: u8,
}
fn default_channel_id() -> u8 {
0
}
-24
View File
@@ -1,24 +0,0 @@
use err_derive::Error;
/// The main error for the status-light subcommand
#[derive(Debug, Error)]
#[allow(clippy::large_enum_variant)]
pub enum Error {
/// Raised when the config file fails to deserlize
#[error(display = "Configuration parsing error")]
Config(#[error(source)] toml::de::Error),
/// Raised when `neolink_core` raises an error
#[error(display = "Communication error")]
Protocol(#[error(source)] neolink_core::Error),
/// Raised when there is an IO error such as unable to find
/// config file
#[error(display = "I/O error")]
Io(#[error(source)] std::io::Error),
/// Raised when the config file fails validataion
#[error(display = "Validation error")]
Validation(#[error(source)] validator::ValidationErrors),
}
#[derive(Error, Debug)]
#[error(display = "Failed to parse on/off flag")]
pub(super) struct ParseOnOffError;
+8 -40
View File
@@ -15,54 +15,22 @@
/// neolink status-light --config=config.toml CameraName off
/// ```
///
use log::*;
use neolink_core::bc_protocol::BcCamera;
use std::fs;
use validator::Validate;
use anyhow::{Context, Result};
mod cmdline;
mod config;
mod errors;
use super::config::Config;
use crate::utils::find_and_connect;
pub(crate) use cmdline::Opt;
use config::Config;
pub(crate) use errors::Error;
/// Entry point for the ledstatus subcommand
///
/// Opt is the command line options
pub fn main(opt: Opt) -> Result<(), Error> {
let config: Config = toml::from_str(&fs::read_to_string(opt.config)?)?;
config.validate()?;
let mut cam_found = false;
for camera_config in &config.cameras {
if opt.camera == camera_config.name {
cam_found = true;
info!(
"{}: Connecting to camera at {}",
camera_config.name, camera_config.camera_addr
);
let mut camera =
BcCamera::new_with_addr(&camera_config.camera_addr, camera_config.channel_id)?;
info!("{}: Logging in", camera_config.name);
camera.login(&camera_config.username, camera_config.password.as_deref())?;
info!("{}: Connected and logged in", camera_config.name);
camera.led_light_set(opt.on)?;
}
}
if !cam_found {
error!(
"No camera with the name {} was found in the config",
opt.camera
);
}
pub(crate) fn main(opt: Opt, config: Config) -> Result<()> {
let mut camera = find_and_connect(&config, &opt.camera)?;
camera
.led_light_set(opt.on)
.context("Unable to set camera light state")?;
Ok(())
}
-3
View File
@@ -9,9 +9,6 @@ use structopt::StructOpt;
/// `gst-launch` can be used to prepare this data
#[derive(StructOpt, Debug)]
pub struct Opt {
/// The path to the config file
#[structopt(short, long, parse(from_os_str))]
pub config: PathBuf,
/// The name of the camera to change the lights of. Must be a name in the config
pub camera: String,
/// The path to the audio file.
-29
View File
@@ -1,29 +0,0 @@
use serde::Deserialize;
use std::clone::Clone;
use validator::Validate;
use validator_derive::Validate;
#[derive(Debug, Deserialize, Validate, Clone)]
pub(crate) struct Config {
#[validate]
pub(crate) cameras: Vec<CameraConfig>,
}
#[derive(Debug, Deserialize, Validate, Clone)]
pub(crate) struct CameraConfig {
pub(crate) name: String,
#[serde(rename = "address")]
pub(crate) camera_addr: String,
pub(crate) username: String,
pub(crate) password: Option<String>,
#[validate(range(min = 0, max = 31, message = "Invalid channel", code = "channel_id"))]
#[serde(default = "default_channel_id")]
pub(crate) channel_id: u8,
}
fn default_channel_id() -> u8 {
0
}
-42
View File
@@ -1,42 +0,0 @@
use err_derive::Error;
use gstreamer::glib;
/// The main error for the status-light subcommand
#[derive(Debug, Error)]
#[allow(clippy::large_enum_variant)]
pub enum Error {
/// Raised when the config file fails to deserlize
#[error(display = "Configuration parsing error")]
Config(#[error(source)] toml::de::Error),
/// Raised when `neolink_core` raises an error
#[error(display = "Communication error")]
Protocol(#[error(source)] neolink_core::Error),
/// Raised when there is an IO error such as unable to find
/// config file
#[error(display = "I/O error")]
Io(#[error(source)] std::io::Error),
/// Raised when the config file fails validataion
#[error(display = "Validation error")]
Validation(#[error(source)] validator::ValidationErrors),
/// Raised when gstreamer fails to init
#[error(display = "Gstreamer init failed")]
GstreamerInit(#[error(source)] glib::Error),
/// Raised when a needed part of the gsteamer pipeline is not found
///
/// Usually this means missing pluings
#[error(display = "Gstreamer element not supported. Check your gstreamer plugins")]
GstreamerElement(gstreamer::Element),
/// Raised where there is an issue starting a audio playback in gstraemer
#[error(display = "Gstreamer Unable to play the file")]
GstreamerPlayback(#[error(source)] gstreamer::StateChangeError),
/// Generic gstreamer error
#[error(display = "Gstreamer raised an error")]
Gstreamer {
error: String,
debug: Option<String>,
},
/// Raised when talk back is unsupported
#[error(display = "This camera does not support talkback")]
TalkUnsupported,
}
+23 -20
View File
@@ -1,3 +1,4 @@
use anyhow::{anyhow, Context, Result};
use gstreamer::{
element_error, parse_launch, prelude::*, Caps, ClockTime, FlowError, FlowSuccess, MessageView,
Pipeline, ResourceError, State,
@@ -5,7 +6,6 @@ use gstreamer::{
use gstreamer_app::{AppSink, AppSinkCallbacks};
use std::sync::mpsc::{sync_channel, Receiver, SyncSender};
use super::errors::Error;
use byte_slice_cast::*;
pub(super) fn from_input(
@@ -13,12 +13,12 @@ pub(super) fn from_input(
volume: f32,
block_align: u16,
sample_rate: u16,
) -> Result<Receiver<Vec<u8>>, Error> {
) -> Result<Receiver<Vec<u8>>> {
let pipeline = create_pipeline(input_src, volume, block_align, sample_rate)?;
input(pipeline)
}
fn input(pipeline: Pipeline) -> Result<Receiver<Vec<u8>>, Error> {
fn input(pipeline: Pipeline) -> Result<Receiver<Vec<u8>>> {
let appsink = get_sink(&pipeline)?;
let (tx, rx) = sync_channel(30);
@@ -31,7 +31,7 @@ fn input(pipeline: Pipeline) -> Result<Receiver<Vec<u8>>, Error> {
Ok(rx)
}
fn start_pipeline(pipeline: Pipeline) -> Result<(), Error> {
fn start_pipeline(pipeline: Pipeline) -> Result<()> {
pipeline.set_state(State::Playing)?;
let bus = pipeline
@@ -42,30 +42,31 @@ fn start_pipeline(pipeline: Pipeline) -> Result<(), Error> {
match msg.view() {
MessageView::Eos(..) => break,
MessageView::Error(err) => {
pipeline.set_state(State::Null)?;
pipeline
.set_state(State::Null)
.context("Error in gstreamer when setting state to Null")?;
log::warn!(
"{:?}",
Error::Gstreamer {
error: err.error().to_string(),
debug: err.debug(),
}
"Error from gstreamer when setting the play state {:?} setting to Null instead",
err
);
}
_ => (),
}
}
pipeline.set_state(State::Null)?;
pipeline
.set_state(State::Null)
.context("Error in gstreamer when setting state to Null")?;
Ok(())
}
fn get_sink(pipeline: &Pipeline) -> Result<AppSink, Error> {
fn get_sink(pipeline: &Pipeline) -> Result<AppSink> {
let sink = pipeline
.by_name("thesink")
.expect("There shoud be a `thesink`");
sink.dynamic_cast::<AppSink>()
.map_err(Error::GstreamerElement)
.map_err(|_| anyhow!("Cannot find appsink in gstreamer, check your gstreamer plugins"))
}
fn set_data_channel(appsink: &AppSink, tx: SyncSender<Vec<u8>>) {
@@ -106,7 +107,7 @@ fn set_data_channel(appsink: &AppSink, tx: SyncSender<Vec<u8>>) {
// We know what format the data in the memory region has, since we requested
// it by setting the appsink's caps. So what we do here is interpret the
// memory region we mapped as an array of signed 16 bit integers.
// memory region we mapped as an array of signed 8 bit integers.
let samples = map.as_slice_of::<u8>().map_err(|_| {
element_error!(
appsink,
@@ -131,8 +132,9 @@ fn create_pipeline(
volume: f32,
block_align: u16,
sample_rate: u16,
) -> Result<Pipeline, Error> {
gstreamer::init()?;
) -> Result<Pipeline> {
gstreamer::init()
.context("Unable to start gstreamer ensure it and all plugins are installed")?;
let launch_str = format!(
"{} \
@@ -152,10 +154,11 @@ fn create_pipeline(
// Parse the pipeline we want to probe from a static in-line string.
// Here we give our audiotestsrc a name, so we can retrieve that element
// from the resulting pipeline.
let pipeline = parse_launch(&launch_str)?;
let pipeline = pipeline
.dynamic_cast::<Pipeline>()
.map_err(Error::GstreamerElement)?;
let pipeline = parse_launch(&launch_str)
.context("Unable to load gstreamer pipeline ensure all gstramer plugins are installed")?;
let pipeline = pipeline.dynamic_cast::<Pipeline>().map_err(|_| {
anyhow!("Unable to create gstreamer pipeline ensure all gstramer plugins are installed")
})?;
let appsink = get_sink(&pipeline)?;
+60 -81
View File
@@ -8,102 +8,81 @@
/// # Usage
///
/// ```bash
/// neolink status-light --config=config.toml --adpcm-file=data.adpcm --sample-rate=16000 --block-size=512 CameraName
/// neolink talk --config=config.toml --adpcm-file=data.adpcm --sample-rate=16000 --block-size=512 CameraName
/// ```
///
use log::*;
use neolink_core::{bc::xml::TalkConfig, bc_protocol::BcCamera};
use std::fs;
use validator::Validate;
use anyhow::{anyhow, Context, Result};
use neolink_core::bc::xml::TalkConfig;
mod cmdline;
mod config;
mod errors;
mod gst;
use super::config::Config;
use crate::utils::{connect_and_login, find_camera_by_name};
pub(crate) use cmdline::Opt;
use config::Config;
pub(crate) use errors::Error;
/// Entry point for the talk subcommand
///
/// Opt is the command line options
pub fn main(opt: Opt) -> Result<(), Error> {
let config: Config = toml::from_str(&fs::read_to_string(opt.config)?)?;
pub(crate) fn main(opt: Opt, config: Config) -> Result<()> {
let camera_config = find_camera_by_name(&config, &opt.camera)?;
let camera = connect_and_login(camera_config)?;
config.validate()?;
let mut cam_found = false;
for camera_config in &config.cameras {
if opt.camera == camera_config.name {
cam_found = true;
info!(
"{}: Connecting to camera at {}",
camera_config.name, camera_config.camera_addr
);
let mut camera =
BcCamera::new_with_addr(&camera_config.camera_addr, camera_config.channel_id)?;
info!("{}: Logging in", camera_config.name);
camera.login(&camera_config.username, camera_config.password.as_deref())?;
info!("{}: Connected and logged in", camera_config.name);
let talk_ability = camera.talk_ability()?;
if talk_ability.duplex_list.is_empty()
|| talk_ability.audio_stream_mode_list.is_empty()
|| talk_ability.audio_config_list.is_empty()
{
return Err(Error::TalkUnsupported);
}
// Just copy that data from the first talk ability in the config have never seen more
// than one ability
let config = 0;
let talk_config = TalkConfig {
channel_id: camera_config.channel_id,
duplex: talk_ability.duplex_list[config].duplex.clone(),
audio_stream_mode: talk_ability.audio_stream_mode_list[config]
.audio_stream_mode
.clone(),
audio_config: talk_ability.audio_config_list[config].audio_config.clone(),
..Default::default()
};
let block_size = (talk_config.audio_config.length_per_encoder / 2) + 4;
let sample_rate = talk_config.audio_config.sample_rate;
if block_size == 0 || sample_rate == 0 {
return Err(Error::TalkUnsupported);
}
let rx = match (&opt.file_path, &opt.microphone) {
(Some(path), false) => gst::from_input(
&format!(
"filesrc location={}",
path.to_str().expect("File path not UTF8 complient")
),
opt.volume,
block_size,
sample_rate,
)?,
(None, true) => {
gst::from_input(&opt.input_src, opt.volume, block_size, sample_rate)?
}
_ => unreachable!(),
};
camera.talk_stream(rx, talk_config)?;
}
let talk_ability = camera
.talk_ability()
.with_context(|| format!("Camera {} does not support talk", camera_config.name))?;
if talk_ability.duplex_list.is_empty()
|| talk_ability.audio_stream_mode_list.is_empty()
|| talk_ability.audio_config_list.is_empty()
{
return Err(anyhow!(
"Camera {} does not support talk",
camera_config.name
));
}
if !cam_found {
error!(
"No camera with the name {} was found in the config",
opt.camera
);
// Just copy that data from the first talk ability in the config have never seen more
// than one ability
let config = 0;
let talk_config = TalkConfig {
channel_id: camera_config.channel_id,
duplex: talk_ability.duplex_list[config].duplex.clone(),
audio_stream_mode: talk_ability.audio_stream_mode_list[config]
.audio_stream_mode
.clone(),
audio_config: talk_ability.audio_config_list[config].audio_config.clone(),
..Default::default()
};
let block_size = (talk_config.audio_config.length_per_encoder / 2) + 4;
let sample_rate = talk_config.audio_config.sample_rate;
if block_size == 0 || sample_rate == 0 {
return Err(anyhow!(
"The camera {} does not support talk with adpcm",
camera_config.name
));
}
let rx = match (&opt.file_path, &opt.microphone) {
(Some(path), false) => gst::from_input(
&format!(
"filesrc location={}",
path.to_str().expect("File path not UTF8 complient")
),
opt.volume,
block_size,
sample_rate,
)
.with_context(|| format!("Failed to setup gst with the file: {:?}", path))?,
(None, true) => gst::from_input(&opt.input_src, opt.volume, block_size, sample_rate)
.context("Failed to setup gst using the microphone")?,
_ => unreachable!(),
};
camera
.talk_stream(rx, talk_config)
.context("Talk stream ended early")?;
Ok(())
}
+85
View File
@@ -0,0 +1,85 @@
//! Contains code that is not specific to any of the subcommands
//!
use log::*;
use super::config::{CameraConfig, Config};
use anyhow::{anyhow, Context, Error, Result};
use neolink_core::bc_protocol::BcCamera;
use std::fmt::{Display, Error as FmtError, Formatter};
pub(crate) enum AddressOrUid {
Address(String),
Uid(String),
}
impl Display for AddressOrUid {
fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), FmtError> {
match self {
AddressOrUid::Address(host) => write!(f, "Address: {}", host),
AddressOrUid::Uid(host) => write!(f, "UID: {}", host),
}
}
}
impl AddressOrUid {
// Created by translating the config fields directly
pub(crate) fn new(address: &Option<String>, uid: &Option<String>) -> Result<Self, Error> {
match (address, uid) {
(None, None) => Err(anyhow!("Neither address or uid given")),
(Some(_), Some(_)) => Err(anyhow!("Either address or uid should be given not both")),
(Some(host), None) => Ok(AddressOrUid::Address(host.clone())),
(None, Some(host)) => Ok(AddressOrUid::Uid(host.clone())),
}
}
// Convience method to get the BcCamera with the appropiate method
pub(crate) fn connect_camera(&self, channel_id: u8) -> Result<BcCamera, Error> {
match self {
AddressOrUid::Address(host) => Ok(BcCamera::new_with_addr(host, channel_id)?),
AddressOrUid::Uid(host) => Ok(BcCamera::new_with_uid(host, channel_id)?),
}
}
}
pub(crate) fn find_and_connect(config: &Config, name: &str) -> Result<BcCamera> {
let camera_config = find_camera_by_name(config, name)?;
connect_and_login(camera_config)
}
pub(crate) fn connect_and_login(camera_config: &CameraConfig) -> Result<BcCamera> {
let camera_addr =
AddressOrUid::new(&camera_config.camera_addr, &camera_config.camera_uid).unwrap();
info!(
"{}: Connecting to camera at {}",
camera_config.name, camera_addr
);
let mut camera = camera_addr
.connect_camera(camera_config.channel_id)
.with_context(|| {
format!(
"Failed to connect to camera {} at {} on channel {}",
camera_config.name, camera_addr, camera_config.channel_id
)
})?;
info!("{}: Logging in", camera_config.name);
camera
.login(&camera_config.username, camera_config.password.as_deref())
.with_context(|| format!("Failed to login to {}", camera_config.name))?;
info!("{}: Connected and logged in", camera_config.name);
Ok(camera)
}
pub(crate) fn find_camera_by_name<'a, 'b>(
config: &'a Config,
name: &'b str,
) -> Result<&'a CameraConfig> {
config
.cameras
.iter()
.find(|c| c.name == name)
.ok_or_else(|| anyhow!("Camera {} not found in the config file", name))
}