Initial import: ICE-NET research docs and Rust workspace (v0.4)
Some checks failed
rust-ci / checks (push) Has been cancelled

- Rust workspace: 7 library crates, icenetd CLI, icenet-city (Slint GUI)
- Sim: fix false Delivered after a route cut, derive traffic class from
  payload size, per-link airtime slots (link capacity, queueing)
- Docs: single docs/STATUS.md for all figures, remove v0.2/egui leftovers,
  drop unimplemented seed claims, uncheck store-and-forward
- License: LGPL-3.0-or-later (LICENSE, LICENSES/GPL-3.0.txt)
This commit is contained in:
Loki 2026-11-13 12:28:48 +01:00
commit 2e61688eb3
Signed by: boba
GPG key ID: 6CDE87BC9A778D97
141 changed files with 13993 additions and 0 deletions

20
.github/workflows/ci.yml vendored Normal file
View file

@ -0,0 +1,20 @@
name: rust-ci
on:
push:
pull_request:
jobs:
checks:
runs-on: ubuntu-latest
defaults:
run:
working-directory: workspace
steps:
- uses: actions/checkout@v4
- uses: dtolnay/rust-toolchain@stable
with:
toolchain: '1.95.0'
components: rustfmt, clippy
- run: python3 tools/check_layout.py
- run: cargo fmt --all -- --check
- run: cargo clippy --workspace --all-targets -- -D warnings
- run: cargo test --workspace

165
LICENSE Normal file
View file

@ -0,0 +1,165 @@
GNU LESSER GENERAL PUBLIC LICENSE
Version 3, 29 June 2007
Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
This version of the GNU Lesser General Public License incorporates
the terms and conditions of version 3 of the GNU General Public
License, supplemented by the additional permissions listed below.
0. Additional Definitions.
As used herein, "this License" refers to version 3 of the GNU Lesser
General Public License, and the "GNU GPL" refers to version 3 of the GNU
General Public License.
"The Library" refers to a covered work governed by this License,
other than an Application or a Combined Work as defined below.
An "Application" is any work that makes use of an interface provided
by the Library, but which is not otherwise based on the Library.
Defining a subclass of a class defined by the Library is deemed a mode
of using an interface provided by the Library.
A "Combined Work" is a work produced by combining or linking an
Application with the Library. The particular version of the Library
with which the Combined Work was made is also called the "Linked
Version".
The "Minimal Corresponding Source" for a Combined Work means the
Corresponding Source for the Combined Work, excluding any source code
for portions of the Combined Work that, considered in isolation, are
based on the Application, and not on the Linked Version.
The "Corresponding Application Code" for a Combined Work means the
object code and/or source code for the Application, including any data
and utility programs needed for reproducing the Combined Work from the
Application, but excluding the System Libraries of the Combined Work.
1. Exception to Section 3 of the GNU GPL.
You may convey a covered work under sections 3 and 4 of this License
without being bound by section 3 of the GNU GPL.
2. Conveying Modified Versions.
If you modify a copy of the Library, and, in your modifications, a
facility refers to a function or data to be supplied by an Application
that uses the facility (other than as an argument passed when the
facility is invoked), then you may convey a copy of the modified
version:
a) under this License, provided that you make a good faith effort to
ensure that, in the event an Application does not supply the
function or data, the facility still operates, and performs
whatever part of its purpose remains meaningful, or
b) under the GNU GPL, with none of the additional permissions of
this License applicable to that copy.
3. Object Code Incorporating Material from Library Header Files.
The object code form of an Application may incorporate material from
a header file that is part of the Library. You may convey such object
code under terms of your choice, provided that, if the incorporated
material is not limited to numerical parameters, data structure
layouts and accessors, or small macros, inline functions and templates
(ten or fewer lines in length), you do both of the following:
a) Give prominent notice with each copy of the object code that the
Library is used in it and that the Library and its use are
covered by this License.
b) Accompany the object code with a copy of the GNU GPL and this license
document.
4. Combined Works.
You may convey a Combined Work under terms of your choice that,
taken together, effectively do not restrict modification of the
portions of the Library contained in the Combined Work and reverse
engineering for debugging such modifications, if you also do each of
the following:
a) Give prominent notice with each copy of the Combined Work that
the Library is used in it and that the Library and its use are
covered by this License.
b) Accompany the Combined Work with a copy of the GNU GPL and this license
document.
c) For a Combined Work that displays copyright notices during
execution, include the copyright notice for the Library among
these notices, as well as a reference directing the user to the
copies of the GNU GPL and this license document.
d) Do one of the following:
0) Convey the Minimal Corresponding Source under the terms of this
License, and the Corresponding Application Code in a form
suitable for, and under terms that permit, the user to
recombine or relink the Application with a modified version of
the Linked Version to produce a modified Combined Work, in the
manner specified by section 6 of the GNU GPL for conveying
Corresponding Source.
1) Use a suitable shared library mechanism for linking with the
Library. A suitable mechanism is one that (a) uses at run time
a copy of the Library already present on the user's computer
system, and (b) will operate properly with a modified version
of the Library that is interface-compatible with the Linked
Version.
e) Provide Installation Information, but only if you would otherwise
be required to provide such information under section 6 of the
GNU GPL, and only to the extent that such information is
necessary to install and execute a modified version of the
Combined Work produced by recombining or relinking the
Application with a modified version of the Linked Version. (If
you use option 4d0, the Installation Information must accompany
the Minimal Corresponding Source and Corresponding Application
Code. If you use option 4d1, you must provide the Installation
Information in the manner specified by section 6 of the GNU GPL
for conveying Corresponding Source.)
5. Combined Libraries.
You may place library facilities that are a work based on the
Library side by side in a single library together with other library
facilities that are not Applications and are not covered by this
License, and convey such a combined library under terms of your
choice, if you do both of the following:
a) Accompany the combined library with a copy of the same work based
on the Library, uncombined with any other library facilities,
conveyed under the terms of this License.
b) Give prominent notice with the combined library that part of it
is a work based on the Library, and explaining where to find the
accompanying uncombined form of the same work.
6. Revised Versions of the GNU Lesser General Public License.
The Free Software Foundation may publish revised and/or new versions
of the GNU Lesser General Public License from time to time. Such new
versions will be similar in spirit to the present version, but may
differ in detail to address new problems or concerns.
Each version is given a distinguishing version number. If the
Library as you received it specifies that a certain numbered version
of the GNU Lesser General Public License "or any later version"
applies to it, you have the option of following the terms and
conditions either of that published version or of any later version
published by the Free Software Foundation. If the Library as you
received it does not specify a version number of the GNU Lesser
General Public License, you may choose any version of the GNU Lesser
General Public License ever published by the Free Software Foundation.
If the Library as you received it specifies that a proxy can decide
whether future versions of the GNU Lesser General Public License shall
apply, that proxy's public statement of acceptance of any version is
permanent authorization for you to choose that version for the
Library.

674
LICENSES/GPL-3.0.txt Normal file
View file

@ -0,0 +1,674 @@
GNU GENERAL PUBLIC LICENSE
Version 3, 29 June 2007
Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The GNU General Public License is a free, copyleft license for
software and other kinds of works.
The licenses for most software and other practical works are designed
to take away your freedom to share and change the works. By contrast,
the GNU General Public License is intended to guarantee your freedom to
share and change all versions of a program--to make sure it remains free
software for all its users. We, the Free Software Foundation, use the
GNU General Public License for most of our software; it applies also to
any other work released this way by its authors. You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
them if you wish), that you receive source code or can get it if you
want it, that you can change the software or use pieces of it in new
free programs, and that you know you can do these things.
To protect your rights, we need to prevent others from denying you
these rights or asking you to surrender the rights. Therefore, you have
certain responsibilities if you distribute copies of the software, or if
you modify it: responsibilities to respect the freedom of others.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must pass on to the recipients the same
freedoms that you received. You must make sure that they, too, receive
or can get the source code. And you must show them these terms so they
know their rights.
Developers that use the GNU GPL protect your rights with two steps:
(1) assert copyright on the software, and (2) offer you this License
giving you legal permission to copy, distribute and/or modify it.
For the developers' and authors' protection, the GPL clearly explains
that there is no warranty for this free software. For both users' and
authors' sake, the GPL requires that modified versions be marked as
changed, so that their problems will not be attributed erroneously to
authors of previous versions.
Some devices are designed to deny users access to install or run
modified versions of the software inside them, although the manufacturer
can do so. This is fundamentally incompatible with the aim of
protecting users' freedom to change the software. The systematic
pattern of such abuse occurs in the area of products for individuals to
use, which is precisely where it is most unacceptable. Therefore, we
have designed this version of the GPL to prohibit the practice for those
products. If such problems arise substantially in other domains, we
stand ready to extend this provision to those domains in future versions
of the GPL, as needed to protect the freedom of users.
Finally, every program is threatened constantly by software patents.
States should not allow patents to restrict development and use of
software on general-purpose computers, but in those that do, we wish to
avoid the special danger that patents applied to a free program could
make it effectively proprietary. To prevent this, the GPL assures that
patents cannot be used to render the program non-free.
The precise terms and conditions for copying, distribution and
modification follow.
TERMS AND CONDITIONS
0. Definitions.
"This License" refers to version 3 of the GNU General Public License.
"Copyright" also means copyright-like laws that apply to other kinds of
works, such as semiconductor masks.
"The Program" refers to any copyrightable work licensed under this
License. Each licensee is addressed as "you". "Licensees" and
"recipients" may be individuals or organizations.
To "modify" a work means to copy from or adapt all or part of the work
in a fashion requiring copyright permission, other than the making of an
exact copy. The resulting work is called a "modified version" of the
earlier work or a work "based on" the earlier work.
A "covered work" means either the unmodified Program or a work based
on the Program.
To "propagate" a work means to do anything with it that, without
permission, would make you directly or secondarily liable for
infringement under applicable copyright law, except executing it on a
computer or modifying a private copy. Propagation includes copying,
distribution (with or without modification), making available to the
public, and in some countries other activities as well.
To "convey" a work means any kind of propagation that enables other
parties to make or receive copies. Mere interaction with a user through
a computer network, with no transfer of a copy, is not conveying.
An interactive user interface displays "Appropriate Legal Notices"
to the extent that it includes a convenient and prominently visible
feature that (1) displays an appropriate copyright notice, and (2)
tells the user that there is no warranty for the work (except to the
extent that warranties are provided), that licensees may convey the
work under this License, and how to view a copy of this License. If
the interface presents a list of user commands or options, such as a
menu, a prominent item in the list meets this criterion.
1. Source Code.
The "source code" for a work means the preferred form of the work
for making modifications to it. "Object code" means any non-source
form of a work.
A "Standard Interface" means an interface that either is an official
standard defined by a recognized standards body, or, in the case of
interfaces specified for a particular programming language, one that
is widely used among developers working in that language.
The "System Libraries" of an executable work include anything, other
than the work as a whole, that (a) is included in the normal form of
packaging a Major Component, but which is not part of that Major
Component, and (b) serves only to enable use of the work with that
Major Component, or to implement a Standard Interface for which an
implementation is available to the public in source code form. A
"Major Component", in this context, means a major essential component
(kernel, window system, and so on) of the specific operating system
(if any) on which the executable work runs, or a compiler used to
produce the work, or an object code interpreter used to run it.
The "Corresponding Source" for a work in object code form means all
the source code needed to generate, install, and (for an executable
work) run the object code and to modify the work, including scripts to
control those activities. However, it does not include the work's
System Libraries, or general-purpose tools or generally available free
programs which are used unmodified in performing those activities but
which are not part of the work. For example, Corresponding Source
includes interface definition files associated with source files for
the work, and the source code for shared libraries and dynamically
linked subprograms that the work is specifically designed to require,
such as by intimate data communication or control flow between those
subprograms and other parts of the work.
The Corresponding Source need not include anything that users
can regenerate automatically from other parts of the Corresponding
Source.
The Corresponding Source for a work in source code form is that
same work.
2. Basic Permissions.
All rights granted under this License are granted for the term of
copyright on the Program, and are irrevocable provided the stated
conditions are met. This License explicitly affirms your unlimited
permission to run the unmodified Program. The output from running a
covered work is covered by this License only if the output, given its
content, constitutes a covered work. This License acknowledges your
rights of fair use or other equivalent, as provided by copyright law.
You may make, run and propagate covered works that you do not
convey, without conditions so long as your license otherwise remains
in force. You may convey covered works to others for the sole purpose
of having them make modifications exclusively for you, or provide you
with facilities for running those works, provided that you comply with
the terms of this License in conveying all material for which you do
not control copyright. Those thus making or running the covered works
for you must do so exclusively on your behalf, under your direction
and control, on terms that prohibit them from making any copies of
your copyrighted material outside their relationship with you.
Conveying under any other circumstances is permitted solely under
the conditions stated below. Sublicensing is not allowed; section 10
makes it unnecessary.
3. Protecting Users' Legal Rights From Anti-Circumvention Law.
No covered work shall be deemed part of an effective technological
measure under any applicable law fulfilling obligations under article
11 of the WIPO copyright treaty adopted on 20 December 1996, or
similar laws prohibiting or restricting circumvention of such
measures.
When you convey a covered work, you waive any legal power to forbid
circumvention of technological measures to the extent such circumvention
is effected by exercising rights under this License with respect to
the covered work, and you disclaim any intention to limit operation or
modification of the work as a means of enforcing, against the work's
users, your or third parties' legal rights to forbid circumvention of
technological measures.
4. Conveying Verbatim Copies.
You may convey verbatim copies of the Program's source code as you
receive it, in any medium, provided that you conspicuously and
appropriately publish on each copy an appropriate copyright notice;
keep intact all notices stating that this License and any
non-permissive terms added in accord with section 7 apply to the code;
keep intact all notices of the absence of any warranty; and give all
recipients a copy of this License along with the Program.
You may charge any price or no price for each copy that you convey,
and you may offer support or warranty protection for a fee.
5. Conveying Modified Source Versions.
You may convey a work based on the Program, or the modifications to
produce it from the Program, in the form of source code under the
terms of section 4, provided that you also meet all of these conditions:
a) The work must carry prominent notices stating that you modified
it, and giving a relevant date.
b) The work must carry prominent notices stating that it is
released under this License and any conditions added under section
7. This requirement modifies the requirement in section 4 to
"keep intact all notices".
c) You must license the entire work, as a whole, under this
License to anyone who comes into possession of a copy. This
License will therefore apply, along with any applicable section 7
additional terms, to the whole of the work, and all its parts,
regardless of how they are packaged. This License gives no
permission to license the work in any other way, but it does not
invalidate such permission if you have separately received it.
d) If the work has interactive user interfaces, each must display
Appropriate Legal Notices; however, if the Program has interactive
interfaces that do not display Appropriate Legal Notices, your
work need not make them do so.
A compilation of a covered work with other separate and independent
works, which are not by their nature extensions of the covered work,
and which are not combined with it such as to form a larger program,
in or on a volume of a storage or distribution medium, is called an
"aggregate" if the compilation and its resulting copyright are not
used to limit the access or legal rights of the compilation's users
beyond what the individual works permit. Inclusion of a covered work
in an aggregate does not cause this License to apply to the other
parts of the aggregate.
6. Conveying Non-Source Forms.
You may convey a covered work in object code form under the terms
of sections 4 and 5, provided that you also convey the
machine-readable Corresponding Source under the terms of this License,
in one of these ways:
a) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by the
Corresponding Source fixed on a durable physical medium
customarily used for software interchange.
b) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by a
written offer, valid for at least three years and valid for as
long as you offer spare parts or customer support for that product
model, to give anyone who possesses the object code either (1) a
copy of the Corresponding Source for all the software in the
product that is covered by this License, on a durable physical
medium customarily used for software interchange, for a price no
more than your reasonable cost of physically performing this
conveying of source, or (2) access to copy the
Corresponding Source from a network server at no charge.
c) Convey individual copies of the object code with a copy of the
written offer to provide the Corresponding Source. This
alternative is allowed only occasionally and noncommercially, and
only if you received the object code with such an offer, in accord
with subsection 6b.
d) Convey the object code by offering access from a designated
place (gratis or for a charge), and offer equivalent access to the
Corresponding Source in the same way through the same place at no
further charge. You need not require recipients to copy the
Corresponding Source along with the object code. If the place to
copy the object code is a network server, the Corresponding Source
may be on a different server (operated by you or a third party)
that supports equivalent copying facilities, provided you maintain
clear directions next to the object code saying where to find the
Corresponding Source. Regardless of what server hosts the
Corresponding Source, you remain obligated to ensure that it is
available for as long as needed to satisfy these requirements.
e) Convey the object code using peer-to-peer transmission, provided
you inform other peers where the object code and Corresponding
Source of the work are being offered to the general public at no
charge under subsection 6d.
A separable portion of the object code, whose source code is excluded
from the Corresponding Source as a System Library, need not be
included in conveying the object code work.
A "User Product" is either (1) a "consumer product", which means any
tangible personal property which is normally used for personal, family,
or household purposes, or (2) anything designed or sold for incorporation
into a dwelling. In determining whether a product is a consumer product,
doubtful cases shall be resolved in favor of coverage. For a particular
product received by a particular user, "normally used" refers to a
typical or common use of that class of product, regardless of the status
of the particular user or of the way in which the particular user
actually uses, or expects or is expected to use, the product. A product
is a consumer product regardless of whether the product has substantial
commercial, industrial or non-consumer uses, unless such uses represent
the only significant mode of use of the product.
"Installation Information" for a User Product means any methods,
procedures, authorization keys, or other information required to install
and execute modified versions of a covered work in that User Product from
a modified version of its Corresponding Source. The information must
suffice to ensure that the continued functioning of the modified object
code is in no case prevented or interfered with solely because
modification has been made.
If you convey an object code work under this section in, or with, or
specifically for use in, a User Product, and the conveying occurs as
part of a transaction in which the right of possession and use of the
User Product is transferred to the recipient in perpetuity or for a
fixed term (regardless of how the transaction is characterized), the
Corresponding Source conveyed under this section must be accompanied
by the Installation Information. But this requirement does not apply
if neither you nor any third party retains the ability to install
modified object code on the User Product (for example, the work has
been installed in ROM).
The requirement to provide Installation Information does not include a
requirement to continue to provide support service, warranty, or updates
for a work that has been modified or installed by the recipient, or for
the User Product in which it has been modified or installed. Access to a
network may be denied when the modification itself materially and
adversely affects the operation of the network or violates the rules and
protocols for communication across the network.
Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.
7. Additional Terms.
"Additional permissions" are terms that supplement the terms of this
License by making exceptions from one or more of its conditions.
Additional permissions that are applicable to the entire Program shall
be treated as though they were included in this License, to the extent
that they are valid under applicable law. If additional permissions
apply only to part of the Program, that part may be used separately
under those permissions, but the entire Program remains governed by
this License without regard to the additional permissions.
When you convey a copy of a covered work, you may at your option
remove any additional permissions from that copy, or from any part of
it. (Additional permissions may be written to require their own
removal in certain cases when you modify the work.) You may place
additional permissions on material, added by you to a covered work,
for which you have or can give appropriate copyright permission.
Notwithstanding any other provision of this License, for material you
add to a covered work, you may (if authorized by the copyright holders of
that material) supplement the terms of this License with terms:
a) Disclaiming warranty or limiting liability differently from the
terms of sections 15 and 16 of this License; or
b) Requiring preservation of specified reasonable legal notices or
author attributions in that material or in the Appropriate Legal
Notices displayed by works containing it; or
c) Prohibiting misrepresentation of the origin of that material, or
requiring that modified versions of such material be marked in
reasonable ways as different from the original version; or
d) Limiting the use for publicity purposes of names of licensors or
authors of the material; or
e) Declining to grant rights under trademark law for use of some
trade names, trademarks, or service marks; or
f) Requiring indemnification of licensors and authors of that
material by anyone who conveys the material (or modified versions of
it) with contractual assumptions of liability to the recipient, for
any liability that these contractual assumptions directly impose on
those licensors and authors.
All other non-permissive additional terms are considered "further
restrictions" within the meaning of section 10. If the Program as you
received it, or any part of it, contains a notice stating that it is
governed by this License along with a term that is a further
restriction, you may remove that term. If a license document contains
a further restriction but permits relicensing or conveying under this
License, you may add to a covered work material governed by the terms
of that license document, provided that the further restriction does
not survive such relicensing or conveying.
If you add terms to a covered work in accord with this section, you
must place, in the relevant source files, a statement of the
additional terms that apply to those files, or a notice indicating
where to find the applicable terms.
Additional terms, permissive or non-permissive, may be stated in the
form of a separately written license, or stated as exceptions;
the above requirements apply either way.
8. Termination.
You may not propagate or modify a covered work except as expressly
provided under this License. Any attempt otherwise to propagate or
modify it is void, and will automatically terminate your rights under
this License (including any patent licenses granted under the third
paragraph of section 11).
However, if you cease all violation of this License, then your
license from a particular copyright holder is reinstated (a)
provisionally, unless and until the copyright holder explicitly and
finally terminates your license, and (b) permanently, if the copyright
holder fails to notify you of the violation by some reasonable means
prior to 60 days after the cessation.
Moreover, your license from a particular copyright holder is
reinstated permanently if the copyright holder notifies you of the
violation by some reasonable means, this is the first time you have
received notice of violation of this License (for any work) from that
copyright holder, and you cure the violation prior to 30 days after
your receipt of the notice.
Termination of your rights under this section does not terminate the
licenses of parties who have received copies or rights from you under
this License. If your rights have been terminated and not permanently
reinstated, you do not qualify to receive new licenses for the same
material under section 10.
9. Acceptance Not Required for Having Copies.
You are not required to accept this License in order to receive or
run a copy of the Program. Ancillary propagation of a covered work
occurring solely as a consequence of using peer-to-peer transmission
to receive a copy likewise does not require acceptance. However,
nothing other than this License grants you permission to propagate or
modify any covered work. These actions infringe copyright if you do
not accept this License. Therefore, by modifying or propagating a
covered work, you indicate your acceptance of this License to do so.
10. Automatic Licensing of Downstream Recipients.
Each time you convey a covered work, the recipient automatically
receives a license from the original licensors, to run, modify and
propagate that work, subject to this License. You are not responsible
for enforcing compliance by third parties with this License.
An "entity transaction" is a transaction transferring control of an
organization, or substantially all assets of one, or subdividing an
organization, or merging organizations. If propagation of a covered
work results from an entity transaction, each party to that
transaction who receives a copy of the work also receives whatever
licenses to the work the party's predecessor in interest had or could
give under the previous paragraph, plus a right to possession of the
Corresponding Source of the work from the predecessor in interest, if
the predecessor has it or can get it with reasonable efforts.
You may not impose any further restrictions on the exercise of the
rights granted or affirmed under this License. For example, you may
not impose a license fee, royalty, or other charge for exercise of
rights granted under this License, and you may not initiate litigation
(including a cross-claim or counterclaim in a lawsuit) alleging that
any patent claim is infringed by making, using, selling, offering for
sale, or importing the Program or any portion of it.
11. Patents.
A "contributor" is a copyright holder who authorizes use under this
License of the Program or a work on which the Program is based. The
work thus licensed is called the contributor's "contributor version".
A contributor's "essential patent claims" are all patent claims
owned or controlled by the contributor, whether already acquired or
hereafter acquired, that would be infringed by some manner, permitted
by this License, of making, using, or selling its contributor version,
but do not include claims that would be infringed only as a
consequence of further modification of the contributor version. For
purposes of this definition, "control" includes the right to grant
patent sublicenses in a manner consistent with the requirements of
this License.
Each contributor grants you a non-exclusive, worldwide, royalty-free
patent license under the contributor's essential patent claims, to
make, use, sell, offer for sale, import and otherwise run, modify and
propagate the contents of its contributor version.
In the following three paragraphs, a "patent license" is any express
agreement or commitment, however denominated, not to enforce a patent
(such as an express permission to practice a patent or covenant not to
sue for patent infringement). To "grant" such a patent license to a
party means to make such an agreement or commitment not to enforce a
patent against the party.
If you convey a covered work, knowingly relying on a patent license,
and the Corresponding Source of the work is not available for anyone
to copy, free of charge and under the terms of this License, through a
publicly available network server or other readily accessible means,
then you must either (1) cause the Corresponding Source to be so
available, or (2) arrange to deprive yourself of the benefit of the
patent license for this particular work, or (3) arrange, in a manner
consistent with the requirements of this License, to extend the patent
license to downstream recipients. "Knowingly relying" means you have
actual knowledge that, but for the patent license, your conveying the
covered work in a country, or your recipient's use of the covered work
in a country, would infringe one or more identifiable patents in that
country that you have reason to believe are valid.
If, pursuant to or in connection with a single transaction or
arrangement, you convey, or propagate by procuring conveyance of, a
covered work, and grant a patent license to some of the parties
receiving the covered work authorizing them to use, propagate, modify
or convey a specific copy of the covered work, then the patent license
you grant is automatically extended to all recipients of the covered
work and works based on it.
A patent license is "discriminatory" if it does not include within
the scope of its coverage, prohibits the exercise of, or is
conditioned on the non-exercise of one or more of the rights that are
specifically granted under this License. You may not convey a covered
work if you are a party to an arrangement with a third party that is
in the business of distributing software, under which you make payment
to the third party based on the extent of your activity of conveying
the work, and under which the third party grants, to any of the
parties who would receive the covered work from you, a discriminatory
patent license (a) in connection with copies of the covered work
conveyed by you (or copies made from those copies), or (b) primarily
for and in connection with specific products or compilations that
contain the covered work, unless you entered into that arrangement,
or that patent license was granted, prior to 28 March 2007.
Nothing in this License shall be construed as excluding or limiting
any implied license or other defenses to infringement that may
otherwise be available to you under applicable patent law.
12. No Surrender of Others' Freedom.
If conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot convey a
covered work so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you may
not convey it at all. For example, if you agree to terms that obligate you
to collect a royalty for further conveying from those to whom you convey
the Program, the only way you could satisfy both those terms and this
License would be to refrain entirely from conveying the Program.
13. Use with the GNU Affero General Public License.
Notwithstanding any other provision of this License, you have
permission to link or combine any covered work with a work licensed
under version 3 of the GNU Affero General Public License into a single
combined work, and to convey the resulting work. The terms of this
License will continue to apply to the part which is the covered work,
but the special requirements of the GNU Affero General Public License,
section 13, concerning interaction through a network will apply to the
combination as such.
14. Revised Versions of this License.
The Free Software Foundation may publish revised and/or new versions of
the GNU General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the
Program specifies that a certain numbered version of the GNU General
Public License "or any later version" applies to it, you have the
option of following the terms and conditions either of that numbered
version or of any later version published by the Free Software
Foundation. If the Program does not specify a version number of the
GNU General Public License, you may choose any version ever published
by the Free Software Foundation.
If the Program specifies that a proxy can decide which future
versions of the GNU General Public License can be used, that proxy's
public statement of acceptance of a version permanently authorizes you
to choose that version for the Program.
Later license versions may give you additional or different
permissions. However, no additional obligations are imposed on any
author or copyright holder as a result of your choosing to follow a
later version.
15. Disclaimer of Warranty.
THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16. Limitation of Liability.
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
SUCH DAMAGES.
17. Interpretation of Sections 15 and 16.
If the disclaimer of warranty and limitation of liability provided
above cannot be given local legal effect according to their terms,
reviewing courts shall apply local law that most closely approximates
an absolute waiver of all civil liability in connection with the
Program, unless a warranty or assumption of liability accompanies a
copy of the Program in return for a fee.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
state the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
<one line to give the program's name and a brief idea of what it does.>
Copyright (C) <year> <name of author>
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <https://www.gnu.org/licenses/>.
Also add information on how to contact you by electronic and paper mail.
If the program does terminal interaction, make it output a short
notice like this when it starts in an interactive mode:
<program> Copyright (C) <year> <name of author>
This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, your program's commands
might be different; for a GUI interface, you would use an "about box".
You should also get your employer (if you work as a programmer) or school,
if any, to sign a "copyright disclaimer" for the program, if necessary.
For more information on this, and how to apply and follow the GNU GPL, see
<https://www.gnu.org/licenses/>.
The GNU General Public License does not permit incorporating your program
into proprietary programs. If your program is a subroutine library, you
may consider it more useful to permit linking proprietary applications with
the library. If this is what you want to do, use the GNU Lesser General
Public License instead of this License. But first, please read
<https://www.gnu.org/licenses/why-not-lgpl.html>.

73
README.md Normal file
View file

@ -0,0 +1,73 @@
# ICE-NET · Research + Rust Workspace · v0.4
> **Статус: архитектура + стартовый код для локальных экспериментов.** Не развёрнутый
> сетевой протокол, не готовая криптосистема и не проверенная RF-симуляция.
> Срез исследования: **13 ноября 2026 года**. Язык документации: русский;
> публичные Rust API и технические комментарии — на английском.
> Актуальные цифры и состояние: [docs/STATUS.md](docs/STATUS.md).
> **Вдохновение.** Идея вдохновлена «Сетью» (the Net) из киберпанка — образом
> глобальной сети поверх разнородных каналов и устройств, которая не принадлежит
> одной корпорации. Это художественное вдохновение: проект не связан с
> правообладателями киберпанк-произведений и ничего из них не воспроизводит.
Репозиторий: <https://git.wihuk.pro/boba/ICE-NET.git>
Лицензия: **LGPL-3.0-or-later** — см. [LICENSE](LICENSE) и [LICENSES/](LICENSES/GPL-3.0.txt).
ICE-NET — проект независимой сети: идентичность устройства отдельно от транспорта,
медленные радиоканалы преимущественно для объявления доступности и малых сообщений,
большие данные — только по подходящим быстрым каналам, при отсутствии пути — очередь.
## 🧭 Путь чтения
1. [Статус: что проверено и что нет](docs/STATUS.md) и [TODO: план по этапам](TODO.md) — **начни здесь**.
**[Полный кликабельный индекс всех Markdown-файлов](docs/INDEX.md).**
2. [Правила разработки и ограничение 250/4](RULES.md).
3. [Аудит зависимостей](docs/build/dependencies.md) и [лицензия Slint](docs/build/slint_license.md).
4. [Архитектура](docs/architecture/overview.md) и [граф зависимостей крейтов](docs/architecture/crates.md).
5. [Интерактивная модель города](docs/simulator/city_editor.md) и [сценарии](docs/simulator/scenarios.md).
6. [Исследование Reticulum](docs/research/reticulum.md), [Meshtastic](docs/research/meshtastic.md),
[наш пробел/гипотеза](docs/research/gaps.md), [лицензии](docs/research/licensing.md).
7. [Руководство Arch Linux](docs/guides/quickstart.md), [команды CI](docs/guides/testing.md).
8. [Ревизия 0.1 → 0.3](docs/review/revision.md) и [открытые решения](docs/review/questions.md).
9. [Архив всех исходных Markdown](archive/README.md), [ссылки исследований](docs/SOURCES.md).
## Каталоги
| Путь | Роль |
| --- | --- |
| `workspace/crates/` | библиотеки на Rust без зависимости от GUI |
| `workspace/apps/icenet-city/` | нативный визуальный городской эмулятор (Slint 1.18.1, software rendering) |
| `workspace/apps/icenetd/` | CLI (`route`/`send`/`sim`/`policy`/`wire`, UDP `serve`/`send-udp`); daemon позже |
| `workspace/tools/` | автоматическая проверка структуры 250/4 и тестов |
| `docs/` | актуальные решения, симулятор, безопасность, исследования |
| `archive/` | полный исходный исследовательский пакет 0.1, не выброшен |
## Минимальный путь без железа
```bash
cd workspace
python3 tools/check_layout.py
cargo fmt --all -- --check
cargo test -p icenet-sim -p icenet-routing
cargo run -p icenet-city
```
Что именно проверено (тесты, fmt, clippy, замеры) и что **не** проверено — только в
[docs/STATUS.md](docs/STATUS.md).
## Что специально НЕ обещаем
- Глобальное покрытие, бесплатные вышки или «высокую скорость по LoRa».
- Совместимость с Reticulum/Meshtastic на уровне wire-протоколов.
- Подтверждённую безопасность: исходные криптографические примитивы пока **не реализованы**.
- Что модель города физически достоверно предсказывает радиопокрытие.
- Что ICE-NET уже лучше существующих решений: это проверяемая гипотеза.
## Зависимости
- Core-библиотеки: **0 внешних crates** (7 внутренних крейтов — границы проекта).
- GUI: `slint` + `slint-build` (build-time), версия и число записей lock — в [STATUS](docs/STATUS.md).
- `default-features = false` не гарантирует меньше транзитивных зависимостей.
Подробности и контрольный список: [dependencies.md](docs/build/dependencies.md).

71
RULES.md Normal file
View file

