pax_global_header 0000666 0000000 0000000 00000000064 13715306717 0014524 g ustar 00root root 0000000 0000000 52 comment=7217265ec7532e8af49547ce75d51a443f048cc6
owl-master/ 0000775 0000000 0000000 00000000000 13715306717 0013162 5 ustar 00root root 0000000 0000000 owl-master/.github/ 0000775 0000000 0000000 00000000000 13715306717 0014522 5 ustar 00root root 0000000 0000000 owl-master/.github/workflows/ 0000775 0000000 0000000 00000000000 13715306717 0016557 5 ustar 00root root 0000000 0000000 owl-master/.github/workflows/test.yml 0000664 0000000 0000000 00000001403 13715306717 0020257 0 ustar 00root root 0000000 0000000 name: Build and test
on: [push, pull_request]
jobs:
build:
runs-on: ${{ matrix.os }}
strategy:
matrix:
os: [ubuntu-latest, macos-latest]
steps:
- uses: actions/checkout@v1
- name: Install dependencies
if: startsWith(matrix.os, 'ubuntu')
run: sudo apt install libpcap-dev libev-dev libnl-3-dev libnl-genl-3-dev libnl-route-3-dev
- name: Install dependencies
if: startsWith(matrix.os, 'macos')
run: brew install libpcap libev
- name: Checkout submodules
run: git submodule update --init
- name: Create build directory
run: mkdir build
- name: CMake
run: cd build && cmake ..
- name: make
run: cd build && make
- name: Run tests
run: build/tests/tests
owl-master/.gitignore 0000664 0000000 0000000 00000000114 13715306717 0015146 0 ustar 00root root 0000000 0000000 # IDEA
.idea/
cmake-build-debug/
cmake-build-release/
# Build files
build/
owl-master/.gitmodules 0000664 0000000 0000000 00000000274 13715306717 0015342 0 ustar 00root root 0000000 0000000 [submodule "googletest"]
path = googletest
url = https://github.com/google/googletest.git
[submodule "radiotap"]
path = radiotap
url = https://github.com/radiotap/radiotap-library.git
owl-master/.lgtm.yml 0000664 0000000 0000000 00000000126 13715306717 0014725 0 ustar 00root root 0000000 0000000 path_classifiers:
library:
- googletest
- radiotap
test:
- googletest
owl-master/CMakeLists.txt 0000664 0000000 0000000 00000000675 13715306717 0015732 0 ustar 00root root 0000000 0000000 cmake_minimum_required(VERSION 3.5)
project(owl)
if (CMAKE_C_COMPILER_ID MATCHES "GNU" OR CMAKE_C_COMPILER_ID MATCHES "Clang")
add_compile_options("-Wall" "-Wextra")
endif ()
add_library(radiotap radiotap/radiotap.c)
target_compile_definitions(radiotap PRIVATE -D_BSD_SOURCE -DRADIOTAP_SUPPORT_OVERRIDES)
add_subdirectory(src)
add_subdirectory(daemon)
option(INSTALL_GTEST "" OFF)
add_subdirectory(googletest)
add_subdirectory(tests)
owl-master/COPYING 0000664 0000000 0000000 00000104515 13715306717 0014223 0 ustar 00root root 0000000 0000000 GNU GENERAL PUBLIC LICENSE
Version 3, 29 June 2007
Copyright (C) 2007 Free Software Foundation, Inc.
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.
Copyright (C)
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 .
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:
Copyright (C)
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
.
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
.
owl-master/README.md 0000664 0000000 0000000 00000016740 13715306717 0014451 0 ustar 00root root 0000000 0000000 # Open Wireless Link
Open Wireless Link (OWL) is an open implementation of the Apple Wireless Direct Link (AWDL) ad hoc protocol for Linux and macOS written in C and part of the [Open Wireless Link project](https://owlink.org).
OWL runs in user space and makes use of Linux’s Netlink API for Wi-Fi specific operations such as channel switching and to integrate itself in the Linux networking stack by providing a virtual network interface such that existing IPv6-capable programs can use AWDL without modification.
You can use OWL to in combination with [OpenDrop](https://github.com/seemoo-lab/opendrop) to enable *Apple AirDrop* functionality on Linux-based systems [such as a Raspberry Pi 3](https://owlink.org/2019/05/16/howto-use-airdrop-on-raspberry-pi-3.html).
## Disclaimer
OWL is experimental software and is the result of reverse engineering efforts by the [Open Wireless Link](https://owlink.org) project.
Therefore, it does not support all features of AWDL or might be incompatible with future AWDL versions.
OWL is not affiliated with or endorsed by Apple Inc. Use this code at your own risk.
## Requirements
**Wi-Fi card with *active* monitor mode.** To use OWL, you will need a Wi-Fi card supporting active monitor mode with frame injection. We recommend the Atheros AR9280 chip (IEEE 802.11n) which we used to develop and test this code. Configurations that do not support *active* monitor mode, i.e., ACK received frames, might suffer from throughput degradation because the sender will re-transmit each frame up to 7 times as per the IEEE 802.11 standard. Have a look at [issue #9](https://github.com/seemoo-lab/owl/issues/9) if you want to find out whether your card meets the requirements.
**No support for virtual machines and WSL.** OWL requires direct access to the Wi-Fi card which means that virtualized environments (except with USB or PCIe passthrough) and Windows Subsystem for Linux (WSL, see [issue #8](https://github.com/seemoo-lab/owl/issues/8)), are *not supported*.
## Installation
If you're an Arch Linux user, then you can install `owl` from the
[`owlink-git` AUR package](https://aur.archlinux.org/packages/owlink-git/), e.g.,
```sh
yay -S owlink-git
```
## Build from source
The project is build using CMake. To build the project, simply clone this repository in `` and run
```sh
cd
git submodule update --init
mkdir build
cd build
cmake ..
make
sudo make install
```
OWL requires `libpcap` for frame injection and reception, `libev` for event handling, and `libnl` (Linux only) for interactions with the system's networking stack which have to be installed on the target system.
On Debian Linux,
```sh
sudo apt install libpcap-dev libev-dev libnl-3-dev libnl-genl-3-dev libnl-route-3-dev
```
On Fedora Linux,
```sh
sudo dnf install libpcap-devel libev-devel libnl3-devel
```
On macOS, you need to add support for tun/tap devices, e.g., via [tuntaposx](http://tuntaposx.sourceforge.net). You can install everything via [Homebrew](https://brew.sh):
```sh
brew install libpcap libev
brew cask install tuntap
```
## Use
Simply run
```sh
sudo owl -i
```
You may increase the log level with `-v` and `-vv` and daemonize the program with `-D`. For other options, have a look at `daemon/owl.c`.
**Warning:** do not use the `-N` flag in setups without Nexmon such as [this](https://owlink.org/2019/05/16/howto-use-airdrop-on-raspberry-pi-3.html) as it will likely [cause several problems](https://github.com/seemoo-lab/owl/issues/12#issuecomment-673651362).
When started, OWL creates a virtual network interface `awdl0` with a link-local IPv6 address. Discovered AWDL peers are automatically added (and removed) to (and from) the system's neighbor table. Run `ip n` to see a list of all current neighbors.
## Architecture
The following figure shows the core structure of OWL.
## Code Structure
We provide a coarse structure of the most important components and files to facilitate navigating the code base.
* `daemon/` Contains the active components that interact with the system.
* `core.{c,h}` Schedules all relevant functions on the event loop.
* `io.{c,h}` Platform-specific functions to send and receive frames.
* `netutils.{c,h}` Platform-specific functions to interact with the system's networking stack.
* `owl.c` Contains `main()` and sets up the `core` based on user arguments.
* `googletest/` The runtime for running the tests.
* `radiotap/` Library for parsing radiotap headers.
* `src/` Contains platform-independent AWDL code.
* `channel.{c,h}` Utilities for managing the channel sequence.
* `election.{c,h}` Code for running the election process.
* `frame.{c,h}` The corresponding header file contains the definitions of all TLVs.
* `peers.{c,h}` Manages the peer table.
* `rx.{c,h}` Functions for handling a received data and action frames including parsing TLVs.
* `schedule.{c,h}` Functions to determine *when* and *which* frames should be sent.
* `state.{c,h}` Consolidates the AWDL state.
* `sync.{c,h}` Synchronization: managing (extended) availability windows.
* `tx.{c,h}` Crafting valid data and action frames ready for transmission.
* `version.{c,h}` Parse and create AWDL version numbers.
* `wire.{c,h}` Mini-library for safely reading and writing primitives types from and to a frame buffer.
* `tests/` The actual test cases for this repository.
* `README.md` This file.
## Current Limitations/TODOs
* OWL uses static election metric and counter values, so it either takes part as a slave (low values) or wins the election (high values). See `AWDL_ELECTION_METRIC_INIT` and `AWDL_ELECTION_COUNTER_INIT` and in `include/election.h`.
* The channel sequence does not adjust itself automatically to current network load and/or other triggers. This would require a better understanding of Apple's implementation. Currently, the channel sequence is fixed when initializing. See `awdl_chanseq_init_static()` in `src/state.{c,h}`.
* OWL does not allow a concurrent connection to an AP. This means, that when started, the Wi-Fi interface exclusively uses AWDL. To work around this, OWL could create a new monitor interface (instead of making the Wi-Fi interface one) and adjust its channel sequence to include the channel of the AP network.
## Our Papers
* Milan Stute, Sashank Narain, Alex Mariotto, Alexander Heinrich, David Kreitschmann, Guevara Noubir, and Matthias Hollick. **A Billion Open Interfaces for Eve and Mallory: MitM, DoS, and Tracking Attacks on iOS and macOS Through Apple Wireless Direct Link.** *28th USENIX Security Symposium (USENIX Security ’19)*, August 14–16, 2019, Santa Clara, CA, USA. [Link](https://www.usenix.org/conference/usenixsecurity19/presentation/stute)
* Milan Stute, David Kreitschmann, and Matthias Hollick. **One Billion Apples’ Secret Sauce: Recipe for the Apple Wireless Direct Link Ad hoc Protocol.** *The 24th Annual International Conference on Mobile Computing and Networking (MobiCom '18)*, October 29–November 2, 2018, New Delhi, India. ACM. [doi:10.1145/3241539.3241566](https://doi.org/10.1145/3241539.3241566)
* Milan Stute, David Kreitschmann, and Matthias Hollick. **Demo: Linux Goes Apple Picking: Cross-Platform Ad hoc Communication with Apple Wireless Direct Link.** *The 24th Annual International Conference on Mobile Computing and Networking (MobiCom '18)*, October 29–November 2, 2018, New Delhi, India. ACM. [doi:10.1145/3241539.3267716](https://doi.org/10.1145/3241539.3267716)
## Contact
* **Milan Stute** ([email](mailto:mstute@seemoo.tu-darmstadt.de), [web](https://seemoo.de/mstute))
owl-master/daemon/ 0000775 0000000 0000000 00000000000 13715306717 0014425 5 ustar 00root root 0000000 0000000 owl-master/daemon/CMakeLists.txt 0000664 0000000 0000000 00000002535 13715306717 0017172 0 ustar 00root root 0000000 0000000 set(CMAKE_CXX_STANDARD 11)
include(FindPackageHandleStandardArgs)
set(SOURCES PRIVATE
io.c
io.h
core.c
core.h
netutils.c
netutils.h)
if (APPLE)
list(APPEND SOURCES corewlan.m corewlan.h)
endif ()
add_executable(owl "")
target_sources(owl ${SOURCES} owl.c)
find_library(libpcap_LIBRARY NAMES pcap)
find_path(libpcap_INCLUDE pcap.h)
find_package_handle_standard_args(libpcap DEFAULT_MSG libpcap_LIBRARY libpcap_INCLUDE)
if (NOT libpcap_FOUND)
message(FATAL_ERROR "libpcap not found")
endif ()
find_library(libev_LIBRARY NAMES ev)
find_path(libev_INCLUDE ev.h PATHS /usr/local/include)
find_package_handle_standard_args(libev DEFAULT_MSG libev_LIBRARY libev_INCLUDE)
if (NOT libev_FOUND)
message(FATAL_ERROR "libev not found")
endif ()
if (APPLE)
find_library(FOUNDATION Foundation)
find_library(COREWLAN CoreWLAN)
find_library(SYSTEMCONFIGURATION SystemConfiguration)
endif ()
target_include_directories(owl PRIVATE ${CMAKE_SOURCE_DIR}/src ${libev_INCLUDE})
target_link_libraries(owl awdl ${libpcap_LIBRARY} ${libev_LIBRARY})
if (APPLE)
target_link_libraries(owl ${FOUNDATION} ${COREWLAN} ${SYSTEMCONFIGURATION})
else ()
target_include_directories(owl PRIVATE /usr/include/libnl3)
target_link_libraries(owl nl-3 nl-genl-3 nl-route-3)
endif ()
install(TARGETS owl DESTINATION bin)
owl-master/daemon/core.c 0000664 0000000 0000000 00000035624 13715306717 0015533 0 ustar 00root root 0000000 0000000 /*
* OWL: an open Apple Wireless Direct Link (AWDL) implementation
* Copyright (C) 2018 The Open Wireless Link Project (https://owlink.org)
* Copyright (C) 2018 Milan Stute
*
* 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 .
*/
#include "core.h"
#include "netutils.h"
#include "log.h"
#include "wire.h"
#include "rx.h"
#include "tx.h"
#include "schedule.h"
#include
#ifdef __APPLE__
# define SIGSTATS SIGINFO
#else
# define SIGSTATS SIGUSR1
#endif
#define ETHER_LENGTH 14
#define ETHER_DST_OFFSET 0
#define ETHER_SRC_OFFSET 6
#define ETHER_ETHERTYPE_OFFSET 12
#define POLL_NEW_UNICAST 0x1
#define POLL_NEW_MULTICAST 0x2
static void dump_frame(const char *dump_file, const struct pcap_pkthdr *hdr, const uint8_t *buf) {
if (dump_file) {
/* Make sure file exists because 'pcap_dump_open_append' does NOT create file for you */
fclose(fopen(dump_file, "a+"));
pcap_t *p = pcap_open_dead(DLT_IEEE802_11_RADIO, 65535);
pcap_dumper_t *dumper = pcap_dump_open_append(p, dump_file);
pcap_dump((u_char *) dumper, hdr, buf);
pcap_close(p);
pcap_dump_close(dumper);
}
}
static void ev_timer_rearm(struct ev_loop *loop, ev_timer *timer, double in) {
ev_timer_stop(loop, timer);
ev_timer_set(timer, in, 0.);
ev_timer_start(loop, timer);
}
void wlan_device_ready(struct ev_loop *loop, ev_io *handle, int revents) {
struct daemon_state *state = handle->data;
int cnt = pcap_dispatch(state->io.wlan_handle, 1, &awdl_receive_frame, handle->data);
if (cnt > 0)
ev_feed_event(loop, handle, revents);
}
static int poll_host_device(struct daemon_state *state) {
struct buf *buf = NULL;
int result = 0;
while (!state->next && !circular_buf_full(state->tx_queue_multicast)) {
buf = buf_new_owned(ETHER_MAX_LEN);
int len = buf_len(buf);
if (host_recv(&state->io, (uint8_t *) buf_data(buf), &len) < 0) {
goto wire_error;
} else {
bool is_multicast;
struct ether_addr dst;
buf_take(buf, buf_len(buf) - len);
READ_ETHER_ADDR(buf, ETHER_DST_OFFSET, &dst);
is_multicast = dst.ether_addr_octet[0] & 0x01;
if (is_multicast) {
circular_buf_put(state->tx_queue_multicast, buf);
result |= POLL_NEW_MULTICAST;
} else { /* unicast */
state->next = buf;
result |= POLL_NEW_UNICAST;
}
}
}
return result;
wire_error:
if (buf)
buf_free(buf);
return 0;
}
void host_device_ready(struct ev_loop *loop, ev_io *handle, int revents) {
(void) loop;
(void) revents; /* should always be EV_READ */
struct daemon_state *state = handle->data;
int poll_result = poll_host_device(state); /* fill TX queues */
if (poll_result & POLL_NEW_MULTICAST)
awdl_send_multicast(loop, &state->ev_state.tx_mcast_timer, 0);
if (poll_result & POLL_NEW_UNICAST)
awdl_send_unicast(loop, &state->ev_state.tx_timer, 0);
}
void awdl_receive_frame(uint8_t *user, const struct pcap_pkthdr *hdr, const uint8_t *buf) {
#define MAX_NUM_AMPDU 16 /* TODO lookup this constant from the standard */
struct daemon_state *state = (void *) user;
int result;
const struct buf *frame = buf_new_const(buf, hdr->caplen);
struct buf *data_arr[MAX_NUM_AMPDU];
struct buf **data = &data_arr[0];
result = awdl_rx(frame, &data, &state->awdl_state);
if (result == RX_OK) {
for (struct buf **data_start = &data_arr[0]; data_start < data; data_start++) {
host_send(&state->io, buf_data(*data_start), buf_len(*data_start));
buf_free(*data_start);
}
} else if (result < RX_OK) {
log_warn("unhandled frame (%d)", result);
dump_frame(state->dump, hdr, buf);
state->awdl_state.stats.rx_unknown++;
}
buf_free(frame);
}
int awdl_send_data(const struct buf *buf, const struct io_state *io_state,
struct awdl_state *awdl_state, struct ieee80211_state *ieee80211_state) {
uint8_t awdl_data[65535];
int awdl_data_len;
uint16_t ethertype;
struct ether_addr src, dst;
uint64_t now;
uint16_t period, slot, tu;
READ_BE16(buf, ETHER_ETHERTYPE_OFFSET, ðertype);
READ_ETHER_ADDR(buf, ETHER_DST_OFFSET, &dst);
READ_ETHER_ADDR(buf, ETHER_SRC_OFFSET, &src);
buf_strip(buf, ETHER_LENGTH);
awdl_data_len = awdl_init_full_data_frame(awdl_data, &src, &dst,
buf_data(buf), buf_len(buf),
awdl_state, ieee80211_state);
now = clock_time_us();
period = awdl_sync_current_eaw(now, &awdl_state->sync) / AWDL_CHANSEQ_LENGTH;
slot = awdl_sync_current_eaw(now, &awdl_state->sync) % AWDL_CHANSEQ_LENGTH;
tu = awdl_sync_next_aw_tu(now, &awdl_state->sync);
log_trace("Send data (len %d) to %s (%u.%u.%u)", awdl_data_len,
ether_ntoa(&dst), period, slot, tu);
awdl_state->stats.tx_data++;
if (wlan_send(io_state, awdl_data, awdl_data_len) < 0)
return TX_FAIL;
return TX_OK;
wire_error:
return TX_FAIL;
}
void awdl_send_action(struct daemon_state *state, enum awdl_action_type type) {
uint8_t buf[65535];
int len;
len = awdl_init_full_action_frame(buf, &state->awdl_state, &state->ieee80211_state, type);
if (len < 0)
return;
log_trace("send %s", awdl_frame_as_str(type));
wlan_send(&state->io, buf, len);
state->awdl_state.stats.tx_action++;
}
void awdl_send_psf(struct ev_loop *loop, ev_timer *handle, int revents) {
(void) loop;
(void) revents;
awdl_send_action(handle->data, AWDL_ACTION_PSF);
}
void awdl_send_mif(struct ev_loop *loop, ev_timer *timer, int revents) {
(void) revents;
struct daemon_state *state = timer->data;
struct awdl_state *awdl_state = &state->awdl_state;
uint64_t now, next_aw, eaw_len;
now = clock_time_us();
next_aw = awdl_sync_next_aw_us(now, &awdl_state->sync);
eaw_len = awdl_state->sync.presence_mode * awdl_state->sync.aw_period;
/* Schedule MIF in middle of sequence (if non-zero) */
if (awdl_chan_num(awdl_state->channel.current, awdl_state->channel.enc) > 0)
awdl_send_action(state, AWDL_ACTION_MIF);
/* schedule next in the middle of EAW */
ev_timer_rearm(loop, timer, usec_to_sec(next_aw + ieee80211_tu_to_usec(eaw_len / 2)));
}
void awdl_send_unicast(struct ev_loop *loop, ev_timer *timer, int revents) {
(void) revents;
struct daemon_state *state = timer->data;
struct awdl_state *awdl_state = &state->awdl_state;
uint64_t now = clock_time_us();
double in = 0;
if (state->next) { /* we have something to send */
struct awdl_peer *peer;
struct ether_addr dst;
read_ether_addr(state->next, ETHER_DST_OFFSET, &dst);
if (compare_ether_addr(&dst, &awdl_state->self_address) == 0) {
/* send back to self */
host_send(&state->io, buf_data(state->next), buf_len(state->next));
buf_free(state->next);
state->next = NULL;
} else if (awdl_peer_get(awdl_state->peers.peers, &dst, &peer) < 0) {
log_debug("Drop frame to non-peer %s", ether_ntoa(&dst));
buf_free(state->next);
state->next = NULL;
} else {
in = awdl_can_send_unicast_in(awdl_state, peer, now, AWDL_UNICAST_GUARD_TU);
if (in == 0) { /* send now */
awdl_send_data(state->next, &state->io, &state->awdl_state, &state->ieee80211_state);
buf_free(state->next);
state->next = NULL;
state->awdl_state.stats.tx_data_unicast++;
} else { /* try later */
if (in < 0) /* we are at the end of slot but within guard */
in = -in + usec_to_sec(ieee80211_tu_to_usec(AWDL_UNICAST_GUARD_TU));
}
}
}
/* rearm if more unicast frames available */
if (state->next) {
log_trace("awdl_send_unicast: retry in %lu TU", ieee80211_usec_to_tu(sec_to_usec(in)));
ev_timer_rearm(loop, timer, in);
} else {
/* poll for more frames to keep queue full */
ev_feed_event(loop, &state->ev_state.read_host, 0);
}
}
void awdl_send_multicast(struct ev_loop *loop, ev_timer *timer, int revents) {
(void) revents;
struct daemon_state *state = timer->data;
struct awdl_state *awdl_state = &state->awdl_state;
uint64_t now = clock_time_us();
double in = 0;
if (!circular_buf_empty(state->tx_queue_multicast)) { /* we have something to send */
in = awdl_can_send_in(awdl_state, now, AWDL_MULTICAST_GUARD_TU);
if (awdl_is_multicast_eaw(awdl_state, now) && (in == 0)) { /* we can send now */
void *next;
circular_buf_get(state->tx_queue_multicast, &next, 0);
awdl_send_data((struct buf *) next, &state->io, &state->awdl_state, &state->ieee80211_state);
buf_free(next);
state->awdl_state.stats.tx_data_multicast++;
} else { /* try later */
if (in == 0) /* try again next EAW */
in = usec_to_sec(ieee80211_tu_to_usec(64));
else if (in < 0) /* we are at the end of slot but within guard */
in = -in + usec_to_sec(ieee80211_tu_to_usec(AWDL_MULTICAST_GUARD_TU));
}
}
/* rearm if more multicast frames available */
if (!circular_buf_empty(state->tx_queue_multicast)) {
log_trace("awdl_send_multicast: retry in %lu TU", ieee80211_usec_to_tu(sec_to_usec(in)));
ev_timer_rearm(loop, timer, in);
} else {
/* poll for more frames to keep queue full */
ev_feed_event(loop, &state->ev_state.read_host, 0);
}
}
void awdl_switch_channel(struct ev_loop *loop, ev_timer *timer, int revents) {
(void) revents;
uint64_t now, next_aw;
int slot;
struct awdl_chan chan_new;
int chan_num_new, chan_num_old;
struct daemon_state *state = timer->data;
struct awdl_state *awdl_state = &state->awdl_state;
chan_num_old = awdl_chan_num(awdl_state->channel.current, awdl_state->channel.enc);
now = clock_time_us();
slot = awdl_sync_current_eaw(now, &awdl_state->sync) % AWDL_CHANSEQ_LENGTH;
chan_new = awdl_state->channel.sequence[slot];
chan_num_new = awdl_chan_num(awdl_state->channel.sequence[slot], awdl_state->channel.enc);
if (chan_num_new && (chan_num_new != chan_num_old)) {
log_debug("switch channel to %d (slot %d)", chan_num_new, slot);
if (!state->io.wlan_is_file)
set_channel(state->io.wlan_ifindex, chan_num_new);
awdl_state->channel.current = chan_new;
}
next_aw = awdl_sync_next_aw_us(now, &awdl_state->sync);
ev_timer_rearm(loop, timer, usec_to_sec(next_aw));
}
static void awdl_neighbor_add(struct awdl_peer *p, void *_io_state) {
struct io_state *io_state = _io_state;
neighbor_add_rfc4291(io_state->host_ifindex, &p->addr);
}
static void awdl_neighbor_remove(struct awdl_peer *p, void *_io_state) {
struct io_state *io_state = _io_state;
neighbor_remove_rfc4291(io_state->host_ifindex, &p->addr);
}
void awdl_clean_peers(struct ev_loop *loop, ev_timer *timer, int revents) {
(void) loop;
(void) revents; /* should always be EV_TIMER */
uint64_t cutoff_time;
struct daemon_state *state;
state = (struct daemon_state *) timer->data;
cutoff_time = clock_time_us() - state->awdl_state.peers.timeout;
awdl_peers_remove(state->awdl_state.peers.peers, cutoff_time,
state->awdl_state.peer_remove_cb, state->awdl_state.peer_remove_cb_data);
/* TODO for now run election immediately after clean up; might consider seperate timer for this */
awdl_election_run(&state->awdl_state.election, &state->awdl_state.peers);
ev_timer_again(loop, timer);
}
void awdl_print_stats(struct ev_loop *loop, ev_signal *handle, int revents) {
(void) loop;
(void) revents; /* should always be EV_TIMER */
struct awdl_stats *stats = &((struct daemon_state *) handle->data)->awdl_state.stats;
log_info("STATISTICS");
log_info(" TX action %llu, data %llu, unicast %llu, multicast %llu",
stats->tx_action, stats->tx_data, stats->tx_data_unicast, stats->tx_data_multicast);
log_info(" RX action %llu, data %llu, unknown %llu",
stats->rx_action, stats->rx_data, stats->rx_unknown);
}
int awdl_init(struct daemon_state *state, const char *wlan, const char *host, struct awdl_chan chan, const char *dump) {
int err;
char hostname[HOST_NAME_LENGTH_MAX + 1];
err = netutils_init();
if (err < 0)
return err;
err = io_state_init(&state->io, wlan, host, &AWDL_BSSID);
if (err < 0)
return err;
err = get_hostname(hostname, sizeof(hostname));
if (err < 0)
return err;
awdl_init_state(&state->awdl_state, hostname, &state->io.if_ether_addr, chan, clock_time_us());
state->awdl_state.peer_cb = awdl_neighbor_add;
state->awdl_state.peer_cb_data = (void *) &state->io;
state->awdl_state.peer_remove_cb = awdl_neighbor_remove;
state->awdl_state.peer_remove_cb_data = (void *) &state->io;
ieee80211_init_state(&state->ieee80211_state);
state->next = NULL;
state->tx_queue_multicast = circular_buf_init(16);
state->dump = dump;
return 0;
}
void awdl_free(struct daemon_state *state) {
circular_buf_free(state->tx_queue_multicast);
io_state_free(&state->io);
netutils_cleanup();
}
void awdl_schedule(struct ev_loop *loop, struct daemon_state *state) {
state->ev_state.loop = loop;
/* Timer for channel switching */
state->ev_state.chan_timer.data = (void *) state;
ev_timer_init(&state->ev_state.chan_timer, awdl_switch_channel, 0, 0);
ev_timer_start(loop, &state->ev_state.chan_timer);
/* Timer for peer table cleanup */
state->ev_state.peer_timer.data = (void *) state;
ev_timer_init(&state->ev_state.peer_timer, awdl_clean_peers, 0, usec_to_sec(state->awdl_state.peers.clean_interval));
ev_timer_again(loop, &state->ev_state.peer_timer);
/* Trigger frame reception from WLAN device */
state->ev_state.read_wlan.data = (void *) state;
ev_io_init(&state->ev_state.read_wlan, wlan_device_ready, state->io.wlan_fd, EV_READ);
ev_io_start(loop, &state->ev_state.read_wlan);
/* Trigger frame reception from host device */
state->ev_state.read_host.data = (void *) state;
ev_io_init(&state->ev_state.read_host, host_device_ready, state->io.host_fd, EV_READ);
ev_io_start(loop, &state->ev_state.read_host);
/* Timer for PSFs */
state->ev_state.psf_timer.data = (void *) state;
ev_timer_init(&state->ev_state.psf_timer, awdl_send_psf,
usec_to_sec(ieee80211_tu_to_usec(state->awdl_state.psf_interval)),
usec_to_sec(ieee80211_tu_to_usec(state->awdl_state.psf_interval)));
ev_timer_start(loop, &state->ev_state.psf_timer);
/* Timer for MIFs */
state->ev_state.mif_timer.data = (void *) state;
ev_timer_init(&state->ev_state.mif_timer, awdl_send_mif, 0, 0);
ev_timer_start(loop, &state->ev_state.mif_timer);
/* Timer for unicast packets */
state->ev_state.tx_timer.data = (void *) state;
ev_timer_init(&state->ev_state.tx_timer, awdl_send_unicast, 0, 0);
ev_timer_start(loop, &state->ev_state.tx_timer);
/* Timer for multicast packets */
state->ev_state.tx_mcast_timer.data = (void *) state;
ev_timer_init(&state->ev_state.tx_mcast_timer, awdl_send_multicast, 0, 0);
ev_timer_start(loop, &state->ev_state.tx_mcast_timer);
/* Register signal to print statistics */
state->ev_state.stats.data = (void *) state;
ev_signal_init(&state->ev_state.stats, awdl_print_stats, SIGSTATS);
ev_signal_start(loop, &state->ev_state.stats);
}
owl-master/daemon/core.h 0000664 0000000 0000000 00000005141 13715306717 0015527 0 ustar 00root root 0000000 0000000 /*
* OWL: an open Apple Wireless Direct Link (AWDL) implementation
* Copyright (C) 2018 The Open Wireless Link Project (https://owlink.org)
* Copyright (C) 2018 Milan Stute
*
* 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 .
*/
#ifndef OWL_CORE_H
#define OWL_CORE_H
#include
#include
#include "state.h"
#include "circular_buffer.h"
#include "io.h"
struct ev_state {
struct ev_loop *loop;
ev_timer mif_timer, psf_timer, tx_timer, tx_mcast_timer, chan_timer, peer_timer;
ev_io read_wlan, read_host;
ev_signal stats;
};
struct daemon_state {
struct io_state io;
struct awdl_state awdl_state;
struct ieee80211_state ieee80211_state;
struct ev_state ev_state;
struct buf *next;
cbuf_handle_t tx_queue_multicast;
const char *dump;
};
int awdl_init(struct daemon_state *state, const char *wlan, const char *host, struct awdl_chan chan, const char *dump);
void awdl_free(struct daemon_state *state);
void awdl_schedule(struct ev_loop *loop, struct daemon_state *state);
void wlan_device_ready(struct ev_loop *loop, ev_io *handle, int revents);
void host_device_ready(struct ev_loop *loop, ev_io *handle, int revents);
void awdl_receive_frame(uint8_t *user, const struct pcap_pkthdr *hdr, const uint8_t *buf);
void awdl_send_action(struct daemon_state *state, enum awdl_action_type type);
void awdl_send_psf(struct ev_loop *loop, ev_timer *handle, int revents);
void awdl_send_mif(struct ev_loop *loop, ev_timer *handle, int revents);
void awdl_send_unicast(struct ev_loop *loop, ev_timer *timer, int revents);
void awdl_send_multicast(struct ev_loop *loop, ev_timer *timer, int revents);
int awdl_send_data(const struct buf *buf, const struct io_state *io_state,
struct awdl_state *awdl_state, struct ieee80211_state *ieee80211_state);
void awdl_switch_channel(struct ev_loop *loop, ev_timer *handle, int revents);
void awdl_clean_peers(struct ev_loop *loop, ev_timer *timer, int revents);
void awdl_print_stats(struct ev_loop *loop, ev_signal *handle, int revents);
#endif /* OWL_CORE_H */
owl-master/daemon/corewlan.h 0000664 0000000 0000000 00000002121 13715306717 0016404 0 ustar 00root root 0000000 0000000 /*
* OWL: an open Apple Wireless Direct Link (AWDL) implementation
* Copyright (C) 2018 The Open Wireless Link Project (https://owlink.org)
* Copyright (C) 2018 Milan Stute
*
* 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 .
*/
#ifndef APPLE_COREWLAN_H
#define APPLE_COREWLAN_H
int corewlan_init();
void corewlan_free();
int corewlan_disassociate(int ifindex);
int corewlan_set_channel(int ifindex, int channel);
int corewlan_get_hostname(char *name, size_t len);
#endif /* APPLE_COREWLAN_H */
owl-master/daemon/corewlan.m 0000664 0000000 0000000 00000005144 13715306717 0016421 0 ustar 00root root 0000000 0000000 /*
* OWL: an open Apple Wireless Direct Link (AWDL) implementation
* Copyright (C) 2018 The Open Wireless Link Project (https://owlink.org)
* Copyright (C) 2018 Milan Stute
*
* 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 .
*/
#import
#import
#import
#import
#import
#import
static struct wlan_state {
CWWiFiClient *client;
CWInterface *iface;
NSSet *supportedChannels;
} state;
int corewlan_init() {
state.iface = NULL;
state.supportedChannels = NULL;
return 0;
}
void corewlan_free() {
}
int corewlan_disassociate(int ifindex) {
if (!state.client) {
state.client = [CWWiFiClient sharedWiFiClient];
}
if (!state.iface) {
char iface_cstr[IFNAMSIZ];
NSString *iface_str =[NSString stringWithUTF8String:if_indextoname(ifindex, iface_cstr)];
state.iface = [state.client interfaceWithName:iface_str];
}
[state.iface disassociate];
return 0;
}
int corewlan_set_channel(int ifindex, int channel) {
if (!state.client) {
state.client = [CWWiFiClient sharedWiFiClient];
}
if (!state.iface) {
char iface_cstr[IFNAMSIZ];
NSString *iface_str = [NSString stringWithUTF8String:if_indextoname(ifindex, iface_cstr)];
state.iface = [state.client interfaceWithName:iface_str];
}
if (!state.supportedChannels)
state.supportedChannels = [state.iface supportedWLANChannels];
CWChannel* currentCandidate = NULL;
for (CWChannel* chan in state.supportedChannels) {
if ([chan channelNumber] != channel)
continue;
if (!currentCandidate || [chan channelWidth] > [currentCandidate channelWidth])
currentCandidate = chan;
}
if (!currentCandidate)
return -1;
NSError* err;
[state.iface setWLANChannel:currentCandidate error:&err];
return !err;
}
int corewlan_get_hostname(char *name, size_t len) {
NSString *computerName = [(NSString *) SCDynamicStoreCopyComputerName(NULL, NULL) autorelease];
strlcpy(name, [computerName UTF8String], len);
return 0;
}
owl-master/daemon/io.c 0000664 0000000 0000000 00000024450 13715306717 0015205 0 ustar 00root root 0000000 0000000 /*
* OWL: an open Apple Wireless Direct Link (AWDL) implementation
* Copyright (C) 2018 The Open Wireless Link Project (https://owlink.org)
* Copyright (C) 2018 Milan Stute
*
* 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 .
*/
#include
#include
#include
#include
#include
#include
#include
#ifndef __APPLE__
#include
#else
#include
#include
#include
#include
#endif /* __APPLE__ */
#include "io.h"
#include "netutils.h"
#include
#include
static int open_nonblocking_device(const char *dev, pcap_t **pcap_handle, const struct ether_addr *bssid_filter) {
char errbuf[PCAP_ERRBUF_SIZE];
pcap_t *handle;
struct bpf_program filter;
int fd;
char filter_str[128];
handle = pcap_create(dev, errbuf);
if (handle == NULL) {
log_error("pcap: unable to open device %s (%s)", dev, errbuf);
return -1;
}
pcap_set_snaplen(handle, 65535);
pcap_set_promisc(handle, 1);
#ifdef __APPLE__
/* On Linux, we activate monitor mode via nl80211 */
pcap_set_rfmon(handle, 1);
#endif /* __APPLE__ */
pcap_set_timeout(handle, 1);
if (pcap_activate(handle) < 0) {
log_error("pcap: unable to activate device %s (%s)", dev, pcap_geterr(handle));
pcap_close(handle);
return -1;
}
if (pcap_setnonblock(handle, 1, errbuf)) {
log_error("pcap: cannot set to non-blocking mode (%s)", errbuf);
pcap_close(handle);
return -1;
}
/* FIXME direction does not seem to have an effect (we get our own frames every time we poll) */
if (pcap_setdirection(handle, PCAP_D_IN)) {
log_warn("pcap: unable to monitor only incoming traffic on device %s (%s)", dev, pcap_geterr(handle));
}
if (pcap_datalink(handle) != DLT_IEEE802_11_RADIO) {
log_error("pcap: device %s does not support radiotap headers", dev);
pcap_close(handle);
return -1;
}
snprintf(filter_str, sizeof(filter_str), "wlan addr3 %s", ether_ntoa(bssid_filter));
if (pcap_compile(handle, &filter, filter_str, 1, PCAP_NETMASK_UNKNOWN) == -1) {
log_error("pcap: could not create filter (%s)", pcap_geterr(handle));
return -1;
}
if (pcap_setfilter(handle, &filter) == -1) {
log_error("pcap: could not set filter (%s)", pcap_geterr(handle));
return -1;
}
if ((fd = pcap_get_selectable_fd(handle)) == -1) {
log_error("pcap: unable to get fd");
return -1;
}
*pcap_handle = handle;
return fd;
}
static int open_savefile(const char *filename, pcap_t **pcap_handle) {
char errbuf[PCAP_ERRBUF_SIZE];
int fd;
pcap_t *handle = pcap_open_offline(filename, errbuf);
if (!handle) {
log_trace("pcap: unable to open savefile (%s)", errbuf);
return -1;
}
if ((fd = pcap_get_selectable_fd(handle)) == -1) {
log_trace("pcap: unable to get fd");
return -1;
}
*pcap_handle = handle;
return fd;
}
static int open_tun(char *dev, const struct ether_addr *self) {
#ifndef __APPLE__
static int one = 1;
struct ifreq ifr;
int fd, err, s;
if ((fd = open("/dev/net/tun", O_RDWR)) < 0) {
log_error("tun: unable to open tun device %d", fd);
return fd;
}
memset(&ifr, 0, sizeof(ifr));
/* Flags: IFF_TUN - TUN device (no Ethernet headers)
* IFF_TAP - TAP device
* IFF_NO_PI - Do not provide packet information
*/
ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
if (*dev)
strncpy(ifr.ifr_name, dev, IFNAMSIZ);
if ((err = ioctl(fd, TUNSETIFF, (void *) &ifr)) < 0) {
close(fd);
return err;
}
strcpy(dev, ifr.ifr_name);
/* Set non-blocking mode */
if ((err = ioctl(fd, FIONBIO, &one)) < 0) {
close(fd);
return err;
}
// Create a socket for ioctl
s = socket(AF_INET6, SOCK_DGRAM, 0);
// Set HW address
ifr.ifr_hwaddr.sa_family = 1; /* ARPHRD_ETHER */
memcpy(ifr.ifr_hwaddr.sa_data, self, 6);
if ((err = ioctl(s, SIOCSIFHWADDR, &ifr)) < 0) {
log_error("tun: unable to set HW address");
close(fd);
return err;
}
// Get current flags and set them
ioctl(s, SIOCGIFFLAGS, &ifr);
ifr.ifr_flags |= IFF_UP | IFF_RUNNING;
if ((err = ioctl(s, SIOCSIFFLAGS, &ifr)) < 0) {
log_error("tun: unable to set up");
close(fd);
return err;
}
/* Set reduced MTU */
ifr.ifr_mtu = 1450; /* TODO arbitary limit to fit all headers */
if ((err = ioctl(s, SIOCSIFMTU, (void *) &ifr)) < 0) {
log_error("tun: unable to set MTU");
close(fd);
return err;
}
close(s);
return fd;
#else
for (int i = 0; i < 16; ++i) {
char tuntap[IFNAMSIZ];
sprintf(tuntap, "/dev/tap%d", i);
int fd = open(tuntap, O_RDWR);
if (fd > 0) {
struct ifreq ifr;
struct in6_aliasreq ifr6;
int err, s;
if (fcntl(fd, F_SETFL, O_NONBLOCK) < 0) {
log_error("fcntl error on %s", tuntap);
return -errno;
}
sprintf(dev, "tap%d", i);
// Create a socket for ioctl
s = socket(AF_INET6, SOCK_DGRAM, 0);
// Set HW address
strlcpy(ifr.ifr_name, dev, sizeof(ifr.ifr_name));
ifr.ifr_addr.sa_len = sizeof(struct ether_addr);
ifr.ifr_addr.sa_family = AF_LINK;
memcpy(ifr.ifr_addr.sa_data, self, sizeof(struct ether_addr));
if ((err = ioctl(s, SIOCSIFLLADDR, (caddr_t) &ifr)) < 0) {
log_error("tun: unable to set HW address %s", ether_ntoa(self));
close(fd);
return err;
}
/* Set reduced MTU */
ifr.ifr_mtu = 1450; /* TODO arbitary limit to fit all headers */
if ((err = ioctl(s, SIOCSIFMTU, (caddr_t) &ifr)) < 0) {
log_error("tun: unable to set MTU");
close(fd);
return err;
}
/* Set IPv6 address */
memset(&ifr6, 0, sizeof(ifr6));
strlcpy(ifr6.ifra_name, dev, sizeof(ifr6.ifra_name));
ifr6.ifra_addr.sin6_len = sizeof(ifr6.ifra_addr);
ifr6.ifra_addr.sin6_family = AF_INET6;
rfc4291_addr(self, &ifr6.ifra_addr.sin6_addr);
ifr6.ifra_prefixmask.sin6_len = sizeof(ifr6.ifra_prefixmask);
ifr6.ifra_prefixmask.sin6_family = AF_INET6;
memset((void *) &ifr6.ifra_prefixmask.sin6_addr, 0x00, sizeof(ifr6.ifra_prefixmask));
for (int i = 0; i < 8; i++) /* prefix length: 64 */
ifr6.ifra_prefixmask.sin6_addr.s6_addr[i] = 0xff;
if (ioctl(s, SIOCAIFADDR_IN6, (caddr_t) &ifr6) < 0) {
log_error("tun: unable to set IPv6 address, %s", strerror(errno));
close(fd);
return -errno;
}
close(s);
return fd;
}
}
log_error("tun: cannot open available device");
return -1;
#endif /* __APPLE__ */
}
static int io_state_init_wlan_try_savefile(struct io_state *state) {
int err;
state->wlan_fd = open_savefile(state->wlan_ifname, &state->wlan_handle);
if ((err = state->wlan_fd) < 0)
return err;
state->wlan_is_file = 1;
state->wlan_ifindex = 0;
return 0;
}
static int io_state_init_wlan(struct io_state *state, const char *wlan, const struct ether_addr *bssid_filter) {
int err;
strcpy(state->wlan_ifname, wlan);
state->wlan_is_file = 0;
if (!io_state_init_wlan_try_savefile(state)) {
log_info("Using savefile instead of device");
return 0;
}
state->wlan_ifindex = if_nametoindex(state->wlan_ifname);
if (!state->wlan_ifindex) {
log_error("No such interface exists %s", state->wlan_ifname);
return -ENOENT;
}
/* TODO we might instead open a new monitor interface instead */
err = link_down(state->wlan_ifindex);
if (err < 0) {
log_error("Could set link down: %", state->wlan_ifname);
return err;
}
if (!state->wlan_no_monitor_mode) /* if device is already in monitor mode */
err = set_monitor_mode(state->wlan_ifindex);
if (err < 0) {
log_error("Could not put device in monitor mode: %s", state->wlan_ifname);
return err;
}
err = link_up(state->wlan_ifindex);
if (err < 0) {
log_error("Could set link up: %", state->wlan_ifname);
return err;
}
state->wlan_fd = open_nonblocking_device(state->wlan_ifname, &state->wlan_handle, bssid_filter);
if (state->wlan_fd < 0) {
log_error("Could not open device: %s", state->wlan_ifname);
return err;
}
err = link_ether_addr_get(state->wlan_ifname, &state->if_ether_addr);
if (err < 0) {
log_error("Could not get LLC address from %s", state->wlan_ifname);
return err;
}
return 0;
}
static int io_state_init_host(struct io_state *state, const char *host) {
int err;
if (strlen(host) > 0) {
strcpy(state->host_ifname, host);
/* Host interface needs to have same ether_addr, to make active (!) monitor mode work */
state->host_fd = open_tun(state->host_ifname, &state->if_ether_addr);
if ((err = state->host_fd) < 0) {
log_error("Could not open device: %s", state->host_ifname);
return err;
}
state->host_ifindex = if_nametoindex(state->host_ifname);
if (!state->host_ifindex) {
log_error("No such interface exists %s", state->host_ifname);
return -ENOENT;
}
} else {
log_debug("No host device given, start without host device");
}
return 0;
}
int io_state_init(struct io_state *state, const char *wlan, const char *host, const struct ether_addr *bssid_filter) {
int err;
if ((err = io_state_init_wlan(state, wlan, bssid_filter)))
return err;
if ((err = io_state_init_host(state, host)))
return err;
return 0;
}
void io_state_free(struct io_state *state) {
close(state->host_fd);
pcap_close(state->wlan_handle);
}
int wlan_send(const struct io_state *state, const uint8_t *buf, int len) {
int err;
if (!state || !state->wlan_handle)
return -EINVAL;
err = pcap_inject(state->wlan_handle, buf, len);
if (err < 0) {
log_error("unable to inject packet (%s)", pcap_geterr(state->wlan_handle));
return err;
}
return 0;
}
int host_send(const struct io_state *state, const uint8_t *buf, int len) {
if (!state || !state->host_fd)
return -EINVAL;
if (write(state->host_fd, buf, len) < 0) {
return -errno;
}
return 0;
}
int host_recv(const struct io_state *state, uint8_t *buf, int *len) {
long nread;
if (!state || !state->host_fd)
return -EINVAL;
nread = read(state->host_fd, buf, *len);
if (nread < 0) {
if (errno != EWOULDBLOCK)
log_error("tun: error reading from device");
return -errno;
}
*len = nread;
return 0;
}
owl-master/daemon/io.h 0000664 0000000 0000000 00000003503 13715306717 0015206 0 ustar 00root root 0000000 0000000 /*
* OWL: an open Apple Wireless Direct Link (AWDL) implementation
* Copyright (C) 2018 The Open Wireless Link Project (https://owlink.org)
* Copyright (C) 2018 Milan Stute
*
* 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 .
*/
#ifndef OWL_IO_H
#define OWL_IO_H
#include
#include
#include
#include
#ifdef __APPLE__
#include
#else
#include
#endif
struct io_state {
pcap_t *wlan_handle;
char wlan_ifname[PATH_MAX]; /* name of WLAN iface */
int wlan_ifindex; /* index of WLAN iface */
char host_ifname[IFNAMSIZ]; /* name of host iface */
int host_ifindex; /* index of host iface */
struct ether_addr if_ether_addr; /* MAC address of WLAN and host iface */
int wlan_fd;
int host_fd;
char *dumpfile;
char wlan_no_monitor_mode;
int wlan_is_file;
};
int io_state_init(struct io_state *state, const char *wlan, const char *host, const struct ether_addr *bssid_filter);
void io_state_free(struct io_state *state);
int wlan_send(const struct io_state *state, const uint8_t *buf, int len);
int host_send(const struct io_state *state, const uint8_t *buf, int len);
int host_recv(const struct io_state *state, uint8_t *buf, int *len);
#endif /* OWL_IO_H */
owl-master/daemon/netutils.c 0000664 0000000 0000000 00000026014 13715306717 0016443 0 ustar 00root root 0000000 0000000 /*
* OWL: an open Apple Wireless Direct Link (AWDL) implementation
* Copyright (C) 2018 The Open Wireless Link Project (https://owlink.org)
* Copyright (C) 2018 Milan Stute
*
* 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 .
*/
#include "netutils.h"
#include
#include
#include
#include
#ifndef __APPLE__
#include
#include
#include
#include
#include
#include
#include
#include
struct nlroute_state {
struct nl_sock *socket;
};
static struct nlroute_state nlroute_state;
static int nlroute_init(struct nlroute_state *state) {
state->socket = nl_socket_alloc();
if (!state->socket) {
log_error("Failed to allocate netlink socket.");
return -ENOMEM;
}
if (nl_connect(state->socket, NETLINK_ROUTE)) {
log_error("Failed to connect to generic netlink.");
nl_socket_free(state->socket);
return -ENOLINK;
}
return 0;
}
static void nlroute_free(struct nlroute_state *state) {
nl_socket_free(state->socket);
}
struct nl80211_state {
struct nl_sock *socket;
int nl80211_id;
};
static struct nl80211_state nl80211_state;
static int nl80211_init(struct nl80211_state *state) {
state->socket = nl_socket_alloc();
if (!state->socket) {
log_error("Failed to allocate netlink socket.");
return -ENOMEM;
}
nl_socket_set_buffer_size(state->socket, 8192, 8192);
if (genl_connect(state->socket)) {
log_error("Failed to connect to generic netlink.");
nl_socket_free(state->socket);
return -ENOLINK;
}
state->nl80211_id = genl_ctrl_resolve(state->socket, "nl80211");
if (state->nl80211_id < 0) {
log_error("nl80211 not found.");
nl_socket_free(state->socket);
return -ENOENT;
}
return 0;
}
static void nl80211_free(struct nl80211_state *state) {
nl_socket_free(state->socket);
}
int netutils_init() {
int err;
err = nlroute_init(&nlroute_state);
if (err < 0)
return err;
err = nl80211_init(&nl80211_state);
if (err < 0)
return err;
return 0;
}
void netutils_cleanup() {
nlroute_free(&nlroute_state);
nl80211_free(&nl80211_state);
}
int neighbor_add(int ifindex, const struct ether_addr *eth, const struct in6_addr *in6) {
int err;
struct rtnl_neigh *neigh;
struct nl_addr *nl_ipaddr, *nl_llcaddr;
neigh = rtnl_neigh_alloc();
if (!neigh) {
log_error("Could not allocate netlink message");
err = -ENOMEM;
goto out;
}
rtnl_neigh_set_ifindex(neigh, ifindex);
nl_ipaddr = nl_addr_build(AF_INET6, (void *) in6, sizeof(struct in6_addr));
if (!nl_ipaddr) {
log_error("Could not allocate netlink message");
err = -ENOMEM;
goto out;
}
rtnl_neigh_set_dst(neigh, nl_ipaddr);
nl_llcaddr = nl_addr_build(AF_LLC, (void *) eth, sizeof(struct ether_addr));
if (!nl_llcaddr) {
log_error("Could not allocate netlink message");
err = -ENOMEM;
goto out;
}
rtnl_neigh_set_lladdr(neigh, nl_llcaddr);
rtnl_neigh_set_state(neigh, NUD_PERMANENT);
err = rtnl_neigh_add(nlroute_state.socket, neigh, NLM_F_CREATE);
if (err < 0) {
log_error("Could not add neighbor: %s", nl_geterror(err));
}
out:
if (neigh)
rtnl_neigh_put(neigh);
if (nl_ipaddr)
nl_addr_put(nl_ipaddr);
if (nl_llcaddr)
nl_addr_put(nl_llcaddr);
return err;
}
int neighbor_remove(int ifindex, const struct in6_addr *in6) {
int err;
struct rtnl_neigh *neigh;
struct nl_addr *nl_ipaddr;
neigh = rtnl_neigh_alloc();
if (!neigh) {
log_error("Could not allocate netlink message");
err = -ENOMEM;
goto out;
}
rtnl_neigh_set_ifindex(neigh, ifindex);
nl_ipaddr = nl_addr_build(AF_INET6, (void *) in6, sizeof(struct in6_addr));
if (!nl_ipaddr) {
log_error("Could not allocate netlink message");
err = -ENOMEM;
goto out;
}
rtnl_neigh_set_dst(neigh, nl_ipaddr);
err = rtnl_neigh_delete(nlroute_state.socket, neigh, 0);
if (err < 0) {
log_error("Could not delete neighbor: %s", nl_geterror(err));
}
out:
if (neigh)
rtnl_neigh_put(neigh);
if (nl_ipaddr)
nl_addr_put(nl_ipaddr);
return err;
}
int set_monitor_mode(int ifindex) {
int err = 0;
struct nl_msg *m = NULL;
struct nl_msg *flags = NULL;
m = nlmsg_alloc();
if (!m) {
log_error("Could not allocate netlink message");
err = -ENOMEM;
goto out;
}
genlmsg_put(m, 0, 0, nl80211_state.nl80211_id, 0, 0, NL80211_CMD_SET_INTERFACE, 0);
NLA_PUT_U32(m, NL80211_ATTR_IFINDEX, ifindex);
NLA_PUT_U32(m, NL80211_ATTR_IFTYPE, NL80211_IFTYPE_MONITOR);
flags = nlmsg_alloc();
if (!flags) {
log_error("Could not allocate netlink message");
err = -ENOMEM;
goto out;
}
NLA_PUT_FLAG(flags, NL80211_MNTR_FLAG_ACTIVE);
nla_put_nested(m, NL80211_ATTR_MNTR_FLAGS, flags);
nlmsg_free(flags);
flags = 0;
err = nl_send_auto(nl80211_state.socket, m);
if (err < 0) {
log_error("Error while sending via netlink: %s", nl_geterror(err));
goto out;
}
err = nl_recvmsgs_default(nl80211_state.socket);
if (err < 0) {
log_error("Error while receiving via netlink: %s", nl_geterror(err));
goto out;
}
goto out;
nla_put_failure:
log_error("building message failed");
err = -ENOBUFS;
out:
if (m)
nlmsg_free(m);
if (flags)
nlmsg_free(flags);
return err;
}
int set_channel(int ifindex, int channel /* TODO int ctrl_freq , int bw, int cntr_freq */) {
int err;
struct nl_msg *m;
int freq;
freq = ieee80211_channel_to_frequency(channel);
if (!freq) {
log_error("Invalid channel number %d", channel);
err = -EINVAL;
goto out;
}
m = nlmsg_alloc();
if (!m) {
log_error("Could not allocate netlink message");
err = -ENOMEM;
goto out;
}
if (genlmsg_put(m, 0, 0, nl80211_state.nl80211_id, 0, 0, NL80211_CMD_SET_CHANNEL, 0) == NULL) {
err = -ENOBUFS;
goto out;
}
NLA_PUT_U32(m, NL80211_ATTR_IFINDEX, ifindex);
NLA_PUT_U32(m, NL80211_ATTR_WIPHY_FREQ, freq);
NLA_PUT_U32(m, NL80211_ATTR_WIPHY_CHANNEL_TYPE, NL80211_CHAN_HT40PLUS);
err = nl_send_auto(nl80211_state.socket, m);
if (err < 0) {
log_error("error while sending via netlink");
goto out;
}
err = nl_recvmsgs_default(nl80211_state.socket);
goto out;
nla_put_failure:
log_error("building message failed");
err = -ENOBUFS;
out:
if (m)
nlmsg_free(m);
return err;
}
static int link_updown(int ifindex, int up) {
int err;
struct rtnl_link *old, *req;
err = rtnl_link_get_kernel(nlroute_state.socket, ifindex, NULL, &old);
if (err < 0) {
log_error("Could not get link: %s", nl_geterror(err));
return err;
}
req = rtnl_link_alloc();
if (up)
rtnl_link_set_flags(req, rtnl_link_str2flags("up"));
else
rtnl_link_set_flags(req, rtnl_link_str2flags("down"));
rtnl_link_change(nlroute_state.socket, old, req, 0);
rtnl_link_put(old);
return 0;
}
int link_up(int ifindex) {
return link_updown(ifindex, 1);
}
int link_down(int ifindex) {
return link_updown(ifindex, 0);
}
int link_ether_addr_get(const char *ifname, struct ether_addr *addr) {
int err;
struct rtnl_link *link;
struct nl_addr *nladdr;
err = rtnl_link_get_kernel(nlroute_state.socket, 0, ifname, &link);
if (err < 0) {
log_error("Could not get link: %s", nl_geterror(err));
return err;
}
nladdr = rtnl_link_get_addr(link);
*addr = *(struct ether_addr *) nl_addr_get_binary_addr(nladdr);
return 0;
}
int get_hostname(char *name, size_t len) {
if (gethostname(name, len) < 0)
return -errno;
return 0;
}
#else /* __APPLE__ */
#include
#include
#include
#include
#include
#include
#include "corewlan.h"
int netutils_init() {
return corewlan_init();
}
void netutils_cleanup() {
corewlan_free();
}
int set_monitor_mode(int ifindex) {
corewlan_disassociate(ifindex);
/* TODO implement here instead of using libpcap */
return 0;
}
int set_channel(int ifindex, int channel) {
return corewlan_set_channel(ifindex, channel);
}
int link_up(int ifindex) {
(void) ifindex;
return 0; /* TODO implement */
}
int link_down(int ifindex) {
(void) ifindex;
return 0; /* TODO implement */
}
int link_ether_addr_get(const char *ifname, struct ether_addr *addr) {
struct ifaddrs *ifap, *ifa;
if (getifaddrs(&ifap) < 0)
return -1;
for (ifa = ifap; ifa; ifa = ifa->ifa_next) {
if (ifa->ifa_addr && (ifa->ifa_addr->sa_family == AF_LINK) && !strcmp(ifname, ifa->ifa_name)) {
struct sockaddr_dl *sdl = (struct sockaddr_dl *) ifa->ifa_addr;
memcpy(addr, LLADDR(sdl), sdl->sdl_alen);
return 0;
}
}
return -1;
}
int get_hostname(char *name, size_t len) {
return corewlan_get_hostname(name, len);
}
/* TODO would be nicer to use PF_ROUTE socket instead of calling ndp */
int neighbor_add(int ifindex, const struct ether_addr *eth, const struct in6_addr *in6) {
if (fork() <= 0) {
char eth_str[18];
char in6_str[INET6_ADDRSTRLEN];
char iface[IFNAMSIZ];
char in6scope_str[INET6_ADDRSTRLEN + 1 + IFNAMSIZ];
strlcpy(eth_str, ether_ntoa(eth), sizeof(eth_str));;
sprintf(in6scope_str, "%s%%%s", inet_ntop(AF_INET6, (void *) in6, in6_str, sizeof(in6_str)),
if_indextoname(ifindex, iface));
int null = open("/dev/null", O_WRONLY);
dup2(null, 1 /* stdout */);
dup2(null, 2 /* stderr */);
execlp("/usr/sbin/ndp", "/usr/sbin/ndp", "-sn", in6scope_str, eth_str, (char *) NULL);
close(null);
}
return 0;
}
int neighbor_remove(int ifindex, const struct in6_addr *in6) {
if (fork() <= 0) {
char in6_str[INET6_ADDRSTRLEN];
char iface[IFNAMSIZ];
char in6scope_str[INET6_ADDRSTRLEN + 1 + IFNAMSIZ];
sprintf(in6scope_str, "%s%%%s", inet_ntop(AF_INET6, (void *) in6, in6_str, sizeof(in6_str)),
if_indextoname(ifindex, iface));
int null = open("/dev/null", O_WRONLY);
dup2(null, 1 /* stdout */);
dup2(null, 2 /* stderr */);
execlp("/usr/sbin/ndp", "/usr/sbin/ndp", "-dn", in6scope_str, (char *) NULL);
close(null);
}
return 0;
}
#endif /* __APPLE__ */
int neighbor_add_rfc4291(int ifindex, const struct ether_addr *addr) {
struct in6_addr in6;
rfc4291_addr(addr, &in6);
return neighbor_add(ifindex, addr, &in6);
}
int neighbor_remove_rfc4291(int ifindex, const struct ether_addr *addr) {
struct in6_addr in6;
rfc4291_addr(addr, &in6);
return neighbor_remove(ifindex, &in6);
}
void rfc4291_addr(const struct ether_addr *eth, struct in6_addr *in6) {
memset(in6, 0, sizeof(struct in6_addr));
in6->s6_addr[0] = 0xfe;
in6->s6_addr[1] = 0x80;
in6->s6_addr[8] = eth->ether_addr_octet[0] ^ 0x02;
in6->s6_addr[9] = eth->ether_addr_octet[1];
in6->s6_addr[10] = eth->ether_addr_octet[2];
in6->s6_addr[11] = 0xff;
in6->s6_addr[12] = 0xfe;
in6->s6_addr[13] = eth->ether_addr_octet[3];
in6->s6_addr[14] = eth->ether_addr_octet[4];
in6->s6_addr[15] = eth->ether_addr_octet[5];
}
owl-master/daemon/netutils.h 0000664 0000000 0000000 00000003641 13715306717 0016451 0 ustar 00root root 0000000 0000000 /*
* OWL: an open Apple Wireless Direct Link (AWDL) implementation
* Copyright (C) 2018 The Open Wireless Link Project (https://owlink.org)
* Copyright (C) 2018 Milan Stute
*
* 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 .
*/
#ifndef OWL_NETUTILS_H_
#define OWL_NETUTILS_H_
#include
#ifdef __APPLE__
#include
#else
#include
#endif
/**
* Needs to be run once before netutils can be used (platform-dependent).
*
* For example, on Linux, sets up nl80211 socket and state.
*
* @return 0 on success, a negative value on failure
*/
int netutils_init();
/**
* Clean up methods if netutils are no longer needed (platform-dependent)
*/
void netutils_cleanup();
int set_monitor_mode(int ifindex);
int set_channel(int ifindex, int channel);
int link_up(int ifindex);
int link_down(int ifindex);
int link_ether_addr_get(const char *ifname, struct ether_addr *addr);
int get_hostname(char *name, size_t len);
int neighbor_add(int ifindex, const struct ether_addr *, const struct in6_addr *);
int neighbor_remove(int ifindex, const struct in6_addr *);
int neighbor_add_rfc4291(int ifindex, const struct ether_addr *);
int neighbor_remove_rfc4291(int ifindex, const struct ether_addr *);
void rfc4291_addr(const struct ether_addr *eth, struct in6_addr *in6);
#endif /* OWL_NETUTILS_H_ */
owl-master/daemon/owl.c 0000664 0000000 0000000 00000012017 13715306717 0015373 0 ustar 00root root 0000000 0000000 /*
* OWL: an open Apple Wireless Direct Link (AWDL) implementation
* Copyright (C) 2018 The Open Wireless Link Project (https://owlink.org)
* Copyright (C) 2018 Milan Stute
*
* 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 .
*/
#include
#include
#include
#include
#include
#include
#include
#include "log.h"
#include "core.h"
#define DEFAULT_AWDL_DEVICE "awdl0"
#define FAILED_DUMP "failed.pcap"
static void daemonize() {
pid_t pid;
long x;
/* Fork off the parent process */
pid = fork();
/* An error occurred */
if (pid < 0)
exit(EXIT_FAILURE);
/* Success: Let the parent terminate */
if (pid > 0)
exit(EXIT_SUCCESS);
/* On success: The child process becomes session leader */
if (setsid() < 0)
exit(EXIT_FAILURE);
/* Catch, ignore and handle signals */
/* TODO: Implement a working signal handler */
signal(SIGCHLD, SIG_IGN);
signal(SIGHUP, SIG_IGN);
/* Fork off for the second time*/
pid = fork();
/* An error occurred */
if (pid < 0)
exit(EXIT_FAILURE);
/* Success: Let the parent terminate */
if (pid > 0)
exit(EXIT_SUCCESS);
/* Set new file permissions */
umask(0);
/* Change the working directory to the root directory */
/* or another appropriated directory */
chdir("/");
/* Close all open file descriptors */
for (x = sysconf(_SC_OPEN_MAX); x >= 0; x--) {
close(x);
}
/* Open the log file */
openlog("owl", LOG_PID, LOG_DAEMON);
}
int main(int argc, char *argv[]) {
int c;
int daemon = 0;
int dump = 0;
int chan_num = 6;
struct awdl_chan chan;
int log_level = LOG_INFO;
int filter_rssi = 1;
int no_monitor_mode = 0;
char wlan[PATH_MAX];
char host[IFNAMSIZ] = DEFAULT_AWDL_DEVICE;
struct ev_loop *loop;
struct daemon_state state;
while ((c = getopt(argc, argv, "Dc:dvi:h:a:t:fN")) != -1) {
switch (c) {
case 'D':
daemon = 1;
break;
case 'c':
chan_num = atoi(optarg);
break;
case 'd':
dump = 1;
break;
case 'f':
filter_rssi = 0;
break;
case 'v':
if (log_level < LOG_TRACE)
log_level++; /* increase log level with every occurence of option */
break;
case 'i':
strcpy(wlan, optarg);
break;
case 'h':
strcpy(host, optarg);
break;
case 'N':
no_monitor_mode = 1;
break;
case '?':
if (optopt == 'i')
fprintf(stderr, "Option -%c needs to specify a wireless interface.\n", optopt);
return EXIT_FAILURE;
default:
abort();
}
}
log_set_level(log_level);
printf(" .oOXWMMMMWXOx:\n"
" .oOOOx:'''''''''''':OOOx:\n"
" oXOo' ........ ':OXx.\n"
" .oOOO''''''''''OOOo.\n"
" oXOo' 'oOO:\n"
" :oOOOOXXXXOOOOo:.\n"
" oXO:' ':OXo\n"
" .:xOXXXXXXOx:.\n"
" .xXMMMMMMMMMMMMMMMMXx.\n"
" 'XWWWWWWMMMMMMMMMMMMMMMMMMMMMMWWWWWWX'\n"
" oWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWo\n"
" OMMMMMMWWMMMMMMMMMMMMMMWWWMMMMMO\n"
" OMMWx' 'xWMMMMWx' 'oXMMO\n"
" :MW: oMMx 'WM:\n"
" XM' .xOOo. :o .xOOo. WX\n"
" WX :MMMMMX :MMMMMX xW\n"
" XW 'WMMMMX .xx. 'WMMMWX XX\n"
" 'Wx 'xWMx' OMMO 'xWMx' xM'\n"
" 'XX: 'XX' :XX'\n"
" 'xXOx:..................:xXWx'\n"
" 'xXMMMMMMMMMMMMMMMMMMWO'\n"
"\n"
" Open Wireless Link\n"
"\n"
" https://owlink.org\n"
"\n");
if (daemon)
daemonize();
switch (chan_num) {
case 6:
chan = CHAN_OPCLASS_6;
break;
case 44:
chan = CHAN_OPCLASS_44;
break;
case 149:
chan = CHAN_OPCLASS_149;
break;
default:
log_error("Unsupported channel %d (use 6, 44, or 149)", chan_num);
return EXIT_FAILURE;
}
state.io.wlan_no_monitor_mode = no_monitor_mode;
if (awdl_init(&state, wlan, host, chan, dump ? FAILED_DUMP : 0) < 0) {
log_error("could not initialize core");
return EXIT_FAILURE;
}
state.awdl_state.filter_rssi = filter_rssi;
if (state.io.wlan_ifindex)
log_info("WLAN device: %s (addr %s)", state.io.wlan_ifname, ether_ntoa(&state.io.if_ether_addr));
if (state.io.host_ifindex)
log_info("Host device: %s", state.io.host_ifname);
loop = EV_DEFAULT;
awdl_schedule(loop, &state);
ev_run(loop, 0);
awdl_free(&state);
return EXIT_SUCCESS;
}
owl-master/googletest/ 0000775 0000000 0000000 00000000000 13715306717 0015336 5 ustar 00root root 0000000 0000000 owl-master/radiotap/ 0000775 0000000 0000000 00000000000 13715306717 0014765 5 ustar 00root root 0000000 0000000 owl-master/resources/ 0000775 0000000 0000000 00000000000 13715306717 0015174 5 ustar 00root root 0000000 0000000 owl-master/resources/overview.png 0000664 0000000 0000000 00000251517 13715306717 0017563 0 ustar 00root root 0000000 0000000 PNG
IHDR ,_ sRGB pHYs .# .#x?v iTXtXML:com.adobe.xmp
2
5
1
2
Ү$ @ IDATxw8p
پ|EWfʈlY!#2"#Hf56?^^{9?=>9!_U>T[gQ[P!026dH[1#ì&XT̾ UY!P!P!02*f T5a@@@b
!P1Ƞ +**/@fVTT GUMX!P!P! }A6BBB`dT>2j
@ 2P#CbAUV,8 XN,dsY6bYBU!>?wo^ק փ>f7ys}{}쳄vB`} g
-n1fY/~'~3f}{ E p8M7F/}bQ_+*V|[m2kd~> :餓R'>%,ȒO}S?Wx̥ 3(ueg?/wiH?~_|"U?Εp U|;|@;OYo[p>7egMok- ^ZiI{^d;s(`2L~H/J/]Y>v# G=J G y$n?'?IU@//yKBfa{; ^b] v~ LDl
pwy _|3bx m7FN.|;Ou )2굅u]u7sZV|oSifU-oyK
^XEL{ g6s]-°<9^eCj>}+_=J@3BTcRoom3G (\@<,v[f9OyS(Sc uzSrP uQvg?I ͳ @_xs{^W#
`X1w]Hrl+~}s%/ymIOzv
WB:ts7~Ѓ ?\_69]zg[iV4@K硕ֱko tk^Qc U Ƽэn;־ԥ.7i V2vM$(C2?ϒZ$2# _)_JHYg7M{
@V(A ˂ E&p Xf~ծ/{mc.y{ [iQ Uя~}&Ebu Ok?6mWrP(m(zˈ#|ӟ` GGJhf$_!PDg_yJ"}_]YTT!LRԈA#3Ru r-b%#'
XmaD죴h@Y]gJַFEw/Mb2x_oAAmYg"hd >"
z)
ٓ`G"NozӛFD%(z"x%`%UɈ$yo4IH~p3G~\v \ue @D";Hc'V5 I<}L>7 ܆8L'Y4L $fK7`Q}`?z;ݩlO#~VZnrU Q}]ZXx+F/B}ه|l>7F FK! ɩq*_[Gh^$90D %R"iN* ,/C @]8vm 6bsswPfOZh=lojWי>*q@1cngcty=l,g=[FVF
/3tHBS>}fҗ4Ǻ @ȋNN
[ }Ѥp ^XB(=I&&mas;14C@p])H{l!~ի^e_26NRHVlY<]RؙH6P[l!A,+a~&v>yU
JHT!dO7͓o|8r$pLB*|YzV f3
Jm6cĀY[0+jF vY&O!52+fOP2C$h }P}_gen$;$Ŧ
(DGdz$$|GAy
o d@P*CBda j) }o{"# mu16 Hfz@]QNR0|d=/HPRB|
N@HcR O? ~>OGKY]gJV1t4:<wSh]31<[Pj Ml*(_TmuvW[>8,SLi;Z,p>"lR9b_&hn#vˈSAtQ5Q8xY>ըjx@+!0bRܿb]e$!Chy)vo o~s ]HX;_žesbT4`SN!}(^vV'R$Ok f`m(1c죨n8B#R1)*/ғuȝ={bvhwݤQ'>A;JISasO>! >8V"sٻ1v6[M (~#1 'DI@L*5%MYgP Ph0Hg9
[NӤ9i|g3*U~c fx%LZuH" j
AXki <дHkMחfo7/bt,R:BLLINK2dhDX jg =${qưѡ iά{j*@DE;6@$ jIygys bmٖz [tPu Ued#-
&&=Hܯ h݀= = Ox-lbv^i17YsN`6m1LLί~*}# GYa+X yk_;#bhh=>!| 27jt sԉ7ωF݇õl,! j}8iZ!0?RrvnFI q641l'^L:z٪U,HܗϘ.`Ar! 8tX]$OjgXK%oJ#lRmH3u cԆ9] xiKE8,FqX]3>P{ΰP!6ھd ckc hx+_iӦr -%#^k'<3"I캡^Nsg`oDM~z`k1K aZy%w'ٶeif1X
HWU.HTipaسG;wg
7N
1
,N0 ~],32rBYB8?w @4S^%2;eyNL0j:䭕
R3Lz=/S>=
@
Z;b2S a*JjX>VB#_9B@sbE?kq
fl#-q+'6E2 OJ1IdBiz+\4Fzjji";#MYK\_VU3?{ \@}inhDwBe |h_N;qpNްW :6w`%hZ)6
WmHƁ,S[}z1r:&-}1K>@3ch '[1t*w 'sLƚeUvXIzn֡ [x1"IHAA}>DDg{9W/Ez[NRy*LF'lvsnPHG?(>m|-v!z4-`3Ɇ`30
N`JVBZF:_
!qI^aײ
V3a$S.4cZHc_DByjgЊ;@V AjE%%^Z5W Ei
^D׀`gH7(C]bMMQqӞv_t [&u46r٩'䐒6I# >)l0ҴoW41
8E-G1bx@= Pyӊ!Ѧ:x^ƈ$BH'-9J_t2_7Ȋ2Op3/|H
36BKiѬv}I*Z3l|cEc-WZ>kBVrpinxh'>H6H6@NL ɹj?` hv9Wh us>(Pudd+
#u6S4JL[>aM\uA8$y
pq~[F3NsC 4JHaBJ(~ | H9LO7*kU̓A^͉Hf! (կ~%0څcbŷ#Lpgm<\0W
,y0pbrE,*]xX D loRE
O Myd qBqsM[:<+,mC Rg`Qg'1FŊ,B?h38 5&͠:%fJ]'N^` !h4j"J%MDz'`Icʑ#xeL e?
q#evN'1{ݪvk dv QkpjpB,d m~!{B{ {⏕b`M,x@Y2++)X.fIM,\ψ RO_4- '2_aba3L(HcG)A!i6\:@ɐ V"2mWVB*6[[.CCiÈ6Gt-O]9(w˒+5qQnKڥ
G.7XvJhDos'EO){<
EaTSl%VY .1f>xfl7,lRrCjva @_"A5ybw 2BG w}vi)$C'@'/^-$s!Hu.s "'[H&c2 eLu68ԑBoM,ܢ76 &6a ,Hb2mX
I U
As&(>\FhK A /DTȁ\b2 l7(Va+ u#ӮL#KӅ`, C_mly48bY{QBD681֭ DoTnDh+%đۛ~a2XQC~$>&Ds7 1q'8QXQ8L2n˄ٳubB81r)M F4'rʍ%kfu$(Q9F$,fs*ݪxhA
Hl0l, ־ ]:PUfCBWaIY A>vi4i63;H 0dyз ҄$MkaS.'(4{2G%,49&;sE
M,##…C 5b [%YrX59 Lifei% y5rl3f,:,l,
"Cж氵if!z c o|Gv/2@*.㖈IͺL @6"/=ma)% !5B z tU p6∸[W 'b۠OOX"YKkH{bo֓ʲ% U/Z_f t#u ;V_6.q#^gHhR"GaB4
ЍH6mPl ¶,bȣaU
zli F^fFKN;?RL|87a|%Ֆ6UF,N3CoH!ձqZ,+
FnJ\lD-b"ѝ"5h/Klj\|j76ZbQ[-DO~;VE]0 fXjFQ P?aek2?0iRhliȋL U8b 뒸khGBW\%!k$v]Q٥_i6`'aBě =;^Y8 jvL. 4ʥ,@6
YDޱ`3@6{mĔI؈R
-D!% @ĤsKS@G]ڟ2 *w#KgzjP* މԕaB0(z32 ԷHk_v
dW
|"Qla&zy 詭+Ze0L=o%+6f]4FSHFS}8TZӝ|Yg ̖ɝ\b !}ْ $a4ֲ>K;'4
UP!N b_ՅJae /C\!dJp#r~ƼWJQ%KaٱW.Nd~lQc gPu4 Cw_6ZZk(
H@h>.GvX\)匾aрj[f/T
BٴO/}!+ݍ9IB$z>= j!l1Vu6vǍqvx>|u!1"-}E: AZ>E,= ) x8=zuFrJCL@4tJ3AIA&
"ر}%QcVj$ g ,Zvcoo
ى J);G$ԲSWWh,0,c@ь גmcK</ 6 6~2:Hj2WmFcLzi>2Qu8!C:=bٽy@JKjvݼѮz1K*SɶF [nǺ4bim^TK@n::@BV)h P(9%Dd %g`6(.K\\Nʘ0kFDVZ/Ӵc|z$j,'@X2Y_@6z0O#`{`ĄZDx"lFwS(_
8Z^ p0
] ͬj,1̗Rq>)fL j_5B`] Uݳh}C@CÁ u PW0;4ːNqblul"219>`[1{?@y; 7G8_" s8Hsx~^NsKIm
K$)C#ڬ"( jd_W-oqLTBsq-0kKXKIC8zDS,`RmXr e>i1Z8WhhSZq#Q\)5Y'^x`FMφ.TrѸ o ^0ςHe7oOͼ"1##
dL`2x⦚2/lsn"=|,..Q&3Ja+E4
'ZΜ-T2{@u h]٩eEQF{r;3[9
Udp{VW|n PO.1`@U`; PչԵي1Wt8(:Kh4lkg7g;(k$njeE{!>ȢNB:ńGݦz>i,+ tiRՌ꧸SZ WLKwL3 @dXV4*0q JLY}`'0yBq(hna4N~ġt4o_)A |--OˡGFqZchlkKﻸx5.\5ۤ; ^|2xW3cLz+SS*2Bk YHȌ1|H lE|Ey;.3 dՎi3(Hl{DA,Kg9 ^օw
w,"~]~Ҙ#z
w8mJtL u+uŎnGQ!2Lͅʳ|, 2^C惡 lHzfJƠ*p H(YyUF-bqpbr % Y t6& 'iÍk+U; }`lAqɑ5A[&@F/$DtP2XQX-,&v2 !͆#%b* w" )5 %`2R?J 77Lc-6x5ᮟW!9S/@pKeE Ɋo>vJ|v9 ͑ !F hMAaC!'kSS2 l/0v=Gp!eR k G$"g90*>
)J3'\V0R M2Hjr4JȢ. yk/\k0yM(dLf AvΪ})"mSҘ q $B[8V NԥIb0ɂ:P6n6+
__mPc(aHJ~f7ôxzɷ}FJV*IÛ9fYfq"˲^RA dQ2qg Sz^% q)fxr*s1r> \Hc"SJ]Bb4㵈- '&+J,L,(H pG[xӌDJ}0iv3*5bU
!s 鼋7J@?m nn`vmR%p Ic841u5"YLQbeY +˾rH+JFAkI7fN[ʬr :! )ʯ6fs?|BZG
bUF
-uQZQ>qO.M]B]ĀMwb%0"b6umnnwܔ7QXO r\_ -jDI1bLfti&W(:j 2_+=9fgfQ2PlB~kkph±,/*:l]#J6 5Ҷ\JG.JPy5 7-
Hh RG 裰Jֹ,{+(g~R3 `W顄x VPc[N^E( g4Ÿ>"]W2LjDbL-bR뎀49Mog>;i =af9LY0y叺2}#Mf "I#hD #BH2s۫+JE.Ѫے@|
:X>(,ٍ.ⵇɢhq9JˌЌA ъEE7&fd%Yl|*4<$6K|U#7AZ'}"e00mڡj!ߡ!Q2(:/nsg8"y241g Bk86য4DjIMnt=.
{}1T0;ˮ鬽vيʖdXTrybFA&$(,$"-|㓘 Tvvڨ덦Jvt13
.' o1KC2 * e6Za/~A jPB H) l;Q<1D
.) Oez|B Cde¾@;(1tDضLL2iHbSР9vUކIY:_V
9SWH)avy<߈)5\!0°[E>cwV1{'Xj!Egc.B GJ)e7gH XQ :+Rqju
_l_Wʮ8 IJj \BvvGXX-"=x A<zj~f\wBHy"5 ; g!5ym͢čzXu=E
ݘAN{i"g!/(|@.]
XMbw#sܲ| ٺ_Ĉ'E 6j Nx͞x !0]3qPjLٜ8")txpFd/R0)/VIU݀T_+f*xgQxUW٧: OySZZ
v tNr
ȸEN3cG
},z< aN 'n-#IzD2|\Uona6Z*SƦZkg qW5ʈpfqgU:"4jƅ(&Zaik'bUaXJ5͜[QCI ;T.6čNp[v(i}R=Mv4kp+og,DFi£6Sl
2A
3gR.G0OC L4Ҁ[5 {._)xP7܂ 9i6Ofjy@NBʲʩW\du > c2`@]ͯ50
ܰ\RV}poJSu~[_[6eЂL <]{7>%ZƁe=Xbr*bJ.{;ѺO0ֽV^v3 i$Rݎm!YZbjK#uopmRB f9jD}\NU̾pCvFIniela;9i~
CC!A;qW`m.r1\+{XX3˃Z:ŵu
{R³ ]>U̾Hhkzp TVL5yW~-y T
@Y***UTT ZR!P!P!0}6BBB` T>j
@ᩍ[G8:6V]!Z*f_-j'Qz[\Ҙڛ
4[op;~K?]k+J
@5 5k@ka-BBB` P1|GmM@@!P1aXK/T>_Q[S!P!P!vT̾v*** xTTT
ry _W"!F 5#kBBB` 8}[3/P
a _rӟ7 ov./~|@
_+**dozӛBmݧ|;?Oof;Ｓކ&~ň/AP (ᛳ,tGzp5cϱ
} ^7vh0n,9}/]W0W
[Vo7}1__W Yri$+\v+** &7v=uP X_W ]vd1{W3rkBB`Q p+\'>q wO_ze]vaniCμ]C2 N: ^1>?3#?_ή دqkT3rkBB`Q |^ *^: {q]O|k^=}7;7] ?NBo_Z!4#y CN jVx7.9_<:l>
T>N}s ʶxsV1P\}i=_)=c XÞ}
X tAH~8m @ IDAT'|r,+f 3
.*yЃ gPF O~ӟg?cǀ. jp*x?ndk38?s_h 10,O}S W'?IJi}O~CߗW ys>uʴk_b:]RR# DecP^"H @p(Vl4H'Ff~ fL<*鏎yl
4ZԿ-ܲA
' u!H"X9N@N |3%/}K W<1 ݿmocn7@4-fԣ \Ұ$G.\l䯯 xt/}i>|^64,ِ]JWrʹӝt܇G<!wa_-hӀ-`va%{ r ਣVarc(d; Sz'tkhg{cC_L<Kq ,INON`]l~킠g_o nֵntlJ1 G8ja; p#kĭCFͯKbS!0?0'LӜ6W0tM ( .Uz#!e
~wz {Ѕy}ֳD3L>sG>IOBjomj~#[|]K kjbP;(^]P4rknqckiO{$ݒ ko J 1&
)ao%ӄ6W؉7PTXztx9_ik }њNm%% ţ"~v¼#5_%y[ڑ:^ X58n4^5WB op![FXq-5lT_$Y!hGIR`;"@ *yf*rX}U J6
G/Ge
NFwzEfD4rs8eY'>H2rae\,y<َ`(B)6mlTyV> H /4$AxYB#rw|?k)o2~١k iajй ݸ TT{b9c}5ֶّz=4|ۋtΘ k6 DR֙l8L}DJ j0y.? i P$9F|E#@`vDvLnvT"^V _ReCؠyi;zi_W0z fwوFˍ&r#2_7I8xUAX G2ӹ;;cFD=wxͶ2>rX,3t`$oŞ!N?,1}e6FX-omgـ1%րxa`x˔%Ex/? cF|eh|Ư=`p/~{ᤒ=Г؈M~V~uM+ {oU;2e'[wZCV
;V\ 2¨|3v+=ʄ.um9l 2+_
KzEv!AC
!yU)
} F;x =!06Kd@z1R/T"0?H?}[ӈ
Ƴ{eEFEjyӟNP~a 缉C);7"@>}a0be^aJnuN *Y1pv
7C e|#҈A;cpm7{ut]%%.E@0&+i2oF0v '} N)Ǽu!榥[LP
j@3#0Ab5{+L {,IK !k{ rR " r`ϰ*o!2#F2/|,YjPur: "fD86%_`V, Ɣ{Sb JL7M`BK "D<+fX4eӸ6I. iC
47
$g]!YD<}Ԋ}>ɂ2"vcb?ɋЏ^ }eGzH*Rؚ'%$O(G7QTv`IbO% 㖠]jaO1鏷(,2"L, #ՙ^ZbBaޙEʔn3n&!0minklju}J|חn4!@el8*tޤ0O>;r Gp7x_`sC.!d6AM@ "i L3 j@>Elܕn2t cḌibI$!{Xbs5RZTaʢ:'3 }r)#pXqv |)Oy^HK'JZp̜`cL #!a3yj !Y,mQO0l<=>$%t~H%kk4V;1'rd >e34XvLJP"̵|P'؉;kSa&
áؙwN"-Wq0O$+]>aQ)~u6b:OQ.`Wꟽ25~ `
k Ԃ3or'}5FTx>|d~a2icvs&"nNp lX9kB`N `~ѾV3$ )ic_ UR<(3F Kz ~sKliqLB"ޚGP0焒(ڎY>J "
LGI?JׅJ\tN`rt=qc-aڹLgwN#jYʂFڱcNT^^ll8RHM|p~mqV9cfAĆM4j]dqG}6WN]RN;
Kg8Tp:9'.mN] CZ + U5xʼn0]sڤYBy7oK@
p <=`5w 5
ԯ3w#
4
VR#EW`UFBD Ӄ@>$ۤ ΑfY91!&DT'|\?LOn8oYH@3d#ie' ԄX2cI(i'">32ƍQ^~>
fgڔNS 9 tIA{}\љ^kGѠF! I1<AMC0#<&!31(Wpn u ק4&ȑD;A>4 ɡ0ycdD
qöKIL,[x5K>ʙ Ɠ~W`s)m6)ٶħ30m
J:D4>G fOX} vy Vu9z0! A`\_SC:>ݬ BFSilO^!tQe܁|E&R'̄Hp{I^1~_+S^1 (%)MFSFt qDEJ(Mx6 ~[8C /daU "̘D p"L B4Kuu 6pQJ ,
UKhc 鰙7t>h
g4"ҫ<.y]Ǒ
=G"IG(I pp^ ټ;2M;p$;ZƸ(gCt% +
\d+ B'LE Gu
es6W{8`$H} Fh~Pd ]9J8"GvuꠒZO!,FEԒ,$刯%7e]ILD!idH|w=*RN'd )Ù >\W:M
R
c2Fy!C=:ܦXBi Nۣ"yCx`[A|P9֍k̓(ڃ]c62L߀Cy
Hf2
z1 4@ !2"MW$J@z Oa%z*f⑰K+ @FbȔRr9DSBo (Adn)ꂪtliP۟C @о4,\ \p
ƴsb\h-8\묝(i;Š~ɲa=АUI7@ӭ(-^.!&( aIɅ`a
DIBqʾbɻV5@[ v BdYHM&d˥,/Ur8wq3!_eˤܛYٮ:#e)8Ce ̘E ÑQ P1E_r ճ轫_`v M E
1Я}IO*jA9dDQ
dJU"/c#SN SQ`l6' *,~
Db}b^Vu X&We2}gx]a<*~Զْ\Z S۱`p]6{ ̰A?ixAYK Q0Bw о˵~M zhqMYB9;L!j'gG:k1L_=#f ~*=r7e{ ۄ,+a0e> KCf Ě{ ታx_.mL
oO aK쓃v[ne3t!;(Jo\~
łNycHf A#Μ6Jx%q gS4;KCFp\F
, 9yL. _ Kڅ ZPRwNZxPq ˑc݄`MEE)Ρ-g#>q ~%@ WA:ݤ%l 8# 2 p+#h(9L,! 3aM ̉0!
4W]vc p7R2cvKٝ(@Y4?ksn!_!V6n8^
h@d3lG4>mWwu < < e94Y6< <qn9n!.S-'>~n-2/4t eqVL\ ~xg\r̮a(0
~}qN˝a ㅇ rԶaYUx?vJ \:?
_gƀ C'xⴽˏٙ FɌ=AkA )˧sN;@]TƸmBd +.LZ&L ٿpֆso,Uw%x3P< yK
~ uS;)?9mFrF\ ᇫopmqm'[sx߳5D < #9?.[1WiWbza$g oe1d.b͠,8}ݙIuhSǵ2 ;,D^y^Kn xU1\c+@I +q^Kͼ+"a^2^❽Si\ePyE ў)r\a C q/swC I6mV³ 9M#sU,W
vJt:W6td Ȯ&S>C7OP!0}hN9Kg ॄ ߲^" Y}±%$p7^--آ,~ >b_;Kd\LDK9{Iwe"1m9f*Vq[Z;PK,:՞T=f *ӹ{9jB`0kI=g3 5
T|3
N+\ZS"Hۗ#&{wu
64pJ8A/Maټ
{
T'O^i B=u Us4PgƤbςO sfWE%$sa%XkxN>dԱ+ Z!,dlI ƽ(c `vE@`fXzt' j B o hvug BĬ:>cM{RK*BNmN$PnvRd{|*3Er0"g|ZֳUME9ifV\5cG}\=uO}S ɣvmEANy4, ;q^ y~x@~+Oԭ
) WhF6'FYBpzPK^;O ԟX~e[ vi'D:O''>on5Owtow2⧐/jZ͇}"q} =| ʝYׄo;Ao;JKL`] rF3S9MѲg-헮o
o=
:YU
yYjl*;Jl[ä15Ate.AnC .3RzIQT sm R~F`]vqMTT݈acS7'=`0&rY#cG,mܝ6visҗ5̼o۶&0,OnO Cˬ3?<YmȚѪ E ܉@ ĕcvX;ShSRlRm]0
53kItlaÀh k/Qq#w`6YK,]b9ZS.1,]>8)Y
%? EMx62 [7 0{gGf
Y2{UjOB I"+˙Xaq͎Z,13
Xc9 2}5)Y礢iHc]% P7nmT(cD矍a,\op\9pJ:'gLM6ۤ={qk;NJv]w%W yKɪYmټgY!NcEt|$a4{$NiH3\Y1}]1fZ1Q~X{Q%8NIi*8y a:8GSpn? >z%eJg@g'=_ٙNL&" <+kh" O tI'
|v.W]bz-wK.mjCd7 z4!GzʊH6Q*";rIN(dV#|;z
b-,89)%Y녀yd ʔRbh>`"~3Kh
{ɘj5L` 22N 5Pp3eeaùFc Rsyqrp +0C#s4ʇ: j:'#@W}rb1,micFEʿoD<(_,*PcS&*%.k O
CNCϣˉ P\:a ,,"i5U3O#ݠ+|{. & F<+rI̍]:!} s& #E[#VT)( y-7N1V.g">Ԕ<IhXUzU uQR:tEqq'"N̾+r"WtDb rr@hWUI6$D7o#x9_q!tcc h0z^C
U̮8 (O
C^aFoTp Ճ|+aOV8|B 7 Fg6"
@ʱ-eLQ]'zJ!.4fҘ@FtA)ZU\uJg:,0l(n`-5G
7f
/L/hdbܒhZބ;Kg!Jx6Q3:E4~/p([Gۡrfl; 6*mYE `sg¾0=
Dx}ΘD+` wx 1k,y m t- I34@UֶU' p2mҗFg%>vJql$fG:RL\wX|∁4 >( "-:?t|smIw|MoMhCұJ 9-YEDZaͶC)@6o}[fm`QEHګb{I$FVI |U8-"ӯ#6ߠUp͍(!olV8۳31;BMc5GNܱ{jj<'[x-mEYRXey` I4J;͋o[dSa;Ֆٗ #; x'{(R ۛ(^n{4hhԫ:1VwASSiٍB*T|KRY/x<H]iBC t6i$qa!*hC kt )!|
]"J@%ؠǣ1Xhң)M&ET|%K@ o¶j(d-xQq`DO@6ݤFOA$a~ PaI `&h =R\zЃ$Hb?ZE_ Ly 6 R39:2d[.e}B lKh(HL- e6?Ojɒ;НŋaE00Dل&R?r/Kc;H% f=(AH*})M9B IQ]t{|YHC"HBF9Y-1P+'\1 #E0Jy"z5 M *ͫ +dQx V.ADF/B%p)$hyn Ҥo<46ˌs=@,C" &@@M"Fi"pR0'ۏ-Ec0,>3ÔvAQ,Z& 5`ƮUeKrobÁcC;]|(~{s:kk\˓^q9 x?8,"ŧZ&8 (.j8%F0(@])gm(Ъ?m"
`j$3 #^}JVzJ/q"Q"KA\ dɨW|Hxa 2`FFK|-k,R `|s
zD]n娫X(M_[~S#zRlv/e;ldI Q}-ShIdQ*@5k`5р
ClxD1+d\ر>'Y'z Ԩ[hnwn|,x(~ s#0),+6~P ,{
?cV*(NO[/Z4E Sƒ, LY*MM5@`G2}A'jcA
Ud2 jiQ:fm;
4Kr`NCs/ Ng#aC=Ț "\F<O5GU%S
ta<
z 9܀Sv\RHRo-_'|74D *vrdY!Qq:Kf^T6>tnߒ7xJ9i\#p_-CS$LߒX Z_{`J 4ܝ"&PX^[?NnHƠT+)`YǾ3ՠ
f& ahrlE36v%džɊ iI<(ͤ(6Eߎ*94 !ep,O x`( POՙ/u M q *A01 dؖUM8C+H `-F E]A!e8"-CW,N L!");
((r3=+A\l6IcsJq\56f#@ !Fo B Q{
>0S_@VEZ[6'm&ު-Bw
^KJ H\mݶ2 ٫"o& 4 /X!P!0e P;9H?` %>#Լ@0uOk@!ʈc>՝#v n@ه᳁rr/
E fڱXV 1'!tt ٣Pg`')9^[MZH@!6%L S ~eE F!|yJx[5 6].Ԗ/:P]|@9R;:'~}][ J
D!/ R.u".A!5w RWذ
!L /`,VC)cܮW `rhr[a}mX ^ oRζn _IS!F8(DZZ^[ ܢ3p ` JE4k ك`wiW>\#@BB`f X4nu85l`Jwܤ"üoWZP蹬kL
µ
CO~ŕ8j'gD+y0{4}Cx~3eDE}PY(ЬBB`DDJ$αlQ =y# }-, fVӛ(?] .8.k
dJpA IA
#z !WT-\G }onTu
@`0{J f
UKP q 8jC6Ek7pjO vU:9t 'L
WBq\ |K\B]I ?zvډ%h}Fv0{٧4Mݣo}+ w^7hNhPfܪl\k* W\33AQw}WT g
[Q읕Cڰv| =pMٗi-P_8G}.PkS+ A%*ހA o#V3 W\3 TN8UNv檑 Ϳ/o V=s&.ߐu?%巂e ,JJݐU vؠ}|ەfoäT,( W[YoDژ^{d}tTiL'6l3ۙFV!o@̞J7;po#V3 W\3 TN8_RzsFV-FSlPGgZKT!04 O>d c=jowy7wӝR_+fyu&7ɖ[nH.w88Ag'>'G2o)Se=o
[ {ߜ?wmuЦB$Z{@@`Nivf0m&}p 'tv[6x 8acG[lqnw V!(if 9(#AC89f N6_+;1%/Kk~ٻ |M U@CoaDQ:H(
B$$` RP.QBoD" A ߏpXn{Oy}ݻٳٯ~?@ׅ+VRv~Kby০):+m6䕣d+ļ '|Gg}!LT9Y֎BlI2t VWo~
g>ɭy1nQMnr=q7
y+_^1K ~}{8~D%
B`$~Us*6 ISv;čo|]jȶOt!Q>#LH &v4WsZ;/ QݍQֳگS%/yc [ft2_W?)O)_M9]y@?97_'=q\U>k?\2&*+_vuNNwwQm$AѮӉ(sUN_H^{^E.ʷTmTpL)r/aNG _z ^L LwP4twF4H48\Wm ;1xX{O|w] gmS׳//?as$+|c g>=[ħ_W6v[/PyS@|ԣ %bE]4ZB`9 {
esg'ErK1s
%ԅoϱW@tu:͆ =AO}S:,kxf-[HI!Fg'<5 u\
vGa̩yyh
$/?Fٿw_"ubCf;0$H`QXPxoo
ap ??77ÑQϬ& pk]h!VߞzW~WϪ* G JڰO84Ғ~^gZNq !ռԦf}>͠( @ IDATC3 !,%y NF7j4 mD` pdUzW$jQ¾菲@sb8Cby U^я~&|w3a~~jk{ _XB!
L͞(3`a. 2պ`SV\_?8]+y ~A H:KD0Xjl^haR a
(|pK" B; TPc9waG>LQhG/w Kަ55ݩ)cޙML$BSd//<OOٟ勚 w$5j@XWXނSfFO9唐)+A:R
o@)ßmYB}'~㈓V؟H4u Cny[R4t
nkj|˿e/s{(ik_Zɲʂz'~'2?['@z]} ;H˯Qɓ
,?ZƱ5袟08Ν+$SO$5FWBO 3ڍtC%F3]Ld
;+1K\[uB 'ek"; דMt.e- M v_g) FtַՉ!Pvl#{©Mëu?QqO܃
Bv7w1HCN:'qpR#E%lY8'*tlD+_"*xdcQ`|u ,Hz%^D*_*W@
R~ȁKӇ w̨ 8
q(QY(rEdr?-ϒvӝ`5) b8=(H@%Qx7Dd.gj۫}k#ؽG q q ]ab*f4p#Tp2:-TrӛTa@ŕR@ؘq1٨E7.|;:ܬe).Ԫ3R]YUPe[eh!sSBKx.1'GG1eI(
a 'bI3B!>W {j{!.t
r"ډmMM'c[wJv+hY}-<ZoZf7MHcK[ny8f^ #$;{ +pފQ d Jh}J#:$'ֈ)) ,*P $ G4̣k@?
;fIJ.'>q 5R.B YC#k^ɔ&e']ukMېEC TTdYl剘\mіcwwk< Xv=cx 0鶥Z7Y[Ml ctð;N,C$:(`?R/ Nt!3N'sv_bЬ. nA]Nb UY3|6?Z
?.H!MԖ *LZWZ`@jˠb{JOp+,
|+:C"
$s敠T^NI'/uAuľMX9]q_,nckȂbl TaO4vkb[ ICE
79 ;C8*ُ`SaoRdf_vK od<~\ʷ2m茍Bf-;{~Go.an@Π%h`Ɖd| ތX}@"67+G# {a`)ɲE.up1 jPy˦+e/Qc!]x,bq;nW*)Vkcr[Emeffcg+s=efo1im,
SxQ! S_vR5]!0
%d՚BF2A4֨F@wn{F)5 G0uS<{ $6x'q VJKht(0oB g=ߣX3~//dfE^^a+IWnOfWذLN Lk uAN%)2n- Y ͤFD2WL/e .z[iy ͵Y<"{ީXGfZgVdcaejNޓpoe;V]6ώAeV)E* dCP8jb ܥ9cph͐Nߵ
`
s%v,(PZD"*IsҢ9İ 9pjv: >蕴 c<*sczS+U?څ:6UVb')v3-ڊI+g3+1k}cd}P y[LJ9ϖgp(=PfĞp\&~Δ
47R*6F
,(ZӒsVx)8ncӸiˍz(;-:H/ςίs.!8c|3/G<ΫM'yLd;\WRa0OXkt<8D $F#C9*o ,:`^kͲN1
.]1)LV(rcZLfP9E_ ""~~TLB1 Yo_" m:ª N> }WMUؠAmbڂGa_ŖC4Ԃ`PFW@
)[ Yܝn߆ RZ1\L`nq[ljp6 uΓJD0&&" 5FeG]%q2Z07WCp$1\ NK[P@ّBޓ( yL&hi @,XPc $s*bҕCA4kAEhcIph4 9K־
FD %~P.l((lH2$=3ePrC!n!WfcB37u&!Iųx4vMp>QȺ'bw
Ŷm}7B*/3i}P^_a\u/e0A5?IO"" 1,}, SP;"ɘ5=iW⫾}|6G·"6+Lj%4J5!Dm S5ٍa.ߞ p4@ : v|W11LA+o I%Ey5 hUAB&vƚ3(<2NsG$fF0tq&Π |:B'qyvTcgQ+cZ}:yu=⧨|ۣi*lYkj.9tSr?cDI6dJZ\#s
vk{3r^)V]SR,Dc#OU+60 z$4Jts[eA9Z48 ? )Z6&ņO 7IS-,q9CYtXYSz4
Q(CW\h8
gmQ (Im]xE*QR! O0 mib Ҁ%.P) .ȯڜk^$@ W
{jW~K)bl07ع;Fa{JrW̜2M͇k(op/31`J,H{(0P7)AŲv 554u7q'1|cx8# !Cqi F|Y6'{N"Hll|UְDL-:>!%2tq2:O*T/#]KGN^t}W.a_H1YL!J6dF(ӞKG4p7UɔױN$`ϗH}hȈ< Lٍ i̔|c1q`ڳ_V;> 7`|
+,aY!`:4{¿35YSBLKōp;˚Cd
}$?r}l2+GN
?O
2}mP``͌ƃ4i}Z鬌ˎKdO,/q >Z~N]$Y|G3N 998W3c> s]H `vނ;QYBA
] g Iɏ,rGnDN ;ai(xb
[/dp lPlg(_0u8Y"3%l uQ>q| wm,vZr$ IA!5Q,-+lacѱPfg('vyE-Ol,%v[)v7SF Q*
9Sv
Z""إB~F\Pr40 X$;F&'P6 <$MTcH"ou
Pl12|\Ve[L 4
l axs-
s1 sPY^b`X }bbAU X́iҐ(D9߀*",Wɢ_9\5!2p& kÎ\f 25r!0eLHko1*Xv2mr
-25YU E v0+B50+-`8"Xz!X] u.v~]Tt!,PvU5Q23J1OO֭%Ss
(Vqp.V6:2sPea870,kL2сƬEf~ g. }¸
HH!ÿ]ۑɸq #$섍%2(ʾL/gYt#&+s" yF㤦f}H6LȺ^e. ""~F^ n*3Uřeʼn >g4!X*:!B3.eZkkpRS3e1; 9rc/;i/pH:lXDHoeCX*|羅bwn75 8}33B䞕/] -w9jNUPF)3Fd\[N
1}Ԉ w 9lLz3W(@߸Q~đq9șMd|ZtB(K4EYr`pOT8 @w wmbv
rd* E 19F勁? So-s Ux3F
K=EN8'"s?ծ[%E鷦We9C͝!BḾC vyYJGB#!t+ M>Pl^a&ʇS)A:
Ia8庇eT
f#=27*>ڄ!}v};>A 10ҭ/S: 7Pt^a)y =Š\ǜ'}:ąpUҏ`֡7l/ٰ:}KvAS
ηAU+FvVU#Z[wVEd#_' 0m{nc㳛=Pw]=0}5_ P{4B aT zB[W8LgqY6\9>>`dfsWm߇/:V>u/q) H|ŵk]xn찿O{8ƀ`TvGM9}{./t}OXu-=2})|IDܔ(J8hʯB,\"$QJy! %x{_A?/mێBJfu!tW'W@={+?HưQ4
Rg!##
vqIg我b D/jU+I4q<>$!bk~x]~:E l _r ^ramEqq
F)Rv1H Y>z8 $aĪVUB0Ғ1 k?}VoO~D[!9/OU6\ZObfpW93> s+ s(/e8)~Ψ82Z&b:(:bv5'e1 l%25aBq"OoG I>g>N4@CWAt8i(J +Þ +*, #Vj
ۅ :W.O!dq5tB^HWR5T]?ۯE.]6[ |zj37=Q1|XqfRvoG=u&LͯhC HUk@x2G D
Dv8fؽ"O.FHFpVn@+K'Fs=~ fK: x BFD pVQ|cQȌߨp!Cܑ%F Đ}b]gL\ [ Ԯ5lͯY 6ɠ_@nv MozSDdW:3ktn
e-J0 !w =0Y_5E J6%?s=W4#<^4:Sj> :;au M;bsB` ,z _g;k;xϹPv
l25`DpL
5z^u07 8U "=;sd\9 s Fy8<%8c m;_.S f W &Dfuyͨ@{2~ C㾬LO% eGFK,2
uC3ΰ 5? .Îk0. ka&( ONv!J/6>lىА2h&$ޯuaz%Lg̼NgWEE4e'dѠ^
٪3Wӛ@0S,fzt+Aٓ,]?䞈 ϜNJ"sl
h$=);:_c,:ISplg=p`אWLc^cL;!$zN¶OX&w 5n=A\:b ClJc|p;t9iʮ9.A4 z
WTLǂ:r.G < ǀ̘JL?):% n]h5'q NOQ"U}x"
>̎7Dl-(0}Co>! ;c jW2uN9ȵsBucoO^ͩXP6B{".(L|:X "ȁ-8+ 4{Svf%yB-V!P!)eOh\ ˁMPG@`tP?7LRNSmX A`:TB;d @;5ngɓt:
3 L۳v07֓QZn+76EPڡP.wL q\o%x'eo+
7q Xh
:a
LG-B`U(<@[ gjObYx. Jd;'=ItYFg=Y{SvER/,l!c!IIU rE1SS3r?Xc]t_2%qS4m#?pw%<;J`L ]X S*Xq Zr(=n
|I7`5WX h.S-e2})FJ-
[wW9 镨>5u XmUN=OHonި(n,SQUc?QOǑ
,1qBIޟ 'wfdƐQ:# 1?22Ġ&R{9jk
@E XST#|rW1!`=|[ӝO +,`MY22/-:W 7C,P37 x3=+lȑ`wwk[̎~dNw
ÞU j +-s˥?яzG> 0nn :ɷn be\[
p+6G (@A ÿxίh *5s z1kB`(mMuiO{ZA\*s)7q%צCg
=C?.7 Y}φcq{7p_ל1F\
ʆqc
Gi25">Wl,?X94ڍ!Ҩ*7aX^p}5\84 +)f=|^qG2wzDpDu2 #Yx:SzR\@=
Эp w5 'T 'nr6oϹ|\Ɂ/Q|^ƭmO'> o {l_ƊuW7 `7⼰W
(Y GB w]yȸ͕@d>z`WZ U8?YI}0\>"5 r䖝viN1 sʡp9>J.#!':f,F^&0ӶP) !czk+#w̬i"sX(S
#n ȡ:k/%1L _B \ گTNU.tſv%̡ =h$gUŌ, +(id2 f;لYdZ |79HaE#U%ʹխnXa=\9W F G$NXE*Dn 0@8?. ct梦1{BŚ25SOKD/粗쵯}L:P ܴ]~aQ q1gg:i@3' Hn5Y3{Gv* Q߇_җ'ϸ}#x,ZK]5@Hy ybBY8B![ *]Mul5Dn/ J G=?4:Yֶ~іH*tnOen FPr)"p_~:3x r\߄C16?twa(;qhTH_;V=с#B;@Ps9 ^pi(ËU h5 I0c&=1]r@Y/o7sJ~և+ ~ W$ ZXT"㐂N8K$H4?vB
?6);6fm!fG[i014(;~$ٖF"؝%$h5SR%ݙO@ځA1)ޖ%TRhb_BNI%Ko˴tJPjiR1zt]+4_TzkWh&.]Mgo Xr(̴t[")y,m%6r-]=LY 90WVsnaq!ld[,ZJc@$HgAL(ܱ ' znB|434{sL\| 4 +*({?%
7Е&J}oVsT(= <V:lI=?Hhɪ 3+ 9 V`Qv=@95ryP$p`0ˉLpydƍ$U ސFt#=R\,'ҫbҖGtɣČsT(4
Ŵmi-*lPj楣!.hf7ZCE0hg{蕮t%/ 2#ĸ/P++1k ވS O"Z>< ǐ<9x@i먁STbG~Sn(OļA`cco]uSW;OAMߋrRS҅wB\b1pD).~?eV[
4!bP0a Q#nЯlx6P|%XO(tФc8髤̇ʡ!(JwA3
O5^a%^Oga`_GAp| YW+h>$*kZTZxFUjZDYN2Ntm|nkc9.- qt&0,%;1킼 #u9H %DC1<)p@bbYjo`gƸ։Nj%
Md+.C^mjzBʡ+ H9Li N_#څJ'5 uhEΑ
yh8Sp9[t4捳HeɝI#OudANbgځX;1pr7.XEDjz':V){ dj @_LvZZ2*h`Gx c;<n ˉ[dcr@GFsMcL`)?qX% VކI(LEdGI f7I'}krK1ISF8~4py@ُ>+eK:7Vև?vxF>B<] 60T8vIe[p"\u㔝E+h@P!ST͇ ey=l FᷓHk7
FN2@GAJ$S]a,C-F\qQO`+j\95i6JdiA#tΈ/' ezI?> \vTɨWh)˗i̯ `
D)i _s<-T.[4i&+bCp]Y9
'Ό0GˑAp(;_)N]pvBO(%NPsF?&=bB/[ZQ _$GmJut7PAQ oZf4pU] ˢbZ퍯kn*AGbd
[n+9
)|Σw\m
%Xo$J s6
g W.T7;\P`ٷDבm bP]9 OjQ ^1hxvQ\~&˻> 2{\\qxABH In˜NgL bᆉF(Y8*L Ie~r+#Gz|f
A|uJ_Za` @漫 zPf2 09r T+n5( xE?~|NJ%u;3ƑYl@ϧQC}7aL C^9TV\ @ՔEy4\#b
蕒IFN9:OmgtemC2g4Y?q ?,.2t̛8wPy;L
'Xzf?摮uwzb{O(#=ALrn})uؾq8:h g) ŗiF7
{Ũ%6)3!/'equd\+ b$Z-Q`*PbhO] ekͯz ύ{ص~zN8,&zKVe3&ͪ6p[=.ͥ"t r]HNl4NJa)@Riw5u7 K'TёiГ΅/H QɨJ;fA8 M t;xܨ$ x"rL:
{
\7ao V-tƙ{/ry1TʙqʽNGæVJ6̶~LP:}cU2NHڈ[8Ldpp: 9ؐ nfk)F] N.EV2xCw 0u7;G<#S`g
HM~0 Uۧ% k?Hv=w]2M3_K#m;/lhLbG$VY끰4A9&Lj`p [K
[(}EFz
P@220@\ 9eگl3揦> am<0,RalW9EZၒ}5L> < CSKHq6Uӽ34GZc-G(
$+8$^i[" FPd-`ϊ
o-z컇=sC/:e0Sy-
%7W PĐ]~$ _Wǁ)Y®1EǹrD}P:ڤ@`r gm쾀FW2 ܆m|K8Hl/Bmך֚(ml xJ(."ޮ*Nn"H~h4>TeDRy0hqn#QT- ###QC X"3To֚"~*&#D&` 岫|w(vr2qaCҸQ|wlz! ,寵m
Gpy { GyPL6 K&( D gɯhM[O :rSM<0v#-jmA @L,W{蠰 ɾ%|) `. %2E~ 5z:ػh4H
aiB)0t6B"w Cq`
vHI R-~}Q a_ƾ͇\&5MI9 BB#G :a*uTB<_a=ϜeQ~a(ot$"w#R `_1*-ɺPmbL 5"ַu`-<_X~m'fB*5'$8#V(ͽ 4ZOreow>M Q(L 'Koɉ̸`=6 d7 jNM}\$YDL3!7qj϶bk:4ղ¨~QY0!/+\sYxU )w!;
:N)䞮 m*{ ȤKe:EN_:#t9 K3U~L@,6Ǵ)730s^n҇}i0E'6!:s)21}+.`h9]/ jʂOD_ .Zxhvl4$7vЋZA-, cmYg9 Lh-1%
(Wf'S`uc <>1|jzic_ki>GMn$(Gtk9-(؍\zC`ZqI'o1@ZgG7U9}Wٜ L#qu". $q +9dxcc. N-JU;7S( m7pp!Bb
*6Űev 7TQ<-Ћ<cVg KqD.#BF qݨ@3Izss0Jw¼lkՎEZe܀հ[5q
aiJ)1
veQ6'XT ڧiKK93 RZdiz-cV LPZO(v-X}gG&MQ 9gJK$Lh 0Z6H A2Gb)[-p90 U%ULhD
B_ /+ Ɂ mo#H>1Yp MrER& Qc^" c
-_#X C1, Ds"
жz~5HX!te:!ϕT-+EY#_I4mkb@#,3kbFΎ%Fe"!#Q(Iv$cmdlT v ^MѲ0*BVghZK H|
D=* Gί.Ku3D VUKg<$FN ul2˒in0{SK_4"yzh ;
C`(M f 2 1j((0eG# Lȁ-G~ŀ.ܖ Hd/2DgT6 4 b g%gCHci:fv'Qm4iJкRsE<W@軙l]F
gD燸N5SXgzg3E0+rb TF)Υ?ˀ,feR 2,f21bQ`@8#Sw;g)J[
40G6>S"cMLNO*0bg#Կel0uj:Z8n1ʮ.c&J= +ve7#\PT d xW;pJQ:F[9F (~D}?D6kmK/Z)ϯ\ѭQ#$ fn >@b<]rdgP谔4~/]Z?S}0
qu+I> uztl?wVQ Mw |ot&
0kUws_[!V]0V;FV6\9: #{Ý ;OΗΆڽ9sK B8An({6ʗ&Δi6=SS'NSY8 mc_7
o-4 ԡrI)"6N]̀UW4 QpJ%uq=J4]yW5p! ({jcrjb-U:z+GV#x|L{ (>=V/J**! : 5)X.9I}{0!v `'YoDG2l ({4f>cDE36>՞ NWaj8;S1 X;BC pEs
p9 VV3Gb6tMW0MdPĈvWgᖌ9y`,u[M
{ژ>@
C i4pCx@ҨZnA^z{goäTA5E.q57QZN@@ur<]<"`r6ƕAL s.\¹AT-h쨕O~AjtG; 1ewkB`=ԥkZ\r" } {8Ⱥ.Wggf@٫cVMeA?t :Tw5]!PB 7 PtM]b9 4j >я~UҩB ܗ R<,sjB !ޱ{,/1nMWQ eoO X!pP '5]!Oq{ )բ0O.5F a-mJ#8֎wu{]
7>
eژrjz^h_ YcBkk 1x≢[iT
eod^9!cu@ РYG[uR
5,o-B(_2&a/6BC\-{<Ǵ5,gC\@jW2WR!E)ćB/w+_~߸ ({twˠB }U 0Y.J#@:Dž7 jgC;3J֧?GaP-jc*YE^+;/YXu u@>_mL s`&jcJLG*D蕮tW0O}=]u<9ƽ' vo~srӭo}%ȳd 0 3ugO?7d-A~S G٫6fSy\ wy GtK2aFz]SBE?)Oy(_F1>Smn?O&ws'xw?W1ۚ88ފz{۱5q Ӵ&&" ^G=QB).PO?6IR/&Ǜk^7>cGW{4oKǍ7O~^VL!kw%\zhu@#$o]z{sr w\}YM~GO_йxZ| EmL $ ) O= k_Zs^_){ dVI/A^YK@ xhcBAܣ'II1%kb"04f"Ǎ98^"D@h7_~Z_t0emd
ޖ6&7>RP<9,VS {Zܖǝrw:V WsYm?Mn,![0WXw]v)xֵ1 FNV?!aSkbXƔQ|?rdzvvNg?47Y@~'iqWffLXWOMe3=~c<#rh{MU6=KK@`9 z(~1( 7}}
7yN !2&@ /zы>)|&կ~[lg@٣}$o`[ǃ X~,leg ÁtI2W5 %p E{6X~?!]P01 D!XG) YSydoy/ga!,yѳO
sヾSn2w7ߴ jdzp,_bxxa/
s;<NO4 ב$Ϯe|;RMw%Y uCЇ>':ۨFt߰ƫGLYgeHf q a%Z x
8>*0zpk,@`:O 9%ʤS#UB`v /]Ү`UހE_.YBշs8 XfJi ؼ6&"8̅9鬩FQNDc̵EqKr38 Jʜ
Ͼ(
x5^
ā?4d <6ٍ%9& mP(֞DQ~@@Ep>'T S"ƃ?O}*ˇ<[X' $NQy Ɍ ql>oK@ Hպs{Ћ_b-Ұź;UzylĝpOipt7.ڍĄaPi`
R6 'eNgCٳdzK;'=Ms\Efe@O CWL O8S b!t!SXX+ylp$N?t DSrN\*kUD@챌Ȭ5w0̠k2'tNd~9PUW̄]lv[_WڙS1}M>Q:LR{Z9'sH|̄~ ub)/^t SepNؒ@ h#6%;m2za h8v R_6gdz"40`'2PB+:egg?QIUQ@91܉y1=>=aއ뼽b1D1=$ޑdNA۶,@bdϮ) ,dP+/3]y\sdMw6~"*vbtK/r!HBW I*m_Qruv;_Yk
2L]D;0)Lú
}`L TRgmlJhenA|aD9hN6}BB xxthXi6>#>=
%'t $0צh$ M@a}@"X9IüAN
<1BNu T(9G8\9C[/KFnG8L[}ޮgZw|_d44Th&۟G@%},ϭ1P)W 6vmל@cCSQ8z+T#m{+9e B@5]IE 5Df5jBߩkphIP1c 8 ^XT7Ʈ$ r G
eb?z㝣61`aN*xK)+| : Km2 ӑJ 7=o`Mn <۩ڊm|Lz*VX]u'0y{T!9uV^`S& /qAʪ31 vG?hτP8N7I.HV3;jaM`ۙj~śFM& P ^7 iYW ]X`I# S Ʒ<-tNYji kyy `g hnXDL=꧅vr,}ej: =ټ` ! N0h>y 8@3(
ulEͧvx) E c^z@Nމ}ֵk ѶG
vyMn_%+_ ǨI*шpW\p>(?':PnFnzͅ
:ULϋUD)0PƒI
CA+tlѪ` +3xv_ W6ZfUX.Qv?RڢTxtOƑZ:Ѹ=)RAWB@$h=kc7
IFTF-@>06P?m19#✣,1 DTQ^bEu i L( do DlȷdہFۚYIڝo~'~ff:*:Ivԧ5
u4P= ^T."P9vou͵!rB )'҃] ({tjcړw`s\ic y4cZFxB~=mQpM l(0 o;18Co+bؤt9N7AqӒ ?҉x;ʾ6662n7济b ̚g74dm`zeq9[gzqtR
̎tM~Ќ j kti=z'2; ϔŸ
q] gY[Pg7<@fwųэS:ʹZ'Kv^[:A3#Qsh5BBB` xNa$D%t/#2
C &MyDoqs,3LZuxmF6ȴxnV9=i.aJ ]>UzQ9ϙAr8, QT]& ĎA` ǘ2qMӹ;{1 3V:*?sļ JLr<תGG#^Oخ>:&G qpO =I0Q:'lR{'CB Np+!KuU%9BD]j W;f9gk@c cUIQv唖c}MϛgW:a̞'pb'䘟1u=2 ^ 0"l 0&%-Am">FRnv&uZ@ "!Kr8?ŴvfuC5 wpMX` YaD803kh}@ώ Ip =~r @B}ʯv M:ss1b%2v8A0P32-c\c >ȢcudͩA7#ӂm:DK)2RyE hihQ|)̵ؐ~6lt% c{L"$(Zj7e7pٕqo'Crq0 EMbtQ
:T%\N~ (ҏ&r(g2t0G E} f4QPոH`(?( ɂJݕ2j#F[+)|3C)OIfL 41oLbZ
˟
eO"Um30
P,AHų~^\ PެD!$
4'Yx
D+ev @37(;LLV bD
f?yи7Mtc0gv_YnѫfC;cV)$?kQ)8*Y~369.R!39 Un|f9N䞑RiDtdZlg 0 4c~& }u ;q[h7~K mQRT}#n t3ZrQJ)
5@J6tv; !iG'#w
J@&+ ^,9D縴@3W/d`@Pm(BBrk PL i#d:a.˯-DT.f֧@M@3b+{?'y@-e-a;
C-~_峡`!#1!4m|州XA]%؎Ƈm{r
)O']'qv+d'bv(F}p衇WJyfUݛo=cr.hF5`Sp蜡^[ wX/t8hh@fn +xݑuQs'' p EQ;i-" H ë a#G4vʯFp n pmokAY j32ڜ$h.[h$vG8xwiw ae7ԉz\IyN`Y2E m$1a?o# 0#Rb8K8HPb%`uDou6ThH,Xm
g٢H
(UƁF8=NRm$qib egwIQIDDzND
&RQyv,}21kok>D١y\}\PLgN21
%_HTD|b | ( Pvc` f2\VPq>]WW:攄 [7gUʾhB`.Zx"v;BU5ps3`;eR,:bnN tp& {#X>SJo3jkc
9nz[r+3JSFˀ c;Ѽ); 6l2f+:\C\39k"Rbad n05*JܺPdqnvӥQa@:uI1ctM٩Ys#2s"%HR1^&ұw%Z1WrsJs2FxġW;.| ( K
t96ʔO*;/g.(>C e" eyX>иnaT Ϫ.Ң ^Wn=v7 Pqi#-7 Ls6SǸfWĢ Z4MLJEmy
ɢ itt
,e!=yA M۞r yvnW <̠_+ gfMT3R&Y {ĭx3)䈒LD
pq1Jn
uFmmѕ"`gQ<"`e/E )!._KȪ
@|Ű핲W,:\&X+;kJBnN?-8v< !cRAvDz4&!ʶPn90;>=WD"*e/'堥 p^/e>'aVѳw.o4l= xȩ@zǦ09r\&9
G(vu}~YnQ&bm3.&ƔMexbEs DL
:m̀gow:sDK4^nڀivuBdiTD'ƞӛ@(x .l ?>HIDy%4;;eUXqQUU ghc8O- q
xC0C$3ǁ\n% [GK1}H6 X̬
+ v`ny[rlwOB;4 S:uP8O V*t,\_h9;rB,J̉4(E
LY#NF~؉&v H]o㭟?CRME!21<%2SBD̉ M(*22EҀ2IzޏL>s 绿kkt#9h@m({s3+> *h:jŃTl/ x "Bϓ0,*9ݏ@Op$J78sh9 w3Jj2`aJd7A8Lv g>A ĉSti; Y'g'mO \98ٰch DXLKYn=3SbPK&ƜHTAg:\d:&Oc7X``#?AR9]^5go`J30~B+gw8SR߁!HZ"}Щbn aUW# [7m8x馛PvКdຏNYJTU+@&)R8 u>m4TȆN^{K@m({
hb0JVɱ $cR < $EU64Y4hgQ$I =:eYg~9aWF:iL̽d Φ ̉{Gc+[RM(E6tPtx]Lq>i[V5Y s~]h
e `2O!~<5zLݘ@"51nI fʜ+P `#P>دF+hI"0fj@ٓ ͂@"0ԀNjI^4W^#'@m(!2
: ?Ԁ'/9S-G$@
(a1
: ?H$e cID`:Is $@"0hԀ`b&]<18g+ P (M$sP'@"0H$e cID`:3lCt/jT8y+8߮Vk`#n;oSL)[5P=?v[gy*۵̨d}c qxgqFu[nlI @ IDAT?=[glg oNM~ 9S~rꩧb"ww_bԡib9o|c<3tm)rhדfi饗zͣ )o6~/Vҫ?
_
s־/UŨ3R\d D6(O7o~_dKbSQ ~$=a\"mHʏ= _XbM,\X!w+K`"bDOSu,);"b wq/믿>
YgޒYj <?x/ )u ;Zh БG vg/Rg/bK6dy[ 5J^{m1 tP@x( qY阰%.D >~T^ JBLG W:/|Űc?at '> қ-x:;+ecj D
;2/( }/bm8ꨣ0e4tCh!Fc9P0|mя~#ytsEXmJQ=A_W^ h-۸n!HY-v!j>~@^2X)U+`"ޱ `ި: Vy ,Fzm/C~[ 9l _ rp+ گMuTT^ {O?=REjΆ.ԑe(
og>#qyD 7<#ߓO>fA!"Cj㕽tXjkئm5,lb f,{'^HT[ In馨k!ھۋBU`|ӛԡ'#$ zhT ywuN>. $-i@aocg`n]=餓dhKZlsX]"ۤ/e
LJN8AVnR`FB6lzkbj
{ pP p8I^7Jd ((ַA *$0pT*RI m_<\ M`";TMjUj5+4)GD -2|
U%m
&Z`vXZYYb%=yu+YYJC=HT<5R )Q.2s=j;cg` Tm`2REk~'zz,nQ*5GP5p| |2 <&k7`'048;V L%C S*uYTًGl5>\;5ȖvwD$ʫE/>яd<:a[ G<*ު(>AkHi"oW! D~.:1dM` Y+X쳏Vi]ϝ8)&%Ч1
1fIfB1R`NR!!
J͓R?qCFT#/@X!AC[vc G 2 .Ry-hamep%U
2@
}q݆D wܡqb, nhőo{.$t"
,hVՁ"Co^~A5j02;nU;|+~ sg`)kU %U۲6xCf.< P?Y
(^{m?w}Sr7ᄼ5^\&/-E| m4#H AAa}TY"/[D#A(vޒ(22#a%-r HxIɔ_m,tL#$ 3)YyPvFWJmYP!`p Qww}-gGŭ؝EL?{=+Wȥ:VGUwZ,/]0jFɏ/ڀۀͩcɷ6вH" G r9 \w fʙxQ8gͦ~ DכF}j tL s}R
4% ]&^ R.)ù
WF= VC`Bg/#mEͳG[6hgbO9-ȉD`f͉ dLB݄,JJRW9ۻcVz:gb\BcjD눦eF|rwϬj<tO dPY6?&a\9i9
j H>N"=S8009 LXb*ƴzu3aq`*lB3Lauk`p)[wanQvc*ƴ@fYҤ[ ?,mv˒-:5:)6#Յ{8o̎1-\I?۹`vwA4F9û&
C_r%7$aIg\ن"hr,2)O[&>*x뮻eJ&;Ga9]o 4g a\&0Uj| HlO76Zjѳh&l¯f7{u^>,~#f>BI}_N
cdH3}Zԍp!
c̈[pQu2*4!/WUC 9kIA*>Cb?3zTpW_}uZ1|@W]uU<nGPa :a9'>xTO
Vۜ!y̿/+qMdu kǣ69(ߞK̓f8UaQn' _=#z2tx=b8ۜ$gW2#fdlL()xā9=9UL T&blט#VÈQ20V!s+HI'SQ~ ; E&㑿渮 guL
%C@W5cnGYz82|#8B0Rd#Q_7"m!ϊo>(jȪ
أ &e6՜Rv.q
9cUv6 wo1opvkVux Wf\<:( w"jc\i.l@[߫紝qM^3ZJ
X9nVH'g(nI@xL=ujUiO5^CRCN-+R
|7!g(x#YpLqW9Pʧ!y
3XE8?<<2}+ .Zvp}?.^赀8sDl['pB<
ط=ZwF*ᖞ/Q)BW.!bm %z?)MlwC)@nnJcDb{[{ &Z!5{%v1D ,3_g]SDmNJO@h.%Ej ų%C_p(TKjt{);aMgor[QogCFs{XeY&k}W߆kL?g8+q3
Ԝ(mOt?, L,51yR'# DGׂɉ"qh_6ou5p]rv+0exŇw@.iF 6a`Y7H> CgG ] xb|iR+oy[pT"GE:I1$s(s_"> 9>c9# >C qHh-OkLAڴ(;gD$5 D$a ǔ;|b`įU/i 0g}6Ή4& P1VŠ␇?50>;9XC3F&vg]w^8'xՅZ.b%CN=TsҦP< G;],0L9l|!ȣ!EP G
M8"Lw"j}Bi7ZdppƪǞc}]~(H2^ KW12@R(^m(Á;2?; apRp;Gl("`ѽ%s\fy$;GLo=iHǘ1->>1ID ~
-GQL6rRjljJaB&ČHo ⷡņjI
j~ FN;UtJ ,c{9i)[dk+RM'h--'&ܻ>w['E]*&6&aD<$_%٨_r=[Lt@}V$6tRd WV+W=c'IE%W'^' x1
tx#VQ' H8C:h$~D "
ПS38A7y QgGlH2}?[E3
:0<l|~+_),I {lZ(fxЁij: Zec^m!sie"L^}gSP
0l]9Coso339Cw#wc=Bl/Ȑ̠jIqWN_RwaP%T$l$fa o~+`VJ
%+P0
.5LکJAqWêLh츗dawk2 J>:ߗC&D?Fסt)r nz7۟2erGWz|3^ӨmT *aI!f#&=r9JYT+27WK C-);~Y/& s͓jjW@ՠcrUejdЮ$RhTXJ"Jh
@%Cp@Ԟۄ?mjRE S,4=\ 0vc67a4a1zѼ8 V
ܛ$ώw9 0$Kji9T=ӯ_^IK
PDLNL VTLsc;oڴic.>U^_]{*ADŽ7V F ;C&:E*){=nC/d1cȍ42ł4*0x Pwgo;x͈t8Aa ժWѨM }mp^dG@ H=S
e]E嘁- 7
"-n n c/šAhʰk Nu#V{"^jG DLr[c?_Vf;KC6 tZK2P8?3t?nls2lw&̳sjy' ~h(xpc;3H<ӰSqFj8#6){zC1vjIzKN$lmQ IȠ1̰Qv|(8 If"&UKcH GS yM)_3s6om2\tD ^-ںR[TvW~a-3U uTts +,[ou8*q{B}U<8<;#\B96,\ Ǫbh֠,~c?d3N ¥ Pt&]Ys!q LG .] qQ$d:RAWR ?x_ \Q 7oxi _8ȧõiǻK
m1
} SN}z^ooWuO1&&Țkil/EOp0 wkF5^fux~IT\
od1:yAXx6'pÆ v6eXu{.nN:JŝQo灬v# .9X}fc Ou'pN-N>#skex{81 h?<$ rF3g3zs~./|TMz ~.՞_* <p}WVz wj|± 典s
m6Fv3 4yi8M#a3V 4 7Zoڅ-s!|vls5k5>@Ll^#
ejd .]mٝWAϡh Ӳe@5 2hwPf ٓ?+9#IOw`:01KGI[30'{
Ak9q _
Bf:,C6x6o>LܾF;C<#"PH9Q
N՝uZ7@Z= EL(no :Va41 QBO٪fq
eѽAىX,x{[Kn\hói.؟#&~>cà#;g{vq0tZ^Q4dM{|Az켥z'H\ Z\Y_d 6lȜ{=N YB7JdZ
+`b = ?d uc9]sp;: |YX(;f FC3Qi7zG ٬g()+ǾDttŪJ//i"֢ЕZ nߑà~vZ ZCآÆsTy7aW 01EB}^1cȺ,8Ue%~[nh =[o曷 |}#B}="9
O| nPqH{"nuT k+g{2VFߪvS3 bC]{f1yx N;i[<㬭eǺaz%+7ff-I%0ʘ Px6?<ؗ5Xc ~3e7=
=eg`);neLŭԖD`0Ʀ (ƸBI8yv'+;蠃nw fRvGƮ]ݛK 2CO *; zF
kh^_K `ĀaT({}=.nА=ns\0KcH\.j= [itC~E 2eo:ƧoG}s U>3e Cݓ{+pԚa(o[|9\a 2*H"",2bFv#ZjG]`cQeLD "-;"1 k\ VZoo6
V*|ʺ a{YF'U%#쒟0lNKVΰ%>j6P7іJkҡ i l}(T?@"$]G El(9j rL fBv#<2.ND ",q
f MV!&.L4id!d]%32HD` ACW8Nʐw?a39e̾Z2É@"$C '˥o߮!ވUx滜 <@bvkjw7.S'@"t {y^D8LKi
s39
-D`OjueW. #|! ;SeC]aFZD`4
".;G?QRS JCD8Y74u5(=~饗 c6dcjz뭤[l7 K)sT͖D`
"ܮ89<7|3v73N~X :ns|1hXb{D7lyGq |+#vH*y27HpQjp5
dGX2yl`u3e䮻jFbHR%6Bw3S)nd2@mq.}D '(r>lWlVrf [Hc
Rlyт·yRdd
ZLDz糢u%lבB
T3*)-贸G=~W^JV 8!a猦|_寀c)H}&Ɯ!` y|0A:aN_c 88r;Y3s[3@ iei9!M 72Cdݠ_=/Lzcu< _JSHW V 3QǪ=wQgEE=Ү~:whhϭt/ J $=B1 iՈmM IMasF,#wWL/7,ǡ3}痑R9){m z! xRr?P !RKmp,>fCZT^)ךҩJGuY sKƌ@;@7B#%܉=B! RI&DS5qUmTd 3 w2B%PZ}6|rgvە2Hƌ fYYz)A.1&oA?x-w\IM~WWTKsYLt 8Z`6b3=aM蕜 JHƌ : "]%.&
AQB4ZԇQv7J9թ_͔D`XSh Qs<M
moo@ze5t&"K%\ K`ĤjNƀ *XU hN=>٧2V wA)ίpCTj8∖922HD /KޡrRuQ%-~^70"%Nn7N:CZ U d8HD`< -7l(fWZ%)ྞcvT~ǧ>) {OɦwjW2D HF# 6! n]A
`58,]k ,@ }'\egz62C"$8@l]+w 0]6NFi t.2ws1A-- PzOD ( H+"vݰ9#P.ٞ-T` *&(_|1۹1 E"0aL6QjK
gϯ^_J`;ar W, rD N]oPL1D_`tz)ҡDŽ ВOonUIɳ7C1@?"Pn ӏ>2tǭ {, 'eDKg$eߗԃ@ ՝Ҙ+3' I+!fĕt"[ \@] Ԍ*s&9cW >i]Ɇ' 5\i0BZ* ILJpWa
_z1Zӗ%4Sp=%oI{ZD`V=͟Ǵ]kVP%x/mݖk曏oVaڍ!){;d2>BV[VҿG/)=7Q_veT|۵wP!S}' EMWuxVӨO"@;*~:|vo \
zg7?C c쳳z$5Ww~d,Cܐ}K.;D),$b N@pdq\m8Di|qpp(giPl v'pn*
(ζKfN %lR C*f/頲c@Fc ~&ۯCoW͓~F5q#⥟%Z) ַT;K/!6.u5}їlV/'tԩ5 אw;{¡(h9V`@x衇|{kJAп\s1I[RHzQs5 لc |v&7!qи9 X.$ e} .K;C@
s0* q:O~>{ o&mj?H6Ğ{ !RR%
rnɳEv [o5Lx}َ\wuX.D.=Ѝ%R@#6Kjan>Qb^fe :"{ӧr/"gqF }nF W/-椌0ڱŠ~
t]C|y;m:&8Gmu=C>K8SǁdaFoK,կ7`HZj7|s;RZƳEYl z6k9t"?CbjӉ@+ q0u>G$*H
Śظ-5 Gv?H#@Enx袋V]u{ｷ:I;S$}cu};H*$qiB輹v
7㎕\썈 .;QVhvH a8 xC=_:ƴ `$
跽m҆T[2!HG QEZXdM7ݔN<Q:6r*5R[-3D"$3 b9@i{I1M_z5NbOTR_Y)N*o/K3@"$m@?cp\׳6ٟf5ېT^QOc=HA6PE>&@"t -8NrqĹ j&z%/y<̃\+2so=CD+lXy%?HD G u9;@K2 4$ĐW_M{ 7D H#w?aʯx+5fc\GS/l=0 ͤQ"@v9'&ih v {1t#LH.« ABTte L )9՟;`'IEpsEMƈ|Gk.__D̖!yȯ-B˲H'4f sQlcϮ:Ώ9묳 yPz>Ϭ@'\m~F o>pg ӟ p1V}>gݸB4]=S]8Ԋ?? ťln!37ιUa-4Yfw!Y|͇pt&quQOls%Iblc<. p Iwhʳ{4,QEa*ޜ1O4@;tKًodpOwFTPo)rDž9Z_b"W8FY;T r)LEc2"}; _}mRchDC R9/^OCڀ_ \4WF!<~ mZ&ed "PX ƫ'2s\{LKGj?+s_~[[oj(IKN_\q4HGS`r nWխ\pAb-KL5@5\n{Ŗ[5o eY\ -xvG]Fa/|NYR#vc|&DcnHTny94/!+ w
ZNk~H`)U"s M"fvZHP+BٯB< J5W3֘}UUK k6Icay
(CATa[+U<p{j%_|1ErOx_# (Èz_?j%sfevK? }5tKdC ){ }X"@^{N_r%u^; .,%hFHR +q ~q_R.;GxI'lGSN\7y%R X-oY.r[jh 9freͥUcJ]q`6dhKjR
}6|sbe]PpO/_ *miV^3S/Izץ` Ce*2-3QxSS_0nEoEr-Q?boձz=jdCݔg_|qKH;P04GREY jW1$, w :%[6u]T,Z`zC=|UWER˚K% t /~1b5\2 <02jVRP^ CChv=$F~F/i1VYǪ4eFf>c3ƌɳõ#G-wgq6b}Cy%EOU+] Lz+oi9քӴ=2` y$G }C6jo=H#ȗcu#XxK/Űܼ4\siע*\U) rҌA1ђa4N8ȉm M/2hv3>2{AdƛV$ }csjح?uG cI>"D}a6R# ыG"k[v b -m*
; 'N_ܿ<
L^Tc5iP.j3(Zd y0= 9>oI\3vUbtĪE@!$As#uv<"!f\M`"N`
\fJ٭K-e) s@} a |J6 5-=\7c1y{VP;C@ hH]J")64g@OMVtD { yBLHTgPUXl+lj' A熚SQav&v
7e̬jC#3Fc=jg/eIoT]K|k (e9Y(mH<ЇADɂy4;RyKUm\
6;B^ń(B˳dž2`I$(D|JY=wڌ"[/ )(h-T7fպ܋vs
h7`j~M 33Ⱥc0'1ΥZY :ܯe nc
" ]PvـF:KGqʼnDg믤NQ4E} `证`impÖd4OŏH8fdō5 "rF-Y'ڄ}KODZ@%'Y
PU1N"
b!+z h;z㘡&6: u% Z\<6
1RU+p!U[vӆ5|+ Iks,2=2$}Գ|W(\#XhAo1iF5F1,$
mAj UCXMA}|ǛNdr81T|z> zP9gD*AԄ>kF˚ʢ
:UI
~#ѐDzK3j(RjT Ye-XR>p~<9 # g@7`65wʬcH>o760pNb,q63 H/H TD0oYU/;b@5p$e W84As/# 8 r@3@R+s'@M
j1} ,\N{:Sl 5~A)X.sǯ#iQd0@woZ5 *kɯ0.
guF ){}3L<-b*m(jlMt d $UWѨq8iӦ1'1*] ?OZebK-馛V]; 1Tlѫ&e`{lͶ&GX^5 Ǝ7:uK/m+W8uJ3]qU{9y}:o{Y
+P͙Z @> zQvryZʆz M
.l"bx-uY/xx9+bub-Jd*>(2PE ){z6bDǡ!Y!c /_"حg hF ͘8&
7?ߠ5 Ov=HƄ@R1֯(3=+j_@HCp'8s~&h"Fxx)kկD7%@ ^BW@u=Tc*YY"PU!IQ˜!}^Pl_iv R"0:Z/})kҲ@W`G>e/{Y҅%#",2ۋJ_ ;9D Hz bSsO}S7.˺wB" ~;?O?4}'{1Oc=fi}C\e>9EKYg"$ ]|1?]|?>#@V$@"Ќ! rQG/䬜9xbfzы^tWЦ,$@"0J#]7=_~f#%@"0~\W=A_a) 4F'3$ ;PI4dԞhjՌD߫7tS{Fn"\y
wQ%>`^hoz<
[>rI'L ee-hF
ܜ4Θ:4u믿*]e].T-.Exd>cvYgUZ0l|
/Q-4GvEk5w cIG2IMv.lK,!|%rs_Đ@\{.5h%TcȅV## V4? ] 5$es/Eod8\O.um}
7eY.2dOC?J~a ^ziy%-JmK-T!NΞ<$m@ik
[n-n/Q\O"#l>Vka8 "Gl4X(ǕӱA/|;n&l%џ)ێ /#_
Vb:ğ} %M\ve!;[ʂJH&8|ߍΒ_s9; OG#OdWU4CU5v"WH]U~vKJRFmF$,lF-]Jnm9戚UnjƩmٲ(IgWw ;Z\~%P)a+Ć ^ }]jW9mi dZf]x]- }59l@q¥P͆vǫ1V9qzG*՜1$"ҘIMRQM6Ţ KAy$͑%&Rio@I VwY~"?3$Ҝ<=Ӑ*VX!) E`J)5]ks9眓 7\Y"v)a83S4gR1Xlps!hNvmE va~ZQ]a%,r @/^?mw0`5jp(Vm Zb
3y衇o?ze)Tx:P*@" 6ˎJ)wߍCɿD`F@JB JCb%pِ &j6M>#(,&EfR#E&
V\qEr!ho4߉9=%# W>#ڴiG]wU'É@g^m v
Gc7@&'MPARij^,zl2ܥd"R2{a L˨T+$Q qQHkFCWސesl j%NFDyo|#f S^{m+f|f r4"z/(hMRd@Ud]f
'
J¹ .G
[\Rknn %Yo6c:#"8s S`2YC,$@"0\e*u ;S{tNԊ;D HB u5 'l MgZ>Zk8Du8=[TyD H@ls&l`P
9CP{V$@"Є bKiӯc?Ĭ9 {ӻȈD HƎ ",b[o/OIc,$@"gu>{!ٝD Hƍa*£@ IENDB` owl-master/src/ 0000775 0000000 0000000 00000000000 13715306717 0013751 5 ustar 00root root 0000000 0000000 owl-master/src/CMakeLists.txt 0000664 0000000 0000000 00000001301 13715306717 0016504 0 ustar 00root root 0000000 0000000 add_library(awdl "")
target_sources(awdl PRIVATE
log.c
log.h
state.c
state.h
election.c
election.h
sync.c
sync.h
channel.c
channel.h
schedule.c
schedule.h
tx.c
tx.h
rx.c
rx.h
frame.c
frame.h
crc32.c
crc32.h
wire.c
wire.h
peers.c
peers.h
version.c
version.h
hashmap.c
hashmap.h
siphash24.c
siphash24.h
circular_buffer.c
circular_buffer.h
)
target_include_directories(awdl PRIVATE ${CMAKE_SOURCE_DIR}/radiotap)
target_link_libraries(awdl radiotap)
owl-master/src/channel.c 0000664 0000000 0000000 00000005726 13715306717 0015537 0 ustar 00root root 0000000 0000000 /*
* OWL: an open Apple Wireless Direct Link (AWDL) implementation
* Copyright (C) 2018 The Open Wireless Link Project (https://owlink.org)
* Copyright (C) 2018 Milan Stute
*
* 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 .
*/
#include "channel.h"
#include "ieee80211.h"
void awdl_chanseq_init(struct awdl_chan *seq) {
for (int i = 0; i < AWDL_CHANSEQ_LENGTH; i++, seq++) {
if (i < 8)
*seq = CHAN_OPCLASS_149;
else
*seq = CHAN_OPCLASS_6;
}
}
void awdl_chanseq_init_idle(struct awdl_chan *seq) {
for (int i = 0; i < AWDL_CHANSEQ_LENGTH; i++, seq++) {
switch (i) {
case 8:
*seq = CHAN_OPCLASS_6;
break;
case 0:
case 9:
case 10:
*seq = CHAN_OPCLASS_149;
break;
default:
*seq = CHAN_NULL;
break;
}
}
}
void awdl_chanseq_init_static(struct awdl_chan *seq, const struct awdl_chan *chan) {
for (int i = 0; i < AWDL_CHANSEQ_LENGTH; i++, seq++) {
*seq = *chan;
}
}
uint8_t awdl_chan_num(struct awdl_chan chan, enum awdl_chan_encoding enc) {
switch (enc) {
case AWDL_CHAN_ENC_SIMPLE:
return chan.simple.chan_num;
case AWDL_CHAN_ENC_LEGACY:
return chan.legacy.chan_num;
case AWDL_CHAN_ENC_OPCLASS:
return chan.opclass.chan_num;
default:
return 0; /* unknown encoding */
}
}
int awdl_chan_encoding_size(enum awdl_chan_encoding enc) {
switch (enc) {
case AWDL_CHAN_ENC_SIMPLE:
return 1;
case AWDL_CHAN_ENC_LEGACY:
case AWDL_CHAN_ENC_OPCLASS:
return 2;
default:
return -1; /* unknown encoding */
}
}
/* adapted from iw/util.c */
int ieee80211_channel_to_frequency(int chan) {
/* see 802.11 17.3.8.3.2 and Annex J
* there are overlapping channel numbers in 5GHz and 2GHz bands */
if (chan <= 0)
return 0; /* not supported */
/* 2 GHz band */
if (chan == 14)
return 2484;
else if (chan < 14)
return 2407 + chan * 5;
/* 5 GHz band */
if (chan < 32)
return 0; /* not supported */
if (chan >= 182 && chan <= 196)
return 4000 + chan * 5;
else
return 5000 + chan * 5;
}
/* from iw/util.c */
int ieee80211_frequency_to_channel(int freq) {
/* see 802.11-2007 17.3.8.3.2 and Annex J */
if (freq == 2484)
return 14;
else if (freq < 2484)
return (freq - 2407) / 5;
else if (freq >= 4910 && freq <= 4980)
return (freq - 4000) / 5;
else if (freq <= 45000) /* DMG band lower limit */
return (freq - 5000) / 5;
else if (freq >= 58320 && freq <= 64800)
return (freq - 56160) / 2160;
else
return 0;
}
owl-master/src/channel.h 0000664 0000000 0000000 00000003754 13715306717 0015543 0 ustar 00root root 0000000 0000000 /*
* OWL: an open Apple Wireless Direct Link (AWDL) implementation
* Copyright (C) 2018 The Open Wireless Link Project (https://owlink.org)
* Copyright (C) 2018 Milan Stute
*
* 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 .
*/
#ifndef AWDL_CHANNEL_H_
#define AWDL_CHANNEL_H_
#include
#define AWDL_CHANSEQ_LENGTH 16
enum awdl_chan_encoding {
AWDL_CHAN_ENC_SIMPLE = 0,
AWDL_CHAN_ENC_LEGACY = 1,
AWDL_CHAN_ENC_OPCLASS = 3,
};
struct awdl_chan {
union {
uint8_t val[2];
struct {
uint8_t chan_num;
} simple;
struct {
uint8_t flags;
uint8_t chan_num;
} legacy;
struct {
uint8_t chan_num;
uint8_t opclass;
} opclass;
};
};
#define CHAN_NULL (struct awdl_chan) { { { 0, 0x00 } } }
#define CHAN_OPCLASS_6 (struct awdl_chan) { { { 6, 0x51 } } }
#define CHAN_OPCLASS_44 (struct awdl_chan) { { { 44, 0x80 } } }
#define CHAN_OPCLASS_149 (struct awdl_chan) { { { 149, 0x80 } } }
uint8_t awdl_chan_num(struct awdl_chan chan, enum awdl_chan_encoding);
int awdl_chan_encoding_size(enum awdl_chan_encoding);
struct awdl_channel_state {
enum awdl_chan_encoding enc;
struct awdl_chan sequence[AWDL_CHANSEQ_LENGTH];
struct awdl_chan master;
struct awdl_chan current;
};
void awdl_chanseq_init(struct awdl_chan *seq);
void awdl_chanseq_init_idle(struct awdl_chan *seq);
void awdl_chanseq_init_static(struct awdl_chan *seq, const struct awdl_chan *chan);
#endif /* AWDL_CHANNEL_H_ */
owl-master/src/circular_buffer.c 0000664 0000000 0000000 00000004602 13715306717 0017254 0 ustar 00root root 0000000 0000000 #include
#include
#include
#include
#include "circular_buffer.h"
// The definition of our circular buffer structure is hidden from the user
struct circular_buf {
void **buffer;
size_t head;
size_t tail;
size_t max; //of the buffer
int full;
};
static void advance_pointer(cbuf_handle_t cbuf)
{
assert(cbuf);
if(cbuf->full)
{
cbuf->tail = (cbuf->tail + 1) % cbuf->max;
}
cbuf->head = (cbuf->head + 1) % cbuf->max;
// We mark full because we will advance tail on the next time around
cbuf->full = (cbuf->head == cbuf->tail);
}
static void retreat_pointer(cbuf_handle_t cbuf)
{
assert(cbuf);
cbuf->full = 0;
cbuf->tail = (cbuf->tail + 1) % cbuf->max;
}
cbuf_handle_t circular_buf_init(size_t size)
{
assert(size);
cbuf_handle_t cbuf = malloc(sizeof(struct circular_buf));
assert(cbuf);
cbuf->buffer = malloc(size * sizeof(void*));
cbuf->max = size;
circular_buf_reset(cbuf);
assert(circular_buf_empty(cbuf));
return cbuf;
}
void circular_buf_free(cbuf_handle_t cbuf)
{
assert(cbuf);
assert(cbuf->buffer);
free(cbuf->buffer);
free(cbuf);
}
void circular_buf_reset(cbuf_handle_t cbuf)
{
assert(cbuf);
cbuf->head = 0;
cbuf->tail = 0;
cbuf->full = 0;
}
size_t circular_buf_size(cbuf_handle_t cbuf)
{
assert(cbuf);
size_t size = cbuf->max;
if(!cbuf->full)
{
if(cbuf->head >= cbuf->tail)
{
size = (cbuf->head - cbuf->tail);
}
else
{
size = (cbuf->max + cbuf->head - cbuf->tail);
}
}
return size;
}
size_t circular_buf_capacity(cbuf_handle_t cbuf)
{
assert(cbuf);
return cbuf->max;
}
void circular_buf_put(cbuf_handle_t cbuf, void *data)
{
assert(cbuf && cbuf->buffer);
cbuf->buffer[cbuf->head] = data;
advance_pointer(cbuf);
}
int circular_buf_put2(cbuf_handle_t cbuf, void *data)
{
int r = -1;
assert(cbuf && cbuf->buffer);
if(!circular_buf_full(cbuf))
{
cbuf->buffer[cbuf->head] = data;
advance_pointer(cbuf);
r = 0;
}
return r;
}
int circular_buf_get(cbuf_handle_t cbuf, void **data, int peek)
{
assert(cbuf && cbuf->buffer);
int r = -1;
if(!circular_buf_empty(cbuf))
{
if (data)
*data = cbuf->buffer[cbuf->tail];
if (!peek)
retreat_pointer(cbuf);
r = 0;
}
return r;
}
int circular_buf_empty(cbuf_handle_t cbuf)
{
assert(cbuf);
return (!cbuf->full && (cbuf->head == cbuf->tail));
}
int circular_buf_full(cbuf_handle_t cbuf)
{
assert(cbuf);
return cbuf->full;
}
owl-master/src/circular_buffer.h 0000664 0000000 0000000 00000004102 13715306717 0017254 0 ustar 00root root 0000000 0000000 #ifndef CIRCULAR_BUFFER_H_
#define CIRCULAR_BUFFER_H_
/// Handle type, the way users interact with the API
typedef struct circular_buf *cbuf_handle_t;
/// Pass in a size, returns a circular buffer handle
/// Requires: size > 0
/// Ensures: cbuf has been created and is returned in an empty state
cbuf_handle_t circular_buf_init(size_t size);
/// Free a circular buffer structure
/// Requires: cbuf is valid and created by circular_buf_init
void circular_buf_free(cbuf_handle_t cbuf);
/// Reset the circular buffer to empty, head == tail. Data not cleared
/// Requires: cbuf is valid and created by circular_buf_init
void circular_buf_reset(cbuf_handle_t cbuf);
/// Put version 1 continues to add data if the buffer is full
/// Old data is overwritten
/// Requires: cbuf is valid and created by circular_buf_init
void circular_buf_put(cbuf_handle_t cbuf, void *data);
/// Put Version 2 rejects new data if the buffer is full
/// Requires: cbuf is valid and created by circular_buf_init
/// Returns 0 on success, -1 if buffer is full
int circular_buf_put2(cbuf_handle_t cbuf, void *data);
/// Retrieve a value from the buffer
/// Requires: cbuf is valid and created by circular_buf_init
/// Returns 0 on success, -1 if the buffer is empty
int circular_buf_get(cbuf_handle_t cbuf, void **data, int peek);
/// CHecks if the buffer is empty
/// Requires: cbuf is valid and created by circular_buf_init
/// Returns true if the buffer is empty
int circular_buf_empty(cbuf_handle_t cbuf);
/// Checks if the buffer is full
/// Requires: cbuf is valid and created by circular_buf_init
/// Returns true if the buffer is full
int circular_buf_full(cbuf_handle_t cbuf);
/// Check the capacity of the buffer
/// Requires: cbuf is valid and created by circular_buf_init
/// Returns the maximum capacity of the buffer
size_t circular_buf_capacity(cbuf_handle_t cbuf);
/// Check the number of elements stored in the buffer
/// Requires: cbuf is valid and created by circular_buf_init
/// Returns the current number of elements in the buffer
size_t circular_buf_size(cbuf_handle_t cbuf);
#endif /* CIRCULAR_BUFFER_H_ */
owl-master/src/crc32.c 0000664 0000000 0000000 00000006475 13715306717 0015045 0 ustar 00root root 0000000 0000000 #include "crc32.h"
/* crc32 calculation */
const uint32_t crc32_tab[] = {
0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,
0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,
0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106,
0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,
0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,
0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa,
0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84,
0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,
0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28,
0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,
0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,
0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
};
uint32_t crc32(const void *buf, unsigned long size) {
const uint8_t *p = buf;
uint32_t crc;
crc = ~0u;
while (size--)
crc = crc32_tab[(crc ^ *p++) & 0xff] ^ (crc >> 8);
return crc ^ ~0u;
}
owl-master/src/crc32.h 0000664 0000000 0000000 00000000204 13715306717 0015032 0 ustar 00root root 0000000 0000000 #ifndef CRC32_H_
#define CRC32_H_
#include
uint32_t crc32(const void *buf, unsigned long size);
#endif /* CRC32_H_ */
owl-master/src/election.c 0000664 0000000 0000000 00000012371 13715306717 0015723 0 ustar 00root root 0000000 0000000 /*
* OWL: an open Apple Wireless Direct Link (AWDL) implementation
* Copyright (C) 2018 The Open Wireless Link Project (https://owlink.org)
* Copyright (C) 2018 Milan Stute
*
* 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 .
*/
#include
#include
#include "election.h"
#include "peers.h"
#include "log.h"
static inline int compare(uint32_t a, uint32_t b) {
return (a < b) ? -1 : (a > b);
}
int compare_ether_addr(const struct ether_addr *a, const struct ether_addr *b) {
return memcmp(a, b, sizeof(struct ether_addr));
}
int awdl_election_is_sync_master(const struct awdl_election_state *state, const struct ether_addr *addr) {
return !compare_ether_addr(&state->sync_addr, addr);
}
static void awdl_election_reset_metric(struct awdl_election_state *state) {
state->self_counter = AWDL_ELECTION_COUNTER_INIT;
state->self_metric = AWDL_ELECTION_METRIC_INIT;
}
static void awdl_election_reset_self(struct awdl_election_state *state) {
state->height = 0;
state->master_addr = state->self_addr;
state->sync_addr = state->self_addr;
state->master_metric = state->self_metric;
state->master_counter = state->self_counter;
}
void awdl_election_state_init(struct awdl_election_state *state, const struct ether_addr *self) {
state->master_addr = *self;
state->sync_addr = *self;
state->self_addr = *self;
awdl_election_reset_metric(state);
awdl_election_reset_self(state);
}
static int awdl_election_compare_master(const struct awdl_election_state *a, const struct awdl_election_state *b) {
int result = compare(a->master_counter, b->master_counter);
if (!result)
result = compare(a->master_metric, b->master_metric);
return result;
}
void awdl_election_run(struct awdl_election_state *state, const struct awdl_peer_state *peers) {
struct awdl_peer *peer;
struct ether_addr old_top_master = state->master_addr;
struct ether_addr old_sync_master = state->sync_addr;
struct awdl_election_state *master_state = state;
awdl_peers_it_t it = awdl_peers_it_new(peers->peers);
awdl_election_reset_self(state);
/* FIXME probably not fully correct */
while (awdl_peers_it_next(it, &peer) == PEERS_OK) {
int cmp_metric;
struct awdl_election_state *peer_state = &peer->election;
if (!peer->is_valid)
continue; /* reject: not a valid peer */
if (peer_state->height + 1 > AWDL_ELECTION_TREE_MAX_HEIGHT) {
log_debug("Ignore peer %s because sync tree would get too large (%u, max %u)",
ether_ntoa(&peer_state->self_addr), peer_state->height + 1, AWDL_ELECTION_TREE_MAX_HEIGHT);
continue; /* reject: tree would get too large if accepted as sync master */
}
if (awdl_election_is_sync_master(peer_state, &state->self_addr))
continue; /* reject: do not allow cycles in sync tree */
cmp_metric = awdl_election_compare_master(peer_state, master_state);
if (cmp_metric < 0) {
continue; /* reject: lower top master metric */
} else if (cmp_metric == 0) {
/* if metric is same, compare distance to master */
if (peer_state->height > master_state->height) {
continue; /* reject: do not increase length of sync tree */
} else if (peer_state->height == master_state->height) {
/* if height is same, need tie breaker */
if (compare_ether_addr(&peer_state->self_addr, &master_state->self_addr) <= 0)
continue; /* reject: peer has smaller address */
}
}
/* accept: otherwise */
master_state = peer_state;
}
if (state != master_state) { /* adopt new master */
state->master_addr = master_state->master_addr;
state->sync_addr = master_state->self_addr;
state->master_metric = master_state->master_metric;
state->master_counter = master_state->master_counter;
state->height = master_state->height + 1;
}
if (compare_ether_addr(&old_top_master, &state->master_addr) ||
compare_ether_addr(&old_sync_master, &state->sync_addr)) {
char tree[256];
awdl_election_tree_print(state, tree, sizeof(tree));
log_debug("new election tree: %s", tree);
}
}
int awdl_election_tree_print(const struct awdl_election_state *state, char *str, int len) {
char *cur = str, *const end = str + len;
cur += snprintf(cur, cur < end ? end - cur: 0, "%s", ether_ntoa(&state->self_addr));
if (state->height > 0)
cur += snprintf(cur, cur < end ? end - cur : 0, " -> %s", ether_ntoa(&state->sync_addr));
if (state->height > 1) {
cur += snprintf(cur, cur < end ? end - cur : 0, " ");
for (uint32_t i = 1; i < state->height; i++)
cur += snprintf(cur, cur < end ? end - cur : 0, "-"); /* one dash for every intermediate hop */
cur += snprintf(cur, cur < end ? end - cur : 0, "> %s", ether_ntoa(&state->master_addr));
}
cur += snprintf(cur, cur < end ? end - cur : 0, " (met %u, ctr %u)", state->master_metric, state->master_counter);
return cur - str;
}
owl-master/src/election.h 0000664 0000000 0000000 00000003456 13715306717 0015734 0 ustar 00root root 0000000 0000000 /*
* OWL: an open Apple Wireless Direct Link (AWDL) implementation
* Copyright (C) 2018 The Open Wireless Link Project (https://owlink.org)
* Copyright (C) 2018 Milan Stute
*
* 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 .
*/
#ifndef AWDL_ELECTION_H_
#define AWDL_ELECTION_H_
#include "ieee80211.h"
#define AWDL_ELECTION_TREE_MAX_HEIGHT 10 /* arbitrary limit */
#define AWDL_ELECTION_METRIC_INIT 60
#define AWDL_ELECTION_COUNTER_INIT 0
struct awdl_peer_state;
struct awdl_election_state {
struct ether_addr master_addr;
struct ether_addr sync_addr;
struct ether_addr self_addr;
uint32_t height;
uint32_t master_metric;
uint32_t self_metric;
uint32_t master_counter;
uint32_t self_counter;
};
int awdl_election_is_sync_master(const struct awdl_election_state *state, const struct ether_addr *addr);
void awdl_election_state_init(struct awdl_election_state *state, const struct ether_addr *self);
void awdl_election_run(struct awdl_election_state *state, const struct awdl_peer_state *peers);
int awdl_election_tree_print(const struct awdl_election_state *state, char *str, int len);
/* Util functions */
int compare_ether_addr(const struct ether_addr *a, const struct ether_addr *b);
#endif /* AWDL_ELECTION_H_ */
owl-master/src/frame.c 0000664 0000000 0000000 00000004774 13715306717 0015223 0 ustar 00root root 0000000 0000000 /*
* OWL: an open Apple Wireless Direct Link (AWDL) implementation
* Copyright (C) 2018 The Open Wireless Link Project (https://owlink.org)
* Copyright (C) 2018 Milan Stute
*
* 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 .
*/
#include "frame.h"
const char *awdl_frame_as_str(uint8_t type) {
switch (type) {
case AWDL_ACTION_PSF:
return "PSF";
case AWDL_ACTION_MIF:
return "MIF";
default:
return "Unknown";
}
}
const char *awdl_tlv_as_str(uint8_t type) {
switch (type) {
case AWDL_SSTH_REQUEST_TLV:
return "SSTH Request";
case AWDL_SERVICE_REQUEST_TLV:
return "Service Request";
case AWDL_SERVICE_RESPONSE_TLV:
return "Service Response";
case AWDL_SYNCHRONIZATON_PARAMETERS_TLV:
return "Synchronization Parameters";
case AWDL_ELECTION_PARAMETERS_TLV:
return "Election Parameters";
case AWDL_SERVICE_PARAMETERS_TLV:
return "Service Parameters";
case AWDL_ENHANCED_DATA_RATE_CAPABILITIES_TLV:
return "HT Capabilities";
case AWDL_ENHANCED_DATA_RATE_OPERATION_TLV:
return "HT Operation";
case AWDL_INFRA_TLV:
return "Infra";
case AWDL_INVITE_TLV:
return "Invite";
case AWDL_DBG_STRING_TLV:
return "Debug String";
case AWDL_DATA_PATH_STATE_TLV:
return "Data Path State";
case AWDL_ENCAPSULATED_IP_TLV:
return "Encapsulated IP";
case AWDL_DATAPATH_DEBUG_PACKET_LIVE_TLV:
return "Datapath Debug Packet Live";
case AWDL_DATAPATH_DEBUG_AF_LIVE_TLV:
return "Datapath Debug AF Live";
case AWDL_ARPA_TLV:
return "Arpa";
case AWDL_IEEE80211_CNTNR_TLV:
return "VHT Capabilities";
case AWDL_CHAN_SEQ_TLV:
return "Channel Sequence";
case AWDL_SYNCTREE_TLV:
return "Synchronization Tree";
case AWDL_VERSION_TLV:
return "Version";
case AWDL_BLOOM_FILTER_TLV:
return "Bloom Filter";
case AWDL_NAN_SYNC_TLV:
return "NAN Sync";
case AWDL_ELECTION_PARAMETERS_V2_TLV:
return "Election Parameters v2";
default:
return "Unknown";
}
}
owl-master/src/frame.h 0000664 0000000 0000000 00000014356 13715306717 0015225 0 ustar 00root root 0000000 0000000 /*
* OWL: an open Apple Wireless Direct Link (AWDL) implementation
* Copyright (C) 2018 The Open Wireless Link Project (https://owlink.org)
* Copyright (C) 2018 Milan Stute
*
* 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 .
*/
#ifndef AWDL_FRAME_H_
#define AWDL_FRAME_H_
#include
#include "ieee80211.h"
#define AWDL_LLC_PROTOCOL_ID 0x0800
#define AWDL_OUI (struct oui){{ 0x00, 0x17, 0xf2 }}
#define AWDL_BSSID (struct ether_addr){{ 0x00, 0x25, 0x00, 0xff, 0x94, 0x73 }}
#define IEEE80211_VENDOR_SPECIFIC 127
#define AWDL_VERSION_COMPAT awdl_version(1, 0)
#define AWDL_TYPE 8
struct awdl_data {
uint16_t head; /* AWDL_DATA_HEAD */
uint16_t seq;
uint16_t pad; /* AWDL_DATA_PAD */
uint16_t ethertype;
} __attribute__((__packed__));
struct awdl_action {
uint8_t category; /* 127 - vendor-specific */
struct oui oui;
uint8_t type;
uint8_t version;
uint8_t subtype; /* awdl_frame_types */
uint8_t reserved;
uint32_t phy_tx;
uint32_t target_tx;
} __attribute__((__packed__));
enum awdl_action_type {
AWDL_ACTION_PSF = 0,
AWDL_ACTION_MIF = 3,
};
const char *awdl_frame_as_str(uint8_t type);
/* AWDL TLV type values */
enum awdl_tlvs {
AWDL_SSTH_REQUEST_TLV = 0, /* assumed deprecated */
AWDL_SERVICE_REQUEST_TLV = 1, /* assumed deprecated */
AWDL_SERVICE_RESPONSE_TLV = 2,
AWDL_SYNCHRONIZATON_PARAMETERS_TLV = 4,
AWDL_ELECTION_PARAMETERS_TLV = 5,
AWDL_SERVICE_PARAMETERS_TLV = 6,
AWDL_ENHANCED_DATA_RATE_CAPABILITIES_TLV = 7,
AWDL_ENHANCED_DATA_RATE_OPERATION_TLV = 8, /* assumed deprecated */
AWDL_INFRA_TLV = 9, /* assumed deprecated */
AWDL_INVITE_TLV = 10, /* assumed deprecated */
AWDL_DBG_STRING_TLV = 11, /* assumed deprecated */
AWDL_DATA_PATH_STATE_TLV = 12,
AWDL_ENCAPSULATED_IP_TLV = 13, /* assumed deprecated */
AWDL_DATAPATH_DEBUG_PACKET_LIVE_TLV = 14, /* assumed deprecated */
AWDL_DATAPATH_DEBUG_AF_LIVE_TLV = 15, /* assumed deprecated */
AWDL_ARPA_TLV = 16,
AWDL_IEEE80211_CNTNR_TLV = 17,
AWDL_CHAN_SEQ_TLV = 18,
AWDL_SYNCTREE_TLV = 20,
AWDL_VERSION_TLV = 21,
AWDL_BLOOM_FILTER_TLV = 22,
AWDL_NAN_SYNC_TLV = 23,
AWDL_ELECTION_PARAMETERS_V2_TLV = 24,
};
struct tl {
uint8_t type;
uint16_t length;
} __attribute__((__packed__));
struct awdl_chanseq {
uint8_t count;
uint8_t encoding;
uint8_t duplicate_count;
uint8_t step_count;
uint16_t fill_channel;
} __attribute__((__packed__));
struct awdl_sync_params_tlv {
uint8_t type;
uint16_t length;
uint8_t next_aw_channel;
uint16_t tx_down_counter;
uint8_t master_channel;
uint8_t guard_time;
uint16_t aw_period; /* AW period in TUs */
uint16_t af_period; /* how often action frames are sent out in TUs */
uint16_t flags;
uint16_t aw_ext_length; /* length of an extended AW in TUs */
uint16_t aw_com_length; /* length of a regular AW in TUs */
uint16_t remaining_aw_length;
uint8_t min_ext;
uint8_t max_ext_multicast;
uint8_t max_ext_unicast;
uint8_t max_ext_af;
struct ether_addr master_addr;
uint8_t presence_mode;
uint8_t reserved;
uint16_t next_aw_seq;
uint16_t ap_alignment;
/* struct awdl_chanseq chanseq; */
/* uint8_t pad[2]; */
} __attribute__((__packed__));
struct awdl_chanseq_tlv {
uint8_t type;
uint16_t length;
/* struct awdl_chanseq chanseq; */
/* uint8_t pad[3]; */
} __attribute__((__packed__));
/* AWDL election parameters */
struct awdl_election_params_tlv {
uint8_t type;
uint16_t length;
uint8_t flags;
uint16_t id;
uint8_t distancetop;
uint8_t unknown;
struct ether_addr top_master_addr;
uint32_t top_master_metric;
uint32_t self_metric;
uint8_t pad[2];
} __attribute__((__packed__));
struct awdl_election_params_v2_tlv {
uint8_t type;
uint16_t length;
struct ether_addr master_addr; /* currently elected master */
struct ether_addr sync_addr; /* this is _probably_ the node we currently sync to */
uint32_t master_counter; /* 'self_counter' of currently elected master */
uint32_t distance_to_master;
uint32_t master_metric;
uint32_t self_metric;
uint32_t unknown; /* 0 */
uint32_t reserved; /* 0 */
uint32_t self_counter; /* is incremented by 1 while node is selected as master every PI (3.14) seconds */
} __attribute__((__packed__));
struct awdl_sync_tree_tlv {
uint8_t type;
uint16_t length;
struct ether_addr tree[1];
} __attribute__((__packed__));
struct awdl_service_params_tlv {
uint8_t type;
uint16_t length;
unsigned char unknown[3];
uint16_t sui;
uint32_t bitmask;
} __attribute__((__packed__));
struct awdl_ht_capabilities_tlv {
uint8_t type;
uint16_t length;
uint16_t unknown;
uint16_t ht_capabilities;
uint8_t ampdu_params;
uint8_t rx_mcs;
uint16_t unknown2;
} __attribute__((__packed__));
enum awdl_data_path_state_flags {
AWDL_DATA_PATH_FLAG_COUNTRY_CODE = 0x0100,
AWDL_DATA_PATH_FLAG_SOCIAL_CHANNEL_MAP = 0x0200,
AWDL_DATA_PATH_FLAG_INFRA_INFO = 0x0001,
AWDL_DATA_PATH_FLAG_INFRA_ADDRESS = 0x0002,
AWDL_DATA_PATH_FLAG_AWDL_ADDRESS = 0x0004,
AWDL_DATA_PATH_FLAG_UMI = 0x0010,
/* TODO complete */
};
struct awdl_data_path_state_tlv {
uint8_t type;
uint16_t length;
uint16_t flags;
char country_code[3];
uint16_t social_channels;
struct ether_addr awdl_addr;
uint16_t ext_flags;
/* uint32_t logtrigger_id; if (ext_flags | 0x4) */
} __attribute__((__packed__));
struct awdl_arpa_tlv {
uint8_t type;
uint16_t length;
uint8_t flags; /* 3 is only valid flag
* found in IO80211Family.kext
* method: IO80211ServiceRequestDescriptor::initWithArpaTLV(apple80211_awdl_arpa_tlv *,ether_addr *,userPrintCtx *) */
uint8_t name_length;
char name[1];
/* uint16_t suffix */
} __attribute__((__packed__));
struct awdl_version_tlv {
uint8_t type;
uint16_t length;
uint8_t version;
uint8_t devclass;
} __attribute__((__packed__));
const char *awdl_tlv_as_str(uint8_t type);
#endif /* AWDL_FRAME_H_ */
owl-master/src/hashmap.c 0000664 0000000 0000000 00000014130 13715306717 0015535 0 ustar 00root root 0000000 0000000 /*
* Generic map implementation.
*/
#include "hashmap.h"
#include
#include
#include
#include "siphash24.h"
#define INITIAL_SIZE (256)
#define MAX_CHAIN_LENGTH (8)
/* We need to keep keys and values */
typedef struct _hashmap_element{
mkey_t key;
int in_use;
any_t data;
} hashmap_element;
/* A hashmap has some maximum size and current size,
* as well as the data to hold. */
typedef struct _hashmap_map{
int table_size;
int size;
int key_size; /* size of user's mkey_t in bytes */
hashmap_element *data;
unsigned char seed[siphash24_KEYBYTES];
} hashmap_map;
/*
* Return an empty hashmap, or NULL on failure.
*/
map_t hashmap_new(int key_size) {
hashmap_map* m = (hashmap_map*) malloc(sizeof(hashmap_map));
if(!m) goto err;
m->data = (hashmap_element*) calloc(INITIAL_SIZE, sizeof(hashmap_element));
if(!m->data) goto err;
m->table_size = INITIAL_SIZE;
m->size = 0;
m->key_size = key_size;
/* TODO init seed randomly */
memset(m->seed, 0, siphash24_KEYBYTES);
return m;
err:
if (m)
hashmap_free(m);
return NULL;
}
/*
* Hashing function for a string
*/
unsigned int hashmap_hash_int(hashmap_map *m, mkey_t key) {
uint64_t hash;
siphash24((unsigned char *) &hash, key, m->key_size, m->seed);
return hash % m->table_size;
}
/*
* Return the integer of the location in data
* to store the point to the item, or MAP_FULL.
*/
int hashmap_hash(map_t in, mkey_t key){
int curr;
int i;
/* Cast the hashmap */
hashmap_map* m = (hashmap_map *) in;
/* If full, return immediately */
if(m->size >= (m->table_size/2)) return MAP_FULL;
/* Find the best index */
curr = hashmap_hash_int(m, key);
/* Linear probing */
for(i = 0; i< MAX_CHAIN_LENGTH; i++){
if(m->data[curr].in_use == 0)
return curr;
if (m->data[curr].in_use == 1 && (memcmp(m->data[curr].key, key, m->key_size) == 0))
return curr;
curr = (curr + 1) % m->table_size;
}
return MAP_FULL;
}
/*
* Doubles the size of the hashmap, and rehashes all the elements
*/
enum map_status hashmap_rehash(map_t in){
int i;
int old_size;
hashmap_element* curr;
/* Setup the new elements */
hashmap_map *m = (hashmap_map *) in;
hashmap_element* temp = (hashmap_element *)
calloc(2 * m->table_size, sizeof(hashmap_element));
if(!temp) return MAP_OMEM;
/* Update the array */
curr = m->data;
m->data = temp;
/* Update the size */
old_size = m->table_size;
m->table_size = 2 * m->table_size;
m->size = 0;
/* Rehash the elements */
for(i = 0; i < old_size; i++){
int status;
if (curr[i].in_use == 0)
continue;
status = hashmap_put(m, curr[i].key, curr[i].data);
if (status != MAP_OK)
return status;
}
free(curr);
return MAP_OK;
}
/*
* Add a pointer to the hashmap with some key
*/
enum map_status hashmap_put(map_t in, mkey_t key, any_t value){
int index;
hashmap_map* m;
/* Cast the hashmap */
m = (hashmap_map *) in;
/* Find a place to put our value */
index = hashmap_hash(in, key);
while(index == MAP_FULL){
if (hashmap_rehash(in) == MAP_OMEM) {
return MAP_OMEM;
}
index = hashmap_hash(in, key);
}
/* Set the data */
m->data[index].data = value;
m->data[index].key = key;
m->data[index].in_use = 1;
m->size++;
return MAP_OK;
}
/*
* Get your pointer out of the hashmap with a key
*/
enum map_status hashmap_get(map_t in, mkey_t key, any_t *arg, int remove) {
int curr;
int i;
hashmap_map* m;
/* Cast the hashmap */
m = (hashmap_map *) in;
/* Find data location */
curr = hashmap_hash_int(m, key);
/* Linear probing, if necessary */
for(i = 0; idata[curr].in_use;
if (in_use == 1){
if (memcmp(m->data[curr].key, key, m->key_size) == 0) {
if (arg)
*arg = (m->data[curr].data);
if (remove) {
/* Blank out the fields */
m->data[curr].in_use = 0;
m->data[curr].data = NULL;
m->data[curr].key = NULL;
/* Reduce the size */
m->size--;
}
return MAP_OK;
}
}
curr = (curr + 1) % m->table_size;
}
if (arg)
*arg = NULL;
/* Not found */
return MAP_MISSING;
}
/* Deallocate the hashmap */
void hashmap_free(map_t in){
hashmap_map* m = (hashmap_map*) in;
free(m->data);
free(m);
}
/* Return the length of the hashmap */
int hashmap_length(map_t in){
hashmap_map* m = (hashmap_map *) in;
if(m != NULL) return m->size;
else return 0;
}
typedef struct _hashmap_it {
hashmap_map *map;
int i; /* current index */
} hashmap_it;
/**
* Get a new iterator.
* @param in the hashmap
* @return a new iterator of hashmap
*/
map_it_t hashmap_it_new(map_t in) {
hashmap_it *it = (hashmap_it *) malloc(sizeof(hashmap_it));
it->map = (hashmap_map *) in;
it->i = -1;
return (map_it_t) it;
}
/**
* Get next element in hashmap. You should not modify the the map while iterating.
* @param it hashmap iterator
* @param key set to current element's key if return MAP_OK
* @param value set to current element's value if return MAP_OK
* @return MAP_OK if had next, MAP_MISSING otherwise
*/
enum map_status hashmap_it_next(map_it_t _it, mkey_t *key, any_t *value) {
hashmap_it *it = (hashmap_it *) _it;
/* Linear probing */
for (it->i++; it->i < it->map->table_size; it->i++)
if (it->map->data[it->i].in_use != 0) {
if (key)
*key = it->map->data[it->i].key;
if (value)
*value = (any_t) (it->map->data[it->i].data);
return MAP_OK;
}
return MAP_MISSING;
}
/**
* Removes current element from hashmap.
* @param it hashmap iterator
* @return MAP_OK if iterator points to valid element, MAP_MISSING otherwise
*/
enum map_status hashmap_it_remove(map_it_t _it) {
hashmap_it *it = (hashmap_it *) _it;
if (it->i < 0 || it->i >= it->map->table_size)
return MAP_MISSING;
if (!it->map->data[it->i].in_use)
/* could be that we are calling remove on an already removed element */
return MAP_MISSING;
it->map->data[it->i].in_use = 0;
it->map->data[it->i].data = NULL;
it->map->data[it->i].key = NULL;
/* Reduce the size */
it->map->size--;
return MAP_OK;
}
/**
* Frees interator. {@code it} must not be used after calling this method.
* @param it hashmap iterator
*/
void hashmap_it_free(map_it_t _it) {
hashmap_it *it = (hashmap_it *) _it;
free(it);
}
owl-master/src/hashmap.h 0000664 0000000 0000000 00000005143 13715306717 0015546 0 ustar 00root root 0000000 0000000 /*
* Generic hashmap manipulation functions
*
* Originally by Elliot C Back - http://elliottback.com/wp/hashmap-implementation-in-c/
*
* Modified by Pete Warden to fix a serious performance problem, support strings as keys
* and removed thread synchronization - http://petewarden.typepad.com
*
* Modified by Milan Stute to support arbitrary key types.
*/
#ifndef __HASHMAP_H__
#define __HASHMAP_H__
#include
enum map_status {
MAP_OK = 0, /* OK */
MAP_OMEM = -1, /* Out of Memory */
MAP_FULL = -2, /* Hashmap is full */
MAP_MISSING = -3, /* No such element */
};
/*
* any_t is a pointer. This allows you to put arbitrary structures in
* the hashmap.
*/
typedef void *any_t;
/*
* Key can be anything. But user has to provide byte length of type.
*/
typedef any_t mkey_t;
/*
* map_t is a pointer to an internally maintained data structure.
* Clients of this package do not need to know how hashmaps are
* represented. They see and manipulate only map_t's.
*/
typedef any_t map_t;
/*
* Return an empty hashmap. Returns NULL if empty.
*/
extern map_t hashmap_new(int mkey_len);
/*
* Add an element to the hashmap. Return MAP_OK or MAP_OMEM.
*/
extern enum map_status hashmap_put(map_t in, mkey_t key, any_t value);
/*
* Get an element from the hashmap. Return MAP_OK or MAP_MISSING.
* If remove is true, element will be removed if it exists.
* arg will be set to the value if found, can be NULL if not required
*/
extern enum map_status hashmap_get(map_t in, mkey_t key, any_t *arg, int remove);
/*
* Free the hashmap
*/
extern void hashmap_free(map_t in);
/*
* Get the current size of a hashmap
*/
extern int hashmap_length(map_t in);
/**
* Opaque iterator type
*/
typedef any_t map_it_t;
/**
* Get a new iterator.
* @param in the hashmap
* @return a new iterator of hashmap
*/
extern map_it_t hashmap_it_new(map_t in);
/**
* Get next element in hashmap. You should not modify the the map while iterating.
* @param it hashmap iterator
* @param key set to current element's key if return MAP_OK
* @param value set to current element's value if return MAP_OK
* @return MAP_OK if had next, MAP_MISSING otherwise
*/
extern enum map_status hashmap_it_next(map_it_t it, mkey_t *key, any_t *value);
/**
* Removes current element from hashmap.
* @param it hashmap iterator
* @return MAP_OK if iterator points to valid element, MAP_MISSING otherwise
*/
extern enum map_status hashmap_it_remove(map_it_t it);
/**
* Frees interator. {@code it} must not be used after calling this method.
* @param it hashmap iterator
*/
extern void hashmap_it_free(map_it_t it);
#endif /* __HASHMAP_H__ */
owl-master/src/ieee80211.h 0000664 0000000 0000000 00000012353 13715306717 0015431 0 ustar 00root root 0000000 0000000 #ifndef IEEE80211_H_
#define IEEE80211_H_
#include
#ifdef __APPLE__
#include
#else
#include
#endif
/* Some relevant Ethernet Protocol IDs */
#define ETH_P_IP 0x0800 /* Internet Protocol packet */
#define ETH_P_IPV6 0x86DD /* IPv6 over bluebook */
#define OUI_LEN 3
struct oui {
uint8_t byte[OUI_LEN];
} __attribute__((__packed__));
#define FCS_LEN 4
#define IEEE80211_FCTL_VERS 0x0003
#define IEEE80211_FCTL_FTYPE 0x000c
#define IEEE80211_FCTL_STYPE 0x00f0
#define IEEE80211_FCTL_TODS 0x0100
#define IEEE80211_FCTL_FROMDS 0x0200
#define IEEE80211_FCTL_MOREFRAGS 0x0400
#define IEEE80211_FCTL_RETRY 0x0800
#define IEEE80211_FCTL_PM 0x1000
#define IEEE80211_FCTL_MOREDATA 0x2000
#define IEEE80211_FCTL_PROTECTED 0x4000
#define IEEE80211_FCTL_ORDER 0x8000
#define IEEE80211_FCTL_CTL_EXT 0x0f00
#define IEEE80211_SCTL_FRAG 0x000F
#define IEEE80211_SCTL_SEQ 0xFFF0
#define IEEE80211_FTYPE_MGMT 0x0000
#define IEEE80211_FTYPE_CTL 0x0004
#define IEEE80211_FTYPE_DATA 0x0008
#define IEEE80211_FTYPE_EXT 0x000c
/* management */
#define IEEE80211_STYPE_ASSOC_REQ 0x0000
#define IEEE80211_STYPE_ASSOC_RESP 0x0010
#define IEEE80211_STYPE_REASSOC_REQ 0x0020
#define IEEE80211_STYPE_REASSOC_RESP 0x0030
#define IEEE80211_STYPE_PROBE_REQ 0x0040
#define IEEE80211_STYPE_PROBE_RESP 0x0050
#define IEEE80211_STYPE_BEACON 0x0080
#define IEEE80211_STYPE_ATIM 0x0090
#define IEEE80211_STYPE_DISASSOC 0x00A0
#define IEEE80211_STYPE_AUTH 0x00B0
#define IEEE80211_STYPE_DEAUTH 0x00C0
#define IEEE80211_STYPE_ACTION 0x00D0
/* control */
#define IEEE80211_STYPE_CTL_EXT 0x0060
#define IEEE80211_STYPE_BACK_REQ 0x0080
#define IEEE80211_STYPE_BACK 0x0090
#define IEEE80211_STYPE_PSPOLL 0x00A0
#define IEEE80211_STYPE_RTS 0x00B0
#define IEEE80211_STYPE_CTS 0x00C0
#define IEEE80211_STYPE_ACK 0x00D0
#define IEEE80211_STYPE_CFEND 0x00E0
#define IEEE80211_STYPE_CFENDACK 0x00F0
/* data */
#define IEEE80211_STYPE_DATA 0x0000
#define IEEE80211_STYPE_DATA_CFACK 0x0010
#define IEEE80211_STYPE_DATA_CFPOLL 0x0020
#define IEEE80211_STYPE_DATA_CFACKPOLL 0x0030
#define IEEE80211_STYPE_NULLFUNC 0x0040
#define IEEE80211_STYPE_CFACK 0x0050
#define IEEE80211_STYPE_CFPOLL 0x0060
#define IEEE80211_STYPE_CFACKPOLL 0x0070
#define IEEE80211_STYPE_QOS_DATA 0x0080
#define IEEE80211_STYPE_QOS_DATA_CFACK 0x0090
#define IEEE80211_STYPE_QOS_DATA_CFPOLL 0x00A0
#define IEEE80211_STYPE_QOS_DATA_CFACKPOLL 0x00B0
#define IEEE80211_STYPE_QOS_NULLFUNC 0x00C0
#define IEEE80211_STYPE_QOS_CFACK 0x00D0
#define IEEE80211_STYPE_QOS_CFPOLL 0x00E0
#define IEEE80211_STYPE_QOS_CFACKPOLL 0x00F0
/* extension, added by 802.11ad */
#define IEEE80211_STYPE_DMG_BEACON 0x0000
/* control extension - for IEEE80211_FTYPE_CTL | IEEE80211_STYPE_CTL_EXT */
#define IEEE80211_CTL_EXT_POLL 0x2000
#define IEEE80211_CTL_EXT_SPR 0x3000
#define IEEE80211_CTL_EXT_GRANT 0x4000
#define IEEE80211_CTL_EXT_DMG_CTS 0x5000
#define IEEE80211_CTL_EXT_DMG_DTS 0x6000
#define IEEE80211_CTL_EXT_SSW 0x8000
#define IEEE80211_CTL_EXT_SSW_FBACK 0x9000
#define IEEE80211_CTL_EXT_SSW_ACK 0xa000
/* Maximum size for the MA-UNITDATA primitive, 802.11 standard section
6.2.1.1.2.
802.11e clarifies the figure in section 7.1.2. The frame body is
up to 2304 octets long (maximum MSDU size) plus any crypt overhead. */
#define IEEE80211_MAX_DATA_LEN 2304
/* 30 byte 4 addr hdr, 2 byte QoS, 2304 byte MSDU, 12 byte crypt, 4 byte FCS */
#define IEEE80211_MAX_FRAME_LEN 2352
#define IEEE80211_QOS_CTL_LEN 2
/* 1d tag mask */
#define IEEE80211_QOS_CTL_TAG1D_MASK 0x0007
/* TID mask */
#define IEEE80211_QOS_CTL_TID_MASK 0x000f
/* EOSP */
#define IEEE80211_QOS_CTL_EOSP 0x0010
/* ACK policy */
#define IEEE80211_QOS_CTL_ACK_POLICY_NORMAL 0x0000
#define IEEE80211_QOS_CTL_ACK_POLICY_NOACK 0x0020
#define IEEE80211_QOS_CTL_ACK_POLICY_NO_EXPL 0x0040
#define IEEE80211_QOS_CTL_ACK_POLICY_BLOCKACK 0x0060
#define IEEE80211_QOS_CTL_ACK_POLICY_MASK 0x0060
/* A-MSDU 802.11n */
#define IEEE80211_QOS_CTL_A_MSDU_PRESENT 0x0080
/* Mesh Control 802.11s */
#define IEEE80211_QOS_CTL_MESH_CONTROL_PRESENT 0x0100
/* Mesh Power Save Level */
#define IEEE80211_QOS_CTL_MESH_PS_LEVEL 0x0200
/* Mesh Receiver Service Period Initiated */
#define IEEE80211_QOS_CTL_RSPI 0x0400
/*
* 802.11n Management Action Frames
*
* Adapted from 'ieee80211_hdr_3addr' in
*/
struct ieee80211_hdr {
uint16_t frame_control;
uint16_t duration_id;
struct ether_addr addr1; /* dst */
struct ether_addr addr2; /* src */
struct ether_addr addr3; /* bssid */
uint16_t seq_ctrl;
} __attribute__((__packed__));
struct llc_hdr {
uint8_t dsap;
uint8_t ssap;
uint8_t control;
/* SNAP extension */
struct oui oui;
uint16_t pid;
} __attribute__((__packed__));
/**
* ieee80211_tu_to_usec - convert time units (TU) to microseconds
* @tu: the TUs
*/
static inline unsigned long ieee80211_tu_to_usec(unsigned long tu) {
return 1024 * tu;
}
static inline unsigned long ieee80211_usec_to_tu(unsigned long usec) {
return usec / 1024;
}
int ieee80211_channel_to_frequency(int chan);
int ieee80211_frequency_to_channel(int freq);
static inline int ieee80211_radiotap_type_to_mask(int type) {
return 1 << type;
}
static inline int ieee80211_radiotap_rate_to_val(int rate) {
return 2 * rate;
}
#endif /* IEEE80211_H_ */
owl-master/src/log.c 0000664 0000000 0000000 00000005705 13715306717 0014705 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2017 rxi
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to
* deal in the Software without restriction, including without limitation the
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
* sell copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
* IN THE SOFTWARE.
*/
#include
#include
#include
#include
#include
#include "log.h"
static struct {
void *udata;
log_LockFn lock;
FILE *fp;
int level;
int quiet;
} L;
static const char *level_names[] = {
"EMERG", "ALERT", "CRIT", "ERROR", "WARN", "NOTICE", "INFO", "DEBUG", "TRACE"
};
#ifdef LOG_USE_COLOR
static const char *level_colors[] = {
"\x1b[94m", "\x1b[36m", "\x1b[32m", "\x1b[33m", "\x1b[31m", "\x1b[35m"
};
#endif
static void lock(void) {
if (L.lock) {
L.lock(L.udata, 1);
}
}
static void unlock(void) {
if (L.lock) {
L.lock(L.udata, 0);
}
}
void log_set_udata(void *udata) {
L.udata = udata;
}
void log_set_lock(log_LockFn fn) {
L.lock = fn;
}
void log_set_fp(FILE *fp) {
L.fp = fp;
}
void log_set_level(int level) {
L.level = level;
}
void log_set_quiet(int enable) {
L.quiet = enable ? 1 : 0;
}
int log_log(int level, const char *file, int line, const char *fmt, ...) {
if (level > L.level) {
return 0;
}
/* Acquire lock */
lock();
/* Get current time */
time_t t = time(NULL);
struct tm lt;
localtime_r(&t, <);
/* Log to stderr */
if (!L.quiet) {
va_list args;
char buf[16];
buf[strftime(buf, sizeof(buf), "%H:%M:%S", <)] = '\0';
#ifdef LOG_USE_COLOR
fprintf(
stderr, "%s %s%-5s\x1b[0m \x1b[90m%s:%d:\x1b[0m ",
buf, level_colors[level], level_names[level], file, line);
#else
fprintf(stderr, "%s %-5s: ", buf, level_names[level]);
#endif
va_start(args, fmt);
vfprintf(stderr, fmt, args);
va_end(args);
fprintf(stderr, "\n");
}
/* Log to file */
if (L.fp) {
va_list args;
char buf[32];
buf[strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", <)] = '\0';
fprintf(L.fp, "%s %-6s %s:%d: ", buf, level_names[level], file, line);
va_start(args, fmt);
vfprintf(L.fp, fmt, args);
va_end(args);
fprintf(L.fp, "\n");
}
/* Release lock */
unlock();
return 1;
}
owl-master/src/log.h 0000664 0000000 0000000 00000003051 13715306717 0014702 0 ustar 00root root 0000000 0000000 /**
* Copyright (c) 2017 rxi
*
* This library is free software; you can redistribute it and/or modify it
* under the terms of the MIT license. See `log.c` for details.
*/
#ifndef LOG_H
#define LOG_H
#include
#include
#define LOG_VERSION "0.1.0"
typedef void (*log_LockFn)(void *udata, int lock);
#ifndef LOG_CRIT
#define LOG_EMERG 0 /* system is unusable */
#define LOG_ALERT 1 /* action must be taken immediately */
#define LOG_CRIT 2 /* critical conditions */
#define LOG_ERR 3 /* error conditions */
#define LOG_WARNING 4 /* warning conditions */
#define LOG_NOTICE 5 /* normal but significant condition */
#define LOG_INFO 6 /* informational */
#define LOG_DEBUG 7 /* debug-level messages */
#endif
#define LOG_TRACE 8 /* trace-level messages */
#define log_crit(...) log_log(LOG_CRIT, __FILE__, __LINE__, __VA_ARGS__)
#define log_error(...) log_log(LOG_ERR, __FILE__, __LINE__, __VA_ARGS__)
#define log_warn(...) log_log(LOG_WARNING, __FILE__, __LINE__, __VA_ARGS__)
#define log_notice(...) log_log(LOG_NOTICE, __FILE__, __LINE__, __VA_ARGS__)
#define log_info(...) log_log(LOG_INFO, __FILE__, __LINE__, __VA_ARGS__)
#define log_debug(...) log_log(LOG_DEBUG, __FILE__, __LINE__, __VA_ARGS__)
#define log_trace(...) log_log(LOG_TRACE, __FILE__, __LINE__, __VA_ARGS__)
void log_set_udata(void *udata);
void log_set_lock(log_LockFn fn);
void log_set_fp(FILE *fp);
void log_set_level(int level);
void log_set_quiet(int enable);
int log_log(int level, const char *file, int line, const char *fmt, ...);
#endif
owl-master/src/peers.c 0000664 0000000 0000000 00000013576 13715306717 0015247 0 ustar 00root root 0000000 0000000 /*
* OWL: an open Apple Wireless Direct Link (AWDL) implementation
* Copyright (C) 2018 The Open Wireless Link Project (https://owlink.org)
* Copyright (C) 2018 Milan Stute
*
* 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 .
*/
#include
#include
#include
#include "peers.h"
#include "hashmap.h"
#include "log.h"
#define PEERS_DEFAULT_TIMEOUT 2000000 /* in ms */
#define PEERS_DEFAULT_CLEAN_INTERVAL 1000000 /* in ms */
void awdl_peer_state_init(struct awdl_peer_state *state) {
state->peers = awdl_peers_init();
state->timeout = PEERS_DEFAULT_TIMEOUT;
state->clean_interval = PEERS_DEFAULT_CLEAN_INTERVAL;
}
awdl_peers_t awdl_peers_init() {
return (awdl_peers_t) hashmap_new(sizeof(struct ether_addr));
}
void awdl_peers_free(awdl_peers_t peers) {
struct awdl_peer *peer;
map_t map = (map_t) peers;
/* Remove all allocated peers */
map_it_t it = hashmap_it_new(map);
while (hashmap_it_next(it, NULL, (any_t *) &peer) == MAP_OK) {
hashmap_it_remove(it);
free(peer);
}
hashmap_it_free(it);
/* Remove hashmap itself */
hashmap_free(peers);
}
int awdl_peers_length(awdl_peers_t peers) {
map_t map = (map_t) peers;
return hashmap_length(map);
}
static int awdl_peer_is_valid(const struct awdl_peer *peer) {
return peer->sent_mif && peer->devclass && peer->version;
}
struct awdl_peer *awdl_peer_new(const struct ether_addr *addr) {
struct awdl_peer *peer = (struct awdl_peer *) malloc(sizeof(struct awdl_peer));
*(struct ether_addr *) &peer->addr = *addr;
peer->last_update = 0;
awdl_election_state_init(&peer->election, addr);
awdl_chanseq_init_static(peer->sequence, &CHAN_NULL);
peer->sync_offset = 0;
peer->devclass = 0;
peer->version = 0;
peer->supports_v2 = 0;
peer->sent_mif = 0;
strcpy(peer->name, "");
strcpy(peer->country_code, "NA");
peer->is_valid = 0;
return peer;
}
enum peers_status
awdl_peer_add(awdl_peers_t peers, const struct ether_addr *_addr, uint64_t now, awdl_peer_cb cb, void *arg) {
int status, result;
map_t map = (map_t) peers;
mkey_t addr = (mkey_t) _addr;
struct awdl_peer *peer;
status = hashmap_get(map, addr, (any_t *) &peer, 0 /* do not remove */);
if (status == MAP_MISSING)
peer = awdl_peer_new(_addr); /* create new entry */
/* update */
peer->last_update = now;
if (status == MAP_OK) {
result = PEERS_UPDATE;
goto out;
}
status = hashmap_put(map, (mkey_t) &peer->addr, peer);
if (status != MAP_OK) {
free(peer);
return PEERS_INTERNAL;
}
result = PEERS_OK;
out:
if (!peer->is_valid && awdl_peer_is_valid(peer)) {
/* peer has turned valid */
peer->is_valid = 1;
log_info("add peer %s (%s)", ether_ntoa(&peer->addr), peer->name);
if (cb)
cb(peer, arg);
}
return result;
}
enum peers_status awdl_peer_remove(awdl_peers_t peers, const struct ether_addr *_addr, awdl_peer_cb cb, void *arg) {
int status;
map_t map = (map_t) peers;
mkey_t addr = (mkey_t) _addr;
struct awdl_peer *peer;
status = hashmap_get(map, addr, (any_t *) &peer, 1 /* remove */);
if (status == MAP_MISSING)
return PEERS_MISSING;
if (peer->is_valid) {
log_info("remove peer %s (%s)", ether_ntoa(&peer->addr), peer->name);
if (cb)
cb(peer, arg);
}
free(peer);
return PEERS_OK;
}
enum peers_status awdl_peer_get(awdl_peers_t peers, const struct ether_addr *_addr, struct awdl_peer **peer) {
int status;
map_t map = (map_t) peers;
mkey_t addr = (mkey_t) _addr;
status = hashmap_get(map, addr, (any_t *) peer, 0 /* keep */);
if (status == MAP_MISSING)
return PEERS_MISSING;
return PEERS_OK;
}
int awdl_peer_print(const struct awdl_peer *peer, char *str, int len) {
char *cur = str, *const end = str + len;
if (strlen(peer->name))
cur += snprintf(cur, cur < end ? end - cur : 0, "%s: ", peer->name);
else
cur += snprintf(cur, cur < end ? end - cur : 0, ": ");
cur += awdl_election_tree_print(&peer->election, cur, end - cur);
return cur - str;
}
int awdl_peers_print(awdl_peers_t peers, char *str, int len) {
char *cur = str, *const end = str + len;
map_t map = (map_t) peers;
map_it_t it = hashmap_it_new(map);
struct awdl_peer *peer;
while (hashmap_it_next(it, NULL, (any_t *) &peer) == MAP_OK) {
cur += awdl_peer_print(peer, cur, end - cur);
cur += snprintf(cur, cur < end ? end - cur : 0, "\n");
}
hashmap_it_free(it);
return cur - str;
}
void awdl_peers_remove(awdl_peers_t peers, uint64_t before, awdl_peer_cb cb, void *arg) {
map_t map = (map_t) peers;
map_it_t it = hashmap_it_new(map);
struct awdl_peer *peer;
while (hashmap_it_next(it, NULL, (any_t *) &peer) == MAP_OK) {
if (peer->last_update < before) {
if (peer->is_valid) {
log_info("remove peer %s (%s)", ether_ntoa(&peer->addr), peer->name);
if (cb)
cb(peer, arg);
}
hashmap_it_remove(it);
free(peer);
}
}
hashmap_it_free(it);
}
awdl_peers_it_t awdl_peers_it_new(awdl_peers_t in) {
return (awdl_peers_it_t) hashmap_it_new((map_t) in);
}
enum peers_status awdl_peers_it_next(awdl_peers_it_t it, struct awdl_peer **peer) {
int s = hashmap_it_next((map_it_t) it, 0, (any_t *) peer);
if (s == MAP_OK)
return PEERS_OK;
else
return PEERS_MISSING;
}
enum peers_status awdl_peers_it_remove(awdl_peers_it_t it) {
int s = hashmap_it_remove((map_it_t) it);
if (s == MAP_OK)
return PEERS_OK;
else
return PEERS_MISSING;
}
void awdl_peers_it_free(awdl_peers_it_t it) {
hashmap_it_free((map_it_t) it);
}
owl-master/src/peers.h 0000664 0000000 0000000 00000006146 13715306717 0015247 0 ustar 00root root 0000000 0000000 /*
* OWL: an open Apple Wireless Direct Link (AWDL) implementation
* Copyright (C) 2018 The Open Wireless Link Project (https://owlink.org)
* Copyright (C) 2018 Milan Stute
*
* 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 .
*/
#ifndef AWDL_PEERS_H
#define AWDL_PEERS_H
#include
#include
#include "election.h"
#include "channel.h"
#define HOST_NAME_LENGTH_MAX 64
enum peers_status {
PEERS_UPDATE = 1, /* Peer updated */
PEERS_OK = 0, /* New peer added */
PEERS_MISSING = -1, /* Peer does not exist */
PEERS_INTERNAL = -2, /* Internal error */
};
struct awdl_peer {
const struct ether_addr addr;
uint64_t last_update;
struct awdl_election_state election;
struct awdl_chan sequence[AWDL_CHANSEQ_LENGTH];
uint64_t sync_offset;
char name[HOST_NAME_LENGTH_MAX + 1]; /* space for trailing zero */
char country_code[2 + 1];
struct ether_addr infra_addr;
uint8_t version;
uint8_t devclass;
uint8_t supports_v2 : 1;
uint8_t sent_mif : 1;
uint8_t is_valid : 1;
};
typedef void (*awdl_peer_cb)(struct awdl_peer *, void *arg);
typedef void *awdl_peers_t;
struct awdl_peer_state {
awdl_peers_t peers;
uint64_t timeout;
uint64_t clean_interval;
};
void awdl_peer_state_init(struct awdl_peer_state *state);
awdl_peers_t awdl_peers_init();
void awdl_peers_free(awdl_peers_t peers);
int awdl_peers_length(awdl_peers_t peers);
enum peers_status
awdl_peer_add(awdl_peers_t peers, const struct ether_addr *addr, uint64_t now, awdl_peer_cb cb, void *arg);
enum peers_status awdl_peer_remove(awdl_peers_t peers, const struct ether_addr *addr, awdl_peer_cb cb, void *arg);
enum peers_status awdl_peer_get(awdl_peers_t peers, const struct ether_addr *addr, struct awdl_peer **peer);
int awdl_peer_print(const struct awdl_peer *peer, char *str, int len);
/**
* Apply callback to and then remove all peers matching a filter
* @param peers the awdl_peers_t instance
* @param before remove all entries with an last_update timestamp {@code before}
* @param cb the callback function, can be NULL
* @param arg will be passed to callback function
*/
void awdl_peers_remove(awdl_peers_t peers, uint64_t before, awdl_peer_cb cb, void *arg);
int awdl_peers_print(awdl_peers_t peers, char *str, int len);
/* Iterator functions */
typedef void *awdl_peers_it_t;
awdl_peers_it_t awdl_peers_it_new(awdl_peers_t in);
enum peers_status awdl_peers_it_next(awdl_peers_it_t it, struct awdl_peer **peer);
enum peers_status awdl_peers_it_remove(awdl_peers_it_t it);
void awdl_peers_it_free(awdl_peers_it_t it);
#endif /* ADWL_PEERS_H */
owl-master/src/rx.c 0000664 0000000 0000000 00000042521 13715306717 0014552 0 ustar 00root root 0000000 0000000 /*
* OWL: an open Apple Wireless Direct Link (AWDL) implementation
* Copyright (C) 2018 The Open Wireless Link Project (https://owlink.org)
* Copyright (C) 2018 Milan Stute
*
* 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 .
*/
#include
#include
#include
#include
#include
#include
#include "rx.h"
#include "sync.h"
#include "wire.h"
#include "log.h"
#define AWDL_SYNC_THRESHOLD 3
int awdl_handle_sync_params_tlv(struct awdl_peer *src, const struct buf *val, struct awdl_state *state, uint64_t now) {
uint16_t aw_counter_master;
uint16_t time_to_next_aw_master;
int64_t sync_err_tu;
if (!awdl_election_is_sync_master(&state->election, &src->addr))
return RX_IGNORE; /* ignore sync params from nodes that are not our master */
/* TODO synchronization could be more accurate */
READ_LE16(val, 1, &time_to_next_aw_master);
READ_LE16(val, 29, &aw_counter_master);
state->sync.meas_total++;
sync_err_tu = awdl_sync_error_tu(now, time_to_next_aw_master, aw_counter_master, &state->sync);
if (sync_err_tu > AWDL_SYNC_THRESHOLD || sync_err_tu < -AWDL_SYNC_THRESHOLD) {
state->sync.meas_err++;
log_trace("Sync error %d TU (%.02f %%)", sync_err_tu, state->sync.meas_err * 100.0 / state->sync.meas_total);
}
awdl_sync_update_last(now, time_to_next_aw_master, aw_counter_master, &state->sync);
return RX_OK;
wire_error:
return RX_TOO_SHORT;
}
int awdl_handle_chanseq_tlv(struct awdl_peer *src, const struct buf *val,
struct awdl_state *state __attribute__((unused))) {
uint8_t count;
uint8_t encoding;
uint8_t duplicate_count;
uint8_t step_count;
uint16_t fill_channel;
struct awdl_chan list[AWDL_CHANSEQ_LENGTH];
int size;
/* read and sanity check, we do not support any other configuration */
READ_U8(val, 0, &count);
if (count + 1 != AWDL_CHANSEQ_LENGTH)
return RX_UNEXPECTED_VALUE;
READ_U8(val, 2, &duplicate_count);
if (duplicate_count > 0)
return RX_UNEXPECTED_VALUE;
READ_U8(val, 3, &step_count);
if (step_count + 1 != state->sync.presence_mode)
return RX_UNEXPECTED_VALUE;
READ_LE16(val, 4, &fill_channel);
if (fill_channel != 0xffff)
return RX_UNEXPECTED_VALUE;
READ_U8(val, 1, &encoding);
size = awdl_chan_encoding_size(encoding);
if (size < 1)
return RX_UNEXPECTED_VALUE;
for (int i = 0, offset = 6; i < AWDL_CHANSEQ_LENGTH; i++, offset += size)
READ_BYTES_COPY(val, offset, list[i].val, size);
if (memcmp(src->sequence, list, sizeof(list))) {
log_debug("peer %s (%s) changed channel sequence to %d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d",
ether_ntoa(&src->addr), src->name,
awdl_chan_num(list[0], encoding), awdl_chan_num(list[1], encoding),
awdl_chan_num(list[2], encoding), awdl_chan_num(list[3], encoding),
awdl_chan_num(list[4], encoding), awdl_chan_num(list[5], encoding),
awdl_chan_num(list[6], encoding), awdl_chan_num(list[7], encoding),
awdl_chan_num(list[8], encoding), awdl_chan_num(list[9], encoding),
awdl_chan_num(list[10], encoding), awdl_chan_num(list[11], encoding),
awdl_chan_num(list[12], encoding), awdl_chan_num(list[13], encoding),
awdl_chan_num(list[14], encoding), awdl_chan_num(list[15], encoding));
memcpy(src->sequence, list, sizeof(list));
}
return RX_OK;
wire_error:
return RX_TOO_SHORT;
}
int awdl_handle_election_params_tlv(struct awdl_peer *src, const struct buf *val,
struct awdl_state *state __attribute__((unused))) {
uint8_t distance_to_master;
if (src->supports_v2)
return 0; /* if node supports election v2, we ignore v1 advertisements */
// READ_U8(val, 0, 0); /* ignore flags */
// READ_LE16(val, 1, 0); /* TODO ignore ID */
READ_U8(val, 3, &distance_to_master);
src->election.height = distance_to_master; // READ_U8(val, 3, &src->election.height);
// READ_U8(val, 4, 0); /* ignore unknown */
READ_ETHER_ADDR(val, 5, &src->election.master_addr);
READ_LE32(val, 11, &src->election.master_metric);
READ_LE32(val, 15, &src->election.self_metric);
// READ_LE16(val, 19, 0); /* padding */
return RX_OK;
wire_error:
return RX_TOO_SHORT;
}
int awdl_handle_election_params_v2_tlv(struct awdl_peer *src, const struct buf *val,
struct awdl_state *state __attribute__((unused))) {
READ_LE32(val, 16, &src->election.height);
READ_ETHER_ADDR(val, 0, &src->election.master_addr);
READ_ETHER_ADDR(val, 6, &src->election.sync_addr);
READ_LE32(val, 12, &src->election.master_counter);
READ_LE32(val, 20, &src->election.master_metric);
READ_LE32(val, 24, &src->election.self_metric);
// READ_LE32(val, 28, &tlv->unknown); /* ignore unknown */
// READ_LE32(val, 32, &tlv->reserved); /* ignore reserved */
READ_LE32(val, 36, &src->election.self_counter);
src->supports_v2 = 1;
return RX_OK;
wire_error:
return RX_TOO_SHORT;
}
int awdl_handle_arpa_tlv(struct awdl_peer *src, const struct buf *val,
struct awdl_state *state __attribute__((unused))) {
// READ_U8(val, 0, &flags); /* semantics unclear, ignore */
READ_INT_STRING(val, 1, src->name, HOST_NAME_LENGTH_MAX);
return RX_OK;
wire_error:
return RX_TOO_SHORT;
}
int awdl_handle_data_path_state_tlv(struct awdl_peer *src, const struct buf *val,
struct awdl_state *state __attribute__((unused))) {
uint16_t flags;
int offset = 0;
READ_LE16(val, offset, &flags);
offset += 2;
if (flags & AWDL_DATA_PATH_FLAG_COUNTRY_CODE) {
READ_BYTES_COPY(val, offset, (uint8_t *) src->country_code, 3);
offset += 3;
}
if (flags & AWDL_DATA_PATH_FLAG_SOCIAL_CHANNEL_MAP) {
READ_LE16(val, offset, NULL /* supported social channels */);
offset += 2;
}
if (flags & AWDL_DATA_PATH_FLAG_INFRA_INFO) {
READ_ETHER_ADDR(val, offset, NULL /* BSSID */);
offset += 6;
READ_LE16(val, offset, NULL /* channel */);
offset += 2;
}
if (flags & AWDL_DATA_PATH_FLAG_INFRA_ADDRESS) {
READ_ETHER_ADDR(val, offset, &src->infra_addr);
offset += 6;
}
if (flags & AWDL_DATA_PATH_FLAG_AWDL_ADDRESS) {
READ_ETHER_ADDR(val, offset, NULL /* AWDL address */);
offset += 6;
}
/* TODO complete parsing */
return RX_OK;
wire_error:
return RX_TOO_SHORT;
}
int awdl_handle_version_tlv(struct awdl_peer *src, const struct buf *val,
struct awdl_state *state __attribute__((unused))) {
uint8_t version, devclass;
READ_U8(val, 0, &version);
READ_U8(val, 1, &devclass);
src->version = version;
src->devclass = devclass;
return RX_OK;
wire_error:
return RX_TOO_SHORT;
}
int awdl_handle_tlv(struct awdl_peer *src, uint8_t type, const struct buf *val,
struct awdl_state *state, uint64_t tsft) {
switch (type) {
case AWDL_SYNCHRONIZATON_PARAMETERS_TLV:
return awdl_handle_sync_params_tlv(src, val, state, tsft);
case AWDL_CHAN_SEQ_TLV:
return awdl_handle_chanseq_tlv(src, val, state);
case AWDL_ELECTION_PARAMETERS_TLV:
return awdl_handle_election_params_tlv(src, val, state);
case AWDL_ELECTION_PARAMETERS_V2_TLV:
return awdl_handle_election_params_v2_tlv(src, val, state);
case AWDL_ARPA_TLV:
return awdl_handle_arpa_tlv(src, val, state);
case AWDL_DATA_PATH_STATE_TLV:
return awdl_handle_data_path_state_tlv(src, val, state);
case AWDL_VERSION_TLV:
return awdl_handle_version_tlv(src, val, state);
case AWDL_SYNCTREE_TLV: /* seems to be buggy, not used in our election process */
/* fall through */
default:
log_trace("awdl: not handling %s (%u)", awdl_tlv_as_str(type), type);
return RX_IGNORE;
}
}
int awdl_parse_action_hdr(const struct buf *frame) {
const struct awdl_action *af;
int valid;
READ_BYTES(frame, 0, NULL, sizeof(struct awdl_action));
af = (const struct awdl_action *) buf_data(frame);
valid = af->category == IEEE80211_VENDOR_SPECIFIC &&
!memcmp(&af->oui, &AWDL_OUI, sizeof(AWDL_OUI)) &&
af->type == AWDL_TYPE &&
af->version == AWDL_VERSION_COMPAT;
if (valid && (af->subtype == AWDL_ACTION_PSF || af->subtype == AWDL_ACTION_MIF))
return af->subtype;
wire_error:
return -1;
}
int awdl_rx_action(const struct buf *frame, signed char rssi, uint64_t tsft,
const struct ether_addr *src, const struct ether_addr *dst,
struct awdl_state *state) {
int len;
enum peers_status status;
uint8_t tlv_type;
uint16_t tlv_len;
const uint8_t *tlv_value;
struct awdl_peer *peer;
int subtype;
(void) dst; /* TODO ignore destination address for now, could be used to mitigate desynchronization attack */
subtype = awdl_parse_action_hdr(frame);
if (subtype < 0) {
log_trace("awdl_action: not an action frame"); /* could be block ACK */
return RX_IGNORE;
}
buf_strip(frame, sizeof(struct awdl_action));
if (state->filter_rssi) {
status = awdl_peer_get(state->peers.peers, src, NULL);
if (((status == PEERS_OK) && rssi < state->rssi_threshold + state->rssi_grace) ||
((status == PEERS_MISSING) && rssi < state->rssi_threshold))
return RX_IGNORE_RSSI;
}
state->stats.rx_action++;
/* Update peer table */
status = awdl_peer_add(state->peers.peers, src, tsft, state->peer_cb, state->peer_cb_data);
if (status < 0) {
log_warn("awdl_action: could not add peer: %s (%d)", ether_ntoa(src), status);
return RX_IGNORE;
}
status = awdl_peer_get(state->peers.peers, src, &peer);
if (status < 0) {
log_warn("awdl_action: could not find peer: %s (%d)", ether_ntoa(src), status);
return RX_IGNORE; /* FIXME happens sometimes, not sure why */
}
log_trace("awdl_action: receive %s from %s (rssi %d)", awdl_frame_as_str(subtype), ether_ntoa(&peer->addr), rssi);
while ((len = read_tlv(frame, 0, &tlv_type, &tlv_len, &tlv_value)) > 0) {
const struct buf *tlv_buf = buf_new_const(tlv_value, tlv_len);
int result = awdl_handle_tlv(peer, tlv_type, tlv_buf, state, tsft);
if (state->tlv_cb)
state->tlv_cb(peer, tlv_type, tlv_buf, state, state->tlv_cb_data);
buf_free(tlv_buf);
if (result < 0) {
log_warn("awdl_action: parsing error %s", awdl_tlv_as_str(tlv_type));
return RX_UNEXPECTED_FORMAT;
}
buf_strip(frame, len);
}
if (buf_len(frame) > 0) {
log_debug("awdl_action: unexpected bytes (%d) at end of frame", buf_len(frame));
return RX_UNEXPECTED_FORMAT;
}
if (subtype == AWDL_ACTION_MIF)
peer->sent_mif = 1;
/* update peer info after parsing all TLVs */
awdl_peer_add(state->peers.peers, src, tsft, state->peer_cb, state->peer_cb_data);
return RX_OK;
}
int llc_parse(const struct buf *frame, struct llc_hdr *llc) {
uint16_t pid; /* to not take pointer of packed llc->pid */
READ_U8(frame, 0, &llc->dsap);
READ_U8(frame, 1, &llc->ssap);
READ_U8(frame, 2, &llc->control);
READ_BYTES_COPY(frame, 3, (uint8_t *) &llc->oui, 3);
READ_BE16(frame, 6, &pid);
llc->pid = pid;
return RX_OK;
wire_error:
return RX_TOO_SHORT;
}
int awdl_valid_llc_header(const struct buf *frame) {
struct llc_hdr llc;
if (llc_parse(frame, &llc) < 0) {
log_warn("llc: frame to short");
return 0;
}
if (llc.dsap != 0xaa || llc.ssap != 0xaa || llc.control != 0x03 ||
llc.pid != AWDL_LLC_PROTOCOL_ID) {
log_warn("llc: invalid header (DSAP %#04x, SSAP %#04x, control %#04x, OUI %02x:%02x:%02x, PID %#06x",
llc.dsap, llc.ssap, llc.control,
llc.oui.byte[0], llc.oui.byte[1], llc.oui.byte[2], llc.pid);
return 0;
}
return 1;
}
int awdl_rx_data(const struct buf *frame, struct buf ***out, const struct ether_addr *src,
const struct ether_addr *dst, struct awdl_state *state) {
uint16_t ether_type;
int offset = 0;
log_trace("awdl_data: receive from %s", ether_ntoa(src));
state->stats.rx_data++;
if (awdl_peer_get(state->peers.peers, src, NULL) != PEERS_OK)
return RX_IGNORE_PEER;
if (!awdl_valid_llc_header(frame))
return RX_UNEXPECTED_FORMAT;
buf_strip(frame, sizeof(struct llc_hdr));
if ((unsigned int) buf_len(frame) < sizeof(struct awdl_data)) {
log_warn("awdl_data: frame too short");
return RX_TOO_SHORT;
}
/* create ethernet frame */
read_be16(frame, 6, ðer_type);
buf_strip(frame, sizeof(struct awdl_data));
**out = buf_new_owned(ETHER_MAX_LEN);
/* TODO use checked write methods */
offset += write_ether_addr(**out, offset, dst);
offset += write_ether_addr(**out, offset, src);
offset += write_be16(**out, offset, ether_type);
/* TODO avoid copying bytes */
offset += write_bytes(**out, offset, buf_data(frame), buf_len(frame));
(*out)++;
return RX_OK;
}
int awdl_rx_data_amsdu(const struct buf *frame, struct buf ***out, const struct ether_addr *src __attribute__((unused)),
const struct ether_addr *dst __attribute__((unused)), struct awdl_state *state) {
/* Iterate over all subframes */
while (buf_len(frame) > 0) {
struct ether_addr src_a, dst_a;
uint16_t len_a;
int err;
const struct buf *subframe;
READ_ETHER_ADDR(frame, 0, &dst_a);
READ_ETHER_ADDR(frame, 6, &src_a);
READ_BE16(frame, 12, &len_a);
BUF_STRIP(frame, 14); /* strip subframe header */
if (len_a > buf_len(frame))
return RX_TOO_SHORT;
/* create subview of buf */
subframe = buf_new_const(buf_data(frame), len_a);
err = awdl_rx_data(subframe, out, &src_a, &dst_a, state);
buf_free(subframe);
if (err < 0)
return err;
BUF_STRIP(frame, len_a); /* strip frame */
if (buf_len(frame) > 0)
BUF_STRIP(frame, (4 - ((14 + len_a) % 4)) % 4); /* strip padding */
}
return RX_OK;
wire_error:
return RX_TOO_SHORT;
}
static int radiotap_parse(const struct buf *frame, signed char *rssi, uint8_t *flags, uint64_t *tsft) {
struct ieee80211_radiotap_iterator iter;
int err;
err = ieee80211_radiotap_iterator_init(&iter, (struct ieee80211_radiotap_header *) buf_data(frame),
buf_len(frame), NULL);
if (err < 0)
return RX_UNEXPECTED_FORMAT;
while (!(err = ieee80211_radiotap_iterator_next(&iter))) {
if (iter.is_radiotap_ns) {
switch (iter.this_arg_index) {
case IEEE80211_RADIOTAP_TSFT: /* https://www.radiotap.org/fields/TSFT.html */
if (tsft)
*tsft = le64toh(*(uint64_t *) iter.this_arg);
break;
case IEEE80211_RADIOTAP_FLAGS:
if (flags)
*flags = *(unsigned char *) iter.this_arg;
break;
case IEEE80211_RADIOTAP_DBM_ANTSIGNAL: /* https://www.radiotap.org/fields/Antenna%20signal.html */
if (rssi)
*rssi = *(signed char *) iter.this_arg;
default:
/* ignore */
break;
}
}
}
if (err != -ENOENT)
return RX_UNEXPECTED_FORMAT;
return RX_OK;
}
static int check_fcs(const struct buf *frame, uint8_t radiotap_flags) {
if (radiotap_flags & IEEE80211_RADIOTAP_F_BADFCS)
return -1;
if (radiotap_flags & IEEE80211_RADIOTAP_F_FCS)
BUF_TAKE(frame, 4); /* strip FCS */
return 0;
wire_error:
return -1;
}
int awdl_rx(const struct buf *frame, struct buf ***data_frame, struct awdl_state *state) {
const struct ieee80211_hdr *ieee80211;
const struct ether_addr *from, *to;
uint16_t fc, qosc; /* frame and QoS control */
signed char rssi;
uint64_t tsft;
uint8_t flags;
tsft = clock_time_us(); /* TODO Radiotap TSFT is more accurate but then need to access TSF in clock_time_us() */
if (radiotap_parse(frame, &rssi, &flags, NULL /* &tsft */) < 0)
return RX_UNEXPECTED_FORMAT;
BUF_STRIP(frame, le16toh(((const struct ieee80211_radiotap_header *) buf_data(frame))->it_len));
if (check_fcs(frame, flags)) /* note that if no flags are present (flags==0), frames will pass */
return RX_IGNORE_FAILED_CRC;
READ_BYTES(frame, 0, NULL, sizeof(struct ieee80211_hdr));
ieee80211 = (const struct ieee80211_hdr *) (buf_data(frame));
from = &ieee80211->addr2;
to = &ieee80211->addr1;
fc = le16toh(ieee80211->frame_control);
if (!memcmp(from, &state->self_address, sizeof(struct ether_addr)))
return RX_IGNORE_FROM_SELF; /* TODO ignore frames from self, should be filtered at pcap level */
//if (!(to->ether_addr_octet[0] & 0x01) && memcmp(to, &state->self_address, sizeof(struct ether_addr)))
// return RX_IGNORE_NOPROMISC; /* neither broadcast/multicast nor unicast to me */
BUF_STRIP(frame, sizeof(struct ieee80211_hdr));
/* Processing based on frame type and subtype */
switch (fc & (IEEE80211_FCTL_FTYPE | IEEE80211_FCTL_STYPE)) {
case IEEE80211_FTYPE_MGMT | IEEE80211_STYPE_ACTION:
return awdl_rx_action(frame, rssi, tsft, from, to, state);
case IEEE80211_FTYPE_DATA | IEEE80211_STYPE_DATA | IEEE80211_STYPE_QOS_DATA:
READ_LE16(frame, 0, &qosc);
BUF_STRIP(frame, IEEE80211_QOS_CTL_LEN);
/* TODO should handle block acks if required (IEEE80211_QOS_CTL_ACK_POLICY_XYZ) */
if (qosc & IEEE80211_QOS_CTL_A_MSDU_PRESENT)
return awdl_rx_data_amsdu(frame, data_frame, from, to, state);
/* else fall through */
case IEEE80211_FTYPE_DATA | IEEE80211_STYPE_DATA:
return awdl_rx_data(frame, data_frame, from, to, state);
default:
log_warn("ieee80211: cannot handle type %x and subtype %x of received frame from %s",
fc & IEEE80211_FCTL_FTYPE, fc & IEEE80211_FCTL_STYPE, ether_ntoa(from));
return RX_UNEXPECTED_TYPE;
}
wire_error:
return RX_TOO_SHORT;
}
owl-master/src/rx.h 0000664 0000000 0000000 00000006210 13715306717 0014552 0 ustar 00root root 0000000 0000000 /*
* OWL: an open Apple Wireless Direct Link (AWDL) implementation
* Copyright (C) 2018 The Open Wireless Link Project (https://owlink.org)
* Copyright (C) 2018 Milan Stute
*
* 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 .
*/
#ifndef AWDL_RX_H_
#define AWDL_RX_H_
#include "frame.h"
#include "version.h"
#include "state.h"
enum RX_RESULT {
RX_IGNORE_PEER = 6,
RX_IGNORE_RSSI = 5,
RX_IGNORE_FAILED_CRC = 4,
RX_IGNORE_NOPROMISC = 3,
RX_IGNORE_FROM_SELF = 2,
RX_IGNORE = 1,
RX_OK = 0,
RX_UNEXPECTED_FORMAT = -1,
RX_UNEXPECTED_TYPE = -2,
RX_UNEXPECTED_VALUE = -3,
RX_TOO_SHORT = -3,
};
int awdl_handle_sync_params_tlv(struct awdl_peer *src, const struct buf *val, struct awdl_state *state, uint64_t tsft);
int awdl_handle_chanseq_tlv(struct awdl_peer *src, const struct buf *val, struct awdl_state *state);
int awdl_handle_election_params_tlv(struct awdl_peer *src, const struct buf *val, struct awdl_state *state);
int awdl_handle_election_params_v2_tlv(struct awdl_peer *src, const struct buf *val,
struct awdl_state *state);
int awdl_handle_arpa_tlv(struct awdl_peer *src, const struct buf *val, struct awdl_state *state);
int awdl_handle_data_path_state_tlv(struct awdl_peer *src, const struct buf *val, struct awdl_state *state);
int awdl_handle_version_tlv(struct awdl_peer *src, const struct buf *val, struct awdl_state *state);
int awdl_handle_tlv(struct awdl_peer *src, uint8_t type, const struct buf *val,
struct awdl_state *state, uint64_t tsft);
int awdl_parse_action_hdr(const struct buf *frame);
int awdl_rx_action(const struct buf *frame, signed char rssi, uint64_t tsft,
const struct ether_addr *src, const struct ether_addr *dst, struct awdl_state *state);
int llc_parse(const struct buf *frame, struct llc_hdr *llc);
int awdl_valid_llc_header(const struct buf *frame);
int awdl_rx_data(const struct buf *frame, struct buf ***out,
const struct ether_addr *src, const struct ether_addr *dst, struct awdl_state *state);
int awdl_rx_data_amsdu(const struct buf *frame, struct buf ***out,
const struct ether_addr *src, const struct ether_addr *dst, struct awdl_state *state);
/** @brief Receive and process AWDL action and data frame
*
* @param frame input frame
* @param data if {@code frame} points to a valid AWDL data frame, will point to converted Ethernet frame after function returns
* @param state
* @return RX_OK
*/
int awdl_rx(const struct buf *frame, struct buf ***data_frames, struct awdl_state *state);
#endif /* AWDL_RX_H_ */
owl-master/src/schedule.c 0000664 0000000 0000000 00000005714 13715306717 0015720 0 ustar 00root root 0000000 0000000 /*
* OWL: an open Apple Wireless Direct Link (AWDL) implementation
* Copyright (C) 2018 The Open Wireless Link Project (https://owlink.org)
* Copyright (C) 2018 Milan Stute
*
* 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 .
*/
#include "schedule.h"
double usec_to_sec(uint64_t usec) {
return usec / 1000000.;
}
uint64_t sec_to_usec(double sec) {
return sec * 1000000;
}
bool awdl_same_channel_as_peer(const struct awdl_state *state, uint64_t now, const struct awdl_peer *peer) {
int own_slot, peer_slot;
int own_chan, peer_chan;
own_slot = awdl_sync_current_eaw(now, &state->sync) % AWDL_CHANSEQ_LENGTH;
peer_slot = awdl_sync_current_eaw(now + peer->sync_offset, &state->sync) % AWDL_CHANSEQ_LENGTH;
own_chan = awdl_chan_num(state->channel.sequence[own_slot], state->channel.enc);
peer_chan = awdl_chan_num(peer->sequence[peer_slot], state->channel.enc);
return own_chan && (own_chan == peer_chan);
}
int awdl_is_multicast_eaw(const struct awdl_state *state, uint64_t now) {
uint16_t slot = awdl_sync_current_eaw(now, &state->sync) % AWDL_CHANSEQ_LENGTH;
return slot == 0 || slot == 10;
}
double awdl_can_send_in(const struct awdl_state *state, uint64_t now, int guard) {
uint64_t next_aw = awdl_sync_next_aw_us(now, &state->sync);
uint64_t _guard = ieee80211_tu_to_usec(guard);
uint64_t eaw = ieee80211_tu_to_usec(64);
return (next_aw < _guard) ? -usec_to_sec(_guard - next_aw) : ((eaw - next_aw < _guard) ? usec_to_sec(
(_guard - (eaw - next_aw))) : 0);
}
double awdl_can_send_unicast_in(const struct awdl_state *state, const struct awdl_peer *peer, uint64_t now, int guard) {
uint64_t next_aw = awdl_sync_next_aw_us(now, &state->sync);
uint64_t _guard = ieee80211_tu_to_usec(guard);
uint64_t eaw = ieee80211_tu_to_usec(64);
if (!awdl_same_channel_as_peer(state, now, peer))
return usec_to_sec(next_aw); /* try again in the next slot */
if (next_aw < _guard) { /* we are at the end of slot */
if (awdl_same_channel_as_peer(state, now + eaw, peer)) {
return 0; /* we are on the same channel in next slot, ignore guard */
} else {
return -usec_to_sec(_guard - next_aw);
}
} else if (eaw - next_aw < _guard) {
if (awdl_same_channel_as_peer(state, now - eaw, peer)) {
return 0; /* we were on the same channel last slot, ignore guard */
} else {
return usec_to_sec(_guard - (eaw - next_aw));
}
} else {
return 0; /* we are inside guard interval */
}
}
owl-master/src/schedule.h 0000664 0000000 0000000 00000004347 13715306717 0015726 0 ustar 00root root 0000000 0000000 /*
* OWL: an open Apple Wireless Direct Link (AWDL) implementation
* Copyright (C) 2018 The Open Wireless Link Project (https://owlink.org)
* Copyright (C) 2018 Milan Stute
*
* 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 .
*/
#ifndef AWDL_SCHEDULE_H_
#define AWDL_SCHEDULE_H_
#include
#include "state.h"
#include "peers.h"
#define AWDL_UNICAST_GUARD_TU 3
#define AWDL_MULTICAST_GUARD_TU 16
double usec_to_sec(uint64_t usec);
uint64_t sec_to_usec(double sec);
/**
* @brief Determine whether we are on the same non-zero channel as {@code peer}.
* @param state our state
* @param peer the other peer
* @return true if we and {@code peer} are on the same non-zero channel, false otherwise
*/
bool awdl_same_channel_as_peer(const struct awdl_state *state, uint64_t now, const struct awdl_peer *peer);
/**
* @brief Determine whether we are
* @param state
* @return
*/
int awdl_is_multicast_eaw(const struct awdl_state *state, uint64_t now);
/**
* @brief Determine whether we are outside a certain guard interval.
*
* time
* ----------------------->
* +---+--------------+---+
* | G | ok to send | G |
* +---+--------------+---+
* ^ ^ ^
* | | |
* pos 0 neg
*
* return when (^) is now
*
* @param state AWDL state
* @param guard guard interval in TU
* @return 0 if we are outside guard interval, or a positive or negative time in seconds
*/
double awdl_can_send_in(const struct awdl_state *state, uint64_t now, int guard);
double awdl_can_send_unicast_in(const struct awdl_state *state, const struct awdl_peer *peer, uint64_t now, int guard);
#endif /* AWDL_SCHEDULE_H_ */
owl-master/src/siphash24.c 0000664 0000000 0000000 00000004617 13715306717 0015732 0 ustar 00root root 0000000 0000000 /*
* Extracted (and adjusted) from the Sodium library v1.0.16
* https://libsodium.org
*/
#include
#include
#include "siphash24.h"
#define LOAD64_LE(SRC) load64_le(SRC)
static inline uint64_t
load64_le(const uint8_t src[8])
{
uint64_t w;
memcpy(&w, src, sizeof w);
return w;
}
#define STORE64_LE(DST, W) store64_le((DST), (W))
static inline void
store64_le(uint8_t dst[8], uint64_t w)
{
memcpy(dst, &w, sizeof w);
}
#define ROTL64(X, B) rotl64((X), (B))
static inline uint64_t
rotl64(const uint64_t x, const int b)
{
return (x << b) | (x >> (64 - b));
}
#define SIPROUND \
do { \
v0 += v1; \
v1 = ROTL64(v1, 13); \
v1 ^= v0; \
v0 = ROTL64(v0, 32); \
v2 += v3; \
v3 = ROTL64(v3, 16); \
v3 ^= v2; \
v0 += v3; \
v3 = ROTL64(v3, 21); \
v3 ^= v0; \
v2 += v1; \
v1 = ROTL64(v1, 17); \
v1 ^= v2; \
v2 = ROTL64(v2, 32); \
} while (0)
int siphash24(unsigned char *out, const unsigned char *in,
unsigned long long inlen, const unsigned char *k)
{
/* "somepseudorandomlygeneratedbytes" */
uint64_t v0 = 0x736f6d6570736575ULL;
uint64_t v1 = 0x646f72616e646f6dULL;
uint64_t v2 = 0x6c7967656e657261ULL;
uint64_t v3 = 0x7465646279746573ULL;
uint64_t b;
uint64_t k0 = LOAD64_LE(k);
uint64_t k1 = LOAD64_LE(k + 8);
uint64_t m;
const uint8_t *end = in + inlen - (inlen % sizeof(uint64_t));
const int left = inlen & 7;
b = ((uint64_t) inlen) << 56;
v3 ^= k1;
v2 ^= k0;
v1 ^= k1;
v0 ^= k0;
for (; in != end; in += 8) {
m = LOAD64_LE(in);
v3 ^= m;
SIPROUND;
SIPROUND;
v0 ^= m;
}
switch (left) {
case 7:
b |= ((uint64_t) in[6]) << 48;
/* FALLTHRU */
case 6:
b |= ((uint64_t) in[5]) << 40;
/* FALLTHRU */
case 5:
b |= ((uint64_t) in[4]) << 32;
/* FALLTHRU */
case 4:
b |= ((uint64_t) in[3]) << 24;
/* FALLTHRU */
case 3:
b |= ((uint64_t) in[2]) << 16;
/* FALLTHRU */
case 2:
b |= ((uint64_t) in[1]) << 8;
/* FALLTHRU */
case 1:
b |= ((uint64_t) in[0]);
break;
case 0:
break;
}
v3 ^= b;
SIPROUND;
SIPROUND;
v0 ^= b;
v2 ^= 0xff;
SIPROUND;
SIPROUND;
SIPROUND;
SIPROUND;
b = v0 ^ v1 ^ v2 ^ v3;
STORE64_LE(out, b);
return 0;
}
owl-master/src/siphash24.h 0000664 0000000 0000000 00000000533 13715306717 0015730 0 ustar 00root root 0000000 0000000 /*
* Extracted (and adjusted) from the Sodium library v1.0.16
* https://libsodium.org
*/
#ifndef SIPHASH24_H
#define SIPHASH24_H
#define siphash24_BYTES 8U
#define siphash24_KEYBYTES 16U
int siphash24(unsigned char *out, const unsigned char *in,
unsigned long long inlen, const unsigned char *k);
#endif /* OWL_SIPHASH24_H */
owl-master/src/state.c 0000664 0000000 0000000 00000006066 13715306717 0015245 0 ustar 00root root 0000000 0000000 /*
* OWL: an open Apple Wireless Direct Link (AWDL) implementation
* Copyright (C) 2018 The Open Wireless Link Project (https://owlink.org)
* Copyright (C) 2018 Milan Stute
*
* 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 .
*/
#include
#include
#include "version.h"
#include "state.h"
#define ETHER_BROADCAST (struct ether_addr) {{ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }}
#define PSF_INTERVAL_MASTER_TU 110
#define PSF_INTERVAL_SLAVE_TU 440
void awdl_init_state(struct awdl_state *state, const char *hostname, const struct ether_addr *self,
struct awdl_chan chan, uint64_t now) {
state->self_address = *self;
strncpy(state->name, hostname, HOST_NAME_LENGTH_MAX);
state->version = awdl_version(3, 4);
state->dev_class = AWDL_DEVCLASS_MACOS;
state->sequence_number = 0;
state->psf_interval = PSF_INTERVAL_MASTER_TU;
state->dst = ETHER_BROADCAST;
state->tlv_cb = 0;
state->tlv_cb_data = 0;
state->peer_cb = 0;
state->peer_cb_data = 0;
state->peer_remove_cb = 0;
state->peer_remove_cb_data = 0;
state->filter_rssi = 1;
state->rssi_threshold = RSSI_THRESHOLD_DEFAULT;
state->rssi_grace = RSSI_GRACE_DEFAULT;
awdl_sync_state_init(&state->sync, now);
state->channel.enc = AWDL_CHAN_ENC_OPCLASS;
state->channel.master = chan;
state->channel.current = CHAN_NULL;
//awdl_chanseq_init(state->channel.sequence);
awdl_chanseq_init_static(state->channel.sequence, &state->channel.master);
awdl_election_state_init(&state->election, self);
awdl_peer_state_init(&state->peers);
awdl_stats_init(&state->stats);
}
void awdl_stats_init(struct awdl_stats *stats) {
stats->tx_action = 0;
stats->tx_data = 0;
stats->tx_data_unicast = 0;
stats->tx_data_multicast = 0;
stats->rx_action = 0;
stats->rx_data = 0;
stats->rx_unknown = 0;
}
uint16_t awdl_state_next_sequence_number(struct awdl_state *state) {
return state->sequence_number++;
};
void ieee80211_init_state(struct ieee80211_state *state) {
state->sequence_number = 0;
state->fcs = 0;
}
unsigned int ieee80211_state_next_sequence_number(struct ieee80211_state *state) {
uint16_t seq = state->sequence_number;
state->sequence_number += 1;
state->sequence_number &= 0x0fff; /* seq has only 12 bits */
return seq;
};
uint64_t clock_time_us() {
int result;
struct timespec now;
uint64_t now_us = 0;
result = clock_gettime(CLOCK_MONOTONIC, &now);
if (!result) {
/* TODO why using 'long' for time? */
now_us = now.tv_sec * 1000000;
now_us += now.tv_nsec / 1000;
}
return now_us;
}
owl-master/src/state.h 0000664 0000000 0000000 00000005724 13715306717 0015252 0 ustar 00root root 0000000 0000000 /*
* OWL: an open Apple Wireless Direct Link (AWDL) implementation
* Copyright (C) 2018 The Open Wireless Link Project (https://owlink.org)
* Copyright (C) 2018 Milan Stute
*
* 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 .
*/
#ifndef AWDL_STATE_H_
#define AWDL_STATE_H_
#include
#include
#include "wire.h"
#include "frame.h"
#include "peers.h"
#include "sync.h"
#include "channel.h"
#define RSSI_THRESHOLD_DEFAULT -65
#define RSSI_GRACE_DEFAULT -5
struct awdl_state; /* forward declaration for tlv_cb */
typedef void (*awdl_tlv_cb)(struct awdl_peer *, uint8_t, const struct buf *, struct awdl_state *, void *);
struct awdl_stats {
uint64_t tx_action;
uint64_t tx_data;
uint64_t tx_data_unicast;
uint64_t tx_data_multicast;
uint64_t rx_action;
uint64_t rx_data;
uint64_t rx_unknown;
};
/* Complete node state */
struct awdl_state {
struct ether_addr self_address;
char name[HOST_NAME_LENGTH_MAX + 1];
uint8_t version;
uint8_t dev_class;
/* sequence number for data frames */
uint16_t sequence_number;
/* PSF interval (in TU) */
uint16_t psf_interval;
/* destination address for action frames */
struct ether_addr dst;
/* Allows to hook TLV reception */
awdl_tlv_cb tlv_cb;
void *tlv_cb_data;
/* Allows to hook adding of new neighbor */
awdl_peer_cb peer_cb;
void *peer_cb_data;
/* Allows to hook removing of new neighbor */
awdl_peer_cb peer_remove_cb;
void *peer_remove_cb_data;
int filter_rssi; /* whether or not to filter (default: true) */
signed char rssi_threshold; /* peers exceeding this threshold are discovered */
signed char rssi_grace; /* once discovered accept lower RSSI */
struct awdl_election_state election;
struct awdl_sync_state sync;
struct awdl_channel_state channel;
struct awdl_peer_state peers;
struct awdl_stats stats;
};
void awdl_stats_init(struct awdl_stats *stats);
void awdl_init_state(struct awdl_state *state, const char *hostname, const struct ether_addr *self,
struct awdl_chan chan, uint64_t now);
uint16_t awdl_state_next_sequence_number(struct awdl_state *);
struct ieee80211_state {
/* IEEE 802.11 sequence number */
uint16_t sequence_number;
/* whether we need to add an fcs */
bool fcs;
};
void ieee80211_init_state(struct ieee80211_state *);
unsigned int ieee80211_state_next_sequence_number(struct ieee80211_state *);
uint64_t clock_time_us();
#endif /* AWDL_STATE_H_ */
owl-master/src/sync.c 0000664 0000000 0000000 00000006160 13715306717 0015074 0 ustar 00root root 0000000 0000000 /*
* OWL: an open Apple Wireless Direct Link (AWDL) implementation
* Copyright (C) 2018 The Open Wireless Link Project (https://owlink.org)
* Copyright (C) 2018 Milan Stute
*
* 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 .
*/
#include "sync.h"
#include "ieee80211.h"
void awdl_sync_state_init(struct awdl_sync_state *state, uint64_t now) {
state->last_update = now;
state->aw_counter = 0;
state->aw_period = 16;
state->presence_mode = 4;
state->meas_err = 0;
state->meas_total = 0;
}
uint16_t awdl_sync_next_aw_tu(uint64_t now_usec, const struct awdl_sync_state *state) {
uint64_t eaw_period = state->presence_mode * state->aw_period;
uint64_t time_since = ieee80211_usec_to_tu(now_usec - state->last_update);
uint64_t next_aw_tu = eaw_period - (time_since % eaw_period);
return (uint16_t) next_aw_tu;
}
uint64_t awdl_sync_next_aw_us(uint64_t now_usec, const struct awdl_sync_state *state) {
uint64_t eaw_period = ieee80211_tu_to_usec(state->presence_mode * state->aw_period);
uint64_t time_since = now_usec - state->last_update;
uint64_t next_aw_us = eaw_period - (time_since % eaw_period);
return next_aw_us;
}
uint16_t awdl_sync_current_aw(uint64_t now_usec, const struct awdl_sync_state *state) {
uint64_t eaw_period = state->presence_mode * state->aw_period;
uint64_t time_since = ieee80211_usec_to_tu(now_usec - state->last_update);
uint64_t current_aw = state->aw_counter + /* last counter */
(time_since % eaw_period) / state->aw_period + /* within EAW */
state->presence_mode * (time_since / eaw_period); /* correction for EAWs */
return (uint16_t) current_aw;
};
uint16_t awdl_sync_current_eaw(uint64_t now_usec, const struct awdl_sync_state *state) {
return (awdl_sync_current_aw(now_usec, state) / state->presence_mode);
}
int64_t awdl_sync_error_tu(uint64_t now_usec, uint16_t time_to_next_aw, uint16_t aw_counter,
const struct awdl_sync_state *state) {
return ((aw_counter / state->presence_mode - awdl_sync_current_eaw(now_usec, state)) *
state->presence_mode * state->aw_period) -
(time_to_next_aw - awdl_sync_next_aw_tu(now_usec, state));
}
void awdl_sync_update_last(uint64_t now_usec, uint16_t time_to_next_aw, uint16_t aw_counter,
struct awdl_sync_state *state) {
uint64_t eaw_period = state->presence_mode * state->aw_period;
state->last_update = now_usec - ieee80211_tu_to_usec(eaw_period - time_to_next_aw);
state->aw_counter = aw_counter & 0xfffc; /* mask last two bits, effectively 'aw_counter/4*4' */
}
owl-master/src/sync.h 0000664 0000000 0000000 00000003511 13715306717 0015076 0 ustar 00root root 0000000 0000000 /*
* OWL: an open Apple Wireless Direct Link (AWDL) implementation
* Copyright (C) 2018 The Open Wireless Link Project (https://owlink.org)
* Copyright (C) 2018 Milan Stute
*
* 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 .
*/
#ifndef AWDL_SYNC_H_
#define AWDL_SYNC_H_
#include
struct awdl_sync_state {
uint16_t aw_counter;
uint64_t last_update; /* in us */
uint16_t aw_period; /* in TU */
uint8_t presence_mode;
/* statistics */
uint64_t meas_err;
uint64_t meas_total;
};
void awdl_sync_state_init(struct awdl_sync_state *state, uint64_t now);
uint16_t awdl_sync_next_aw_tu(uint64_t now_usec, const struct awdl_sync_state *state);
uint64_t awdl_sync_next_aw_us(uint64_t now_usec, const struct awdl_sync_state *state);
uint16_t awdl_sync_current_aw(uint64_t now_usec, const struct awdl_sync_state *state);
uint16_t awdl_sync_current_eaw(uint64_t now_usec, const struct awdl_sync_state *state);
int64_t awdl_sync_error_tu(uint64_t now_usec, uint16_t time_to_next_aw, uint16_t aw_counter,
const struct awdl_sync_state *state);
void awdl_sync_update_last(uint64_t now_usec, uint16_t time_to_next_aw, uint16_t aw_counter,
struct awdl_sync_state *state);
#endif /* AWDL_SYNC_H_ */
owl-master/src/tx.c 0000664 0000000 0000000 00000033551 13715306717 0014557 0 ustar 00root root 0000000 0000000 /*
* OWL: an open Apple Wireless Direct Link (AWDL) implementation
* Copyright (C) 2018 The Open Wireless Link Project (https://owlink.org)
* Copyright (C) 2018 Milan Stute
*
* 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 .
*/
#include
#include
#include
#include "tx.h"
#include "sync.h"
#include "ieee80211.h"
#include "crc32.h"
#define AWDL_DNS_SHORT_LOCAL 0xc00c /* .local */
#define AWDL_DATA_HEAD 0x0403
#define AWDL_DATA_PAD 0x0000
#define AWDL_SOCIAL_CHANNEL_6_BIT 0x0001
#define AWDL_SOCIAL_CHANNEL_44_BIT 0x0002
#define AWDL_SOCIAL_CHANNEL_149_BIT 0x0004
int awdl_init_data(uint8_t *buf, struct awdl_state *state) {
struct awdl_data *header = (struct awdl_data *) buf;
header->head = htole16(AWDL_DATA_HEAD);
header->seq = htole16(awdl_state_next_sequence_number(state));
header->pad = htole16(AWDL_DATA_PAD);
/* TODO we should generally to able to send any kind of data */
header->ethertype = htobe16(ETH_P_IPV6);
return sizeof(struct awdl_data);
}
int awdl_init_action(uint8_t *buf, enum awdl_action_type type) {
struct awdl_action *af = (struct awdl_action *) buf;
uint32_t steady_time = (uint32_t) clock_time_us(); /* TODO awdl_init_* methods should not call clock_time_us() themselves but rather be given as parameter to avoid inconsitent calculation of stuff, e.g., fields in sync parameters should be calculated based on the timestamp indicated in af->target_tx */
af->category = IEEE80211_VENDOR_SPECIFIC; /* vendor specific */
af->oui = AWDL_OUI;
af->type = AWDL_TYPE;
af->version = AWDL_VERSION_COMPAT;
af->subtype = type;
af->reserved = 0;
af->phy_tx = htole32(steady_time); /* TODO arbitrary offset */
af->target_tx = htole32(steady_time);
return sizeof(struct awdl_action);
}
int awdl_chan_encoding_length(enum awdl_chan_encoding enc) {
switch (enc) {
case AWDL_CHAN_ENC_SIMPLE:
return 1;
case AWDL_CHAN_ENC_LEGACY:
case AWDL_CHAN_ENC_OPCLASS:
return 2;
default:
return 0; /* unknown encoding */
}
}
int awdl_init_chanseq(uint8_t *buf, const struct awdl_state *state) {
struct awdl_chanseq *chanseq = (struct awdl_chanseq *) buf;
int enc_len = awdl_chan_encoding_length(state->channel.enc);
int offset = sizeof(struct awdl_chanseq);
chanseq->count = AWDL_CHANSEQ_LENGTH - 1; /* +1 */
chanseq->encoding = state->channel.enc;
chanseq->duplicate_count = 0;
chanseq->step_count = 3;
chanseq->fill_channel = htole16(0xffff); /* repeat current channel */
for (int i = 0; i < AWDL_CHANSEQ_LENGTH; i++) {
/* copy based on length */
memcpy(buf + offset, &(state->channel.sequence[i]), enc_len);
offset += enc_len;
}
return offset;
}
int awdl_init_sync_params_tlv(uint8_t *buf, const struct awdl_state *state) {
struct awdl_sync_params_tlv *tlv = (struct awdl_sync_params_tlv *) buf;
int len;
uint64_t now;
now = clock_time_us();
tlv->type = AWDL_SYNCHRONIZATON_PARAMETERS_TLV;
/* static info: appears to be fixed in current AWDL implementation */
tlv->guard_time = 0;
tlv->aw_period = htole16(state->sync.aw_period);
tlv->aw_ext_length = htole16(state->sync.aw_period);
tlv->aw_com_length = htole16(state->sync.aw_period);
tlv->min_ext = state->sync.presence_mode - 1;
tlv->max_ext_unicast = state->sync.presence_mode - 1;
tlv->max_ext_multicast = state->sync.presence_mode - 1;
tlv->max_ext_af = state->sync.presence_mode - 1;
tlv->flags = htole16(0x1800); /* TODO: not sure what they do */
tlv->reserved = 0;
/* TODO: dynamic info needs to be adjusted during runtime */
tlv->next_aw_channel = awdl_chan_num(state->channel.current,
state->channel.enc); /* TODO need to calculate this from current seq */
tlv->next_aw_seq = htole16(awdl_sync_current_aw(now, &state->sync));
tlv->ap_alignment = tlv->next_aw_seq; /* awdl_fill_sync_params(..) */
tlv->tx_down_counter = htole16(awdl_sync_next_aw_tu(now, &state->sync));
tlv->af_period = htole16(state->psf_interval);
tlv->presence_mode = state->sync.presence_mode; /* always available, usually 4 */
tlv->master_addr = state->election.master_addr;
tlv->master_channel = awdl_chan_num(state->channel.master, state->channel.enc);
/* lower bound is 0 */
if (le16toh(tlv->aw_com_length) < (le16toh(tlv->aw_period) * tlv->presence_mode - le16toh(tlv->tx_down_counter)))
tlv->remaining_aw_length = htole16(0);
else
tlv->remaining_aw_length = htole16(le16toh(tlv->aw_com_length) -
(le16toh(tlv->aw_period) * tlv->presence_mode - le16toh(tlv->tx_down_counter)));
len = sizeof(struct awdl_sync_params_tlv);
len += awdl_init_chanseq(buf + sizeof(struct awdl_sync_params_tlv), state);
/* padding */
buf[len++] = 0;
buf[len++] = 0;
tlv->length = htole16(len - sizeof(struct tl));
return len;
}
int awdl_init_chanseq_tlv(uint8_t *buf, const struct awdl_state *state) {
struct awdl_chanseq_tlv *tlv = (struct awdl_chanseq_tlv *) buf;
int len;
tlv->type = AWDL_CHAN_SEQ_TLV;
len = sizeof(struct awdl_chanseq_tlv);
len += awdl_init_chanseq(buf + sizeof(struct awdl_chanseq_tlv), state);
/* padding */
buf[len++] = 0;
buf[len++] = 0;
buf[len++] = 0;
tlv->length = htole16(len - sizeof(struct tl));
return len;
}
int awdl_init_election_params_tlv(uint8_t *buf, const struct awdl_state *state) {
struct awdl_election_params_tlv *tlv = (struct awdl_election_params_tlv *) buf;
tlv->type = AWDL_ELECTION_PARAMETERS_TLV;
tlv->length = htole16(sizeof(struct awdl_election_params_tlv) - sizeof(struct tl));
tlv->distancetop = state->election.height;
tlv->top_master_addr = state->election.master_addr;
tlv->top_master_metric = htole32(state->election.master_metric);
tlv->self_metric = htole32(state->election.self_metric);
/* TODO unsure what flags do */
tlv->flags = 0;
tlv->id = htole16(0);
tlv->unknown = 0;
tlv->pad[0] = 0;
tlv->pad[1] = 0;
return sizeof(struct awdl_election_params_tlv);
}
int awdl_init_election_params_v2_tlv(uint8_t *buf, const struct awdl_state *state) {
struct awdl_election_params_v2_tlv *tlv = (struct awdl_election_params_v2_tlv *) buf;
tlv->type = AWDL_ELECTION_PARAMETERS_V2_TLV;
tlv->length = htole16(sizeof(struct awdl_election_params_v2_tlv) - sizeof(struct tl));
tlv->master_addr = state->election.master_addr;
tlv->sync_addr = state->election.sync_addr;
tlv->distance_to_master = htole32(state->election.height);
tlv->master_metric = htole32(state->election.master_metric);
tlv->self_metric = htole32(state->election.self_metric);
tlv->unknown = htole32(0);
tlv->reserved = htole32(0);
tlv->master_counter = htole32(state->election.master_counter);
tlv->self_counter = htole32(state->election.self_counter);
return sizeof(struct awdl_election_params_v2_tlv);
}
int awdl_init_service_params_tlv(uint8_t *buf, const struct awdl_state *state __attribute__((unused))) {
struct awdl_service_params_tlv *tlv = (struct awdl_service_params_tlv *) buf;
tlv->type = AWDL_SERVICE_PARAMETERS_TLV;
tlv->length = htole16(sizeof(struct awdl_service_params_tlv) - sizeof(struct tl));
/* changing the SUI causes receiving nodes to flush their mDNS cache,
* other than that, this TLV seems to be deprecated in AWDL v2+ */
tlv->unknown[0] = 0;
tlv->unknown[1] = 0;
tlv->unknown[2] = 0;
tlv->sui = htole16(0);
tlv->bitmask = htole32(0);
return sizeof(struct awdl_service_params_tlv);
}
int awdl_init_ht_capabilities_tlv(uint8_t *buf, const struct awdl_state *state __attribute__((unused))) {
struct awdl_ht_capabilities_tlv *tlv = (struct awdl_ht_capabilities_tlv *) buf;
tlv->type = AWDL_ENHANCED_DATA_RATE_CAPABILITIES_TLV;
tlv->length = htole16(sizeof(struct awdl_ht_capabilities_tlv) - sizeof(struct tl));
/* TODO extract capabilities from nl80211 (nl80211_band_attr) */
tlv->ht_capabilities = htole16(0x11ce);
tlv->ampdu_params = 0x1b;
tlv->rx_mcs = 0xff; /* one stream, all MCS */
tlv->unknown = htole16(0);
tlv->unknown2 = htole16(0);
return sizeof(struct awdl_ht_capabilities_tlv);
}
int awdl_init_data_path_state_tlv(uint8_t *buf, const struct awdl_state *state) {
struct awdl_data_path_state_tlv *tlv = (struct awdl_data_path_state_tlv *) buf;
tlv->type = AWDL_DATA_PATH_STATE_TLV;
tlv->length = htole16(sizeof(struct awdl_data_path_state_tlv) - sizeof(struct tl));
/* TODO this is very ugly currently */
tlv->flags = htole16(0x8f24);
tlv->awdl_addr = state->self_address;
tlv->country_code[0] = 'X';
tlv->country_code[1] = '0';
tlv->country_code[2] = 0;
if (awdl_chan_num(state->channel.master, AWDL_CHAN_ENC_OPCLASS) == 6)
tlv->social_channels = htole16(AWDL_SOCIAL_CHANNEL_6_BIT);
else if (awdl_chan_num(state->channel.master, AWDL_CHAN_ENC_OPCLASS) == 44) {
tlv->social_channels = htole16(AWDL_SOCIAL_CHANNEL_44_BIT);
} else { // 149
tlv->social_channels = htole16(AWDL_SOCIAL_CHANNEL_149_BIT);
}
tlv->ext_flags = htole16(0x0000);
return sizeof(struct awdl_data_path_state_tlv);
}
int awdl_init_arpa_tlv(uint8_t *buf, const struct awdl_state *state) {
struct awdl_arpa_tlv *tlv = (struct awdl_arpa_tlv *) buf;
size_t len = strlen(state->name);
tlv->type = AWDL_ARPA_TLV;
tlv->length = htole16((uint16_t) (sizeof(struct awdl_arpa_tlv) - sizeof(struct tl) + len + 1));
tlv->flags = 3;
tlv->name_length = (uint8_t) len;
memcpy(tlv->name, state->name, len);
*(uint16_t *) (tlv->name + len) = htobe16(AWDL_DNS_SHORT_LOCAL);
return sizeof(struct tl) + le16toh(tlv->length);
}
int awdl_init_version_tlv(uint8_t *buf, const struct awdl_state *state) {
struct awdl_version_tlv *tlv = (struct awdl_version_tlv *) buf;
tlv->type = AWDL_VERSION_TLV;
tlv->length = htole16(sizeof(struct awdl_version_tlv) - sizeof(struct tl));
tlv->version = state->version;
tlv->devclass = state->dev_class;
return sizeof(struct awdl_version_tlv);
}
int ieee80211_init_radiotap_header(uint8_t *buf) {
/*
* TX radiotap headers and mac80211
* https://www.kernel.org/doc/Documentation/networking/mac80211-injection.txt
*/
struct ieee80211_radiotap_header *hdr = (struct ieee80211_radiotap_header *) buf;
uint8_t *ptr = buf + sizeof(struct ieee80211_radiotap_header);
uint32_t present = 0;
hdr->it_version = 0;
hdr->it_pad = 0;
/* TODO Adjust PHY parameters based on receiver capabilities */
present |= ieee80211_radiotap_type_to_mask(IEEE80211_RADIOTAP_RATE);
*ptr = htole16(ieee80211_radiotap_rate_to_val(12));
ptr += sizeof(uint8_t);
hdr->it_len = htole16((uint16_t) (ptr - buf));
hdr->it_present = htole32(present);
return ptr - buf;
}
int ieee80211_init_awdl_hdr(uint8_t *buf, const struct ether_addr *src, const struct ether_addr *dst,
struct ieee80211_state *state, uint16_t type) {
struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) buf;
hdr->frame_control = htole16(type);
hdr->duration_id = htole16(0);
hdr->addr1 = *dst;
hdr->addr2 = *src;
hdr->addr3 = AWDL_BSSID;
hdr->seq_ctrl = htole16(ieee80211_state_next_sequence_number(state) << 4);
return sizeof(struct ieee80211_hdr);
}
int ieee80211_init_awdl_action_hdr(uint8_t *buf, const struct ether_addr *src, const struct ether_addr *dst,
struct ieee80211_state *state) {
return ieee80211_init_awdl_hdr(buf, src, dst, state, IEEE80211_FTYPE_MGMT | IEEE80211_STYPE_ACTION);
}
int ieee80211_init_awdl_data_hdr(uint8_t *buf, const struct ether_addr *src, const struct ether_addr *dst,
struct ieee80211_state *state) {
return ieee80211_init_awdl_hdr(buf, src, dst, state, IEEE80211_FTYPE_DATA | IEEE80211_STYPE_DATA);
}
int llc_init_awdl_hdr(uint8_t *buf) {
struct llc_hdr *hdr = (struct llc_hdr *) buf;
hdr->dsap = 0xaa; /* 0xaa - SNAP Extension Used */
hdr->ssap = 0xaa; /* 0xaa - SNAP Extension Used */
hdr->control = 0x03;
hdr->oui = AWDL_OUI;
hdr->pid = htobe16(AWDL_LLC_PROTOCOL_ID);
return sizeof(struct llc_hdr);
}
int ieee80211_add_fcs(const uint8_t *start, uint8_t *end) {
uint32_t crc = crc32(start, end - start);
*(uint32_t *) end = htole32(crc);
return sizeof(uint32_t);
}
int awdl_init_full_action_frame(uint8_t *buf, struct awdl_state *state, struct ieee80211_state *ieee80211_state,
enum awdl_action_type type) {
uint8_t *ptr = buf;
ptr += ieee80211_init_radiotap_header(ptr);
ptr += ieee80211_init_awdl_action_hdr(ptr, &state->self_address, &state->dst, ieee80211_state);
ptr += awdl_init_action(ptr, type);
ptr += awdl_init_sync_params_tlv(ptr, state);
ptr += awdl_init_election_params_tlv(ptr, state);
ptr += awdl_init_chanseq_tlv(ptr, state);
ptr += awdl_init_election_params_v2_tlv(ptr, state);
ptr += awdl_init_service_params_tlv(ptr, state);
if (type == AWDL_ACTION_MIF)
ptr += awdl_init_ht_capabilities_tlv(ptr, state);
if (type == AWDL_ACTION_MIF)
ptr += awdl_init_arpa_tlv(ptr, state);
ptr += awdl_init_data_path_state_tlv(ptr, state);
ptr += awdl_init_version_tlv(ptr, state);
if (ieee80211_state->fcs)
ptr += ieee80211_add_fcs(buf, ptr);
return ptr - buf;
}
int awdl_init_full_data_frame(uint8_t *buf, const struct ether_addr *src, const struct ether_addr *dst,
const uint8_t *payload, unsigned int plen,
struct awdl_state *state, struct ieee80211_state *ieee80211_state) {
uint8_t *ptr = buf;
ptr += ieee80211_init_radiotap_header(ptr);
ptr += ieee80211_init_awdl_data_hdr(ptr, src, dst, ieee80211_state);
ptr += llc_init_awdl_hdr(ptr);
ptr += awdl_init_data(ptr, state);
memcpy(ptr, payload, plen);
ptr += plen;
if (ieee80211_state->fcs)
ptr += ieee80211_add_fcs(buf, ptr);
return ptr - buf;
}
owl-master/src/tx.h 0000664 0000000 0000000 00000005411 13715306717 0014556 0 ustar 00root root 0000000 0000000 /*
* OWL: an open Apple Wireless Direct Link (AWDL) implementation
* Copyright (C) 2018 The Open Wireless Link Project (https://owlink.org)
* Copyright (C) 2018 Milan Stute
*
* 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 .
*/
#ifndef AWDL_TX_H_
#define AWDL_TX_H_
#include "frame.h"
#include "version.h"
#include "state.h"
enum TX_RESULT {
TX_OK = 0,
TX_FAIL = -1,
};
int awdl_init_action(uint8_t *buf, enum awdl_action_type);
int awdl_init_chanseq(uint8_t *buf, const struct awdl_state *);
int awdl_init_sync_params_tlv(uint8_t *buf, const struct awdl_state *);
int awdl_init_chanseq_tlv(uint8_t *buf, const struct awdl_state *);
int awdl_init_election_params_tlv(uint8_t *buf, const struct awdl_state *);
int awdl_init_election_params_v2_tlv(uint8_t *buf, const struct awdl_state *);
int awdl_init_service_params_tlv(uint8_t *buf, const struct awdl_state *);
int awdl_init_ht_capabilities_tlv(uint8_t *buf, const struct awdl_state *);
int awdl_init_data_path_state_tlv(uint8_t *buf, const struct awdl_state *);
int awdl_init_arpa_tlv(uint8_t *buf, const struct awdl_state *);
int awdl_init_version_tlv(uint8_t *buf, const struct awdl_state *);
int awdl_init_full_action_frame(uint8_t *buf, struct awdl_state *, struct ieee80211_state *, enum awdl_action_type);
int awdl_init_data(uint8_t *buf, struct awdl_state *);
int awdl_init_full_data_frame(uint8_t *buf, const struct ether_addr *src, const struct ether_addr *dst,
const uint8_t *payload, unsigned int plen,
struct awdl_state *, struct ieee80211_state *);
int ieee80211_init_radiotap_header(uint8_t *buf);
int ieee80211_init_awdl_hdr(uint8_t *buf, const struct ether_addr *src, const struct ether_addr *dst,
struct ieee80211_state *, uint16_t type);
int ieee80211_init_awdl_action_hdr(uint8_t *buf, const struct ether_addr *src, const struct ether_addr *dst,
struct ieee80211_state *);
int ieee80211_init_awdl_data_hdr(uint8_t *buf, const struct ether_addr *src, const struct ether_addr *dst,
struct ieee80211_state *);
int llc_init_awdl_hdr(uint8_t *buf);
#endif /* AWDL_TX_H_ */
owl-master/src/version.c 0000664 0000000 0000000 00000003236 13715306717 0015606 0 ustar 00root root 0000000 0000000 /*
* OWL: an open Apple Wireless Direct Link (AWDL) implementation
* Copyright (C) 2018 The Open Wireless Link Project (https://owlink.org)
* Copyright (C) 2018 Milan Stute
*
* 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 .
*/
#include
#include "version.h"
uint8_t awdl_version(int major, int minor) {
return ((uint8_t) (((major) << 4) & 0xf0) | ((minor) & 0x0f));
}
int awdl_version_major(uint8_t version) {
return (version >> 4) & 0xf;
}
int awdl_version_minor(uint8_t version) {
return (version & 0xf);
}
const char *awdl_version_to_str(uint8_t version) {
static char str[64];
char *cur = str, *const end = str + sizeof(str);
cur += snprintf(cur, end - cur, "%d", awdl_version_major(version));
cur += snprintf(cur, end - cur, ".");
cur += snprintf(cur, end - cur, "%d", awdl_version_minor(version));
return str;
}
const char *awdl_devclass_to_str(uint8_t devclass) {
switch (devclass) {
case AWDL_DEVCLASS_MACOS:
return "macOS";
case AWDL_DEVCLASS_IOS:
return "iOS";
case AWDL_DEVCLASS_TVOS:
return "tvOS";
default:
return "Unknown";
}
}
owl-master/src/version.h 0000664 0000000 0000000 00000002351 13715306717 0015610 0 ustar 00root root 0000000 0000000 /*
* OWL: an open Apple Wireless Direct Link (AWDL) implementation
* Copyright (C) 2018 The Open Wireless Link Project (https://owlink.org)
* Copyright (C) 2018 Milan Stute
*
* 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 .
*/
#ifndef AWDL_VERSION_H_
#define AWDL_VERSION_H_
#include
uint8_t awdl_version(int major, int minor);
int awdl_version_major(uint8_t version);
int awdl_version_minor(uint8_t version);
const char *awdl_version_to_str(uint8_t);
enum awdl_devclass {
AWDL_DEVCLASS_MACOS = 1,
AWDL_DEVCLASS_IOS = 2,
AWDL_DEVCLASS_TVOS = 8,
};
const char *awdl_devclass_to_str(uint8_t devclass);
#endif /* AWDL_VERSION_H_ */
owl-master/src/wire.c 0000664 0000000 0000000 00000013417 13715306717 0015071 0 ustar 00root root 0000000 0000000 /*
* OWL: an open Apple Wireless Direct Link (AWDL) implementation
* Copyright (C) 2018 The Open Wireless Link Project (https://owlink.org)
* Copyright (C) 2018 Milan Stute
*
* 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 .
*/
#include
#include
#include "wire.h"
struct buf {
const uint8_t *orig;
uint8_t *data;
int len;
int owned;
};
struct buf *buf_new_owned(int len) {
if (len < 0)
return NULL;
struct buf *buf = (struct buf *) malloc(sizeof(struct buf));
buf->data = (uint8_t *) malloc(len);
buf->orig = buf->data;
buf->len = len;
buf->owned = 1;
return buf;
}
const struct buf *buf_new_const(const uint8_t *data, int len) {
if (len < 0)
return NULL;
struct buf *buf = (struct buf *) malloc(sizeof(struct buf));
buf->data = (uint8_t *) data;
buf->orig = data;
buf->len = len;
buf->owned = 0;
return buf;
}
void buf_free(const struct buf *buf) {
if (buf->owned)
free((void *) buf->orig);
free((struct buf *) buf);
}
const uint8_t *buf_data(const struct buf *buf) {
return buf->data;
}
int buf_len(const struct buf *buf) {
return buf->len;
}
int buf_strip(const struct buf *buf, int len) {
if (len > buf->len || len < 0)
return OUT_OF_BOUNDS;
((struct buf *) buf)->data += len;
((struct buf *) buf)->len -= len;
return len;
}
int buf_take(const struct buf *buf, int len) {
if (len > buf->len || len < 0)
return OUT_OF_BOUNDS;
((struct buf *) buf)->len -= len;
return len;
}
int write_u8(struct buf *buf, int offset, uint8_t value) {
if (offset < 0 || offset + 1 > buf->len)
return OUT_OF_BOUNDS;
*(buf->data + offset) = value;
return 1;
}
int write_le16(struct buf *buf, int offset, uint16_t value) {
if (offset < 0 || offset + 2 > buf->len)
return OUT_OF_BOUNDS;
*(uint16_t *) (buf->data + offset) = htole16(value);
return 2;
}
int write_be16(struct buf *buf, int offset, uint16_t value) {
if (offset < 0 || offset + 2 > buf->len)
return OUT_OF_BOUNDS;
*(uint16_t *) (buf->data + offset) = htobe16(value);
return 2;
}
int write_le32(struct buf *buf, int offset, uint32_t value) {
if (offset < 0 || offset + 4 > buf->len)
return OUT_OF_BOUNDS;
*(uint32_t *) (buf->data + offset) = htole32(value);
return 4;
}
int write_be32(struct buf *buf, int offset, uint32_t value) {
if (offset < 0 || offset + 4 > buf->len)
return OUT_OF_BOUNDS;
*(uint32_t *) (buf->data + offset) = htobe32(value);
return 4;
}
int write_ether_addr(struct buf *buf, int offset, const struct ether_addr *addr) {
if (offset < 0 || offset + ETHER_ADDR_LEN > buf->len)
return OUT_OF_BOUNDS;
*(struct ether_addr *) (buf->data + offset) = *addr;
return ETHER_ADDR_LEN;
}
int write_bytes(struct buf *buf, int offset, const uint8_t *bytes, int length) {
if (offset < 0 || offset + length > buf->len)
return OUT_OF_BOUNDS;
memcpy(buf->data + offset, bytes, length);
return length;
}
int read_u8(const struct buf *buf, int offset, uint8_t *value) {
if (offset < 0 || offset + 1 > buf->len)
return OUT_OF_BOUNDS;
if (value)
*value = *(buf->data + offset);
return 1;
}
int read_le16(const struct buf *buf, int offset, uint16_t *value) {
if (offset < 0 || offset + 2 > buf->len)
return OUT_OF_BOUNDS;
if (value)
*value = le16toh(*(uint16_t *) (buf->data + offset));
return 2;
}
int read_be16(const struct buf *buf, int offset, uint16_t *value) {
if (offset < 0 || offset + 2 > buf->len)
return OUT_OF_BOUNDS;
if (value)
*value = be16toh(*(uint16_t *) (buf->data + offset));
return 2;
}
int read_le32(const struct buf *buf, int offset, uint32_t *value) {
if (offset < 0 || offset + 4 > buf->len)
return OUT_OF_BOUNDS;
if (value)
*value = le32toh(*(uint32_t *) (buf->data + offset));
return 4;
}
int read_be32(const struct buf *buf, int offset, uint32_t *value) {
if (offset < 0 || offset + 4 > buf->len)
return OUT_OF_BOUNDS;
if (value)
*value = be32toh(*(uint32_t *) (buf->data + offset));
return 4;
}
int read_ether_addr(const struct buf *buf, int offset, struct ether_addr *addr) {
if (offset < 0 || offset + ETHER_ADDR_LEN > buf->len)
return OUT_OF_BOUNDS;
if (addr)
*addr = *(struct ether_addr *) (buf->data + offset);
return ETHER_ADDR_LEN;
}
int read_bytes(const struct buf *buf, int offset, const uint8_t **bytes, int length) {
if (offset < 0 || offset + length > buf->len)
return OUT_OF_BOUNDS;
if (bytes)
*bytes = buf->data + offset;
return length;
}
int read_bytes_copy(const struct buf *buf, int offset, uint8_t *bytes, int length) {
if (offset < 0 || offset + length > buf->len)
return OUT_OF_BOUNDS;
if (bytes)
memcpy(bytes, buf->data + offset, length);
return length;
}
int read_int_string(const struct buf *buf, int offset, char *str, int length) {
uint8_t _len;
READ_U8(buf, offset, &_len);
if (_len > length)
_len = length;
READ_BYTES_COPY(buf, offset + 1, (uint8_t *) str, _len);
if (str)
str[_len] = 0; /* add trailing zero */
return _len + 1;
wire_error:
return OUT_OF_BOUNDS;
}
int read_tlv(const struct buf *buf, int offset, uint8_t *type, uint16_t *len, const uint8_t **val) {
uint8_t _type;
uint16_t _len;
READ_U8(buf, offset, &_type);
READ_LE16(buf, offset + 1, &_len);
READ_BYTES(buf, offset + 3, val, _len);
if (type)
*type = _type;
if (len)
*len = _len;
return _len + 3;
wire_error:
return OUT_OF_BOUNDS;
}
owl-master/src/wire.h 0000664 0000000 0000000 00000015026 13715306717 0015074 0 ustar 00root root 0000000 0000000 /*
* OWL: an open Apple Wireless Direct Link (AWDL) implementation
* Copyright (C) 2018 The Open Wireless Link Project (https://owlink.org)
* Copyright (C) 2018 Milan Stute
*
* 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 .
*/
#ifndef OWL_WIRE_H
#define OWL_WIRE_H
#include
#include
#ifdef __APPLE__
#include
#include
#define htobe16(x) OSSwapHostToBigInt16(x)
#define htole16(x) OSSwapHostToLittleInt16(x)
#define be16toh(x) OSSwapBigToHostInt16(x)
#define le16toh(x) OSSwapLittleToHostInt16(x)
#define htobe32(x) OSSwapHostToBigInt32(x)
#define htole32(x) OSSwapHostToLittleInt32(x)
#define be32toh(x) OSSwapBigToHostInt32(x)
#define le32toh(x) OSSwapLittleToHostInt32(x)
#define htobe64(x) OSSwapHostToBigInt64(x)
#define htole64(x) OSSwapHostToLittleInt64(x)
#define be64toh(x) OSSwapBigToHostInt64(x)
#define le64toh(x) OSSwapLittleToHostInt64(x)
#else
#include
#endif /* __APPLE__ */
/** @brief Opaque buffer used to transport network packets.
*
* We can read from and write to a buffer using dedicated
* read and write functions.
*
* @see buf_data
* @see buf_len
*/
struct buf;
/* FIXME change interface: only return wire_error or 0, do not return length */
enum wire_error {
OUT_OF_BOUNDS = -1,
};
/** @brief Allocates a new {@code buf} of given length.
*
* Will free internal array when calling {@code buf_free}.
*
* @param len length of the buffer in bytes
* @return a pointer to a mutable {@code buf} instance
*
* @see buf_new_const
* @see buf_free
*/
struct buf *buf_new_owned(int len);
/** @brief Allocates a new {@code buf} an already existing bytes array.
*
* Will use {@code data} as its internal array which is _not_ freed when calling {@code buf_free}.
*
* @param data immutable reference to buffer array
* @param len length of the buffer in bytes
* @return a pointer to a mutable {@code buf} instance
*
* @see buf_new_owned
* @see buf_free
*/
const struct buf *buf_new_const(const uint8_t *data, int len);
/** @brief Deallocates a {@code buf} instance.
*
* Will dellocate internal bytes array if {@code buf} is an 'owned' instance.
*
* @param buf instance to free
*
* @see buf_new_owned
* @see buf_new_const
*/
void buf_free(const struct buf *buf);
/** @brief Read-only access to internal bytes array. */
const uint8_t *buf_data(const struct buf *buf);
/** @brief Length of internal bytes array. */
int buf_len(const struct buf *buf);
#define BUF_STRIP(buf, len) \
do { \
int result = buf_strip(buf, len); \
if (result < 0) \
goto wire_error; \
} while (0)
/** @brief Strip {@code len} bytes from the front of {@code buf}.
*
* @return 0 if successful or -1 if {@code len} is longer than length of {@code buf}
*/
int buf_strip(const struct buf *buf, int len);
#define BUF_TAKE(buf, len) \
do { \
int result = buf_take(buf, len); \
if (result < 0) \
goto wire_error; \
} while (0)
/** @brief Strip {@code len} bytes from the end of {@code buf}.
*
* @return 0 if successful or -1 if {@code len} is longer than length of {@code buf}
*/
int buf_take(const struct buf *buf, int len);
int write_u8(struct buf *buf, int offset, uint8_t value);
int write_le16(struct buf *buf, int offset, uint16_t value);
int write_be16(struct buf *buf, int offset, uint16_t value);
int write_le32(struct buf *buf, int offset, uint32_t value);
int write_be32(struct buf *buf, int offset, uint32_t value);
int write_ether_addr(struct buf *buf, int offset, const struct ether_addr *addr);
int write_bytes(struct buf *buf, int offset, const uint8_t *bytes, int length);
#define CHECKED_READ(type, ...) \
do { \
int result = read_##type(__VA_ARGS__); \
if (result < 0) \
goto wire_error; \
} while (0)
#define READ_U8(...) CHECKED_READ(u8, __VA_ARGS__)
#define READ_LE16(...) CHECKED_READ(le16, __VA_ARGS__)
#define READ_BE16(...) CHECKED_READ(be16, __VA_ARGS__)
#define READ_LE32(...) CHECKED_READ(le32, __VA_ARGS__)
#define READ_BE32(...) CHECKED_READ(be32, __VA_ARGS__)
#define READ_ETHER_ADDR(...) CHECKED_READ(ether_addr, __VA_ARGS__)
#define READ_BYTES(...) CHECKED_READ(bytes, __VA_ARGS__)
#define READ_BYTES_COPY(...) CHECKED_READ(bytes_copy, __VA_ARGS__)
#define READ_INT_STRING(...) CHECKED_READ(int_string, __VA_ARGS__)
#define READ_TLV(...) CHECKED_READ(tlv, __VA_ARGS__)
/** @brief Read an unsigned char from a @code buffer.
*
* @param buf @code buffer to be read from
* @param offset read at this offset in bytes
* @param value read into this pointer, can be null if not wanted
* @return the number of bytes read or a negative value if an error occured
*/
int read_u8(const struct buf *buf, int offset, uint8_t *value);
/** @brief Read an unsigned short in little-endian byte order.
*
* @see read_u8
*/
int read_le16(const struct buf *buf, int offset, uint16_t *value);
int read_be16(const struct buf *buf, int offset, uint16_t *value);
int read_le32(const struct buf *buf, int offset, uint32_t *value);
int read_be32(const struct buf *buf, int offset, uint32_t *value);
int read_ether_addr(const struct buf *buf, int offset, struct ether_addr *addr);
int read_bytes(const struct buf *buf, int offset, const uint8_t **bytes, int length);
int read_bytes_copy(const struct buf *buf, int offset, uint8_t *bytes, int length);
int read_int_string(const struct buf *buf, int offset, char *str, int length);
/** @brief Get offset to next TLV
*
* Can also be used to check whether buffer points to a complete TLV.
*
* @param buf @code buffer to be read from
* @param offset read at this offset in bytes
* @param type pointer is set to the type of the TLV, can be null if not wanted
* @param len pointer is set to the length of the TLV, can be null if not wanted
* @param val pointer is set to the value of the TLV, can be null if not wanted
* @return offset to next TLV or a negative value if an error occured
*/
int read_tlv(const struct buf *buf, int offset, uint8_t *type, uint16_t *len, const uint8_t **val);
#endif /* OWL_WIRE_H */
owl-master/tests/ 0000775 0000000 0000000 00000000000 13715306717 0014324 5 ustar 00root root 0000000 0000000 owl-master/tests/CMakeLists.txt 0000664 0000000 0000000 00000000677 13715306717 0017076 0 ustar 00root root 0000000 0000000 set(CMAKE_CXX_STANDARD 11)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
include_directories(${gtest_SOURCE_DIR}/include ${gtest_SOURCE_DIR})
add_executable(tests "")
target_sources(tests PRIVATE
test_wire.cpp
test_awdl_sync.cpp
test_awdl_peers.cpp
test_awdl_election.cpp
)
target_include_directories(tests PRIVATE ${CMAKE_SOURCE_DIR}/src)
target_link_libraries(tests gtest gtest_main)
target_link_libraries(tests awdl)
owl-master/tests/test_awdl_election.cpp 0000664 0000000 0000000 00000007426 13715306717 0020711 0 ustar 00root root 0000000 0000000 /*
* OWL: an open Apple Wireless Direct Link (AWDL) implementation
* Copyright (C) 2018 The Open Wireless Link Project (https://owlink.org)
* Copyright (C) 2018 Milan Stute
*
* 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 .
*/
extern "C" {
#include "election.h"
#include "peers.h"
}
#include "gtest/gtest.h"
#define TEST_ADDR(i) static const struct ether_addr TEST_ADDR##i = {{ i, i, i, i, i, i }}
TEST_ADDR(0);
TEST_ADDR(1);
#define ASSERT_ETHEREQ(val1, val2) ASSERT_FALSE(compare_ether_addr(&val1, &val2))
#define ASSERT_ETHERNEQ(val1, val2) ASSERT_TRUE(compare_ether_addr(&val1, &val2))
void test_add_valid_peer(awdl_peers_t peers, const struct ether_addr *addr) {
struct awdl_peer *peer;
awdl_peer_add(peers, addr, 0, NULL, NULL);
awdl_peer_get(peers, addr, &peer);
peer->is_valid = true;
}
TEST(awdl_election, init) {
struct awdl_election_state s;
awdl_election_state_init(&s, &TEST_ADDR0);
ASSERT_EQ(s.self_counter, 0);
ASSERT_EQ(s.self_metric, 60);
ASSERT_EQ(s.master_counter, 0);
ASSERT_EQ(s.master_metric, 60);
ASSERT_EQ(s.height, 0);
ASSERT_ETHEREQ(s.self_addr, TEST_ADDR0);
ASSERT_ETHEREQ(s.master_addr, TEST_ADDR0);
ASSERT_ETHEREQ(s.sync_addr, TEST_ADDR0);
ASSERT_ETHEREQ(s.self_addr, TEST_ADDR0);
}
TEST(awdl_election, elect_simple) {
struct awdl_election_state s;
struct awdl_peer_state p;
awdl_election_state_init(&s, &TEST_ADDR0);
awdl_peer_state_init(&p);
test_add_valid_peer(p.peers, &TEST_ADDR1);
awdl_election_run(&s, &p);
ASSERT_ETHEREQ(s.master_addr, TEST_ADDR1);
}
TEST(awdl_election, elect_simple_invalid) {
struct awdl_election_state s;
struct awdl_peer_state p;
awdl_election_state_init(&s, &TEST_ADDR0);
awdl_peer_state_init(&p);
awdl_peer_add(p.peers, &TEST_ADDR1, 0, NULL, NULL);
awdl_election_run(&s, &p);
ASSERT_ETHEREQ(s.master_addr, TEST_ADDR0);
}
TEST(awdl_election, counter_metric) {
struct awdl_election_state s;
struct awdl_peer_state p;
struct awdl_peer *peer;
awdl_election_state_init(&s, &TEST_ADDR0);
awdl_peer_state_init(&p);
test_add_valid_peer(p.peers, &TEST_ADDR1);
awdl_peer_get(p.peers, &TEST_ADDR1, &peer);
awdl_election_run(&s, &p);
ASSERT_ETHEREQ(s.master_addr, TEST_ADDR1);
peer->election.master_metric = 1000;
awdl_election_run(&s, &p);
ASSERT_ETHEREQ(s.master_addr, TEST_ADDR1);
s.self_metric = 1000;
awdl_election_run(&s, &p);
ASSERT_ETHEREQ(s.master_addr, TEST_ADDR1);
s.self_metric = 1001;
awdl_election_run(&s, &p);
ASSERT_ETHEREQ(s.master_addr, TEST_ADDR0);
peer->election.master_counter = 1;
awdl_election_run(&s, &p);
ASSERT_ETHEREQ(s.master_addr, TEST_ADDR1);
s.self_counter = 1;
awdl_election_run(&s, &p);
ASSERT_ETHEREQ(s.master_addr, TEST_ADDR0);
}
TEST(awdl_election, elect_cycle) {
struct awdl_election_state s;
struct awdl_peer_state p;
struct awdl_peer *peer;
awdl_election_state_init(&s, &TEST_ADDR0);
awdl_peer_state_init(&p);
test_add_valid_peer(p.peers, &TEST_ADDR1);
awdl_peer_get(p.peers, &TEST_ADDR1, &peer);
peer->election.master_metric = 1000;
peer->election.self_metric = 1000;
/* add top master */
peer->election.height = 1;
peer->election.master_addr = TEST_ADDR0;
awdl_election_run(&s, &p);
ASSERT_ETHEREQ(s.master_addr, TEST_ADDR0);
}
owl-master/tests/test_awdl_peers.cpp 0000664 0000000 0000000 00000010370 13715306717 0020215 0 ustar 00root root 0000000 0000000 /*
* OWL: an open Apple Wireless Direct Link (AWDL) implementation
* Copyright (C) 2018 The Open Wireless Link Project (https://owlink.org)
* Copyright (C) 2018 Milan Stute
*
* 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 .
*/
extern "C" {
#include "peers.h"
}
#include "gtest/gtest.h"
#define TEST_ADDR(i) static const struct ether_addr TEST_ADDR##i = {{ i, i, i, i, i, i }}
TEST_ADDR(0);
TEST_ADDR(1);
TEST(awdl_peers, init_free) {
awdl_peers_t p = awdl_peers_init();
EXPECT_TRUE(p);
EXPECT_EQ(awdl_peers_length(p), 0);
awdl_peers_free(p);
}
TEST(awdl_peers, add) {
int s;
awdl_peers_t p = awdl_peers_init();
s = awdl_peer_add(p, &TEST_ADDR0, 0, NULL, NULL);
EXPECT_EQ(s, PEERS_OK);
EXPECT_EQ(awdl_peers_length(p), 1);
awdl_peers_free(p);
}
TEST(awdl_peers, add_two) {
int s;
awdl_peers_t p = awdl_peers_init();
s = awdl_peer_add(p, &TEST_ADDR0, 0, NULL, NULL);
EXPECT_EQ(s, PEERS_OK);
EXPECT_EQ(awdl_peers_length(p), 1);
s = awdl_peer_add(p, &TEST_ADDR1, 0, NULL, NULL);
EXPECT_EQ(s, PEERS_OK);
EXPECT_EQ(awdl_peers_length(p), 2);
awdl_peers_free(p);
}
TEST(awdl_peers, add_same) {
int s;
awdl_peers_t p = awdl_peers_init();
s = awdl_peer_add(p, &TEST_ADDR0, 0, NULL, NULL);
EXPECT_EQ(s, PEERS_OK);
EXPECT_EQ(awdl_peers_length(p), 1);
s = awdl_peer_add(p, &TEST_ADDR0, 0, NULL, NULL);
EXPECT_EQ(s, PEERS_UPDATE);
EXPECT_EQ(awdl_peers_length(p), 1);
awdl_peers_free(p);
}
TEST(awdl_peers, remove) {
int s;
awdl_peers_t p = awdl_peers_init();
awdl_peer_add(p, &TEST_ADDR0, 0, NULL, NULL);
s = awdl_peer_remove(p, &TEST_ADDR0, NULL, NULL);
EXPECT_EQ(s, PEERS_OK);
EXPECT_EQ(awdl_peers_length(p), 0);
awdl_peers_free(p);
}
TEST(awdl_peers, remove_empty) {
int s;
awdl_peers_t p = awdl_peers_init();
s = awdl_peer_remove(p, &TEST_ADDR0, NULL, NULL);
EXPECT_EQ(s, PEERS_MISSING);
EXPECT_EQ(awdl_peers_length(p), 0);
awdl_peers_free(p);
}
TEST(awdl_peers, remove_twice) {
int s;
awdl_peers_t p = awdl_peers_init();
awdl_peer_add(p, &TEST_ADDR0, 0, NULL, NULL);
awdl_peer_remove(p, &TEST_ADDR0, NULL, NULL);
s = awdl_peer_remove(p, &TEST_ADDR0, NULL, NULL);
EXPECT_EQ(s, PEERS_MISSING);
EXPECT_EQ(awdl_peers_length(p), 0);
awdl_peers_free(p);
}
static int count_cb = 0;
static void test_cb(struct awdl_peer *p, void *ignore) {
(void) ignore;
count_cb++;
EXPECT_TRUE(!memcmp(&TEST_ADDR0, &p->addr, sizeof(struct ether_addr)));
}
TEST(awdl_peers, remove_timedout) {
struct awdl_peer *peer = NULL;
uint64_t now = 0;
awdl_peers_t p = awdl_peers_init();
awdl_peer_add(p, &TEST_ADDR0, now, NULL, NULL);
awdl_peer_get(p, &TEST_ADDR0, &peer);
peer->is_valid = 1;
EXPECT_EQ(awdl_peers_length(p), 1);
awdl_peers_remove(p, now, test_cb, NULL);
EXPECT_EQ(awdl_peers_length(p), 1);
EXPECT_EQ(count_cb, 0);
now++;
awdl_peers_remove(p, now, test_cb, NULL);
EXPECT_EQ(awdl_peers_length(p), 0);
EXPECT_EQ(count_cb, 1);
awdl_peers_free(p);
}
TEST(awdl_peers, print) {
char buf[1000]; // Buffer is large enough
awdl_peers_t p = awdl_peers_init();
awdl_peer_add(p, &TEST_ADDR0, 0, NULL, NULL);
awdl_peer_add(p, &TEST_ADDR1, 0, NULL, NULL);
int len = awdl_peers_print(p, buf, sizeof(buf));
EXPECT_EQ(len, strlen(buf));
EXPECT_STREQ(buf, ": 0:0:0:0:0:0 (met 60, ctr 0)\n"
": 1:1:1:1:1:1 (met 60, ctr 0)\n");
}
TEST(awdl_peers, print_overflow) {
char buf[30]; // Buffer is too small
awdl_peers_t p = awdl_peers_init();
awdl_peer_add(p, &TEST_ADDR0, 0, NULL, NULL);
awdl_peer_add(p, &TEST_ADDR1, 0, NULL, NULL);
int len = awdl_peers_print(p, buf, sizeof(buf));
EXPECT_GT(len, strlen(buf)); // would have written more
EXPECT_EQ(strlen(buf), sizeof(buf) - 1); // buffer is full
EXPECT_STREQ(buf, ": 0:0:0:0:0:0 (met 6");
}
owl-master/tests/test_awdl_sync.cpp 0000664 0000000 0000000 00000004456 13715306717 0020063 0 ustar 00root root 0000000 0000000 /*
* OWL: an open Apple Wireless Direct Link (AWDL) implementation
* Copyright (C) 2018 The Open Wireless Link Project (https://owlink.org)
* Copyright (C) 2018 Milan Stute
*
* 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 .
*/
extern "C" {
#include "sync.h"
#include "ieee80211.h"
}
#include "gtest/gtest.h"
static struct awdl_sync_state *test_state(uint64_t now) {
static struct awdl_sync_state state;
awdl_sync_state_init(&state, now);
return &state;
}
TEST(awdl_sync, next_aw_tu) {
uint64_t now = 0;
struct awdl_sync_state *state = test_state(now);
uint64_t eaw_period = 64;
for (uint64_t tu = 0; tu < 4 * eaw_period; tu++) {
for (; now < ieee80211_tu_to_usec(tu + 1); now++) {
uint16_t next_aw_tu = awdl_sync_next_aw_tu(now, state);
EXPECT_EQ(next_aw_tu, eaw_period - (tu % eaw_period));
}
}
}
TEST(awdl_sync, current_aw) {
uint64_t now = 0;
struct awdl_sync_state *state;
uint16_t aw, current_aw;
aw = 0;
state = test_state(now);
state->aw_counter = aw;
current_aw = awdl_sync_current_aw(now, state);
EXPECT_EQ(current_aw, aw);
aw = 1337;
state = test_state(now);
state->aw_counter = aw;
current_aw = awdl_sync_current_aw(now, state);
EXPECT_EQ(current_aw, aw);
aw = 0xffff;
state = test_state(now);
state->aw_counter = aw;
current_aw = awdl_sync_current_aw(now, state);
EXPECT_EQ(current_aw, aw);
}
TEST(awdl_sync, current_aw_timedelta) {
uint64_t now = 0;
struct awdl_sync_state *state = test_state(now);
uint64_t tu = 0;
for (uint16_t aw = 0; aw < 0xffff; aw++) {
for (; tu < (aw + 1u) * state->aw_period; tu++) {
uint16_t current_aw = awdl_sync_current_aw(ieee80211_tu_to_usec(tu), state);
EXPECT_EQ(current_aw, aw);
}
}
}
owl-master/tests/test_wire.cpp 0000664 0000000 0000000 00000027725 13715306717 0017052 0 ustar 00root root 0000000 0000000 /*
* OWL: an open Apple Wireless Direct Link (AWDL) implementation
* Copyright (C) 2018 The Open Wireless Link Project (https://owlink.org)
* Copyright (C) 2018 Milan Stute
*
* 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 .
*/
extern "C" {
#include "state.h"
#include "wire.h"
#include "tx.h"
#include "channel.h"
}
#include "gtest/gtest.h"
static struct buf *create_test_buf(int len) {
return buf_new_owned(len);
}
static void destroy_test_buf(struct buf *buf) {
buf_free(buf);
}
TEST(wire, buf_take) {
bool success = 0;
struct buf *frame = create_test_buf(2);
write_u8(frame, 0, 4);
write_u8(frame, 1, 2);
BUF_TAKE(frame, 1);
uint8_t x;
read_u8(frame, 0, &x);
EXPECT_EQ(x, 4);
success = 1;
wire_error:
EXPECT_TRUE(success);
EXPECT_EQ(buf_len(frame), 1);
destroy_test_buf(frame);
}
TEST(wire, buf_take_oob) {
bool success = 0;
struct buf *frame = create_test_buf(1);
BUF_TAKE(frame, buf_len(frame) + 1);
success = 1;
wire_error:
EXPECT_FALSE(success);
EXPECT_EQ(buf_len(frame), 1);
destroy_test_buf(frame);
}
TEST(wire, buf_take_negative) {
bool success = 0;
struct buf *frame = create_test_buf(1);
BUF_TAKE(frame, -1);
success = 1;
wire_error:
EXPECT_FALSE(success);
EXPECT_EQ(buf_len(frame), 1);
destroy_test_buf(frame);
}
TEST(wire, buf_strip) {
bool success = 0;
struct buf *frame = create_test_buf(2);
write_u8(frame, 0, 4);
write_u8(frame, 1, 2);
BUF_STRIP(frame, 1);
uint8_t x;
read_u8(frame, 0, &x);
EXPECT_EQ(x, 2);
success = 1;
wire_error:
EXPECT_TRUE(success);
EXPECT_EQ(buf_len(frame), 1);
destroy_test_buf(frame);
}
TEST(wire, buf_strip_oob) {
bool success = 0;
struct buf *frame = create_test_buf(1);
BUF_STRIP(frame, buf_len(frame) + 1);
success = 1;
wire_error:
EXPECT_FALSE(success);
EXPECT_EQ(buf_len(frame), 1);
destroy_test_buf(frame);
}
TEST(wire, buf_strip_negative) {
bool success = 0;
struct buf *frame = create_test_buf(1);
BUF_STRIP(frame, -1);
success = 1;
wire_error:
EXPECT_FALSE(success);
EXPECT_EQ(buf_len(frame), 1);
destroy_test_buf(frame);
}
TEST(wire, read_tlv) {
struct ether_addr addr;
struct awdl_state state;
struct buf *frame;
uint8_t *ptr, *start;
int tlv_len;
awdl_init_state(&state, "", &addr, CHAN_OPCLASS_6, 0);
frame = create_test_buf(1024);
// TODO use wire API in awdl_init_ functions, so cast is not necessary
ptr = (uint8_t *) buf_data(frame);
start = ptr;
ptr += awdl_init_sync_params_tlv(ptr, &state);
ptr += awdl_init_election_params_tlv(ptr, &state);
ptr += awdl_init_chanseq_tlv(ptr, &state);
ptr += awdl_init_service_params_tlv(ptr, &state);
ptr += awdl_init_arpa_tlv(ptr, &state);
ptr += awdl_init_data_path_state_tlv(ptr, &state);
ptr += awdl_init_version_tlv(ptr, &state);
buf_take(frame, buf_len(frame) - (ptr - start));
uint8_t type;
while ((tlv_len = read_tlv(frame, 0, &type, NULL, NULL)) > 0) {
EXPECT_STRNE(awdl_tlv_as_str(type), "Unknown");
buf_strip(frame, tlv_len);
}
EXPECT_EQ(buf_len(frame), 0);
buf_free(frame);
}
TEST(wire, read_u8) {
struct buf *frame = create_test_buf(1);
EXPECT_LT(read_u8(frame, -1, NULL), 0);
EXPECT_EQ(read_u8(frame, 0, NULL), 1);
EXPECT_LT(read_u8(frame, 1, NULL), 0);
destroy_test_buf(frame);
}
TEST(wire, checked_read_u8) {
struct buf *frame = create_test_buf(1);
int expect_fail = 0;
READ_U8(frame, 0, NULL);
EXPECT_FALSE(expect_fail);
expect_fail = 1;
READ_U8(frame, 1, NULL);
EXPECT_FALSE(expect_fail); // we should not be here
wire_error:
EXPECT_TRUE(expect_fail);
destroy_test_buf(frame);
}
TEST(wire, read_le16) {
struct buf *frame = create_test_buf(2);
EXPECT_LT(read_le16(frame, -1, NULL), 0);
EXPECT_EQ(read_le16(frame, 0, NULL), 2);
EXPECT_LT(read_le16(frame, 1, NULL), 0);
destroy_test_buf(frame);
}
TEST(wire, checked_read_le16) {
struct buf *frame = create_test_buf(2);
int expect_fail = 0;
READ_LE16(frame, 0, NULL);
EXPECT_FALSE(expect_fail);
expect_fail = 1;
READ_LE16(frame, 1, NULL);
EXPECT_FALSE(expect_fail); // we should not be here
wire_error:
EXPECT_TRUE(expect_fail);
destroy_test_buf(frame);
}
TEST(wire, read_be16) {
struct buf *frame = create_test_buf(2);
EXPECT_LT(read_be16(frame, -1, NULL), 0);
EXPECT_EQ(read_be16(frame, 0, NULL), 2);
EXPECT_LT(read_be16(frame, 1, NULL), 0);
destroy_test_buf(frame);
}
TEST(wire, checked_read_be16) {
struct buf *frame = create_test_buf(2);
int expect_fail = 0;
READ_BE16(frame, 0, NULL);
EXPECT_FALSE(expect_fail);
expect_fail = 1;
READ_BE16(frame, 1, NULL);
EXPECT_FALSE(expect_fail); // we should not be here
wire_error:
EXPECT_TRUE(expect_fail);
destroy_test_buf(frame);
}
TEST(wire, read_le32) {
struct buf *frame = create_test_buf(4);
EXPECT_LT(read_le32(frame, -1, NULL), 0);
EXPECT_EQ(read_le32(frame, 0, NULL), 4);
EXPECT_LT(read_le32(frame, 1, NULL), 0);
destroy_test_buf(frame);
}
TEST(wire, checked_read_le32) {
struct buf *frame = create_test_buf(4);
int expect_fail = 0;
READ_LE32(frame, 0, NULL);
EXPECT_FALSE(expect_fail);
expect_fail = 1;
READ_LE32(frame, 1, NULL);
EXPECT_FALSE(expect_fail); // we should not be here
wire_error:
EXPECT_TRUE(expect_fail);
destroy_test_buf(frame);
}
TEST(wire, read_be32) {
struct buf *frame = create_test_buf(4);
EXPECT_LT(read_be32(frame, -1, NULL), 0);
EXPECT_EQ(read_be32(frame, 0, NULL), 4);
EXPECT_LT(read_be32(frame, 1, NULL), 0);
destroy_test_buf(frame);
}
TEST(wire, checked_read_be32) {
struct buf *frame = create_test_buf(4);
int expect_fail = 0;
READ_BE32(frame, 0, NULL);
EXPECT_FALSE(expect_fail);
expect_fail = 1;
READ_BE32(frame, 1, NULL);
EXPECT_FALSE(expect_fail); // we should not be here
wire_error:
EXPECT_TRUE(expect_fail);
destroy_test_buf(frame);
}
TEST(wire, read_ether_addr) {
struct buf *frame = create_test_buf(6);
EXPECT_LT(read_ether_addr(frame, -1, NULL), 0);
EXPECT_EQ(read_ether_addr(frame, 0, NULL), 6);
EXPECT_LT(read_ether_addr(frame, 1, NULL), 0);
destroy_test_buf(frame);
}
TEST(wire, checked_read_ether_addr) {
struct buf *frame = create_test_buf(6);
int expect_fail = 0;
READ_ETHER_ADDR(frame, 0, NULL);
EXPECT_FALSE(expect_fail);
expect_fail = 1;
READ_ETHER_ADDR(frame, 1, NULL);
EXPECT_FALSE(expect_fail); // we should not be here
wire_error:
EXPECT_TRUE(expect_fail);
destroy_test_buf(frame);
}
TEST(wire, read_bytes) {
const static int LEN = 100;
struct buf *frame = create_test_buf(LEN);
EXPECT_LT(read_bytes(frame, -1, NULL, LEN), 0);
EXPECT_EQ(read_bytes(frame, 0, NULL, LEN), LEN);
EXPECT_LT(read_bytes(frame, 1, NULL, LEN), 0);
destroy_test_buf(frame);
}
TEST(wire, checked_read_bytes) {
const static int LEN = 100;
struct buf *frame = create_test_buf(LEN);
int expect_fail = 0;
READ_BYTES(frame, 0, NULL, LEN);
EXPECT_FALSE(expect_fail);
expect_fail = 1;
READ_BYTES(frame, 1, NULL, LEN);
EXPECT_FALSE(expect_fail); // we should not be here
wire_error:
EXPECT_TRUE(expect_fail);
destroy_test_buf(frame);
}
TEST(wire, read_int_string) {
char name[] = "owl";
char read[4];
struct buf *frame = create_test_buf(1 + strlen(name));
write_u8(frame, 0, strlen(name));
write_bytes(frame, 1, (uint8_t *) name, strlen(name));
EXPECT_EQ(read_int_string(frame, 0, read, 0), 1);
EXPECT_STREQ(read, "");
EXPECT_EQ(read_int_string(frame, 0, read, 1), 2);
EXPECT_STREQ(read, "o");
EXPECT_EQ(read_int_string(frame, 0, read, 2), 3);
EXPECT_STREQ(read, "ow");
EXPECT_EQ(read_int_string(frame, 0, read, 3), 4);
EXPECT_STREQ(read, "owl");
EXPECT_EQ(read_int_string(frame, 0, read, sizeof(read)), 4);
EXPECT_STREQ(read, name);
destroy_test_buf(frame);
}
TEST(wire, checked_read_int_string) {
char name[] = "owl";
char read[4];
struct buf *frame = create_test_buf(1 + strlen(name));
write_u8(frame, 0, strlen(name));
write_bytes(frame, 1, (uint8_t *) name, strlen(name));
int expect_fail = 0;
READ_INT_STRING(frame, 0, NULL, sizeof(read));
EXPECT_FALSE(expect_fail);
expect_fail = 1;
READ_INT_STRING(frame, buf_len(frame), NULL, sizeof(read));
EXPECT_FALSE(expect_fail); // we should not be here
wire_error:
EXPECT_TRUE(expect_fail);
destroy_test_buf(frame);
}
TEST(wire, write_read_u8) {
struct buf *frame = create_test_buf(1);
uint8_t write = 42;
uint8_t read = 0;
EXPECT_EQ(write_u8((struct buf *)frame, 0, write), 1);
EXPECT_EQ(read_u8(frame, 0, &read), 1);
EXPECT_EQ(read, write);
destroy_test_buf(frame);
}
TEST(wire, write_read_le16) {
struct buf *frame = create_test_buf(2);
uint16_t write = 42;
uint16_t read = 0;
EXPECT_EQ(write_le16((struct buf *)frame, 0, write), 2);
EXPECT_EQ(read_le16(frame, 0, &read), 2);
EXPECT_EQ(read, write);
destroy_test_buf(frame);
}
TEST(wire, write_read_be16) {
struct buf *frame = create_test_buf(2);
uint16_t write = 42;
uint16_t read = 0;
EXPECT_EQ(write_be16((struct buf *)frame, 0, write), 2);
EXPECT_EQ(read_be16(frame, 0, &read), 2);
EXPECT_EQ(read, write);
destroy_test_buf(frame);
}
TEST(wire, write_le16_read_be16) {
struct buf *frame = create_test_buf(2);
uint16_t write = 42;
uint16_t read = 0;
EXPECT_EQ(write_le16((struct buf *)frame, 0, write), 2);
EXPECT_EQ(read_be16(frame, 0, &read), 2);
EXPECT_NE(read, write);
destroy_test_buf(frame);
}
TEST(wire, write_be16_read_le16) {
struct buf *frame = create_test_buf(2);
uint16_t write = 42;
uint16_t read = 0;
EXPECT_EQ(write_be16((struct buf *)frame, 0, write), 2);
EXPECT_EQ(read_le16(frame, 0, &read), 2);
EXPECT_NE(read, write);
destroy_test_buf(frame);
}
TEST(wire, write_read_le32) {
struct buf *frame = create_test_buf(4);
uint32_t write = 42;
uint32_t read = 0;
EXPECT_EQ(write_le32((struct buf *)frame, 0, write), 4);
EXPECT_EQ(read_le32(frame, 0, &read), 4);
EXPECT_EQ(read, write);
destroy_test_buf(frame);
}
TEST(wire, write_read_be32) {
struct buf *frame = create_test_buf(4);
uint32_t write = 42;
uint32_t read = 0;
EXPECT_EQ(write_be32((struct buf *)frame, 0, write), 4);
EXPECT_EQ(read_be32(frame, 0, &read), 4);
EXPECT_EQ(read, write);
destroy_test_buf(frame);
}
TEST(wire, write_le32_read_be32) {
struct buf *frame = create_test_buf(4);
uint32_t write = 42;
uint32_t read = 0;
EXPECT_EQ(write_le32((struct buf *)frame, 0, write), 4);
EXPECT_EQ(read_be32(frame, 0, &read), 4);
EXPECT_NE(read, write);
destroy_test_buf(frame);
}
TEST(wire, write_be32_read_le32) {
struct buf *frame = create_test_buf(4);
uint32_t write = 42;
uint32_t read = 0;
EXPECT_EQ(write_be32((struct buf *)frame, 0, write), 4);
EXPECT_EQ(read_le32(frame, 0, &read), 4);
EXPECT_NE(read, write);
destroy_test_buf(frame);
}
TEST(wire, write_read_ether_addr) {
struct buf *frame = create_test_buf(6);
struct ether_addr write = {{ 0x01, 0x02, 0x03, 0x04, 0x05 }};
struct ether_addr read = {{ 0x00, 0x00, 0x00, 0x00, 0x00 }};
EXPECT_EQ(write_ether_addr((struct buf *)frame, 0, &write), 6);
EXPECT_EQ(read_ether_addr(frame, 0, &read), 6);
for (int i = 0; i < 6; i++)
EXPECT_EQ(read.ether_addr_octet[i], write.ether_addr_octet[i]);
destroy_test_buf(frame);
}
TEST(wire, write_read_bytes) {
const static uint8_t LEN = 100;
struct buf *frame = create_test_buf(LEN);
uint8_t write[LEN];
const uint8_t *read;
for (uint8_t i = 0; i < LEN; i++)
write[i] = i;
EXPECT_EQ(write_bytes((struct buf *)frame, 0, write, LEN), LEN);
EXPECT_EQ(read_bytes(frame, 0, &read, LEN), LEN);
for (int i = 0; i < LEN; i++)
EXPECT_EQ(read[i], write[i]);
destroy_test_buf(frame);
}