@ -0,0 +1,71 @@
# Правила репозитория ICE-NET · обязательные
## Структура и ограничения
1. **Не более 250 физических строк на любой авторский текстовый файл**, включая MD, Rust, Slint, TOML, Python, YAML.
2. **Не более 4 авторских файлов непосредственно в одном каталоге** (подкаталоги отдельно). Сгенерированный `Cargo.lock`, `.gitignore` и системный `.DS_Store` не учитываются при подсчёте; на исходники и `.slint` это исключение не действует.
3. Если модуль вырос — делить по ответственности, **не** сжимать код в одну строку.
4. Не размещать тесты в `src/` через `#[cfg(test)]`: unit-like и integration tests — отдельные `tests/*.rs`.
5. Не создавать crate ради каждого типа; новая граница crate требует независимой ответственности и односторонних зависимостей.
6. `workspace/tools/check_layout.py` проверяет лимиты для `.rs`, `.slint`, `.md` и конфигурации. Не обходить скрипт переименованием файла.
7. Исключение: дословные тексты лицензий (`LICENSE`, `LICENSES/`) — не авторские файлы; не править и не сокращать.
## Documentation & comments (English)
- Public crates: `//! Module or crate description.`
- Public types, traits, methods: `/// Summary.` — **rustdoc** (Rust-аналог JavaDoc).
- Для нетривиальных API применять секции `# Arguments`, `# Returns`, `# Errors`, `# Panics`, `# Examples`, `# Safety` где уместно.
- Комментарии внутри исходников — **English**, поясняют *почему*, а не буквально *что* делает строка.
- Текст документации в `docs/` и issue допускается на русском.
```rust
/// Finds a route that satisfies the traffic class policy.
///
/// # Arguments
/// - `class`: The traffic class to schedule.
///
/// # Returns
/// A route, or `None` when no eligible path exists.
///
/// # Errors
/// This operation currently does not return I/O errors.
pub fn find_route(class: TrafficClass) -> Option<Route> { /* example */ None }
```
## Архитектурные принципы
- **KISS:** сначала простейшая проверяемая реализация; избегать преждевременного async/actor/DI-фреймворка.
- **DRY:** общая логика живёт в одном crate; не превращать каждый похожий `match` в абстракцию.
- **SOLID:** маленькие интерфейсы (`Transport`, `RoutePlanner`), разделение политик и механики, инверсия зависимостей на границе с железом.
- **Hexagonal architecture:** UI и сеть — адаптеры; алгоритмы **не** импортируют GUI и операционную систему.
- Детерминированность симулятора: фиксированные seed, стабильный порядок событий, симулированное время.
- Одна ответственность на модуль; публичный API минимальный; ошибки типизированные, не `panic` на входных пакетах.
## Код, качество, безопасность
- Rust Edition 2024, `resolver = "3"`; версия инструмента согласуется с версиями GUI.
- Не применять `unsafe` без ADR + ревью; `unwrap()` в обработке входных данных запрещён.
- Запретить секреты, токены, приватные ключи и реальные данные пользователей в git/фикстурах.
- Test Pyramid: проверка инвариантов → integration → сценарии города → hardware-in-the-loop.
- Криптографическая «угроза» от ICE: только **локально разрешить/отказать/ограничить/залогировать**; никаких ответных атак.
- Code review по контрактам, тестам, потреблению RAM/airtime, privacy и зависимости.
## Definition of Done для PR
- [ ] Лимиты 250/4, rustdoc на новых публичных API, тесты в `tests/`.
- [ ] `cargo fmt`, `cargo clippy`, `cargo test` без ошибок.
- [ ] Указано, какие сценарии покрыты, какие риски и какие измерения получены.
- [ ] Не заявлена совместимость/безопасность без тестов, лицензия зависимостей проверена.
## Внешние зависимости (MVP)
- Библиотечные крейты по умолчанию работают **без crates.io-зависимостей**.
- Каждая новая зависимость требует краткого обоснования: функция, лицензия, MSRV,
транситивные зависимости, поддержка, альтернатива на std.
- GUI-зависимости только в `apps/icenet-city`, никогда в `icenet-core`/`icenet-sim`.
- Для Slint выключены defaults: без Qt, Skia, WGPU, webview, tokio или serde.
- `slint-build` нужен только для компиляции `.slint` в `build.rs`.
- В версии 0.3 GUI: Slint 1.18.1, software renderer и Winit (desktop Linux).
- Поставляемые программы требуют проверки лицензий, особенно Slint.
- Лицензия собственного кода: **LGPL-3.0-or-later** (`license` в `workspace/Cargo.toml`; каждый crate наследует её). Код других проектов с несовместимой лицензией не копировать.
- После обновления GUI **перегенерировать и закоммитить новый `Cargo.lock`**.

94
TODO.md Normal file
View file

@ -0,0 +1,94 @@
# TODO · план ICE-NET (v0.4)
> Отмечай только после **измеренного результата**. Этап не считается готовым по факту написания документа.
> Приоритет: P0 — обязательно, P1 — после первого прототипа, P2 — позже.
> Числа и результаты проверок — только в [docs/STATUS.md](docs/STATUS.md).
## P0 · подготовка и изучение (Этап 0)
- [ ] Прочитать [Reticulum manual](https://reticulum.network/manual/) и проверить его текущие QoS, discoverable interfaces, blackhole и transport modes.
- [ ] На Arch поднять 2 локальных Reticulum-инстанса, провести обмен текстом и файлом; записать команды, задержки и неожиданности.
- [ ] Проверить Meshtastic **без покупки радио** по документации и доступным симуляторам/эмуляторам; позже протестировать 2 платы.
- [ ] Сформулировать **один измеримый разрыв** относительно Reticulum/Meshtastic; пока гипотеза: политика data/control path selection.
- [ ] Оформить ADR: строим свой wire-протокол или слой политики/плагин поверх готового стека.
- [ ] Не копировать исходники Reticulum до правового анализа его **нестандартной лицензии**.
## P0 · Slint и контроль зависимостей (v0.3)
- [x] Удалить прямой `egui/eframe` и вынести декларативную UI в `.slint`.
- [x] Выключить default-features Slint; включить только Winit + software renderer.
- [x] Оставить все базовые библиотеки без внешних crates.io-зависимостей.
- [x] Добавить отдельные state-тесты без графического backend.
- [x] Исправить конфликт 4 файла vs `Cargo.lock` в `check_layout.py`.
- [x] **На Arch собрать Slint 1.18.1** (результаты проверок — в STATUS).
- [ ] Замерить RSS и холодный старт Slint GUI в release (сравнение с egui снято: старого проекта нет).
- [x] Сгенерировать новый `Cargo.lock`; старый `Cargo.lock` с egui **не использовать**.
- [x] `cargo fmt`, `cargo clippy`, `cargo test` на Slint-сборке.
- [x] Вручную проверить перетаскивание точек, линии и элементы боковой панели (X11/Xvfb + XTest).
- [ ] Уточнить режим распространения ПО и выполнить обязательства лицензии Slint.
## P0 · Rust workspace и правила
- [x] Установить `rustup`, Rust toolchain, `rustfmt`, `clippy` и `python3` на Arch.
- [x] `python3 workspace/tools/check_layout.py` проходит без исключений.
- [x] `cargo fmt --all -- --check`, `cargo clippy --workspace --all-targets -- -D warnings`.
- [x] `cargo test --workspace`, включая отдельные файлы в `tests/`.
- [x] Все публичные API документированы в rustdoc на английском, без JavaDoc-синтаксиса `/** */`.
- [x] Зафиксировать **новый** Cargo.lock после разрешения Slint-графа для GUI/daemon.
## P0 · интерактивный город (M0)
- [x] Запустить `cargo run -p icenet-city` и проверить создание/отключение линков.
- [x] Визуально выбрать отправителя и получателя, послать Text и Photo.
- [x] Проверить: Photo **никогда** не выбирает slow-only маршрут.
- [x] Проверить: Text может пройти через slow radio, если другого пути нет.
- [x] Отключить транзитный узел, убедиться в QUEUED/NO_ROUTE и повторной попытке.
- [x] Одинаковый сценарий и действия → байт-в-байт одинаковые CSV/JSON.
- [ ] Seeded случайные отказы линков/узлов. **`seed` не реализован**; детерминизм сейчас обеспечен отсутствием случайности.
- [x] Добавить экспорт JSON сценария/CSV метрик.
## P0 · CLI без GUI (headless)
- [x] `icenetd route` — путь/NO_ROUTE по demo-топологии и отключённым линкам.
- [x] `icenetd send` — статусы Delivered/Queued/Expired с TTL и виртуальным временем.
- [x] `icenetd sim` — детерминированный сценарий + экспорт CSV/JSON.
- [x] `icenetd policy` — Permit/Deny с причиной (ACL, размер, authenticated).
- [x] `icenetd wire-encode/wire-decode` — roundtrip чернового кадра.
- [x] CLI integration tests запускают реальный бинарник.
- [x] `icenetd serve`/`send-udp` поверх UDP adapter (сеть, без GUI).
## P1 · инженерные измерения и безопасность
- [ ] 100/1000 узлов, p50/p95 поиска маршрута, delivery ratio, control airtime, RAM.
Частично, цифры — в STATUS. RAM на 1000 узлов и release-замеры — позже.
- [x] Исправить ложный `DELIVERED` при обрыве маршрута до крупного шага времени (регрессионные тесты).
- [x] Класс трафика выводится из размера (Control ≤ 256 Б, Text ≤ 4096 Б, иначе Bulk).
- [x] Ёмкость линка: слоты эфира, очередь на ребре, `slow_radio_airtime_ms`.
- [ ] Генератор служебного (announce/discovery) трафика — без него H4 не проверить.
- [ ] Метрика задержки от создания сообщения (`first_route_ms` сейчас — абсолютная метка).
- [ ] Выбор пути с учётом бэклога линков и перепланирование с текущего узла, не с источника.
- [ ] Сравнить результаты с базовыми алгоритмами, не делать заявлений о превосходстве без данных.
- [ ] Выбрать криптосхему в ADR + тест-векторы; до этого не заявлять E2E-защиту.
- [x] Реализовать replay window, ACL, rate limit, лимиты очередей.
- [x] Детерминированный fuzz-smoke парсера (10 000 входов, без паник).
- [ ] Полноценный fuzz-прогон (cargo-fuzz/OSS-Fuzz) и очередь с квотами/TTL.
- [x] UDP adapter (std::net) + loopback integration test.
- [ ] A-B-C в трёх network namespaces с `tc netem`.
- [ ] Store-and-Forward: TTL и явные QUEUED/DELIVERED/EXPIRED есть, но сообщение хранится
в общем списке, а не на узле. Нет хранения на промежуточных узлах, квот и store-carry.
- [ ] Обсудить телефон+ПК: модель пользователя и несколько DeviceID.
## P2 · реальное радио и экосистема
- [ ] Подключить готовый RNode/LoRa адаптер и измерить фактический airtime.
- [ ] Изучить законодательство конкретной страны до передачи в эфир.
- [ ] Wi-Fi mesh / направленный backhaul, затем мобильные SDK (UniFFI — кандидат).
- [ ] Опубликовать один воспроизводимый сценарий + метрики; затем искать коллег.
- [x] Выбрать лицензию кода (LGPL-3.0-or-later) и `git init`; первый коммит — по решению автора.
- [ ] Опубликовать репозиторий (<https://git.wihuk.pro/boba/ICE-NET.git>) после первого коммита.
## Решение, которое нужно принять первым
**Что делаем на старте?** Рекомендация: отдельная симуляция и независимый Rust API,
без объявления собственного сетевого протокола «стандартом» и без беспроводного железа.
См. [вопросы для автора](docs/review/questions.md).

12
archive/README.md Normal file
View file

@ -0,0 +1,12 @@
# Архив первичного исследования (2026-11-12)
Здесь **сохранены все 34 исходных Markdown-файла** из ICE-NET research-draft-0.1.
Папки глубже разбиты исключительно для нового правила «не более 4 файлов на каталог».
Внутренние относительные Markdown-ссылки переназначены на новые пути.
- [Оригинальный README](README_0.1.md)
- [Оригинальный START_HERE](START_HERE_0.1.md)
- [Источники S01–S30](sources/part1.md) и [S31–S60](sources/part2.md)
**Внимание:** архивные гипотезы не становятся утверждёнными решениями. Смотри актуальные
[README](../README.md), [правила](../RULES.md), [сравнение](../docs/research/gaps.md).

68
archive/README_0.1.md Normal file
View file

@ -0,0 +1,68 @@
# ICE-NET — исследовательский пакет проекта автономной гибридной сети
**Версия заметок:** `research-draft-0.1`
**Дата проверки:** 2026-11-12
**Язык:** русский
**Статус:** концепция и план экспериментов, **НЕ готовый протокол**.
> **Коротко.** ICE-NET — идея децентрализованной сети, способной работать через интернет, Wi-Fi, кабель, радиорелейные каналы и низкоскоростное радио; сохранять идентичность устройств независимо от физического адреса; доставлять сообщения по нескольким переходам и переживать разрывы связи. Защитный компонент условно называется **ICE Guard**. Глобальное покрытие пока только долгосрочная цель.
## 🧭 Как читать
1. [Начни здесь: сводка на одной странице](START_HERE_0.1.md).
2. [Общая архитектура](project/foundation/architecture.md) → [требования](project/foundation/requirements.md) → [ограничения и риски](project/governance/risks.md).
3. [Идея адресов и идентичности](protocol/foundation/identities_addresses.md) → [пакеты](protocol/foundation/packet_wire_format.md) → [маршрутизация](protocol/control/routing.md).
4. [Радио](radio/physical_links.md) → [вышки и магистрали](radio/backhaul_city_deployment.md) → [закон и частоты](radio/legal_spectrum.md).
5. [ICE Guard](security/ice_engine.md) → [модель угроз](security/threat_model.md).
6. [Что существует в мире](research/comparison.md) → [новое в 2025–2026](research/2025_2026_updates.md) → [чтение по темам](research/reading_list.md).
7. [MVP без бюджета](implementation/mvp_zero_budget.md) → [симулятор](implementation/simulation.md) → [тесты](implementation/tests_metrics.md).
8. [Где искать команду](community/projects_people.md) → [Reddit и стратегия](community/reddit_strategy.md) → [текст объявления](community/call_for_collaborators.md).
## 🗂️ Карта разделов
| Папка | Что внутри |
|---|---|
| [`project/`](project/foundation/vision.md) | миссия, архитектура, решения, риски |
| [`protocol/`](protocol/foundation/overview.md) | идентичность, адресация, формат пакетов, discovery, маршруты, QoS, DTN |
| [`radio/`](radio/physical_links.md) | физическая связь, направленные мосты, радиоправила |
| [`security/`](security/ice_engine.md) | ICE, криптография, приватность и модель атак |
| [`research/`](research/comparison.md) | сравнение с реальными проектами, новое в 2025–2026 |
| [`community/`](community/projects_people.md) | сообщества и публичные контакты разработчиков |
| [`implementation/`](implementation/roadmap.md) | реализация, эксперимент, тестовые сценарии и roadmap |
| [`docs/`](docs/glossary.md) | глоссарий, открытые вопросы, хронология разговоров |
| [`SOURCES.md`](sources/part1.md) | **60 пронумерованных ссылок**: RFC, мануалы, проекты, комьюнити |
## 🧩 Ядро идеи
```text
ICE-NET: логическая адресация и доставка
┌────────────────────────────────────────────────────┐
│ Приложения: текст / фото / файлы / сервисы │
├────────────────────────────────────────────────────┤
│ ID узла + ID сервиса + E2E-защита + ICE Guard │
├────────────────────────────────────────────────────┤
│ Discovery / routing / store-and-forward / QoS │
└────────────────────────────────────────────────────┘
│ │ │ │
Интернет Wi-Fi Mesh LoRa / радио Ethernet
(временно) (быстрые) (служебный) (магистраль)
```
**Ключевая идея пользователя:** узкая радиополоса — преимущественно для поиска соседей, малых сообщений и объявления доступности. Большие объёмы (например, фото) идут только по найденному быстрому маршруту. Если быстрого маршрута нет — честно показываем задержку и предлагаем отложенную доставку, а не засоряем радио.
## Что НЕ утверждается
- «Без IP» означает: **ICE-NET не обязан использовать IP для собственных адресов и пакетов**. В гибридном режиме IP/UDP может быть одним из транспортов.
- Нет обещания бесплатного глобального покрытия: нужна физическая инфраструктура, спектр, энергия, администрирование и пользователи.
- LoRa не измеряет автоматически точную дистанцию и не подтверждает личность человека.
- Модель ICE не должна «атаковать хакера в ответ»: политика — локальная защита, аутентификация, ограничение ресурсов и отчётность.
- Слово **ICE** также закреплено за действующим IETF-протоколом NAT traversal ([RFC 8445](https://www.rfc-editor.org/info/rfc8445/)). В будущем бренд модуля безопасности потребуется уточнить.
- Здесь нет нового проверенного криптографического примитива. Для MVP берём стандартные решения.
## Главная рекомендация
**Не начинать с форка Linux и закупки вышек.** Сначала proof-of-concept на одном Arch Linux, затем проверка у сообщества, затем низкобюджетный физический тест. См. [roadmap](implementation/roadmap.md).
## Лицензии и авторство
Это новый текст исследовательского досье, подготовленный по запросу. Архив **не содержит копий стороннего исходного кода или RFC**; вместо них — ссылки. Лицензию будущего публичного репозитория нужно выбрать отдельно после обсуждения (MIT/Apache-2.0 для кода, CC BY для собственных документов — лишь варианты, не назначенные лицензии). Не присваивай себе права на сторонние разработки.

36
archive/START_HERE_0.1.md Normal file
View file

@ -0,0 +1,36 @@
# За 5 минут: суть ICE-NET
## Цель
Построить сеть, в которой *идентичность* устройства не зависит от IP, операторов, дата-центров и центрального DNS. Она должна объединять любые физические линии, работать локально при падении глобального интернета и постепенно расширяться от пары компьютеров до радиомагистралей.
## Основная архитектурная ставка
- **Discovery / контроль:** небольшой объём объявлений по медленным каналам; ограничения количества, TTL и эфирного времени.
- **Data plane / пользовательский трафик:** большой файл только через маршруты с достаточной пропускной способностью; запрет случайного переноса фото через LoRa.
- **Addressing:** криптографическая идентичность узла и независимый идентификатор сервиса. Это **не** новые стандартные TCP-порты.
- **Routing:** поиск следующего перехода, ограниченная область распространения объявлений, метрики качества; допустима задержанная доставка.
- **ICE Guard:** небольшой детерминированный защитный компонент на CPU без GPU; поведение + правила + контроль лимитов.
- **Transport adapters:** UDP/QUIC, LAN, Wi-Fi, serial/LoRa, радиорелейная линия, Ethernet; всё опционально.
## Неприятные, но важные факты
1. Сеть без IP-адресов на логическом уровне **не отменяет** радиофизику и требования законодательства.
2. Даже при красивой маршрутизации фотографии не передать быстро, если каждый возможный физический путь медленный.
3. Масштабирование — не «хранить хеши всех пользователей на каждой вышке»: нужны иерархия / ограничение анонсов / кэш / запрос по требованию.
4. Большая общая база местоположений создаёт слежку. Приватность должна быть встроена изначально.
5. «Порт 77777» возможен как виртуальный ID сервиса ICE-NET, но **не** как стандартный TCP/UDP-порт ([S01](sources/part1.md#s01)).
6. Похожий подход уже демонстрирует [Reticulum](sources/part1.md#s13); лучше изучить и протестировать его, прежде чем писать всё с нуля.
## 3 первых действия без расходов
1. Записать 10 измеримых требований и модель угроз: [требования](project/foundation/requirements.md).
2. Поднять симулятор 10–100 узлов на одном ПК: [сценарии](implementation/simulation.md).
3. Выставить черновик спецификации на обсуждение (без обещания «заменим интернет»): [сообщества](community/projects_people.md), [пост](community/call_for_collaborators.md).
## Сейчас не делать
- не переписывать ядро Linux;
- не изобретать криптографию;
- не закупать дорогие 60-ГГц мосты до радиопланирования;
- не обещать защиту от полного отключения энергии, массовых помех или отсутствия физического канала.
Составной обзор: [сравнение проектов](research/comparison.md), [новинки 2025–2026](research/2025_2026_updates.md), [источники](sources/part1.md).

View file

@ -0,0 +1,35 @@
# Переход с v0.2 (egui) на v0.3 (Slint)
> **Исторический документ.** Миграция выполнена, Slint собирается и проверен (см. [STATUS](../../docs/STATUS.md)).
> Старого checkout с egui не существует, шаги ниже сохранены только как запись.
В v0.3 изменён GUI; алгоритмы маршрутизации, пакеты и тесты доменных
крейтов сохранены из v0.2. Старый `ice-net-v0.2-fix.patch` больше не требуется:
он исправлял eframe API и относится только к удалённым исходникам egui.
## Для существующего checkout
1. Сохрани незакоммиченные изменения.
2. Замени файлы из v0.2 на новую структуру v0.3.
3. Удали старые `apps/icenet-city/src/app.rs` и `map.rs`, если они остались.
4. Удали **старый** `workspace/Cargo.lock`, который фиксировал egui/eframe.
5. Убедись, что появился `apps/icenet-city/ui/main.slint`.
6. Пересоздай `Cargo.lock`, проверь компиляцию и закоммить lockfile.
```bash
cd workspace
cargo generate-lockfile
python3 tools/check_layout.py
cargo fmt --all
cargo clippy --workspace --all-targets -- -D warnings
cargo test --workspace
cargo run -p icenet-city
```
## Как оценивать результат
- Разделение GUI/симулятора важнее количества строк интерфейса.
- Для v0.3 прямых внешних зависимостей GUI только две (runtime/build-time),
но число транзитивных dependencies неизвестно до генерации lockfile.
- Slint **не гарантирует** меньший size/compile-time относительно egui.
Измерь это на одной машине, одном toolchain, с чистым `target`.

View file

@ -0,0 +1,38 @@
# Черновик объявления для поиска единомышленников
> Можно размещать после появления репозитория и одного воспроизводимого теста. Переменные в `[квадратных скобках]` заполнить реальными данными; не заявлять несуществующие достижения.
## Русская версия
### ICE-NET: исследовательский протокол для автономной гибридной mesh-сети
Исследую концепцию сети, которая может жить без центрального DNS или обязательного провайдера и поддерживает разные физические линии: провод, Wi-Fi, направленные радиомосты, интернет-туннель и узкополосное радио. Низкоскоростной канал предназначен прежде всего для обнаружения соседей, коротких сообщений и маршрутов; большие файлы должны идти только через подходящую быструю линию или откладываться.
Основные направления: ключевая идентичность узла независимо от IP, минимальный control plane, multi-hop, DTN/store-carry-forward, управление пропускной способностью и лёгкая локальная защита ICE Guard. Уже сравниваю Reticulum, Meshtastic, Babel, BPv7, libp2p и AREDN — **не утверждаю, что придумал всё с нуля**.
Пока это draft, не готовый продукт. Ищу конструктивное ревью архитектуры и идеи для самого маленького воспроизводимого теста на Linux (1 ПК, 10–100 виртуальных узлов). Особо интересны люди с опытом routing, LoRa, Wi-Fi mesh, Rust, threat modeling, SDR и community networks. Не обещаю оплату/релиз/покрытие.
- Архитектура: `[ссылка на репозиторий/документ]`
- Технический вопрос: «как ограничить control-plane airtime при изменении топологии и не потерять discovery?»
- Демо/тесты: `[действительная ссылка, если появились]`
## English version
### ICE-NET: exploring a transport-agnostic, disruption-tolerant community mesh
I'm researching an experimental networking architecture that does not require IP addressing at its logical layer or a central server. The idea is to use low-bandwidth links (e.g. LoRa) primarily for bounded discovery/control traffic and small messages, while sending bulk data over whatever high-capacity physical route is actually available (Wi-Fi, Ethernet, point-to-point radio links or Internet tunnels). When no suitable path exists, delivery may be deferred rather than saturating a shared radio channel.
The design topics are cryptographic node identity, service identifiers, constrained control plane, multi-hop routing, QoS, store-carry-forward, and a small local policy engine (working name: ICE Guard). I'm studying existing work including Reticulum, Meshtastic, Babel, BPv7, libp2p and AREDN, not claiming to reinvent those systems.
It's an early research draft, **not a working global network**. I'm looking for technical criticism and collaborators willing to help define a tiny reproducible Linux simulation. Especially interested in mesh routing, RF/SDR, DTN, security and Rust systems programming. No funding or compensation is promised.
- Draft: `[actual public URL]`
- Proposed first benchmark: control-plane airtime and recovery after link loss on a 10–100-node virtual network.
- Specific question: What failure mode would you test first, and what existing protocol should I study before implementing this?
## Не писать так
- «Никто никогда такого не делал» — неверно.
- «Будет покрывать весь мир бесплатно» — физически не обосновано.
- «Нейронная ICE непобедима» — нет security evidence.
- «Защищено от всех атак» — нет аудита.

View file

@ -0,0 +1,48 @@
# Где искать людей и партнёров — реальные входы в сообщества
> «Люди, с которыми можно было бы реализовать» — **публичные проекты, рабочие группы и их авторы**, а не обещание их участия. Не пишем, что кто-то согласился или ищет работу. Начинать стоит с общего канала проекта и конкретного технического вопроса, а не с массовой личной рассылки.
## Самые практичные направления
| Организация / проект | Чем помогут в теории | Куда заходить |
|---|---|---|
| **Reticulum** | криптографические ID, низкая полоса, transport adaptation | [официальный manual](../sources/part1.md#s13), [зеркало GitHub/предупреждения](../sources/part1.md#s16) |
| **Meshtastic** | узкополосная LoRa mesh, эфир, буферы, Next-Hop | [документация](../sources/part1.md#s17), [r/meshtastic](../sources/part2.md#s50) |
| **AREDN** | реальная эксплуатация узлов, Babel, Wi-Fi HaLow | [официальный сайт](../sources/part1.md#s24), [release notes](../sources/part2.md#s35) |
| **NYC Mesh** | построение городской инфраструктуры, rooftop, карта | [volunteer / Slack / onboarding](../sources/part2.md#s45) |
| **Freifunk** | региональные mesh-сообщества и разработчики OpenWrt | [как вступить](../sources/part2.md#s46) |
| **guifi.net** | устойчивое совместное управление инфраструктурой | [платформа и гайды](../sources/part2.md#s47) |
| **Wireless Battlemesh** | личная сеть разработчиков routing/firmware | [сайт](../sources/part2.md#s48), [прошедший v18, 2026](../sources/part2.md#s49) |
| **IETF MANET** | routing в мобильных ad-hoc сетях | [WG и открытая рассылка](../sources/part1.md#s10) |
| **IETF DTN** | отсутствие непрерывного пути, стандарты BP | [WG](../sources/part1.md#s11), [документы 2026](../sources/part1.md#s12) |
| **rust-libp2p** | дешёвый P2P MVP, peer discovery, релеи | [Discussions и форум](../sources/part1.md#s22) |
| **GNU Radio** | SDR и модуляция, эксперимент в симуляции | [сообщество/релиз](../sources/part2.md#s34) |
## Публично известные технические участники, работы которых стоит читать
- **Mark Qvist** — автор/сопровождающий Reticulum reference implementation; README зеркала чётко объясняет, куда относится официальный процесс разработки ([публичный проект](../sources/part1.md#s16)). Сначала читать manual и уважать указания о допустимом использовании кода.
- **Juliusz Chroboczek** и **David Schinazi** — авторы [Babel RFC 8966](../sources/part1.md#s06); прежде чем задавать вопросы, изучить RFC и публичные дискуссии IETF.
- **Don Fedyk, Donald E. Eastlake 3rd, Ronald in ’t Velt** — перечислены как председатели [IETF MANET](../sources/part1.md#s10) на дату проверки; обращаться через **рабочую группу**, а не угадывать частные контакты.
- **Josh Morman** — опубликован как автор сообщения о [GNU Radio 4 RC3](../sources/part2.md#s34); обсуждать идеи SDR через публичные каналы проекта.
Наличие имени в документации **не** означает интерес к ICE-NET, доступность к сотрудничеству или разрешение использовать чужой код.
## Какие специалисты нужны в реальности
1. **Network protocol engineer:** статусы узлов, адреса, congestion/routing/DTN.
2. **Wireless/RF engineer:** link budget, радиомонтаж, антенны и правовой частотный план.
3. **Systems developer (Rust/C):** быстрый стабильный core и adapters для ARM/x86.
4. **Security engineer:** threat modeling, криптографические протоколы, fuzzing.
5. **Android/iOS developer:** реальная поддержка Wi-Fi Aware, фоновая работа и батарея.
6. **Community network organizer:** люди, крыши, бюджет, инфраструктурное обслуживание.
7. **Technical writer / translator:** спецификации и onboarding.
## В какой последовательности выходить на людей
1. Показать **одну страницу архитектуры** и **один воспроизводимый опыт**.
2. Уточнить узкую проблему: например, «как ограничивать объявления на 1 кбит/с при изменяющейся топологии?».
3. Спросить, не реализовано ли это уже; попросить ссылку на prior art.
4. Опубликовать маленький тест/таблицу, исправить ошибки после обратной связи.
5. Только затем приглашать участвовать в разработке или запуске узла.
**Не обещать зарплату, гранты, глобальный запуск и аудит, которых нет.** Репутация инженерного проекта строится на открытых проверяемых результатах.

View file

@ -0,0 +1,41 @@
# Reddit и публичное сообщество: как собрать команду
## Существующие сабреддиты, которые проверены
| Площадка | Тема | Какой пост уместен |
|---|---|---|
| [r/meshtastic](../sources/part2.md#s50) | LoRa/low-speed mesh | конкретные эфирные ограничения, discovery, hardware |
| [r/darknetplan](../sources/part2.md#s51) | независимая инфраструктура | архитектура и поиск похожих проектов |
| [r/amateurradio](../sources/part2.md#s52) | радио | законность, link budget, практические измерения |
| [r/selfhosted](../sources/part2.md#s53) | автономные сервисы | пользовательские сценарии и hosted relays |
| [r/Lora](../sources/part2.md#s54) | LoRa/радиомодули | PHY и ограничения канала |
| [r/ReticulumNetwork](../sources/part2.md#s55) | тема подходит | на дату проверки постов не было: не рассчитывать на аудиторию |
| [r/Meshnet](../sources/part2.md#s56) | много тем о домашнем mesh Wi-Fi | не оптимальная площадка для новых routing-протоколов |
**Перед публикацией** читать правила каждого сабреддита. В Reddit много практических наблюдений, но не все мнения и обещания основаны на измерениях; проверять через RFC и стенды.
## Делать ли собственный subreddit?
**Не в первый день.** Свой сабреддит без участников почти не решает проблему набора команды. Разумнее начать с публичного репозитория, issue-tracker и 2–3 точных обсуждений в существующих сообществах. Собственный `r/ICE_NET` или похожее имя возможно только после проверки доступности названия и появления регулярных обновлений; наличие сообщества с таким адресом **не проверено и не утверждается**.
## Хороший первый пост
Не «Я изобрету новый интернет, кто со мной?»; лучше:
> Исследую transport-agnostic сеть без обязательных IP-адресов в overlay: LoRa только для маленьких discovery-анонсов, файлы через Wi-Fi/проводные/направленные backhaul, DTN при разрывах. Есть требования и таблица prior art (Reticulum, Meshtastic, Babel, BPv7). Какие фундаментальные ошибки в модели и какой тест измерить первым?
Здесь есть узкая техническая тема и уважение к уже существующим работам.
## Что сделать, чтобы не превратить сообщество в спам
- На каждой площадке — **разный вопрос**, релевантный теме, без массового одинакового текста.
- Первый пост содержит архитектуру, конкретные ограничения и ссылку на воспроизводимый эксперимент.
- Ясно сказать, что это draft, не релиз/готовая сеть и не инвестиционный сбор.
- Публиковать измерения, негативные результаты и исправления ошибок.
- Документировать Code of Conduct, процесс отзывов по security, contribution guide и список good first issues.
## Практический минимальный набор
`README.md` → `ARCHITECTURE.md` → `tests/` с графиками → `good-first-issues` → публичный чат/форум. Когда есть живые 10–20 участников, обсуждать отдельный subreddit и модерацию.
Текст объявления на двух языках: [call_for_collaborators](call_for_collaborators.md).

17
archive/docs/changelog.md Normal file
View file

@ -0,0 +1,17 @@
# История досье
## 2026-11-12 — Research draft 0.1
Собран первый архив markdown. Содержание: цели, архитектура, адресация, service ID, wire-format предложение, малоскоростное discovery, маршруты, QoS, DTN, ICE Guard, threat model, физические радиоканалы/магистрали, закон ЕС/CEPT, сравнение проектов, актуальные 2025–2026 изменения, сообщества и поэтапный MVP.
**Подтверждено официальными источниками:** существование RFC 10069 от ноября 2026; IETF DTN обновления осени 2026; архитектура Reticulum и Meshtastic; AREDN и Wi-Fi HaLow; WBA Wi-Fi 7 MLO испытания 2026; GNU Radio 4 RC3 2026; современные нормы ЕС/CEPT.
**Не подтверждено как работающее:** собственный ICE-NET wire format, универсальные адреса и discovery, глобальные маршруты, масштабируемая схема хешей на вышках, безопасность ICE Guard и экономическая осуществимость полного покрытия. Это исследовательские предложения.
## Что изменить в следующей версии
- Реальная таблица измерений после симулятора.
- Сравнить Airtime/announce budget с эталонным Reticulum и Meshtastic.
- Зафиксировать threat model и криптографические алгоритмы после review.
- Оценить стоимости двух-трёх типичных городских радиолиний с разрешённым железом.
- Опубликовать первую воспроизводимую demo-topology и получить отзывы экспертов.

View file

@ -0,0 +1,39 @@
# Открытые инженерные вопросы для следующих итераций
## Архитектура
- Нужен ли новый протокол вместо адаптации Reticulum? **Какая одна функция отсутствует в существующем стеке?**
- Отделять ли идентичность пользователя от идентичности физического ретранслятора?
- Как реализовать смену ключей и восстановление идентичности без центра?
- Стоит ли NodeID адресовать саму конечную машину, сервис или группу?
## Routing
- Как ограничить маршрутизаторную информацию в LoRa до заданного airtime budget?
- Как выбирать путь с низкой латентностью, не забивая канал неверными метриками?
- Как разделять лес локальных domain'ов и long-haul backbone?
- Что делать при взломанных relay, ложных объявленных метриках и Sybil?
- Можно ли доказать отсутствие циклов при комбинированных алгоритмах?
## Приватность
- Как сохранять поиск друзей без глобальной геолокации и постоянных маяков?
- Как обеспечить приватный discovery с минимальным размером пакета?
- Нужна ли анонимность? Если да, какую угроз-модель реально выдержать?
## Радиофизика
- Что быстрее и дешевле в конкретной местности: 5 ГГц P2P, 802.11ah, 60 ГГц или оптика?
- Какие погодные условия, зона Френеля и высоты нужны на конкретной линии?
- Какой национальный радиорежим разрешает фактическое оборудование и мощность?
## Организация
- Есть ли городское сообщество, готовое поставить один relay и измерять сеть месяц?
- Какая модель распределения затрат и ответственности за rooftop?
- На какой лицензии выпускать reference implementation и public specification?
- Как принять security bug без публичного раскрытия уязвимости до исправления?
## Проверка гипотез
Самый полезный первый сравнительный эксперимент: два алгоритма discovery на одинаковой 100-node топологии, ограничение медленного интерфейса 1 кбит/с, измерения control overhead, p95 route time, errors и energy estimate. Числа — **сценарные**, не измеренная физика.

34
archive/docs/glossary.md Normal file
View file

@ -0,0 +1,34 @@
# Глоссарий ICE-NET
- **Overlay** — логическая сеть поверх существующих транспортов; может использовать IP как носитель, не используя его как собственный ID.
- **Underlay** — физическая/существующая транспортная сеть.
- **NodeID** — криптографическая идентичность устройства или узла, не координаты.
- **Locator** — временный способ добраться до узла через определённый интерфейс/ретранслятор.
- **ServiceID** — логический ID сервиса, потенциально 64-битный; это не TCP-порт.
- **Control plane** — discovery/объявления/маршрутная информация.
- **Data plane** — передача пользовательской нагрузки.
- **Backhaul** — магистральная связь между узлами/вышками.
- **Mesh** — сеть с несколькими равноправными/ретранслирующими узлами; не обязательно полностью децентрализована.
- **Multi-hop** — передача через последовательность устройств.
- **Broadcast / flooding** — рассылка нескольким соседям; дорого в радиоэфире.
- **Next hop** — следующий узел в направлении конечного адресата.
- **DTN** — сеть с длительными задержками и периодическими разрывами связи.
- **Store-carry-forward** — временное хранение и передача при появлении контакта.
- **LoRa** — радиомодуляция для дальнобойной малоскоростной связи.
- **LoRaWAN** — отдельный MAC/network-протокол и экосистема поверх LoRa, не синоним LoRa.
- **Wi-Fi Aware / NAN** — прямое обнаружение nearby устройств без internet/AP при поддержке ОС и радиочипа.
- **802.11s** — Wi-Fi mesh-режим; требует аппаратной/программной поддержки.
- **802.11ah / HaLow** — Wi-Fi с суб-ГГц линком, специализированное оборудование.
- **MLO** — Wi-Fi 7 multi-link operation; несколько Wi-Fi линков.
- **FSO** — свободнопространственная оптическая связь, например оптический мост.
- **E2E encryption** — шифрование между конечными участниками, транзитным узлам ключи не предоставляются.
- **Sybil** — атака множеством поддельных идентичностей.
- **Eclipse** — вытеснение честных соседей/источников маршрутов контролируемыми атакующим узлами.
- **Anti-replay** — защита от повторного предъявления ранее корректного пакета.
- **ICE Guard** — условное название локальной защитной системы этого проекта.
- **IETF ICE** — совершенно другой протокол NAT traversal (RFC 8445), не Cyberpunk ICE Guard.
- **Proposed Standard** — статус части RFC, не то же, что Internet-Draft.
- **Internet-Draft** — рабочий черновик, может измениться или не стать RFC.
- **Goodput** — скорость передачи полезных данных после накладных расходов.
- **Airtime** — время занятия радиоканала передатчиком.
- **TTL** — срок или hop-budget доставки, чтобы пакеты не жили бесконечно.

View file

@ -0,0 +1,46 @@
# MVP без бюджета — Arch Linux, один ПК
## Цель первой версии
Сделать **один демон ICE-NET**, который запускает виртуальные NodeID, умеет передать зашифрованное маленькое сообщение по двум-трём hop и отказывается отправлять большой файл через slow-only маршрут. Не нужно модифицировать ядро Linux, создавать дистрибутив или покупать антенны.
## Приоритетные компоненты
```text
icenetd
identity/ generation, fingerprints, key storage
protocols/ messages, versioning, serialization, parser tests
routing/ neighbor table, weighted path, TTL, expiry
transports/ loopback + UDP; later: serial/LoRa + LAN
storage/ bounded queue / TTL / receipts
ice_guard/ ACL, rate limit, replay, audit
cli/ node, neighbors, send, routes, trace
simulator/ topology, delay, loss, throughput, churn
```
Предложение языка: **Rust** для mainline (типобезопасность и ARM/x86), с использованием существующих криптографических библиотек. C также возможен, но требует особенно строгой работы с памятью. Не привязываться к одному runtime на время проектирования спецификации.
## План на четыре небольшие вехи (без обещания дат)
### M0 — логическая пересылка
Три виртуальных узла `A-B-C`. Узел A знает только B, но доставляет текст C. Проверить ACK конечного получателя, ограничение TTL и dedup.
### M1 — две среды
`A-B` быстрый, `B-C` очень медленный. Симулировать 1 кбит/с; проверка, что короткий текст допускается, а фото не идёт автоматически.
### M2 — смена пути
Добавить `A-D-C`. Отключить B, повторить. Проверить route invalidation, loss и очередь.
### M3 — E2E + ICE Guard
Включить шифрование сообщений на endpoints, ACL сервисов, лимиты ресурсов, тест на поддельный пакет и spam flood.
## На чём испытывать
- Unix process + UDP loopback (для начала достаточно).
- Linux network namespaces и veth для более реалистичного поведения ([S40](../sources/part2.md#s40)).
- `tc netem` для задержки/потерь/скорости ([S41](../sources/part2.md#s41)).
- CORE/ns-3, если нужен более точный сетевой/RF симулятор ([S43](../sources/part2.md#s43), [S42](../sources/part2.md#s42)).
## Готовность для первой публичной демонстрации
В README должны быть шаги запуска на чистой машине, ожидаемое поведение, команда теста, один trace с 3 hops, негативный тест с большим payload, чётко отмеченные несделанные функции и security disclaimer.

View file

@ -0,0 +1,37 @@
# Roadmap: от идеи до сообщества (без придуманных сроков)
## Фаза A — требования / prior art
**Выход:** 1-страничная архитектура, сравнительная таблица альтернатив, модель угроз, список критериев невозможности. **Проверка:** другой разработчик понимает границу control/data и может назвать главный риск.
## Фаза B — симулятор на одном ПК
**Выход:** 10–1000 виртуальных узлов, фиксированные сценарии, профили медленного/быстрого канала, трассировка. **Проверка:** воспроизводимый тест после обрыва связи и запрет фото по slow link.
## Фаза C — overlay MVP
**Выход:** userland daemon, NodeID+ServiceID, encrypted text, UDP/LAN adapters, ICE Core, краткий API. **Проверка:** три реальных процесса по разным сетевым namespace.
## Фаза D — интеграция и сравнение
**Выход:** интеграционные испытания с Reticulum/Meshtastic/AREDN как *сравниваемыми эталонами*, а не выдача их кода за собственный. **Проверка:** публичные CSV, графики и честные ограничения.
## Фаза E — физический low-cost pilot
**Выход:** два радиоустройства/стационарных relay, законная работа в разрешённом диапазоне, реальная оценка airtime и packet loss. **Проверка:** измеренный бюджет канала и работа текстовых сценариев.
## Фаза F — локальная mesh-инфраструктура
**Выход:** несколько независимых реле и минимум два пути; приложение на компьютере/телефоне; безопасное обновление ПО. **Проверка:** восстановление связи после отключения одного реле.
## Фаза G — магистральные мосты
**Выход:** разрешённые размещения на крышах, направленная линия, учёт бюджета оборудования, локальная кооперация. **Проверка:** многодневные реальные измерения качества и отказов, законность.
## Фаза H — федерация и стандарт
**Выход:** независимые реализации или хотя бы независимая проверка, документированный wire format, управление версиями, governance и security disclosure. **Проверка:** две команды могут реализовать совместимые узлы без доступа к внутренним данным друг друга.
## Не перескакивать
Ни публичные сборы на мачты, ни форк дистрибутива Linux, ни заявление о новой безопасной глобальной сети до успешных фаз B–D. В любой фазе можно закрыть риск или поменять архитектуру, не «сжигать» годы на предположениях.

View file

@ -0,0 +1,43 @@
# Симуляция до покупки железа
## Зачем
На одном компьютере можно сравнить маршрутизацию, перегрузку и отказоустойчивость на сотнях узлов. Это не заменит физическое радио, но спасёт от нескольких месяцев разработки неверной идеи.
## Сценарии
| Сценарий | Топология | Что проверяем |
|---|---|---|
| A | 3 узла в цепочке | TTL, dedup, end-to-end ACK |
| B | 15 узлов, несколько путей | выбор next hop и восстановление после потери relay |
| C | 50 узлов, 1 кбит/с discovery | airtime, overhead, rate limits |
| D | 100 узлов, mobile churn | stale routes, reconnect, path search p95 |
| E | 1000 виртуальных узлов | RAM, CPU, таблицы, поток анонсов |
| F | 2 disconnected islands | store-carry-forward и честный статус без пути |
| G | 20% malicious peers | Sybil/flood/path poisoning, ложные блокировки |
| H | fast/slow mixed | 5MiB photo не забивает control plane |
## Модель физического канала
Для каждого edge хранить `available`, `capacity_bps`, `loss_rate`, `latency_ms`, `jitter_ms`, `energy_cost` и `airtime_budget`. Измеренные параметры отделить от придуманной симуляции. Начать с условных параметров и честно обозначать их как **сценарные**, а не реальные свойства LoRa/5GHz.
## Бесплатные инструменты
- **Свой дискретно-событийный симулятор**: самый дешёвый старт; логика событий, узлов, queues, TTL.
- **Linux namespaces**: настоящее сетевое ПО в изолированных сетевых окружениях ([S40](../sources/part2.md#s40)).
- **tc-netem**: имитация потерь, задержек, reorder ([S41](../sources/part2.md#s41)).
- **CORE**: графический и программный эмулятор сетей ([S43](../sources/part2.md#s43)).
- **ns-3**: более детальное моделирование среды и радио ([S42](../sources/part2.md#s42)).
- **Mininet**: простой быстрый стенд для логики сети ([S44](../sources/part2.md#s44)).
- **GNU Radio**: физические waveform/модуляции в симуляции, без разрешений на передачу, если нет реального излучения ([S33](../sources/part2.md#s33)).
## Минимальный эксперимент без shell-команд root
Собрать приложение из процессов/задач с `VirtualLink` и фиксированным `random_seed`. При каждом тесте записывать CSV: `time,node,event,from,to,bytes,channel,reason`. Затем вычислять [метрики](tests_metrics.md). Публичный результат должен включать topologies и seed, иначе benchmark нельзя повторить.
## Два почти наверняка важных отрицательных результата
1. Глобальный broadcast новых IDs перегрузит общий LoRa-канал при росте сети.
2. Aggressive learning ICE на нестационарных сетях будет ошибочно блокировать честных мобильных клиентов.
Оба тезиса — **гипотезы для проверки**, не измеренные результаты.

View file

@ -0,0 +1,47 @@
# Метрики, протоколы испытаний и критерии фальсификации
## Что мерить
| Метрика | Единица | Зачем |
|---|---|---|
| Delivery ratio | % сообщений, дошедших до адресата | основная функция сети |
| Time-to-first-route | p50/p95 секунд | discovery и routing |
| Time-to-recover | p95 секунд | self-healing после отказа |
| Control-plane airtime | % физического канала | предотвращение засорения LoRa |
| Goodput | полезных бит/с | отличие от линковой скорости |
| Bottleneck throughput | бит/с | видимость узкого hop |
| Tail latency | p99 мс/с | редкие тяжёлые задержки |
| CPU usage | % ядра / пакетов в секунду | слабые устройства |
| RAM per 1000 peers | MiB | масштабируемость |
| Storage per relay | MiB / TTL | злоупотребление DTN |
| False positive blocking | % нормального трафика | ICE качество |
| Metadata exposed | список полей / hop | приватность |
| Energy budget | mWh / переданный MiB | мобильные узлы |
## Первые гипотезы
- **H1:** адаптивные объявления с rate cap сохраняют более низкий control-plane airtime, чем регулярный flood в тех же условиях.
- **H2:** отделение пути DATA от discovery предотвращает переполнение медленного радио при передаче фото.
- **H3:** path cache снижает число route queries, но увеличивает stale route errors.
- **H4:** предельные политики ICE сохраняют RAM/CPU bounded при злонамеренном флуде.
Каждую проверять на одинаковом графе, seed, traffic pattern, времени работы и уровне потерь. Результаты должны включать отрицательные сценарии.
## Тестовые пакеты и fuzz
1. Неправильная длина пакета и неизвестные поля.
2. Повторный MessageID.
3. TTL=0, TTL переполнение, поддельные ACK.
4. Большие фрагменты и неограниченная reassembly.
5. Быстро меняющийся next hop.
6. 1000 случайных NodeID от одного радиоисточника.
7. Восстановление после отключения половины узлов.
8. Локальный сервис закрыт для чужих ключей.
## Что означало бы провал концепции
Если после разумной оптимизации control traffic растёт быстрее полезной пропускной способности медленных каналов; если нет возможности валидировать доставку без массового слежения; если цена хранения/перенаправления не ограничивается; если реальная радиофизика не позволяет полезные маршруты для целевого сценария без неприемлемой инфраструктуры. Тогда надо изменить архитектуру, а не скрывать результаты.
## Как оформлять бенчмарк
Один Markdown-отчёт, таблица CSV/JSON (будущий репозиторий), дата и hardware, commit hash, конфигурация, seed, график, выводы, ограничения. Не публиковать заявления «в 100 раз лучше Reticulum» без честных сравнимых измерений.

View file

@ -0,0 +1,59 @@
# Архитектура ICE-NET
## Слои
```text
┌───────────────────────────────────────────────┐
│ APP: chat / images / files / service API │
├───────────────────────────────────────────────┤
│ SERVICE: 64-bit ID / ACL / end-to-end crypto │
├───────────────────────────────────────────────┤
│ DELIVERY: sessions / chunks / receipts / DTN │
├───────────────────────────────────────────────┤
│ NETWORK: Node ID / routing / rate limits │
├───────────────────────────────────────────────┤
│ ADAPTERS: UDP / LAN / Wi-Fi / serial / LoRa │
└───────────────────────────────────────────────┘
│
physical medium
```
Это логическая модель **проекта**; ни один слой не объявлен существующим стандартом.
## Control plane и data plane разделены логически
- **Control plane**: HELLO, объявление доступности сервиса, получение кратких метрик, route discovery и отзыв устаревшего маршрута. Он имеет бюджет *на каждом физическом интерфейсе*.
- **Data plane**: реальные сообщения/файлы; может использовать несколько быстрых каналов, не обязан следовать тем же маршрутами, что маленькие радиопакеты.
- **Переменная задержка**: если путь отсутствует, для отдельных сервисов применяется DTN/очередь; не притворяемся, что соединение постоянно.
## Типы узлов
| Тип | Обязанности | Доступные среды |
|---|---|---|
| Client | Отправка/приём, иногда транзит по согласию | телефон, ПК |
| Relay | Ограниченный forward по заданным политикам | дом, крыша, маршрутизатор |
| Gateway | Мост между физическими средами | LoRa ↔ Ethernet; Wi-Fi ↔ microwave |
| Store | Защищённая очередь отложенных данных | всегда включённый узел |
| Backbone | Быстрые устойчивые линии | оптика/кабель/направленное радио |
Могут сочетаться на одном устройстве. Никто не обязан хранить полную глобальную таблицу пользователей.
## Сценарий «отправить фото»
1. Телефон знает **Node ID** друга (например, из QR-кода/контактов), сервис `photo.inbox`.
2. Подключается к соседнему локальному узлу (Wi-Fi Aware, LAN, обычный интернет, когда есть).
3. Сеть оценивает наличие пути с достаточной пропускной способностью.
4. Медленный радиоканал может помочь объявить доступность или перенести небольшую управляющую запись, **но не файл**.
5. Файл разбивается на фрагменты, шифруется и уходит через быстрый путь. Посредники видят только необходимую им служебную информацию.
6. Если пути нет — приложение показывает `ожидает доставки` и TTL; пользователь сам решает, разрешить ли дорогой/медленный режим.
## Чего не делать
- Не flood'ить каждый поиск на всю планету.
- Не публиковать постоянный глобальный GPS узлов.
- Не разрешать любому пользователю загружать произвольные гигабайты в память чужого ретранслятора.
- Не считать «больше пути» автоматически «больше скорости». Нужно учитывать узкое место, перегрузку и стоимость передачи.
## Ближайшие родственные подходы
[Reticulum](../../sources/part1.md#s13) решает очень близкую задачу криптоидентичности и работы поверх разных сред. [Babel](../../sources/part1.md#s06) и [SCION](../../sources/part1.md#s20) дают другие ориентиры по маршрутам, [DTN/BPv7](../../sources/part1.md#s04) — по задержанной доставке. Не следует механически смешивать их wire-форматы без исследования совместимости.

View file

@ -0,0 +1,36 @@
# Требования и критерии готовности v0.1
> Все требования ниже — **предлагаемые**, ещё не согласованный стандарт. Их следует превратить в машинные тесты.
| ID | Требование | Проверка |
|---|---|---|
| R-01 | Логический Node ID не зависит от IP | Node ID одинаков после смены UDP-туннеля на локальный линк |
| R-02 | Нет обязательного сервера координации | Три изолированных Linux-узла могут обменяться сообщениями |
| R-03 | Транспорт сменный | Один API отправки поверх UDP, затем raw serial/test adapter |
| R-04 | Service ID шире 16 бит | Выбор идентификатора 77777, не попытка bind TCP:77777 |
| R-05 | Discovery не забивает канал | Верхний лимит доли пропускной способности на каждый интерфейс |
| R-06 | Фото не уходит через дальнее малоскоростное радио по умолчанию | Тест: запрет передачи payload > заданного размера на narrowband |
| R-07 | Неизвестный узел не получает доступ к приватному сервису | Тест deny-by-default |
| R-08 | Удаление ретранслятора не ломает идентичность | Повторный поиск маршрута и счётчик потерь |
| R-09 | У отсутствующего адресата допускается отложенная доставка | Пакет сохраняется до TTL и подтверждения |
| R-10 | Узел устойчив к флуду соседей | Rate limits, caps на память/CPU/очередь, timeout |
| R-11 | Ключи не передаются посредникам | Проверка протокола, threat review |
| R-12 | При отсутствии пути сообщаем правду | Состояния queued/no-route/expired, а не ложное «доставлено» |
| R-13 | Сбор данных о местоположении выключен по умолчанию | Проверка discovery-пакетов и конфигурации |
| R-14 | Протокол имеет версионирование | Неизвестные расширения корректно игнорируются/отклоняются |
| R-15 | Работа на ARM/x86 без GPU | Собираемый бинарник и бюджет ресурсов в тестах |
## Non-goals v0.1
- Глобальное покрытие на первом релизе.
- Безлимитная пропускная способность.
- Абсолютная анонимность по умолчанию.
- Модификация Linux kernel.
- Обход правовых ограничений радиоспектра.
- Массовый публичный запуск с непроверенной криптографией.
## Техническая проверка готовности
**Milestone M0:** детерминированная доставка текстового сообщения по 3 hops в симуляции, проверяемый trace. **M1:** две физически разные связи, автоматическое восстановление. **M2:** E2E-ключи и лимиты трафика. **M3:** тестирование третьими лицами.
См. [план испытаний](../../implementation/tests_metrics.md).

View file

@ -0,0 +1,33 @@
# Миссия и происхождение идеи
## Откуда взялась ICE-NET
Разговор начался с вопроса о 16-битных TCP/UDP-портах (0…65535) и возможности «порта 77777». Затем обсуждались собственный сетевой стек Linux/Arch, децентрализованная сеть из Cyberpunk, условная охранная система ICE, малые CPU-модели и независимость от глобального интернета.
Идея развивалась к двум связанным направлениям:
**1. Протокол без обязательной зависимости от IP:** свой адрес устройства, ID сервиса (хоть 64-битный), маршрутизация, доверие и обмен сообщениями поверх разных физических каналов. **2. Инфраструктура:** дальнее радио для малых объявлений/текста и быстрые маршруты через устройства, направленные антенны, локальную Wi-Fi mesh и, где есть, кабельные мосты.
Фантастика Cyberpunk вдохновила на название ICE и идею активного охранника соединений, но сюжетная механика Breach Protocol — не инженерная спецификация.
## Что проект должен приносить людям
- Локальные коммуникации, когда нет доступного интернета.
- Переписку и обмен файлами с возможностью задержанной доставки.
- Возможность самостоятельно развернуть узел и не зависеть от единого центрального сервера.
- Предсказуемое поведение на дешёвых маломощных машинах и возможность CPU-only защиты.
- Открытые интерфейсы, пригодные для проверки и независимой реализации.
## Правила проекта
**Открытость.** Протокол документируется независимо от конкретной реализации. **Интероперабельность.** Не зависит от одной ОС или бренда устройств. **Градация возможностей.** Медленный канал — не ошибка, а ограниченная опция. **Приватность.** Не публикуем глобальные карты людей. **Безопасность.** Защищаем свои ресурсы, не атакуем других. **Исследовательская честность.** Метрики доказываются экспериментом, а не красивой схемой.
## Небольшие точные цели вместо «всей планеты»
- P0: три узла в одной виртуальной сети, доставка сообщений и изменение маршрута.
- P1: два типа каналов с разной пропускной способностью, управление нагрузкой.
- P2: сквозное шифрование и разрешения для сервисов.
- P3: передача файла без использования медленного discovery-канала.
- P4: выход за пределы IP-переноса через физический последовательный/радиоинтерфейс.
Дальнейший путь см. [roadmap](../../implementation/roadmap.md).

View file

@ -0,0 +1,40 @@
# ADR: журнал архитектурных решений
Правило: изменение большого решения оформляем как новый ADR с мотивацией, альтернативами и критериями пересмотра.
## ADR-001: транспорт-независимые адреса (предложено)
**Решение:** Node ID = стабильный криптографический идентификатор, физический адрес = временный маршрут.
**Причина:** адрес должен работать при переходе с UDP на локальное радио.
**Риск:** метаданные и ротация ключей; см. [privacy](../../security/crypto_privacy.md).
## ADR-002: управление ≠ передача больших файлов (предложено)
**Решение:** discovery имеет минимальный общий интерфейс и строгие эфирные лимиты, а крупные payload допускаются только при наличии подходящего канала.
**Причина:** не забивать LoRa фотографиями.
**Исключение:** добровольная отложенная пересылка малых chunks при отсутствии альтернативы и явных квотах.
## ADR-003: CPU-only ICE Guard (предложено)
**Решение:** детерминированное ядро правил, FSM, счётчики, token bucket и маленькая классификация без обязательной нейросети.
**Причина:** работает на слабых процессорах и поддаётся аудиту.
**Риск:** ложные блокировки, data poisoning; см. [security](../../security/ice_engine.md).
## ADR-004: без форка ядра на MVP (принято для прототипа)
**Решение:** пользовательский процесс на Linux + сменные adapters.
**Причина:** меньшая цена эксперимента, легче тестировать и переносить.
## ADR-005: заимствуем принципы, а не копируем чужой протокол (принято для исследований)
**Решение:** сравнительный анализ Reticulum, DTN, Babel, libp2p и других; юридический аудит лицензий перед использованием кода.
**Причина:** безопасность и лицензионная чистота.
## ADR-006: нет активных атак «в ответ» (принято для модели безопасности)
**Решение:** ICE может локально прекратить обмен, уменьшить rate, потребовать повторную аутентификацию, изолировать ключ и сообщить владельцу, но не взламывает чужой узел.
## ADR-007: глобальное радио — цель, а не свойство MVP
**Решение:** первая версия гибридная, но каждый компонент может работать без центральной инфраструктуры там, где есть физическая связность.
## Открытые ADR
- Выбор длины Node ID: полный 256-битный ключевой hash vs сокращённые идентификаторы и риск коллизий.
- Дискавери: proactive annonces vs on-demand поиск, различная политика для LoRa/backhaul.
- Домашние relay по opt-in, лимиты энергии и доверия.
- Приватная адресная книга vs глобальный каталог сервисов.
- Фрагментация, окна подтверждений и разные TTL для разных типов данных.

View file

@ -0,0 +1,38 @@
# Риски и неприятные ограничения
## Физика / инфраструктура
| Риск | Почему важно | Защита от самообмана |
|---|---|---|
| Нет радиовидимости | Направленный мост не проходит через любые здания | Исследовать рельеф, высоту, зону Френеля и реальные измерения |
| Радиоэфир перегружен | Discovery не бесплатен: каждое объявление потребляет airtime | Жёсткий бюджет, периодичность, приоритеты |
| Узкое место | Один 1 кбит/с hop ограничивает всю передачу | Учитывать bottleneck; запрет больших payload |
| Нет электричества | Все ретрансляторы могут выключиться | Резерв питания там, где экономически оправданно |
| Разные частоты/нормы | Страны регулируют передатчики по-разному | Частотный план и консультация перед выходом в эфир |
| Неравномерная плотность | В городе пути есть, между городами — пустота | Backhaul, DTN и стратегические узлы |
## Протокол
- **Sybil/Eclipse**: ложные идентичности и поддельная «карта соседей» могут вытеснить честные маршруты.
- **Routing poisoning**: злоумышленник предлагает привлекательный путь, затем сбрасывает трафик.
- **Flooding**: каждый новый чужой Node ID вынуждает узлы тратить CPU/время эфира.
- **Metadata leakage**: повторяющийся стабильный идентификатор может позволить отслеживание даже при сильном шифровании.
- **Store-and-forward abuse**: чужие сообщения могут забить локальные диски.
- **Version fragmentation**: несовместимые версии провоцируют образование закрытых островов.
## Проект / команда
- Слишком рано писать своё всё (ядро, радиодрайвер, протокол, crypto, UI).
- Переоценка интереса сообщества без демонстрации кода или измерений.
- Сложная лицензия сторонних реализаций (особенно внимательно изучить предупреждения [Reticulum](../../sources/part1.md#s16)).
- Цена крыши/монтажа/страховки/электричества выше цены одного радиомодуля.
## Пять честных предпосылок
1. Глобальная география ≠ глобальная связность: сеть может быть набором островов.
2. Защищённая идентичность ≠ известное реальное имя и местонахождение.
3. «Сеть без IP» можно строить поверх IP при наличии интернета; это не противоречие.
4. Маршрутизаторы не обязаны понимать прикладное содержимое; политики доступа лучше проверять у конечного сервиса.
5. Новизна проекта — не в том, чтобы «открыть P2P», а в **проверяемом сочетании** низкоскоростного discovery, многосредной маршрутизации, ограничений ресурсов и UX при исчезновении связи.
Подробная [модель угроз](../../security/threat_model.md), [закон](../../radio/legal_spectrum.md), [метрики](../../implementation/tests_metrics.md).

View file

@ -0,0 +1,40 @@
# Обнаружение узлов: экономный control plane
## Исходное предложение
Дальнобойное радио распространяет **не файл**, а короткие данные: «сосед доступен», «у меня есть путь», «этот ID видел недавно», «сервис возможен через меня». Стабильные ключи, полные списки контактов и GPS-позиции не должны публиковаться по умолчанию.
## Процедура
1. Узел слушает несколько каналов/адаптеров и строит таблицу **непосредственных соседей**.
2. Периодически с jitter отправляет редкое HELLO согласно airtime budget.
3. Транспортный узел анонсирует **ограниченный** набор направлений, а не всех клиентов мира.
4. При необходимости узел задаёт rate-limited запрос PATH_QUERY; ответы записываются в кеш со сроком годности.
5. При переполнении медленного канала служебные обновления сокращаются, объединяются или откладываются.
## Не путать «хеши» с маршрутизацией
Хеш ID подходит для ключа записи. Bloom filter может сказать «возможно есть такой ID в области», но:
- false positive -> ошибочный поиск;
- хеш не даёт права читать содержимое;
- глобальный индекс ID может компрометировать приватность;
- фильтры имеют параметры размера и ошибки; их распространение тоже стоит airtime.
Поэтому Bloom filters — **исследуемая опция** для агрегированного presence, не базовая истина проекта.
## Масштабирование
| Масштаб | Стратегия |
|---|---|
| Несколько узлов | прямая таблица соседей |
| Район | локальные агрегаты + route queries |
| Город | границы зон, ретрансляторы, приоритизация и кеш |
| Города | высокоскоростные backbone переходы или DTN |
| Глобально | разделённые домены управления и проверка стоимости служебного трафика |
У Reticulum есть подробная схема announces и ограничения полосы под них ([S14](../../sources/part1.md#s14)); Meshtastic управляет floods и использует next-hop для direct messages ([S17](../../sources/part1.md#s17)). Сначала сравнить их airtime и поведение при перемещении узлов.
## Измерения, без которых архитектура не обоснована
Control overhead (% полезной/доступной полосы), среднее число анонсов/узел/час, время поиска (p50/p95), отношение false-positive, степень устаревания маршрутов и раскрытие идентичности.

View file

@ -0,0 +1,52 @@
# Маршрутизация: как найти друга через тысячи устройств
## Требования
Маршрутизатор знает **своих соседей** и следующий переход для части адресов. Ему не нужен полный граф всей сети или «все люди в радиусе каждой вышки».
## Пример
```text
Дом A ─── Wi-Fi ─── R1 ══ радиомост ══ R2 ─── Wi-Fi ─── Дом B
│ │
LoRa LoRa
discovery discovery
```
Когда A отправляет фото B, LoRa может помочь обнаружению. Большой файл идёт A→R1→R2→B, **только если** есть реальные быстрые физические участки и они разрешены политиками.
## Метрики маршрута
Нельзя выбирать только по числу hops. Учитывать:
- оценку задержки и потерь;
- *минимальную* пропускную способность вдоль пути;
- airtime и фактическую занятость радио;
- стоимость энергии на мобильном устройстве;
- разрешение владельца relay, квоту/платный канал;
- надёжность/время последнего контакта;
- безопасность маршрута и историю отказов.
## Возможные направления реализации
**A. Проактивная маршрутизация (Babel/батманоподобная)** — хорошо для сравнительно связной локальной сети, есть регулярные обновления. [Babel RFC 8966](../../sources/part1.md#s06), [batman-adv](../../sources/part1.md#s23).
**B. On-demand / announce-based** — меньше постоянных сообщений при редких запросах. Изучать [Reticulum](../../sources/part1.md#s14).
**C. Content/destination discovery** — DHT через стабильные быстрые узлы (см. [libp2p](../../sources/part1.md#s21)); DHT не переносится бесплатно на узкополосное радио.
**D. DTN** — доставка при отсутствии одновременного пути ([RFC 9171](../../sources/part1.md#s04)).
## Гибридная гипотеза
- В пределах высокоскоростного района — поддерживаем соседские маршруты и метрики.
- Между районами — отдельные backbone-переходы и границы анонсирования.
- При отсутствии пути — store-carry-forward с TTL и квотами.
Это **пока не доказано**. Особая проблема — единая корректность при изменении путей между разными классами link'ов. Тестировать петли, route storms, malicious metrics и голодание медленных узлов.
## Failure behavior
- После смерти соседнего узла — route invalidation, backoff на перестроение.
- Для дублирующихся путей — осторожная multipath политика, не перемножать дубликаты бесконтрольно.
- `NO_ROUTE` — обычный статус.
- `QUEUED` ≠ `DELIVERED`. Только конечное подтверждение даёт `DELIVERED`.
Полезное новое: [RFC 10069 (2026)](../../sources/part1.md#s03) добавил управление несколькими путями **в QUIC**, но он не заменяет маршрутизатор ICE-NET.

View file

@ -0,0 +1,41 @@
# Транспорт и QoS: от нескольких байтов до фотографии
## Почему классификация трафика обязательна
Представим 5 MiB фото (≈41.9 млн бит). Даже идеальный канал **1 кбит/с** теоретически потребовал бы **≈11.7 часа**, без сетевых заголовков, повторов, пауз и правовых ограничений. Поэтому «через LoRa пойдёт, просто медленно» — опасная продуктовая установка; она забьёт общий эфир.
## Классы трафика (предложение)
| Класс | Пример | Политика |
|---|---|---|
| C0 | HELLO, route hints, ошибки | очень короткий payload, rate limit, высокий приоритет только в пределах квоты |
| C1 | SOS, короткое текстовое сообщение | допускается slow link по согласию, отдельная fair queue |
| C2 | обычный чат и подтверждения | высокий приоритет среди приложений, encryption |
| C3 | фото, файлы, обновления | **fast-links-only** по умолчанию, chunks + resume |
| C4 | потоковое видео/аудио | best-effort, без гарантий, только при подходящем непрерывном пути |
## Доставка файла
- Разбивать на ограниченные chunks, иметь идентификаторы фрагментов, integrity hash всего файла, окно выдачи и возобновление.
- Сжимать там, где экономия реальна (не предполагать, что JPEG сжимается ещё на порядок).
- Уважать лимиты памяти и диска каждого транзитного узла.
- Использовать congestion/flow control для каждой доступной среды, а не одну «скорость сети».
- Не делать многопутевую передачу доступной по умолчанию без контроля порядка и устойчивости.
## Предварительный scheduler
```text
if no_path: queue_or_fail()
elif file_size > MAX_SLOW_PAYLOAD and path.bottleneck < FAST_THRESHOLD:
offer_deferred_delivery()
else:
send_chunks_with_rate_limit()
```
Порог выбирается экспериментом. Идентичность узла/сервиса и разрешения проверяются **до** доступа к ресурсоёмкому приложению.
## Сравнить с реальными технологиями
- [QUIC RFC 9000](../../sources/part1.md#s02): streams, смена пути, congestion control.
- [Multipath QUIC RFC 10069](../../sources/part1.md#s03): несколько путей при одном соединении, новый стандарт 2026; не автоматически пригоден для каждого LoRa линка.
- [LoRaWAN ограничения](../../sources/part2.md#s31): хороший пример, почему канал малых пакетов нельзя продавать как видеосеть.

View file

@ -0,0 +1,37 @@
# Криптографическая идентичность и адресация
## Исходная проблема
IP — адрес интерфейса в сети с определённой моделью маршрутизации. В ICE-NET нужен логический ID, который переживает смену транспорта. **Это не «IP плохой»**: IPv6 уже имеет огромный адресный диапазон, а польза новой адресации — независимость от IP-плоскости, поддержка радиосвязи и идентичность по ключу, а не число портов.
## Предложенная модель
```text
node-id: ice1:Q7HW... (краткое человекочитаемое представление)
service: 77777 (логический ServiceID, uint64)
locator: local-wifi / serial-radio / udp-gateway / relay-next-hop
```
- Генерировать приватный ключ локально и хранить его защищённо.
- `NodeID` вычислять из открытого ключа стандартной функцией криптографического хеширования и схемой однозначного кодирования.
- `ServiceID` определять независимо от физического адреса; **приложение** решает, разрешён ли сервис на этом узле.
- Human readable alias (`friend@...`) — отдельно, с локальной книгой контактов и проверкой отпечатка.
## Запрос «кто ты?» и «где ты?» — разные вещи
Подпись challenge доказывает **владение ключом**, но не доказывает, что человек действительно друг и что устройство находится в заявленном городе. Для привязки к человеку нужен обмен отпечатками (QR-код, личное подтверждение) или модель доверия. Для расстояния нужны измерения RTT/RTT-радио, а не чтение NodeID. Подробнее: [Wi-Fi Aware RTT](../../sources/part1.md#s27).
## Приватность
Долгоживущий идентификатор в публичном beacon можно использовать для трекинга. Рассмотреть ротируемые announcement ID, псевдонимы локальных сервисов, короткий TTL, разделение идентичности и сетевого локатора. Нельзя назвать сеть «анонимной», пока не оценена утечка метаданных.
## Важные операции
- **Key rotation:** при замене ключа узел подписывает безопасное переназначение до компрометации; при компрометации нужна политика отзывов.
- **Lost keys:** восстановление ключей — отдельная пользовательская задача, централизованная «проверка паспорта» не требуется протоколу.
- **Collisions:** сокращённые адреса экономят эфир, но повышают риск совпадения; нужно хранить полный ID при аутентификации.
- **Key separation:** отдельные ключи аутентификации, шифрования и подписи сообщений в соответствии с выбранным криптографическим протоколом.
## Что читать
[HPKE RFC 9180](../../sources/part1.md#s08), [Noise](../../sources/part1.md#s26), [Reticulum ID](../../sources/part1.md#s14), [MLS](../../sources/part1.md#s07). Выбор конкретных алгоритмов — результат отдельного security review.

View file

@ -0,0 +1,40 @@
# Протокол: границы и жизненный цикл v0.1
> **Proposal:** ниже не RFC, а исходный скелет. Цель — удобство инженерного обсуждения, а не немедленная реализация совместимого стандарта.
## Что в сети считается адресом
- `NodeID` обозначает **идентичность конечного устройства**, а не физический радиоканал.
- `ServiceID` (пока предложено 64 бита) обозначает конкретное приложение/доступную функцию.
- `Locator` — локальные сведения о пути: Wi-Fi MAC, последовательный порт, UDP endpoint, следующий ретранслятор. Он может изменяться без изменения идентичности.
Невозможно создать реальный TCP/UDP порт 77777 без изменения wire format TCP/UDP; возможен **виртуальный сервис** с ID `77777` в собственном протоколе ([RFC 9293](../../sources/part1.md#s01)).
## Обязательные элементы протокола
1. `HELLO`: обнаружение соседа и его способностей (ограниченная локальная область).
2. `ANNOUNCE`: сообщение о достижимости NodeID/сервиса с ограниченным сроком действия.
3. `PATH_QUERY / PATH_REPLY`: поиск маршрута по запросу; rate limited.
4. `DATA`: зашифрованный пользовательский payload; metadata минимальна.
5. `ACK / STATUS`: доставка до получателя (не путать с подтверждением от одного ретранслятора).
6. `ERROR / QUOTA`: явный отказ, нет пути, закончился бюджет или TTL.
## Фазы отправки
```text
UNKNOWN → DISCOVERY → PATH CANDIDATE → POLICY CHECK
↘ NO PATH → QUEUED (if allowed)
POLICY CHECK → SEND CHUNKS → VERIFY → DELIVERED
↘ EXPIRED / FAILED
```
## Чего не стоит стандартизировать сразу
- Человекочитаемые имена: они удобны, но могут потребовать сложного распределённого резолвера.
- «Полную» унифицированную таблицу топологии.
- Самостоятельные новые криптографические операции.
- Одновременную поддержку всех радиопротоколов.
## Референсы
[Reticulum](../../sources/part1.md#s13), [Babel](../../sources/part1.md#s06), [DTN](../../sources/part1.md#s04), [libp2p](../../sources/part1.md#s21). См. детальную [адресацию](identities_addresses.md), [маршруты](../control/routing.md), [wire format](packet_wire_format.md).

View file

@ -0,0 +1,40 @@
# Черновой wire format (proposal; не для production)
Формат нужен, чтобы обсудить стоимость каждого байта. **Ниже иллюстративный формат без окончательно выбранных размеров и криптографических параметров.** Он намеренно не является готовой реализацией.
## Пример полей
| Поле | Предварительно | Назначение |
|---|---:|---|
| Version | 1 байт | Обратная совместимость |
| Type | 1 байт | HELLO / ANNOUNCE / DATA / ACK |
| Flags | 1 байт | Опциональные признаки |
| HopLimit | 1 байт | Снижение риска бесконечных петель |
| MessageID | 8–16 байт | Dedup; нужен анти-replay анализ |
| Src/Dst hint | переменно | Указатели без раскрытия полных ключей всегда |
| ServiceID | varint или 8 байт | Логический сервис, например 77777 |
| TTL / Expiry | переменно | Завершение жизни пакета |
| Payload | переменно | Зашифрованные данные/служебная нагрузка |
| Auth tag | по выбранному AEAD | Контроль целостности/подлинности |
## Приоритетная проблема — не экономия одного байта
Радиоканалу дорого стоит **каждая передача**, а особенно широковещательная. Сначала измерить частоту объявлений, длины пакетов, ограничения времени эфира и повторов, потом оптимизировать кодирование.
## Дополнения
- `HELLO` должен укладываться в бюджет discovery-адаптера; не раскрывать лишние имена и координаты.
- `DATA` не обязательно помещается в один пакет физического канала; нужна фрагментация, контроль памяти и защита от повторов.
- Уменьшение HopLimit на каждом переходе, проверка явных возрастных/TTL полей.
- Список расширений по TLV или другому парсибельному схематическому кодированию, обработка неизвестных обязательных полей.
- Все входные длины, смещения, переменные числа проверять до выделения памяти.
## Невыполненные задачи перед реализацией
1. Угрозы подделки/повторного воспроизведения сообщений.
2. Формат подписи и каноническое кодирование при нескольких языках программирования.
3. MTU по каждому адаптеру, фрагментация и сохранение replay-window при DTN.
4. Стратегия версии + downgrade protection.
5. Закреплённые test vectors и fuzzing сериализатора.
Протоколу нельзя давать обещания безопасности, пока он не прошёл независимый аудит. См. [threat model](../../security/threat_model.md).

View file

@ -0,0 +1,29 @@
# Когда связь прерывается: DTN / store-carry-forward
## Сценарий
Деревня без постоянного радио-моста. Сообщение для друга помещается в зашифрованную локальную очередь, а когда появляется доступный узел (машина/рюкзак/вышка/временный gateway), копия переправляется. Получатель может получить данные через часы. Это **задержанная доставка**, не live-соединение.
## Очередь должна иметь правила
- Storage quota по пользователю/узлу/сервису.
- TTL/expiry для каждого сообщения.
- Отдельно квитанция о приёме relay и о доставке адресату.
- Content ciphertext + минимум метаданных.
- Удаление старых сообщений по прозрачной политике, а не бесконечный диск.
- Предотвращение replay, копирования одних и тех же bundle и намеренного засорения памяти.
- Не обещать доставку, если пути не возникает ни разу.
## Три модели
1. **Store-and-forward при активном пути** — краткая очередь между соседними hops.
2. **Store-carry-forward (DTN)** — нет end-to-end пути, relay переносит зашифрованный пакет физически или ждёт появления линка.
3. **Scheduled contacts** — известные окна доступности, например периодический мост; требует календаря доступности и реального измерения.
## Инженерные источники
[BPv7 RFC 9171](../../sources/part1.md#s04) уже формализует передачу через проблемные сети. [BPSec RFC 9172](../../sources/part1.md#s05) прямо обсуждает защиту хранения, ограниченность ресурсов и отсутствие непрерывного доступа к авторитетному серверу. В 2026 IETF продолжает работу над [обнаружением и управлением в DTN](../../sources/part1.md#s12), но эти новые документы — **drafts**, пока не стандарт.
## UX
Показывать пользователю `отправлено с моего устройства`, `передано следующему узлу`, `доставлено конечному`, `истекло`. Никогда не называть первую стадию финальной доставкой.

View file

@ -0,0 +1,48 @@
# Вышки, крыши, направленные мосты и реальная цена сети
## Что пользователю понравилось в идее
Низкоскоростная вышка **не прокачивает все фото через себя**. Она объявляет присутствие и помогает поиску маршрута. Для крупных данных строится физически быстрый маршрут из соседних смартфонов, локальных Wi-Fi устройств, домовых relay и направленных мостов между крышами.
## Реалистичная городская схема
```text
Смартфоны ↔ [домашний Wi-Fi relay] ---+-- [районный hub A]
| ||
Ethernet || направленный backhaul
| ||
Смартфоны ↔ [другой дом/кафе] --------+-- [районный hub B]
... |
резервный канал/DTN
```
**Важное уточнение:** цепочка из телефонов менее предсказуема, чем инфраструктурные узлы: они уходят, выключают Wi-Fi, экономят батарею; ОС ограничивает фоновую работу. Город с большим количеством пользователей не гарантирует непрерывный путь без стационарных узлов.
## Что нужно реальной «вышке»
1. Разрешение разместить оборудование на крыше / мачте.
2. Питание, погодозащита, молниезащита и требования электробезопасности.
3. Радиомодем, антенна и согласованный частотный план.
4. Вычислитель/маршрутизатор, не обязательно полноценный мини-сервер.
5. Мониторинг состояния, обновления, физический доступ для ремонта.
6. Резервный путь или понятное поведение при обрыве.
## Какие магистрали испытывать первыми
- 5 ГГц направленная радиолиния: относительно доступна по железу, но качество и законные параметры зависят от географии/частоты.
- Кабель между собственными двумя комнатами/помещениями: бесплатная в смысле радиопомех тестовая база, если кабель уже есть.
- 60 ГГц там, где короткая гарантированная видимость и нужен большой backhaul. Делать осмысленный budget дождя и атмосферного затухания.
- Длинные licensed microwave линии — **не** дешёвый хобби-первый шаг.
- FSO — интересная исследовательская альтернатива, но туман и юстировка делают её рискованной как единственный магистральный канал.
## Как сократить капитальные расходы
**Архитектурно:** сетевые узлы могут быть предоставлены добровольцами, работать на существующих мини-компьютерах/совместимых роутерах. **Операционно:** требуются обязанности, финансирование обслуживания, прозрачные правила и учёт потока ресурсов. Модель сообщества изучать у [NYC Mesh](../sources/part2.md#s45), [Freifunk](../sources/part2.md#s46), [guifi.net](../sources/part2.md#s47).
## Масштабирование без потери независимости
Предлагать **федерацию районов**: каждый район сам управляет relay, ключами доступа к своим сервисам и политиками backhaul; объединение по добровольным interconnect соглашениям. Не давать одному центральному серверу права запретить работу всех остальных.
## Предлагаемый пилот
Первый физический пилот = два стационарных узла + один мобильный клиент + один искусственно плохой канал. Цель — подтвердить *работу протокола*, а не показать покрытие города. После измерений перейти к 3–5 реальным точкам с резервным маршрутом.

View file

@ -0,0 +1,32 @@
# Радиозаконодательство и безопасность эксплуатации (обязательно до эфира)
> Информационный обзор, не юридическая консультация. Страна, диапазон, мощность, аппаратный класс, назначение и тип передачи определяют правила. **Нельзя** просто выбрать частоту и произвольно излучать.
## Что проверить перед покупкой/передачей
1. Национальная таблица распределения частот, ограничения на конкретную полосу.
2. Разрешённая EIRP/ERP с учётом усиления направленной антенны (не только мощность модуля).
3. Duty cycle, LBT/AFA и требования к совместному использованию спектра, если применимы.
4. Ограничения на наружные устройства, DFS/TPC и каналы Wi-Fi, если применимы.
5. Требования по соответствию радиооборудования, CE/RED, монтажу и электро/лазерной безопасности.
6. Нужно ли получать индивидуальную лицензию / согласие на размещение антенны.
7. Правила радиолюбительской службы: не считать все её диапазоны свободной альтернативой для приватного коммерческого зашифрованного трафика; проверить правила соответствующей юрисдикции.
## Источники (проверены до 12.11.2026)
- [CEPT/EFIS](../sources/part2.md#s36) и [ERC/REC 70-03](../sources/part2.md#s37) — подбор по диапазону и национальные отклонения.
- [Директива 2014/53/EU](../sources/part2.md#s38) — правовая рамка при выводе радиооборудования на рынок ЕС.
- [Страница Еврокомиссии о RED](../sources/part2.md#s39) — юридические изменения 2026. **Важно:** в 2026 принят акт об отмене отдельного cybersecurity-регулирования RED с действием отмены с 11 декабря 2027 года на фоне перехода к CRA; не полагаться на старые FAQ 2024–2025 как на окончательное состояние.
## Для ЕС/Польши, если сеть разворачивается там
В ЕС гармонизация не означает идентичность всех ограничений в каждой стране. Для конкретного оборудования и частоты требуется проверка национальных интерфейсов и актуальных решений регулятора; рекомендации CEPT сами по себе не заменяют применимое право.
## Нельзя упрощать
- «868 МГц — свободная частота для чего угодно» — неверно.
- «Направленная антенна позволяет бесконечно увеличивать мощность» — неверно.
- «Если это P2P и не интернет, то закон о радиочастотах не действует» — неверно.
- «Лазер между крышами не требует безопасности» — неверно.
Первый легальный и безопасный этап — **симуляция и проводной стенд**; радиочасть только после отдельной проверки диапазона и железа.

View file

@ -0,0 +1,39 @@
# Физическая передача: какие каналы подходят ICE-NET
> Среда не выбирается по лозунгу «дальше = лучше». Важны зона видимости, суммарная полоса, задержка, чувствительность к помехам, управление спектром, энергия, цена размещения и число устройств.
## Технологии по задачам
| Среда | Для чего может пригодиться | Что не стоит обещать |
|---|---|---|
| LoRa (физический уровень) | редкие HELLO, SOS, короткий текст, очень экономные объявления | высокая скорость для фото и массовых широковещаний |
| LoRaWAN | отдельная IoT-сеть со своей архитектурой шлюзов и управляющей сетью | «универсальная LoRa mesh»: LoRaWAN не означает mesh по умолчанию |
| Wi-Fi 2.4/5/6 ГГц | локальные быстрые данные, соединения ближайших узлов | постоянное километровое покрытие в городе сквозь здания |
| Wi-Fi Aware (NAN) | discovery и прямое соединение поддерживаемых телефонов | поддержка абсолютно всех смартфонов, свободная многохоп-маршрутизация ОС |
| 802.11s + batman-adv | локальный mesh из поддерживаемых роутеров | работа без ограничения общего эфирного ресурса |
| Wi-Fi HaLow (802.11ah) | промежуточный вариант «дальность / скорость» в суб-ГГц диапазоне | обязательная поддержка обычным телефоном |
| Направленный 5 ГГц | сравнительно дешёвый backhaul между крышами при прямой видимости | гарантия скорости и легальности в любой стране/полосе |
| 60 ГГц | быстрые короткие плотные магистральные мосты в подходящих условиях | надёжная связь на десятки километров сквозь дождь/здания |
| Радиорелейная СВЧ | более дальние магистрали при расчёте трасс и правильных разрешениях | монтаж без инженерных расчётов и требований регулятора |
| FSO/лазер | быстрый оптический мост между фиксированными точками | устойчивость к туману и отсутствие требований к безопасности излучения |
| Ethernet / оптоволокно | самая предсказуемая backbone-связь где возможно | доступность везде без прокладки и разрешений |
| SDR (GNU Radio) | эксперименты с физическим протоколом и сигнальной обработкой | возможность законно излучать что угодно на любой частоте |
## Что действительно новое/полезное к 2026
- **Wi-Fi 7 MLO:** несколько Wi-Fi-линков между совместимыми клиентами и AP; доказанное направление повышения устойчивости, **не mesh между городами** ([AOSP](../sources/part1.md#s29), [полевые испытания 2026](../sources/part1.md#s30)).
- **Wi-Fi Aware:** уже позволяет прямое обнаружение и высокоскоростное общение без интернета на поддерживаемых устройствах ([AOSP](../sources/part1.md#s27), [Apple](../sources/part2.md#s59)); отличная тема для клиента ICE-NET, но смотреть API и поддержку железа.
- **AREDN использует 802.11ah/HaLow:** практические прошивки и драйверы существуют ([S25](../sources/part1.md#s25), [S35](../sources/part2.md#s35)).
- **GNU Radio 4 RC3 от октября 2026:** для разработки DSP и SDR есть живая open-source экосистема ([S34](../sources/part2.md#s34)).
## Нельзя путать «дальность» и «адресацию»
Радиомаяк может помочь понять, что некий узел **слышен** и какой сигнал принят. Но RSSI сам по себе не измеряет точное расстояние: мешают мощность передатчика, отражения, препятствия и антенны. Для определения положения могут понадобиться RTT, несколько приёмников, GNSS или специальные методы, с отдельной моделью приватности.
## Задача про фото
Если человек отправляет фото — scheduler сперва ищет fast path, а затем либо использует его, либо откладывает доставку. **Не надо** «выбирать хороший канал по красивой метке вышки»: узкое звено может находиться на любом hop.
## Надёжность магистралей
Для фиксированных трасс применимы расчёты ITU-R P.530-19 ([S32](../sources/part2.md#s32)). Туман для FSO исследуется отдельно ([S57](../sources/part2.md#s57)). Не переносить лабораторную пропускную способность на случайную городскую сеть.

View file

@ -0,0 +1,49 @@
# Что особенно важно из найденного в 2025–2026
> **Срез исследований на 12 ноября 2026.** Здесь только результаты с конкретными источниками и статусами. Не все «новые» технологии впервые появились в эти годы — часто нова редакция, релиз или испытание.
## Ноябрь 2026 — Multipath QUIC становится RFC 10069
[Опубликован RFC 10069](../sources/part1.md#s03), *Managing Multiple Paths for a QUIC Connection*, статус Proposed Standard. Он описывает управление несколькими путями одного QUIC-соединения и явные path IDs. Авторы прямо оговаривают, что адресное обнаружение и планирование трафика по путям вне документа. **Для ICE-NET**: идея отделять транспортное многопутевое соединение от собственно mesh-маршрутизатора.
## Октябрь–ноябрь 2026 — активная работа над DTN
[IETF DTN WG](../sources/part1.md#s11) обновила устав 5 октября 2026. В реестре [активных документов](../sources/part1.md#s12) находятся Internet-Drafts о безопасных объявлениях и соседском discovery (SAND), однонаправленной передаче, forward error correction и QUIC convergence layers. **Это проекты стандартов**, ещё не обещанная совместимость. Для ICE-NET особенно важны автономное discovery, доставляемость при длительных разрывах и управление очередями.
## Октябрь 2026 — GNU Radio 4.0 RC3
[13 октября 2026 GNU Radio выпустила RC3](../sources/part2.md#s34): новый modular runtime и новые DSP-модули; объявлен переход к более широкому сопровождению сообщества. Это не релиз 4.0 final. Для проекта — возможность экспериментировать с сигналами, не создавая радиотракт с нуля.
## Октябрь 2026 — Briar и AREDN
Сайт [Briar](../sources/part1.md#s18) указывает релиз 1.5.24 от 30 октября 2026 — P2P-общение без центрального сервера через Bluetooth/Wi-Fi/Tor.
Сайт [AREDN](../sources/part1.md#s24) описывает выпуск 4.26.10.0 и новые возможности multi-radio в 2026; его публичные [release notes](../sources/part2.md#s35) показывают практику использования Babel, OpenWrt, Wi-Fi и HaLow.
## Февраль 2026 — Wi-Fi 7 Multi-Link Operation
[Wireless Broadband Alliance](../sources/part1.md#s30) опубликовала результаты полевых испытаний. MLO поддерживает параллельные/альтернативные каналы совместимых устройств и может улучшать устойчивость. **Ограничение**: тесты проведены в конкретной жилой среде, это не доказательство километрового mesh. Для ICE-NET интересен выбор физического канала, а не создание нового стандарта радиосвязи.
## 2025–2026 — Wi-Fi HaLow / 802.11ah в практических mesh-проектах
[AREDN (октябрь 2025)](../sources/part1.md#s25) перечисляет поддерживаемые HaLow-устройства в экспериментальных ветках, а [release notes 2026](../sources/part2.md#s35) подтверждают продолжение поддержки. Для ICE-NET HaLow стоит исследовать как **средний класс** между LoRa и обычным Wi-Fi. Это не замена радиомагистрали и не стандартная функция каждого смартфона.
## Сентябрь 2025 — ITU-R P.530-19
Новая действующая редакция [P.530-19](../sources/part2.md#s32) содержит модель расчёта надёжности terrestrial line-of-sight радиолиний. Это практическая база для проектирования направленных мостов, особенно дождевых потерь, fading и устойчивости нескольких hops.
## 2026 — FSO в исследовательской литературе
[Статья ноября 2026](../sources/part2.md#s57) рассматривает fog-limited оптические линии и обоснованность моделей затухания. Она подчёркивает, что высокая скорость FSO сама по себе не означает приемлемую круглогодичную доступность.
## Регулирование — документы тоже меняются
[CEPT](../sources/part2.md#s37) и [EFIS](../sources/part2.md#s36) обновляют условия применения SRD. [Еврокомиссия](../sources/part2.md#s39) сообщила в 2026 об утверждённой отмене отдельного делегированного cybersecurity-акта RED **с 11 декабря 2027 года** на фоне перехода к CRA. Перед радиотестами проверять последнюю **национальную** реализацию, а не только дату старой статьи.
## Что не является доказанным «прорывом»
- 6G как гарантия бесплатной автономной связи: нет.
- Квантовый интернет, автоматически решающий mesh discovery: нет.
- Умная антенна, передающая фото сквозь любой город без ретрансляторов: нет.
- Обучаемый ICE без ложных блокировок: пока нет.
Следить прежде всего за [IETF MANET](../sources/part1.md#s10), [IETF DTN](../sources/part1.md#s12), [Reticulum](../sources/part1.md#s13), [AREDN](../sources/part1.md#s24) и [GNU Radio](../sources/part2.md#s34).

View file

@ -0,0 +1,45 @@
# Сравнение существующих проектов — чему учиться, а не копировать вслепую
## Карта альтернатив
| Проект | Ключевая идея | Чем полезен ICE-NET | Чего не решает автоматически |
|---|---|---|---|
| [Reticulum](../sources/part1.md#s13) | crypto адреса + transport-agnostic сеть | почти прямой ориентир по логическому уровню | не обещает произвольной скорости без физического канала |
| [Meshtastic](../sources/part1.md#s17) | LoRa mesh и ограничения эфира | алгоритмы flood, next-hop, airtime | не скоростная сеть фото/видео |
| [AREDN](../sources/part1.md#s24) | mesh-сеть на роутерах/радиомостах | реальная эксплуатация, multi-radio, Babel | модель адресации в основном IP-ориентированная |
| [Yggdrasil](../sources/part1.md#s19) | end-to-end encrypted overlay | self-healing и идентичность | само overlay использует IPv6 API и не создаёт радио |
| [Briar](../sources/part1.md#s18) | offline P2P мессенджер | UX без интернета, локальная privacy | не общий сетевой backhaul |
| [libp2p](../sources/part1.md#s21) | P2P transports, relay, peer discovery | инструменты для первого Rust MVP | некоторые протоколы/DHT чрезмерны для узкополосного радио |
| [Babel](../sources/part1.md#s06) | устойчивые маршруты на проводе и Wi-Fi | быстрый путь к работающей mesh-маршрутизации | зависит от модели адресов и метрик |
| [batman-adv](../sources/part1.md#s23) | L2 mesh forwarding в Linux/OpenWrt | местные Wi-Fi домены | широковещание и масштаб на огромные расстояния |
| [DTN / BPv7](../sources/part1.md#s04) | хранение-передача при разрывах | прерывистые дальние связи | живой видеозвонок без постоянного пути |
| [SCION](../sources/part1.md#s20) | path-aware, доверие и отказоустойчивость | источники идей контроля маршрутов | не ориентирован на LoRa и чисто ad-hoc клиент |
| [Wi-Fi Aware](../sources/part1.md#s27) | discovery и прямой скоростной линк | мобильное подключение без сети оператора | многопереходная маршрутизация не предоставляется сама |
| [guifi.net](../sources/part2.md#s47) | общественная физическая сеть | реальная управленческая модель | не готовый новый wire format |
## Главное открытие исследования
**Почти все элементы идеи уже встречаются по отдельности.** Сильная постановка задачи ICE-NET — не доказывать «первое в мире открытие», а предложить проверяемую и полезную интеграцию с понятной границей slow discovery и fast transport, строгим QoS, E2E privacy и понятным UX.
## Что разумнее использовать, а не переписывать
- для прототипа Rust peers/транспорты — [rust-libp2p](../sources/part1.md#s22), если размер и свойства подходят;
- для исследования радио/разрывов — [ns-3](../sources/part2.md#s42), [CORE](../sources/part2.md#s43), [GNU Radio](../sources/part2.md#s33);
- для безопасности сообщений — общепринятые криптопримитивы и стандартные схемы, не новый шифр;
- для предсказуемости в локальной Wi-Fi области — попробовать Babel/batman-adv вместо разработки маршрутизатора с нуля с первого дня.
## Критический момент по Reticulum
На GitHub существует публичное зеркало, сам проект явно предупреждает о большом количестве некорректных сторонних реализаций и лицензионных нарушений ([S16](../sources/part1.md#s16)). **Читать** его — хорошо; **копировать чужой код и объявлять своим** — нельзя. Если решишь делать compatible implementation, сначала изучить лицензию, истинную спецификацию и тестировать реальную интероперабельность.
## Вопросы для сравнения протоколов
1. Какова доля control traffic при 10 / 100 / 1000 соседних узлов?
2. Как ведёт себя маршрут при 30% packet loss?
3. Какой payload overhead на пакете 32–64 байта?
4. Обязательна ли глобальная DHT или центральный bootstrap?
5. Возможен ли store-carry-forward без активного пути?
6. Что видит промежуточный узел и что может изменить?
7. Каков размер бинарника/памяти на x86 и ARM?
Не выбирать победителя на основе одного рекламного benchmark.

View file

@ -0,0 +1,31 @@
# План чтения: что изучать и в каком порядке
## Если хочется разобраться и начать программировать
**Сначала:** [Linux network namespaces](../sources/part2.md#s40) → [tc netem](../sources/part2.md#s41) → [Reticulum manual](../sources/part1.md#s13). Это покажет, как создать сеть и потерять пакеты на одном компьютере.
**Адреса и маршруты:** [Reticulum understanding](../sources/part1.md#s14) → [Babel RFC](../sources/part1.md#s06) → [Meshtastic mesh algo](../sources/part1.md#s17) → [libp2p protocols](../sources/part1.md#s21).
**Разрывы связи:** [BPv7](../sources/part1.md#s04) → [BPSec](../sources/part1.md#s05) → [DTN drafts](../sources/part1.md#s12).
**Криптография:** [Noise](../sources/part1.md#s26) → [HPKE](../sources/part1.md#s08) → [MLS](../sources/part1.md#s07); не надо читать все RFC подряд для первой версии чата.
**Радио:** [Meshtastic](../sources/part1.md#s17) → [LoRaWAN limitations](../sources/part2.md#s31) → [Wi-Fi Aware](../sources/part1.md#s27) → [ITU-R P.530](../sources/part2.md#s32) → [GNU Radio](../sources/part2.md#s33).
**Сообщество:** [NYC Mesh](../sources/part2.md#s45) → [Freifunk](../sources/part2.md#s46) → [Battlemesh](../sources/part2.md#s48) → [IETF](../sources/part2.md#s58).
## Обязательно прочитать перед формальным design review
- [Требования](../project/foundation/requirements.md)
- [Границы слоёв](../project/foundation/architecture.md)
- [Модель угроз](../security/threat_model.md)
- [Служебные объявления](../protocol/control/discovery_control_plane.md)
- [Радиочастоты и закон](../radio/legal_spectrum.md)
## Фактчек-лист для добавления нового источника
1. Записать название, URL, автора/организацию, дату версии, дату просмотра.
2. Определить тип: RFC, draft, manual, эксперимент, статья, маркетинг, форум.
3. Разделить «источник сообщает» и «ICE-NET предполагает».
4. Не переписывать страницы целиком в архив: краткая аннотация + ссылка.
5. Не считать ссылку доказательством безопасной реализации.

View file

@ -0,0 +1,35 @@
# Криптография и приватность: проектные принципы
## Цель
Даже если посредники физически хранят и передают данные, они не получают ключей для чтения сообщений. При этом защита от чтения содержимого **не** равна защите от анализа метаданных.
## Стандартные строительные блоки
- Проверенная криптографическая библиотека, не собственный алгоритм шифрования.
- Аутентифицированный обмен ключами; исследовать [Noise](../sources/part1.md#s26).
- E2E сообщения с аутентификацией и подтверждением криптографического sender identity; варианты [HPKE](../sources/part1.md#s08) и [MLS для групп](../sources/part1.md#s07).
- DTN требует защищать **данные в очереди** (encryption at rest, TTL, квоты). Полезен [BPSec](../sources/part1.md#s05).
- Отдельный слой авторизации сервисов: корректная подпись Node ID не означает право читать «фото-ящик».
## Приватность географии и графа контактов
Сильный шифр не скрывает, что два устройства часто переписываются, когда передают и какой relay используют. Публикация стабильного хеша ID в каждой вышке может построить базу перемещений. План защиты:
1. Не объявлять GPS/местоположение автоматически.
2. По умолчанию лишь ephemeral идентификаторы поиска соседей, насколько это совместимо с маршрутизацией.
3. Не строить публичные «списки присутствующих людей на вышке».
4. Хранить маршрутизаторные кэши недолго; минимизировать журналы.
5. Обсудить возможные атаки корреляцией сигнала, времени и размера пакетов.
## Конфликт приватности и маршрутизации
Ротация псевдонимов увеличивает цену поиска. Глобальная discoverability уменьшает privacy. Нет бесплатной магии — оценивать компромиссы отдельно для городского high-bandwidth домена и LoRa.
## Модель доверия
`NodeID = криптографическая идентичность`, `Contact = утверждение пользователя`, `Service permission = локальная политика`. Не смешивать эти три понятия.
## Криптографический релиз-гейт
Никакого публичного «100% безопасно» до независимого аудита, тестовых векторов, результатов fuzz и воспроизводимой сборки. Даже при аудите формулировать ограниченную угроз-модель.

View file

@ -0,0 +1,52 @@
# ICE Guard: маленькая локальная система безопасности
> Слово ICE вдохновлено Cyberpunk; его нужно отличать от [Interactive Connectivity Establishment (RFC 8445)](../sources/part1.md#s09). Внутреннее название **ICE Guard** пока рабочее. Система **не** атакует чужие компьютеры.
## Цель
Дешёвый модуль, который выполняет *проверку входящих сетевых событий* и не требует нейросети, GPU и постоянного сервера. Полезно разделить защиту на **обязательные правила** и **адаптивную оценку риска**.
## Базовый путь решения
```text
RX packet
│
├─ parser + caps → malformed? → DROP
├─ cryptographic auth → invalid? → DROP
├─ ACL service → denied? → DENY
├─ anti-replay → replay? → DROP
├─ rate limiter → over quota? → DELAY/DROP
└─ behavior telemetry → anomaly? → SCORE / REVIEW / THROTTLE
└─ allowed? → forward / deliver
```
## Подходящие CPU-only методы
| Метод | Для чего | Ограничение |
|---|---|---|
| FSM | допустимые переходы состояний | фиксированные правила |
| Decision tree | быстрый предсказуемый классификатор | зависит от качества обучения |
| Байесовская модель | оценка риска по признакам | независимость признаков может быть неверной |
| EWMA/statistics | необычные потоки/скорость запросов | ошибка при смене нормального поведения |
| Token bucket | гарантированные rate caps | не распознаёт сложные угрозы |
| Exact ACL + signatures | права доступа и подлинность | требует корректной криптографии |
## Архитектура
- **ICE Core:** C/Rust, детерминированные проверки, лимиты байтов и CPU, фиксированные профили сервисов.
- **ICE Policy:** настройки владельца («этот сервис только контакты», «мобильная батарея не ретранслирует»).
- **ICE Learning:** необязательный офлайн-процесс: анализирует анонимизированные журналы/пометки, строит маленькое дерево и предлагает **новую версию правил**, но не включает её автоматически.
## Важные предохранители
1. Не блокировать доступ только из-за отклонения от статистики: false positive высоки в нестабильных радиосетях.
2. Не обучаться бесконтрольно на открытом трафике — возможно poisoning.
3. Не хранить бессрочно чужие адреса/локаторы и геопозиции.
4. Не отсылать ответные «атаки», вредоносные payload или сетевое сканирование чужих хостов.
5. Не задерживать критически важный текст ради сложной классификации: сначала дешёвые проверки и fair queue.
## Измерять
p95 времени проверки, CPU/пакет, память на 10k соседей, число ошибочных блокировок, устойчивость к burst, скорость восстановления честного узла, наличие удалённой возможности изменить политику без перезапуска.
Основной RFC-подход к security для задержанной доставки см. [BPSec](../sources/part1.md#s05). Подход к рукопожатиям — [Noise](../sources/part1.md#s26).

View file

@ -0,0 +1,41 @@
# Модель угроз ICE-NET
## Активы
Закрытые ключи пользователя; сообщения и фото; metadata об участниках и маршрутах; airtime и батарея; память/диск реле; таблицы путей; контроль над сервисами.
## Противники
1. Пассивный наблюдатель радио: видит передачу, длительность, сигнал, даже если содержимое зашифровано.
2. Чужой relay: может задерживать, изменять, удалять пакеты, заявлять ложные маршруты.
3. Массовый участник: создаёт множество ключей (Sybil), фальшивые объявления, пытается истощить память и радиоэфир.
4. Владелец скомпрометированного конечного устройства: криптография не исправит заражённый endpoint.
5. Сбойный узел без злого умысла: дублирует пакеты, забывает state, путает время.
## Угрозы и контроль
| Угроза | Контроль | Остаточный риск |
|---|---|---|
| Подделка Node ID | подпись challenge, валидные ключи | адрес можно создать новый, Sybil остаётся |
| Подмена/чтение трафика relay | E2E encryption + integrity | relay видит часть metadata и может сбросить |
| Replay | уникальные packet IDs, ограниченные replay windows | при DTN окна сложнее |
| Flooding | лимиты на путь, на сервис, на анонс, bounded queues | массовая радиопомеха всё ещё возможна |
| Poisoned route | ограниченная область доверия, независимая проверка метрик | злой relay всё ещё может blackhole |
| Перехват имени | проверка fingerprint out-of-band | человек может ошибиться |
| Слежка по стабильным beacon | ротируемые псевдонимы, минимальные анонсы | анализ трафика остаётся |
| Зависимость от большого хаба | несколько peers / маршрутов и DTN | при отсутствии всех путей связь невозможна |
## Правила реагирования
**Разрешённые локальные действия ICE:** DROP, THROTTLE, REQUIRE-AUTH, QUARANTINE LOCAL SESSION, REVOKE KEY, REPORT LOCAL LOG.
**Не предусмотрены:** встречный взлом, повреждение чужих устройств, перехват управления чужим маршрутизатором.
## Проверки безопасности
- Fuzz всего парсера и сериализатора.
- Verify under traffic load + malicious input.
- Verify authenticated header binding: не оставлять опасные неаутентифицированные поля.
- Replay/drop/reorder и несинхронные часы в тестовой среде.
- Процедура security disclosure и отдельная политика хранения секретов.
См. [ICE Guard](ice_engine.md), [privacy & crypto](crypto_privacy.md), [BPSec RFC 9172](../sources/part1.md#s05).

131
archive/sources/part1.md Normal file
View file

@ -0,0 +1,131 @@
# Каталог источников ICE-NET
> Проверка материалов: **12 ноября 2026**. Источники собраны выборочно из доступной публичной документации и актуальных веб-страниц; это **не** систематический обзор всего интернета. Дата обновления отдельных сайтов может меняться, поэтому для проектных решений открывай оригинал. RFC и утверждённые стандарты отделены от черновиков, маркетинга и идей.
>
> Ссылки в файлах вида `[S12](part1.md#s12)` ведут сюда. Страницы пронумерованы для воспроизводимости обзора.
## Стандарты, RFC, IETF
## S01 — TCP, RFC 9293 (стандарт, 2022)
https://www.rfc-editor.org/info/rfc9293/
16-битные поля source/destination port. Справка о том, почему обычный TCP-порт 77777 невозможен.
## S02 — QUIC, RFC 9000 (Proposed Standard, 2021)
https://www.rfc-editor.org/info/rfc9000/
Потоки, миграция соединения, защита данных в транспорте.
## S03 — Multipath QUIC, RFC 10069 (Proposed Standard, **ноябрь 2026**)
https://www.rfc-editor.org/info/rfc10069/
Новый стандарт расширения QUIC с несколькими путями. Это **не** готовая маршрутизация mesh-сети и не обнаружение узлов.
## S04 — Bundle Protocol Version 7, RFC 9171 (Proposed Standard, 2022)
https://www.rfc-editor.org/info/rfc9171/
Store-carry-forward при длительных задержках и разрывах связи.
## S05 — Bundle Protocol Security, RFC 9172 (Proposed Standard, 2022)
https://www.rfc-editor.org/info/rfc9172/
Целостность и конфиденциальность DTN-пакетов.
## S06 — Babel, RFC 8966 (Proposed Standard, 2021)
https://www.rfc-editor.org/info/rfc8966/
Маршрутизация в нестабильных и беспроводных mesh-сетях.
## S07 — MLS, RFC 9420 (Proposed Standard, 2023)
https://www.rfc-editor.org/info/rfc9420/
Управление ключами групповых сообщений, не готовый сетевой стек.
## S08 — HPKE, RFC 9180 (Informational, 2022)
https://www.rfc-editor.org/info/rfc9180/
Строительные блоки шифрования для получателя.
## S09 — ICE/NAT traversal, RFC 8445 (Proposed Standard, 2018)
https://www.rfc-editor.org/info/rfc8445/
Важно: стандартное название **ICE** уже занято протоколом Interactive Connectivity Establishment. Название «ICE Security» в проекте — временное.
## S10 — IETF MANET, рабочая группа
https://datatracker.ietf.org/wg/manet/about/
Активное сообщество по мобильным самоорганизующимся сетям, публичная рассылка и Zulip.
## S11 — IETF DTN, рабочая группа (устав обновлён 5 октября 2026)
https://datatracker.ietf.org/doc/charter-ietf-dtn/
Продолжается работа над сетями с переменной доступностью.
## S12 — Активные документы IETF DTN (снимок на ноябрь 2026)
https://datatracker.ietf.org/group/dtn/documents/
Содержит Internet-Drafts, в том числе соседское обнаружение, однонаправленную передачу, QUIC convergence layer. **Черновик — не RFC и не законченный стандарт.**
## Сетевые стеки и реализация
## S13 — Reticulum, официальный manual (наблюдалась документация 1.6.0)
https://reticulum.network/manual/
Архитектура, криптографические адреса, интерфейсы, транспорт и ограничения.
## S14 — Reticulum: understanding и announce
https://reticulum.network/manual/understanding.html
Обнаружение направлений и ограничение служебного радиоэфира.
## S15 — Reticulum: building networks
https://reticulum.network/manual/networks.html
Смешивание LoRa/радиосвязи, Ethernet, туннелей и промежуточных узлов.
## S16 — Reticulum: публичное зеркало репозитория
https://github.com/markqvist/Reticulum
**Осторожно:** зеркало не основной канал разработки. Прочитать предупреждение об ошибочных сторонних реализациях и лицензии перед повторным использованием кода.
## S17 — Meshtastic: официальный алгоритм mesh
https://meshtastic.org/docs/overview/mesh-algo/
Ограничение эфира, managed flooding, next-hop для прямых сообщений начиная с версии 2.6.
## S18 — Briar, официальный проект (релиз 1.5.24 от 30 октября 2026 на сайте)
https://briarproject.org/
Децентрализованная переписка поверх Bluetooth, Wi-Fi и Tor; не универсальный радиомаршрутизатор.
## S19 — Yggdrasil Network
https://yggdrasilnetwork.org/
Шифрованная P2P-сеть с IPv6-адресами в overlay. Экспериментальный проект, не отсутствие IP во всех слоях.
## S20 — SCION, официальная документация
https://docs.scion.org/en/latest/
Междоменные пути, доверие, изоляция отказов; ориентирован на другую среду, чем LoRa.
## S21 — libp2p: protocol docs
https://libp2p.io/docs/protocols/
Peer ID, discovery/DHT и relays; применимость к интернет-оверлею, а не непосредственная магистраль для 300 бит/с.
## S22 — Rust libp2p, репозиторий и связи с сообществом
https://github.com/libp2p/rust-libp2p
GitHub Discussions и libp2p Discourse.
## S23 — batman-adv/OpenWrt
https://openwrt.org/docs/guide-user/network/wifi/mesh/batman
Реальная L2 mesh-маршрутизация, осторожно с broadcast и масштабом.
## S24 — AREDN, официальный проект (в октябре 2026 описан релиз 4.26.10.0)
https://www.arednmesh.org/
Практический опыт аварийных радиосетей, перехода на Babel и разных типов узлов.
## S25 — AREDN и поддержка 802.11ah (2025)
https://www.arednmesh.org/content/aredn-release-325100-80211ah-support
Реальный пример использования HaLow, а не гарантия поддержки любым телефоном.
## S26 — Noise Protocol Framework
https://noiseprotocol.org/
Шаблоны рукопожатий и свойства шифрования. Не нужно самостоятельно изобретать криптографию.
## Физические технологии и радио
## S27 — Wi-Fi Aware, AOSP (страница обновлена в 2026)
https://source.android.com/docs/core/connect/wifi-aware
Обнаружение устройств напрямую без интернета, на поддерживаемых Android-устройствах.
## S28 — Wi-Fi Aware, Android API
https://developer.android.com/develop/connectivity/wifi/wifi-aware
Ограничения аппаратной поддержки и API.
## S29 — Wi-Fi 7 MLO, Android/AOSP
https://source.android.com/docs/core/connect/wifi-7
Multi-Link Operation — несколько физических Wi-Fi линков; **не** автоматическая межгородская mesh-маршрутизация.
## S30 — WBA: полевые испытания Wi-Fi 7 MLO (февраль 2026)
https://wballiance.com/wba-validates-wifi-7-mlo-reliability-cablelabs-intel/
Результаты испытаний в жилой среде, не универсальная гарантия скорости для ICE-NET.

136
archive/sources/part2.md Normal file
View file

@ -0,0 +1,136 @@
# Каталог источников ICE-NET — продолжение (S31–S60)
## S31 — LoRaWAN: практические ограничения, The Things Network
https://www.thethingsnetwork.org/docs/lorawan/limitations/
Низкая скорость и airtime. **LoRa PHY и LoRaWAN не одно и то же**; цифры этой страницы относятся к LoRaWAN.
## S32 — ITU-R P.530-19 (утверждён сентябрь 2025)
https://www.itu.int/rec/R-REC-P.530-19-202509-I/en
Расчёт радиорелейных линий прямой видимости с учётом дождя, многолучёвости и отказов.
## S33 — GNU Radio, проект и симуляция без SDR-железа
https://www.gnuradio.org/about/
Разработка сигналов и модуляции; можно использовать без радиооборудования.
## S34 — GNU Radio 4.0 RC3 (13 октября 2026)
https://www.gnuradio.org/news/2026-10-13-gr4-rc3-release/
Активное развитие SDR-экосистемы, **релиз-кандидат**.
## S35 — AREDN release notes в GitHub (обновления 2026)
https://github.com/aredn/aredn/blob/main/RELEASE_NOTES.md
Пример практики совмещения OpenWrt, Wi-Fi, HaLow, Babel и туннелей.
## Регулирование
## S36 — CEPT/EFIS, реестр условий SRD
https://efis.cept.org/sitecontent.jsp?sitecontent=srd_regulations
Условия зависят от диапазона, страны, мощности, назначения и класса устройства. Проверять непосредственно перед испытаниями.
## S37 — ERC/REC 70-03, документация регуляторов CEPT
https://docdb.cept.org/document/845
История обновлений, национальные ограничения; выпуски 2026, сверить с EFIS.
## S38 — Директива ЕС 2014/53/EU (RED)
https://eur-lex.europa.eu/eli/dir/2014/53/oj/eng
Радиооборудование, соответствие требованиям при выводе оборудования на рынок ЕС.
## S39 — Еврокомиссия: RED и изменения 2026
https://single-market-economy.ec.europa.eu/sectors/electrical-and-electronic-engineering-industries-eei/radio-equipment-directive-red_en
Правовой статус новых актов; упомянута отмена отдельного акта по кибербезопасности RED с переходом к CRA.
## Эмуляция и тестирование
## S40 — Linux network namespaces, man7
https://man7.org/linux/man-pages/man7/network_namespaces.7.html
Изоляция сетевых устройств и таблиц маршрутизации в одном Linux.
## S41 — Linux tc-netem, man7
https://linuxman7.org/linux/man-pages/man8/tc-netem.8.html
Имитация задержки, потерь, переупорядочивания, ограничения скорости.
## S42 — ns-3 simulator, official docs
https://www2.nsnam.org/documentation/
Дискретно-событийная модель; для исследования радиосети.
## S43 — CORE Network Emulator
https://github.com/coreemu/core
Эмуляция множества узлов и реального сетевого ПО.
## S44 — Mininet
https://mininet.org/
Виртуальные сети на одном компьютере, удобны для первоначального тестирования логики.
## Люди и сообщества, где реально можно искать участников
## S45 — NYC Mesh: волонтёры и удалённые разработчики
https://www.nycmesh.net/help
Публичные способы участия; удалённый софт и документация возможны.
## S46 — Freifunk: вступление и создание сообщества
https://freifunk.net/en/how-to-join/
Сети с местными сообществами, разработчики и инфраструктура.
## S47 — guifi.net: общие телекоммуникационные сети
https://network.guifi.net/
Модель совместного владения и эксплуатации инфраструктуры.
## S48 — Wireless Battle of the Mesh
https://www.battlemesh.org/HomePage
Встречи разработчиков wireless mesh и OpenWrt. Мероприятие 2026 состоялось 7–13 сентября.
## S49 — Battlemesh v18: архив мероприятия 2026
https://www.battlemesh.org/BattleMeshV18
Записи, участники, темы и организаторы; не выдавать прошлое событие за предстоящее.
## S50 — Reddit r/meshtastic
https://www.reddit.com/r/meshtastic/
Реальная активность и практическое оборудование/сети.
## S51 — Reddit r/darknetplan
https://www.reddit.com/r/darknetplan/
Идеи о независимых mesh-сетях. Качество обсуждений неоднородно.
## S52 — Reddit r/amateurradio
https://www.reddit.com/r/amateurradio/
Радиочастоты, антенны, лицензии, реальные ограничения.
## S53 — Reddit r/selfhosted
https://www.reddit.com/r/selfhosted/
Локальные сервисы, эксплуатация, самохостинг и автономность.
## S54 — Reddit r/Lora
https://www.reddit.com/r/LoRa/
Датчики, модемы и практические радиопросчёты.
## S55 — Reddit r/ReticulumNetwork
https://www.reddit.com/r/ReticulumNetwork/
Сообщество существует, но на дату проверки **не имело публикаций**; плохая основная площадка для поиска команды.
## S56 — Reddit r/Meshnet
https://www.reddit.com/r/meshnet/
Существует, но много бытовых тем о домашних Wi-Fi mesh-системах; не основной форум для нового сетевого протокола.
## S57 — FSO: исследование надёжности оптической связи при тумане (ноябрь 2026)
https://www.mdpi.com/2304-6732/13/11/1013
Исследовательская статья; реальные выводы о погодной чувствительности FSO, не подтверждение конкретной будущей системы.
## S58 — IETF: списки рассылок
https://www.ietf.org/participate/lists/wg-lists/
Как участвовать: изучить документы и архив обсуждений до публикации идей.
## S59 — Apple Developer Wi-Fi Aware
https://developer.apple.com/documentation/WiFiAware
Фреймворк для поддерживаемых устройств и сценариев, не гарантия поддержки всей линейки.
## S60 — libp2p 0.57.1 (15 октября 2026)
https://docs.rs/crate/libp2p/latest
Конкретный пример активного Rust SDK, версия быстро устаревает.
---
### Как использовать источники
1. RFC/документация проекта → факты об уже существующих протоколах.
2. Исследовательская статья → гипотеза, модель, ограниченная экспериментальная область.
3. Форум/Reddit → практические отзывы и приглашения к обсуждению, **не** доказательство технических характеристик.
4. Дизайн ICE-NET ниже → **авторская проектная гипотеза**, пока не стандарт и не реальная работающая сеть.

84
docs/INDEX.md Normal file
View file

@ -0,0 +1,84 @@
# Индекс ICE-NET
Все Markdown-документы проекта. Цифры и состояние — только в [STATUS.md](STATUS.md).
## Корень
- [README.md](../README.md)
- [RULES.md](../RULES.md)
- [TODO.md](../TODO.md)
## Актуальные документы
- [docs/INDEX.md](../docs/INDEX.md)
- [docs/SOURCES.md](../docs/SOURCES.md)
- [docs/STATUS.md](../docs/STATUS.md)
- [docs/architecture/contracts.md](../docs/architecture/contracts.md)
- [docs/architecture/crates.md](../docs/architecture/crates.md)
- [docs/architecture/decisions.md](../docs/architecture/decisions.md)
- [docs/architecture/overview.md](../docs/architecture/overview.md)
- [docs/build/dependencies.md](../docs/build/dependencies.md)
- [docs/build/slint_license.md](../docs/build/slint_license.md)
- [docs/community/announcement_en.md](../docs/community/announcement_en.md)
- [docs/community/announcement_ru.md](../docs/community/announcement_ru.md)
- [docs/guides/commands.md](../docs/guides/commands.md)
- [docs/guides/contributing.md](../docs/guides/contributing.md)
- [docs/guides/quickstart.md](../docs/guides/quickstart.md)
- [docs/guides/testing.md](../docs/guides/testing.md)
- [docs/research/gaps.md](../docs/research/gaps.md)
- [docs/research/licensing.md](../docs/research/licensing.md)
- [docs/research/meshtastic.md](../docs/research/meshtastic.md)
- [docs/research/reticulum.md](../docs/research/reticulum.md)
- [docs/review/questions.md](../docs/review/questions.md)
- [docs/review/revision.md](../docs/review/revision.md)
- [docs/review/rf_notes.md](../docs/review/rf_notes.md)
- [docs/security/guard.md](../docs/security/guard.md)
- [docs/security/privacy.md](../docs/security/privacy.md)
- [docs/simulator/city_editor.md](../docs/simulator/city_editor.md)
- [docs/simulator/event_model.md](../docs/simulator/event_model.md)
- [docs/simulator/metrics.md](../docs/simulator/metrics.md)
- [docs/simulator/scenarios.md](../docs/simulator/scenarios.md)
## Workspace
- [workspace/README.md](../workspace/README.md)
## Архив исследования 0.1
- [archive/README.md](../archive/README.md)
- [archive/README_0.1.md](../archive/README_0.1.md)
- [archive/START_HERE_0.1.md](../archive/START_HERE_0.1.md)
- [archive/build/migration_egui_to_slint.md](../archive/build/migration_egui_to_slint.md)
- [archive/community/call_for_collaborators.md](../archive/community/call_for_collaborators.md)
- [archive/community/projects_people.md](../archive/community/projects_people.md)
- [archive/community/reddit_strategy.md](../archive/community/reddit_strategy.md)
- [archive/docs/changelog.md](../archive/docs/changelog.md)
- [archive/docs/future_questions.md](../archive/docs/future_questions.md)
- [archive/docs/glossary.md](../archive/docs/glossary.md)
- [archive/implementation/mvp_zero_budget.md](../archive/implementation/mvp_zero_budget.md)
- [archive/implementation/roadmap.md](../archive/implementation/roadmap.md)
- [archive/implementation/simulation.md](../archive/implementation/simulation.md)
- [archive/implementation/tests_metrics.md](../archive/implementation/tests_metrics.md)
- [archive/project/foundation/architecture.md](../archive/project/foundation/architecture.md)
- [archive/project/foundation/requirements.md](../archive/project/foundation/requirements.md)
- [archive/project/foundation/vision.md](../archive/project/foundation/vision.md)
- [archive/project/governance/decisions.md](../archive/project/governance/decisions.md)
- [archive/project/governance/risks.md](../archive/project/governance/risks.md)
- [archive/protocol/control/discovery_control_plane.md](../archive/protocol/control/discovery_control_plane.md)
- [archive/protocol/control/routing.md](../archive/protocol/control/routing.md)
- [archive/protocol/control/transport_qos.md](../archive/protocol/control/transport_qos.md)
- [archive/protocol/foundation/identities_addresses.md](../archive/protocol/foundation/identities_addresses.md)
- [archive/protocol/foundation/overview.md](../archive/protocol/foundation/overview.md)
- [archive/protocol/foundation/packet_wire_format.md](../archive/protocol/foundation/packet_wire_format.md)
- [archive/protocol/store/storage_dtn.md](../archive/protocol/store/storage_dtn.md)
- [archive/radio/backhaul_city_deployment.md](../archive/radio/backhaul_city_deployment.md)
- [archive/radio/legal_spectrum.md](../archive/radio/legal_spectrum.md)
- [archive/radio/physical_links.md](../archive/radio/physical_links.md)
- [archive/research/2025_2026_updates.md](../archive/research/2025_2026_updates.md)
- [archive/research/comparison.md](../archive/research/comparison.md)
- [archive/research/reading_list.md](../archive/research/reading_list.md)
- [archive/security/crypto_privacy.md](../archive/security/crypto_privacy.md)
- [archive/security/ice_engine.md](../archive/security/ice_engine.md)
- [archive/security/threat_model.md](../archive/security/threat_model.md)
- [archive/sources/part1.md](../archive/sources/part1.md)
- [archive/sources/part2.md](../archive/sources/part2.md)

38
docs/SOURCES.md Normal file
View file

@ -0,0 +1,38 @@
# Источники ICE-NET (срез 12.11.2026, дополнено 13.11.2026)
Список ссылок на **первичные** документы и каталоги. Это источники фактов,
не разрешение на копирование исходников. Архивные 60 источников —
[часть 1](../archive/sources/part1.md) и [часть 2](../archive/sources/part2.md).
| ID | Назначение | Первоисточник |
|---|---|---|
| N01 | Reticulum: полная текущая документация (1.6.0) | https://reticulum.network/manual/ |
| N02 | Reticulum: интерфейсы, обнаружение, rate limits | https://reticulum.network/manual/interfaces.html |
| N03 | Reticulum: transport nodes и разнородные среды | https://reticulum.network/manual/networks.html |
| N04 | Reticulum: FIFO для обычного трафика | https://reticulum.network/manual/understanding.html |
| N05 | Reticulum: лицензия и ограничения | https://github.com/markqvist/Reticulum/blob/master/LICENSE |
| N06 | Reticulum: код и происхождение, предупреждения | https://github.com/markqvist/Reticulum |
| N07 | Meshtastic: broadcast & next-hop | https://meshtastic.org/docs/overview/mesh-algo/ |
| N08 | Meshtastic: firmware и версии, включая prerelease | https://github.com/meshtastic/firmware/releases |
| N09 | Meshtastic: лицензии и компоненты | https://github.com/meshtastic |
| N10 | Cargo workspaces | https://doc.rust-lang.org/cargo/reference/workspaces.html |
| N11 | Rust 2024 resolver v3 | https://doc.rust-lang.org/stable/edition-guide/rust-2024/cargo-resolver.html |
| N12 | Отдельные integration tests | https://doc.rust-lang.org/stable/cargo/reference/cargo-targets.html |
| N13 | _снято_: eframe/egui (GUI заменён на Slint в v0.3) | — |
| N14 | _снято_: egui MSRV | — |
| N15 | Симуляция и отличие от реального RF (ns-3) | https://www.nsnam.org/ |
| N16 | Wi-Fi Aware (Apple) | https://developer.apple.com/documentation/wifiaware |
**Ограничения:** страницы с latest могут изменяться после даты среза;
нужен `Cargo.lock` и регулярная повторная проверка лицензий. Выписанные факты
из [внешней ревизии](review/revision.md) отмечены отдельно от нового поиска.
## Дополнение: Slint и экосистема
- [Slint 1.18.1 Rust API](https://docs.slint.dev/latest/docs/rust/slint/) — интеграция Rust с компилируемым `.slint`.
- [Флаги Slint](https://docs.slint.dev/latest/docs/rust/slint/docs/cargo_features/) — управление backend/renderer.
- [Slint Winit backend](https://docs.slint.dev/latest/docs/slint/guide/backends-and-renderers/backend_winit/) — desktop Linux/X11/Wayland.
- [Slint TouchArea](https://docs.slint.dev/latest/docs/slint/reference/gestures/toucharea/) — drag без сторонней библиотеки.
- [Slint license](https://github.com/slint-ui/slint/blob/master/LICENSE.md) — GPLv3 / royalty-free / commercial.
- [Slint crate v1.18.1](https://docs.rs/crate/slint/1.18.1/source/Cargo.toml) — MSRV 1.92.
- [GNU LGPL v3](https://www.gnu.org/licenses/lgpl-3.0.html) и [GPL v3](https://www.gnu.org/licenses/gpl-3.0.html) — лицензия кода ICE-NET.

67
docs/STATUS.md Normal file
View file

@ -0,0 +1,67 @@
# Статус ICE-NET (единственный источник цифр)
Все остальные документы **ссылаются сюда** и не повторяют числа. Меняешь код —
обнови только этот файл. Дата последней сверки: **13 ноября 2026**.
## Окружение и лицензия
| Параметр | Значение |
| --- | --- |
| Toolchain | Rust 1.95.0 (`workspace/rust-toolchain.toml`), Edition 2024, resolver 3 |
| Crates workspace | 7 библиотек + 2 приложения (`icenetd`, `icenet-city`) |
| Лицензия кода | **LGPL-3.0-or-later** (`LICENSE`, `LICENSES/GPL-3.0.txt`), см. ADR-010 |
| GUI-зависимость | Slint 1.18.1 (отдельная лицензионная проверка, [slint_license.md](build/slint_license.md)) |
| Git | репозиторий инициализирован; коммитов пока нет |
## Что проверено (в этой сессии)
| Проверка | Результат |
| --- | --- |
| `python3 tools/check_layout.py` | PASS (≤250 строк, ≤4 файла на каталог) |
| `cargo fmt --all -- --check` | чисто |
| `cargo clippy --workspace --all-targets -- -D warnings` | чисто |
| `cargo test --workspace` | **91 тест, 0 падений** (в v0.3 было 77) |
| Записей в `Cargo.lock` | 523 (не равно числу скомпилированных crates) |
| Поиск маршрута, сетка 1000 узлов, 200 запросов, **debug** | p50 ≈ 6.3 мс, p95 ≈ 8.4 мс (**реальное** время CPU, не симулированное) |
Не перепроверялось в этой сессии и взято из записей 12.11.2026: ручной прогон GUI под
X11/Xvfb (клики, drag, экспорт), RSS GUI ≈ 55 МБ (debug), `cargo build --release`
`icenet-city` ≈ 2m27s и 18 МБ без strip. Wayland не проверялся. Сравнение с egui
невозможно: старого проекта и lock-файла нет.
## Что реализовано, а что нет
| Область | Состояние |
| --- | --- |
| Классы трафика, запрет Bulk на slow radio | Есть. Класс **выводится из размера** (`effective_for`): Control ≤ 256 Б, Text ≤ 4096 Б, иначе Bulk |
| Выбор пути | Dijkstra с детерминированным tie-break; возвращает индексы линков |
| Ёмкость линка | Есть: один линк — одна передача, слоты эфира, очередь на ребре, бэклог и airtime |
| Статусы | `Queued`, `InFlight`, `Delivered`, `Expired`; ложный `Delivered` при обрыве маршрута исправлен |
| TTL / EXPIRED | Есть |
| Store-and-forward | **Нет**: сообщение лежит в общем списке, не на узле; нет квот и store-carry |
| Случайность / `seed` | **Нет**: детерминизм обеспечен отсутствием случайности |
| Служебный (control) трафик | **Не генерируется**: announce/discovery не моделируются |
| Wire-формат | Черновик без криптографии, без fragmentation |
| ICE Guard | ACL, размер, очередь, replay window, token bucket; `authenticated` — тестовый флаг |
| Транспорт | `MemoryTransport` и неблокирующий `UdpTransport` (loopback) |
| Криптография, handshake, ключи | Нет |
| Реальное радио, RF-модель | Нет |
## Статус гипотез
| Гипотеза | Статус |
| --- | --- |
| H1: bulk не занимает airtime slow radio | Обеспечена фильтром маршрутизации и размером; тесты проходят, но это **инвариант кода**, а не научный результат. Измеряется `slow_radio_airtime_ms` |
| H2: короткий текст доходит по единственному slow-пути | Теперь проверяема (есть ёмкость, задержка растёт с очередью). Нагрузочных экспериментов ещё не было |
| H3: нет ложного `DELIVERED` | Исправлено и покрыто регрессионными тестами (`tests/city.rs`) |
| H4: контрольный airtime при 100→1000 узлов | **Не проверяема**: нет генератора служебного трафика |
## Известные ограничения симулятора
- Маршрутизация — оракул: видит весь граф бесплатно; стоимость пути не учитывает бэклог.
- Перепланирование начинает передачу заново с источника; уже потраченный airtime не возвращается.
- `first_route_ms` — **абсолютная** метка симулированного времени, не задержка от создания.
- Нет потерь, коллизий, скрытых терминалов, duty cycle и MAC; очередь — по порядку резервирования.
- Число в `demo_bps` — иллюстрация, не измерение железа.
Планы и чек-листы: [TODO.md](../TODO.md).

View file

@ -0,0 +1,44 @@
# Первые контракты и определения
## Какие ID какие
- `NodeId` **реальной сети** в `icenet-core` пока представлен `u64` исключительно для каркаса. Это НЕ криптографическая идентичность!
- `SimNodeId` по сути тот же тестовый ID. В будущем: стабильный fingerprint публичного ключа и отдельный DeviceID.
- `ServiceId(u64)` — логический номер сервиса, не ОС-порт и не гарантия уникальности без схемы namespace.
- `LinkKind::{SlowRadio, FastWireless, Wired, Internet}` — профили симуляции, не протоколы передачи по воздуху.
## Классы
- `Control`: объявления/короткие служебные данные, минимальный payload.
- `Text`: малый payload (≤ 4096 Б), в исключительных случаях допустима передача по slow radio.
- `Bulk`: файлы/фото, `SlowRadio` запрещён независимо от скорости маршрута.
- Класс **выводится из размера**: `effective_for(bytes)` повышает Control > 256 Б до Text, Text > 4096 Б до
Bulk; `Bulk` не уменьшается. Метка отправителя не даёт доступа к slow radio.
## Маршрут
- `choose_path` возвращает последовательность NodeId, индексы использованных линков и приблизительную
задержку сериализации **без очереди**.
- Каждый переход проверяется на `enabled`, разрешённый класс, throughput > 0.
- Для сравнимости первые измерения: dijkstra с deterministic tie-break, затем baseline shortest hops.
- Нельзя автоматически считать `route_found` равным `delivered`.
- Линк несёт одну передачу за раз: время прибытия включает ожидание слота. `Delivered` ставится
только если маршрут (узлы, линки, класс) ещё пригоден на момент `tick`.
- У сообщения есть `created_ms`/`expires_ms`; истёкшее сообщение переходит в `Expired`
и не оживает. Прибытие не позже `expires_ms` считается доставкой.
- CSV/JSON экспорт детерминирован и не использует системные часы.
## Сетевой пакет (черновик)
`magic | version | class | service_id | payload_len | bytes`.
- Пример без криптографии, без anti-replay, без fragmentation.
- Отдельный парсер ограничивает длину входящих байтов и возвращает `Result`.
- В продакшене формат нужно будет изменить после threat modeling и test vectors.
## Результат безопасности
- `Permit`, `Deny(reason)`; без "strike back".
- `Deny` не расходует replay/rate state; `sequence` фиксируется только после `Permit`.
- Входной `authenticated: bool` в scaffold — только тестовый флаг,
**не криптографическая проверка**.

View file

@ -0,0 +1,47 @@
# Cargo workspace: границы крейтов
| Crate | Ответственность | Кому может зависеть |
|---|---|---|
| `icenet-core` | типы идентификаторов, класс сообщения, среда | стандартная библиотека |
| `icenet-wire` | framing + парсер *чернового* пакета | core |
| `icenet-guard` | детерминированные ACL, размер, очередь, replay, rate (без crypto) | core |
| `icenet-routing` | выбор допустимого пути на графе, индексы линков | core |
| `icenet-transport` | интерфейс отправки байтов, memory + UDP адаптеры | core |
| `icenet-sim` | виртуальное время, узлы, ёмкость линков, сценарии, метрики | core, routing |
| `icenet-sdk` | будущий публичный фасад API | core, wire, guard, transport |
| `icenetd` | CLI и UDP `serve`/`send-udp`; позже daemon | sdk, sim |
| `icenet-city` | GUI-карта и контроллер сценариев | sim, core, Slint |
## Принципы границ
- Ни один core crate не зависит от `Slint`, Tokio, Linux, Wi-Fi или LoRa.
- Sim **не** использует `icenetd`; GUI **не** содержит алгоритма маршрутизации.
- SDK является библиотекой встраивания, а daemon и GUI — клиентами публичных интерфейсов.
- Адаптеры настоящего радио добавятся **после** тестов в симуляторе и решения ADR.
- Защиту и типы не дублировать в GUI: дополнять tests на границе библиотеки.
## Почему не 20 crates
SOLID — не повод усложнять сборку. Переносим модуль в crate, если есть отдельная
ответственность, тестируемый контракт или платформенная граница. Сейчас есть
7 библиотек и 2 приложения, почти все минимальные.
## Программируемые интерфейсы
- `Transport::send(bytes)`, `Transport::recv()` — реальные bytes, не UI-события.
- `choose_path(nodes, links, source, destination, class, size)` — чистая функция.
- `City::send(...)`, `City::tick(delta_ms)`, `City::set_link_enabled(...)`, `City::link_airtime_ms(kind)` — контролируемая модель.
- `Guard::check(context)` — решение доступа, не ответная атака.
- `icenetd route|send|sim|policy|wire-*` — headless-проверка этих контрактов.
Детали: [API-контракты](contracts.md) и [симулятор](../simulator/city_editor.md).
## Зависимости и границы UI
`icenet-city` — только адаптер интерфейса. Slint UI в `ui/main.slint`;
`src/state.rs` изменяет `City`; `src/view.rs` конвертирует данные в модели;
`src/main.rs` подключает callbacks. В остальные crates не импортируется Slint.
Все 7 библиотек намеренно разделены по обязанностям, **все без внешних crates** (числа — в [STATUS](../STATUS.md)).
Если эти границы перестанут приносить пользу, нужно объединить crates по ADR,
а не бездумно делить ещё мельче. См. [аудит](../build/dependencies.md).

View file

@ -0,0 +1,48 @@
# ADR register
| ADR | Решение | Статус |
|---|---|---|
| ADR-001 | Userland Rust вместо Linux kernel fork | Принято для MVP |
| ADR-002 | Slow control / fast bulk policy | Принято как **гипотеза** |
| ADR-003 | Rust workspace + отдельные integration tests | Принято |
| ADR-004 | Город — графовая DES-модель, не RF-доказательство | Принято |
| ADR-005 | Slint 1.18.1 + software renderer для native GUI (egui удалён) | Принято в v0.3 |
| ADR-006 | Реальная криптография, wire-format, физические драйверы | Открыто |
| ADR-007 | Свой полноценный протокол или адаптер к Reticulum | Открыто до экспериментов |
| ADR-008 | Общая идентичность человека на нескольких устройствах | Открыто |
| ADR-009 | TTL и явное состояние `EXPIRED` для недоставленных сообщений | Принято в v0.3 |
| ADR-010 | Лицензия собственного кода: LGPL-3.0-or-later | Принято (автор проекта) |
| ADR-011 | Класс трафика выводится из размера, метка не доверена | Принято в v0.4 |
| ADR-012 | Ёмкость линка: слоты эфира с владельцем, очередь на ребре | Принято в v0.4 |
## Для каждого нового ADR
Описание контекста → альтернативы → причины выбора → проверяемые последствия → риски → срок ревизии.
Запрещено объявлять открытые ADR реализованными в README.
## ADR-010 · Лицензия: LGPL-3.0-or-later
- **Контекст:** автор выбрал LGPL; репозиторий не имел лицензии.
- **Решение:** LGPL-3.0-or-later; тексты в `LICENSE` и `LICENSES/GPL-3.0.txt` (LGPL v3 опирается на GPL v3).
- **Альтернативы:** LGPL-2.1 (несовместима с GPLv3-only), MIT/Apache (не выбраны автором).
- **Последствия:** Rust линкует crates статически; при распространении бинарника с LGPL-кодом нужно
дать получателю возможность пересобрать его с изменённой библиотекой (исходники или объектные файлы).
Комбинация с Slint по GPLv3 даёт GPLv3 для бинарника GUI. Юристом не проверялось.
- **Ревизия:** до первой публикации бинарников.
## ADR-011 · Класс по размеру
- **Контекст:** метка `Text` на 5 МБ проходила по slow radio: класс заявлял отправитель.
- **Решение:** `TrafficClass::effective_for(bytes)`: Control > 256 Б → Text, Text > 4096 Б → Bulk;
`Bulk` не уменьшается. Применяется внутри `choose_path`, поэтому защищает всех вызывающих.
- **Последствия:** лимит Text совпадает с лимитом payload wire-кадра; пороги условные, их надо
подтвердить airtime-расчётом для реального радио (ADR-006).
## ADR-012 · Ёмкость линка
- **Контекст:** линк пропускал любое число сообщений параллельно, поэтому S4/H2/H4 были пустыми.
- **Решение:** на каждом линке календарь слотов; слот принадлежит сообщению; перепланирование
освобождает ещё не начатые слоты. Время передачи — `transfer_ms + HOP_OVERHEAD_MS` на hop.
- **Последствия:** задержка растёт с очередью, TTL может истечь из-за бэклога. Выбор пути пока не
учитывает бэклог, перепланирование начинает с источника — это записано как ограничение.

View file

@ -0,0 +1,44 @@
# Актуальная архитектура ICE-NET
## Инварианты
1. `NodeID` — стабильная криптографическая идентичность (будущая), не IP и не физическая координата.
2. `ServiceID` адресует сервис на узле; 64-битные значения — концепция, **не TCP-порты**.
3. Медленный канал (`SlowRadio`) допускает beacon, route-discovery и маленький текст, но не bulk.
Класс определяется **размером**, а не только меткой отправителя (Control ≤ 256 Б, Text ≤ 4096 Б).
4. Фото и файлы отправляются только если найден **разрешённый по политике** путь.
5. Отсутствие пути ≠ успешная доставка; статусы `Queued`, `InFlight`, `Delivered`, `Expired` различаются; `Delivered` только если маршрут жив.
6. End-to-end криптография обязательна для реальной сети, **в симуляторе пока не реализована**.
7. Сетевой слой существует независимо от транспорта (UDP/радиомодем/ethernet) и UI.
## Границы
```text
apps/icenet-city ───> icenet-sim ──> icenet-routing ──> icenet-core
apps/icenetd ───────> icenet-sim (offline-команды)
apps/icenetd ───────> icenet-sdk ───> icenet-wire / icenet-transport / icenet-guard
└──────────────> icenet-core
```
Актуальный список и точные зависимости: [crates.md](crates.md).
## Control plane / data plane
- **Control**: маленькие объявления, отметки доступности, поиск маршрутов, ACK; отдельный лимит airtime и TTL.
- **Data**: текст, файлы, сервисные потоки; расписание маршрутов с учётом профиля физического канала.
- В будущем LoRa может передавать экстренный текст, если это допускают местные правила.
- В сети неизвестных узлов объявления не должны бесконтрольно распространяться; нужны квоты, дедупликация, expire.
## Какую проблему изучаем
Не «мы изобрели mesh/IPv6/крипто-адреса», а:
**может ли строгая политика передачи по гетерогенным каналам избежать перегрузки узкой полосы,
сохранив доставку коротких сообщений и стабильную идентичность?**
Это гипотеза. Сравнивать надо с [Reticulum](../research/reticulum.md) и baselines.
## Важная разница между симуляцией и продакшеном
- Редактор города — модель графа со скоростью ребра, не радиотехнический расчёт покрытия.
- В нём нет настоящей криптографии, реального Wi-Fi, скрытых терминалов, интерференции, MAC.
- Числа в демо условны. Линк несёт одну передачу за раз, но потерь, коллизий и MAC нет. Для реального RF потребуется измерение или ns-3/другая PHY-модель.

50
docs/build/dependencies.md vendored Normal file
View file

@ -0,0 +1,50 @@
# Аудит зависимостей ICE-NET
Числа (записи `Cargo.lock`, версия Rust, результаты сборки и замеров) — только в
[STATUS.md](../STATUS.md). Здесь — решения и политика.
## Прямые внешние зависимости
| Уровень | Внешняя зависимость | Почему |
| --- | --- | --- |
| `icenet-core`, `wire`, `guard`, `routing`, `transport`, `sdk`, `sim` | нет | Алгоритмы и интерфейсы на `std` |
| `icenetd` | нет | CLI и UDP на `std::net` |
| `icenet-city` | `slint = 1.18.1` | Декларативный GUI |
| сборка `icenet-city` | `slint-build = 1.18.1` | Генерация Rust из `.slint` |
`slint` подключён с `default-features = false` и признаками `std`, `backend-winit`,
`renderer-software`, `compat-1-18`. Не включены Qt, Skia, FemtoVG, OpenGL, Vello, WGPU,
системный трей и интеграции. `renderer-software` не требует GPU, но `winit` зависит от
окружения рабочего стола. `slint-build` имеет собственный большой граф, который нельзя
убрать при заранее компилируемом UI. Меньшие флаги **не гарантируют** меньше транзитивных
зависимостей: число записей lock — не число скомпилированных crates.
## История
До v0.3 GUI был на `eframe`/`egui`. Он заменён на Slint; старый lock-файл не сохранён,
поэтому сравнение размера, RSS и старта с egui **невозможно** и снято с плана.
Инструкция по переходу — в архиве: [migration_egui_to_slint.md](../../archive/build/migration_egui_to_slint.md).
## Проверка
```bash
cd workspace
cargo tree -p icenet-city --depth 1
cargo clippy --workspace --all-targets -- -D warnings
cargo test --workspace
cargo build -p icenet-city --release
```
`Cargo.lock` нужно коммитить: workspace содержит исполняемые программы.
## Политика для новых crates
Перед добавлением библиотеки — отдельный ADR: какую задачу решает, почему нельзя на `std`,
MSRV, лицензия (совместимость с LGPL-3.0-or-later), число транзитивных crates, размер,
поддержка и план отказа. Не импортировать `serde`, `tokio`, `async-std`, `tracing`, `wgpu`,
`iced`, `egui` до замеров.
Источники:
- [Slint feature flags](https://docs.slint.dev/latest/docs/rust/slint/docs/cargo_features/)
- [Slint Winit backend](https://docs.slint.dev/latest/docs/slint/guide/backends-and-renderers/backend_winit/)
- [Slint Rust integration](https://docs.rs/slint/latest/slint/)

25
docs/build/slint_license.md vendored Normal file
View file

@ -0,0 +1,25 @@
# Лицензия Slint: решение до публичного релиза
Slint не MIT/Apache; это **тройное лицензирование**:
GPLv3, royalty-free с условиями и коммерческая лицензия.
- **GPLv3:** можно для открытого проекта, но совместное распространяемое
приложение должно соблюдать GPLv3.
- **Royalty-free:** для desktop/mobile/web, включая проприетарные приложения,
но с надлежащей атрибуцией Slint; не распространяется на embedded.
- **Коммерческая:** вариант для закрытого embedded или специальных требований.
Лицензия собственного кода ICE-NET — **LGPL-3.0-or-later** (ADR-010). Она совместима с GPLv3:
если `icenet-city` распространяется со Slint по GPLv3, бинарник GUI целиком идёт под GPLv3.
Если нужна иная схема (royalty-free с атрибуцией), её надо проверить отдельно. Юридически это
не проверялось.
Для ICE-NET: `icenet-city` — desktop GUI, а будущий роутер/LoRa-узел
не должен содержать Slint. Поэтому выбор лицензии GUI **отделён** от
сетевых библиотек. Условия не переносятся автоматически на независимые
библиотеки, но для связанного и распространяемого приложения обязательства
нужно проверить до публикации бинарников. Режим лицензии Slint для распространяемых бинарников GUI всё ещё **не выбран** (открытый пункт TODO).
Источники:
- [Официальный LICENSE Slint](https://github.com/slint-ui/slint/blob/master/LICENSE.md)
- [FAQ лицензирования](https://slint.dev/faqs)

View file

@ -0,0 +1,16 @@
# Community post draft (EN)
Hi! I'm experimenting with ICE-NET, a research-oriented Rust project inspired by
the Net of cyberpunk fiction: an identity-centric network that can span multiple underlying links, including
wired, IP, Wi-Fi, and low-bandwidth radio.
Our first falsifiable hypothesis is that a strict, measurable scheduling
policy can keep slow radio available for discovery and tiny messages while
sending bulk data only through appropriate higher-capacity paths.
This is currently a graph-based simulator and a set of protocol design notes,
not an operating wireless network. I'd love critical feedback on routing,
control-plane airtime, failure handling, and comparisons to Reticulum and
Meshtastic. Please suggest reproducible scenarios rather than feature lists.
Repository: https://git.wihuk.pro/boba/ICE-NET.git (LGPL-3.0-or-later).

View file

@ -0,0 +1,15 @@
# Черновик поста о проекте (RU)
Привет! Мы экспериментируем с ICE-NET — идеей сети, вдохновлённой «Сетью» из киберпанка, которая может работать через
разные виды связи, включая интернет, кабель, Wi-Fi и малоскоростное радио.
Цель первого опыта — проверить, можно ли гарантированно сохранять медленный
радиоканал для коротких сообщений и обнаружения узлов, направляя файлы только
через подходящие быстрые маршруты. Проект ещё на стадии симулятора на Rust,
а не развёрнутой радиосети.
Ищу обратную связь по routing/QoS, ограничению служебного трафика и тестам.
Особенно полезны критические сравнения с Reticulum, Meshtastic и существующими
планировщиками. Желателен конкретный сценарий или воспроизводимый тест.
Репозиторий: https://git.wihuk.pro/boba/ICE-NET.git (лицензия LGPL-3.0-or-later).

22
docs/guides/commands.md Normal file
View file

@ -0,0 +1,22 @@
# Шпаргалка команд
```bash
cd workspace
python3 tools/check_layout.py # file <=250 lines, dir <=4 files
cargo metadata --no-deps
cargo fmt --all -- --check
cargo clippy --workspace --all-targets -- -D warnings
cargo test --workspace
cargo run -p icenet-city
cargo run -p icenetd -- help
cargo run -p icenetd -- route --from 1 --to 3 --class bulk --size 5000000
cargo run -p icenetd -- send --from 1 --to 3 --class text --ticks 1000
cargo run -p icenetd -- sim --csv metrics.csv --json scenario.json
cargo run -p icenetd -- policy --service 77777 --size 5 --allow 1
cargo run -p icenetd -- wire-encode --service 7 --class text --text hello
cargo run -p icenetd -- serve --bind 127.0.0.1:9000 --count 1 --timeout 5000
cargo run -p icenetd -- send-udp --to 127.0.0.1:9000 --service 7 --class text --text hello
```
Пакеты в `crates/*` — библиотеки, `apps/*` — исполняемые приложения.
Cargo workspace использует общий `Cargo.lock` (коммитится) и закреплённый toolchain.

View file

@ -0,0 +1,18 @@
# Contributing conventions
- Feature branch: `feat/<short-name>`; fix: `fix/<short-name>`.
- PR начинается с проблемы и одного конкретного сценария, а не общих обещаний.
- Прежде чем добавлять crate, проверь зависимость и альтернативу module.
- Контракты в `docs/architecture/contracts.md`; тесты снаружи `src`.
- Публичные Rust элементы используют `///` doc comments на **английском**.
- Область изменения: краткая, отлаживаемая, 250 строк на файл максимум.
- До реального радио — legal review и тесты аппаратуры.
## Suggested PR template
- **What / Why:** одна конкретная проблема.
- **How:** какие crates и интерфейсы изменены.
- **Tests:** команды и результаты.
- **Metrics:** новые расходы CPU/RAM/airtime (если затронуты).
- **Security:** новые доверенные данные/границы.
- **Alternatives:** почему проще нельзя.

57
docs/guides/quickstart.md Normal file
View file

@ -0,0 +1,57 @@
# Arch Linux: быстрый запуск разработчика
## Установить инструменты
```bash
sudo pacman -S --needed rustup python git pkgconf clang
rustup default stable
rustup component add rustfmt clippy
```
Для GUI могут потребоваться системные библиотеки графического backend (X11/Wayland,
mesa, fontconfig и т.п.); точные пакеты зависят от Arch, X11/Wayland и версии Slint.
## Запуск
```bash
cd workspace
python3 tools/check_layout.py
cargo test -p icenet-routing -p icenet-sim
cargo run -p icenet-city
```
В окне: выбрать From/To, отправить `Text`/`Photo`, менять состояние линков,
шагать по времени. Это моделирование, не сетевое соединение.
## Отдельная библиотека
```bash
cargo test -p icenet-routing --test routing
cargo test -p icenet-sim --test city
cargo doc --workspace --no-deps
```
`icenetd` — headless CLI для проверки ядра без GUI и без сети:
```bash
cargo run -p icenetd -- route --from 1 --to 3 --class bulk --size 5000000
cargo run -p icenetd -- send --from 1 --to 3 --class text --ticks 1000
cargo run -p icenetd -- sim --csv /tmp/metrics.csv --json /tmp/scenario.json
```
Реальная UDP-передача между двумя процессами (локальный loopback, без crypto):
```bash
# терминал 1
cargo run -p icenetd -- serve --bind 127.0.0.1:9000 --count 1 --timeout 5000
# терминал 2
cargo run -p icenetd -- send-udp --to 127.0.0.1:9000 --service 7 --class text --text hello
```
Это незащищённый черновой кадр: без криптографии, аутентификации и защиты от replay на уровне сети.
## Примечание по версиям
`Slint 1.18.1` требует Rust >=1.92; toolchain закреплён в `rust-toolchain.toml` (версия — в [STATUS](../STATUS.md)).
Для ускоренной сборки не запускай `--workspace`, если сейчас тестируешь только
алгоритмы. Для релиза нужны полноценные CI-проверки всех crates и GUI.

42
docs/guides/testing.md Normal file
View file

@ -0,0 +1,42 @@
# Tests / CI
В Rust тесты лежат **только** в отдельной папке каждого крейта:
`crates/<name>/tests/*.rs` и `apps/<name>/tests/*.rs`. Inline `#[cfg(test)]` в `src` запрещён.
```bash
cd workspace
python3 tools/check_layout.py
cargo fmt --all -- --check
cargo clippy --workspace --all-targets -- -D warnings
cargo test --workspace
cargo doc --workspace --no-deps
```
## Пирамида
1. `core`: классы и логические ID.
2. `wire`: roundtrip + отказ на malformed frame / oversize.
3. `routing`: slow-only route for Text / forbidden for Bulk / oversized Text treated as Bulk / link-down.
4. `guard`: deny unknown service, cap payload, no fake authentication.
5. `sim`: node failure, in-flight state, queued retry, no false `Delivered` after a cut, link capacity (`tests/capacity/`).
6. `city`: GUI smoke test вручную (позднее snapshot/interaction integration tests).
## Приёмка
- Все новые тесты воспроизводимы без сети/радио.
- Каждый алгоритм не нуждается в реальном `sleep`; используется sim clock.
- При дефекте добавить regression test отдельно от production module.
- Маркеры `TODO`/`unimplemented!()` не прятать в ветки реальных пакетов.
Что проверено и сколько тестов проходит — в [STATUS](../STATUS.md).
## Быстрые и полные проверки
```bash
cd workspace
sh tools/check_all.sh # core routing/simulator, без Slint-сборки
sh tools/check_all.sh --full # также Slint GUI и все integration tests
```
`cargo fmt --all` форматирует в том числе GUI crate; `.slint` не проверяется
`rustfmt` и проверяется компилятором Slint в `build.rs`.

36
docs/research/gaps.md Normal file
View file

@ -0,0 +1,36 @@
# ICE-NET vs существующие стеки — гипотеза уникальной ценности
## Что НЕ уникально
- Не-IP идентификаторы, криптография, announce routing, transport-agnostic mesh;
всё это уже реализовано в Reticulum и смежных проектах.
- Узкополосная LoRa discovery и next-hop маршрутизация представлены в Meshtastic.
- Статические радио-мосты, Wi-Fi mesh, store-and-forward и DTN не новые технологии.
## Предлагаемая *исследовательская* функция
**Constrained Path Policy Engine (CPPE)** — единая проверяемая политика,
которая запрещает большой полезный трафик на slow-control интерфейсах,
сопоставляет классы сообщений с возможностями канала, допускает очереди при
partition и измеряет цену служебного discovery в airtime.
Это **не заявка на новизну**: ближайшие системы уже обладают частью этих функций;
эффект или удобство реализации должны быть доказаны экспериментами.
## Проверяемые гипотезы
- H1: bulk traffic не занимает slow-radio airtime при любом графе.
- H2: короткий текст достигает адресата, когда slow radio — единственный маршрут,
при условии допустимой загрузки канала.
- H3: смена link профилей/падение узла не создаёт ложного `DELIVERED`.
- H4: контрольный airtime и время поиска не растут неприемлемо при 100→1000 узлах.
## Baselines
1. Наивный shortest-hop.
2. Dijkstra по длине передачи/требуемому bitrate.
3. Reticulum с включёнными встроенными ограничениями/настройкой интерфейсов.
4. Meshtastic (узкая полоса, отдельный кейс, без попытки bulk).
Если не обнаружено измеримого преимущества или недостающего рабочего сценария:
не писать весь свой протокол, а сделать policy adapter / contribution.

View file

@ -0,0 +1,20 @@
# Правила лицензий и заимствований
- Нельзя копировать исходники Reticulum, считая их MIT или Apache: его лицензия
содержит специфические ограничения. См. [полный текст](https://github.com/markqvist/Reticulum/blob/master/LICENSE).
- Reticulum является полезным независимым проектом; это исследование **не** заявляет его несовместимым с любой иной лицензией без юридической проверки.
- Meshtastic firmware официально GPL-3.0: проверять условия распространения производных работ.
- Slint и другие Rust зависимости сверять по версиям, NOTICE и SPDX;
нельзя механически приписывать всем crates одну лицензию.
- Наша документация написана заново, исходники сторонних проектов в ZIP **не вложены**.
- Лицензия собственного кода: **LGPL-3.0-or-later** (решение автора, ADR-010). Код с несовместимой
лицензией (в том числе нестандартной лицензии Reticulum) в ICE-NET не копировать.
- LGPL и статическая линковка Rust: получатель бинарника должен иметь возможность пересобрать его с
изменённой библиотекой. Юридически не проверялось.
- Не использовать чужие эмблемы/названия так, будто проект официально поддержан.
## Рекомендация
На старте: изучение документации, самостоятельная реализация демонстрационного
графового алгоритма, инструментальные сравнительные тесты. Кодовые зависимости
выбирать после review лицензий и security advisories.

View file

@ -0,0 +1,29 @@
# Meshtastic: как устроена дальняя текстовая mesh-сеть
**Источник:** [официальный mesh algorithm](https://meshtastic.org/docs/overview/mesh-algo/).
- Фокус: LoRa, текст, телеметрия и локальные сообщения без сотовой инфраструктуры.
- В `2.6+` broadcast использует управляемое flooding; direct-message после
обнаружения направления может использовать next-hop, затем откатиться к flooding.
- Используется Protocol Buffers (`MeshPacket`).
- У Meshtastic есть реальные ограничения bandwidth, airtime и батареи.
- **Он не является транспортом больших фото и не совместим с Reticulum по пакету.**
## Что перенять
1. Безусловный лимит на размер/частоту широковещательных объявлений.
2. Разделение broadcast и directed routing.
3. Корректный ACK/дедуп и hop limit.
4. Реальные правила эфира региона до включения радиоплаты.
## Статус релизов
GitHub Releases в ноябре 2026 показывает **2.7.x Beta и 2.8.x Alpha**, часть
alpha помечена `Revoked`. Не устанавливать «latest» вслепую; выбирать
стабильный релиз, проверять совместимость и регион. [Список релизов](https://github.com/meshtastic/firmware/releases).
## Лицензии
Meshtastic — группа репозиториев с разными лицензиями; официальный firmware
указан как **GPL-3.0**. Перед переносом кода проверять конкретный репозиторий,
а не название экосистемы целиком: https://github.com/meshtastic

View file

@ -0,0 +1,31 @@
# Reticulum: что уже готово и чему учиться
**Источник:** [официальный manual](https://reticulum.network/manual/) (на 12.11.2026 отображается 1.6.0).
| Функция | Состояние у Reticulum | Вывод для ICE-NET |
|---|---|---|
| Не-IP идентичности | Есть, cryptographic addressing | не заявлять новизну |
| Multi-hop через разные среды | Есть | копировать идею, НЕ исходный код |
| Announce/path discovery | Есть | проверить baseline и стоимость пакетов |
| Interface discovery | Есть, включая private/encrypted announcements | большой пробел прежнего досье |
| QoS обычного трафика | В manual: обычные данные FIFO, без классов приоритета | возможная область исследований, не доказанное преимущество |
| Announce throttling / queue tuning | Есть | нельзя утверждать «нет контроля радиоэфира» |
| Передача файлов | Есть (`rncp`, Resources) | не изобретать ради галочки |
## Что тестировать руками
1. Две изолированные инстанции на localhost/UDP и transport node.
2. Смена интерфейса во время доступного маршрута.
3. Нагрузка на slow link: объявление + большой файл; измерить фактическое поведение.
4. Сверить с ограничениями Reticulum на rate, announce priority и interface modes.
5. Зафиксировать объективный пробел, а не предполагать его по обзору.
## Осторожно с лицензией!
[Reticulum License](https://github.com/markqvist/Reticulum/blob/master/LICENSE) — **нестандартная**;
включает дополнительные ограничения, включая запрет некоторых вредоносных
применений и использования кода для AI/ML training dataset. Её нельзя
автоматически считать MIT/Apache-2.0 или стандартной OSI-лицензией.
Изучать по документации можно; переносить код в ICE-NET без юридического
анализа нельзя. Официальный GitHub предупреждает о сторонних недостоверных
«совместимых» реализациях. Не объявлять wire-совместимость без тестов.

15
docs/review/questions.md Normal file
View file

@ -0,0 +1,15 @@
# Вопросы к автору ICE-NET (обсудить при следующем созвоне/чате)
1. **Главная функция:** исследуем constrained routing или хочешь полностью свой новый протокол независимо от сравнения?
2. **Городской GUI:** нужен только топологический граф или настоящий вид города с улицами/домами и RF-моделью?
3. **Основная роль устройств:** мобильные клиенты — только leaf или добровольное временное реле при зарядке?
4. **Идентичность:** один пользователь с несколькими устройствами — аккаунт, группа ключей или отдельные адреса?
5. **Радио:** какое разрешённое оборудование/страна первичного пилота? Без этой детали не подбирать частоты.
6. ~~Open-source: какая лицензия?~~ **Решено:** LGPL-3.0-or-later (ADR-010). Чужие источники по-прежнему не копировать.
7. **Сетевые сервисы:** первый полезный сценарий — текст, файл, remote SSH-like сервис или другое?
8. **Мобильная платформа:** Android первым или только Linux/Arch до готового desktop MVP?
9. **GUI:** достаточно 2D на Slint (сильно быстрее) или нужен 3D город (дороже и сложнее)?
10. **Скорость vs ресурсность:** какой предел RAM/CPU у самых слабых устройств?
**Не нужно отвечать сейчас на всё.** Для следующего этапа самый важный выбор:
пункт 1 и вид редактора из пункта 2.

57
docs/review/revision.md Normal file
View file

@ -0,0 +1,57 @@
# Что исправлено по внешней ревизии (18 страниц, 12.11.2026)
**Основание:** загруженный пользователем документ
`ICE-NET_ревизия_досье_и_план_реализации.pdf/docx`.
Документ оценил 35 старых файлов, выборочно проверил 10 свежих утверждений
и предложил дополнительные направления; утверждения ревизора не являются
автоматически окончательной спецификацией.
## Критика → решение v0.2
| Замечание | Ответ |
|---|---|
| Нет уникальной цели | отдельный [gaps.md](../research/gaps.md), H1–H4 |
| Много MD, нет кода | оформлен Cargo workspace, GUI и тесты; результаты проверок — в [STATUS](../STATUS.md) |
| Нет этапа 0 с Reticulum | отдельная P0 фаза в [TODO](../../TODO.md) |
| ICE Learning рискован | убран из MVP, [guard.md](../security/guard.md) |
| Нет mobile identity | открыто как ADR-008 |
| Нет экономической модели ретрансляторов | вынесено в [questions.md](questions.md) |
| Закон ограничен ЕС | по радиопередаче остаётся обязательная региональная проверка |
| Не зафиксированы API и тесты | [contracts.md](../architecture/contracts.md) + `workspace/*/tests/` |
| Нет выбора между своим протоколом/адаптером | ADR-007 открыт до полевых тестов |
## Важные поправки к самому обзору
- Фраза «телефоны не могут быть ретрансляторами» слишком категорична: Android может
участвовать в отдельных режимах, но непригоден как гарантированная магистраль 24/7.
- Цена и сроки железа оценочные; пользователь может стартовать с бюджетом ноль.
- Пример «городской mesh из смартфонов» не считается надёжным backbone.
## Что не делали
Не исполняли весь 30-дневный план; не проверяли по воздуху, не проводили аудит
безопасности. Этот документ — changelog решений, не сертификат готовности.
## v0.3 · Slint и минимальные зависимости
- GUI `eframe/egui` заменён на декларативный Slint; обновлены UI-модели и state-команды.
- Прямые внешние crates ограничены runtime `slint` и build-time `slint-build`.
- Rust domain crates изолированы и не используют сторонние пакеты.
- Проверка 250/4 не считает generated Cargo.lock / .gitignore, но считает `.slint`.
- Тесты добавлены отдельно; результаты `cargo test/fmt/clippy` — в [STATUS](../STATUS.md).
## v0.4 · Внутренний разбор симулятора и документации
Источник: самостоятельный разбор кода и доков 13.11.2026, не внешняя ревизия.
| Находка | Исправление |
| --- | --- |
| Крупный `tick` давал `Delivered` после обрыва маршрута | доставка требует живого маршрута; регрессионные тесты в `tests/city.rs` |
| Метка `Text` на 5 МБ шла по slow radio | класс выводится из размера (ADR-011) |
| Линк пропускал любую нагрузку параллельно | слоты эфира и очередь на ребре (ADR-012) |
| `seed` в доках, но не в коде | убран из доков; TODO снят; случайные отказы — отдельная задача |
| Store-and-forward отмечен готовым | галочка снята, оговорено в TODO и STATUS |
| Устаревшие утверждения, v0.2/egui, дублирование чисел | числа вынесены в [STATUS](../STATUS.md), остатки убраны |
| Нет git и лицензии | `git init`, LGPL-3.0-or-later (ADR-010) |
Не сделано: тела ADR-001…009, этап 0 с Reticulum, служебный трафик для H4.

12
docs/review/rf_notes.md Normal file
View file

@ -0,0 +1,12 @@
# Радиосвязь и физическая реальность
- LoRa дальнобойнее на малой скорости, но радиоканал разделяется соседями и
регулируется полосой/мощностью/duty cycle.
- Направленные Wi-Fi/микроволновые мосты позволяют высокий bitrate при прямой
видимости, правильной установке и соблюдении местных норм.
- Расстояние по RSSI не является надёжным измерением геопозиции.
- Провал маршрута нельзя исправить «умным алгоритмом», если нет физического пути.
- В первом GUI геометрия **иллюстративная**, а линк задаётся пользователем вручную.
Перед передачей в эфир проверить местные частоты, power/EIRP, duty cycle, DFS,
разрешения и условия для шифрованных данных. Пример региона не переносится на все страны.

35
docs/security/guard.md Normal file
View file

@ -0,0 +1,35 @@
# ICE Guard: маленькая предсказуемая защита
## До криптографии
В `icenet-guard` реализованы детерминированные локальные проверки:
1. Разрешён ли сервис (ACL).
2. Не превышен ли лимит размера payload.
3. Есть ли место в очереди (`queue_full`).
4. Replay window per peer по монотонному `sequence`.
5. Token bucket per peer (`rate_limited`, `0` отключает лимит).
6. Передан ли тестовый `authenticated` flag **(не реальное доказательство)**.
Проверка возвращает `Permit | Deny(reason)`. Отказ не расходует replay/rate state;
`sequence` фиксируется только после успешного `Permit`. Время передаёт вызывающий
код (`now_ms`), системные часы не читаются.
**Нельзя** считать `authenticated` защитой от подмены на реальной сети.
## После фиксации криптосхемы
- Проверка подписи/handshake + binding NodeID -> key.
- Replay window per sender/peer, ограничение памяти на окна и очереди.
- Rate limits per interface/per service/per peer.
- Неизвестные пути, ложные announce, Sybil, DoS, packet bombs.
- Автоматическое действие только: log, local drop, local rate-limit, local revoke.
## ICE Learning
Из MVP исключён. Возможно вернётся **после** накопления реальных логов и
оценки ложноположительных блокировок, как отдельное необязательное решение.
## Название
Не путать «ICE Guard» со стандартизированным IETF ICE (Interactive Connectivity Establishment).
Перед публичным релизом обсудить переименование внутреннего security crate.

18
docs/security/privacy.md Normal file
View file

@ -0,0 +1,18 @@
# Идентичность и приватность
Криптографический NodeID подтверждает владение ключом, **не личность человека**.
Список соседей и объявления о маршрутах могут раскрывать паттерны движения.
## Для дизайна
- Device identity отдельно от user identity (телефон + ПК — независимые ключи).
- Нужно заранее решить, разрешён ли общий «профиль» на нескольких устройствах.
- Защитить метаданные TTL, discovery frequency и route request patterns.
- У relay должен быть минимальный доступ к содержимому сообщений.
- Не хранить GPS/историю маршрутов по умолчанию без согласия владельца.
- Перед повторной отправкой с нарушенной связью не объявлять доставку.
## Не решено
Public-key derivation, key rotation, group membership, encrypted store-and-forward
и TTL-политика ещё не специфицированы. См. [вопросы](../review/questions.md).

View file

@ -0,0 +1,45 @@
# ICE-NET City Lab — интерактивный эмулятор города
## Назначение
Нативное окно Rust/Slint, где видны устройства и каналы связи.
Первый GUI не зависит от реальных IP-адресов и может работать **офлайн**.
## Возможности стартового каркаса
- Нарисовать карту/граф, добавлять устройства и связи, видеть названия и типы.
- Выбрать отправителя/получателя; отправить Text (малый) или Photo (Bulk).
- Выбрать роль нового узла (Client/Relay/Backbone) и тип линка; подсветить последний маршрут.
- Отключить/включить узел или ребро через боковую панель.
- Продвинуть симуляционное время вручную (Step), посмотреть Queued/Delivered/Expired.
- Изменить расположение устройств кликом/drag (проверено под X11/Xvfb).
- Посмотреть выбранный маршрут и базовый журнал доставки.
- Экспортировать `icenet-metrics.csv` и `icenet-scenario.json` кнопками в боковой панели.
## Не реализовано на старте
- Сценарии на 1000 узлов в GUI, загрузка сохранённого JSON обратно.
- Настоящее позиционирование по GPS/радиосигналу, физика Fresnel, beamforming.
- Моделирование interference, duty cycle, hidden terminals и настоящая передача файлов.
- Релеи через смартфоны и реальный интернет.
## Как использовать при разработке алгоритмов
1. Реализовать новый `choose_path` в `icenet-routing`.
2. Добавить тест в `crates/icenet-routing/tests/routing.rs`.
3. Запустить city lab; сравнить Text vs Bulk на одном графе.
4. Отключить быстрейшую связь; проверить корректный NO_ROUTE/QUEUED.
5. Зафиксировать seed/топологию в scenario и сравнить метрики.
**Критично:** рисовалка не должна выполнять маршрутизацию внутри `ui.update()`;
она передаёт запрос в `icenet-sim`, а рисует результат.
## Граница GUI (v0.3)
`ui/main.slint` показывает объекты из `VecModel`, фиксирует нажатия и drag.
`src/main.rs` регистрирует callback-обработчики, `src/state.rs` изменяет
`icenet-sim::City`, `src/view.rs` строит только визуальные модели.
Обработчик **не** рассчитывает маршруты сам; алгоритм остался в `icenet-routing`.
GUI на Slint собран и проверен под X11/Xvfb: узлы, линии, drag, переключение
устройств/линий и экспорт CSV/JSON. Полная проверка на Wayland-сессии — отдельный шаг.

View file

@ -0,0 +1,45 @@
# Simulation engine: contract
## Состояния сообщения
`Queued -> InFlight -> Delivered`; `InFlight -> Queued` при потере пригодного маршрута;
`Queued | InFlight -> Expired` по TTL. `Delivered` и `Expired` конечные.
- Есть `created_ms`, `expires_ms`, `first_route_ms`; `tick()` переводит просроченное сообщение в
`Expired` и больше не доставляет его.
- Прибытие в момент `due_ms <= expires_ms` — доставка, даже если один крупный шаг времени
перескочил оба дедлайна (`tests/ttl.rs`).
- **Ложный `Delivered` исключён.** Изменения топологии происходят между тиками, поэтому топология
в `tick` держалась весь интервал. Доставка требует, чтобы все узлы маршрута были online, каждый
линк включён, соединял нужные узлы и допускал класс. Иначе сообщение перепланируется или встаёт
в `Queued` (`tests/city.rs`).
## Ёмкость линка
- На каждом линке календарь слотов эфира. Hop занимает `transfer_ms(bytes) + HOP_OVERHEAD_MS`.
- Резервирование идёт по порядку отправки; следующий слот начинается не раньше конца предыдущего,
а освободившиеся промежутки могут быть заняты. `due_ms` включает ожидание в очереди.
- Перепланирование освобождает ещё не начатые слоты сообщения; уже начатый airtime считается
потраченным. Истёкшее или потерявшее путь сообщение тоже освобождает будущие слоты.
- Выбор пути **не** учитывает бэклог, а перепланирование начинает с источника — ограничения.
- Метрики: `City::link_airtime_ms(kind)`, `City::link_backlog_ms(index)`, `slow_radio_airtime_ms`.
## События будущей DES
Сейчас время идёт шагами `tick`; полноценной очереди событий нет. План:
| Event | Поля |
| --- | --- |
| `Announce` | node_id, iface, ttl |
| `LinkUp/LinkDown` | link_id, now_ms |
| `Send` | source, dest, bytes, traffic_class |
| `HopFinished` | message_id, hop_index |
| `Ack` | message_id, kind |
| `QueueExpire` | message_id, ttl |
## Детерминизм
- Одинаковые сценарий и последовательность действий дают одинаковый результат бит-в-бит
(случайности нет; **`seed` не реализован**).
- Ни один core алгоритм не вызывает `SystemTime` напрямую.
- GUI не ускоряет модель при изменении частоты кадров.

32
docs/simulator/metrics.md Normal file
View file

@ -0,0 +1,32 @@
# Метрики и честность моделирования
Цифры измерений — только в [STATUS](../STATUS.md).
## Минимальный набор
| Метрика | Смысл | Метод |
| --- | --- | --- |
| Delivery ratio | доставлено / создано | считать только `Delivered` |
| `first_route_ms` p50/p95 | **абсолютная** метка симулированного времени первого пути | не задержка: вычитания `created_ms` пока нет |
| Control airtime | эфир, занятый сообщениями класса Control по их маршрутам | сумма `transfer_ms + HOP_OVERHEAD_MS` по hop |
| `slow_radio_airtime_ms` | эфир, зарезервированный на slow radio всеми сообщениями | календарь слотов линков |
| Задержка поиска пути | реальное время CPU Dijkstra | `Instant` в `tests/scale.rs`, **debug**, не симуляция |
| RAM | реальная память процесса | procfs/OS вне симуляции; на 1000 узлов не измерено |
`icenet_sim::metrics` считает состояния, delivery ratio, перцентили и airtime.
`messages_csv` и `scenario_json` дают детерминированный экспорт.
## Условия воспроизводимости
- Источник кода/commit, дата, топология, link profile, последовательность действий.
- Отдельно записать версию Rust и OS. `seed` не нужен, пока в модели нет случайности.
- Минимум 3 сценария: пустой эфир, заполненный эфир, отключение backbone.
- Изменённые параметры должны сохраняться в сценарии, не в GUI state.
## Ограничения
Время доставки учитывает последовательность hop и очередь на линке, но **не** включает
коллизии, hidden terminals, duty cycle, retransmission, FEC, TCP congestion control, радиолокацию,
OS scheduling и стоимость crypto. Выбор пути не знает о бэклоге.
Нельзя из такого графа делать заявления «реальная сеть быстрее Reticulum».

View file

@ -0,0 +1,34 @@
# Сценарии для City Lab и регрессионных тестов
## S1 · LoRa discovery, Wi-Fi photo
- A — клиент, B — реле, C — друг.
- A–B: SlowRadio, A–C: FastWireless, B–C: SlowRadio.
- Text A→C может идти напрямую или через B по метрике.
- Photo A→C **только** fast link; при отключении A–C фото QUEUED.
## S2 · Городские две магистрали
- 12 узлов: 8 клиентов, 2 relay, 2 backbone.
- У каждой магистрали резервное беспроводное ребро.
- Bulk идёт по fast сегментам, контрольные объявления лимитируются на slow.
## S3 · Partition/merge
- Граф из двух районов, между ними 1 bridge.
- После отключения bridge новые сообщения `Queued`, не `Delivered`.
- При восстановлении моста очередь переходит к доставке.
## S4 · Злая нагрузка
- 100 текстовых сообщений + 1 фото 5 MiB при медленном LoRa.
- Проверить, что фото не блокирует канал discovery: `slow_radio_airtime_ms` не содержит фото.
- Очередь на slow-линке растёт, часть текстов может истечь по TTL (`tests/capacity/`).
- Метрики: control airtime, бэклог линка, p95 поиска. Квоты control пока не реализованы.
## S5 · Повторяемость
- Одинаковый начальный граф и последовательность действий → одинаковые результаты и CSV.
- Случайных отказов и `seed` пока нет; когда появятся, seed обязан входить в сценарий.
Не смешивать с реальными RF-измерениями. [Подробнее о метриках](metrics.md).

7
workspace/.gitignore vendored Normal file
View file

@ -0,0 +1,7 @@
/target/
**/*.rs.bk
*.log
.env
.DS_Store
.idea/
.vscode/

5424
workspace/Cargo.lock generated Normal file

File diff suppressed because it is too large Load diff

16
workspace/Cargo.toml Normal file
View file

@ -0,0 +1,16 @@
[workspace]
resolver = "3"
members = ["crates/*", "apps/*"]
default-members = ["crates/icenet-sim", "apps/icenetd"]
[workspace.package]
version = "0.0.1"
edition = "2024"
license = "LGPL-3.0-or-later"
[profile.dev]
debug = 1
[profile.release]
lto = "thin"
codegen-units = 1

32
workspace/README.md Normal file
View file

@ -0,0 +1,32 @@
# ICE-NET Rust workspace
Исследовательский каркас, а не работающий сетевой протокол. Два приложения:
`icenet-city` (GUI графового эмулятора на Slint) и `icenetd` (CLI: route/send/sim/policy/wire
и UDP `serve`/`send-udp`). Что проверено и какие цифры — в [../docs/STATUS.md](../docs/STATUS.md).
## Запуск на Arch
```bash
rustup default stable # toolchain закреплён в rust-toolchain.toml
cd workspace
python3 tools/check_layout.py
cargo test -p icenet-sim -p icenet-routing
cargo run -p icenet-city # нужна графическая сессия
```
## Карта зависимостей
`core` → `wire`, `guard`, `routing`, `transport` → `sdk` → `icenetd`
`core + routing` → `sim` → `icenet-city`, `icenetd`
`icenet-transport` содержит `MemoryTransport` (тесты) и неблокирующий `UdpTransport` на
`std::net`; loopback-тесты в `tests/udp.rs`.
Тесты **не** внутри `src`, а в `tests/` каждого крейта. Лицензия: LGPL-3.0-or-later (`../LICENSE`).
## Зависимости
Прямые внешние: `slint` (runtime) и `slint-build` (build-time) только в `icenet-city`;
остальные крейты без внешних библиотек. `cargo test --workspace` собирает и Slint; для быстрой
проверки алгоритмов выбирай конкретные пакеты. `Cargo.lock` коммитится.

View file

@ -0,0 +1,16 @@
[package]
name = "icenet-city"
version.workspace = true
edition.workspace = true
license.workspace = true
build = "build.rs"
[dependencies]
icenet-core = { path = "../../crates/icenet-core" }
icenet-sim = { path = "../../crates/icenet-sim" }
slint = { version = "=1.18.1", default-features = false, features = [
"std", "backend-winit", "renderer-software", "compat-1-18",
] }
[build-dependencies]
slint-build = "=1.18.1"

View file

@ -0,0 +1,6 @@
//! Compile the declarative interface without including GUI code in domain crates.
/// Compiles the Slint UI into generated Rust bindings.
fn main() {
slint_build::compile("ui/main.slint").expect("Slint UI compilation failed");
}

View file

@ -0,0 +1,5 @@
//! Slint application adapter for the deterministic ICE-NET city simulator.
pub mod state;
pub mod view;
slint::include_modules!();

View file

@ -0,0 +1,119 @@
//! Standalone Slint GUI for offline ICE-NET city routing experiments.
use icenet_city::{CityWindow, state::UiState, view};
use slint::{ComponentHandle, Weak};
use std::{cell::RefCell, rc::Rc};
/// Performs a state command and refreshes the window, if it still exists.
fn apply(weak: &Weak<CityWindow>, state: &Rc<RefCell<UiState>>, change: impl FnOnce(&mut UiState)) {
let mut state = state.borrow_mut();
change(&mut state);
if let Some(ui) = weak.upgrade() {
view::refresh(&ui, &state);
}
}
/// Registers UI callbacks without allowing the simulator to depend on Slint.
fn register_callbacks(ui: &CityWindow, state: Rc<RefCell<UiState>>) {
{
let state = state.clone();
let weak = ui.as_weak();
ui.on_send_text(move || apply(&weak, &state, |s| s.send(false)));
}
{
let state = state.clone();
let weak = ui.as_weak();
ui.on_send_photo(move || apply(&weak, &state, |s| s.send(true)));
}
{
let state = state.clone();
let weak = ui.as_weak();
ui.on_export_csv(move || apply(&weak, &state, UiState::export_default_csv));
}
{
let state = state.clone();
let weak = ui.as_weak();
ui.on_export_json(move || apply(&weak, &state, UiState::export_default_json));
}
{
let state = state.clone();
let weak = ui.as_weak();
ui.on_next_from(move || apply(&weak, &state, |s| s.cycle_endpoint(true)));
}
{
let state = state.clone();
let weak = ui.as_weak();
ui.on_next_to(move || apply(&weak, &state, |s| s.cycle_endpoint(false)));
}
{
let state = state.clone();
let weak = ui.as_weak();
ui.on_next_role(move || apply(&weak, &state, UiState::cycle_role));
}
{
let state = state.clone();
let weak = ui.as_weak();
ui.on_next_link_kind(move || apply(&weak, &state, UiState::cycle_link_kind));
}
{
let state = state.clone();
let weak = ui.as_weak();
ui.on_add_node(move || apply(&weak, &state, UiState::add_node));
}
{
let state = state.clone();
let weak = ui.as_weak();
ui.on_connect_nodes(move || apply(&weak, &state, UiState::connect));
}
{
let state = state.clone();
let weak = ui.as_weak();
ui.on_toggle_node(move |id| apply(&weak, &state, |s| s.toggle_node(id)));
}
{
let state = state.clone();
let weak = ui.as_weak();
ui.on_toggle_link(move |index| apply(&weak, &state, |s| s.toggle_link(index)));
}
{
let state = state.clone();
ui.on_drag_start(move |id, x, y| state.borrow_mut().start_drag(id, x, y));
}
{
let state = state.clone();
let weak = ui.as_weak();
ui.on_drag_move(move |x, y| {
let mut state = state.borrow_mut();
state.drag_to(x, y);
if let Some(ui) = weak.upgrade() {
view::drag(&ui, &state);
}
});
}
{
let state = state.clone();
let weak = ui.as_weak();
ui.on_drag_end(move || apply(&weak, &state, UiState::end_drag));
}
{
let state = state.clone();
let weak = ui.as_weak();
ui.on_advance(move |elapsed| {
apply(&weak, &state, |s| {
s.city.tick(u64::try_from(elapsed).unwrap_or(0));
})
});
}
{
let weak = ui.as_weak();
ui.on_reset_city(move || apply(&weak, &state, |s| *s = UiState::default()));
}
}
/// Starts the desktop simulator. The event loop is owned by Slint.
fn main() -> Result<(), slint::PlatformError> {
let ui = CityWindow::new()?;
let state = Rc::new(RefCell::new(UiState::default()));
view::refresh(&ui, &state.borrow());
register_callbacks(&ui, state);
ui.run()
}

View file

@ -0,0 +1,194 @@
//! GUI-independent commands applied to the city simulator.
use std::{io, path::Path};
use icenet_core::{LinkKind, NodeId, TrafficClass};
use icenet_sim::{City, DeviceRole, metrics};
const CSV_FILE: &str = "icenet-metrics.csv";
const JSON_FILE: &str = "icenet-scenario.json";
/// Grab state for stable pointer dragging of one node.
#[derive(Clone, Copy, Debug)]
pub struct Drag {
id: NodeId,
node_x: f32,
node_y: f32,
pointer_x: f32,
pointer_y: f32,
}
/// Mutable state of the standalone city editor.
#[derive(Debug)]
pub struct UiState {
/// Deterministic offline city graph.
pub city: City,
/// Current sender in the sample graph.
pub from: NodeId,
/// Current recipient in the sample graph.
pub to: NodeId,
/// New node role selected in the editor.
pub role: DeviceRole,
/// New link technology selected in the editor.
pub link_kind: LinkKind,
/// Human-readable result of the last export action.
pub last_export: String,
drag: Option<Drag>,
}
impl Default for UiState {
fn default() -> Self {
Self {
city: City::demo(),
from: NodeId(1),
to: NodeId(3),
role: DeviceRole::Client,
link_kind: LinkKind::FastWireless,
last_export: String::new(),
drag: None,
}
}
}
impl UiState {
/// Cycles through available sender or recipient IDs.
pub fn cycle_endpoint(&mut self, sender: bool) {
let current = if sender { self.from } else { self.to };
let ids: Vec<NodeId> = self.city.devices.iter().map(|d| d.id).collect();
if ids.is_empty() {
return;
}
let index = ids.iter().position(|id| *id == current).unwrap_or(0);
let next = ids[(index + 1) % ids.len()];
if sender {
self.from = next;
} else {
self.to = next;
}
}
/// Cycles among client, relay and backbone device roles.
pub fn cycle_role(&mut self) {
self.role = match self.role {
DeviceRole::Client => DeviceRole::Relay,
DeviceRole::Relay => DeviceRole::Backbone,
DeviceRole::Backbone => DeviceRole::Client,
};
}
/// Cycles among simulated radio, Wi-Fi, cable and internet links.
pub fn cycle_link_kind(&mut self) {
self.link_kind = match self.link_kind {
LinkKind::SlowRadio => LinkKind::FastWireless,
LinkKind::FastWireless => LinkKind::Wired,
LinkKind::Wired => LinkKind::Internet,
LinkKind::Internet => LinkKind::SlowRadio,
};
}
/// Adds a new device and selects it as recipient.
pub fn add_node(&mut self) {
let label = format!("New {:?} {}", self.role, self.city.devices.len() + 1);
self.to = self.city.add_device(label, self.role);
}
/// Adds a link between the selected endpoints, if valid.
pub fn connect(&mut self) {
self.city.add_link(self.from, self.to, self.link_kind);
}
/// Toggles a device's online state.
pub fn toggle_node(&mut self, id: i32) {
let update = self
.city
.devices
.iter()
.find(|d| d.id.0 == id as u64)
.map(|device| (device.id, !device.online));
if let Some((id, online)) = update {
self.city.set_device_online(id, online);
}
}
/// Toggles a link by its visible index.
pub fn toggle_link(&mut self, index: i32) {
if let Ok(index) = usize::try_from(index)
&& let Some(enabled) = self.city.links.get(index).map(|link| !link.enabled)
{
self.city.set_link_enabled(index, enabled);
}
}
/// Remembers the node and pointer position when a drag begins.
pub fn start_drag(&mut self, id: i32, pointer_x: f32, pointer_y: f32) {
let id = NodeId(id as u64);
if let Some(device) = self.city.devices.iter().find(|device| device.id == id) {
self.drag = Some(Drag {
id,
node_x: device.x,
node_y: device.y,
pointer_x,
pointer_y,
});
}
}
/// Moves the grabbed node by the pointer delta from the drag start.
pub fn drag_to(&mut self, pointer_x: f32, pointer_y: f32) {
if let Some(drag) = self.drag {
self.city.move_device(
drag.id,
(drag.node_x + pointer_x - drag.pointer_x).clamp(20.0, 520.0),
(drag.node_y + pointer_y - drag.pointer_y).clamp(20.0, 310.0),
);
}
}
/// Releases the current drag, if any.
pub fn end_drag(&mut self) {
self.drag = None;
}
/// Sends synthetic text or bulk data; no real bytes leave this process.
pub fn send(&mut self, bulk: bool) {
let (kind, size) = if bulk {
(TrafficClass::Bulk, 5 * 1024 * 1024)
} else {
(TrafficClass::Text, 128)
};
self.city.send(self.from, self.to, kind, size);
}
/// Writes deterministic message metrics to `path`.
///
/// # Errors
/// Returns the underlying I/O error when the file cannot be written.
pub fn export_csv(&mut self, path: &Path) -> io::Result<()> {
std::fs::write(path, metrics::messages_csv(&self.city))?;
self.last_export = format!("Exported {}", path.display());
Ok(())
}
/// Writes the full scenario to `path` as deterministic JSON.
///
/// # Errors
/// Returns the underlying I/O error when the file cannot be written.
pub fn export_json(&mut self, path: &Path) -> io::Result<()> {
std::fs::write(path, metrics::scenario_json(&self.city))?;
self.last_export = format!("Exported {}", path.display());
Ok(())
}
/// Writes `icenet-metrics.csv` in the process working directory.
pub fn export_default_csv(&mut self) {
if let Err(error) = self.export_csv(Path::new(CSV_FILE)) {
self.last_export = format!("Export failed: {error}");
}
}
/// Writes `icenet-scenario.json` in the process working directory.
pub fn export_default_json(&mut self) {
if let Err(error) = self.export_json(Path::new(JSON_FILE)) {
self.last_export = format!("Export failed: {error}");
}
}
}

View file

@ -0,0 +1,140 @@
//! Translate simulation state into Slint models without introducing UI into core crates.
use crate::{CityWindow, UiLink, UiNode, state::UiState};
use icenet_core::NodeId;
use icenet_sim::{City, DeliveryState};
use slint::{Color, Model, VecModel};
/// Updates node and link rows in place so an active drag is not interrupted.
pub fn drag(ui: &CityWindow, state: &UiState) {
if let Some(nodes) = ui.get_nodes().as_any().downcast_ref::<VecModel<UiNode>>() {
for (index, device) in state.city.devices.iter().enumerate() {
let Some(mut node) = nodes.row_data(index) else {
continue;
};
node.px = device.x;
node.py = device.y;
nodes.set_row_data(index, node);
}
}
if let Some(links) = ui.get_links().as_any().downcast_ref::<VecModel<UiLink>>() {
for (index, link) in state.city.links.iter().enumerate() {
let Some(mut row) = links.row_data(index) else {
continue;
};
let (Some(a), Some(b)) = (device(&state.city, link.a), device(&state.city, link.b))
else {
continue;
};
row.ax = a.x;
row.ay = a.y;
row.bx = b.x;
row.by = b.y;
links.set_row_data(index, row);
}
}
}
fn device(city: &City, id: NodeId) -> Option<&icenet_sim::Device> {
city.devices.iter().find(|device| device.id == id)
}
/// Applies one immutable simulator snapshot to the Slint window.
pub fn refresh(ui: &CityWindow, state: &UiState) {
let route = state
.city
.messages
.last()
.map(|m| m.route.as_slice())
.unwrap_or(&[]);
let nodes: Vec<UiNode> = state
.city
.devices
.iter()
.map(|device| UiNode {
id: device.id.0 as i32,
label: device.label.as_str().into(),
px: device.x,
py: device.y,
online: device.online,
})
.collect();
ui.set_nodes(VecModel::from_slice(&nodes));
let links: Vec<UiLink> = state
.city
.links
.iter()
.map(|link| {
let a = state.city.devices.iter().find(|d| d.id == link.a);
let b = state.city.devices.iter().find(|d| d.id == link.b);
let (ax, ay, bx, by) = match (a, b) {
(Some(a), Some(b)) => (a.x, a.y, b.x, b.y),
_ => (0.0, 0.0, 0.0, 0.0),
};
let enabled =
link.enabled && a.is_some_and(|n| n.online) && b.is_some_and(|n| n.online);
let highlighted = route
.windows(2)
.any(|hop| hop == [link.a, link.b] || hop == [link.b, link.a]);
UiLink {
ax,
ay,
bx,
by,
title: format!("{} — {} / {}", link.a.0, link.b.0, link.kind.label()).into(),
enabled,
highlighted,
color: if !enabled {
Color::from_rgb_u8(78, 88, 99)
} else {
link_color(link.kind.label())
},
}
})
.collect();
ui.set_links(VecModel::from_slice(&links));
let messages: Vec<slint::SharedString> = state
.city
.messages
.iter()
.rev()
.take(12)
.map(|message| {
let status = match message.status {
DeliveryState::Queued => "QUEUED",
DeliveryState::InFlight => "IN_FLIGHT",
DeliveryState::Delivered => "DELIVERED",
DeliveryState::Expired => "EXPIRED",
};
format!(
"#{} {} → {} | {:?} | {}",
message.id, message.from.0, message.to.0, message.class, status
)
.into()
})
.collect();
ui.set_messages(VecModel::from_slice(&messages));
ui.set_clock(format!("Virtual clock: {} ms", state.city.now_ms).into());
ui.set_from_label(endpoint_name(&state.city, state.from).into());
ui.set_to_label(endpoint_name(&state.city, state.to).into());
ui.set_role_label(format!("Role: {:?}", state.role).into());
ui.set_link_label(format!("New link: {}", state.link_kind.label()).into());
ui.set_export_status(state.last_export.as_str().into());
}
fn endpoint_name(city: &City, id: NodeId) -> String {
city.devices.iter().find(|n| n.id == id).map_or_else(
|| format!("#{:?}", id.0),
|n| format!("{} (#{})", n.label, id.0),
)
}
fn link_color(kind: &str) -> Color {
match kind {
"LoRa (slow)" => Color::from_rgb_u8(230, 177, 94),
"Wi-Fi (fast)" => Color::from_rgb_u8(89, 174, 250),
"Wired" => Color::from_rgb_u8(73, 222, 164),
_ => Color::from_rgb_u8(195, 145, 255),
}
}

View file

@ -0,0 +1,11 @@
use icenet_core::{NodeId, TrafficClass};
use icenet_sim::City;
#[test]
fn city_example_contains_bulk_eligible_route() {
let city = City::demo();
assert!(
city.route(NodeId(1), NodeId(3), TrafficClass::Bulk, 5_000_000)
.is_some()
);
}

View file

@ -0,0 +1,100 @@
//! Regression tests for UI commands with no graphical backend.
use icenet_city::state::UiState;
use icenet_core::{NodeId, TrafficClass};
use icenet_sim::DeliveryState;
#[test]
fn photo_avoids_slow_radio_after_fast_links_are_disabled() {
let mut app = UiState::default();
for index in [2, 3, 4, 5] {
app.city.set_link_enabled(index, false);
}
app.send(true);
assert_eq!(
app.city.messages.last().unwrap().status,
DeliveryState::Queued
);
assert!(
app.city
.route(NodeId(1), NodeId(3), TrafficClass::Text, 128)
.is_some()
);
}
#[test]
fn toggling_a_device_and_restarting_are_deterministic() {
let mut app = UiState::default();
app.toggle_node(2);
assert!(
!app.city
.devices
.iter()
.find(|d| d.id == NodeId(2))
.unwrap()
.online
);
app = UiState::default();
assert!(app.city.devices.iter().all(|d| d.online));
}
#[test]
fn editor_adds_a_link_and_cycles_endpoints() {
let mut app = UiState::default();
app.add_node();
assert_eq!(app.to, NodeId(7));
app.connect();
assert!(
app.city
.links
.iter()
.any(|link| link.a == NodeId(1) && link.b == NodeId(7))
);
}
#[test]
fn drag_uses_a_fixed_start_pointer_offset() {
let mut app = UiState::default();
app.start_drag(1, 409.0, 186.0);
app.drag_to(470.0, 240.0);
app.drag_to(530.0, 290.0);
let node = app
.city
.devices
.iter()
.find(|device| device.id == NodeId(1))
.expect("demo node");
assert!((node.x - 191.0).abs() < f32::EPSILON);
assert!((node.y - 189.0).abs() < f32::EPSILON);
app.end_drag();
app.drag_to(0.0, 0.0);
let node = app
.city
.devices
.iter()
.find(|device| device.id == NodeId(1))
.expect("demo node");
assert!((node.x - 191.0).abs() < f32::EPSILON);
}
#[test]
fn exports_csv_and_json_to_requested_paths() {
let mut app = UiState::default();
app.send(false);
let stamp = format!("icenet-test-{}", std::process::id());
let csv_path = std::env::temp_dir().join(format!("{stamp}.csv"));
let json_path = std::env::temp_dir().join(format!("{stamp}.json"));
app.export_csv(&csv_path).expect("csv export");
let csv = std::fs::read_to_string(&csv_path).expect("read csv");
assert!(csv.starts_with("id,from,to,class,bytes,status,"));
assert_eq!(csv.lines().count(), 2);
assert!(app.last_export.contains(&stamp));
app.export_json(&json_path).expect("json export");
let json = std::fs::read_to_string(&json_path).expect("read json");
assert!(json.contains("\"messages\""));
assert!(json.contains("\"devices\""));
std::fs::remove_file(csv_path).expect("cleanup csv");
std::fs::remove_file(json_path).expect("cleanup json");
}

View file

@ -0,0 +1,206 @@
// A desktop-only city topology editor; all networking logic stays in Rust crates.
import { Button, ScrollView } from "std-widgets.slint";
export struct UiNode {
id: int,
label: string,
px: float,
py: float,
online: bool,
}
export struct UiLink {
ax: float,
ay: float,
bx: float,
by: float,
title: string,
enabled: bool,
highlighted: bool,
color: color,
}
export component CityWindow inherits Window {
title: "ICE-NET City Lab | Slint";
preferred-width: 1140px;
preferred-height: 760px;
background: #0c131b;
in property <[UiNode]> nodes;
in property <[UiLink]> links;
in property <[string]> messages;
in property <string> clock;
in property <string> from-label;
in property <string> to-label;
in property <string> role-label;
in property <string> link-label;
in property <string> export-status;
callback send-text();
callback send-photo();
callback export-csv();
callback export-json();
callback next-from();
callback next-to();
callback next-role();
callback next-link-kind();
callback add-node();
callback connect-nodes();
callback toggle-node(int);
callback toggle-link(int);
callback drag-start(int, float, float);
callback drag-move(float, float);
callback drag-end();
callback advance(int);
callback reset-city();
HorizontalLayout {
padding: 16px;
spacing: 14px;
side := Rectangle {
width: 295px;
background: #172533;
border-radius: 12px;
VerticalLayout {
padding: 14px;
spacing: 9px;
Text { text: "ICE-NET / CITY LAB"; color: #6de0cb; font-size: 20px; font-weight: 700; }
Text { text: "Offline graph simulation • no real radio"; color: #adc0ce; font-size: 12px; }
Rectangle { height: 1px; background: #344557; }
Text { text: "ROUTE"; color: #6de0cb; font-size: 13px; font-weight: 700; }
Button { text: "From: " + root.from-label; clicked => { root.next-from(); } }
Button { text: "To: " + root.to-label; clicked => { root.next-to(); } }
HorizontalLayout {
spacing: 5px;
Button { text: "Text (128 B)"; clicked => { root.send-text(); } }
Button { text: "Photo (5 MiB)"; clicked => { root.send-photo(); } }
}
Rectangle { height: 1px; background: #344557; }
Text { text: "TOPOLOGY EDITOR"; color: #6de0cb; font-size: 13px; font-weight: 700; }
Button { text: root.role-label; clicked => { root.next-role(); } }
Button { text: "Add device"; clicked => { root.add-node(); } }
Button { text: root.link-label; clicked => { root.next-link-kind(); } }
Button { text: "Connect selected devices"; clicked => { root.connect-nodes(); } }
Text { text: "DEVICES (CLICK TO TOGGLE)"; color: #b5c9d5; font-size: 12px; }
ScrollView {
height: 92px;
VerticalLayout {
spacing: 3px;
for node in root.nodes: Button {
text: node.label + (node.online ? " [ON]" : " [OFF]");
clicked => { root.toggle-node(node.id); }
}
}
}
Text { text: "LINKS (CLICK TO TOGGLE)"; color: #b5c9d5; font-size: 12px; }
ScrollView {
height: 82px;
VerticalLayout {
spacing: 3px;
for edge[index] in root.links: Button {
text: edge.title + (edge.enabled ? " ON" : " OFF");
clicked => { root.toggle-link(index); }
}
}
}
Text { text: root.clock; color: #adc0ce; font-size: 12px; }
HorizontalLayout {
spacing: 5px;
Button { text: "+1 sec"; clicked => { root.advance(1000); } }
Button { text: "+1 min"; clicked => { root.advance(60000); } }
Button { text: "Reset"; clicked => { root.reset-city(); } }
}
HorizontalLayout {
spacing: 5px;
Button { text: "Export CSV"; clicked => { root.export-csv(); } }
Button { text: "Export JSON"; clicked => { root.export-json(); } }
}
Text { text: root.export-status; color: #6de0cb; font-size: 11px; }
}
}
content := Rectangle {
background: #17212e;
border-radius: 12px;
VerticalLayout {
padding: 16px;
spacing: 12px;
Text { text: "Network topology"; color: #e7f3f8; font-size: 21px; font-weight: 600; }
Text { text: "Drag nodes. Thick links show the last selected route."; color: #9cb2c6; }
graph := Rectangle {
height: 355px;
background: #101c29;
border-radius: 8px;
for edge in root.links: Path {
width: 100%;
height: 100%;
viewbox-x: 0;
viewbox-y: 0;
viewbox-width: parent.width / 1px;
viewbox-height: parent.height / 1px;
stroke: edge.highlighted ? #ffffff : edge.color;
stroke-width: edge.highlighted ? 4px : 2px;
MoveTo { x: edge.ax; y: edge.ay; }
LineTo { x: edge.bx; y: edge.by; }
}
for node in root.nodes: Rectangle {
x: (node.px - 17.0) * 1px;
y: (node.py - 17.0) * 1px;
width: 34px;
height: 34px;
border-radius: 17px;
background: node.online ? #235b66 : #35404c;
border-color: node.online ? #72d0e2 : #78808a;
border-width: 2px;
Text {
text: node.id;
color: #ffffff;
horizontal-alignment: center;
vertical-alignment: center;
font-size: 13px;
font-weight: 700;
}
TouchArea {
mouse-cursor: pointer;
pointer-event(event) => {
if (event.kind == PointerEventKind.down) {
root.drag-start(node.id,
(self.absolute-position.x + self.mouse-x) / 1px,
(self.absolute-position.y + self.mouse-y) / 1px);
} else if (event.kind == PointerEventKind.up) {
root.drag-end();
}
}
moved => {
if (self.pressed) {
root.drag-move(
(self.absolute-position.x + self.mouse-x) / 1px,
(self.absolute-position.y + self.mouse-y) / 1px);
}
}
}
}
}
Text { text: "Message log"; color: #e7f3f8; font-size: 17px; font-weight: 600; }
ScrollView {
VerticalLayout {
spacing: 6px;
for line in root.messages: Rectangle {
height: 28px;
background: #233242;
border-radius: 5px;
Text {
x: 9px;
text: line;
color: #d8e4ed;
vertical-alignment: center;
font-size: 12px;
}
}
}
}
Text { text: "Synthetic transmission estimates; not an RF model or a live network.";
color: #91aabd; font-size: 11px; }
}
}
}
}

View file

@ -0,0 +1,9 @@
[package]
name = "icenetd"
version.workspace = true
edition.workspace = true
license.workspace = true
[dependencies]
icenet-sdk = { path = "../../crates/icenet-sdk" }
icenet-sim = { path = "../../crates/icenet-sim" }

View file

@ -0,0 +1,148 @@
//! Minimal dependency-free option parser for the offline CLI.
use std::collections::{BTreeMap, BTreeSet};
const VALUE_OPTIONS: [&str; 25] = [
"from",
"to",
"class",
"size",
"ttl",
"ticks",
"disable",
"service",
"allow",
"max-size",
"text",
"hex",
"csv",
"json",
"peer",
"seq",
"now",
"queue",
"max-queue",
"rate",
"burst",
"window",
"bind",
"count",
"timeout",
];
const FLAGS: [&str; 3] = ["unauthenticated", "help", "version"];
/// Parsed command line: one command name plus value options and boolean flags.
#[derive(Debug)]
pub struct Args {
command: String,
options: BTreeMap<String, String>,
flags: BTreeSet<String>,
}
impl Args {
/// Parses arguments after the executable name.
///
/// # Errors
/// Returns a message for a missing command, an unknown option, or a
/// value option without a value.
pub fn parse(argv: impl IntoIterator<Item = String>) -> Result<Self, String> {
let mut iter = argv.into_iter();
let Some(command) = iter.next() else {
return Err("missing command; try `help`".to_owned());
};
let mut options = BTreeMap::new();
let mut flags = BTreeSet::new();
while let Some(token) = iter.next() {
let Some(name) = token.strip_prefix("--") else {
return Err(format!("unexpected argument `{token}`"));
};
if name.is_empty() {
return Err("empty option name".to_owned());
}
if FLAGS.contains(&name) {
flags.insert(name.to_owned());
continue;
}
let Some(value) = iter.next() else {
return Err(format!("option `--{name}` needs a value"));
};
if options.insert(name.to_owned(), value).is_some() {
return Err(format!("option `--{name}` was supplied more than once"));
}
}
for name in options.keys().chain(flags.iter()) {
if !VALUE_OPTIONS.contains(&name.as_str()) && !FLAGS.contains(&name.as_str()) {
return Err(format!("unknown option `--{name}`"));
}
}
Ok(Self {
command,
options,
flags,
})
}
/// Returns the command name.
pub fn command(&self) -> &str {
&self.command
}
/// Returns an option value, if present.
pub fn value(&self, name: &str) -> Option<&str> {
self.options.get(name).map(String::as_str)
}
/// Returns whether a boolean flag was supplied.
pub fn flag(&self, name: &str) -> bool {
self.flags.contains(name)
}
/// Rejects options and flags that the current command does not implement.
///
/// # Errors
/// Returns a message naming the first unsupported option.
pub fn only(&self, allowed: &[&str]) -> Result<(), String> {
for name in self.options.keys() {
if !allowed.contains(&name.as_str()) {
return Err(format!(
"option `--{name}` is not supported by `{}`",
self.command
));
}
}
for name in &self.flags {
if name != "help" && name != "version" && !allowed.contains(&name.as_str()) {
return Err(format!(
"option `--{name}` is not supported by `{}`",
self.command
));
}
}
Ok(())
}
/// Reads a required unsigned integer option.
///
/// # Errors
/// Returns a message when the option is absent or not an integer.
pub fn u64(&self, name: &str) -> Result<u64, String> {
let value = self
.value(name)
.ok_or_else(|| format!("option `--{name}` is required"))?;
value
.parse()
.map_err(|_| format!("`--{name}` must be an unsigned integer, got `{value}`"))
}
/// Reads an optional unsigned integer option or returns `default`.
///
/// # Errors
/// Returns a message when the supplied value is not an integer.
pub fn u64_or(&self, name: &str, default: u64) -> Result<u64, String> {
match self.value(name) {
Some(value) => value
.parse()
.map_err(|_| format!("`--{name}` must be an unsigned integer, got `{value}`")),
None => Ok(default),
}
}
}

View file

@ -0,0 +1,178 @@
//! Offline command implementations; no sockets, GUI or cryptography are used.
use icenet_sdk::{NodeId, TrafficClass};
use icenet_sim::{City, DeliveryState, metrics};
use crate::args::Args;
mod policy;
mod udp;
mod wire;
/// A CLI failure with a usage/runtime distinction for exit codes.
#[derive(Debug)]
pub enum CommandError {
/// The caller supplied invalid arguments.
Usage(String),
/// A valid request failed at runtime.
Runtime(String),
}
impl From<String> for CommandError {
fn from(message: String) -> Self {
Self::Usage(message)
}
}
/// Runs one subcommand.
///
/// # Errors
/// Returns a usage or runtime failure with a human-readable message.
pub fn run(args: &Args) -> Result<(), CommandError> {
match args.command() {
"route" => route(args),
"send" => send(args),
"sim" => sim(args),
"policy" => policy::run(args),
"send-udp" => udp::send(args),
"serve" => udp::serve(args),
"wire-encode" => wire::encode(args),
"wire-decode" => wire::decode(args),
other => Err(CommandError::Usage(format!(
"unknown command `{other}`; try `help`"
))),
}
}
fn route(args: &Args) -> Result<(), CommandError> {
args.only(&["from", "to", "class", "size", "disable"])?;
let city = demo_city(args)?;
let class = class(args)?;
let size = args.u64_or("size", 128)?;
let from = NodeId(args.u64("from")?);
let to = NodeId(args.u64("to")?);
match city.route(from, to, class, size) {
Some(path) => {
println!("route: {}", join_nodes(&path.nodes));
println!("estimated_ms: {}", path.estimated_ms);
}
None => println!("route: NO_ROUTE"),
}
Ok(())
}
fn send(args: &Args) -> Result<(), CommandError> {
args.only(&["from", "to", "class", "size", "disable", "ttl", "ticks"])?;
let mut city = demo_city(args)?;
let class = class(args)?;
let size = args.u64_or("size", 128)?;
let ttl = args.u64_or("ttl", City::DEFAULT_TTL_MS)?;
if ttl == 0 {
return Err(CommandError::Usage(
"`--ttl` must be at least 1 millisecond".to_owned(),
));
}
let ticks = args.u64_or("ticks", 0)?;
let from = NodeId(args.u64("from")?);
let to = NodeId(args.u64("to")?);
let id = city.send_with_ttl(from, to, class, size, ttl);
city.tick(ticks);
let message = city
.messages
.iter()
.find(|message| message.id == id)
.ok_or_else(|| CommandError::Runtime("message was not recorded".to_owned()))?;
println!(
"message: id={} status={:?} class={:?} bytes={} created_ms={} expires_ms={} \
first_route_ms={:?} due_ms={:?} route={}",
message.id,
message.status,
message.class,
message.bytes,
message.created_ms,
message.expires_ms,
message.first_route_ms,
message.due_ms,
join_nodes(&message.route)
);
if message.status == DeliveryState::Queued {
println!("hint: QUEUED means no eligible path, not delivered");
}
Ok(())
}
fn sim(args: &Args) -> Result<(), CommandError> {
args.only(&["csv", "json"])?;
let mut city = City::demo();
set_link(&mut city, 2, false)?;
city.send_with_ttl(NodeId(1), NodeId(3), TrafficClass::Bulk, 5_000_000, 1_000);
city.send(NodeId(1), NodeId(3), TrafficClass::Text, 128);
city.tick(1_000);
set_link(&mut city, 2, true)?;
city.tick(120_000);
let summary = metrics::summarize(&city);
println!(
"created={} delivered={} in_flight={} queued={} expired={} \
delivery_ratio={:.2} first_route_p50_ms={:?} first_route_p95_ms={:?} control_airtime_ms={}",
summary.created,
summary.delivered,
summary.in_flight,
summary.queued,
summary.expired,
summary.delivery_ratio(),
summary.first_route_p50_ms,
summary.first_route_p95_ms,
summary.control_airtime_ms
);
if let Some(path) = args.value("csv") {
std::fs::write(path, metrics::messages_csv(&city))
.map_err(|error| CommandError::Runtime(format!("cannot write `{path}`: {error}")))?;
println!("csv: {path}");
}
if let Some(path) = args.value("json") {
std::fs::write(path, metrics::scenario_json(&city))
.map_err(|error| CommandError::Runtime(format!("cannot write `{path}`: {error}")))?;
println!("json: {path}");
}
Ok(())
}
pub(crate) fn class(args: &Args) -> Result<TrafficClass, String> {
match args.value("class").unwrap_or("text") {
"control" => Ok(TrafficClass::Control),
"text" => Ok(TrafficClass::Text),
"bulk" => Ok(TrafficClass::Bulk),
other => Err(format!("unknown class `{other}`; use control|text|bulk")),
}
}
pub(crate) fn join_nodes(nodes: &[NodeId]) -> String {
if nodes.is_empty() {
return "NO_ROUTE".to_owned();
}
nodes
.iter()
.map(|node| node.0.to_string())
.collect::<Vec<_>>()
.join("-")
}
fn demo_city(args: &Args) -> Result<City, String> {
let mut city = City::demo();
if let Some(list) = args.value("disable") {
for part in list.split(',') {
let index = part
.trim()
.parse::<usize>()
.map_err(|_| format!("invalid link index `{part}`"))?;
set_link(&mut city, index, false)?;
}
}
Ok(city)
}
fn set_link(city: &mut City, index: usize, enabled: bool) -> Result<(), String> {
city.set_link_enabled(index, enabled)
.then_some(())
.ok_or_else(|| format!("no link with index {index}"))
}

View file

@ -0,0 +1,67 @@
//! Local Guard policy command.
use icenet_sdk::{Context, Guard, Limits, NodeId, ServiceId, Verdict};
use super::CommandError;
use crate::args::Args;
/// Evaluates one local admission request and prints the verdict.
pub fn run(args: &Args) -> Result<(), CommandError> {
args.only(&[
"service",
"size",
"allow",
"max-size",
"unauthenticated",
"peer",
"seq",
"now",
"queue",
"max-queue",
"rate",
"burst",
"window",
])?;
let service = ServiceId(args.u64("service")?);
let payload_bytes = to_usize(args.u64_or("size", 0)?, "--size")?;
let limits = Limits {
max_payload_bytes: to_usize(args.u64_or("max-size", 4_096)?, "--max-size")?,
max_queue_depth: to_usize(args.u64_or("max-queue", 64)?, "--max-queue")?,
rate_per_second: args.u64_or("rate", 20)?,
burst: args.u64_or("burst", 10)?,
replay_window: args.u64_or("window", 64)?,
};
let allowed = match args.value("allow") {
Some(list) => parse_services(list)?,
None => vec![service],
};
let mut guard = Guard::new(allowed, limits);
let context = Context {
authenticated: !args.flag("unauthenticated"),
peer: NodeId(args.u64_or("peer", 1)?),
service,
payload_bytes,
sequence: args.u64_or("seq", 1)?,
now_ms: args.u64_or("now", 0)?,
queue_depth: to_usize(args.u64_or("queue", 0)?, "--queue")?,
};
match guard.check(context) {
Verdict::Permit => println!("Permit"),
Verdict::Deny(reason) => println!("Deny({reason})"),
}
Ok(())
}
fn to_usize(value: u64, name: &str) -> Result<usize, String> {
usize::try_from(value).map_err(|_| format!("`{name}` is too large for this machine"))
}
fn parse_services(list: &str) -> Result<Vec<ServiceId>, String> {
list.split(',')
.map(|part| {
part.trim()
.parse::<u64>()
.map(ServiceId)
.map_err(|_| format!("invalid service id `{part}`"))
})
.collect()
}

View file

@ -0,0 +1,135 @@
//! Real UDP frame exchange for local process-to-process experiments.
use std::io::{self, Write as _};
use std::net::SocketAddr;
use std::time::{Duration, Instant};
use icenet_sdk::{Frame, ServiceId, Transport, UdpTransport, decode, encode};
use super::wire::hex_encode;
use super::{CommandError, class};
use crate::args::Args;
/// Encodes one frame and sends it to `--to`.
pub fn send(args: &Args) -> Result<(), CommandError> {
args.only(&["to", "service", "class", "text"])?;
let peer = address(required(args, "to")?)?;
let service = ServiceId(args.u64("service")?);
let class = class(args)?;
let text = args.value("text").unwrap_or("");
let frame = Frame {
class,
service,
payload: text.as_bytes().to_vec(),
};
let bytes = encode(&frame)
.map_err(|error| CommandError::Runtime(format!("encode failed: {error:?}")))?;
let transport = UdpTransport::bind("0.0.0.0:0")
.map_err(|error| CommandError::Runtime(format!("bind failed: {error}")))?;
let mut transport = transport
.connect(peer)
.map_err(|error| CommandError::Runtime(format!("connect failed: {error}")))?;
transport
.send(bytes)
.map_err(|error| CommandError::Runtime(format!("send failed: {error:?}")))?;
println!("sent: {} bytes to {peer}", frame.payload.len());
Ok(())
}
/// Receives frames until `--count` is reached or `--timeout` elapses.
pub fn serve(args: &Args) -> Result<(), CommandError> {
args.only(&["bind", "count", "timeout"])?;
let bind = address(required(args, "bind")?)?;
let count = optional_count(args)?;
let timeout = optional_timeout(args)?;
let transport = UdpTransport::bind(bind)
.map_err(|error| CommandError::Runtime(format!("bind failed: {error}")))?;
let mut transport = transport;
let local = transport
.local_addr()
.map_err(|error| CommandError::Runtime(format!("local address failed: {error}")))?;
println!("listening: {local}");
flush()?;
let deadline = timeout.map(|duration| Instant::now() + duration);
let mut received = 0_usize;
loop {
if let Some(bytes) = transport
.recv()
.map_err(|error| CommandError::Runtime(format!("recv failed: {error:?}")))?
{
match decode(&bytes) {
Ok(frame) => {
received = received.saturating_add(1);
println!(
"frame: service={} class={:?} bytes={} payload={}",
frame.service.0,
frame.class,
frame.payload.len(),
printable(&frame.payload)
);
flush()?;
if count.is_some_and(|limit| received >= limit) {
return Ok(());
}
}
Err(error) => {
println!("malformed: {error:?}");
flush()?;
}
}
}
if deadline.is_some_and(|limit| Instant::now() >= limit) {
let millis = timeout.unwrap_or_default().as_millis();
return Err(CommandError::Runtime(format!(
"timeout after {millis} ms waiting for frames"
)));
}
std::thread::sleep(Duration::from_millis(5));
}
}
fn required<'a>(args: &'a Args, name: &str) -> Result<&'a str, CommandError> {
args.value(name)
.ok_or_else(|| CommandError::Usage(format!("option `--{name}` is required")))
}
fn address(value: &str) -> Result<SocketAddr, String> {
value
.parse()
.map_err(|_| format!("invalid socket address `{value}`; expected IP:PORT"))
}
fn optional_count(args: &Args) -> Result<Option<usize>, String> {
if args.value("count").is_none() {
return Ok(None);
}
let count = usize::try_from(args.u64("count")?).map_err(|_| "`--count` is too large")?;
if count == 0 {
return Err("`--count` must be at least 1".to_owned());
}
Ok(Some(count))
}
fn optional_timeout(args: &Args) -> Result<Option<Duration>, String> {
if args.value("timeout").is_none() {
return Ok(None);
}
let millis = args.u64("timeout")?;
if millis == 0 {
return Err("`--timeout` must be at least 1 millisecond".to_owned());
}
Ok(Some(Duration::from_millis(millis)))
}
fn printable(payload: &[u8]) -> String {
match std::str::from_utf8(payload) {
Ok(text) if !text.chars().any(char::is_control) => text.to_owned(),
_ => format!("0x{}", hex_encode(payload)),
}
}
fn flush() -> Result<(), CommandError> {
io::stdout()
.flush()
.map_err(|error| CommandError::Runtime(format!("stdout flush failed: {error}")))
}

View file

@ -0,0 +1,64 @@
//! Draft frame encoding and decoding commands.
use std::fmt::Write as _;
use icenet_sdk::{Frame, ServiceId, decode as decode_frame, encode as encode_frame};
use super::{CommandError, class};
use crate::args::Args;
/// Encodes a draft frame and prints its hex bytes.
pub fn encode(args: &Args) -> Result<(), CommandError> {
args.only(&["service", "class", "text"])?;
let service = ServiceId(args.u64("service")?);
let class = class(args)?;
let text = args.value("text").unwrap_or("");
let frame = Frame {
class,
service,
payload: text.as_bytes().to_vec(),
};
let bytes = encode_frame(&frame).map_err(|error| format!("encode failed: {error:?}"))?;
println!("frame: {}", hex_encode(&bytes));
Ok(())
}
/// Decodes a draft frame from hex and prints its fields.
pub fn decode(args: &Args) -> Result<(), CommandError> {
args.only(&["hex"])?;
let hex = args
.value("hex")
.ok_or_else(|| CommandError::Usage("option `--hex` is required".to_owned()))?;
let bytes = hex_decode(hex)?;
let frame = decode_frame(&bytes).map_err(|error| format!("decode failed: {error:?}"))?;
println!("service: {}", frame.service.0);
println!("class: {:?}", frame.class);
println!("payload_bytes: {}", frame.payload.len());
match std::str::from_utf8(&frame.payload) {
Ok(text) if !text.chars().any(char::is_control) => println!("payload: {text}"),
_ => println!("payload_hex: {}", hex_encode(&frame.payload)),
}
Ok(())
}
pub(super) fn hex_encode(bytes: &[u8]) -> String {
let mut out = String::with_capacity(bytes.len() * 2);
for byte in bytes {
write!(out, "{byte:02x}").expect("writing into a String cannot fail");
}
out
}
fn hex_decode(text: &str) -> Result<Vec<u8>, String> {
let clean = text.trim();
if !clean.len().is_multiple_of(2) {
return Err("hex input must have an even number of digits".to_owned());
}
let mut out = Vec::with_capacity(clean.len() / 2);
for index in (0..clean.len()).step_by(2) {
let pair = clean
.get(index..index + 2)
.ok_or_else(|| format!("invalid hex at byte {index}"))?;
out.push(u8::from_str_radix(pair, 16).map_err(|_| format!("invalid hex pair `{pair}`"))?);
}
Ok(out)
}

View file

@ -0,0 +1,63 @@
//! Usage text for the offline CLI.
/// Prints the command reference.
pub fn print() {
println!("{USAGE}");
}
const USAGE: &str = "\
icenetd — offline ICE-NET lab (no sockets, no GUI, no cryptography)
USAGE:
icenetd <command> [options]
COMMANDS:
route Find a policy-eligible path in the demo topology
send Create one message, advance time, print its state
sim Run the deterministic demo scenario and export metrics
policy Evaluate the local Guard policy (ACL/size/queue/replay/rate)
send-udp Encode one frame and send it over UDP
serve Receive draft frames over UDP and print them
wire-encode Encode a draft frame and print its hex bytes
wire-decode Parse a draft frame from hex bytes
version Print the binary version
help Print this text
OPTIONS:
--from N --to N node IDs for route/send (default none)
--class C control | text | bulk (default text)
--size N payload bytes (default 128; policy default 0)
--ttl MS message lifetime, at least 1 (default 86400000)
--ticks MS simulated time to advance after send
--disable I,J disable demo link indexes before routing
--service N service ID for policy/wire commands
--allow I,J allowed service IDs (default: requested service)
--max-size N guard payload cap (default 4096)
--unauthenticated simulate an unauthenticated caller
--peer N --seq N guard sender identity and replay sequence
--now MS guard monotonic time for rate limiting
--queue N --max-queue N current and maximum guard queue depth
--rate N --burst N guard sustained rate and burst (rate 0 disables;
burst 0 with rate > 0 blocks all traffic)
--window N guard replay window size (default 64)
--text TEXT frame payload for wire-encode
--hex HEX frame bytes for wire-decode
--to IP:PORT UDP peer for send-udp
--bind IP:PORT local UDP address for serve (port 0 = auto)
--count N serve: exit after N valid frames
--timeout MS serve: exit with code 1 after this idle time
--csv PATH --json PATH exports for the sim command
--help print this text
EXAMPLES:
icenetd route --from 1 --to 3 --class bulk --size 5000000
icenetd route --from 1 --to 3 --class bulk --size 5000000 --disable 2,3,4
icenetd send --from 1 --to 3 --class text --size 128 --ticks 1000
icenetd sim --csv metrics.csv --json scenario.json
icenetd policy --service 77777 --size 5 --allow 1
icenetd wire-encode --service 7 --class text --text hello
icenetd serve --bind 127.0.0.1:9000 --count 1 --timeout 5000
icenetd send-udp --to 127.0.0.1:9000 --service 7 --class text --text hello
Reminder: the simulator is not an RF model and this CLI has no authentication.
";

View file

@ -0,0 +1,88 @@
//! Offline command-line lab for the ICE-NET core crates.
//!
//! Besides offline route/send/sim/policy/wire commands it offers plain UDP
//! `serve`/`send-udp`; there is no GUI, cryptography or daemon loop yet.
use std::ffi::OsString;
use std::process::ExitCode;
mod args;
mod commands;
mod help;
use args::Args;
use commands::CommandError;
/// Classifies CLI failures so usage mistakes exit with code 2.
enum Failure {
Usage(String),
Runtime(String),
}
fn main() -> ExitCode {
let argv = match utf8_arguments(std::env::args_os().skip(1)) {
Ok(argv) => argv,
Err(message) => return exit(Failure::Usage(message)),
};
match dispatch(argv) {
Ok(()) => ExitCode::SUCCESS,
Err(failure) => exit(failure),
}
}
fn exit(failure: Failure) -> ExitCode {
match failure {
Failure::Usage(message) => {
eprintln!("error: {message}");
eprintln!();
help::print();
ExitCode::from(2)
}
Failure::Runtime(message) => {
eprintln!("error: {message}");
ExitCode::from(1)
}
}
}
fn utf8_arguments(args: impl Iterator<Item = OsString>) -> Result<Vec<String>, String> {
args.map(|arg| {
arg.into_string()
.map_err(|_| "command-line arguments must be valid UTF-8".to_owned())
})
.collect()
}
fn dispatch(argv: Vec<String>) -> Result<(), Failure> {
if argv.is_empty() {
help::print();
return Ok(());
}
match argv[0].as_str() {
"--help" | "-h" => {
help::print();
return Ok(());
}
"--version" => {
print_version();
return Ok(());
}
_ => {}
}
let args = Args::parse(argv).map_err(Failure::Usage)?;
if args.flag("help") || args.command() == "help" {
help::print();
return Ok(());
}
if args.flag("version") || args.command() == "version" {
print_version();
return Ok(());
}
commands::run(&args).map_err(|error| match error {
CommandError::Usage(message) => Failure::Usage(message),
CommandError::Runtime(message) => Failure::Runtime(message),
})
}
fn print_version() {
println!("icenetd {}", env!("CARGO_PKG_VERSION"));
}

View file

@ -0,0 +1,156 @@
//! End-to-end route/send/sim/wire tests against the real `icenetd` binary.
mod common;
use common::{run, stderr, stdout, temp};
#[test]
fn help_lists_all_commands() {
let output = run(&["help"]);
assert!(output.status.success());
let text = stdout(&output);
for command in [
"route",
"send",
"sim",
"policy",
"wire-encode",
"wire-decode",
] {
assert!(text.contains(command), "missing {command} in help");
}
}
#[test]
fn bulk_route_avoids_slow_radio() {
let output = run(&[
"route", "--from", "1", "--to", "3", "--class", "bulk", "--size", "5000000",
]);
assert!(output.status.success(), "stderr: {}", stderr(&output));
assert!(stdout(&output).contains("1-4-5-3"));
}
#[test]
fn bulk_route_reports_no_route_without_fast_links() {
let output = run(&[
"route",
"--from",
"1",
"--to",
"3",
"--class",
"bulk",
"--size",
"5000000",
"--disable",
"2,3,4",
]);
assert!(output.status.success());
assert!(stdout(&output).contains("NO_ROUTE"));
}
#[test]
fn text_route_may_use_slow_radio() {
let output = run(&[
"route",
"--from",
"1",
"--to",
"3",
"--class",
"text",
"--size",
"128",
"--disable",
"2,3,4",
]);
assert!(output.status.success());
assert!(stdout(&output).contains("1-2-3"));
}
#[test]
fn send_reports_delivered_message() {
let output = run(&[
"send", "--from", "1", "--to", "3", "--class", "text", "--size", "128", "--ticks", "1000",
]);
assert!(output.status.success());
assert!(stdout(&output).contains("status=Delivered"));
}
#[test]
fn send_reports_expired_message() {
let output = run(&[
"send",
"--from",
"1",
"--to",
"3",
"--class",
"bulk",
"--size",
"5000000",
"--disable",
"2,3,4",
"--ttl",
"1000",
"--ticks",
"2000",
]);
assert!(output.status.success(), "stderr: {}", stderr(&output));
assert!(stdout(&output).contains("status=Expired"));
}
#[test]
fn sim_writes_csv_and_json_exports() {
let csv = temp("metrics.csv");
let json = temp("scenario.json");
let output = run(&[
"sim",
"--csv",
csv.to_str().expect("utf8 path"),
"--json",
json.to_str().expect("utf8 path"),
]);
assert!(output.status.success(), "stderr: {}", stderr(&output));
assert!(stdout(&output).contains("expired=1"));
let csv_body = std::fs::read_to_string(&csv).expect("csv export");
assert!(csv_body.starts_with("id,from,to,class,bytes,status,"));
let json_body = std::fs::read_to_string(&json).expect("json export");
assert!(json_body.contains("\"messages\""));
let _ = std::fs::remove_file(csv);
let _ = std::fs::remove_file(json);
}
#[test]
fn wire_encoder_and_decoder_round_trip() {
let encoded = run(&[
"wire-encode",
"--service",
"7",
"--class",
"text",
"--text",
"hello",
]);
assert!(encoded.status.success(), "stderr: {}", stderr(&encoded));
let text = stdout(&encoded);
let hex = text
.lines()
.find_map(|line| line.strip_prefix("frame: "))
.expect("frame hex line")
.to_owned();
let decoded = run(&["wire-decode", "--hex", &hex]);
assert!(decoded.status.success(), "stderr: {}", stderr(&decoded));
let text = stdout(&decoded);
assert!(text.contains("class: Text"));
assert!(text.contains("service: 7"));
assert!(text.contains("payload: hello"));
}
#[test]
fn wire_decode_escapes_control_bytes() {
let output = run(&["wire-decode", "--hex", "494e0101000000000000000700020102"]);
assert!(output.status.success(), "stderr: {}", stderr(&output));
let text = stdout(&output);
assert!(text.contains("payload_hex: 0102"));
assert!(!text.contains('\u{1}'));
}

View file

@ -0,0 +1,23 @@
//! Shared helpers for CLI integration tests.
#![allow(dead_code)]
use std::path::PathBuf;
use std::process::{Command, Output};
pub fn run(args: &[&str]) -> Output {
Command::new(env!("CARGO_BIN_EXE_icenetd"))
.args(args)
.output()
.expect("icenetd must start")
}
pub fn stdout(output: &Output) -> String {
String::from_utf8_lossy(&output.stdout).into_owned()
}
pub fn stderr(output: &Output) -> String {
String::from_utf8_lossy(&output.stderr).into_owned()
}
pub fn temp(name: &str) -> PathBuf {
std::env::temp_dir().join(format!("icenetd-{}-{name}", std::process::id()))
}

View file

@ -0,0 +1,104 @@
//! Policy, usage and exit-code tests against the real `icenetd` binary.
mod common;
use common::{run, stderr, stdout};
#[test]
fn policy_reports_acl_and_authentication_reasons() {
let permit = run(&["policy", "--service", "77777", "--size", "5"]);
assert!(permit.status.success());
assert!(stdout(&permit).contains("Permit"));
let denied = run(&[
"policy",
"--service",
"77777",
"--size",
"5",
"--allow",
"1",
]);
assert!(denied.status.success());
assert!(stdout(&denied).contains("service_denied"));
let anonymous = run(&[
"policy",
"--service",
"77777",
"--size",
"5",
"--unauthenticated",
]);
assert!(anonymous.status.success());
assert!(stdout(&anonymous).contains("unauthenticated"));
}
#[test]
fn policy_reports_rate_and_queue_reasons() {
let queue = run(&[
"policy",
"--service",
"77777",
"--size",
"5",
"--queue",
"2",
"--max-queue",
"2",
]);
assert!(queue.status.success());
assert!(stdout(&queue).contains("queue_full"));
let rate = run(&[
"policy",
"--service",
"77777",
"--size",
"5",
"--rate",
"1",
"--burst",
"0",
]);
assert!(rate.status.success());
assert!(stdout(&rate).contains("rate_limited"));
}
#[test]
fn help_and_version_flags_work_without_a_command() {
let help = run(&["--help"]);
assert!(help.status.success());
assert!(stdout(&help).contains("USAGE"));
let version = run(&["--version"]);
assert!(version.status.success());
assert!(stdout(&version).contains("icenetd"));
}
#[test]
fn invalid_values_are_usage_errors_with_exit_two() {
let cases: Vec<Vec<&str>> = vec![
vec!["route", "--from", "1"],
vec!["route", "--from", "1", "--to", "3", "--class", "Bulk"],
vec!["route", "--from", "1", "--to", "3", "--disable", "99"],
vec!["route", "--from", "1", "--to", "3", "--csv", "x.csv"],
vec!["send", "--from", "1", "--to", "3", "--ttl", "0"],
vec!["sim", "--disable", "0"],
vec!["route", "--from", "1", "--from", "3", "--to", "2"],
];
for case in cases {
let output = run(&case);
assert_eq!(
output.status.code(),
Some(2),
"case {case:?} stderr: {}",
stderr(&output)
);
}
}
#[test]
fn unknown_option_is_a_usage_error() {
let output = run(&["route", "--bogus", "1"]);
assert_eq!(output.status.code(), Some(2));
assert!(stderr(&output).contains("unknown option"));
}

View file

@ -0,0 +1,75 @@
//! Process-to-process UDP tests for `icenetd send-udp` and `icenetd serve`.
mod common;
use std::io::{BufRead, BufReader, Read};
use std::process::{Command, Stdio};
use common::{run, stderr, stdout};
#[test]
fn serve_and_send_udp_exchange_a_frame() {
let mut server = Command::new(env!("CARGO_BIN_EXE_icenetd"))
.args([
"serve",
"--bind",
"127.0.0.1:0",
"--count",
"1",
"--timeout",
"5000",
])
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.spawn()
.expect("serve starts");
let stdout_pipe = server.stdout.take().expect("server stdout");
let mut reader = BufReader::new(stdout_pipe);
let mut first_line = String::new();
reader.read_line(&mut first_line).expect("listening line");
let address = first_line
.trim()
.strip_prefix("listening: ")
.expect("listening address")
.to_owned();
let sent = run(&[
"send-udp",
"--to",
&address,
"--service",
"77777",
"--class",
"text",
"--text",
"hello-udp",
]);
assert!(sent.status.success(), "stderr: {}", stderr(&sent));
assert!(stdout(&sent).contains("sent:"));
let mut received = String::new();
reader.read_to_string(&mut received).expect("server output");
let status = server.wait().expect("server exits");
assert!(status.success(), "server stderr: {received}");
assert!(
received.contains("service=77777 class=Text bytes=9 payload=hello-udp"),
"received: {received}"
);
}
#[test]
fn serve_times_out_when_no_frames_arrive() {
let output = Command::new(env!("CARGO_BIN_EXE_icenetd"))
.args(["serve", "--bind", "127.0.0.1:0", "--timeout", "200"])
.output()
.expect("serve starts");
assert_eq!(output.status.code(), Some(1));
assert!(stderr(&output).contains("timeout after"));
}
#[test]
fn send_udp_rejects_invalid_addresses() {
let output = run(&["send-udp", "--to", "not-an-address", "--text", "hello"]);
assert_eq!(output.status.code(), Some(2));
assert!(stderr(&output).contains("invalid socket address"));
}

View file

@ -0,0 +1,7 @@
[package]
name = "icenet-core"
version.workspace = true
edition.workspace = true
license.workspace = true
[dependencies]

View file

@ -0,0 +1,106 @@
//! Shared, platform-independent types for ICE-NET prototypes.
//!
//! These numeric node IDs are simulation placeholders, not cryptographic IDs.
#![forbid(unsafe_code)]
#![warn(missing_docs)]
/// An ICE-NET node identifier in the current prototype.
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct NodeId(pub u64);
/// An ICE-NET application service identifier; not a TCP/UDP port.
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct ServiceId(pub u64);
/// User-facing classes of traffic.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum TrafficClass {
/// Tiny announcements and routing control messages.
Control,
/// Small user messages that may use a slow radio link.
Text,
/// Bulk transfers, including photos and files.
Bulk,
}
impl TrafficClass {
/// Largest payload that may travel as [`TrafficClass::Control`].
pub const CONTROL_MAX_BYTES: u64 = 256;
/// Largest payload that may travel as [`TrafficClass::Text`].
///
/// Equals the wire frame payload limit, so one text is one frame.
pub const TEXT_MAX_BYTES: u64 = 4_096;
/// Returns whether slow radio links are eligible for this traffic class.
pub const fn allows_slow_radio(self) -> bool {
!matches!(self, Self::Bulk)
}
/// Returns the class a payload of `bytes` is actually treated as.
///
/// The label is chosen by the sender and cannot be trusted: an oversized
/// `Control` becomes `Text` and an oversized `Text` becomes `Bulk`, so a
/// large payload can never claim a slow radio. `Bulk` never shrinks.
pub const fn effective_for(self, bytes: u64) -> Self {
match self {
Self::Control if bytes <= Self::CONTROL_MAX_BYTES => Self::Control,
Self::Control | Self::Text if bytes <= Self::TEXT_MAX_BYTES => Self::Text,
_ => Self::Bulk,
}
}
}
/// Abstract physical or tunnel link categories used by the simulator.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum LinkKind {
/// Low-throughput, long-range radio.
SlowRadio,
/// Directional Wi-Fi or comparable fast wireless communication.
FastWireless,
/// Wired fiber or Ethernet-style backhaul.
Wired,
/// A best-effort internet tunnel.
Internet,
}
impl LinkKind {
/// Returns an illustrative bitrate, not a measured hardware capability.
pub const fn demo_bps(self) -> u64 {
match self {
Self::SlowRadio => 1_000,
Self::FastWireless => 20_000_000,
Self::Wired => 100_000_000,
Self::Internet => 10_000_000,
}
}
/// Returns illustrative serialization time for `bytes`, rounded up.
///
/// A zero-byte payload costs one byte, so the result is always at least
/// one millisecond for a nonzero bitrate.
pub const fn transfer_ms(self, bytes: u64) -> u64 {
let bitrate = self.demo_bps() as u128;
if bitrate == 0 {
return u64::MAX;
}
let transfer = ((if bytes == 0 { 1 } else { bytes }) as u128)
.saturating_mul(8_000)
.saturating_add(bitrate - 1)
/ bitrate;
if transfer > u64::MAX as u128 {
u64::MAX
} else {
transfer as u64
}
}
/// Returns a short display name.
pub const fn label(self) -> &'static str {
match self {
Self::SlowRadio => "LoRa (slow)",
Self::FastWireless => "Wi-Fi (fast)",
Self::Wired => "Wired",
Self::Internet => "Internet",
}
}
}

View file

@ -0,0 +1,41 @@
use icenet_core::{LinkKind, NodeId, ServiceId, TrafficClass};
#[test]
fn slow_radio_is_not_allowed_for_bulk() {
assert!(TrafficClass::Text.allows_slow_radio());
assert!(TrafficClass::Control.allows_slow_radio());
assert!(!TrafficClass::Bulk.allows_slow_radio());
}
#[test]
fn service_id_is_not_limited_to_tcp_ports() {
assert!(ServiceId(77_777).0 > 65_535);
assert_eq!(NodeId(42), NodeId(42));
assert!(LinkKind::FastWireless.demo_bps() > LinkKind::SlowRadio.demo_bps());
}
#[test]
fn transfer_time_uses_ceiling_and_a_nonzero_minimum() {
assert_eq!(LinkKind::SlowRadio.transfer_ms(1), 8);
assert_eq!(LinkKind::Wired.transfer_ms(1), 1);
assert_eq!(LinkKind::FastWireless.transfer_ms(0), 1);
assert_eq!(LinkKind::SlowRadio.transfer_ms(1_000), 8_000);
}
#[test]
fn class_is_derived_from_size_not_only_from_the_label() {
use TrafficClass::{Bulk, Control, Text};
assert_eq!(
Control.effective_for(TrafficClass::CONTROL_MAX_BYTES),
Control
);
assert_eq!(
Control.effective_for(TrafficClass::CONTROL_MAX_BYTES + 1),
Text
);
assert_eq!(Text.effective_for(TrafficClass::TEXT_MAX_BYTES), Text);
assert_eq!(Text.effective_for(TrafficClass::TEXT_MAX_BYTES + 1), Bulk);
assert_eq!(Control.effective_for(5_000_000), Bulk);
// A Bulk label never shrinks, however small the payload is.
assert_eq!(Bulk.effective_for(1), Bulk);
}

View file

@ -0,0 +1,8 @@
[package]
name = "icenet-guard"
version.workspace = true
edition.workspace = true
license.workspace = true
[dependencies]
icenet-core = { path = "../icenet-core" }

Some files were not shown because too many files have changed in this diff Show more