source code

.gitignore

@@ -0,0 +1,8 @@
+/target
+.idea
+.DS_Store
+src/ui/inline.rs
+extractor
+__pycache__
+src/version.rs
+*dmg

Cargo.toml

@@ -0,0 +1,109 @@
+[package]
+name = "rustdesk"
+version = "1.1.2"
+authors = ["rustdesk <info@rustdesk.com>"]
+edition = "2018"
+build= "build.rs"
+description = "A remote control software."
+
+[lib]
+crate-type = ["cdylib", "staticlib", "rlib"] 
+
+[features]
+inline = []
+cli = []
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+whoami = "0.9"
+scrap = { path = "libs/scrap" }
+hbb_common = { path = "libs/hbb_common" }
+enigo = { path = "libs/enigo" }
+serde_derive = "1.0"
+serde = "1.0"
+serde_json = "1.0"
+cfg-if = "1.0"
+lazy_static = "1.4"
+sha2 = "0.9"
+repng = "0.2"
+libc = "0.2"
+parity-tokio-ipc = { path = "libs/parity-tokio-ipc" }
+flexi_logger = "0.16"
+runas = "0.2"
+magnum-opus = { path = "libs/magnum-opus" }
+dasp = { version = "0.11", features = ["signal", "interpolate-linear", "interpolate"] }
+async-trait = "0.1"
+crc32fast = "1.2"
+uuid = { version = "0.8", features = ["v4"] }
+copypasta = "0.7"
+clap = "2.33"
+rpassword = "5.0"
+
+[target.'cfg(not(any(target_os = "android")))'.dependencies]
+cpal = { git = "https://github.com/rustaudio/cpal" }
+
+[target.'cfg(not(any(target_os = "android", target_os = "ios")))'.dependencies]
+machine-uid = "0.2"
+mac_address = "1.1"
+sciter-rs = { git = "https://github.com/sciter-sdk/rust-sciter" }
+
+[target.'cfg(target_os = "windows")'.dependencies]
+systray = { path = "libs/systray-rs" }
+winapi = { version = "0.3", features = ["winuser"] }
+winreg = "0.7"
+windows-service = { git = 'https://github.com/mullvad/windows-service-rs.git' }
+
+[target.'cfg(target_os = "macos")'.dependencies]
+objc = "0.2"
+cocoa = "0.24"
+dispatch = "0.2"
+core-foundation = "0.9"
+core-graphics = "0.22"
+
+[target.'cfg(target_os = "linux")'.dependencies]
+libpulse-simple-binding = "2.16"
+libpulse-binding = "2.16"
+rust-pulsectl = { path = "libs/pulsectl" }
+ctrlc = "3.1"
+
+[target.'cfg(not(any(target_os = "windows", target_os = "android", target_os = "ios")))'.dependencies]
+psutil = "3.2"
+
+[target.'cfg(target_os = "android")'.dependencies]
+android_logger = "0.9"
+
+[workspace]
+members = ["libs/scrap", "libs/hbb_common", "libs/enigo"]
+
+[package.metadata.winres]
+LegalCopyright = "Copyright © 2020"
+# this FileDescription overrides package.description
+FileDescription = "RustDesk"
+
+[target.'cfg(target_os="windows")'.build-dependencies]
+winres = "0.1"
+winapi = { version = "0.3", features = [ "winnt" ] }
+
+[build-dependencies]
+cc = "1.0"
+hbb_common = { path = "libs/hbb_common" }
+
+[dev-dependencies]
+hound = "3.4"
+
+[package.metadata.bundle]
+name = "RustDesk"
+identifier = "com.carriez.rustdesk"
+icon = ["32x32.png", "128x128.png", "128x128@2x.png"]
+deb_depends = ["libgtk-3-0", "libxcb-randr0", "libxdo3", "libxfixes3", "libxcb-shape0", "libxcb-xfixes0", "libasound2", "libsystemd0", "pulseaudio"]
+osx_minimum_system_version = "10.14"
+
+#https://github.com/johnthagen/min-sized-rust
+#!!! rembember call "strip target/release/rustdesk"
+# which reduce binary size a lot
+[profile.release]
+#lto = true
+#codegen-units = 1
+#panic = 'abort'
+#opt-level = 'z' # only have smaller size after strip

LICENSE

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

README.md

@@ -1,5 +1,35 @@
 ### RustDesk | Your Remote Desktop Software
 
-This is a repository used to release RustDesk software and track issues.
+The best open source remote desktop software written with Rust.
 
-[**DOWNLOAD**](https://github.com/rustdesk/rustdesk/releases)
+[**BINARY DOWNLOAD**](https://github.com/rustdesk/rustdesk/releases)
+
+## Dependence
+
+Desktop versions use [sciter](https://sciter.com/) for GUI, please download sciter dynamic library yourself.
+
+[Windows](https://github.com/c-smile/sciter-sdk/blob/dc65744b66389cd5a0ff6bdb7c63a8b7b05a708b/bin.win/x64/sciter.dll)
+[Linux](https://github.com/c-smile/sciter-sdk/raw/dc65744b66389cd5a0ff6bdb7c63a8b7b05a708b/bin.lnx/x64/libsciter-gtk.so)
+[Osx](https://github.com/c-smile/sciter-sdk/raw/dc65744b66389cd5a0ff6bdb7c63a8b7b05a708b/bin.osx/sciter-osx-64.dylib)
+
+## How To Build
+
+* Prepare your Rust development env and C++ build env
+
+* Install [vcpkg](https://github.com/microsoft/vcpkg), and set VCPKG_ROOT env variable correctly
+
+   - Windows: vcpkg install libvpx:x64-windows-static libyuv:x64-windows-static opus:x64-windows-static
+   - Linux/Osx: vcpkg install libvpx libyuv opus
+   
+* cargo run
+
+## File Structure
+
+- **[libs/hbb_common](https://github.com/rustdesk/rustdesk/tree/master/libs/hbb_common)**: video codec, config, tcp/udp wrapper, protobuf, fs functions for file transfer, and some other utility functions
+- **[libs/scrap](https://github.com/rustdesk/rustdesk/tree/master/libs/scrap)**: screen capture
+- **[libs/enigo](https://github.com/rustdesk/rustdesk/tree/master/libs/enigo)**: platform specific keyboard/mouse control
+- **[src/ui](https://github.com/rustdesk/rustdesk/tree/master/src/ui)**: GUI
+- **[src/server](https://github.com/rustdesk/rustdesk/tree/master/src/server)**: audio/clipboard/input/video services, and network connections
+- **[src/client.rs](https://github.com/rustdesk/rustdesk/tree/master/src/client.rs)**: start a peer connection
+- **[src/rendezvous_mediator.rs](https://github.com/rustdesk/rustdesk/tree/master/src/rendezvous_mediator.rs)**: Communicate with [rustdesk-server](https://github.com/rustdesk/rustdesk-server), wait for remote direct (TCP hole punching) or relayed connection
+- **[src/platform](https://github.com/rustdesk/rustdesk/tree/master/src/platform)**: platform specific code

build.rs

@@ -0,0 +1,74 @@
+#[cfg(windows)]
+fn build_windows() {
+    cc::Build::new().file("windows.cc").compile("windows");
+    // println!("cargo:rustc-link-lib=WtsApi32");
+    println!("cargo:rerun-if-changed=build.rs");
+    println!("cargo:rerun-if-changed=windows.cc");
+}
+
+#[cfg(all(windows, feature = "inline"))]
+fn build_manifest() {
+    use std::io::Write;
+    if std::env::var("PROFILE").unwrap() == "release" {
+        let mut res = winres::WindowsResource::new();
+        res.set_icon("icon.ico")
+            .set_language(winapi::um::winnt::MAKELANGID(
+                winapi::um::winnt::LANG_ENGLISH,
+                winapi::um::winnt::SUBLANG_ENGLISH_US,
+            ))
+            .set_manifest_file("manifest.xml");
+        match res.compile() {
+            Err(e) => {
+                write!(std::io::stderr(), "{}", e).unwrap();
+                std::process::exit(1);
+            }
+            Ok(_) => {}
+        }
+    }
+}
+
+fn install_oboe() {
+    let target_os = std::env::var("CARGO_CFG_TARGET_OS").unwrap();
+    if target_os != "android" {
+        return;
+    }
+    let mut target_arch = std::env::var("CARGO_CFG_TARGET_ARCH").unwrap();
+    if target_arch == "x86_64" {
+        target_arch = "x64".to_owned();
+    } else if target_arch == "aarch64" {
+        target_arch = "arm64".to_owned();
+    } else {
+        target_arch = "arm".to_owned();
+    }
+    let target = format!("{}-android-static", target_arch);
+    let vcpkg_root = std::env::var("VCPKG_ROOT").unwrap();
+    let mut path: std::path::PathBuf = vcpkg_root.into();
+    path.push("installed");
+    path.push(target);
+    println!(
+        "{}",
+        format!(
+            "cargo:rustc-link-search={}",
+            path.join("lib").to_str().unwrap()
+        )
+    );
+    println!("cargo:rustc-link-lib=oboe");
+    println!("cargo:rustc-link-lib=c++");
+    println!("cargo:rustc-link-lib=OpenSLES");
+    // I always got some strange link error with oboe, so as workaround, put oboe.cc into oboe src: src/common/AudioStreamBuilder.cpp
+    // also to avoid libc++_shared not found issue, cp ndk's libc++_shared.so to jniLibs, e.g.
+    // ./flutter_hbb/android/app/src/main/jniLibs/arm64-v8a/libc++_shared.so
+    // let include = path.join("include");
+    //cc::Build::new().file("oboe.cc").include(include).compile("oboe_wrapper");
+}
+
+fn main() {
+    #[cfg(all(windows, feature = "inline"))]
+    build_manifest();
+    #[cfg(windows)]
+    build_windows();
+    #[cfg(target_os = "macos")]
+    println!("cargo:rustc-link-lib=framework=ApplicationServices");
+    hbb_common::gen_version();
+    install_oboe();
+}

libs/enigo/.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,25 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: bug, needs investigation
+assignees: ''
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps or a minimal code example to reproduce the behavior.
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Environment (please complete the following information):**
+ - OS: [e.g. Linux, Windows, macOS ..]
+ - Rust [e.g. rustc --version]
+ - Library Version [e.g. enigo 0.0.13 or commit hash fa448be ]
+
+**Additional context**
+Add any other context about the problem here.

libs/enigo/.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: enhancement, needs investigation
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

libs/enigo/.github/ISSUE_TEMPLATE/question.md

@@ -0,0 +1,19 @@
+---
+name: Question
+about: Ask your Question here
+title: ''
+labels: question
+assignees: ''
+
+---
+
+**Describe your Question**
+A clear and concise description of what you want to know.
+
+**Describe your Goal**
+A clear and concise description of what you want to achieve. Consider the [XYProblem](http://xyproblem.info/)
+
+**Environment (please complete the following information):**
+ - OS: [e.g. Linux, Windows, macOS ..]
+ - Rust [e.g. rustc --version]
+ - Library Version [e.g. enigo 0.0.13 or commit hash fa448be ]

libs/enigo/.gitignore

@@ -0,0 +1,14 @@
+.DS_Store
+# Generated by Cargo
+# will have compiled files and executables
+/target/
+
+# Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
+# More information here http://doc.crates.io/guide.html#cargotoml-vs-cargolock
+Cargo.lock
+
+# RustFmt files
+**/*.rs.bk
+
+# intellij
+.idea

libs/enigo/.travis.yml

@@ -0,0 +1,15 @@
+language: rust
+rust:
+  - stable
+  - beta
+  - nightly
+matrix:
+  allow_failures:
+    - rust: nightly
+before_install:
+  - if [ "$TRAVIS_OS_NAME" == "linux" ]; then sudo apt-get -qq update; fi
+  - if [ "$TRAVIS_OS_NAME" == "linux" ]; then sudo apt-get install -y libxdo-dev; fi
+os:
+  - linux
+  - osx
+

libs/enigo/.vscode/launch.json

@@ -0,0 +1,13 @@
+{
+    "version": "0.2.0",
+    "configurations": [
+    
+        {
+            "name": "Debug",
+            "type": "gdb",
+            "request": "launch",
+            "target": "./target/debug/examples/keyboard",
+            "cwd": "${workspaceRoot}"
+        }
+    ]
+}

libs/enigo/Cargo.toml

@@ -0,0 +1,41 @@
+[package]
+name = "enigo"
+version = "0.0.14"
+authors = ["Dustin Bensing <dustin.bensing@googlemail.com>"]
+edition = "2018"
+build = "build.rs"
+
+description = "Enigo lets you control your mouse and keyboard in an abstract way on different operating systems (currently only Linux, macOS, Win – Redox and *BSD planned)"
+documentation = "https://docs.rs/enigo/"
+homepage = "https://github.com/enigo-rs/enigo"
+repository = "https://github.com/enigo-rs/enigo"
+readme = "README.md"
+keywords = ["input", "mouse", "testing", "keyboard", "automation"]
+categories = ["development-tools::testing", "api-bindings", "hardware-support"]
+license = "MIT"
+
+[badges]
+travis-ci = { repository = "enigo-rs/enigo" }
+appveyor = { repository = "pythoneer/enigo-85xiy" }
+
+[dependencies]
+serde = { version = "1.0", optional = true }
+serde_derive = { version = "1.0", optional = true }
+log = "0.4"
+
+[features]
+with_serde = ["serde", "serde_derive"]
+
+[target.'cfg(target_os = "windows")'.dependencies]
+winapi = { version = "0.3", features = ["winuser", "winbase"] }
+
+[target.'cfg(target_os = "macos")'.dependencies]
+core-graphics = "0.22"
+objc = "0.2"
+unicode-segmentation = "1.6"
+
+[target.'cfg(target_os = "linux")'.dependencies]
+libc = "0.2"
+
+[build-dependencies]
+pkg-config = "0.3"

libs/enigo/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 pythoneer
+
+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.

libs/enigo/README.md

@@ -0,0 +1,46 @@
+[![Build Status](https://travis-ci.org/enigo-rs/enigo.svg?branch=master)](https://travis-ci.org/enigo-rs/enigo)
+[![Build status](https://ci.appveyor.com/api/projects/status/6cd00pajx4tvvl3e?svg=true)](https://ci.appveyor.com/project/pythoneer/enigo-85xiy)
+[![Dependency Status](https://dependencyci.com/github/pythoneer/enigo/badge)](https://dependencyci.com/github/pythoneer/enigo)
+[![Docs](https://docs.rs/enigo/badge.svg)](https://docs.rs/enigo)
+[![Crates.io](https://img.shields.io/crates/v/enigo.svg)](https://crates.io/crates/enigo)
+[![Discord chat](https://img.shields.io/discord/315925376486342657.svg)](https://discord.gg/Eb8CsnN)
+[![Gitter chat](https://badges.gitter.im/gitterHQ/gitter.png)](https://gitter.im/enigo-rs/Lobby)
+
+
+# enigo
+Cross platform input simulation in Rust!
+
+- [x] Linux (X11) mouse
+- [x] Linux (X11) text
+- [ ] Linux (Wayland) mouse
+- [ ] Linux (Wayland) text
+- [x] MacOS mouse
+- [x] MacOS text
+- [x] Win mouse
+- [x] Win text
+- [x] Custom Parser
+
+
+```Rust
+let mut enigo = Enigo::new();
+
+enigo.mouse_move_to(500, 200);
+enigo.mouse_click(MouseButton::Left);
+enigo.key_sequence_parse("{+CTRL}a{-CTRL}{+SHIFT}Hello World{-SHIFT}");
+```
+
+for more look at examples
+
+Runtime dependencies
+--------------------
+
+Linux users may have to install libxdo-dev. For example, on Ubuntu:
+
+```Bash
+apt install libxdo-dev
+```
+On Arch: 
+
+```Bash
+pacman -S xdotool
+```

libs/enigo/appveyor.yml

@@ -0,0 +1,121 @@
+# Appveyor configuration template for Rust using rustup for Rust installation
+# https://github.com/starkat99/appveyor-rust
+
+## Operating System (VM environment) ##
+
+# Rust needs at least Visual Studio 2013 Appveyor OS for MSVC targets.
+os: Visual Studio 2015
+
+## Build Matrix ##
+
+# This configuration will setup a build for each channel & target combination (12 windows
+# combinations in all).
+#
+# There are 3 channels: stable, beta, and nightly.
+#
+# Alternatively, the full version may be specified for the channel to build using that specific
+# version (e.g. channel: 1.5.0)
+#
+# The values for target are the set of windows Rust build targets. Each value is of the form
+#
+# ARCH-pc-windows-TOOLCHAIN
+#
+# Where ARCH is the target architecture, either x86_64 or i686, and TOOLCHAIN is the linker
+# toolchain to use, either msvc or gnu. See https://www.rust-lang.org/downloads.html#win-foot for
+# a description of the toolchain differences.
+# See https://github.com/rust-lang-nursery/rustup.rs/#toolchain-specification for description of
+# toolchains and host triples.
+#
+# Comment out channel/target combos you do not wish to build in CI.
+#
+# You may use the `cargoflags` and `RUSTFLAGS` variables to set additional flags for cargo commands
+# and rustc, respectively. For instance, you can uncomment the cargoflags lines in the nightly
+# channels to enable unstable features when building for nightly. Or you could add additional
+# matrix entries to test different combinations of features.
+environment:
+  matrix:
+
+### MSVC Toolchains ###
+
+  # Stable 64-bit MSVC
+    - channel: stable
+      target: x86_64-pc-windows-msvc
+  # Stable 32-bit MSVC
+    - channel: stable
+      target: i686-pc-windows-msvc
+  # Beta 64-bit MSVC
+    - channel: beta
+      target: x86_64-pc-windows-msvc
+  # Beta 32-bit MSVC
+    - channel: beta
+      target: i686-pc-windows-msvc
+  # Nightly 64-bit MSVC
+    - channel: nightly
+      target: x86_64-pc-windows-msvc
+      #cargoflags: --features "unstable"
+  # Nightly 32-bit MSVC
+    - channel: nightly
+      target: i686-pc-windows-msvc
+      #cargoflags: --features "unstable"
+
+### GNU Toolchains ###
+
+  # Stable 64-bit GNU
+    - channel: stable
+      target: x86_64-pc-windows-gnu
+  # Stable 32-bit GNU
+    - channel: stable
+      target: i686-pc-windows-gnu
+  # Beta 64-bit GNU
+    - channel: beta
+      target: x86_64-pc-windows-gnu
+  # Beta 32-bit GNU
+    - channel: beta
+      target: i686-pc-windows-gnu
+  # Nightly 64-bit GNU
+    - channel: nightly
+      target: x86_64-pc-windows-gnu
+      #cargoflags: --features "unstable"
+  # Nightly 32-bit GNU
+    - channel: nightly
+      target: i686-pc-windows-gnu
+      #cargoflags: --features "unstable"
+
+### Allowed failures ###
+
+# See Appveyor documentation for specific details. In short, place any channel or targets you wish
+# to allow build failures on (usually nightly at least is a wise choice). This will prevent a build
+# or test failure in the matching channels/targets from failing the entire build.
+matrix:
+  allow_failures:
+    - channel: nightly
+
+# If you only care about stable channel build failures, uncomment the following line:
+    #- channel: beta
+
+## Install Script ##
+
+# This is the most important part of the Appveyor configuration. This installs the version of Rust
+# specified by the 'channel' and 'target' environment variables from the build matrix. This uses
+# rustup to install Rust.
+#
+# For simple configurations, instead of using the build matrix, you can simply set the
+# default-toolchain and default-host manually here.
+install:
+  - appveyor DownloadFile https://win.rustup.rs/ -FileName rustup-init.exe
+  - rustup-init -yv --default-toolchain %channel% --default-host %target%
+  - set PATH=%PATH%;%USERPROFILE%\.cargo\bin
+  - rustc -vV
+  - cargo -vV
+
+## Build Script ##
+
+# 'cargo test' takes care of building for us, so disable Appveyor's build stage. This prevents
+# the "directory does not contain a project or solution file" error.
+build: false
+
+# Uses 'cargo test' to run tests and build. Alternatively, the project may call compiled programs
+#directly or perform other testing commands. Rust will automatically be placed in the PATH
+# environment variable.
+test_script:
+  - cargo test --verbose %cargoflags%

libs/enigo/build.rs

@@ -0,0 +1,61 @@
+#[cfg(target_os = "windows")]
+fn main() {}
+
+#[cfg(target_os = "macos")]
+fn main() {}
+
+#[cfg(target_os = "linux")]
+use pkg_config;
+#[cfg(target_os = "linux")]
+use std::env;
+#[cfg(target_os = "linux")]
+use std::fs::File;
+#[cfg(target_os = "linux")]
+use std::io::Write;
+#[cfg(target_os = "linux")]
+use std::path::Path;
+
+#[cfg(target_os = "linux")]
+fn main() {
+    let libraries = [
+        "xext",
+        "gl",
+        "xcursor",
+        "xxf86vm",
+        "xft",
+        "xinerama",
+        "xi",
+        "x11",
+        "xlib_xcb",
+        "xmu",
+        "xrandr",
+        "xtst",
+        "xrender",
+        "xscrnsaver",
+        "xt",
+    ];
+
+    let mut config = String::new();
+    for lib in libraries.iter() {
+        let libdir = match pkg_config::get_variable(lib, "libdir") {
+            Ok(libdir) => format!("Some(\"{}\")", libdir),
+            Err(_) => "None".to_string(),
+        };
+        config.push_str(&format!(
+            "pub const {}: Option<&'static str> = {};\n",
+            lib, libdir
+        ));
+    }
+    let config = format!("pub mod config {{ pub mod libdir {{\n{}}}\n}}", config);
+    let out_dir = env::var("OUT_DIR").unwrap();
+    let dest_path = Path::new(&out_dir).join("config.rs");
+    let mut f = File::create(&dest_path).unwrap();
+    f.write_all(&config.into_bytes()).unwrap();
+
+    let target = env::var("TARGET").unwrap();
+    if target.contains("linux") {
+        println!("cargo:rustc-link-lib=dl");
+    } else if target.contains("freebsd") || target.contains("dragonfly") {
+        println!("cargo:rustc-link-lib=c");
+    }
+}

libs/enigo/examples/dsl.rs

@@ -0,0 +1,11 @@
+use enigo::{Enigo, KeyboardControllable};
+use std::thread;
+use std::time::Duration;
+
+fn main() {
+    thread::sleep(Duration::from_secs(2));
+    let mut enigo = Enigo::new();
+
+    // write text and select all
+    enigo.key_sequence_parse("{+UNICODE}{{Hello World!}} ❤️{-UNICODE}{+CTRL}a{-CTRL}");
+}

libs/enigo/examples/key.rs

@@ -0,0 +1,12 @@
+use enigo::{Enigo, Key, KeyboardControllable};
+use std::thread;
+use std::time::Duration;
+
+fn main() {
+    thread::sleep(Duration::from_secs(2));
+    let mut enigo = Enigo::new();
+
+    enigo.key_down(Key::Layout('a'));
+    thread::sleep(Duration::from_secs(1));
+    enigo.key_up(Key::Layout('a'));
+}

libs/enigo/examples/keyboard.rs

@@ -0,0 +1,16 @@
+use enigo::{Enigo, Key, KeyboardControllable};
+use std::thread;
+use std::time::Duration;
+
+fn main() {
+    thread::sleep(Duration::from_secs(2));
+    let mut enigo = Enigo::new();
+
+    // write text
+    enigo.key_sequence("Hello World! here is a lot of text  ❤️");
+
+    // select all
+    enigo.key_down(Key::Control);
+    enigo.key_click(Key::Layout('a'));
+    enigo.key_up(Key::Control);
+}

libs/enigo/examples/mouse.rs

@@ -0,0 +1,37 @@
+use enigo::{Enigo, MouseButton, MouseControllable};
+use std::thread;
+use std::time::Duration;
+
+fn main() {
+    let wait_time = Duration::from_secs(2);
+    let mut enigo = Enigo::new();
+
+    thread::sleep(wait_time);
+
+    enigo.mouse_move_to(500, 200);
+    thread::sleep(wait_time);
+
+    enigo.mouse_down(MouseButton::Left);
+    thread::sleep(wait_time);
+
+    enigo.mouse_move_relative(100, 100);
+    thread::sleep(wait_time);
+
+    enigo.mouse_up(MouseButton::Left);
+    thread::sleep(wait_time);
+
+    enigo.mouse_click(MouseButton::Left);
+    thread::sleep(wait_time);
+
+    enigo.mouse_scroll_x(2);
+    thread::sleep(wait_time);
+
+    enigo.mouse_scroll_x(-2);
+    thread::sleep(wait_time);
+
+    enigo.mouse_scroll_y(2);
+    thread::sleep(wait_time);
+
+    enigo.mouse_scroll_y(-2);
+    thread::sleep(wait_time);
+}

libs/enigo/examples/timer.rs

@@ -0,0 +1,22 @@
+use enigo::{Enigo, Key, KeyboardControllable};
+use std::thread;
+use std::time::Duration;
+use std::time::Instant;
+
+fn main() {
+    thread::sleep(Duration::from_secs(2));
+    let mut enigo = Enigo::new();
+
+    let now = Instant::now();
+
+    // write text
+    enigo.key_sequence("Hello World! ❤️");
+
+    let time = now.elapsed();
+    println!("{:?}", time);
+
+    // select all
+    enigo.key_down(Key::Control);
+    enigo.key_click(Key::Layout('a'));
+    enigo.key_up(Key::Control);
+}

libs/enigo/rustfmt.toml

@@ -0,0 +1 @@
+wrap_comments = true

libs/enigo/src/dsl.rs

@@ -0,0 +1,184 @@
+use crate::{Key, KeyboardControllable};
+use std::error::Error;
+use std::fmt;
+
+/// An error that can occur when parsing DSL
+#[derive(Debug, PartialEq, Eq)]
+pub enum ParseError {
+    /// When a tag doesn't exist.
+    /// Example: {+TEST}{-TEST}
+    ///            ^^^^   ^^^^
+    UnknownTag(String),
+
+    /// When a { is encountered inside a {TAG}.
+    /// Example: {+HELLO{WORLD}
+    ///                 ^
+    UnexpectedOpen,
+
+    /// When a { is never matched with a }.
+    /// Example: {+SHIFT}Hello{-SHIFT
+    ///                              ^
+    UnmatchedOpen,
+
+    /// Opposite of UnmatchedOpen.
+    /// Example: +SHIFT}Hello{-SHIFT}
+    ///         ^
+    UnmatchedClose,
+}
+impl Error for ParseError {
+    fn description(&self) -> &str {
+        match *self {
+            ParseError::UnknownTag(_) => "Unknown tag",
+            ParseError::UnexpectedOpen => "Unescaped open bracket ({) found inside tag name",
+            ParseError::UnmatchedOpen => "Unmatched open bracket ({). No matching close (})",
+            ParseError::UnmatchedClose => "Unmatched close bracket (}). No previous open ({)",
+        }
+    }
+}
+impl fmt::Display for ParseError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(&self.to_string())
+    }
+}
+
+/// Evaluate the DSL. This tokenizes the input and presses the keys.
+pub fn eval<K>(enigo: &mut K, input: &str) -> Result<(), ParseError>
+where
+    K: KeyboardControllable,
+{
+    for token in tokenize(input)? {
+        match token {
+            Token::Sequence(buffer) => {
+                for key in buffer.chars() {
+                    enigo.key_click(Key::Layout(key));
+                }
+            }
+            Token::Unicode(buffer) => enigo.key_sequence(&buffer),
+            Token::KeyUp(key) => enigo.key_up(key),
+            Token::KeyDown(key) => enigo.key_down(key).unwrap_or(()),
+        }
+    }
+    Ok(())
+}
+
+#[derive(Debug, PartialEq, Eq)]
+enum Token {
+    Sequence(String),
+    Unicode(String),
+    KeyUp(Key),
+    KeyDown(Key),
+}
+
+fn tokenize(input: &str) -> Result<Vec<Token>, ParseError> {
+    let mut unicode = false;
+
+    let mut tokens = Vec::new();
+    let mut buffer = String::new();
+    let mut iter = input.chars().peekable();
+
+    fn flush(tokens: &mut Vec<Token>, buffer: String, unicode: bool) {
+        if !buffer.is_empty() {
+            if unicode {
+                tokens.push(Token::Unicode(buffer));
+            } else {
+                tokens.push(Token::Sequence(buffer));
+            }
+        }
+    }
+
+    while let Some(c) = iter.next() {
+        if c == '{' {
+            match iter.next() {
+                Some('{') => buffer.push('{'),
+                Some(mut c) => {
+                    flush(&mut tokens, buffer, unicode);
+                    buffer = String::new();
+
+                    let mut tag = String::new();
+                    loop {
+                        tag.push(c);
+                        match iter.next() {
+                            Some('{') => match iter.peek() {
+                                Some(&'{') => {
+                                    iter.next();
+                                    c = '{'
+                                }
+                                _ => return Err(ParseError::UnexpectedOpen),
+                            },
+                            Some('}') => match iter.peek() {
+                                Some(&'}') => {
+                                    iter.next();
+                                    c = '}'
+                                }
+                                _ => break,
+                            },
+                            Some(new) => c = new,
+                            None => return Err(ParseError::UnmatchedOpen),
+                        }
+                    }
+                    match &*tag {
+                        "+UNICODE" => unicode = true,
+                        "-UNICODE" => unicode = false,
+                        "+SHIFT" => tokens.push(Token::KeyDown(Key::Shift)),
+                        "-SHIFT" => tokens.push(Token::KeyUp(Key::Shift)),
+                        "+CTRL" => tokens.push(Token::KeyDown(Key::Control)),
+                        "-CTRL" => tokens.push(Token::KeyUp(Key::Control)),
+                        "+META" => tokens.push(Token::KeyDown(Key::Meta)),
+                        "-META" => tokens.push(Token::KeyUp(Key::Meta)),
+                        "+ALT" => tokens.push(Token::KeyDown(Key::Alt)),
+                        "-ALT" => tokens.push(Token::KeyUp(Key::Alt)),
+                        _ => return Err(ParseError::UnknownTag(tag)),
+                    }
+                }
+                None => return Err(ParseError::UnmatchedOpen),
+            }
+        } else if c == '}' {
+            match iter.next() {
+                Some('}') => buffer.push('}'),
+                _ => return Err(ParseError::UnmatchedClose),
+            }
+        } else {
+            buffer.push(c);
+        }
+    }
+
+    flush(&mut tokens, buffer, unicode);
+
+    Ok(tokens)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn success() {
+        assert_eq!(
+            tokenize("{{Hello World!}} {+CTRL}hi{-CTRL}"),
+            Ok(vec![
+                Token::Sequence("{Hello World!} ".into()),
+                Token::KeyDown(Key::Control),
+                Token::Sequence("hi".into()),
+                Token::KeyUp(Key::Control)
+            ])
+        );
+    }
+    #[test]
+    fn unexpected_open() {
+        assert_eq!(tokenize("{hello{}world}"), Err(ParseError::UnexpectedOpen));
+    }
+    #[test]
+    fn unmatched_open() {
+        assert_eq!(
+            tokenize("{this is going to fail"),
+            Err(ParseError::UnmatchedOpen)
+        );
+    }
+    #[test]
+    fn unmatched_close() {
+        assert_eq!(
+            tokenize("{+CTRL}{{this}} is going to fail}"),
+            Err(ParseError::UnmatchedClose)
+        );
+    }
+}

libs/enigo/src/lib.rs

@@ -0,0 +1,525 @@
+//! Enigo lets you simulate mouse and keyboard input-events as if they were
+//! made by the actual hardware. The goal is to make it available on different
+//! operating systems like Linux, macOS and Windows – possibly many more but
+//! [Redox](https://redox-os.org/) and *BSD are planned. Please see the
+//! [Repo](https://github.com/enigo-rs/enigo) for the current status.
+//!
+//! I consider this library in an early alpha status, the API will change in
+//! in the future. The keyboard handling is far from being very usable. I plan
+//! to build a simple
+//! [DSL](https://en.wikipedia.org/wiki/Domain-specific_language)
+//! that will resemble something like:
+//!
+//! `"hello {+SHIFT}world{-SHIFT} and break line{ENTER}"`
+//!
+//! The current status is that you can just print
+//! [unicode](http://unicode.org/)
+//! characters like [emoji](http://getemoji.com/) without the `{+SHIFT}`
+//! [DSL](https://en.wikipedia.org/wiki/Domain-specific_language)
+//! or any other "special" key on the Linux, macOS and Windows operating system.
+//!
+//! Possible use cases could be for testing user interfaces on different
+//! plattforms,
+//! building remote control applications or just automating tasks for user
+//! interfaces unaccessible by a public API or scripting laguage.
+//!
+//! For the keyboard there are currently two modes you can use. The first mode
+//! is represented by the [key_sequence]() function
+//! its purpose is to simply write unicode characters. This is independent of
+//! the keyboardlayout. Please note that
+//! you're not be able to use modifier keys like Control
+//! to influence the outcome. If you want to use modifier keys to e.g.
+//! copy/paste
+//! use the Layout variant. Please note that this is indeed layout dependent.
+
+//! # Examples
+//! ```no_run
+//! use enigo::*;
+//! let mut enigo = Enigo::new();
+//! //paste
+//! enigo.key_down(Key::Control);
+//! enigo.key_click(Key::Layout('v'));
+//! enigo.key_up(Key::Control);
+//! ```
+//!
+//! ```no_run
+//! use enigo::*;
+//! let mut enigo = Enigo::new();
+//! enigo.mouse_move_to(500, 200);
+//! enigo.mouse_down(MouseButton::Left);
+//! enigo.mouse_move_relative(100, 100);
+//! enigo.mouse_up(MouseButton::Left);
+//! enigo.key_sequence("hello world");
+//! ```
+#![deny(missing_docs)]
+
+#[cfg(target_os = "macos")]
+#[macro_use]
+extern crate objc;
+
+// TODO(dustin) use interior mutability not &mut self
+
+#[cfg(target_os = "windows")]
+mod win;
+#[cfg(target_os = "windows")]
+pub use win::Enigo;
+
+#[cfg(target_os = "macos")]
+mod macos;
+#[cfg(target_os = "macos")]
+pub use macos::Enigo;
+
+#[cfg(target_os = "linux")]
+mod linux;
+#[cfg(target_os = "linux")]
+pub use crate::linux::Enigo;
+
+/// DSL parser module
+pub mod dsl;
+
+#[cfg(feature = "with_serde")]
+#[macro_use]
+extern crate serde_derive;
+
+#[cfg(feature = "with_serde")]
+extern crate serde;
+
+///
+pub type ResultType = std::result::Result<(), Box<dyn std::error::Error>>;
+
+#[cfg_attr(feature = "with_serde", derive(Serialize, Deserialize))]
+#[derive(Debug, Clone, Copy, PartialEq)]
+/// MouseButton represents a mouse button,
+/// and is used in for example
+/// [mouse_click](trait.MouseControllable.html#tymethod.mouse_click).
+/// WARNING: Types with the prefix Scroll
+/// IS NOT intended to be used, and may not work on
+/// all operating systems.
+pub enum MouseButton {
+    /// Left mouse button
+    Left,
+    /// Middle mouse button
+    Middle,
+    /// Right mouse button
+    Right,
+
+    /// Scroll up button
+    ScrollUp,
+    /// Left right button
+    ScrollDown,
+    /// Left right button
+    ScrollLeft,
+    /// Left right button
+    ScrollRight,
+}
+
+/// Representing an interface and a set of mouse functions every
+/// operating system implementation _should_ implement.
+pub trait MouseControllable {
+    /// Lets the mouse cursor move to the specified x and y coordinates.
+    ///
+    /// The topleft corner of your monitor screen is x=0 y=0. Move
+    /// the cursor down the screen by increasing the y and to the right
+    /// by increasing x coordinate.
+    ///
+    /// # Example
+    ///
+    /// ```no_run
+    /// use enigo::*;
+    /// let mut enigo = Enigo::new();
+    /// enigo.mouse_move_to(500, 200);
+    /// ```
+    fn mouse_move_to(&mut self, x: i32, y: i32);
+
+    /// Lets the mouse cursor move the specified amount in the x and y
+    /// direction.
+    ///
+    /// The amount specified in the x and y parameters are added to the
+    /// current location of the mouse cursor. A positive x values lets
+    /// the mouse cursor move an amount of `x` pixels to the right. A negative
+    /// value for `x` lets the mouse cursor go to the left. A positive value
+    /// of y
+    /// lets the mouse cursor go down, a negative one lets the mouse cursor go
+    /// up.
+    ///
+    /// # Example
+    ///
+    /// ```no_run
+    /// use enigo::*;
+    /// let mut enigo = Enigo::new();
+    /// enigo.mouse_move_relative(100, 100);
+    /// ```
+    fn mouse_move_relative(&mut self, x: i32, y: i32);
+
+    /// Push down one of the mouse buttons
+    ///
+    /// Push down the mouse button specified by the parameter `button` of
+    /// type [MouseButton](enum.MouseButton.html)
+    /// and holds it until it is released by
+    /// [mouse_up](trait.MouseControllable.html#tymethod.mouse_up).
+    /// Calls to [mouse_move_to](trait.MouseControllable.html#tymethod.
+    /// mouse_move_to) or
+    /// [mouse_move_relative](trait.MouseControllable.html#tymethod.
+    /// mouse_move_relative)
+    /// will work like expected and will e.g. drag widgets or highlight text.
+    ///
+    /// # Example
+    ///
+    /// ```no_run
+    /// use enigo::*;
+    /// let mut enigo = Enigo::new();
+    /// enigo.mouse_down(MouseButton::Left);
+    /// ```
+    fn mouse_down(&mut self, button: MouseButton) -> ResultType;
+
+    /// Lift up a pushed down mouse button
+    ///
+    /// Lift up a previously pushed down button (by invoking
+    /// [mouse_down](trait.MouseControllable.html#tymethod.mouse_down)).
+    /// If the button was not pushed down or consecutive calls without
+    /// invoking [mouse_down](trait.MouseControllable.html#tymethod.mouse_down)
+    /// will emit lift up events. It depends on the
+    /// operating system whats actually happening – my guess is it will just
+    /// get ignored.
+    ///
+    /// # Example
+    ///
+    /// ```no_run
+    /// use enigo::*;
+    /// let mut enigo = Enigo::new();
+    /// enigo.mouse_up(MouseButton::Right);
+    /// ```
+    fn mouse_up(&mut self, button: MouseButton);
+
+    /// Click a mouse button
+    ///
+    /// it's esentially just a consecutive invokation of
+    /// [mouse_down](trait.MouseControllable.html#tymethod.mouse_down) followed
+    /// by a [mouse_up](trait.MouseControllable.html#tymethod.mouse_up). Just
+    /// for
+    /// convenience.
+    ///
+    /// # Example
+    ///
+    /// ```no_run
+    /// use enigo::*;
+    /// let mut enigo = Enigo::new();
+    /// enigo.mouse_click(MouseButton::Right);
+    /// ```
+    fn mouse_click(&mut self, button: MouseButton);
+
+    /// Scroll the mouse (wheel) left or right
+    ///
+    /// Positive numbers for length lets the mouse wheel scroll to the right
+    /// and negative ones to the left. The value that is specified translates
+    /// to `lines` defined by the operating system and is essentially one 15°
+    /// (click)rotation on the mouse wheel. How many lines it moves depends
+    /// on the current setting in the operating system.
+    ///
+    /// # Example
+    ///
+    /// ```no_run
+    /// use enigo::*;
+    /// let mut enigo = Enigo::new();
+    /// enigo.mouse_scroll_x(2);
+    /// ```
+    fn mouse_scroll_x(&mut self, length: i32);
+
+    /// Scroll the mouse (wheel) up or down
+    ///
+    /// Positive numbers for length lets the mouse wheel scroll down
+    /// and negative ones up. The value that is specified translates
+    /// to `lines` defined by the operating system and is essentially one 15°
+    /// (click)rotation on the mouse wheel. How many lines it moves depends
+    /// on the current setting in the operating system.
+    ///
+    /// # Example
+    ///
+    /// ```no_run
+    /// use enigo::*;
+    /// let mut enigo = Enigo::new();
+    /// enigo.mouse_scroll_y(2);
+    /// ```
+    fn mouse_scroll_y(&mut self, length: i32);
+}
+
+/// A key on the keyboard.
+/// For alphabetical keys, use Key::Layout for a system independent key.
+/// If a key is missing, you can use the raw keycode with Key::Raw.
+#[cfg_attr(feature = "with_serde", derive(Serialize, Deserialize))]
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum Key {
+    /// alt key on Linux and Windows (option key on macOS)
+    Alt,
+    /// backspace key
+    Backspace,
+    /// caps lock key
+    CapsLock,
+    #[deprecated(since = "0.0.12", note = "now renamed to Meta")]
+    /// command key on macOS (super key on Linux, windows key on Windows)
+    Command,
+    /// control key
+    Control,
+    /// delete key
+    Delete,
+    /// down arrow key
+    DownArrow,
+    /// end key
+    End,
+    /// escape key (esc)
+    Escape,
+    /// F1 key
+    F1,
+    /// F10 key
+    F10,
+    /// F11 key
+    F11,
+    /// F12 key
+    F12,
+    /// F2 key
+    F2,
+    /// F3 key
+    F3,
+    /// F4 key
+    F4,
+    /// F5 key
+    F5,
+    /// F6 key
+    F6,
+    /// F7 key
+    F7,
+    /// F8 key
+    F8,
+    /// F9 key
+    F9,
+    /// home key
+    Home,
+    /// left arrow key
+    LeftArrow,
+    /// meta key (also known as "windows", "super", and "command")
+    Meta,
+    /// option key on macOS (alt key on Linux and Windows)
+    Option,
+    /// page down key
+    PageDown,
+    /// page up key
+    PageUp,
+    /// return key
+    Return,
+    /// right arrow key
+    RightArrow,
+    /// shift key
+    Shift,
+    /// space key
+    Space,
+    #[deprecated(since = "0.0.12", note = "now renamed to Meta")]
+    /// super key on linux (command key on macOS, windows key on Windows)
+    Super,
+    /// tab key (tabulator)
+    Tab,
+    /// up arrow key
+    UpArrow,
+    #[deprecated(since = "0.0.12", note = "now renamed to Meta")]
+    /// windows key on Windows (super key on Linux, command key on macOS)
+    Windows,
+    ///
+    Numpad0,
+    ///
+    Numpad1,
+    ///
+    Numpad2,
+    ///
+    Numpad3,
+    ///
+    Numpad4,
+    ///
+    Numpad5,
+    ///
+    Numpad6,
+    ///
+    Numpad7,
+    ///
+    Numpad8,
+    ///
+    Numpad9,
+    ///
+    Cancel,
+    ///
+    Clear,
+    ///
+    Menu,
+    ///
+    Pause,
+    ///
+    Kana,
+    ///
+    Hangul,
+    ///
+    Junja,
+    ///
+    Final,
+    ///
+    Hanja,
+    ///
+    Kanji,
+    ///
+    Convert,
+    ///
+    Select,
+    ///
+    Print,
+    ///
+    Execute,
+    ///
+    Snapshot,
+    ///
+    Insert,
+    ///
+    Help,
+    ///
+    Sleep,
+    ///
+    Separator,
+    ///
+    VolumeUp,
+    ///
+    VolumeDown,
+    ///
+    Mute,
+    ///
+    Scroll,
+    /// scroll lock
+    NumLock,
+    ///
+    RWin,
+    ///
+    Apps,
+    ///
+    Multiply,
+    ///
+    Add,
+    ///
+    Subtract,
+    ///
+    Decimal,
+    ///
+    Divide,
+    ///
+    Equals,
+    ///
+    NumpadEnter,
+    ///
+    /// Function, /// mac
+    /// keyboard layout dependent key
+    Layout(char),
+    /// raw keycode eg 0x38
+    Raw(u16),
+}
+
+/// Representing an interface and a set of keyboard functions every
+/// operating system implementation _should_ implement.
+pub trait KeyboardControllable {
+    /// Types the string parsed with DSL.
+    ///
+    /// Typing {+SHIFT}hello{-SHIFT} becomes HELLO.
+    /// TODO: Full documentation
+    fn key_sequence_parse(&mut self, sequence: &str)
+    where
+        Self: Sized,
+    {
+        self.key_sequence_parse_try(sequence)
+            .expect("Could not parse sequence");
+    }
+    /// Same as key_sequence_parse except returns any errors
+    fn key_sequence_parse_try(&mut self, sequence: &str) -> Result<(), dsl::ParseError>
+    where
+        Self: Sized,
+    {
+        dsl::eval(self, sequence)
+    }
+
+    /// Types the string
+    ///
+    /// Emits keystrokes such that the given string is inputted.
+    ///
+    /// You can use many unicode here like: ❤️. This works
+    /// regadless of the current keyboardlayout.
+    ///
+    /// # Example
+    ///
+    /// ```no_run
+    /// use enigo::*;
+    /// let mut enigo = Enigo::new();
+    /// enigo.key_sequence("hello world ❤️");
+    /// ```
+    fn key_sequence(&mut self, sequence: &str);
+
+    /// presses a given key down
+    fn key_down(&mut self, key: Key) -> ResultType;
+
+    /// release a given key formally pressed down by
+    /// [key_down](trait.KeyboardControllable.html#tymethod.key_down)
+    fn key_up(&mut self, key: Key);
+
+    /// Much like the
+    /// [key_down](trait.KeyboardControllable.html#tymethod.key_down) and
+    /// [key_up](trait.KeyboardControllable.html#tymethod.key_up)
+    /// function they're just invoked consecutively
+    fn key_click(&mut self, key: Key);
+
+    ///
+    fn get_key_state(&mut self, key: Key) -> bool;
+}
+
+#[cfg(any(target_os = "android", target_os = "ios"))]
+struct Enigo;
+
+impl Enigo {
+    /// Constructs a new `Enigo` instance.
+    ///
+    /// # Example
+    ///
+    /// ```no_run
+    /// use enigo::*;
+    /// let mut enigo = Enigo::new();
+    /// ```
+    pub fn new() -> Self {
+        #[cfg(any(target_os = "android", target_os = "ios"))]
+        return Enigo{};
+        #[cfg(not(any(target_os = "android", target_os = "ios")))]
+        Self::default()
+    }
+}
+
+use std::fmt;
+
+impl fmt::Debug for Enigo {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "Enigo")
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn test_get_key_state() {
+        let mut enigo = Enigo::new();
+        let keys = [Key::CapsLock, Key::NumLock];
+        for k in keys.iter() {
+            enigo.key_click(k.clone());
+            let a = enigo.get_key_state(k.clone());
+            enigo.key_click(k.clone());
+            let b = enigo.get_key_state(k.clone());
+            assert!(a != b);
+        }
+        let keys = [Key::Control, Key::Alt, Key::Shift];
+        for k in keys.iter() {
+            enigo.key_down(k.clone()).ok();
+            let a = enigo.get_key_state(k.clone());
+            enigo.key_up(k.clone());
+            let b = enigo.get_key_state(k.clone());
+            assert!(a != b);
+        }
+    }
+}

libs/enigo/src/linux.rs

@@ -0,0 +1,361 @@
+use libc;
+
+use crate::{Key, KeyboardControllable, MouseButton, MouseControllable};
+
+use self::libc::{c_char, c_int, c_void, useconds_t};
+use std::{borrow::Cow, ffi::CString, ptr};
+
+const CURRENT_WINDOW: c_int = 0;
+const DEFAULT_DELAY: u64 = 12000;
+type Window = c_int;
+type Xdo = *const c_void;
+
+#[link(name = "xdo")]
+extern "C" {
+    fn xdo_free(xdo: Xdo);
+    fn xdo_new(display: *const c_char) -> Xdo;
+
+    fn xdo_click_window(xdo: Xdo, window: Window, button: c_int) -> c_int;
+    fn xdo_mouse_down(xdo: Xdo, window: Window, button: c_int) -> c_int;
+    fn xdo_mouse_up(xdo: Xdo, window: Window, button: c_int) -> c_int;
+    fn xdo_move_mouse(xdo: Xdo, x: c_int, y: c_int, screen: c_int) -> c_int;
+    fn xdo_move_mouse_relative(xdo: Xdo, x: c_int, y: c_int) -> c_int;
+
+    fn xdo_enter_text_window(
+        xdo: Xdo,
+        window: Window,
+        string: *const c_char,
+        delay: useconds_t,
+    ) -> c_int;
+    fn xdo_send_keysequence_window(
+        xdo: Xdo,
+        window: Window,
+        string: *const c_char,
+        delay: useconds_t,
+    ) -> c_int;
+    fn xdo_send_keysequence_window_down(
+        xdo: Xdo,
+        window: Window,
+        string: *const c_char,
+        delay: useconds_t,
+    ) -> c_int;
+    fn xdo_send_keysequence_window_up(
+        xdo: Xdo,
+        window: Window,
+        string: *const c_char,
+        delay: useconds_t,
+    ) -> c_int;
+    fn xdo_get_input_state(xdo: Xdo) -> u32;
+}
+
+fn mousebutton(button: MouseButton) -> c_int {
+    match button {
+        MouseButton::Left => 1,
+        MouseButton::Middle => 2,
+        MouseButton::Right => 3,
+        MouseButton::ScrollUp => 4,
+        MouseButton::ScrollDown => 5,
+        MouseButton::ScrollLeft => 6,
+        MouseButton::ScrollRight => 7,
+    }
+}
+
+/// The main struct for handling the event emitting
+pub struct Enigo {
+    xdo: Xdo,
+    delay: u64,
+}
+// This is safe, we have a unique pointer.
+// TODO: use Unique<c_char> once stable.
+unsafe impl Send for Enigo {}
+
+impl Default for Enigo {
+    /// Create a new Enigo instance
+    fn default() -> Self {
+        Self {
+            xdo: unsafe { xdo_new(ptr::null()) },
+            delay: DEFAULT_DELAY,
+        }
+    }
+}
+impl Enigo {
+    /// Get the delay per keypress.
+    /// Default value is 12000.
+    /// This is Linux-specific.
+    pub fn delay(&self) -> u64 {
+        self.delay
+    }
+    /// Set the delay per keypress.
+    /// This is Linux-specific.
+    pub fn set_delay(&mut self, delay: u64) {
+        self.delay = delay;
+    }
+}
+impl Drop for Enigo {
+    fn drop(&mut self) {
+        if self.xdo.is_null() {
+            return;
+        }
+        unsafe {
+            xdo_free(self.xdo);
+        }
+    }
+}
+impl MouseControllable for Enigo {
+    fn mouse_move_to(&mut self, x: i32, y: i32) {
+        if self.xdo.is_null() {
+            return;
+        }
+        unsafe {
+            xdo_move_mouse(self.xdo, x as c_int, y as c_int, 0);
+        }
+    }
+    fn mouse_move_relative(&mut self, x: i32, y: i32) {
+        if self.xdo.is_null() {
+            return;
+        }
+        unsafe {
+            xdo_move_mouse_relative(self.xdo, x as c_int, y as c_int);
+        }
+    }
+    fn mouse_down(&mut self, button: MouseButton) -> crate::ResultType {
+        if self.xdo.is_null() {
+            return Ok(());
+        }
+        unsafe {
+            xdo_mouse_down(self.xdo, CURRENT_WINDOW, mousebutton(button));
+        }
+        Ok(())
+    }
+    fn mouse_up(&mut self, button: MouseButton) {
+        if self.xdo.is_null() {
+            return;
+        }
+        unsafe {
+            xdo_mouse_up(self.xdo, CURRENT_WINDOW, mousebutton(button));
+        }
+    }
+    fn mouse_click(&mut self, button: MouseButton) {
+        if self.xdo.is_null() {
+            return;
+        }
+        unsafe {
+            xdo_click_window(self.xdo, CURRENT_WINDOW, mousebutton(button));
+        }
+    }
+    fn mouse_scroll_x(&mut self, length: i32) {
+        let button;
+        let mut length = length;
+
+        if length < 0 {
+            button = MouseButton::ScrollLeft;
+        } else {
+            button = MouseButton::ScrollRight;
+        }
+
+        if length < 0 {
+            length = -length;
+        }
+
+        for _ in 0..length {
+            self.mouse_click(button);
+        }
+    }
+    fn mouse_scroll_y(&mut self, length: i32) {
+        let button;
+        let mut length = length;
+
+        if length < 0 {
+            button = MouseButton::ScrollUp;
+        } else {
+            button = MouseButton::ScrollDown;
+        }
+
+        if length < 0 {
+            length = -length;
+        }
+
+        for _ in 0..length {
+            self.mouse_click(button);
+        }
+    }
+}
+fn keysequence<'a>(key: Key) -> Cow<'a, str> {
+    if let Key::Layout(c) = key {
+        return Cow::Owned(format!("U{:X}", c as u32));
+    }
+    if let Key::Raw(k) = key {
+        return Cow::Owned(format!("{}", k as u16));
+    }
+    #[allow(deprecated)]
+    // I mean duh, we still need to support deprecated keys until they're removed
+    // https://www.rubydoc.info/gems/xdo/XDo/Keyboard
+    // https://gitlab.com/cunidev/gestures/-/wikis/xdotool-list-of-key-codes
+    Cow::Borrowed(match key {
+        Key::Alt => "Alt",
+        Key::Backspace => "BackSpace",
+        Key::CapsLock => "Caps_Lock",
+        Key::Control => "Control",
+        Key::Delete => "Delete",
+        Key::DownArrow => "Down",
+        Key::End => "End",
+        Key::Escape => "Escape",
+        Key::F1 => "F1",
+        Key::F10 => "F10",
+        Key::F11 => "F11",
+        Key::F12 => "F12",
+        Key::F2 => "F2",
+        Key::F3 => "F3",
+        Key::F4 => "F4",
+        Key::F5 => "F5",
+        Key::F6 => "F6",
+        Key::F7 => "F7",
+        Key::F8 => "F8",
+        Key::F9 => "F9",
+        Key::Home => "Home",
+        //Key::Layout(_) => unreachable!(),
+        Key::LeftArrow => "Left",
+        Key::Option => "Option",
+        Key::PageDown => "Page_Down",
+        Key::PageUp => "Page_Up",
+        //Key::Raw(_) => unreachable!(),
+        Key::Return => "Return",
+        Key::RightArrow => "Right",
+        Key::Shift => "Shift",
+        Key::Space => "space",
+        Key::Tab => "Tab",
+        Key::UpArrow => "Up",
+        Key::Numpad0 => "U30", //"KP_0",
+        Key::Numpad1 => "U31", //"KP_1",
+        Key::Numpad2 => "U32", //"KP_2",
+        Key::Numpad3 => "U33", //"KP_3",
+        Key::Numpad4 => "U34", //"KP_4",
+        Key::Numpad5 => "U35", //"KP_5",
+        Key::Numpad6 => "U36", //"KP_6",
+        Key::Numpad7 => "U37", //"KP_7",
+        Key::Numpad8 => "U38", //"KP_8",
+        Key::Numpad9 => "U39", //"KP_9",
+        Key::Decimal => "U2E", //"KP_Decimal",
+        Key::Cancel => "Cancel",
+        Key::Clear => "Clear",
+        Key::Menu => "Menu",
+        Key::Pause => "Pause",
+        Key::Kana => "Kana",
+        Key::Hangul => "Hangul",
+        Key::Junja => "",
+        Key::Final => "",
+        Key::Hanja => "Hanja",
+        Key::Kanji => "Kanji",
+        Key::Convert => "",
+        Key::Select => "Select",
+        Key::Print => "Print",
+        Key::Execute => "Execute",
+        Key::Snapshot => "3270_PrintScreen",
+        Key::Insert => "Insert",
+        Key::Help => "Help",
+        Key::Sleep => "",
+        Key::Separator => "KP_Separator",
+        Key::VolumeUp => "",
+        Key::VolumeDown => "",
+        Key::Mute => "",
+        Key::Scroll => "Scroll_Lock",
+        Key::NumLock => "Num_Lock",
+        Key::RWin => "",
+        Key::Apps => "",
+        Key::Multiply => "KP_Multiply",
+        Key::Add => "KP_Add",
+        Key::Subtract => "KP_Subtract",
+        Key::Divide => "KP_Divide",
+        Key::Equals => "KP_Equal",
+        Key::NumpadEnter => "KP_Enter",
+
+        Key::Command | Key::Super | Key::Windows | Key::Meta => "Super",
+
+        _ => "",
+    })
+}
+impl KeyboardControllable for Enigo {
+    fn get_key_state(&mut self, key: Key) -> bool {
+        if self.xdo.is_null() {
+            return false;
+        }
+        let mod_shift = 1 << 0;
+        let mod_lock = 1 << 1;
+        let mod_control = 1 << 2;
+        let mod_alt = 1 << 3;
+        let mod_numlock = 1 << 4;
+        let mod_meta = 1 << 6;
+        let mask = unsafe { xdo_get_input_state(self.xdo) };
+        // println!("{:b}", mask);
+        match key {
+            Key::Shift => mask & mod_shift != 0,
+            Key::CapsLock => mask & mod_lock != 0,
+            Key::Control => mask & mod_control != 0,
+            Key::Alt => mask & mod_alt != 0,
+            Key::NumLock => mask & mod_numlock != 0,
+            Key::Meta => mask & mod_meta != 0,
+            _ => false,
+        }
+    }
+
+    fn key_sequence(&mut self, sequence: &str) {
+        if self.xdo.is_null() {
+            return;
+        }
+        if let Ok(string) = CString::new(sequence) {
+            unsafe {
+                xdo_enter_text_window(
+                    self.xdo,
+                    CURRENT_WINDOW,
+                    string.as_ptr(),
+                    self.delay as useconds_t,
+                );
+            }
+        }
+    }
+    fn key_down(&mut self, key: Key) -> crate::ResultType {
+        if self.xdo.is_null() {
+            return Ok(());
+        }
+        let string = CString::new(&*keysequence(key))?;
+        unsafe {
+            xdo_send_keysequence_window_down(
+                self.xdo,
+                CURRENT_WINDOW,
+                string.as_ptr(),
+                self.delay as useconds_t,
+            );
+        }
+        Ok(())
+    }
+    fn key_up(&mut self, key: Key) {
+        if self.xdo.is_null() {
+            return;
+        }
+        if let Ok(string) = CString::new(&*keysequence(key)) {
+            unsafe {
+                xdo_send_keysequence_window_up(
+                    self.xdo,
+                    CURRENT_WINDOW,
+                    string.as_ptr(),
+                    self.delay as useconds_t,
+                );
+            }
+        }
+    }
+    fn key_click(&mut self, key: Key) {
+        if self.xdo.is_null() {
+            return;
+        }
+        if let Ok(string) = CString::new(&*keysequence(key)) {
+            unsafe {
+                xdo_send_keysequence_window(
+                    self.xdo,
+                    CURRENT_WINDOW,
+                    string.as_ptr(),
+                    self.delay as useconds_t,
+                );
+            }
+        }
+    }
+}

libs/enigo/src/macos/keycodes.rs

@@ -0,0 +1,72 @@
+// https://stackoverflow.com/questions/3202629/where-can-i-find-a-list-of-mac-virtual-key-codes
+
+/* keycodes for keys that are independent of keyboard layout */
+
+#![allow(non_upper_case_globals)]
+#![allow(dead_code)]
+
+pub const kVK_Return: u16 = 0x24;
+pub const kVK_Tab: u16 = 0x30;
+pub const kVK_Space: u16 = 0x31;
+pub const kVK_Delete: u16 = 0x33;
+pub const kVK_Escape: u16 = 0x35;
+pub const kVK_Command: u16 = 0x37;
+pub const kVK_Shift: u16 = 0x38;
+pub const kVK_CapsLock: u16 = 0x39;
+pub const kVK_Option: u16 = 0x3A;
+pub const kVK_Control: u16 = 0x3B;
+pub const kVK_RightShift: u16 = 0x3C;
+pub const kVK_RightOption: u16 = 0x3D;
+pub const kVK_RightControl: u16 = 0x3E;
+pub const kVK_Function: u16 = 0x3F;
+pub const kVK_F17: u16 = 0x40;
+pub const kVK_VolumeUp: u16 = 0x48;
+pub const kVK_VolumeDown: u16 = 0x49;
+pub const kVK_Mute: u16 = 0x4A;
+pub const kVK_F18: u16 = 0x4F;
+pub const kVK_F19: u16 = 0x50;
+pub const kVK_F20: u16 = 0x5A;
+pub const kVK_F5: u16 = 0x60;
+pub const kVK_F6: u16 = 0x61;
+pub const kVK_F7: u16 = 0x62;
+pub const kVK_F3: u16 = 0x63;
+pub const kVK_F8: u16 = 0x64;
+pub const kVK_F9: u16 = 0x65;
+pub const kVK_F11: u16 = 0x67;
+pub const kVK_F13: u16 = 0x69;
+pub const kVK_F16: u16 = 0x6A;
+pub const kVK_F14: u16 = 0x6B;
+pub const kVK_F10: u16 = 0x6D;
+pub const kVK_F12: u16 = 0x6F;
+pub const kVK_F15: u16 = 0x71;
+pub const kVK_Help: u16 = 0x72;
+pub const kVK_Home: u16 = 0x73;
+pub const kVK_PageUp: u16 = 0x74;
+pub const kVK_ForwardDelete: u16 = 0x75;
+pub const kVK_F4: u16 = 0x76;
+pub const kVK_End: u16 = 0x77;
+pub const kVK_F2: u16 = 0x78;
+pub const kVK_PageDown: u16 = 0x79;
+pub const kVK_F1: u16 = 0x7A;
+pub const kVK_LeftArrow: u16 = 0x7B;
+pub const kVK_RightArrow: u16 = 0x7C;
+pub const kVK_DownArrow: u16 = 0x7D;
+pub const kVK_UpArrow: u16 = 0x7E;
+pub const kVK_ANSI_Keypad0: u16 = 0x52;
+pub const kVK_ANSI_Keypad1: u16 = 0x53;
+pub const kVK_ANSI_Keypad2: u16 = 0x54;
+pub const kVK_ANSI_Keypad3: u16 = 0x55;
+pub const kVK_ANSI_Keypad4: u16 = 0x56;
+pub const kVK_ANSI_Keypad5: u16 = 0x57;
+pub const kVK_ANSI_Keypad6: u16 = 0x58;
+pub const kVK_ANSI_Keypad7: u16 = 0x59;
+pub const kVK_ANSI_Keypad8: u16 = 0x5B;
+pub const kVK_ANSI_Keypad9: u16 = 0x5C;
+pub const kVK_ANSI_KeypadClear: u16 = 0x47;
+pub const kVK_ANSI_KeypadDecimal: u16 = 0x41;
+pub const kVK_ANSI_KeypadMultiply: u16 = 0x43;
+pub const kVK_ANSI_KeypadPlus: u16 = 0x45;
+pub const kVK_ANSI_KeypadDivide: u16 = 0x4B;
+pub const kVK_ANSI_KeypadEnter: u16 = 0x4C;
+pub const kVK_ANSI_KeypadMinus: u16 = 0x4E;
+pub const kVK_ANSI_KeypadEquals: u16 = 0x51;

libs/enigo/src/macos/macos_impl.rs

@@ -0,0 +1,680 @@
+use core_graphics;
+
+// TODO(dustin): use only the things i need
+
+use self::core_graphics::display::*;
+use self::core_graphics::event::*;
+use self::core_graphics::event_source::*;
+
+use crate::macos::keycodes::*;
+use crate::{Key, KeyboardControllable, MouseButton, MouseControllable};
+use objc::runtime::Class;
+use std::ffi::CStr;
+use std::os::raw::*;
+
+// required for pressedMouseButtons on NSEvent
+#[link(name = "AppKit", kind = "framework")]
+extern "C" {}
+
+struct MyCGEvent;
+
+#[allow(improper_ctypes)]
+#[allow(non_snake_case)]
+#[link(name = "ApplicationServices", kind = "framework")]
+extern "C" {
+    fn CGEventPost(tapLocation: CGEventTapLocation, event: *mut MyCGEvent);
+    // not present in servo/core-graphics
+    fn CGEventCreateScrollWheelEvent(
+        source: &CGEventSourceRef,
+        units: ScrollUnit,
+        wheelCount: u32,
+        wheel1: i32,
+        ...
+    ) -> *mut MyCGEvent;
+    fn CGEventSourceKeyState(stateID: i32, key: u16) -> bool;
+}
+
+pub type CFDataRef = *const c_void;
+
+#[repr(C)]
+#[derive(Clone, Copy)]
+struct NSPoint {
+    x: f64,
+    y: f64,
+}
+
+#[repr(C)]
+pub struct __TISInputSource;
+pub type TISInputSourceRef = *const __TISInputSource;
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct __CFString([u8; 0]);
+pub type CFStringRef = *const __CFString;
+pub type Boolean = c_uchar;
+pub type UInt8 = c_uchar;
+pub type SInt32 = c_int;
+pub type UInt16 = c_ushort;
+pub type UInt32 = c_uint;
+pub type UniChar = UInt16;
+pub type UniCharCount = c_ulong;
+
+pub type OptionBits = UInt32;
+pub type OSStatus = SInt32;
+
+pub type CFStringEncoding = UInt32;
+
+#[allow(non_upper_case_globals)]
+pub const kUCKeyActionDisplay: _bindgen_ty_702 = _bindgen_ty_702::kUCKeyActionDisplay;
+
+#[allow(non_camel_case_types)]
+#[repr(u32)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+pub enum _bindgen_ty_702 {
+    // kUCKeyActionDown = 0,
+    // kUCKeyActionUp = 1,
+    // kUCKeyActionAutoKey = 2,
+    kUCKeyActionDisplay = 3,
+}
+
+#[allow(non_snake_case)]
+#[repr(C)]
+#[derive(Debug, Clone, Copy)]
+pub struct UCKeyboardTypeHeader {
+    pub keyboardTypeFirst: UInt32,
+    pub keyboardTypeLast: UInt32,
+    pub keyModifiersToTableNumOffset: UInt32,
+    pub keyToCharTableIndexOffset: UInt32,
+    pub keyStateRecordsIndexOffset: UInt32,
+    pub keyStateTerminatorsOffset: UInt32,
+    pub keySequenceDataIndexOffset: UInt32,
+}
+
+#[allow(non_snake_case)]
+#[repr(C)]
+#[derive(Debug, Clone, Copy)]
+pub struct UCKeyboardLayout {
+    pub keyLayoutHeaderFormat: UInt16,
+    pub keyLayoutDataVersion: UInt16,
+    pub keyLayoutFeatureInfoOffset: UInt32,
+    pub keyboardTypeCount: UInt32,
+    pub keyboardTypeList: [UCKeyboardTypeHeader; 1usize],
+}
+
+#[allow(non_upper_case_globals)]
+pub const kUCKeyTranslateNoDeadKeysBit: _bindgen_ty_703 =
+    _bindgen_ty_703::kUCKeyTranslateNoDeadKeysBit;
+
+#[allow(non_camel_case_types)]
+#[repr(u32)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+pub enum _bindgen_ty_703 {
+    kUCKeyTranslateNoDeadKeysBit = 0,
+}
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct __CFAllocator([u8; 0]);
+pub type CFAllocatorRef = *const __CFAllocator;
+
+// #[repr(u32)]
+// #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+// pub enum _bindgen_ty_15 {
+//     kCFStringEncodingMacRoman = 0,
+//     kCFStringEncodingWindowsLatin1 = 1280,
+//     kCFStringEncodingISOLatin1 = 513,
+//     kCFStringEncodingNextStepLatin = 2817,
+//     kCFStringEncodingASCII = 1536,
+//     kCFStringEncodingUnicode = 256,
+//     kCFStringEncodingUTF8 = 134217984,
+//     kCFStringEncodingNonLossyASCII = 3071,
+//     kCFStringEncodingUTF16BE = 268435712,
+//     kCFStringEncodingUTF16LE = 335544576,
+//     kCFStringEncodingUTF32 = 201326848,
+//     kCFStringEncodingUTF32BE = 402653440,
+//     kCFStringEncodingUTF32LE = 469762304,
+// }
+
+#[allow(non_upper_case_globals)]
+pub const kCFStringEncodingUTF8: u32 = 134_217_984;
+
+#[allow(improper_ctypes)]
+#[link(name = "Carbon", kind = "framework")]
+extern "C" {
+    fn TISCopyCurrentKeyboardInputSource() -> TISInputSourceRef;
+
+    //     extern void *
+    // TISGetInputSourceProperty(
+    //   TISInputSourceRef   inputSource,
+    //   CFStringRef         propertyKey)
+
+    #[allow(non_upper_case_globals)]
+    #[link_name = "kTISPropertyUnicodeKeyLayoutData"]
+    pub static kTISPropertyUnicodeKeyLayoutData: CFStringRef;
+
+    #[allow(non_snake_case)]
+    pub fn TISGetInputSourceProperty(
+        inputSource: TISInputSourceRef,
+        propertyKey: CFStringRef,
+    ) -> *mut c_void;
+
+    #[allow(non_snake_case)]
+    pub fn CFDataGetBytePtr(theData: CFDataRef) -> *const UInt8;
+
+    #[allow(non_snake_case)]
+    pub fn UCKeyTranslate(
+        keyLayoutPtr: *const UInt8, //*const UCKeyboardLayout,
+        virtualKeyCode: UInt16,
+        keyAction: UInt16,
+        modifierKeyState: UInt32,
+        keyboardType: UInt32,
+        keyTranslateOptions: OptionBits,
+        deadKeyState: *mut UInt32,
+        maxStringLength: UniCharCount,
+        actualStringLength: *mut UniCharCount,
+        unicodeString: *mut UniChar,
+    ) -> OSStatus;
+
+    pub fn LMGetKbdType() -> UInt8;
+
+    #[allow(non_snake_case)]
+    pub fn CFStringCreateWithCharacters(
+        alloc: CFAllocatorRef,
+        chars: *const UniChar,
+        numChars: CFIndex,
+    ) -> CFStringRef;
+
+    #[allow(non_upper_case_globals)]
+    #[link_name = "kCFAllocatorDefault"]
+    pub static kCFAllocatorDefault: CFAllocatorRef;
+
+    #[allow(non_snake_case)]
+    pub fn CFStringGetCString(
+        theString: CFStringRef,
+        buffer: *mut c_char,
+        bufferSize: CFIndex,
+        encoding: CFStringEncoding,
+    ) -> Boolean;
+}
+
+// not present in servo/core-graphics
+#[allow(dead_code)]
+#[derive(Debug)]
+enum ScrollUnit {
+    Pixel = 0,
+    Line = 1,
+}
+// hack
+
+/// The main struct for handling the event emitting
+pub struct Enigo {
+    event_source: Option<CGEventSource>,
+    keycode_to_string_map: std::collections::HashMap<String, CGKeyCode>,
+    double_click_interval: u32,
+    last_click_time: Option<std::time::Instant>,
+    multiple_click: i64,
+    flags: CGEventFlags,
+}
+
+impl Enigo {
+    ///
+    pub fn reset_flag(&mut self) {
+        self.flags = CGEventFlags::CGEventFlagNull;
+    }
+
+    ///
+    pub fn add_flag(&mut self, key: &Key) {
+        let flag = match key {
+            &Key::CapsLock => CGEventFlags::CGEventFlagAlphaShift,
+            &Key::Shift => CGEventFlags::CGEventFlagShift,
+            &Key::Control => CGEventFlags::CGEventFlagControl,
+            &Key::Alt => CGEventFlags::CGEventFlagAlternate,
+            &Key::Meta => CGEventFlags::CGEventFlagCommand,
+            &Key::NumLock => CGEventFlags::CGEventFlagNumericPad,
+            _ => CGEventFlags::CGEventFlagNull,
+        };
+        self.flags |= flag;
+    }
+
+    fn post(&self, event: CGEvent) {
+        event.set_flags(self.flags);
+        event.post(CGEventTapLocation::HID);
+    }
+}
+
+impl Default for Enigo {
+    fn default() -> Self {
+        let mut double_click_interval = 500;
+        if let Some(ns_event) = Class::get("NSEvent") {
+            let tm: f64 = unsafe { msg_send![ns_event, doubleClickInterval] };
+            if tm > 0. {
+                double_click_interval = (tm * 1000.) as u32;
+                log::info!("double click interval: {}ms", double_click_interval);
+            }
+        }
+        Self {
+            // TODO(dustin): return error rather than panic here
+            event_source: if let Ok(src) =
+                CGEventSource::new(CGEventSourceStateID::CombinedSessionState)
+            {
+                Some(src)
+            } else {
+                None
+            },
+            keycode_to_string_map: Default::default(),
+            double_click_interval,
+            multiple_click: 1,
+            last_click_time: None,
+            flags: CGEventFlags::CGEventFlagNull,
+        }
+    }
+}
+
+impl MouseControllable for Enigo {
+    fn mouse_move_to(&mut self, x: i32, y: i32) {
+        let pressed = Self::pressed_buttons();
+
+        let event_type = if pressed & 1 > 0 {
+            CGEventType::LeftMouseDragged
+        } else if pressed & 2 > 0 {
+            CGEventType::RightMouseDragged
+        } else {
+            CGEventType::MouseMoved
+        };
+
+        let dest = CGPoint::new(x as f64, y as f64);
+        if let Some(src) = self.event_source.as_ref() {
+            if let Ok(event) =
+                CGEvent::new_mouse_event(src.clone(), event_type, dest, CGMouseButton::Left)
+            {
+                self.post(event);
+            }
+        }
+    }
+
+    fn mouse_move_relative(&mut self, x: i32, y: i32) {
+        let (display_width, display_height) = Self::main_display_size();
+        let (current_x, y_inv) = Self::mouse_location_raw_coords();
+        let current_y = (display_height as i32) - y_inv;
+        let new_x = current_x + x;
+        let new_y = current_y + y;
+
+        if new_x < 0
+            || new_x as usize > display_width
+            || new_y < 0
+            || new_y as usize > display_height
+        {
+            return;
+        }
+
+        self.mouse_move_to(new_x, new_y);
+    }
+
+    fn mouse_down(&mut self, button: MouseButton) -> crate::ResultType {
+        let now = std::time::Instant::now();
+        if let Some(t) = self.last_click_time {
+            if t.elapsed().as_millis() as u32 <= self.double_click_interval {
+                self.multiple_click += 1;
+            } else {
+                self.multiple_click = 1;
+            }
+        }
+        self.last_click_time = Some(now);
+        let (current_x, current_y) = Self::mouse_location();
+        let (button, event_type) = match button {
+            MouseButton::Left => (CGMouseButton::Left, CGEventType::LeftMouseDown),
+            MouseButton::Middle => (CGMouseButton::Center, CGEventType::OtherMouseDown),
+            MouseButton::Right => (CGMouseButton::Right, CGEventType::RightMouseDown),
+            _ => unimplemented!(),
+        };
+        let dest = CGPoint::new(current_x as f64, current_y as f64);
+        if let Some(src) = self.event_source.as_ref() {
+            if let Ok(event) = CGEvent::new_mouse_event(src.clone(), event_type, dest, button) {
+                if self.multiple_click > 1 {
+                    event.set_integer_value_field(
+                        EventField::MOUSE_EVENT_CLICK_STATE,
+                        self.multiple_click,
+                    );
+                }
+                self.post(event);
+            }
+        }
+        Ok(())
+    }
+
+    fn mouse_up(&mut self, button: MouseButton) {
+        let (current_x, current_y) = Self::mouse_location();
+        let (button, event_type) = match button {
+            MouseButton::Left => (CGMouseButton::Left, CGEventType::LeftMouseUp),
+            MouseButton::Middle => (CGMouseButton::Center, CGEventType::OtherMouseUp),
+            MouseButton::Right => (CGMouseButton::Right, CGEventType::RightMouseUp),
+            _ => unimplemented!(),
+        };
+        let dest = CGPoint::new(current_x as f64, current_y as f64);
+        if let Some(src) = self.event_source.as_ref() {
+            if let Ok(event) = CGEvent::new_mouse_event(src.clone(), event_type, dest, button) {
+                if self.multiple_click > 1 {
+                    event.set_integer_value_field(
+                        EventField::MOUSE_EVENT_CLICK_STATE,
+                        self.multiple_click,
+                    );
+                }
+                self.post(event);
+            }
+        }
+    }
+
+    fn mouse_click(&mut self, button: MouseButton) {
+        self.mouse_down(button).ok();
+        self.mouse_up(button);
+    }
+
+    fn mouse_scroll_x(&mut self, length: i32) {
+        let mut scroll_direction = -1; // 1 left -1 right;
+        let mut length = length;
+
+        if length < 0 {
+            length *= -1;
+            scroll_direction *= -1;
+        }
+
+        if let Some(src) = self.event_source.as_ref() {
+            for _ in 0..length {
+                unsafe {
+                    let mouse_ev = CGEventCreateScrollWheelEvent(
+                        &src,
+                        ScrollUnit::Line,
+                        2, // CGWheelCount 1 = y 2 = xy 3 = xyz
+                        0,
+                        scroll_direction,
+                    );
+
+                    CGEventPost(CGEventTapLocation::HID, mouse_ev);
+                    CFRelease(mouse_ev as *const std::ffi::c_void);
+                }
+            }
+        }
+    }
+
+    fn mouse_scroll_y(&mut self, length: i32) {
+        let mut scroll_direction = -1; // 1 left -1 right;
+        let mut length = length;
+
+        if length < 0 {
+            length *= -1;
+            scroll_direction *= -1;
+        }
+
+        if let Some(src) = self.event_source.as_ref() {
+            for _ in 0..length {
+                unsafe {
+                    let mouse_ev = CGEventCreateScrollWheelEvent(
+                        &src,
+                        ScrollUnit::Line,
+                        1, // CGWheelCount 1 = y 2 = xy 3 = xyz
+                        scroll_direction,
+                    );
+
+                    CGEventPost(CGEventTapLocation::HID, mouse_ev);
+                    CFRelease(mouse_ev as *const std::ffi::c_void);
+                }
+            }
+        }
+    }
+}
+
+// https://stackoverflow.
+// com/questions/1918841/how-to-convert-ascii-character-to-cgkeycode
+
+impl KeyboardControllable for Enigo {
+    fn key_sequence(&mut self, sequence: &str) {
+        // NOTE(dustin): This is a fix for issue https://github.com/enigo-rs/enigo/issues/68
+        // TODO(dustin): This could be improved by aggregating 20 bytes worth of graphemes at a time
+        // but i am unsure what would happen for grapheme clusters greater than 20 bytes ...
+        use unicode_segmentation::UnicodeSegmentation;
+        let clusters = UnicodeSegmentation::graphemes(sequence, true).collect::<Vec<&str>>();
+        for cluster in clusters {
+            if let Some(src) = self.event_source.as_ref() {
+                if let Ok(event) = CGEvent::new_keyboard_event(src.clone(), 0, true) {
+                    event.set_string(cluster);
+                    self.post(event);
+                }
+            }
+        }
+    }
+
+    fn key_click(&mut self, key: Key) {
+        let keycode = self.key_to_keycode(key);
+        if keycode == 0 {
+            return;
+        }
+
+        if let Some(src) = self.event_source.as_ref() {
+            if let Ok(event) = CGEvent::new_keyboard_event(src.clone(), keycode, true) {
+                self.post(event);
+            }
+
+            if let Ok(event) = CGEvent::new_keyboard_event(src.clone(), keycode, false) {
+                self.post(event);
+            }
+        }
+    }
+
+    fn key_down(&mut self, key: Key) -> crate::ResultType {
+        if let Some(src) = self.event_source.as_ref() {
+            if let Ok(event) =
+                CGEvent::new_keyboard_event(src.clone(), self.key_to_keycode(key), true)
+            {
+                self.post(event);
+            }
+        }
+        Ok(())
+    }
+
+    fn key_up(&mut self, key: Key) {
+        if let Some(src) = self.event_source.as_ref() {
+            if let Ok(event) =
+                CGEvent::new_keyboard_event(src.clone(), self.key_to_keycode(key), false)
+            {
+                self.post(event);
+            }
+        }
+    }
+
+    fn get_key_state(&mut self, key: Key) -> bool {
+        let keycode = self.key_to_keycode(key);
+        unsafe { CGEventSourceKeyState(1, keycode) }
+    }
+}
+
+impl Enigo {
+    fn pressed_buttons() -> usize {
+        if let Some(ns_event) = Class::get("NSEvent") {
+            unsafe { msg_send![ns_event, pressedMouseButtons] }
+        } else {
+            0
+        }
+    }
+
+    /// Fetches the `(width, height)` in pixels of the main display
+    pub fn main_display_size() -> (usize, usize) {
+        let display_id = unsafe { CGMainDisplayID() };
+        let width = unsafe { CGDisplayPixelsWide(display_id) };
+        let height = unsafe { CGDisplayPixelsHigh(display_id) };
+        (width, height)
+    }
+
+    /// Returns the current mouse location in Cocoa coordinates which have Y
+    /// inverted from the Carbon coordinates used in the rest of the API.
+    /// This function exists so that mouse_move_relative only has to fetch
+    /// the screen size once.
+    fn mouse_location_raw_coords() -> (i32, i32) {
+        if let Some(ns_event) = Class::get("NSEvent") {
+            let pt: NSPoint = unsafe { msg_send![ns_event, mouseLocation] };
+            (pt.x as i32, pt.y as i32)
+        } else {
+            (0, 0)
+        }
+    }
+
+    /// The mouse coordinates in points, only works on the main display
+    pub fn mouse_location() -> (i32, i32) {
+        let (x, y_inv) = Self::mouse_location_raw_coords();
+        let (_, display_height) = Self::main_display_size();
+        (x, (display_height as i32) - y_inv)
+    }
+
+    fn key_to_keycode(&mut self, key: Key) -> CGKeyCode {
+        #[allow(deprecated)]
+        // I mean duh, we still need to support deprecated keys until they're removed
+        match key {
+            Key::Alt => kVK_Option,
+            Key::Backspace => kVK_Delete,
+            Key::CapsLock => kVK_CapsLock,
+            Key::Control => kVK_Control,
+            Key::Delete => kVK_ForwardDelete,
+            Key::DownArrow => kVK_DownArrow,
+            Key::End => kVK_End,
+            Key::Escape => kVK_Escape,
+            Key::F1 => kVK_F1,
+            Key::F10 => kVK_F10,
+            Key::F11 => kVK_F11,
+            Key::F12 => kVK_F12,
+            Key::F2 => kVK_F2,
+            Key::F3 => kVK_F3,
+            Key::F4 => kVK_F4,
+            Key::F5 => kVK_F5,
+            Key::F6 => kVK_F6,
+            Key::F7 => kVK_F7,
+            Key::F8 => kVK_F8,
+            Key::F9 => kVK_F9,
+            Key::Home => kVK_Home,
+            Key::LeftArrow => kVK_LeftArrow,
+            Key::Option => kVK_Option,
+            Key::PageDown => kVK_PageDown,
+            Key::PageUp => kVK_PageUp,
+            Key::Return => kVK_Return,
+            Key::RightArrow => kVK_RightArrow,
+            Key::Shift => kVK_Shift,
+            Key::Space => kVK_Space,
+            Key::Tab => kVK_Tab,
+            Key::UpArrow => kVK_UpArrow,
+            Key::Numpad0 => kVK_ANSI_Keypad0,
+            Key::Numpad1 => kVK_ANSI_Keypad1,
+            Key::Numpad2 => kVK_ANSI_Keypad2,
+            Key::Numpad3 => kVK_ANSI_Keypad3,
+            Key::Numpad4 => kVK_ANSI_Keypad4,
+            Key::Numpad5 => kVK_ANSI_Keypad5,
+            Key::Numpad6 => kVK_ANSI_Keypad6,
+            Key::Numpad7 => kVK_ANSI_Keypad7,
+            Key::Numpad8 => kVK_ANSI_Keypad8,
+            Key::Numpad9 => kVK_ANSI_Keypad9,
+            Key::Mute => kVK_Mute,
+            Key::VolumeDown => kVK_VolumeUp,
+            Key::VolumeUp => kVK_VolumeDown,
+            Key::Help => kVK_Help,
+            Key::Snapshot => kVK_F13,
+            Key::Clear => kVK_ANSI_KeypadClear,
+            Key::Decimal => kVK_ANSI_KeypadDecimal,
+            Key::Multiply => kVK_ANSI_KeypadMultiply,
+            Key::Add => kVK_ANSI_KeypadPlus,
+            Key::Divide => kVK_ANSI_KeypadDivide,
+            Key::NumpadEnter => kVK_ANSI_KeypadEnter,
+            Key::Subtract => kVK_ANSI_KeypadMinus,
+            Key::Equals => kVK_ANSI_KeypadEquals,
+            Key::NumLock => kVK_ANSI_KeypadClear,
+
+            Key::Raw(raw_keycode) => raw_keycode,
+            Key::Layout(c) => self.get_layoutdependent_keycode(c.to_string()),
+
+            Key::Super | Key::Command | Key::Windows | Key::Meta => kVK_Command,
+            _ => 0,
+        }
+    }
+
+    fn get_layoutdependent_keycode(&mut self, string: String) -> CGKeyCode {
+        if self.keycode_to_string_map.is_empty() {
+            self.init_map();
+        }
+        *self.keycode_to_string_map.get(&string).unwrap_or(&0)
+    }
+
+    fn init_map(&mut self) {
+        self.keycode_to_string_map.insert("".to_owned(), 0);
+        // loop through every keycode (0 - 127)
+        for keycode in 0..128 {
+            // no modifier
+            if let Some(key_string) = self.keycode_to_string(keycode, 0x100) {
+                self.keycode_to_string_map.insert(key_string, keycode);
+            }
+
+            // shift modifier
+            if let Some(key_string) = self.keycode_to_string(keycode, 0x20102) {
+                self.keycode_to_string_map.insert(key_string, keycode);
+            }
+
+            // alt modifier
+            // if let Some(string) = self.keycode_to_string(keycode, 0x80120) {
+            //     println!("{:?}", string);
+            // }
+            // alt + shift modifier
+            // if let Some(string) = self.keycode_to_string(keycode, 0xa0122) {
+            //     println!("{:?}", string);
+            // }
+        }
+    }
+
+    fn keycode_to_string(&self, keycode: u16, modifier: u32) -> Option<String> {
+        let cf_string = self.create_string_for_key(keycode, modifier);
+        unsafe {
+            if !cf_string.is_null() {
+                let mut buf: [i8; 255] = [0; 255];
+                let success = CFStringGetCString(
+                    cf_string,
+                    buf.as_mut_ptr(),
+                    buf.len() as _,
+                    kCFStringEncodingUTF8,
+                );
+                if success != 0 {
+                    let name: &CStr = CStr::from_ptr(buf.as_ptr());
+                    if let Ok(name) = name.to_str() {
+                        return Some(name.to_owned());
+                    }
+                }
+            }
+        }
+
+        None
+    }
+
+    fn create_string_for_key(&self, keycode: u16, modifier: u32) -> CFStringRef {
+        let current_keyboard = unsafe { TISCopyCurrentKeyboardInputSource() };
+        let layout_data = unsafe {
+            TISGetInputSourceProperty(current_keyboard, kTISPropertyUnicodeKeyLayoutData)
+        };
+        let keyboard_layout = unsafe { CFDataGetBytePtr(layout_data) };
+
+        let mut keys_down: UInt32 = 0;
+        // let mut chars: *mut c_void;//[UniChar; 4];
+        let mut chars: u16 = 0;
+        let mut real_length: UniCharCount = 0;
+        unsafe {
+            UCKeyTranslate(
+                keyboard_layout,
+                keycode,
+                kUCKeyActionDisplay as u16,
+                modifier,
+                LMGetKbdType() as u32,
+                kUCKeyTranslateNoDeadKeysBit as u32,
+                &mut keys_down,
+                8, // sizeof(chars) / sizeof(chars[0]),
+                &mut real_length,
+                &mut chars,
+            );
+        }
+
+        unsafe { CFStringCreateWithCharacters(kCFAllocatorDefault, &chars, 1) }
+    }
+}
+
+unsafe impl Send for Enigo {}

libs/enigo/src/macos/mod.rs

@@ -0,0 +1,4 @@
+mod macos_impl;
+
+pub mod keycodes;
+pub use self::macos_impl::Enigo;

libs/enigo/src/win/keycodes.rs

@@ -0,0 +1,73 @@
+// https://msdn.microsoft.com/en-us/library/windows/desktop/dd375731
+
+pub const EVK_RETURN: u16 = 0x0D;
+pub const EVK_TAB: u16 = 0x09;
+pub const EVK_SPACE: u16 = 0x20;
+pub const EVK_BACK: u16 = 0x08;
+pub const EVK_ESCAPE: u16 = 0x1b;
+pub const EVK_LWIN: u16 = 0x5b;
+pub const EVK_SHIFT: u16 = 0x10;
+pub const EVK_CAPITAL: u16 = 0x14;
+pub const EVK_MENU: u16 = 0x12;
+pub const EVK_LCONTROL: u16 = 0xa2;
+pub const EVK_HOME: u16 = 0x24;
+pub const EVK_PRIOR: u16 = 0x21;
+pub const EVK_NEXT: u16 = 0x22;
+pub const EVK_END: u16 = 0x23;
+pub const EVK_LEFT: u16 = 0x25;
+pub const EVK_RIGHT: u16 = 0x27;
+pub const EVK_UP: u16 = 0x26;
+pub const EVK_DOWN: u16 = 0x28;
+pub const EVK_DELETE: u16 = 0x2E;
+pub const EVK_F1: u16 = 0x70;
+pub const EVK_F2: u16 = 0x71;
+pub const EVK_F3: u16 = 0x72;
+pub const EVK_F4: u16 = 0x73;
+pub const EVK_F5: u16 = 0x74;
+pub const EVK_F6: u16 = 0x75;
+pub const EVK_F7: u16 = 0x76;
+pub const EVK_F8: u16 = 0x77;
+pub const EVK_F9: u16 = 0x78;
+pub const EVK_F10: u16 = 0x79;
+pub const EVK_F11: u16 = 0x7a;
+pub const EVK_F12: u16 = 0x7b;
+pub const EVK_NUMPAD0: u16 = 0x60;
+pub const EVK_NUMPAD1: u16 = 0x61;
+pub const EVK_NUMPAD2: u16 = 0x62;
+pub const EVK_NUMPAD3: u16 = 0x63;
+pub const EVK_NUMPAD4: u16 = 0x64;
+pub const EVK_NUMPAD5: u16 = 0x65;
+pub const EVK_NUMPAD6: u16 = 0x66;
+pub const EVK_NUMPAD7: u16 = 0x67;
+pub const EVK_NUMPAD8: u16 = 0x68;
+pub const EVK_NUMPAD9: u16 = 0x69;
+pub const EVK_CANCEL: u16 = 0x03;
+pub const EVK_CLEAR: u16 = 0x0C;
+pub const EVK_PAUSE: u16 = 0x13;
+pub const EVK_KANA: u16 = 0x15;
+pub const EVK_HANGUL: u16 = 0x15;
+pub const EVK_JUNJA: u16 = 0x17;
+pub const EVK_FINAL: u16 = 0x18;
+pub const EVK_HANJA: u16 = 0x19;
+pub const EVK_KANJI: u16 = 0x19;
+pub const EVK_CONVERT: u16 = 0x1C;
+pub const EVK_SELECT: u16 = 0x29;
+pub const EVK_PRINT: u16 = 0x2A;
+pub const EVK_EXECUTE: u16 = 0x2B;
+pub const EVK_SNAPSHOT: u16 = 0x2C;
+pub const EVK_INSERT: u16 = 0x2D;
+pub const EVK_HELP: u16 = 0x2F;
+pub const EVK_SLEEP: u16 = 0x5F;
+pub const EVK_SEPARATOR: u16 = 0x6C;
+pub const EVK_VOLUME_MUTE: u16 = 0xAD;
+pub const EVK_VOLUME_DOWN: u16 = 0xAE;
+pub const EVK_VOLUME_UP: u16 = 0xAF;
+pub const EVK_NUMLOCK: u16 = 0x90;
+pub const EVK_SCROLL: u16 = 0x91;
+pub const EVK_RWIN: u16 = 0x5C;
+pub const EVK_APPS: u16 = 0x5D;
+pub const EVK_ADD: u16 = 0x6B;
+pub const EVK_MULTIPLY: u16 = 0x6A;
+pub const EVK_SUBTRACT: u16 = 0x6D;
+pub const EVK_DECIMAL: u16 = 0x6E;
+pub const EVK_DIVIDE: u16 = 0x6F;

libs/enigo/src/win/mod.rs

@@ -0,0 +1,4 @@
+mod win_impl;
+
+pub mod keycodes;
+pub use self::win_impl::Enigo;

libs/enigo/src/win/win_impl.rs

@@ -0,0 +1,366 @@
+use winapi;
+
+use self::winapi::ctypes::c_int;
+use self::winapi::shared::{minwindef::*, windef::*};
+use self::winapi::um::winbase::*;
+use self::winapi::um::winuser::*;
+
+use crate::win::keycodes::*;
+use crate::{Key, KeyboardControllable, MouseButton, MouseControllable};
+use std::mem::*;
+
+extern "system" {
+    pub fn GetLastError() -> DWORD;
+}
+
+/// The main struct for handling the event emitting
+#[derive(Default)]
+pub struct Enigo;
+
+fn mouse_event(flags: u32, data: u32, dx: i32, dy: i32) -> DWORD {
+    let mut input = INPUT {
+        type_: INPUT_MOUSE,
+        u: unsafe {
+            transmute(MOUSEINPUT {
+                dx,
+                dy,
+                mouseData: data,
+                dwFlags: flags,
+                time: 0,
+                dwExtraInfo: 0,
+            })
+        },
+    };
+    unsafe { SendInput(1, &mut input as LPINPUT, size_of::<INPUT>() as c_int) }
+}
+
+fn keybd_event(flags: u32, vk: u16, scan: u16) -> DWORD {
+    let mut input = INPUT {
+        type_: INPUT_KEYBOARD,
+        u: unsafe {
+            transmute_copy(&KEYBDINPUT {
+                wVk: vk,
+                wScan: scan,
+                dwFlags: flags,
+                time: 0,
+                dwExtraInfo: 0,
+            })
+        },
+    };
+    unsafe { SendInput(1, &mut input as LPINPUT, size_of::<INPUT>() as c_int) }
+}
+
+fn get_error() -> String {
+    unsafe {
+        let buff_size = 256;
+        let mut buff: Vec<u16> = Vec::with_capacity(buff_size);
+        buff.resize(buff_size, 0);
+        let errno = GetLastError();
+        let chars_copied = FormatMessageW(
+            FORMAT_MESSAGE_IGNORE_INSERTS
+                | FORMAT_MESSAGE_FROM_SYSTEM
+                | FORMAT_MESSAGE_ARGUMENT_ARRAY,
+            std::ptr::null(),
+            errno,
+            0,
+            buff.as_mut_ptr(),
+            (buff_size + 1) as u32,
+            std::ptr::null_mut(),
+        );
+        if chars_copied == 0 {
+            return "".to_owned();
+        }
+        let mut curr_char: usize = chars_copied as usize;
+        while curr_char > 0 {
+            let ch = buff[curr_char];
+
+            if ch >= ' ' as u16 {
+                break;
+            }
+            curr_char -= 1;
+        }
+        let sl = std::slice::from_raw_parts(buff.as_ptr(), curr_char);
+        let err_msg = String::from_utf16(sl);
+        return err_msg.unwrap_or("".to_owned());
+    }
+}
+
+impl MouseControllable for Enigo {
+    fn mouse_move_to(&mut self, x: i32, y: i32) {
+        mouse_event(
+            MOUSEEVENTF_MOVE | MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_VIRTUALDESK,
+            0,
+            (x - unsafe { GetSystemMetrics(SM_XVIRTUALSCREEN) }) * 65535
+                / unsafe { GetSystemMetrics(SM_CXVIRTUALSCREEN) },
+            (y - unsafe { GetSystemMetrics(SM_YVIRTUALSCREEN) }) * 65535
+                / unsafe { GetSystemMetrics(SM_CYVIRTUALSCREEN) },
+        );
+    }
+
+    fn mouse_move_relative(&mut self, x: i32, y: i32) {
+        mouse_event(MOUSEEVENTF_MOVE, 0, x, y);
+    }
+
+    fn mouse_down(&mut self, button: MouseButton) -> crate::ResultType {
+        let res = mouse_event(
+            match button {
+                MouseButton::Left => MOUSEEVENTF_LEFTDOWN,
+                MouseButton::Middle => MOUSEEVENTF_MIDDLEDOWN,
+                MouseButton::Right => MOUSEEVENTF_RIGHTDOWN,
+                _ => unimplemented!(),
+            },
+            0,
+            0,
+            0,
+        );
+        if res == 0 {
+            let err = get_error();
+            if !err.is_empty() {
+                return Err(err.into());
+            }
+        }
+        Ok(())
+    }
+
+    fn mouse_up(&mut self, button: MouseButton) {
+        mouse_event(
+            match button {
+                MouseButton::Left => MOUSEEVENTF_LEFTUP,
+                MouseButton::Middle => MOUSEEVENTF_MIDDLEUP,
+                MouseButton::Right => MOUSEEVENTF_RIGHTUP,
+                _ => unimplemented!(),
+            },
+            0,
+            0,
+            0,
+        );
+    }
+
+    fn mouse_click(&mut self, button: MouseButton) {
+        self.mouse_down(button).ok();
+        self.mouse_up(button);
+    }
+
+    fn mouse_scroll_x(&mut self, length: i32) {
+        mouse_event(MOUSEEVENTF_HWHEEL, unsafe { transmute(length * 120) }, 0, 0);
+    }
+
+    fn mouse_scroll_y(&mut self, length: i32) {
+        mouse_event(MOUSEEVENTF_WHEEL, unsafe { transmute(length * 120) }, 0, 0);
+    }
+}
+
+impl KeyboardControllable for Enigo {
+    fn key_sequence(&mut self, sequence: &str) {
+        let mut buffer = [0; 2];
+
+        for c in sequence.chars() {
+            // Windows uses uft-16 encoding. We need to check
+            // for variable length characters. As such some
+            // characters can be 32 bit long and those are
+            // encoded in such called hight and low surrogates
+            // each 16 bit wide that needs to be send after
+            // another to the SendInput function without
+            // being interrupted by "keyup"
+            let result = c.encode_utf16(&mut buffer);
+            if result.len() == 1 {
+                self.unicode_key_click(result[0]);
+            } else {
+                for utf16_surrogate in result {
+                    self.unicode_key_down(utf16_surrogate.clone());
+                }
+                // do i need to produce a keyup?
+                // self.unicode_key_up(0);
+            }
+        }
+    }
+
+    fn key_click(&mut self, key: Key) {
+        let scancode = self.key_to_scancode(key);
+        keybd_event(KEYEVENTF_SCANCODE, 0, scancode);
+        keybd_event(KEYEVENTF_KEYUP | KEYEVENTF_SCANCODE, 0, scancode);
+    }
+
+    fn key_down(&mut self, key: Key) -> crate::ResultType {
+        let res = keybd_event(KEYEVENTF_SCANCODE, 0, self.key_to_scancode(key));
+        if res == 0 {
+            let err = get_error();
+            if !err.is_empty() {
+                return Err(err.into());
+            }
+        }
+        Ok(())
+    }
+
+    fn key_up(&mut self, key: Key) {
+        keybd_event(
+            KEYEVENTF_KEYUP | KEYEVENTF_SCANCODE,
+            0,
+            self.key_to_scancode(key),
+        );
+    }
+
+    fn get_key_state(&mut self, key: Key) -> bool {
+        let keycode = self.key_to_keycode(key);
+        let x = unsafe { GetKeyState(keycode as _) };
+        if key == Key::CapsLock || key == Key::NumLock || key == Key::Scroll {
+            return (x & 0x1) == 0x1;
+        }
+        return (x as u16 & 0x8000) == 0x8000;
+    }
+}
+
+impl Enigo {
+    /// Gets the (width, height) of the main display in screen coordinates (pixels).
+    ///
+    /// # Example
+    ///
+    /// ```no_run
+    /// use enigo::*;
+    /// let mut size = Enigo::main_display_size();
+    /// ```
+    pub fn main_display_size() -> (usize, usize) {
+        let w = unsafe { GetSystemMetrics(SM_CXSCREEN) as usize };
+        let h = unsafe { GetSystemMetrics(SM_CYSCREEN) as usize };
+        (w, h)
+    }
+
+    /// Gets the location of mouse in screen coordinates (pixels).
+    ///
+    /// # Example
+    ///
+    /// ```no_run
+    /// use enigo::*;
+    /// let mut location = Enigo::mouse_location();
+    /// ```
+    pub fn mouse_location() -> (i32, i32) {
+        let mut point = POINT { x: 0, y: 0 };
+        let result = unsafe { GetCursorPos(&mut point) };
+        if result != 0 {
+            (point.x, point.y)
+        } else {
+            (0, 0)
+        }
+    }
+
+    fn unicode_key_click(&self, unicode_char: u16) {
+        self.unicode_key_down(unicode_char);
+        self.unicode_key_up(unicode_char);
+    }
+
+    fn unicode_key_down(&self, unicode_char: u16) {
+        keybd_event(KEYEVENTF_UNICODE, 0, unicode_char);
+    }
+
+    fn unicode_key_up(&self, unicode_char: u16) {
+        keybd_event(KEYEVENTF_UNICODE | KEYEVENTF_KEYUP, 0, unicode_char);
+    }
+
+    fn key_to_keycode(&self, key: Key) -> u16 {
+        // do not use the codes from crate winapi they're
+        // wrongly typed with i32 instead of i16 use the
+        // ones provided by win/keycodes.rs that are prefixed
+        // with an 'E' infront of the original name
+        #[allow(deprecated)]
+        // I mean duh, we still need to support deprecated keys until they're removed
+        match key {
+            Key::Alt => EVK_MENU,
+            Key::Backspace => EVK_BACK,
+            Key::CapsLock => EVK_CAPITAL,
+            Key::Control => EVK_LCONTROL,
+            Key::Delete => EVK_DELETE,
+            Key::DownArrow => EVK_DOWN,
+            Key::End => EVK_END,
+            Key::Escape => EVK_ESCAPE,
+            Key::F1 => EVK_F1,
+            Key::F10 => EVK_F10,
+            Key::F11 => EVK_F11,
+            Key::F12 => EVK_F12,
+            Key::F2 => EVK_F2,
+            Key::F3 => EVK_F3,
+            Key::F4 => EVK_F4,
+            Key::F5 => EVK_F5,
+            Key::F6 => EVK_F6,
+            Key::F7 => EVK_F7,
+            Key::F8 => EVK_F8,
+            Key::F9 => EVK_F9,
+            Key::Home => EVK_HOME,
+            Key::LeftArrow => EVK_LEFT,
+            Key::Option => EVK_MENU,
+            Key::PageDown => EVK_NEXT,
+            Key::PageUp => EVK_PRIOR,
+            Key::Return => EVK_RETURN,
+            Key::RightArrow => EVK_RIGHT,
+            Key::Shift => EVK_SHIFT,
+            Key::Space => EVK_SPACE,
+            Key::Tab => EVK_TAB,
+            Key::UpArrow => EVK_UP,
+            Key::Numpad0 => EVK_NUMPAD0,
+            Key::Numpad1 => EVK_NUMPAD1,
+            Key::Numpad2 => EVK_NUMPAD2,
+            Key::Numpad3 => EVK_NUMPAD3,
+            Key::Numpad4 => EVK_NUMPAD4,
+            Key::Numpad5 => EVK_NUMPAD5,
+            Key::Numpad6 => EVK_NUMPAD6,
+            Key::Numpad7 => EVK_NUMPAD7,
+            Key::Numpad8 => EVK_NUMPAD8,
+            Key::Numpad9 => EVK_NUMPAD9,
+            Key::Cancel => EVK_CANCEL,
+            Key::Clear => EVK_CLEAR,
+            Key::Menu => EVK_MENU,
+            Key::Pause => EVK_PAUSE,
+            Key::Kana => EVK_KANA,
+            Key::Hangul => EVK_HANGUL,
+            Key::Junja => EVK_JUNJA,
+            Key::Final => EVK_FINAL,
+            Key::Hanja => EVK_HANJA,
+            Key::Kanji => EVK_KANJI,
+            Key::Convert => EVK_CONVERT,
+            Key::Select => EVK_SELECT,
+            Key::Print => EVK_PRINT,
+            Key::Execute => EVK_EXECUTE,
+            Key::Snapshot => EVK_SNAPSHOT,
+            Key::Insert => EVK_INSERT,
+            Key::Help => EVK_HELP,
+            Key::Sleep => EVK_SLEEP,
+            Key::Separator => EVK_SEPARATOR,
+            Key::Mute => EVK_VOLUME_MUTE,
+            Key::VolumeDown => EVK_VOLUME_DOWN,
+            Key::VolumeUp => EVK_VOLUME_UP,
+            Key::Scroll => EVK_SCROLL,
+            Key::NumLock => EVK_NUMLOCK,
+            Key::RWin => EVK_RWIN,
+            Key::Apps => EVK_APPS,
+            Key::Add => EVK_ADD,
+            Key::Multiply => EVK_MULTIPLY,
+            Key::Decimal => EVK_DECIMAL,
+            Key::Subtract => EVK_SUBTRACT,
+            Key::Divide => EVK_DIVIDE,
+            Key::NumpadEnter => EVK_RETURN,
+            Key::Equals => '=' as _,
+
+            Key::Raw(raw_keycode) => raw_keycode,
+            Key::Layout(c) => self.get_layoutdependent_keycode(c.to_string()),
+            Key::Super | Key::Command | Key::Windows | Key::Meta => EVK_LWIN,
+        }
+    }
+
+    fn key_to_scancode(&self, key: Key) -> u16 {
+        let keycode = self.key_to_keycode(key);
+        unsafe { MapVirtualKeyW(keycode as u32, 0) as u16 }
+    }
+
+    fn get_layoutdependent_keycode(&self, string: String) -> u16 {
+        // get the first char from the string ignore the rest
+        // ensure its not a multybyte char
+        if let Some(chr) = string.chars().nth(0) {
+            // NOTE VkKeyScanW uses the current keyboard layout
+            // to specify a layout use VkKeyScanExW and GetKeyboardLayout
+            // or load one with LoadKeyboardLayoutW
+            let keycode_and_shiftstate = unsafe { VkKeyScanW(chr as _) };
+            keycode_and_shiftstate as _
+        } else {
+            0
+        }
+    }
+}

libs/hbb_common/.gitignore

@@ -0,0 +1,4 @@
+/target
+**/*.rs.bk
+Cargo.lock
+src/protos/

libs/hbb_common/Cargo.toml

@@ -0,0 +1,46 @@
+[package]
+name = "hbb_common"
+version = "0.1.0"
+authors = ["open-trade <info@opentradesolutions.com>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+protobuf = { version = "3.0.0-pre", git = "https://github.com/stepancheg/rust-protobuf" }
+tokio = { version = "0.2", features = ["full"] }
+tokio-util = { version = "0.3", features = ["full"] }
+futures = "0.3"
+bytes = "0.5"
+log = "0.4"
+env_logger = "0.8"
+socket2 = { version = "0.3", features = ["reuseport"] }
+zstd = "0.5"
+quinn = {version = "0.6", optional = true }
+anyhow = "1.0"
+futures-util = "0.3"
+directories-next = "2.0"
+rand = "0.7"
+serde_derive = "1.0"
+serde = "1.0"
+lazy_static = "1.4"
+confy = { git = "https://github.com/open-trade/confy" }
+dirs-next = "2.0"
+filetime = "0.2"
+sodiumoxide = "0.2"
+
+[target.'cfg(not(any(target_os = "android", target_os = "ios")))'.dependencies]
+mac_address = "1.1"
+
+[features]
+quic = ["quinn"]
+
+[build-dependencies]
+protobuf-codegen-pure = { version = "3.0.0-pre", git = "https://github.com/stepancheg/rust-protobuf" }
+
+[target.'cfg(target_os = "windows")'.dependencies]
+winapi = { version = "0.3", features = ["winuser"] }
+
+[dev-dependencies]
+toml = "0.5"
+serde_json = "1.0"

libs/hbb_common/build.rs

@@ -0,0 +1,9 @@
+fn main() {
+    std::fs::create_dir_all("src/protos").unwrap();
+    protobuf_codegen_pure::Codegen::new()
+        .out_dir("src/protos")
+        .inputs(&["protos/rendezvous.proto", "protos/message.proto"])
+        .include("protos")
+        .run()
+        .expect("Codegen failed.");
+}

libs/hbb_common/protos/message.proto

@@ -0,0 +1,401 @@
+syntax = "proto3";
+package hbb;
+
+message VP9 {
+  bytes data = 1;
+  bool key = 2;
+  int64 pts = 3;
+}
+
+message VP9s { repeated VP9 frames = 1; }
+
+message RGB { bool compress = 1; }
+
+// planes data send directly in binary for better use arraybuffer on web
+message YUV {
+  bool compress = 1;
+  int32 stride = 2;
+}
+
+message VideoFrame {
+  oneof union {
+    VP9s vp9s = 6;
+    RGB rgb = 7;
+    YUV yuv = 8;
+  }
+}
+
+message DisplayInfo {
+  sint32 x = 1;
+  sint32 y = 2;
+  int32 width = 3;
+  int32 height = 4;
+  string name = 5;
+  bool online = 6;
+}
+
+message PortForward {
+  string host = 1;
+  int32 port = 2;
+}
+
+message FileTransfer {
+  string dir = 1;
+  bool show_hidden = 2;
+}
+
+message LoginRequest {
+  string username = 1;
+  bytes password = 2;
+  string my_id = 4;
+  string my_name = 5;
+  OptionMessage option = 6;
+  oneof union {
+    FileTransfer file_transfer = 7;
+    PortForward port_forward = 8;
+  }
+}
+
+message ChatMessage { string text = 1; }
+
+message PeerInfo {
+  string username = 1;
+  string hostname = 2;
+  string platform = 3;
+  repeated DisplayInfo displays = 4;
+  int32 current_display = 5;
+  bool sas_enabled = 6;
+  string version = 7;
+}
+
+message LoginResponse {
+  oneof union {
+    string error = 1;
+    PeerInfo peer_info = 2;
+  }
+}
+
+message MouseEvent {
+  int32 mask = 1;
+  sint32 x = 2;
+  sint32 y = 3;
+  repeated ControlKey modifiers = 4;
+}
+
+enum ControlKey {
+  Alt = 1;
+  Backspace = 2;
+  CapsLock = 3;
+  Control = 4;
+  Delete = 5;
+  DownArrow = 6;
+  End = 7;
+  Escape = 8;
+  F1 = 9;
+  F10 = 10;
+  F11 = 11;
+  F12 = 12;
+  F2 = 13;
+  F3 = 14;
+  F4 = 15;
+  F5 = 16;
+  F6 = 17;
+  F7 = 18;
+  F8 = 19;
+  F9 = 20;
+  Home = 21;
+  LeftArrow = 22;
+  /// meta key (also known as "windows"; "super"; and "command")
+  Meta = 23;
+  /// option key on macOS (alt key on Linux and Windows)
+  Option = 24;
+  PageDown = 25;
+  PageUp = 26;
+  Return = 27;
+  RightArrow = 28;
+  Shift = 29;
+  Space = 30;
+  Tab = 31;
+  UpArrow = 32;
+  Numpad0 = 33;
+  Numpad1 = 34;
+  Numpad2 = 35;
+  Numpad3 = 36;
+  Numpad4 = 37;
+  Numpad5 = 38;
+  Numpad6 = 39;
+  Numpad7 = 40;
+  Numpad8 = 41;
+  Numpad9 = 42;
+  Cancel = 43;
+  Clear = 44;
+  Menu = 45;
+  Pause = 46;
+  Kana = 47;
+  Hangul = 48;
+  Junja = 49;
+  Final = 50;
+  Hanja = 51;
+  Kanji = 52;
+  Convert = 53;
+  Select = 54;
+  Print = 55;
+  Execute = 56;
+  Snapshot = 57;
+  Insert = 58;
+  Help = 59;
+  Sleep = 60;
+  Separator = 61;
+  Scroll = 62;
+  NumLock = 63;
+  RWin = 64;
+  Apps = 65;
+  Multiply = 66;
+  Add = 67;
+  Subtract = 68;
+  Decimal = 69;
+  Divide = 70;
+  Equals = 71;
+  NumpadEnter = 72;
+  CtrlAltDel = 100;
+  LockScreen = 101;
+}
+
+message KeyEvent {
+  bool down = 1;
+  bool press = 2;
+  oneof union {
+    ControlKey control_key = 3;
+    uint32 chr = 4;
+    uint32 unicode = 5;
+    string seq = 6;
+  }
+  repeated ControlKey modifiers = 8;
+}
+
+message CursorData {
+  uint64 id = 1;
+  sint32 hotx = 2;
+  sint32 hoty = 3;
+  int32 width = 4;
+  int32 height = 5;
+  bytes colors = 6;
+}
+
+message CursorPosition {
+  sint32 x = 1;
+  sint32 y = 2;
+}
+
+message Hash {
+  string salt = 1;
+  string challenge = 2;
+};
+
+message Clipboard {
+  bool compress = 1;
+  bytes content = 2;
+};
+
+enum FileType {
+  Dir = 1;
+  DirLink = 2;
+  DirDrive = 3;
+  File = 4;
+  FileLink = 5;
+}
+
+message FileEntry {
+  FileType entry_type = 1;
+  string name = 2;
+  bool is_hidden = 3;
+  uint64 size = 4;
+  uint64 modified_time = 5;
+}
+
+message FileDirectory {
+  int32 id = 1;
+  string path = 2;
+  repeated FileEntry entries = 3;
+}
+
+message ReadDir {
+  string path = 1;
+  bool include_hidden = 2;
+}
+
+message ReadAllFiles {
+  int32 id = 1;
+  string path = 2;
+  bool include_hidden = 3;
+}
+
+message FileAction {
+  oneof union {
+    ReadDir read_dir = 1;
+    FileTransferSendRequest send = 2;
+    FileTransferReceiveRequest receive = 3;
+    FileDirCreate create = 4;
+    FileRemoveDir remove_dir = 5;
+    FileRemoveFile remove_file = 6;
+    ReadAllFiles all_files = 7;
+    FileTransferCancel cancel = 8;
+  }
+}
+
+message FileTransferCancel { int32 id = 1; }
+
+message FileResponse {
+  oneof union {
+    FileDirectory dir = 1;
+    FileTransferBlock block = 2;
+    FileTransferError error = 3;
+    FileTransferDone done = 4;
+  }
+}
+
+message FileTransferBlock {
+  int32 id = 1;
+  sint32 file_num = 2;
+  bytes data = 3;
+  bool compressed = 4;
+}
+
+message FileTransferError {
+  int32 id = 1;
+  string error = 2;
+  sint32 file_num = 3;
+}
+
+message FileTransferSendRequest {
+  int32 id = 1;
+  string path = 2;
+  bool include_hidden = 3;
+}
+
+message FileTransferDone {
+  int32 id = 1;
+  sint32 file_num = 2;
+}
+
+message FileTransferReceiveRequest {
+  int32 id = 1;
+  string path = 2; // path written to
+  repeated FileEntry files = 3;
+}
+
+message FileRemoveDir {
+  int32 id = 1;
+  string path = 2;
+  bool recursive = 3;
+}
+
+message FileRemoveFile {
+  int32 id = 1;
+  string path = 2;
+  sint32 file_num = 3;
+}
+
+message FileDirCreate {
+  int32 id = 1;
+  string path = 2;
+}
+
+message SwitchDisplay {
+  int32 display = 1;
+  sint32 x = 2;
+  sint32 y = 3;
+  int32 width = 4;
+  int32 height = 5;
+}
+
+enum Permission {
+  Keyboard = 1;
+  Clipboard = 2;
+  Audio = 3;
+}
+
+message PermissionInfo {
+  Permission permission = 1;
+  bool enabled = 2;
+}
+
+enum ImageQuality {
+  NotSet = 0;
+  Low = 2;
+  Balanced = 3;
+  Best = 4;
+}
+
+enum BoolOption {
+  NotSet = 0;
+  No = 1;
+  Yes = 2;
+}
+
+message OptionMessage {
+  ImageQuality image_quality = 1;
+  BoolOption lock_after_session_end = 2;
+  BoolOption show_remote_cursor = 3;
+  BoolOption privacy_mode = 4;
+  BoolOption block_input = 5;
+  int32 custom_image_quality = 6;
+  BoolOption disable_audio = 7;
+  BoolOption disable_clipboard = 8;
+}
+
+message TestDelay {
+  int64 time = 1;
+  bool from_client = 2;
+}
+
+message PublicKey {
+  bytes asymmetric_value = 1;
+  bytes symmetric_value = 2;
+}
+
+message SignedId {
+  bytes id = 1;
+  bytes pk = 2;
+}
+
+message AudioFormat {
+  uint32 sample_rate = 1;
+  uint32 channels = 2;
+}
+
+message AudioFrame { bytes data = 1; }
+
+message Misc {
+  oneof union {
+    ChatMessage chat_message = 4;
+    SwitchDisplay switch_display = 5;
+    PermissionInfo permission_info = 6;
+    OptionMessage option = 7;
+    AudioFormat audio_format = 8;
+    string close_reason = 9;
+    bool refresh_video = 10;
+  }
+}
+
+message Message {
+  oneof union {
+    SignedId signed_id = 3;
+    PublicKey public_key = 4;
+    TestDelay test_delay = 5;
+    VideoFrame video_frame = 6;
+    LoginRequest login_request = 7;
+    LoginResponse login_response = 8;
+    Hash hash = 9;
+    MouseEvent mouse_event = 10;
+    AudioFrame audio_frame = 11;
+    CursorData cursor_data = 12;
+    CursorPosition cursor_position = 13;
+    uint64 cursor_id = 14;
+    KeyEvent key_event = 15;
+    Clipboard clipboard = 16;
+    FileAction file_action = 17;
+    FileResponse file_response = 18;
+    Misc misc = 19;
+  }
+}

libs/hbb_common/protos/rendezvous.proto

@@ -0,0 +1,133 @@
+syntax = "proto3";
+package hbb;
+
+message RegisterPeer {
+  string id = 1;
+  int32 serial = 2;
+}
+
+message RegisterPeerResponse { bool request_pk = 2; }
+
+message PunchHoleRequest { 
+  string id = 1; 
+  NatType nat_type = 2;
+}
+
+message PunchHole { 
+  bytes socket_addr = 1;
+  string relay_server = 2;
+  NatType nat_type = 3;
+}
+
+message TestNatRequest {
+  int32 serial = 1;
+}
+
+// per my test, uint/int has no difference in encoding, int not good for negative, use sint for negative
+message TestNatResponse {
+  int32 port = 1; 
+  ConfigUpdate cu = 2; // for mobile
+}
+
+enum NatType {
+  UNKNOWN_NAT = 0;
+  ASYMMETRIC = 1;
+  SYMMETRIC = 2;
+}
+
+message PunchHoleSent {
+  bytes socket_addr = 1;
+  string id = 2;
+  string relay_server = 3;
+  NatType nat_type = 4;
+}
+
+message RegisterPk {
+  string id = 1;
+  bytes uuid = 2;
+  bytes pk = 3;
+}
+
+message RegisterPkResponse {
+  enum Result {
+    OK = 1;
+    UUID_MISMATCH = 2;
+  }
+  Result result = 1;
+}
+
+message PunchHoleResponse {
+  bytes socket_addr = 1;
+  bytes pk = 2;
+  enum Failure {
+    ID_NOT_EXIST = 1;
+    OFFLINE = 2;
+  }
+  Failure failure = 3;
+  string relay_server = 4;
+  oneof union {
+    NatType nat_type = 5;
+    bool is_local = 6;
+  }
+}
+
+message ConfigUpdate {
+  int32 serial = 1;
+  repeated string rendezvous_servers = 2;
+}
+
+message RequestRelay {
+  string id = 1;
+  string uuid = 2;
+  bytes socket_addr = 3;
+  string relay_server = 4;
+  bool secure = 5;
+}
+
+message RelayResponse {
+  bytes socket_addr = 1;
+  string uuid = 2;
+  string relay_server = 3;
+  oneof union {
+    string id = 4;
+    bytes pk = 5;
+  }
+}
+
+message SoftwareUpdate { string url = 1; }
+
+// if in same intranet, punch hole won't work both for udp and tcp,
+// even some router has below connection error if we connect itself,
+//  { kind: Other, error: "could not resolve to any address" },
+// so we request local address to connect.
+message FetchLocalAddr { 
+  bytes socket_addr = 1; 
+  string relay_server = 2;
+}
+
+message LocalAddr {
+  bytes socket_addr = 1;
+  bytes local_addr = 2;
+  string relay_server = 3;
+}
+
+message RendezvousMessage {
+  oneof union {
+    RegisterPeer register_peer = 6;
+    RegisterPeerResponse register_peer_response = 7;
+    PunchHoleRequest punch_hole_request = 8;
+    PunchHole punch_hole = 9;
+    PunchHoleSent punch_hole_sent = 10;
+    PunchHoleResponse punch_hole_response = 11;
+    FetchLocalAddr fetch_local_addr = 12;
+    LocalAddr local_addr = 13;
+    ConfigUpdate configure_update = 14;
+    RegisterPk register_pk = 15;
+    RegisterPkResponse register_pk_response = 16;
+    SoftwareUpdate software_update = 17;
+    RequestRelay request_relay = 18;
+    RelayResponse relay_response = 19;
+    TestNatRequest test_nat_request = 20;
+    TestNatResponse test_nat_response = 21;
+  }
+}

libs/hbb_common/src/bytes_codec.rs

@@ -0,0 +1,274 @@
+use bytes::{Buf, BufMut, Bytes, BytesMut};
+use std::io;
+use tokio_util::codec::{Decoder, Encoder};
+
+#[derive(Debug, Clone, Copy)]
+pub struct BytesCodec {
+    state: DecodeState,
+    raw: bool,
+    max_packet_length: usize,
+}
+
+#[derive(Debug, Clone, Copy)]
+enum DecodeState {
+    Head,
+    Data(usize),
+}
+
+impl BytesCodec {
+    pub fn new() -> Self {
+        Self {
+            state: DecodeState::Head,
+            raw: false,
+            max_packet_length: usize::MAX,
+        }
+    }
+
+    pub fn set_raw(&mut self) {
+        self.raw = true;
+    }
+
+    pub fn set_max_packet_length(&mut self, n: usize) {
+        self.max_packet_length = n;
+    }
+
+    fn decode_head(&mut self, src: &mut BytesMut) -> io::Result<Option<usize>> {
+        if src.is_empty() {
+            return Ok(None);
+        }
+        let head_len = ((src[0] & 0x3) + 1) as usize;
+        if src.len() < head_len {
+            return Ok(None);
+        }
+        let mut n = src[0] as usize;
+        if head_len > 1 {
+            n |= (src[1] as usize) << 8;
+        }
+        if head_len > 2 {
+            n |= (src[2] as usize) << 16;
+        }
+        if head_len > 3 {
+            n |= (src[3] as usize) << 24;
+        }
+        n >>= 2;
+        if n > self.max_packet_length {
+            return Err(io::Error::new(io::ErrorKind::InvalidData, "Too big packet"));
+        }
+        src.advance(head_len);
+        src.reserve(n);
+        return Ok(Some(n));
+    }
+
+    fn decode_data(&self, n: usize, src: &mut BytesMut) -> io::Result<Option<BytesMut>> {
+        if src.len() < n {
+            return Ok(None);
+        }
+        Ok(Some(src.split_to(n)))
+    }
+}
+
+impl Decoder for BytesCodec {
+    type Item = BytesMut;
+    type Error = io::Error;
+
+    fn decode(&mut self, src: &mut BytesMut) -> Result<Option<BytesMut>, io::Error> {
+        if self.raw {
+            if !src.is_empty() {
+                let len = src.len();
+                return Ok(Some(src.split_to(len)));
+            } else {
+                return Ok(None);
+            }
+        }
+        let n = match self.state {
+            DecodeState::Head => match self.decode_head(src)? {
+                Some(n) => {
+                    self.state = DecodeState::Data(n);
+                    n
+                }
+                None => return Ok(None),
+            },
+            DecodeState::Data(n) => n,
+        };
+
+        match self.decode_data(n, src)? {
+            Some(data) => {
+                self.state = DecodeState::Head;
+                Ok(Some(data))
+            }
+            None => Ok(None),
+        }
+    }
+}
+
+impl Encoder<Bytes> for BytesCodec {
+    type Error = io::Error;
+
+    fn encode(&mut self, data: Bytes, buf: &mut BytesMut) -> Result<(), io::Error> {
+        if self.raw {
+            buf.reserve(data.len());
+            buf.put(data);
+            return Ok(());
+        }
+        if data.len() <= 0x3F {
+            buf.put_u8((data.len() << 2) as u8);
+        } else if data.len() <= 0x3FFF {
+            buf.put_u16_le((data.len() << 2) as u16 | 0x1);
+        } else if data.len() <= 0x3FFFFF {
+            let h = (data.len() << 2) as u32 | 0x2;
+            buf.put_u16_le((h & 0xFFFF) as u16);
+            buf.put_u8((h >> 16) as u8);
+        } else if data.len() <= 0x3FFFFFFF {
+            buf.put_u32_le((data.len() << 2) as u32 | 0x3);
+        } else {
+            return Err(io::Error::new(io::ErrorKind::InvalidInput, "Overflow"));
+        }
+        buf.extend(data);
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn test_codec1() {
+        let mut codec = BytesCodec::new();
+        let mut buf = BytesMut::new();
+        let mut bytes: Vec<u8> = Vec::new();
+        bytes.resize(0x3F, 1);
+        assert!(!codec.encode(bytes.into(), &mut buf).is_err());
+        let buf_saved = buf.clone();
+        assert_eq!(buf.len(), 0x3F + 1);
+        if let Ok(Some(res)) = codec.decode(&mut buf) {
+            assert_eq!(res.len(), 0x3F);
+            assert_eq!(res[0], 1);
+        } else {
+            assert!(false);
+        }
+        let mut codec2 = BytesCodec::new();
+        let mut buf2 = BytesMut::new();
+        if let Ok(None) = codec2.decode(&mut buf2) {
+        } else {
+            assert!(false);
+        }
+        buf2.extend(&buf_saved[0..1]);
+        if let Ok(None) = codec2.decode(&mut buf2) {
+        } else {
+            assert!(false);
+        }
+        buf2.extend(&buf_saved[1..]);
+        if let Ok(Some(res)) = codec2.decode(&mut buf2) {
+            assert_eq!(res.len(), 0x3F);
+            assert_eq!(res[0], 1);
+        } else {
+            assert!(false);
+        }
+    }
+
+    #[test]
+    fn test_codec2() {
+        let mut codec = BytesCodec::new();
+        let mut buf = BytesMut::new();
+        let mut bytes: Vec<u8> = Vec::new();
+        assert!(!codec.encode("".into(), &mut buf).is_err());
+        assert_eq!(buf.len(), 1);
+        bytes.resize(0x3F + 1, 2);
+        assert!(!codec.encode(bytes.into(), &mut buf).is_err());
+        assert_eq!(buf.len(), 0x3F + 2 + 2);
+        if let Ok(Some(res)) = codec.decode(&mut buf) {
+            assert_eq!(res.len(), 0);
+        } else {
+            assert!(false);
+        }
+        if let Ok(Some(res)) = codec.decode(&mut buf) {
+            assert_eq!(res.len(), 0x3F + 1);
+            assert_eq!(res[0], 2);
+        } else {
+            assert!(false);
+        }
+    }
+
+    #[test]
+    fn test_codec3() {
+        let mut codec = BytesCodec::new();
+        let mut buf = BytesMut::new();
+        let mut bytes: Vec<u8> = Vec::new();
+        bytes.resize(0x3F - 1, 3);
+        assert!(!codec.encode(bytes.into(), &mut buf).is_err());
+        assert_eq!(buf.len(), 0x3F + 1 - 1);
+        if let Ok(Some(res)) = codec.decode(&mut buf) {
+            assert_eq!(res.len(), 0x3F - 1);
+            assert_eq!(res[0], 3);
+        } else {
+            assert!(false);
+        }
+    }
+    #[test]
+    fn test_codec4() {
+        let mut codec = BytesCodec::new();
+        let mut buf = BytesMut::new();
+        let mut bytes: Vec<u8> = Vec::new();
+        bytes.resize(0x3FFF, 4);
+        assert!(!codec.encode(bytes.into(), &mut buf).is_err());
+        assert_eq!(buf.len(), 0x3FFF + 2);
+        if let Ok(Some(res)) = codec.decode(&mut buf) {
+            assert_eq!(res.len(), 0x3FFF);
+            assert_eq!(res[0], 4);
+        } else {
+            assert!(false);
+        }
+    }
+
+    #[test]
+    fn test_codec5() {
+        let mut codec = BytesCodec::new();
+        let mut buf = BytesMut::new();
+        let mut bytes: Vec<u8> = Vec::new();
+        bytes.resize(0x3FFFFF, 5);
+        assert!(!codec.encode(bytes.into(), &mut buf).is_err());
+        assert_eq!(buf.len(), 0x3FFFFF + 3);
+        if let Ok(Some(res)) = codec.decode(&mut buf) {
+            assert_eq!(res.len(), 0x3FFFFF);
+            assert_eq!(res[0], 5);
+        } else {
+            assert!(false);
+        }
+    }
+
+    #[test]
+    fn test_codec6() {
+        let mut codec = BytesCodec::new();
+        let mut buf = BytesMut::new();
+        let mut bytes: Vec<u8> = Vec::new();
+        bytes.resize(0x3FFFFF + 1, 6);
+        assert!(!codec.encode(bytes.into(), &mut buf).is_err());
+        let buf_saved = buf.clone();
+        assert_eq!(buf.len(), 0x3FFFFF + 4 + 1);
+        if let Ok(Some(res)) = codec.decode(&mut buf) {
+            assert_eq!(res.len(), 0x3FFFFF + 1);
+            assert_eq!(res[0], 6);
+        } else {
+            assert!(false);
+        }
+        let mut codec2 = BytesCodec::new();
+        let mut buf2 = BytesMut::new();
+        buf2.extend(&buf_saved[0..1]);
+        if let Ok(None) = codec2.decode(&mut buf2) {
+        } else {
+            assert!(false);
+        }
+        buf2.extend(&buf_saved[1..6]);
+        if let Ok(None) = codec2.decode(&mut buf2) {
+        } else {
+            assert!(false);
+        }
+        buf2.extend(&buf_saved[6..]);
+        if let Ok(Some(res)) = codec2.decode(&mut buf2) {
+            assert_eq!(res.len(), 0x3FFFFF + 1);
+            assert_eq!(res[0], 6);
+        } else {
+            assert!(false);
+        }
+    }
+}

libs/hbb_common/src/compress.rs

@@ -0,0 +1,50 @@
+use std::cell::RefCell;
+use zstd::block::{Compressor, Decompressor};
+
+thread_local! {
+    static COMPRESSOR: RefCell<Compressor> = RefCell::new(Compressor::new());
+    static DECOMPRESSOR: RefCell<Decompressor> = RefCell::new(Decompressor::new());
+}
+
+/// The library supports regular compression levels from 1 up to ZSTD_maxCLevel(),
+/// which is currently 22. Levels >= 20
+/// Default level is ZSTD_CLEVEL_DEFAULT==3.
+/// value 0 means default, which is controlled by ZSTD_CLEVEL_DEFAULT
+pub fn compress(data: &[u8], level: i32) -> Vec<u8> {
+    let mut out = Vec::new();
+    COMPRESSOR.with(|c| {
+        if let Ok(mut c) = c.try_borrow_mut() {
+            match c.compress(data, level) {
+                Ok(res) => out = res,
+                Err(err) => {
+                    crate::log::debug!("Failed to compress: {}", err);
+                }
+            }
+        }
+    });
+    out
+}
+
+pub fn decompress(data: &[u8]) -> Vec<u8> {
+    let mut out = Vec::new();
+    DECOMPRESSOR.with(|d| {
+        if let Ok(mut d) = d.try_borrow_mut() {
+            const MAX: usize = 1024 * 1024 * 64;
+            const MIN: usize = 1024 * 1024;
+            let mut n = 30 * data.len();
+            if n > MAX {
+                n = MAX;
+            }
+            if n < MIN {
+                n = MIN;
+            }
+            match d.decompress(data, n) {
+                Ok(res) => out = res,
+                Err(err) => {
+                    crate::log::debug!("Failed to decompress: {}", err);
+                }
+            }
+        }
+    });
+    out
+}

libs/hbb_common/src/config.rs

@@ -0,0 +1,688 @@
+use crate::log;
+use directories_next::ProjectDirs;
+use rand::Rng;
+use serde_derive::{Deserialize, Serialize};
+use sodiumoxide::crypto::sign;
+use std::{
+    collections::HashMap,
+    fs,
+    net::SocketAddr,
+    path::{Path, PathBuf},
+    sync::{Arc, Mutex, RwLock},
+    time::SystemTime,
+};
+
+pub const APP_NAME: &str = "RustDesk";
+pub const BIND_INTERFACE: &str = "0.0.0.0";
+pub const RENDEZVOUS_TIMEOUT: u64 = 12_000;
+pub const CONNECT_TIMEOUT: u64 = 18_000;
+pub const COMPRESS_LEVEL: i32 = 3;
+const SERIAL: i32 = 0;
+// 128x128
+#[cfg(target_os = "macos")] // 128x128 on 160x160 canvas, then shrink to 128, mac looks better with padding
+pub const ICON: &str = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAAyVBMVEUAAAAAcf8Acf8Acf8Acv8Acf8Acf8Acf8Acf8AcP8Acf8Ab/8AcP8Acf////8AaP/z+f/o8v/k7v/5/v/T5f8AYP/u9v/X6f+hx/+Kuv95pP8Aef/B1/+TwP9xoP8BdP/g6P+Irv9ZmP8Bgf/E3f98q/9sn/+01f+Es/9nm/9Jif8hhv8off/M4P+syP+avP86iP/c7f+xy/9yqf9Om/9hk/9Rjv+60P99tv9fpf88lv8yjf8Tgf8deP+kvP8BiP8NeP8hkP80gP8oj2VLAAAADXRSTlMA7o7qLvnaxZ1FOxYPjH9HWgAABHJJREFUeNrtm+tW4jAQgBfwuu7MtIUWsOUiCCioIIgLiqvr+z/UHq/LJKVkmwTcc/r9E2nzlU4mSTP9lpGRkZGR8VX5cZjfL+yCEXYL+/nDH//U/Pd8DgyTy39Xbv7oIAcWyB0cqbW/sweW2NtRaj8H1sgpGOwUIAH7Bkd7YJW9dXFwAJY5WNP/cmCZQnJvzIN18on5LwfWySXlxEPYAIcad8D6PdiHDbCfIFCADVBIENiFDbCbIACKPPXrZ+cP8E6/0znvP4EymgIEravIRcTxu8HxNSJ60a8W0AYECKrlAN+YwAthCd9wm1Ug6wKzIn5SgRduXfwkqDasCjx0XFzi9PV6zwNcIuhcWBOg+ikySq8C9UD4dEKWBCoOcspvAuLHTo9sCDQiFPHotRM48j8G5gVur1FdAN2uaYEuiz7xFsgEJ2RUoMUakXuBTHHoGxQYOBhHjeUBAefEnMAowFhaLBOKuOemBBbxLRQrH2PBCgMvNCPQGMeevTb9zLrPxz2Mo+QbEaijzPUcOOHMQZkKGRAIPem39+bypREMPTkQW/oCfk866zAkiIFG4yIKRE/aAnfiSd0WrORY6pFdXQEqi9mvAQm0RIOSnoCcZ8vJoz3diCnjRk+g8VP4/fuQDJ2Lxr6WwG0gXs9aTpDzW0vgDBlVUpixR8gYk44AD8FrUKHr8JQJGgIDnoDqoALxmWPQSi9AVVzm8gKUuEPGr/QCvptwJkbSYT/TC4S8C96DGjTj86aHtAI0x2WaBIq0eSYYpRa4EsdWVVwWu9O0Aj6f6dyBMnwEraeOgSYu0wZlauzA47QCbT7DgAQSE+hZWoEBF/BBmWOewNMK3BsSqKUW4MGcWqCSVmDkbvkXGKQOwg6PAUO9oL3xXhA20yaiCjuwYygRVQlUOTWTCf2SuNJTxeFjgaHByGuAIvd8ItdPLTDhS7IuqEE1YSKVOgbayLhSFQhMzYh8hwfBs1r7c505YVIQYEdNoKwxK06MJiyrpUFHiF0NAfCQUVHoiRclIXJIR6C2fqG37pBHvcWpgwzvAtYwkR5UGV2e42UISdBJETl3mg8ouo54Rcnti1/vaT+iuUQBt500Cgo4U10BeHSkk57FB0JjWkKRMWgLUA0lLodtImAQdaMiiri3+gIAPZQoutHNsgKF1aaDMhMyIdBf8Th+Bh8MTjGWCpl5Wv43tDmnF+IUVMrcZgRoiAxhtrloYizNkZaAnF5leglbNhj0wYCAbCDvGb0mP4nib7O7ZlcYQ2m1gPtIZgVgGNNMeaVAaWR+57TrqgtUnm3sHQ+kYeE6fufUubG1ez50FXbPnWgBlgSABmN3TTcsRl2yWkHRrwbiunvk/W2+Mg1hPZplPDeXRbZzStFH15s1QIVd3UImP5z/bHpeeQLvRJ7XLFUffQIlCvqlXETQbgN9/rlYABGosv+Vi9m2Xs639YLGrZd0br+odetlvdsvbN56abfd4vbCzv9Q3v/ygoOV21A4OPpfXvH4Ai+5ZGRkZGRkbJA/t/I0QMzoMiEAAAAASUVORK5CYII=
+";
+#[cfg(windows)] // windows, 32x32, bigger very ugly after shrink
+pub const ICON: &str = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAolBMVEUAAAAAcf8Acf8Acf8AcP8Acf8Acf8Acf8AcP8Acf/////9/v/7/f+gyv9wr/8Ld/8GdP/A3P+nzv+Qwf9mqv8lhv8UfP+Kvv88k/8zjv/x+P/Y6f/U5//J4f/F3/+x1P+pz/+izP+Cuv9Zov9Qnv9FmP8gg//f7f+42P96tv9fpv8ui//1+f/q8//o8v/Q5f+ax/+Zxv+VxP+Fu/9rrf8rif+x1o3FAAAACXRSTlMAv/RPTPKHioRsIqhAAAABNklEQVQ4y4WT6XaCQAyFB7S2GUD2RaxSKGDV7sv7v1on4djEluL9Ncn5biaZk1FKzSwbRmVbM2V0DRNaGD9Maq6sacBS9jRwpUTw1Ww7SEOvkwQDaeVofQeJ1nrXjgD3pTaqCDCg/xs4OBrlwUGTHvxzoHAx69Y9+Hk5oGdAsCNXSoHfEN1JYEme4KcfvO9WAmtMBNx6jIaCgSPGLbAyvKRhAEcrAxAKTSZiACu+gNSbyWwZeKdQKj91yRXWIOWZTMgATun6EtjgczNQaKMEWD0+xJ6B4AnvECVqdKwYoJ50hIPyw25AANkzpsLB00cYOIUEoHU0uVaQVcMxBwlgVZJ3Orz+3ahH6gP2tBgfYzsZmdo1fGIzRx5Irn2WxKaHeJnKtb/4cS5/PbWACd0oo/n/39/4vwGFYSxtSYV4OAAAAABJRU5ErkJggg==
+";
+#[cfg(target_os = "linux")] // 128x128 no padding
+pub const ICON: &str = "data:image/png;base64,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
+";
+#[cfg(target_os = "macos")]
+pub const ORG: &str = "com.carriez";
+
+type Size = (i32, i32, i32, i32);
+
+lazy_static::lazy_static! {
+    static ref CONFIG: Arc<RwLock<Config>> = Arc::new(RwLock::new(Config::load()));
+    static ref CONFIG2: Arc<RwLock<Config2>> = Arc::new(RwLock::new(Config2::load()));
+    pub static ref ONLINE: Arc<Mutex<HashMap<String, i64>>> = Default::default();
+}
+#[cfg(any(target_os = "android", target_os = "ios"))]
+lazy_static::lazy_static! {
+    pub static ref APP_DIR: Arc<RwLock<String>> = Default::default();
+}
+const CHARS: &'static [char] = &[
+    '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k',
+    'm', 'n', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
+];
+
+pub const RENDEZVOUS_SERVERS: &'static [&'static str] = &[
+    "rs-sg.rustdesk.com",
+    "rs-cn.rustdesk.com",
+];
+pub const RENDEZVOUS_PORT: i32 = 21116;
+pub const RELAY_PORT: i32 = 21117;
+
+#[derive(Debug, Default, Serialize, Deserialize, Clone)]
+pub struct Config {
+    #[serde(default)]
+    id: String,
+    #[serde(default)]
+    password: String,
+    #[serde(default)]
+    salt: String,
+    #[serde(default)]
+    key_pair: (Vec<u8>, Vec<u8>), // sk, pk
+    #[serde(default)]
+    key_confirmed: bool,
+    #[serde(default)]
+    keys_confirmed: HashMap<String, bool>,
+}
+
+// more variable configs
+#[derive(Debug, Default, Serialize, Deserialize, Clone)]
+pub struct Config2 {
+    #[serde(default)]
+    remote_id: String, // latest used one
+    #[serde(default)]
+    size: Size,
+    #[serde(default)]
+    rendezvous_server: String,
+    #[serde(default)]
+    nat_type: i32,
+    #[serde(default)]
+    serial: i32,
+
+    // the other scalar value must before this
+    #[serde(default)]
+    pub options: HashMap<String, String>,
+}
+
+#[derive(Debug, Default, Serialize, Deserialize, Clone)]
+pub struct PeerConfig {
+    #[serde(default)]
+    pub password: Vec<u8>,
+    #[serde(default)]
+    pub size: Size,
+    #[serde(default)]
+    pub size_ft: Size,
+    #[serde(default)]
+    pub size_pf: Size,
+    #[serde(default)]
+    pub view_style: String, // original (default), scale
+    #[serde(default)]
+    pub image_quality: String,
+    #[serde(default)]
+    pub custom_image_quality: Vec<i32>,
+    #[serde(default)]
+    pub show_remote_cursor: bool,
+    #[serde(default)]
+    pub lock_after_session_end: bool,
+    #[serde(default)]
+    pub privacy_mode: bool,
+    #[serde(default)]
+    pub port_forwards: Vec<(i32, String, i32)>,
+    #[serde(default)]
+    pub direct_failures: i32,
+    #[serde(default)]
+    pub disable_audio: bool,
+    #[serde(default)]
+    pub disable_clipboard: bool,
+
+    // the other scalar value must before this
+    #[serde(default)]
+    pub options: HashMap<String, String>,
+    #[serde(default)]
+    pub info: PeerInfoSerde,
+}
+
+#[derive(Debug, PartialEq, Default, Serialize, Deserialize, Clone)]
+pub struct PeerInfoSerde {
+    #[serde(default)]
+    pub username: String,
+    #[serde(default)]
+    pub hostname: String,
+    #[serde(default)]
+    pub platform: String,
+}
+
+fn patch(path: PathBuf) -> PathBuf {
+    if let Some(_tmp) = path.to_str() {
+        #[cfg(windows)]
+        return _tmp
+            .replace(
+                "system32\\config\\systemprofile",
+                "ServiceProfiles\\LocalService",
+            )
+            .into();
+        #[cfg(target_os = "macos")]
+        return _tmp.replace("Application Support", "Preferences").into();
+    }
+    path
+}
+
+impl Config2 {
+    fn load() -> Config2 {
+        Config::load_::<Config2>("2")
+    }
+
+    fn store(&self) {
+        Config::store_(self, "2");
+    }
+}
+
+impl Config {
+    fn load_<T: serde::Serialize + serde::de::DeserializeOwned + Default + std::fmt::Debug>(
+        suffix: &str,
+    ) -> T {
+        let file = Self::file_(suffix);
+        log::debug!("Configuration path: {}", file.display());
+        let cfg = match confy::load_path(&file) {
+            Ok(config) => config,
+            Err(err) => {
+                log::error!("Failed to load config: {}", err);
+                T::default()
+            }
+        };
+        if suffix.is_empty() {
+            log::debug!("{:?}", cfg);
+        }
+        cfg
+    }
+
+    fn store_<T: serde::Serialize>(config: &T, suffix: &str) {
+        let file = Self::file_(suffix);
+        if let Err(err) = confy::store_path(file, config) {
+            log::error!("Failed to store config: {}", err);
+        }
+    }
+
+    fn load() -> Config {
+        Config::load_::<Config>("")
+    }
+
+    fn store(&self) {
+        Config::store_(self, "");
+    }
+
+    pub fn file() -> PathBuf {
+        Self::file_("")
+    }
+
+    pub fn import(from: &str) {
+        log::info!("import {}", from);
+        // load first to create path
+        Self::load();
+        crate::allow_err!(std::fs::copy(from, Self::file()));
+        crate::allow_err!(std::fs::copy(
+            from.replace(".toml", "2.toml"),
+            Self::file_("2")
+        ));
+    }
+
+    pub fn save_tmp() -> String {
+        let _lock = CONFIG.read().unwrap(); // do not use let _, which will be dropped immediately
+        let path = Self::file_("2").to_str().unwrap_or("").to_owned();
+        let path2 = format!("{}_tmp", path);
+        crate::allow_err!(std::fs::copy(&path, &path2));
+        let path = Self::file().to_str().unwrap_or("").to_owned();
+        let path2 = format!("{}_tmp", path);
+        crate::allow_err!(std::fs::copy(&path, &path2));
+        path2
+    }
+
+    fn file_(suffix: &str) -> PathBuf {
+        let name = format!("{}{}", APP_NAME, suffix);
+        Self::path(name).with_extension("toml")
+    }
+
+    pub fn get_home() -> PathBuf {
+        #[cfg(any(target_os = "android", target_os = "ios"))]
+        return Self::path("");
+        if let Some(path) = dirs_next::home_dir() {
+            patch(path)
+        } else if let Ok(path) = std::env::current_dir() {
+            path
+        } else {
+            std::env::temp_dir()
+        }
+    }
+
+    fn path<P: AsRef<Path>>(p: P) -> PathBuf {
+        #[cfg(any(target_os = "android", target_os = "ios"))]
+        {
+            let mut path: PathBuf = APP_DIR.read().unwrap().clone().into();
+            path.push(p);
+            return path;
+        }
+        #[cfg(not(target_os = "macos"))]
+        let org = "";
+        #[cfg(target_os = "macos")]
+        let org = ORG;
+        // /var/root for root
+        if let Some(project) = ProjectDirs::from("", org, APP_NAME) {
+            let mut path = patch(project.config_dir().to_path_buf());
+            path.push(p);
+            return path;
+        }
+        return "".into();
+    }
+
+    pub fn log_path() -> PathBuf {
+        #[cfg(target_os = "macos")]
+        {
+            if let Some(path) = dirs_next::home_dir().as_mut() {
+                path.push(format!("Library/Logs/{}", APP_NAME));
+                return path.clone();
+            }
+        }
+        #[cfg(target_os = "linux")]
+        {
+            if let Some(path) = dirs_next::home_dir().as_mut() {
+                path.push(format!(".local/share/logs/{}", APP_NAME));
+                std::fs::create_dir_all(&path).ok();
+                return path.clone();
+            }
+        }
+        if let Some(path) = Self::path("").parent() {
+            let mut path: PathBuf = path.into();
+            path.push("log");
+            return path;
+        }
+        "".into()
+    }
+
+    pub fn ipc_path(postfix: &str) -> String {
+        #[cfg(windows)]
+        {
+            // \\ServerName\pipe\PipeName
+            // where ServerName is either the name of a remote computer or a period, to specify the local computer.
+            // https://docs.microsoft.com/en-us/windows/win32/ipc/pipe-names
+            format!("\\\\.\\pipe\\{}\\query{}", APP_NAME, postfix)
+        }
+        #[cfg(not(windows))]
+        {
+            use std::os::unix::fs::PermissionsExt;
+            let mut path: PathBuf = format!("/tmp/{}", APP_NAME).into();
+            fs::create_dir(&path).ok();
+            fs::set_permissions(&path, fs::Permissions::from_mode(0o0777)).ok();
+            path.push(format!("ipc{}", postfix));
+            path.to_str().unwrap_or("").to_owned()
+        }
+    }
+
+    pub fn icon_path() -> PathBuf {
+        let mut path = Self::path("icons");
+        if fs::create_dir_all(&path).is_err() {
+            path = std::env::temp_dir();
+        }
+        path
+    }
+
+    #[inline]
+    pub fn get_any_listen_addr() -> SocketAddr {
+        format!("{}:0", BIND_INTERFACE).parse().unwrap()
+    }
+
+    pub fn get_rendezvous_server() -> SocketAddr {
+        let mut rendezvous_server = Self::get_option("custom-rendezvous-server");
+        if rendezvous_server.is_empty() {
+            rendezvous_server = CONFIG2.write().unwrap().rendezvous_server.clone();
+        }
+        if rendezvous_server.is_empty() {
+            rendezvous_server = Self::get_rendezvous_servers()
+                .drain(..)
+                .next()
+                .unwrap_or("".to_owned());
+        }
+        if !rendezvous_server.contains(":") {
+            rendezvous_server = format!("{}:{}", rendezvous_server, RENDEZVOUS_PORT);
+        }
+        if let Ok(addr) = crate::to_socket_addr(&rendezvous_server) {
+            addr
+        } else {
+            Self::get_any_listen_addr()
+        }
+    }
+
+    pub fn get_rendezvous_servers() -> Vec<String> {
+        let s = Self::get_option("custom-rendezvous-server");
+        if !s.is_empty() {
+            return vec![s];
+        }
+        let serial_obsolute = CONFIG2.read().unwrap().serial > SERIAL;
+        if serial_obsolute {
+            let ss: Vec<String> = Self::get_option("rendezvous-servers")
+                .split(",")
+                .filter(|x| x.contains("."))
+                .map(|x| x.to_owned())
+                .collect();
+            if !ss.is_empty() {
+                return ss;
+            }
+        }
+        return RENDEZVOUS_SERVERS.iter().map(|x| x.to_string()).collect();
+    }
+
+    pub fn reset_online() {
+        *ONLINE.lock().unwrap() = Default::default();
+    }
+
+    pub fn update_latency(host: &str, latency: i64) {
+        ONLINE.lock().unwrap().insert(host.to_owned(), latency);
+        let mut host = "".to_owned();
+        let mut delay = i64::MAX;
+        for (tmp_host, tmp_delay) in ONLINE.lock().unwrap().iter() {
+            if tmp_delay > &0 && tmp_delay < &delay {
+                delay = tmp_delay.clone();
+                host = tmp_host.to_string();
+            }
+        }
+        if !host.is_empty() {
+            let mut config = CONFIG2.write().unwrap();
+            if host != config.rendezvous_server {
+                log::debug!("Update rendezvous_server in config to {}", host);
+                log::debug!("{:?}", *ONLINE.lock().unwrap());
+                config.rendezvous_server = host;
+                config.store();
+            }
+        }
+    }
+
+    pub fn set_id(id: &str) {
+        let mut config = CONFIG.write().unwrap();
+        if id == config.id {
+            return;
+        }
+        config.id = id.into();
+        config.store();
+    }
+
+    pub fn set_nat_type(nat_type: i32) {
+        let mut config = CONFIG2.write().unwrap();
+        if nat_type == config.nat_type {
+            return;
+        }
+        config.nat_type = nat_type;
+        config.store();
+    }
+
+    pub fn get_nat_type() -> i32 {
+        CONFIG2.read().unwrap().nat_type
+    }
+
+    pub fn set_serial(serial: i32) {
+        let mut config = CONFIG2.write().unwrap();
+        if serial == config.serial {
+            return;
+        }
+        config.serial = serial;
+        config.store();
+    }
+
+    pub fn get_serial() -> i32 {
+        std::cmp::max(CONFIG2.read().unwrap().serial, SERIAL)
+    }
+
+    fn get_auto_id() -> Option<String> {
+        #[cfg(any(target_os = "android", target_os = "ios"))]
+        return None;
+        let mut id = 0u32;
+        #[cfg(not(any(target_os = "android", target_os = "ios")))]
+        if let Ok(Some(ma)) = mac_address::get_mac_address() {
+            for x in &ma.bytes()[2..] {
+                id = (id << 8) | (*x as u32);
+            }
+            id = id & 0x1FFFFFFF;
+            Some(id.to_string())
+        } else {
+            None
+        }
+    }
+
+    pub fn get_auto_password() -> String {
+        let mut rng = rand::thread_rng();
+        (0..6)
+            .map(|_| CHARS[rng.gen::<usize>() % CHARS.len()])
+            .collect()
+    }
+
+    pub fn get_key_confirmed() -> bool {
+        CONFIG.read().unwrap().key_confirmed
+    }
+
+    pub fn set_key_confirmed(v: bool) {
+        let mut config = CONFIG.write().unwrap();
+        if config.key_confirmed == v {
+            return;
+        }
+        config.key_confirmed = v;
+        if !v {
+            config.keys_confirmed = Default::default();
+        }
+        config.store();
+    }
+
+    pub fn get_host_key_confirmed(host: &str) -> bool {
+        if let Some(true) = CONFIG.read().unwrap().keys_confirmed.get(host) {
+            true
+        } else {
+            false
+        }
+    }
+
+    pub fn set_host_key_confirmed(host: &str, v: bool) {
+        if Self::get_host_key_confirmed(host) == v {
+            return;
+        }
+        let mut config = CONFIG.write().unwrap();
+        config.keys_confirmed.insert(host.to_owned(), v);
+        config.store();
+    }
+
+    pub fn set_key_pair(pair: (Vec<u8>, Vec<u8>)) {
+        let mut config = CONFIG.write().unwrap();
+        config.key_pair = pair;
+        config.store();
+    }
+
+    pub fn get_key_pair() -> (Vec<u8>, Vec<u8>) {
+        // lock here to make sure no gen_keypair more than once
+        let mut config = CONFIG.write().unwrap();
+        if config.key_pair.0.is_empty() {
+            let (pk, sk) = sign::gen_keypair();
+            config.key_pair = (sk.0.to_vec(), pk.0.into());
+            config.store();
+        }
+        config.key_pair.clone()
+    }
+
+    pub fn get_id() -> String {
+        let mut id = CONFIG.read().unwrap().id.clone();
+        if id.is_empty() {
+            if let Some(tmp) = Config::get_auto_id() {
+                id = tmp;
+                Config::set_id(&id);
+            }
+        }
+        id
+    }
+
+    pub fn get_options() -> HashMap<String, String> {
+        CONFIG2.read().unwrap().options.clone()
+    }
+
+    pub fn set_options(v: HashMap<String, String>) {
+        let mut config = CONFIG2.write().unwrap();
+        config.options = v;
+        config.store();
+    }
+
+    pub fn get_option(k: &str) -> String {
+        if let Some(v) = CONFIG2.read().unwrap().options.get(k) {
+            v.clone()
+        } else {
+            "".to_owned()
+        }
+    }
+
+    pub fn set_option(k: String, v: String) {
+        let mut config = CONFIG2.write().unwrap();
+        if k == "custom-rendezvous-server" {
+            config.rendezvous_server = "".to_owned();
+        }
+        let v2 = if v.is_empty() { None } else { Some(&v) };
+        if v2 != config.options.get(&k) {
+            if v2.is_none() {
+                config.options.remove(&k);
+            } else {
+                config.options.insert(k, v);
+            }
+            config.store();
+        }
+    }
+
+    pub fn update_id() {
+        // to-do: how about if one ip register a lot of ids?
+        let id = Self::get_id();
+        let mut rng = rand::thread_rng();
+        let new_id = rng.gen_range(1_000_000_000, 2_000_000_000).to_string();
+        Config::set_id(&new_id);
+        log::info!("id updated from {} to {}", id, new_id);
+    }
+
+    pub fn set_password(password: &str) {
+        let mut config = CONFIG.write().unwrap();
+        if password == config.password {
+            return;
+        }
+        config.password = password.into();
+        config.store();
+    }
+
+    pub fn get_password() -> String {
+        let mut password = CONFIG.read().unwrap().password.clone();
+        if password.is_empty() {
+            password = Config::get_auto_password();
+            Config::set_password(&password);
+        }
+        password
+    }
+
+    pub fn set_salt(salt: &str) {
+        let mut config = CONFIG.write().unwrap();
+        if salt == config.salt {
+            return;
+        }
+        config.salt = salt.into();
+        config.store();
+    }
+
+    pub fn get_salt() -> String {
+        let mut salt = CONFIG.read().unwrap().salt.clone();
+        if salt.is_empty() {
+            salt = Config::get_auto_password();
+            Config::set_salt(&salt);
+        }
+        salt
+    }
+
+    pub fn get_size() -> Size {
+        CONFIG2.read().unwrap().size
+    }
+
+    pub fn set_size(x: i32, y: i32, w: i32, h: i32) {
+        let mut config = CONFIG2.write().unwrap();
+        let size = (x, y, w, h);
+        if size == config.size || size.2 < 300 || size.3 < 300 {
+            return;
+        }
+        config.size = size;
+        config.store();
+    }
+
+    pub fn set_remote_id(remote_id: &str) {
+        let mut config = CONFIG2.write().unwrap();
+        if remote_id == config.remote_id {
+            return;
+        }
+        config.remote_id = remote_id.into();
+        config.store();
+    }
+
+    pub fn get_remote_id() -> String {
+        CONFIG2.read().unwrap().remote_id.clone()
+    }
+}
+
+const PEERS: &str = "peers";
+
+impl PeerConfig {
+    pub fn load(id: &str) -> PeerConfig {
+        let _ = CONFIG.read().unwrap(); // for lock
+        match confy::load_path(&Self::path(id)) {
+            Ok(config) => config,
+            Err(err) => {
+                log::error!("Failed to load config: {}", err);
+                Default::default()
+            }
+        }
+    }
+
+    pub fn store(&self, id: &str) {
+        let _ = CONFIG.read().unwrap(); // for lock
+        if let Err(err) = confy::store_path(Self::path(id), self) {
+            log::error!("Failed to store config: {}", err);
+        }
+    }
+
+    pub fn remove(id: &str) {
+        fs::remove_file(&Self::path(id)).ok();
+    }
+
+    fn path(id: &str) -> PathBuf {
+        let path: PathBuf = [PEERS, id].iter().collect();
+        Config::path(path).with_extension("toml")
+    }
+
+    pub fn peers() -> Vec<(String, SystemTime, PeerInfoSerde)> {
+        if let Ok(peers) = Config::path(PEERS).read_dir() {
+            if let Ok(peers) = peers
+                .map(|res| res.map(|e| e.path()))
+                .collect::<Result<Vec<_>, _>>()
+            {
+                let mut peers: Vec<_> = peers
+                    .iter()
+                    .filter(|p| {
+                        p.is_file()
+                            && p.extension().map(|p| p.to_str().unwrap_or("")) == Some("toml")
+                    })
+                    .map(|p| {
+                        let t = fs::metadata(p)
+                            .map(|m| m.modified().unwrap_or(SystemTime::UNIX_EPOCH))
+                            .unwrap_or(SystemTime::UNIX_EPOCH);
+                        let id = p
+                            .file_stem()
+                            .map(|p| p.to_str().unwrap_or(""))
+                            .unwrap_or("")
+                            .to_owned();
+                        let info = PeerConfig::load(&id).info;
+                        if info.platform.is_empty() {
+                            fs::remove_file(&p).ok();
+                        }
+                        (id, t, info)
+                    })
+                    .filter(|p| !p.2.platform.is_empty())
+                    .collect();
+                peers.sort_unstable_by(|a, b| b.1.cmp(&a.1));
+                return peers;
+            }
+        }
+        Default::default()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn test_serialize() {
+        let cfg: Config = Default::default();
+        let res = toml::to_string_pretty(&cfg);
+        assert!(res.is_ok());
+        let cfg: PeerConfig = Default::default();
+        let res = toml::to_string_pretty(&cfg);
+        assert!(res.is_ok());
+    }
+}

libs/hbb_common/src/fs.rs

@@ -0,0 +1,554 @@
+use crate::{bail, message_proto::*, ResultType};
+use std::path::{Path, PathBuf};
+// https://doc.rust-lang.org/std/os/windows/fs/trait.MetadataExt.html
+use crate::{
+    compress::{compress, decompress},
+    config::{Config, COMPRESS_LEVEL},
+};
+#[cfg(windows)]
+use std::os::windows::prelude::*;
+use tokio::{fs::File, prelude::*};
+
+pub fn read_dir(path: &PathBuf, include_hidden: bool) -> ResultType<FileDirectory> {
+    let mut dir = FileDirectory {
+        path: get_string(&path),
+        ..Default::default()
+    };
+    #[cfg(windows)]
+    if "/" == &get_string(&path) {
+        let drives = unsafe { winapi::um::fileapi::GetLogicalDrives() };
+        for i in 0..32 {
+            if drives & (1 << i) != 0 {
+                let name = format!(
+                    "{}:",
+                    std::char::from_u32('A' as u32 + i as u32).unwrap_or('A')
+                );
+                dir.entries.push(FileEntry {
+                    name,
+                    entry_type: FileType::DirDrive.into(),
+                    ..Default::default()
+                });
+            }
+        }
+        return Ok(dir);
+    }
+    for entry in path.read_dir()? {
+        if let Ok(entry) = entry {
+            let p = entry.path();
+            let name = p
+                .file_name()
+                .map(|p| p.to_str().unwrap_or(""))
+                .unwrap_or("")
+                .to_owned();
+            if name.is_empty() {
+                continue;
+            }
+            let mut is_hidden = false;
+            let meta;
+            if let Ok(tmp) = std::fs::symlink_metadata(&p) {
+                meta = tmp;
+            } else {
+                continue;
+            }
+            // docs.microsoft.com/en-us/windows/win32/fileio/file-attribute-constants
+            #[cfg(windows)]
+            if meta.file_attributes() & 0x2 != 0 {
+                is_hidden = true;
+            }
+            #[cfg(not(windows))]
+            if name.find('.').unwrap_or(usize::MAX) == 0 {
+                is_hidden = true;
+            }
+            if is_hidden && !include_hidden {
+                continue;
+            }
+            let (entry_type, size) = {
+                if p.is_dir() {
+                    if meta.file_type().is_symlink() {
+                        (FileType::DirLink.into(), 0)
+                    } else {
+                        (FileType::Dir.into(), 0)
+                    }
+                } else {
+                    if meta.file_type().is_symlink() {
+                        (FileType::FileLink.into(), 0)
+                    } else {
+                        (FileType::File.into(), meta.len())
+                    }
+                }
+            };
+            let modified_time = meta
+                .modified()
+                .map(|x| {
+                    x.duration_since(std::time::SystemTime::UNIX_EPOCH)
+                        .map(|x| x.as_secs())
+                        .unwrap_or(0)
+                })
+                .unwrap_or(0) as u64;
+            dir.entries.push(FileEntry {
+                name: get_file_name(&p),
+                entry_type,
+                is_hidden,
+                size,
+                modified_time,
+                ..Default::default()
+            });
+        }
+    }
+    Ok(dir)
+}
+
+#[inline]
+pub fn get_file_name(p: &PathBuf) -> String {
+    p.file_name()
+        .map(|p| p.to_str().unwrap_or(""))
+        .unwrap_or("")
+        .to_owned()
+}
+
+#[inline]
+pub fn get_string(path: &PathBuf) -> String {
+    path.to_str().unwrap_or("").to_owned()
+}
+
+#[inline]
+pub fn get_path(path: &str) -> PathBuf {
+    Path::new(path).to_path_buf()
+}
+
+#[inline]
+pub fn get_home_as_string() -> String {
+    get_string(&Config::get_home())
+}
+
+fn read_dir_recursive(
+    path: &PathBuf,
+    prefix: &PathBuf,
+    include_hidden: bool,
+) -> ResultType<Vec<FileEntry>> {
+    let mut files = Vec::new();
+    if path.is_dir() {
+        // to-do: symbol link handling, cp the link rather than the content
+        // to-do: file mode, for unix
+        let fd = read_dir(&path, include_hidden)?;
+        for entry in fd.entries.iter() {
+            match entry.entry_type.enum_value() {
+                Ok(FileType::File) => {
+                    let mut entry = entry.clone();
+                    entry.name = get_string(&prefix.join(entry.name));
+                    files.push(entry);
+                }
+                Ok(FileType::Dir) => {
+                    if let Ok(mut tmp) = read_dir_recursive(
+                        &path.join(&entry.name),
+                        &prefix.join(&entry.name),
+                        include_hidden,
+                    ) {
+                        for entry in tmp.drain(0..) {
+                            files.push(entry);
+                        }
+                    }
+                }
+                _ => {}
+            }
+        }
+        Ok(files)
+    } else if path.is_file() {
+        let (size, modified_time) = if let Ok(meta) = std::fs::metadata(&path) {
+            (
+                meta.len(),
+                meta.modified()
+                    .map(|x| {
+                        x.duration_since(std::time::SystemTime::UNIX_EPOCH)
+                            .map(|x| x.as_secs())
+                            .unwrap_or(0)
+                    })
+                    .unwrap_or(0) as u64,
+            )
+        } else {
+            (0, 0)
+        };
+        files.push(FileEntry {
+            entry_type: FileType::File.into(),
+            size,
+            modified_time,
+            ..Default::default()
+        });
+        Ok(files)
+    } else {
+        bail!("Not exists");
+    }
+}
+
+pub fn get_recursive_files(path: &str, include_hidden: bool) -> ResultType<Vec<FileEntry>> {
+    read_dir_recursive(&get_path(path), &get_path(""), include_hidden)
+}
+
+#[derive(Default)]
+pub struct TransferJob {
+    id: i32,
+    path: PathBuf,
+    files: Vec<FileEntry>,
+    file_num: i32,
+    file: Option<File>,
+    total_size: u64,
+    finished_size: u64,
+    transfered: u64,
+}
+
+#[inline]
+fn get_ext(name: &str) -> &str {
+    if let Some(i) = name.rfind(".") {
+        return &name[i + 1..];
+    }
+    ""
+}
+
+#[inline]
+fn is_compressed_file(name: &str) -> bool {
+    let ext = get_ext(name);
+    ext == "xz"
+        || ext == "gz"
+        || ext == "zip"
+        || ext == "7z"
+        || ext == "rar"
+        || ext == "bz2"
+        || ext == "tgz"
+        || ext == "png"
+        || ext == "jpg"
+}
+
+impl TransferJob {
+    pub fn new_write(id: i32, path: String, files: Vec<FileEntry>) -> Self {
+        let total_size = files.iter().map(|x| x.size as u64).sum();
+        Self {
+            id,
+            path: get_path(&path),
+            files,
+            total_size,
+            ..Default::default()
+        }
+    }
+
+    pub fn new_read(id: i32, path: String, include_hidden: bool) -> ResultType<Self> {
+        let files = get_recursive_files(&path, include_hidden)?;
+        let total_size = files.iter().map(|x| x.size as u64).sum();
+        Ok(Self {
+            id,
+            path: get_path(&path),
+            files,
+            total_size,
+            ..Default::default()
+        })
+    }
+
+    #[inline]
+    pub fn files(&self) -> &Vec<FileEntry> {
+        &self.files
+    }
+
+    #[inline]
+    pub fn set_files(&mut self, files: Vec<FileEntry>) {
+        self.files = files;
+    }
+
+    #[inline]
+    pub fn id(&self) -> i32 {
+        self.id
+    }
+
+    #[inline]
+    pub fn total_size(&self) -> u64 {
+        self.total_size
+    }
+
+    #[inline]
+    pub fn finished_size(&self) -> u64 {
+        self.finished_size
+    }
+
+    #[inline]
+    pub fn transfered(&self) -> u64 {
+        self.transfered
+    }
+
+    #[inline]
+    pub fn file_num(&self) -> i32 {
+        self.file_num
+    }
+
+    pub fn modify_time(&self) {
+        let file_num = self.file_num as usize;
+        if file_num < self.files.len() {
+            let entry = &self.files[file_num];
+            let path = self.join(&entry.name);
+            let download_path = format!("{}.download", get_string(&path));
+            std::fs::rename(&download_path, &path).ok();
+            filetime::set_file_mtime(
+                &path,
+                filetime::FileTime::from_unix_time(entry.modified_time as _, 0),
+            )
+            .ok();
+        }
+    }
+
+    pub fn remove_download_file(&self) {
+        let file_num = self.file_num as usize;
+        if file_num < self.files.len() {
+            let entry = &self.files[file_num];
+            let path = self.join(&entry.name);
+            let download_path = format!("{}.download", get_string(&path));
+            std::fs::remove_file(&download_path).ok();
+        }
+    }
+
+    pub async fn write(&mut self, block: FileTransferBlock) -> ResultType<()> {
+        if block.id != self.id {
+            bail!("Wrong id");
+        }
+        let file_num = block.file_num as usize;
+        if file_num >= self.files.len() {
+            bail!("Wrong file number");
+        }
+        if file_num != self.file_num as usize || self.file.is_none() {
+            self.modify_time();
+            if let Some(file) = self.file.as_mut() {
+                file.sync_all().await?;
+            }
+            self.file_num = block.file_num;
+            let entry = &self.files[file_num];
+            let path = self.join(&entry.name);
+            if let Some(p) = path.parent() {
+                std::fs::create_dir_all(p).ok();
+            }
+            let path = format!("{}.download", get_string(&path));
+            self.file = Some(File::create(&path).await?);
+        }
+        if block.compressed {
+            let tmp = decompress(&block.data);
+            self.file.as_mut().unwrap().write_all(&tmp).await?;
+            self.finished_size += tmp.len() as u64;
+        } else {
+            self.file.as_mut().unwrap().write_all(&block.data).await?;
+            self.finished_size += block.data.len() as u64;
+        }
+        self.transfered += block.data.len() as u64;
+        Ok(())
+    }
+
+    #[inline]
+    fn join(&self, name: &str) -> PathBuf {
+        if name.is_empty() {
+            self.path.clone()
+        } else {
+            self.path.join(name)
+        }
+    }
+
+    pub async fn read(&mut self) -> ResultType<Option<FileTransferBlock>> {
+        let file_num = self.file_num as usize;
+        if file_num >= self.files.len() {
+            self.file.take();
+            return Ok(None);
+        }
+        let name = &self.files[file_num].name;
+        if self.file.is_none() {
+            match File::open(self.join(&name)).await {
+                Ok(file) => {
+                    self.file = Some(file);
+                }
+                Err(err) => {
+                    self.file_num += 1;
+                    return Err(err.into());
+                }
+            }
+        }
+        const BUF_SIZE: usize = 128 * 1024;
+        let mut buf: Vec<u8> = Vec::with_capacity(BUF_SIZE);
+        unsafe {
+            buf.set_len(BUF_SIZE);
+        }
+        let mut compressed = false;
+        let mut offset: usize = 0;
+        loop {
+            match self.file.as_mut().unwrap().read(&mut buf[offset..]).await {
+                Err(err) => {
+                    self.file_num += 1;
+                    self.file = None;
+                    return Err(err.into());
+                }
+                Ok(n) => {
+                    offset += n;
+                    if n == 0 || offset == BUF_SIZE {
+                        break;
+                    }
+                }
+            }
+        }
+        unsafe { buf.set_len(offset) };
+        if offset == 0 {
+            self.file_num += 1;
+            self.file = None;
+        } else {
+            self.finished_size += offset as u64;
+            if !is_compressed_file(name) {
+                let tmp = compress(&buf, COMPRESS_LEVEL);
+                if tmp.len() < buf.len() {
+                    buf = tmp;
+                    compressed = true;
+                }
+            }
+            self.transfered += buf.len() as u64;
+        }
+        Ok(Some(FileTransferBlock {
+            id: self.id,
+            file_num: file_num as _,
+            data: buf.into(),
+            compressed,
+            ..Default::default()
+        }))
+    }
+}
+
+#[inline]
+pub fn new_error<T: std::string::ToString>(id: i32, err: T, file_num: i32) -> Message {
+    let mut resp = FileResponse::new();
+    resp.set_error(FileTransferError {
+        id,
+        error: err.to_string(),
+        file_num,
+        ..Default::default()
+    });
+    let mut msg_out = Message::new();
+    msg_out.set_file_response(resp);
+    msg_out
+}
+
+#[inline]
+pub fn new_dir(id: i32, files: Vec<FileEntry>) -> Message {
+    let mut resp = FileResponse::new();
+    resp.set_dir(FileDirectory {
+        id,
+        entries: files.into(),
+        ..Default::default()
+    });
+    let mut msg_out = Message::new();
+    msg_out.set_file_response(resp);
+    msg_out
+}
+
+#[inline]
+pub fn new_block(block: FileTransferBlock) -> Message {
+    let mut resp = FileResponse::new();
+    resp.set_block(block);
+    let mut msg_out = Message::new();
+    msg_out.set_file_response(resp);
+    msg_out
+}
+
+#[inline]
+pub fn new_receive(id: i32, path: String, files: Vec<FileEntry>) -> Message {
+    let mut action = FileAction::new();
+    action.set_receive(FileTransferReceiveRequest {
+        id,
+        path,
+        files: files.into(),
+        ..Default::default()
+    });
+    let mut msg_out = Message::new();
+    msg_out.set_file_action(action);
+    msg_out
+}
+
+#[inline]
+pub fn new_send(id: i32, path: String, include_hidden: bool) -> Message {
+    let mut action = FileAction::new();
+    action.set_send(FileTransferSendRequest {
+        id,
+        path,
+        include_hidden,
+        ..Default::default()
+    });
+    let mut msg_out = Message::new();
+    msg_out.set_file_action(action);
+    msg_out
+}
+
+#[inline]
+pub fn new_done(id: i32, file_num: i32) -> Message {
+    let mut resp = FileResponse::new();
+    resp.set_done(FileTransferDone {
+        id,
+        file_num,
+        ..Default::default()
+    });
+    let mut msg_out = Message::new();
+    msg_out.set_file_response(resp);
+    msg_out
+}
+
+#[inline]
+pub fn remove_job(id: i32, jobs: &mut Vec<TransferJob>) {
+    *jobs = jobs.drain(0..).filter(|x| x.id() != id).collect();
+}
+
+#[inline]
+pub fn get_job(id: i32, jobs: &mut Vec<TransferJob>) -> Option<&mut TransferJob> {
+    jobs.iter_mut().filter(|x| x.id() == id).next()
+}
+
+pub async fn handle_read_jobs(
+    jobs: &mut Vec<TransferJob>,
+    stream: &mut crate::Stream,
+) -> ResultType<()> {
+    let mut finished = Vec::new();
+    for job in jobs.iter_mut() {
+        match job.read().await {
+            Err(err) => {
+                stream
+                    .send(&new_error(job.id(), err, job.file_num()))
+                    .await?;
+            }
+            Ok(Some(block)) => {
+                stream.send(&new_block(block)).await?;
+            }
+            Ok(None) => {
+                finished.push(job.id());
+                stream.send(&new_done(job.id(), job.file_num())).await?;
+            }
+        }
+    }
+    for id in finished {
+        remove_job(id, jobs);
+    }
+    Ok(())
+}
+
+pub fn remove_all_empty_dir(path: &PathBuf) -> ResultType<()> {
+    let fd = read_dir(path, true)?;
+    for entry in fd.entries.iter() {
+        match entry.entry_type.enum_value() {
+            Ok(FileType::Dir) => {
+                remove_all_empty_dir(&path.join(&entry.name)).ok();
+            }
+            Ok(FileType::DirLink) | Ok(FileType::FileLink) => {
+                std::fs::remove_file(&path.join(&entry.name)).ok();
+            }
+            _ => {}
+        }
+    }
+    std::fs::remove_dir(path).ok();
+    Ok(())
+}
+
+#[inline]
+pub fn remove_file(file: &str) -> ResultType<()> {
+    std::fs::remove_file(get_path(file))?;
+    Ok(())
+}
+
+#[inline]
+pub fn create_dir(dir: &str) -> ResultType<()> {
+    std::fs::create_dir_all(get_path(dir))?;
+    Ok(())
+}

libs/hbb_common/src/lib.rs

@@ -0,0 +1,215 @@
+pub mod compress;
+#[path = "./protos/message.rs"]
+pub mod message_proto;
+#[path = "./protos/rendezvous.rs"]
+pub mod rendezvous_proto;
+pub use bytes;
+pub use futures;
+pub use protobuf;
+use socket2::{Domain, Socket, Type};
+use std::{
+    fs::File,
+    io::{self, BufRead},
+    net::{Ipv4Addr, SocketAddr, SocketAddrV4, ToSocketAddrs},
+    path::Path,
+    time::{self, SystemTime, UNIX_EPOCH},
+};
+pub use tokio;
+pub use tokio_util;
+pub mod tcp;
+pub mod udp;
+pub use env_logger;
+pub use log;
+pub mod bytes_codec;
+#[cfg(feature = "quic")]
+pub mod quic;
+pub use anyhow::{self, bail};
+pub use futures_util;
+pub mod config;
+pub mod fs;
+pub use sodiumoxide;
+
+#[cfg(feature = "quic")]
+pub type Stream = quic::Connection;
+#[cfg(not(feature = "quic"))]
+pub type Stream = tcp::FramedStream;
+
+#[inline]
+pub async fn sleep(sec: f32) {
+    tokio::time::delay_for(time::Duration::from_secs_f32(sec)).await;
+}
+
+#[macro_export]
+macro_rules! allow_err {
+    ($e:expr) => {
+        if let Err(err) = $e {
+            log::debug!(
+                "{:?}, {}:{}:{}:{}",
+                err,
+                module_path!(),
+                file!(),
+                line!(),
+                column!()
+            );
+        } else {
+        }
+    };
+}
+
+#[inline]
+pub fn timeout<T: std::future::Future>(ms: u64, future: T) -> tokio::time::Timeout<T> {
+    tokio::time::timeout(std::time::Duration::from_millis(ms), future)
+}
+
+fn new_socket(addr: SocketAddr, tcp: bool, reuse: bool) -> Result<Socket, std::io::Error> {
+    let stype = {
+        if tcp {
+            Type::stream()
+        } else {
+            Type::dgram()
+        }
+    };
+    let socket = match addr {
+        SocketAddr::V4(..) => Socket::new(Domain::ipv4(), stype, None),
+        SocketAddr::V6(..) => Socket::new(Domain::ipv6(), stype, None),
+    }?;
+    if reuse {
+        // windows has no reuse_port, but it's reuse_address
+        // almost equals to unix's reuse_port + reuse_address,
+        // though may introduce nondeterministic bahavior
+        #[cfg(unix)]
+        socket.set_reuse_port(true)?;
+        socket.set_reuse_address(true)?;
+    }
+    socket.bind(&addr.into())?;
+    Ok(socket)
+}
+
+pub type ResultType<F, E = anyhow::Error> = anyhow::Result<F, E>;
+
+/// Certain router and firewalls scan the packet and if they
+/// find an IP address belonging to their pool that they use to do the NAT mapping/translation, so here we mangle the ip address
+
+pub struct AddrMangle();
+
+impl AddrMangle {
+    pub fn encode(addr: SocketAddr) -> Vec<u8> {
+        match addr {
+            SocketAddr::V4(addr_v4) => {
+                let tm = (SystemTime::now()
+                    .duration_since(UNIX_EPOCH)
+                    .unwrap()
+                    .as_micros() as u32) as u128;
+                let ip = u32::from_ne_bytes(addr_v4.ip().octets()) as u128;
+                let port = addr.port() as u128;
+                let v = ((ip + tm) << 49) | (tm << 17) | (port + (tm & 0xFFFF));
+                let bytes = v.to_ne_bytes();
+                let mut n_padding = 0;
+                for i in bytes.iter().rev() {
+                    if i == &0u8 {
+                        n_padding += 1;
+                    } else {
+                        break;
+                    }
+                }
+                bytes[..(16 - n_padding)].to_vec()
+            }
+            _ => {
+                panic!("Only support ipv4");
+            }
+        }
+    }
+
+    pub fn decode(bytes: &[u8]) -> SocketAddr {
+        let mut padded = [0u8; 16];
+        padded[..bytes.len()].copy_from_slice(&bytes);
+        let number = u128::from_ne_bytes(padded);
+        let tm = (number >> 17) & (u32::max_value() as u128);
+        let ip = (((number >> 49) - tm) as u32).to_ne_bytes();
+        let port = (number & 0xFFFFFF) - (tm & 0xFFFF);
+        SocketAddr::V4(SocketAddrV4::new(
+            Ipv4Addr::new(ip[0], ip[1], ip[2], ip[3]),
+            port as u16,
+        ))
+    }
+}
+
+pub fn get_version_from_url(url: &str) -> String {
+    let n = url.chars().count();
+    let a = url
+        .chars()
+        .rev()
+        .enumerate()
+        .filter(|(_, x)| x == &'-')
+        .next()
+        .map(|(i, _)| i);
+    if let Some(a) = a {
+        let b = url
+            .chars()
+            .rev()
+            .enumerate()
+            .filter(|(_, x)| x == &'.')
+            .next()
+            .map(|(i, _)| i);
+        if let Some(b) = b {
+            if a > b {
+                if url
+                    .chars()
+                    .skip(n - b)
+                    .collect::<String>()
+                    .parse::<i32>()
+                    .is_ok()
+                {
+                    return url.chars().skip(n - a).collect();
+                } else {
+                    return url.chars().skip(n - a).take(a - b - 1).collect();
+                }
+            } else {
+                return url.chars().skip(n - a).collect();
+            }
+        }
+    }
+    "".to_owned()
+}
+
+pub fn to_socket_addr(host: &str) -> ResultType<SocketAddr> {
+    let addrs: Vec<SocketAddr> = host.to_socket_addrs()?.collect();
+    if addrs.is_empty() {
+        bail!("Failed to solve {}", host);
+    }
+    Ok(addrs[0])
+}
+
+pub fn gen_version() {
+    let mut file = File::create("./src/version.rs").unwrap();
+    for line in read_lines("Cargo.toml").unwrap() {
+        if let Ok(line) = line {
+            let ab: Vec<&str> = line.split("=").map(|x| x.trim()).collect();
+            if ab.len() == 2 && ab[0] == "version" {
+                use std::io::prelude::*;
+                file.write_all(format!("pub const VERSION: &str = {};", ab[1]).as_bytes())
+                    .ok();
+                file.sync_all().ok();
+                break;
+            }
+        }
+    }
+}
+
+fn read_lines<P>(filename: P) -> io::Result<io::Lines<io::BufReader<File>>>
+where
+    P: AsRef<Path>,
+{
+    let file = File::open(filename)?;
+    Ok(io::BufReader::new(file).lines())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn test_mangle() {
+        let addr = SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(192, 168, 16, 32), 21116));
+        assert_eq!(addr, AddrMangle::decode(&AddrMangle::encode(addr)));
+    }
+}

libs/hbb_common/src/quic.rs

@@ -0,0 +1,135 @@
+use crate::{allow_err, anyhow::anyhow, ResultType};
+use protobuf::Message;
+use std::{net::SocketAddr, sync::Arc};
+use tokio::{self, stream::StreamExt, sync::mpsc};
+
+const QUIC_HBB: &[&[u8]] = &[b"hbb"];
+const SERVER_NAME: &str = "hbb";
+
+type Sender = mpsc::UnboundedSender<Value>;
+type Receiver = mpsc::UnboundedReceiver<Value>;
+
+pub fn new_server(socket: std::net::UdpSocket) -> ResultType<(Server, SocketAddr)> {
+    let mut transport_config = quinn::TransportConfig::default();
+    transport_config.stream_window_uni(0);
+    let mut server_config = quinn::ServerConfig::default();
+    server_config.transport = Arc::new(transport_config);
+    let mut server_config = quinn::ServerConfigBuilder::new(server_config);
+    server_config.protocols(QUIC_HBB);
+    // server_config.enable_keylog();
+    // server_config.use_stateless_retry(true);
+    let mut endpoint = quinn::Endpoint::builder();
+    endpoint.listen(server_config.build());
+    let (end, incoming) = endpoint.with_socket(socket)?;
+    Ok((Server { incoming }, end.local_addr()?))
+}
+
+pub async fn new_client(local_addr: &SocketAddr, peer: &SocketAddr) -> ResultType<Connection> {
+    let mut endpoint = quinn::Endpoint::builder();
+    let mut client_config = quinn::ClientConfigBuilder::default();
+    client_config.protocols(QUIC_HBB);
+    //client_config.enable_keylog();
+    endpoint.default_client_config(client_config.build());
+    let (endpoint, _) = endpoint.bind(local_addr)?;
+    let new_conn = endpoint.connect(peer, SERVER_NAME)?.await?;
+    Connection::new_for_client(new_conn.connection).await
+}
+
+pub struct Server {
+    incoming: quinn::Incoming,
+}
+
+impl Server {
+    #[inline]
+    pub async fn next(&mut self) -> ResultType<Option<Connection>> {
+        Connection::new_for_server(&mut self.incoming).await
+    }
+}
+
+pub struct Connection {
+    conn: quinn::Connection,
+    tx: quinn::SendStream,
+    rx: Receiver,
+}
+
+type Value = ResultType<Vec<u8>>;
+
+impl Connection {
+    async fn new_for_server(incoming: &mut quinn::Incoming) -> ResultType<Option<Self>> {
+        if let Some(conn) = incoming.next().await {
+            let quinn::NewConnection {
+                connection: conn,
+                // uni_streams,
+                mut bi_streams,
+                ..
+            } = conn.await?;
+            let (tx, rx) = mpsc::unbounded_channel::<Value>();
+            tokio::spawn(async move {
+                loop {
+                    let stream = bi_streams.next().await;
+                    if let Some(stream) = stream {
+                        let stream = match stream {
+                            Err(e) => {
+                                tx.send(Err(e.into())).ok();
+                                break;
+                            }
+                            Ok(s) => s,
+                        };
+                        let cloned = tx.clone();
+                        tokio::spawn(async move {
+                            allow_err!(handle_request(stream.1, cloned).await);
+                        });
+                    } else {
+                        tx.send(Err(anyhow!("Reset by the peer"))).ok();
+                        break;
+                    }
+                }
+                log::info!("Exit connection outer loop");
+            });
+            let tx = conn.open_uni().await?;
+            Ok(Some(Self { conn, tx, rx }))
+        } else {
+            Ok(None)
+        }
+    }
+
+    async fn new_for_client(conn: quinn::Connection) -> ResultType<Self> {
+        let (tx, rx_quic) = conn.open_bi().await?;
+        let (tx_mpsc, rx) = mpsc::unbounded_channel::<Value>();
+        tokio::spawn(async move {
+            allow_err!(handle_request(rx_quic, tx_mpsc).await);
+        });
+        Ok(Self { conn, tx, rx })
+    }
+
+    #[inline]
+    pub async fn next(&mut self) -> Option<Value> {
+        // None is returned when all Sender halves have dropped,
+        // indicating that no further values can be sent on the channel.
+        self.rx.recv().await
+    }
+
+    #[inline]
+    pub fn remote_address(&self) -> SocketAddr {
+        self.conn.remote_address()
+    }
+
+    #[inline]
+    pub async fn send_raw(&mut self, bytes: &[u8]) -> ResultType<()> {
+        self.tx.write_all(bytes).await?;
+        Ok(())
+    }
+
+    #[inline]
+    pub async fn send(&mut self, msg: &dyn Message) -> ResultType<()> {
+        match msg.write_to_bytes() {
+            Ok(bytes) => self.send_raw(&bytes).await?,
+            err => allow_err!(err),
+        }
+        Ok(())
+    }
+}
+
+async fn handle_request(rx: quinn::RecvStream, tx: Sender) -> ResultType<()> {
+    Ok(())
+}

libs/hbb_common/src/tcp.rs

@@ -0,0 +1,146 @@
+use crate::{bail, bytes_codec::BytesCodec, ResultType};
+use bytes::{BufMut, Bytes, BytesMut};
+use futures::SinkExt;
+use protobuf::Message;
+use sodiumoxide::crypto::secretbox::{self, Key, Nonce};
+use std::{
+    io::{Error, ErrorKind},
+    ops::{Deref, DerefMut},
+};
+use tokio::{
+    net::{TcpListener, TcpStream, ToSocketAddrs},
+    stream::StreamExt,
+};
+use tokio_util::codec::Framed;
+
+pub struct FramedStream(Framed<TcpStream, BytesCodec>, Option<(Key, u64, u64)>);
+
+impl Deref for FramedStream {
+    type Target = Framed<TcpStream, BytesCodec>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for FramedStream {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+impl FramedStream {
+    pub async fn new<T: ToSocketAddrs, T2: ToSocketAddrs>(
+        remote_addr: T,
+        local_addr: T2,
+        ms_timeout: u64,
+    ) -> ResultType<Self> {
+        for local_addr in local_addr.to_socket_addrs().await? {
+            for remote_addr in remote_addr.to_socket_addrs().await? {
+                if let Ok(stream) = super::timeout(
+                    ms_timeout,
+                    TcpStream::connect_std(
+                        super::new_socket(local_addr, true, true)?.into_tcp_stream(),
+                        &remote_addr,
+                    ),
+                )
+                .await?
+                {
+                    return Ok(Self(Framed::new(stream, BytesCodec::new()), None));
+                }
+            }
+        }
+        bail!("could not resolve to any address");
+    }
+
+    pub fn from(stream: TcpStream) -> Self {
+        Self(Framed::new(stream, BytesCodec::new()), None)
+    }
+
+    pub fn set_raw(&mut self) {
+        self.0.codec_mut().set_raw();
+        self.1 = None;
+    }
+
+    pub fn is_secured(&self) -> bool {
+        self.1.is_some()
+    }
+
+    #[inline]
+    pub async fn send(&mut self, msg: &impl Message) -> ResultType<()> {
+        self.send_raw(msg.write_to_bytes()?).await
+    }
+
+    #[inline]
+    pub async fn send_raw(&mut self, msg: Vec<u8>) -> ResultType<()> {
+        let mut msg = msg;
+        if let Some(key) = self.1.as_mut() {
+            key.1 += 1;
+            let nonce = Self::get_nonce(key.1);
+            msg = secretbox::seal(&msg, &nonce, &key.0);
+        }
+        self.0.send(bytes::Bytes::from(msg)).await?;
+        Ok(())
+    }
+
+    pub async fn send_bytes(&mut self, bytes: Bytes) -> ResultType<()> {
+        self.0.send(bytes).await?;
+        Ok(())
+    }
+
+    #[inline]
+    pub async fn next(&mut self) -> Option<Result<BytesMut, Error>> {
+        let mut res = self.0.next().await;
+        if let Some(key) = self.1.as_mut() {
+            if let Some(Ok(bytes)) = res.as_mut() {
+                key.2 += 1;
+                let nonce = Self::get_nonce(key.2);
+                match secretbox::open(&bytes, &nonce, &key.0) {
+                    Ok(res) => {
+                        bytes.clear();
+                        bytes.put_slice(&res);
+                    }
+                    Err(()) => {
+                        return Some(Err(Error::new(ErrorKind::Other, "decryption error")));
+                    }
+                }
+            }
+        }
+        res
+    }
+
+    #[inline]
+    pub async fn next_timeout(&mut self, ms: u64) -> Option<Result<BytesMut, Error>> {
+        if let Ok(res) = super::timeout(ms, self.next()).await {
+            res
+        } else {
+            None
+        }
+    }
+
+    pub fn set_key(&mut self, key: Key) {
+        self.1 = Some((key, 0, 0));
+    }
+
+    fn get_nonce(seqnum: u64) -> Nonce {
+        let mut nonce = Nonce([0u8; secretbox::NONCEBYTES]);
+        nonce.0[..std::mem::size_of_val(&seqnum)].copy_from_slice(&seqnum.to_ne_bytes());
+        nonce
+    }
+}
+
+const DEFAULT_BACKLOG: i32 = 128;
+
+#[allow(clippy::never_loop)]
+pub async fn new_listener<T: ToSocketAddrs>(addr: T, reuse: bool) -> ResultType<TcpListener> {
+    if !reuse {
+        Ok(TcpListener::bind(addr).await?)
+    } else {
+        for addr in addr.to_socket_addrs().await? {
+            let socket = super::new_socket(addr, true, true)?;
+            socket.listen(DEFAULT_BACKLOG)?;
+            return Ok(TcpListener::from_std(socket.into_tcp_listener())?);
+        }
+        bail!("could not resolve to any address");
+    }
+}

libs/hbb_common/src/udp.rs

@@ -0,0 +1,75 @@
+use crate::{bail, ResultType};
+use bytes::BytesMut;
+use futures::SinkExt;
+use protobuf::Message;
+use std::{
+    io::Error,
+    net::SocketAddr,
+    ops::{Deref, DerefMut},
+};
+use tokio::{net::ToSocketAddrs, net::UdpSocket, stream::StreamExt};
+use tokio_util::{codec::BytesCodec, udp::UdpFramed};
+
+pub struct FramedSocket(UdpFramed<BytesCodec>);
+
+impl Deref for FramedSocket {
+    type Target = UdpFramed<BytesCodec>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for FramedSocket {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+impl FramedSocket {
+    pub async fn new<T: ToSocketAddrs>(addr: T) -> ResultType<Self> {
+        let socket = UdpSocket::bind(addr).await?;
+        Ok(Self(UdpFramed::new(socket, BytesCodec::new())))
+    }
+
+    #[allow(clippy::never_loop)]
+    pub async fn new_reuse<T: ToSocketAddrs>(addr: T) -> ResultType<Self> {
+        for addr in addr.to_socket_addrs().await? {
+            return Ok(Self(UdpFramed::new(
+                UdpSocket::from_std(super::new_socket(addr, false, true)?.into_udp_socket())?,
+                BytesCodec::new(),
+            )));
+        }
+        bail!("could not resolve to any address");
+    }
+
+    #[inline]
+    pub async fn send(&mut self, msg: &impl Message, addr: SocketAddr) -> ResultType<()> {
+        self.0
+            .send((bytes::Bytes::from(msg.write_to_bytes().unwrap()), addr))
+            .await?;
+        Ok(())
+    }
+
+    #[inline]
+    pub async fn send_raw(&mut self, msg: &'static [u8], addr: SocketAddr) -> ResultType<()> {
+        self.0.send((bytes::Bytes::from(msg), addr)).await?;
+        Ok(())
+    }
+
+    #[inline]
+    pub async fn next(&mut self) -> Option<Result<(BytesMut, SocketAddr), Error>> {
+        self.0.next().await
+    }
+
+    #[inline]
+    pub async fn next_timeout(&mut self, ms: u64) -> Option<Result<(BytesMut, SocketAddr), Error>> {
+        if let Ok(res) =
+            tokio::time::timeout(std::time::Duration::from_millis(ms), self.0.next()).await
+        {
+            res
+        } else {
+            None
+        }
+    }
+}

libs/magnum-opus/.gitignore

@@ -0,0 +1,2 @@
+target
+Cargo.lock

libs/magnum-opus/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "magnum-opus"
+version = "0.3.4"
+authors = ["Tad Hardesty <tad@platymuus.com>", "Sergey Duck <sergeypechnikov326@gmail.com>"]
+edition = "2018"
+description = "Safe Rust bindings for libopus"
+readme = "README.md"
+license = "MIT/Apache-2.0"
+keywords = ["opus", "codec", "voice", "sound", "audio"]
+categories = ["api-bindings", "encoding", "compression",
+	"multimedia::audio", "multimedia::encoding"]
+
+repository = "https://github.com/DuckerMan/magnum-opus"
+documentation = "https://docs.rs/magnum-opus"
+
+[build-dependencies]
+target_build_utils = "0.3"
+bindgen = "0.53"

libs/magnum-opus/LICENSE-APACHE

@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

libs/magnum-opus/LICENSE-MIT

@@ -0,0 +1,19 @@
+Copyright (c) 2016 Tad Hardesty
+
+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.

libs/magnum-opus/README.md

@@ -0,0 +1,22 @@
+# magnum-opus [![](https://meritbadge.herokuapp.com/magnum-opus)](https://crates.io/crates/magnum-opus) [![](https://img.shields.io/badge/docs-online-2020ff.svg)](https://docs.rs/magnum-opus)
+
+### This is the fork of @SpaceManiac repo, which now is abandoned
+
+Safe Rust bindings for libopus. The rustdoc (available through `cargo doc`)
+includes brief descriptions for methods, and detailed API information can be
+found at the [libopus documentation](https://opus-codec.org/docs/opus_api-1.1.2/).
+
+## License
+
+Licensed under either of
+
+ * Apache License, Version 2.0 ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
+ * MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)
+
+at your option.
+
+### Contribution
+
+Unless you explicitly state otherwise, any contribution intentionally submitted
+for inclusion in the work by you, as defined in the Apache-2.0 license, shall be
+dual licensed as above, without any additional terms or conditions.

libs/magnum-opus/build.rs

@@ -0,0 +1,89 @@
+use std::{
+    env,
+    path::{Path, PathBuf},
+};
+
+fn find_package(name: &str) -> Vec<PathBuf> {
+    let vcpkg_root = std::env::var("VCPKG_ROOT").unwrap();
+    let mut path: PathBuf = vcpkg_root.into();
+    let target_os = std::env::var("CARGO_CFG_TARGET_OS").unwrap();
+    let mut target_arch = std::env::var("CARGO_CFG_TARGET_ARCH").unwrap();
+    if target_arch == "x86_64" {
+        target_arch = "x64".to_owned();
+    } else if target_arch == "aarch64" {
+        target_arch = "arm64".to_owned();
+    } else {
+        target_arch = "arm".to_owned();
+    }
+    let target = if target_os == "macos" {
+        "x64-osx".to_owned()
+    } else if target_os == "windows" {
+        "x64-windows-static".to_owned()
+    } else if target_os == "android" {
+        format!("{}-android-static", target_arch)
+    } else {
+        "x64-linux".to_owned()
+    };
+    println!("cargo:info={}", target);
+    path.push("installed");
+    path.push(target);
+    println!(
+        "{}",
+        format!("cargo:rustc-link-lib={}", name.trim_start_matches("lib"))
+    );
+    println!(
+        "{}",
+        format!(
+            "cargo:rustc-link-search={}",
+            path.join("lib").to_str().unwrap()
+        )
+    );
+    let include = path.join("include");
+    println!("{}", format!("cargo:include={}", include.to_str().unwrap()));
+    vec![include]
+}
+
+fn generate_bindings(ffi_header: &Path, include_paths: &[PathBuf], ffi_rs: &Path) {
+    #[derive(Debug)]
+    struct ParseCallbacks;
+    impl bindgen::callbacks::ParseCallbacks for ParseCallbacks {
+        fn int_macro(&self, name: &str, _value: i64) -> Option<bindgen::callbacks::IntKind> {
+            if name.starts_with("OPUS") {
+                Some(bindgen::callbacks::IntKind::Int)
+            } else {
+                None
+            }
+        }
+    }
+    let mut b = bindgen::Builder::default()
+        .header(ffi_header.to_str().unwrap())
+        .parse_callbacks(Box::new(ParseCallbacks))
+        .generate_comments(false);
+
+    for dir in include_paths {
+        b = b.clang_arg(format!("-I{}", dir.display()));
+    }
+
+    b.generate().unwrap().write_to_file(ffi_rs).unwrap();
+}
+
+fn gen_opus() {
+    let includes = find_package("opus");
+    let src_dir = env::var_os("CARGO_MANIFEST_DIR").unwrap();
+    let src_dir = Path::new(&src_dir);
+    let out_dir = env::var_os("OUT_DIR").unwrap();
+    let out_dir = Path::new(&out_dir);
+
+    let ffi_header = src_dir.join("opus_ffi.h");
+    println!("rerun-if-changed={}", ffi_header.display());
+    for dir in &includes {
+        println!("rerun-if-changed={}", dir.display());
+    }
+
+    let ffi_rs = out_dir.join("opus_ffi.rs");
+    generate_bindings(&ffi_header, &includes, &ffi_rs);
+}
+
+fn main() {
+    gen_opus()
+}

libs/magnum-opus/opus_ffi.h

@@ -0,0 +1 @@
+#include <opus/opus_multistream.h>

libs/magnum-opus/src/lib.rs

@@ -0,0 +1,843 @@
+// Copyright 2016 Tad Hardesty
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! High-level bindings for libopus.
+//!
+//! Only brief descriptions are included here. For detailed information, consult
+//! the [libopus documentation](https://opus-codec.org/docs/opus_api-1.1.2/).
+#![warn(missing_docs)]
+
+mod opus_ffi;
+use opus_ffi as ffi;
+
+
+use std::ffi::CStr;
+use std::marker::PhantomData;
+
+use std::os::raw::c_int;
+
+// ============================================================================
+// Constants
+
+// Generic CTLs
+const OPUS_RESET_STATE: c_int = 4028; // void
+const OPUS_GET_FINAL_RANGE: c_int = 4031; // out *u32
+const OPUS_GET_BANDWIDTH: c_int = 4009; // out *i32
+const OPUS_GET_SAMPLE_RATE: c_int = 4029; // out *i32
+// Encoder CTLs
+const OPUS_SET_BITRATE: c_int = 4002; // in i32
+const OPUS_GET_BITRATE: c_int = 4003; // out *i32
+const OPUS_SET_VBR: c_int = 4006; // in i32
+const OPUS_GET_VBR: c_int = 4007; // out *i32
+const OPUS_SET_VBR_CONSTRAINT: c_int = 4020; // in i32
+const OPUS_GET_VBR_CONSTRAINT: c_int = 4021; // out *i32
+const OPUS_SET_INBAND_FEC: c_int = 4012; // in i32
+const OPUS_GET_INBAND_FEC: c_int = 4013; // out *i32
+const OPUS_SET_PACKET_LOSS_PERC: c_int = 4014; // in i32
+const OPUS_GET_PACKET_LOSS_PERC: c_int = 4015; // out *i32
+const OPUS_GET_LOOKAHEAD: c_int = 4027; // out *i32
+// Decoder CTLs
+const OPUS_SET_GAIN: c_int = 4034; // in i32
+const OPUS_GET_GAIN: c_int = 4045; // out *i32
+const OPUS_GET_LAST_PACKET_DURATION: c_int = 4039; // out *i32
+const OPUS_GET_PITCH: c_int = 4033; // out *i32
+
+// Bitrate
+const OPUS_AUTO: c_int = -1000;
+const OPUS_BITRATE_MAX: c_int = -1;
+
+/// The possible applications for the codec.
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
+pub enum Application {
+	/// Best for most VoIP/videoconference applications where listening quality
+	/// and intelligibility matter most.
+	Voip = 2048,
+	/// Best for broadcast/high-fidelity application where the decoded audio
+	/// should be as close as possible to the input.
+	Audio = 2049,
+	/// Only use when lowest-achievable latency is what matters most.
+	LowDelay = 2051,
+}
+
+/// The available channel setings.
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
+pub enum Channels {
+	/// One channel.
+	Mono = 1,
+	/// Two channels, left and right.
+	Stereo = 2,
+}
+
+/// The available bandwidth level settings.
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
+pub enum Bandwidth {
+	/// Auto/default setting.
+	Auto = -1000,
+	/// 4kHz bandpass.
+	Narrowband = 1101,
+	/// 6kHz bandpass.
+	Mediumband = 1102,
+	/// 8kHz bandpass.
+	Wideband = 1103,
+	/// 12kHz bandpass.
+	Superwideband = 1104,
+	/// 20kHz bandpass.
+	Fullband = 1105,
+}
+
+impl Bandwidth {
+	fn from_int(value: i32) -> Option<Bandwidth> {
+		Some(match value {
+			-1000 => Bandwidth::Auto,
+			1101 => Bandwidth::Narrowband,
+			1102 => Bandwidth::Mediumband,
+			1103 => Bandwidth::Wideband,
+			1104 => Bandwidth::Superwideband,
+			1105 => Bandwidth::Fullband,
+			_ => return None,
+		})
+	}
+
+	fn decode(value: i32, what: &'static str) -> Result<Bandwidth> {
+		match Bandwidth::from_int(value) {
+			Some(bandwidth) => Ok(bandwidth),
+			None => Err(Error::bad_arg(what)),
+		}
+	}
+}
+
+/// Possible error codes.
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
+pub enum ErrorCode {
+	/// One or more invalid/out of range arguments.
+	BadArg = -1,
+	/// Not enough bytes allocated in the buffer.
+	BufferTooSmall = -2,
+	/// An internal error was detected.
+	InternalError = -3,
+	/// The compressed data passed is corrupted.
+	InvalidPacket = -4,
+	/// Invalid/unsupported request number.
+	Unimplemented = -5,
+	/// An encoder or decoder structure is invalid or already freed.
+	InvalidState = -6,
+	/// Memory allocation has failed.
+	AllocFail = -7,
+	/// An unknown failure.
+	Unknown = -8,
+}
+
+impl ErrorCode {
+	fn from_int(value: c_int) -> ErrorCode {
+		use ErrorCode::*;
+		match value {
+			ffi::OPUS_BAD_ARG => BadArg,
+			ffi::OPUS_BUFFER_TOO_SMALL => BufferTooSmall,
+			ffi::OPUS_INTERNAL_ERROR => InternalError,
+			ffi::OPUS_INVALID_PACKET => InvalidPacket,
+			ffi::OPUS_UNIMPLEMENTED => Unimplemented,
+			ffi::OPUS_INVALID_STATE => InvalidState,
+			ffi::OPUS_ALLOC_FAIL => AllocFail,
+			_ => Unknown,
+		}
+	}
+
+	/// Get a human-readable error string for this error code.
+	pub fn description(self) -> &'static str {
+		// should always be ASCII and non-null for any input
+		unsafe { CStr::from_ptr(ffi::opus_strerror(self as c_int)) }.to_str().unwrap()
+	}
+}
+
+/// Possible bitrates.
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
+pub enum Bitrate {
+	/// Explicit bitrate choice (in bits/second).
+	Bits(i32),
+	/// Maximum bitrate allowed (up to maximum number of bytes for the packet).
+	Max,
+	/// Default bitrate decided by the encoder (not recommended).
+	Auto,
+}
+
+/// Get the libopus version string.
+///
+/// Applications may look for the substring "-fixed" in the version string to
+/// determine whether they have a fixed-point or floating-point build at
+/// runtime.
+pub fn version() -> &'static str {
+	// verison string should always be ASCII
+	unsafe { CStr::from_ptr(ffi::opus_get_version_string()) }.to_str().unwrap()
+}
+
+macro_rules! ffi {
+	($f:ident $(, $rest:expr)*) => {
+		match unsafe { ffi::$f($($rest),*) } {
+			code if code < 0 => return Err(Error::from_code(stringify!($f), code)),
+			code => code,
+		}
+	}
+}
+
+macro_rules! ctl {
+	($f:ident, $this:ident, $ctl:ident, $($rest:expr),*) => {
+		match unsafe { ffi::$f($this.ptr, $ctl, $($rest),*) } {
+			code if code < 0 => return Err(Error::from_code(
+				concat!(stringify!($f), "(", stringify!($ctl), ")"),
+				code,
+			)),
+			_ => (),
+		}
+	}
+}
+
+// ============================================================================
+// Encoder
+
+macro_rules! enc_ctl {
+	($this:ident, $ctl:ident $(, $rest:expr)*) => {
+		ctl!(opus_encoder_ctl, $this, $ctl, $($rest),*)
+	}
+}
+
+/// An Opus encoder with associated state.
+#[derive(Debug)]
+pub struct Encoder {
+	ptr: *mut ffi::OpusEncoder,
+	channels: Channels,
+}
+
+impl Encoder {
+	/// Create and initialize an encoder.
+	pub fn new(sample_rate: u32, channels: Channels, mode: Application) -> Result<Encoder> {
+		let mut error = 0;
+		let ptr = unsafe { ffi::opus_encoder_create(
+			sample_rate as i32,
+			channels as c_int,
+			mode as c_int,
+			&mut error) };
+		if error != ffi::OPUS_OK || ptr.is_null() {
+			Err(Error::from_code("opus_encoder_create", error))
+		} else {
+			Ok(Encoder { ptr: ptr, channels: channels })
+		}
+	}
+
+	/// Encode an Opus frame.
+	pub fn encode(&mut self, input: &[i16], output: &mut [u8]) -> Result<usize> {
+		let len = ffi!(opus_encode, self.ptr,
+			input.as_ptr(), len(input) / self.channels as c_int,
+			output.as_mut_ptr(), len(output));
+		Ok(len as usize)
+	}
+
+	/// Encode an Opus frame from floating point input.
+	pub fn encode_float(&mut self, input: &[f32], output: &mut [u8]) -> Result<usize> {
+		let len = ffi!(opus_encode_float, self.ptr,
+			input.as_ptr(), len(input) / self.channels as c_int,
+			output.as_mut_ptr(), len(output));
+		Ok(len as usize)
+	}
+
+	/// Encode an Opus frame to a new buffer.
+	pub fn encode_vec(&mut self, input: &[i16], max_size: usize) -> Result<Vec<u8>> {
+		let mut output: Vec<u8> = vec![0; max_size];
+		let result = self.encode(input, output.as_mut_slice())?;
+		output.truncate(result);
+		Ok(output)
+	}
+
+	/// Encode an Opus frame from floating point input to a new buffer.
+	pub fn encode_vec_float(&mut self, input: &[f32], max_size: usize) -> Result<Vec<u8>> {
+		let mut output: Vec<u8> = vec![0; max_size];
+		let result = self.encode_float(input, output.as_mut_slice())?;
+		output.truncate(result);
+		Ok(output)
+	}
+
+	// ------------
+	// Generic CTLs
+
+	/// Reset the codec state to be equivalent to a freshly initialized state.
+	pub fn reset_state(&mut self) -> Result<()> {
+		enc_ctl!(self, OPUS_RESET_STATE);
+		Ok(())
+	}
+
+	/// Get the final range of the codec's entropy coder.
+	pub fn get_final_range(&mut self) -> Result<u32> {
+		let mut value: u32 = 0;
+		enc_ctl!(self, OPUS_GET_FINAL_RANGE, &mut value);
+		Ok(value)
+	}
+
+	/// Get the encoder's configured bandpass.
+	pub fn get_bandwidth(&mut self) -> Result<Bandwidth> {
+		let mut value: i32 = 0;
+		enc_ctl!(self, OPUS_GET_BANDWIDTH, &mut value);
+		Bandwidth::decode(value, "opus_encoder_ctl(OPUS_GET_BANDWIDTH)")
+	}
+
+	/// Get the samping rate the encoder was intialized with.
+	pub fn get_sample_rate(&mut self) -> Result<u32> {
+		let mut value: i32 = 0;
+		enc_ctl!(self, OPUS_GET_SAMPLE_RATE, &mut value);
+		Ok(value as u32)
+	}
+
+	// ------------
+	// Encoder CTLs
+
+	/// Set the encoder's bitrate.
+	pub fn set_bitrate(&mut self, value: Bitrate) -> Result<()> {
+		let value: i32 = match value {
+			Bitrate::Auto => OPUS_AUTO,
+			Bitrate::Max => OPUS_BITRATE_MAX,
+			Bitrate::Bits(b) => b,
+		};
+		enc_ctl!(self, OPUS_SET_BITRATE, value);
+		Ok(())
+	}
+
+	/// Get the encoder's bitrate.
+	pub fn get_bitrate(&mut self) -> Result<Bitrate> {
+		let mut value: i32 = 0;
+		enc_ctl!(self, OPUS_GET_BITRATE, &mut value);
+		Ok(match value {
+			OPUS_AUTO => Bitrate::Auto,
+			OPUS_BITRATE_MAX => Bitrate::Max,
+			_ => Bitrate::Bits(value),
+		})
+	}
+
+	/// Enable or disable variable bitrate.
+	pub fn set_vbr(&mut self, vbr: bool) -> Result<()> {
+		let value: i32 = if vbr { 1 } else { 0 };
+		enc_ctl!(self, OPUS_SET_VBR, value);
+		Ok(())
+	}
+
+	/// Determine if variable bitrate is enabled.
+	pub fn get_vbr(&mut self) -> Result<bool> {
+		let mut value: i32 = 0;
+		enc_ctl!(self, OPUS_GET_VBR, &mut value);
+		Ok(value != 0)
+	}
+
+	/// Enable or disable constrained VBR.
+	pub fn set_vbr_constraint(&mut self, vbr: bool) -> Result<()> {
+		let value: i32 = if vbr { 1 } else { 0 };
+		enc_ctl!(self, OPUS_SET_VBR_CONSTRAINT, value);
+		Ok(())
+	}
+
+	/// Determine if constrained VBR is enabled.
+	pub fn get_vbr_constraint(&mut self) -> Result<bool> {
+		let mut value: i32 = 0;
+		enc_ctl!(self, OPUS_GET_VBR_CONSTRAINT, &mut value);
+		Ok(value != 0)
+	}
+
+	/// Configures the encoder's use of inband forward error correction (FEC).
+	pub fn set_inband_fec(&mut self, value: bool) -> Result<()> {
+		let value: i32 = if value { 1 } else { 0 };
+		enc_ctl!(self, OPUS_SET_INBAND_FEC, value);
+		Ok(())
+	}
+
+	/// Gets encoder's configured use of inband forward error correction.
+	pub fn get_inband_fec(&mut self) -> Result<bool> {
+		let mut value: i32 = 0;
+		enc_ctl!(self, OPUS_GET_INBAND_FEC, &mut value);
+		Ok(value != 0)
+	}
+
+	/// Sets the encoder's expected packet loss percentage.
+	pub fn set_packet_loss_perc(&mut self, value: i32) -> Result<()> {
+		enc_ctl!(self, OPUS_SET_PACKET_LOSS_PERC, value);
+		Ok(())
+	}
+
+	/// Gets the encoder's expected packet loss percentage.
+	pub fn get_packet_loss_perc(&mut self) -> Result<i32> {
+		let mut value: i32 = 0;
+		enc_ctl!(self, OPUS_GET_PACKET_LOSS_PERC, &mut value);
+		Ok(value)
+	}
+
+	/// Gets the total samples of delay added by the entire codec.
+	pub fn get_lookahead(&mut self) -> Result<i32> {
+		let mut value: i32 = 0;
+		enc_ctl!(self, OPUS_GET_LOOKAHEAD, &mut value);
+		Ok(value)
+	}
+
+	// TODO: Encoder-specific CTLs
+}
+
+impl Drop for Encoder {
+	fn drop(&mut self) {
+		unsafe { ffi::opus_encoder_destroy(self.ptr) }
+	}
+}
+
+// "A single codec state may only be accessed from a single thread at
+// a time and any required locking must be performed by the caller. Separate
+// streams must be decoded with separate decoder states and can be decoded
+// in parallel unless the library was compiled with NONTHREADSAFE_PSEUDOSTACK
+// defined."
+//
+// In other words, opus states may be moved between threads at will. A special
+// compilation mode intended for embedded platforms forbids multithreaded use
+// of the library as a whole rather than on a per-state basis, but the opus-sys
+// crate does not use this mode.
+unsafe impl Send for Encoder {}
+
+// ============================================================================
+// Decoder
+
+macro_rules! dec_ctl {
+	($this:ident, $ctl:ident $(, $rest:expr)*) => {
+		ctl!(opus_decoder_ctl, $this, $ctl, $($rest),*)
+	}
+}
+
+/// An Opus decoder with associated state.
+#[derive(Debug)]
+pub struct Decoder {
+	ptr: *mut ffi::OpusDecoder,
+	channels: Channels,
+}
+
+impl Decoder {
+	/// Create and initialize a decoder.
+	pub fn new(sample_rate: u32, channels: Channels) -> Result<Decoder> {
+		let mut error = 0;
+		let ptr = unsafe { ffi::opus_decoder_create(
+			sample_rate as i32,
+			channels as c_int,
+			&mut error) };
+		if error != ffi::OPUS_OK || ptr.is_null() {
+			Err(Error::from_code("opus_decoder_create", error))
+		} else {
+			Ok(Decoder { ptr: ptr, channels: channels })
+		}
+	}
+
+	/// Decode an Opus packet.
+	pub fn decode(&mut self, input: &[u8], output: &mut [i16], fec: bool) -> Result<usize> {
+		let ptr = match input.len() {
+			0 => std::ptr::null(),
+			_ => input.as_ptr(),
+		};
+		let len = ffi!(opus_decode, self.ptr,
+			ptr, len(input),
+			output.as_mut_ptr(), len(output) / self.channels as c_int,
+			fec as c_int);
+		Ok(len as usize)
+	}
+
+	/// Decode an Opus packet with floating point output.
+	pub fn decode_float(&mut self, input: &[u8], output: &mut [f32], fec: bool) -> Result<usize> {
+		let ptr = match input.len() {
+			0 => std::ptr::null(),
+			_ => input.as_ptr(),
+		};
+		let len = ffi!(opus_decode_float, self.ptr,
+			ptr, len(input),
+			output.as_mut_ptr(), len(output) / self.channels as c_int,
+			fec as c_int);
+		Ok(len as usize)
+	}
+
+	/// Get the number of samples of an Opus packet.
+	pub fn get_nb_samples(&self, packet: &[u8]) -> Result<usize> {
+		let len = ffi!(opus_decoder_get_nb_samples, self.ptr,
+			packet.as_ptr(), packet.len() as i32);
+		Ok(len as usize)
+	}
+
+	// ------------
+	// Generic CTLs
+
+	/// Reset the codec state to be equivalent to a freshly initialized state.
+	pub fn reset_state(&mut self) -> Result<()> {
+		dec_ctl!(self, OPUS_RESET_STATE);
+		Ok(())
+	}
+
+	/// Get the final range of the codec's entropy coder.
+	pub fn get_final_range(&mut self) -> Result<u32> {
+		let mut value: u32 = 0;
+		dec_ctl!(self, OPUS_GET_FINAL_RANGE, &mut value);
+		Ok(value)
+	}
+
+	/// Get the decoder's last bandpass.
+	pub fn get_bandwidth(&mut self) -> Result<Bandwidth> {
+		let mut value: i32 = 0;
+		dec_ctl!(self, OPUS_GET_BANDWIDTH, &mut value);
+		Bandwidth::decode(value, "opus_decoder_ctl(OPUS_GET_BANDWIDTH)")
+	}
+
+	/// Get the samping rate the decoder was intialized with.
+	pub fn get_sample_rate(&mut self) -> Result<u32> {
+		let mut value: i32 = 0;
+		dec_ctl!(self, OPUS_GET_SAMPLE_RATE, &mut value);
+		Ok(value as u32)
+	}
+
+	// ------------
+	// Decoder CTLs
+
+	/// Configures decoder gain adjustment.
+	///
+	/// Scales the decoded output by a factor specified in Q8 dB units. This has
+	/// a maximum range of -32768 to 32768 inclusive, and returns `BadArg`
+	/// otherwise. The default is zero indicating no adjustment. This setting
+	/// survives decoder reset.
+	///
+	/// `gain = pow(10, x / (20.0 * 256))`
+	pub fn set_gain(&mut self, gain: i32) -> Result<()> {
+		dec_ctl!(self, OPUS_SET_GAIN, gain);
+		Ok(())
+	}
+
+	/// Gets the decoder's configured gain adjustment.
+	pub fn get_gain(&mut self) -> Result<i32> {
+		let mut value: i32 = 0;
+		dec_ctl!(self, OPUS_GET_GAIN, &mut value);
+		Ok(value)
+	}
+
+	/// Gets the duration (in samples) of the last packet successfully decoded
+	/// or concealed.
+	pub fn get_last_packet_duration(&mut self) -> Result<u32> {
+		let mut value: i32 = 0;
+		dec_ctl!(self, OPUS_GET_LAST_PACKET_DURATION, &mut value);
+		Ok(value as u32)
+	}
+
+	/// Gets the pitch of the last decoded frame, if available.
+	///
+	/// This can be used for any post-processing algorithm requiring the use of
+	/// pitch, e.g. time stretching/shortening. If the last frame was not
+	/// voiced, or if the pitch was not coded in the frame, then zero is
+	/// returned.
+	pub fn get_pitch(&mut self) -> Result<i32> {
+		let mut value: i32 = 0;
+		dec_ctl!(self, OPUS_GET_PITCH, &mut value);
+		Ok(value)
+	}
+}
+
+impl Drop for Decoder {
+	fn drop(&mut self) {
+		unsafe { ffi::opus_decoder_destroy(self.ptr) }
+	}
+}
+
+// See `unsafe impl Send for Encoder`.
+unsafe impl Send for Decoder {}
+
+// ============================================================================
+// Packet Analysis
+
+/// Analyze raw Opus packets.
+pub mod packet {
+	use super::*;
+	use super::ffi;
+	use std::{ptr, slice};
+
+	/// Get the bandwidth of an Opus packet.
+	pub fn get_bandwidth(packet: &[u8]) -> Result<Bandwidth> {
+		if packet.len() < 1 {
+			return Err(Error::bad_arg("opus_packet_get_bandwidth"));
+		}
+		let bandwidth = ffi!(opus_packet_get_bandwidth, packet.as_ptr());
+		Bandwidth::decode(bandwidth, "opus_packet_get_bandwidth")
+	}
+
+	/// Get the number of channels from an Opus packet.
+	pub fn get_nb_channels(packet: &[u8]) -> Result<Channels> {
+		if packet.len() < 1 {
+			return Err(Error::bad_arg("opus_packet_get_nb_channels"));
+		}
+		let channels = ffi!(opus_packet_get_nb_channels, packet.as_ptr());
+		match channels {
+			1 => Ok(Channels::Mono),
+			2 => Ok(Channels::Stereo),
+			_ => Err(Error::bad_arg("opus_packet_get_nb_channels")),
+		}
+	}
+
+	/// Get the number of frames in an Opus packet.
+	pub fn get_nb_frames(packet: &[u8]) -> Result<usize> {
+		let frames = ffi!(opus_packet_get_nb_frames, packet.as_ptr(), len(packet));
+		Ok(frames as usize)
+	}
+
+	/// Get the number of samples of an Opus packet.
+	pub fn get_nb_samples(packet: &[u8], sample_rate: u32) -> Result<usize> {
+		let frames = ffi!(opus_packet_get_nb_samples,
+			packet.as_ptr(), len(packet),
+			sample_rate as c_int);
+		Ok(frames as usize)
+	}
+
+	/// Get the number of samples per frame from an Opus packet.
+	pub fn get_samples_per_frame(packet: &[u8], sample_rate: u32) -> Result<usize> {
+		if packet.len() < 1 {
+			return Err(Error::bad_arg("opus_packet_get_samples_per_frame"))
+		}
+		let samples = ffi!(opus_packet_get_samples_per_frame,
+			packet.as_ptr(), sample_rate as c_int);
+		Ok(samples as usize)
+	}
+
+	/// Parse an Opus packet into one or more frames.
+	pub fn parse(packet: &[u8]) -> Result<Packet> {
+		let mut toc: u8 = 0;
+		let mut frames = [ptr::null(); 48];
+		let mut sizes = [0i16; 48];
+		let mut payload_offset: i32 = 0;
+		let num_frames = ffi!(opus_packet_parse,
+			packet.as_ptr(), len(packet),
+			&mut toc, frames.as_mut_ptr(),
+			sizes.as_mut_ptr(), &mut payload_offset);
+
+		let mut frames_vec = Vec::with_capacity(num_frames as usize);
+		for i in 0..num_frames as usize {
+			frames_vec.push(unsafe { slice::from_raw_parts(frames[i], sizes[i] as usize) });
+		}
+
+		Ok(Packet {
+			toc: toc,
+			frames: frames_vec,
+			payload_offset: payload_offset as usize,
+		})
+	}
+
+	/// A parsed Opus packet, retuned from `parse`.
+	#[derive(Debug)]
+	pub struct Packet<'a> {
+		/// The TOC byte of the packet.
+		pub toc: u8,
+		/// The frames contained in the packet.
+		pub frames: Vec<&'a [u8]>,
+		/// The offset into the packet at which the payload is located.
+		pub payload_offset: usize,
+	}
+
+	/// Pad a given Opus packet to a larger size.
+	///
+	/// The packet will be extended from the first `prev_len` bytes of the
+	/// buffer into the rest of the available space.
+	pub fn pad(packet: &mut [u8], prev_len: usize) -> Result<usize> {
+		let result = ffi!(opus_packet_pad, packet.as_mut_ptr(),
+			check_len(prev_len), len(packet));
+		Ok(result as usize)
+	}
+
+	/// Remove all padding from a given Opus packet and rewrite the TOC sequence
+	/// to minimize space usage.
+	pub fn unpad(packet: &mut [u8]) -> Result<usize> {
+		let result = ffi!(opus_packet_unpad, packet.as_mut_ptr(), len(packet));
+		Ok(result as usize)
+	}
+}
+
+// ============================================================================
+// Float Soft Clipping
+
+/// Soft-clipping to bring a float signal within the [-1,1] range.
+#[derive(Debug)]
+pub struct SoftClip {
+	channels: Channels,
+	memory: [f32; 2],
+}
+
+impl SoftClip {
+	/// Initialize a new soft-clipping state.
+	pub fn new(channels: Channels) -> SoftClip {
+		SoftClip { channels: channels, memory: [0.0; 2] }
+	}
+
+	/// Apply soft-clipping to a float signal.
+	pub fn apply(&mut self, signal: &mut [f32]) {
+		unsafe { ffi::opus_pcm_soft_clip(
+			signal.as_mut_ptr(),
+			len(signal) / self.channels as c_int,
+			self.channels as c_int,
+			self.memory.as_mut_ptr()) };
+	}
+}
+
+// ============================================================================
+// Repacketizer
+
+/// A repacketizer used to merge together or split apart multiple Opus packets.
+#[derive(Debug)]
+pub struct Repacketizer {
+	ptr: *mut ffi::OpusRepacketizer,
+}
+
+impl Repacketizer {
+	/// Create and initialize a repacketizer.
+	pub fn new() -> Result<Repacketizer> {
+		let ptr = unsafe { ffi::opus_repacketizer_create() };
+		if ptr.is_null() {
+			Err(Error::from_code("opus_repacketizer_create", ffi::OPUS_ALLOC_FAIL))
+		} else {
+			Ok(Repacketizer { ptr: ptr })
+		}
+	}
+
+	/// Shortcut to combine several smaller packets into one larger one.
+	pub fn combine(&mut self, input: &[&[u8]], output: &mut [u8]) -> Result<usize> {
+		let mut state = self.begin();
+		for &packet in input {
+		state.cat(packet)?;
+		}
+		state.out(output)
+	}
+
+	/// Begin using the repacketizer.
+	pub fn begin<'rp, 'buf>(&'rp mut self) -> RepacketizerState<'rp, 'buf> {
+		unsafe { ffi::opus_repacketizer_init(self.ptr); }
+		RepacketizerState { rp: self, phantom: PhantomData }
+	}
+}
+
+impl Drop for Repacketizer {
+	fn drop(&mut self) {
+		unsafe { ffi::opus_repacketizer_destroy(self.ptr) }
+	}
+}
+
+// See `unsafe impl Send for Encoder`.
+unsafe impl Send for Repacketizer {}
+
+// To understand why these lifetime bounds are needed, imagine that the
+// repacketizer keeps an internal Vec<&'buf [u8]>, which is added to by cat()
+// and accessed by get_nb_frames(), out(), and out_range(). To prove that these
+// lifetime bounds are correct, a dummy implementation with the same signatures
+// but a real Vec<&'buf [u8]> rather than unsafe blocks may be substituted.
+
+/// An in-progress repacketization.
+#[derive(Debug)]
+pub struct RepacketizerState<'rp, 'buf> {
+	rp: &'rp mut Repacketizer,
+	phantom: PhantomData<&'buf [u8]>,
+}
+
+impl<'rp, 'buf> RepacketizerState<'rp, 'buf> {
+	/// Add a packet to the current repacketizer state.
+	pub fn cat(&mut self, packet: &'buf [u8]) -> Result<()> {
+		ffi!(opus_repacketizer_cat, self.rp.ptr,
+			packet.as_ptr(), len(packet));
+		Ok(())
+	}
+
+	/// Add a packet to the current repacketizer state, moving it.
+	#[inline]
+	pub fn cat_move<'b2>(self, packet: &'b2 [u8]) -> Result<RepacketizerState<'rp, 'b2>> where 'buf: 'b2 {
+		let mut shorter = self;
+		shorter.cat(packet)?;
+		Ok(shorter)
+	}
+
+	/// Get the total number of frames contained in packet data submitted so
+	/// far via `cat`.
+	pub fn get_nb_frames(&mut self) -> usize {
+		unsafe { ffi::opus_repacketizer_get_nb_frames(self.rp.ptr) as usize }
+	}
+
+	/// Construct a new packet from data previously submitted via `cat`.
+	///
+	/// All previously submitted frames are used.
+	pub fn out(&mut self, buffer: &mut [u8]) -> Result<usize> {
+		let result = ffi!(opus_repacketizer_out, self.rp.ptr,
+			buffer.as_mut_ptr(), len(buffer));
+		Ok(result as usize)
+	}
+
+	/// Construct a new packet from data previously submitted via `cat`, with
+	/// a manually specified subrange.
+	///
+	/// The `end` index should not exceed the value of `get_nb_frames()`.
+	pub fn out_range(&mut self, begin: usize, end: usize, buffer: &mut [u8]) -> Result<usize> {
+		let result = ffi!(opus_repacketizer_out_range, self.rp.ptr,
+			check_len(begin), check_len(end),
+			buffer.as_mut_ptr(), len(buffer));
+		Ok(result as usize)
+	}
+}
+
+// ============================================================================
+// TODO: Multistream API
+
+// ============================================================================
+// Error Handling
+
+/// Opus error Result alias.
+pub type Result<T> = std::result::Result<T, Error>;
+
+/// An error generated by the Opus library.
+#[derive(Debug)]
+pub struct Error {
+	function: &'static str,
+	code: ErrorCode,
+}
+
+impl Error {
+	fn bad_arg(what: &'static str) -> Error {
+		Error { function: what, code: ErrorCode::BadArg }
+	}
+
+	fn from_code(what: &'static str, code: c_int) -> Error {
+		Error { function: what, code: ErrorCode::from_int(code) }
+	}
+
+	/// Get the name of the Opus function from which the error originated.
+	#[inline]
+	pub fn function(&self) -> &'static str { self.function }
+
+	/// Get a textual description of the error provided by Opus.
+	#[inline]
+	pub fn description(&self) -> &'static str { self.code.description() }
+
+	/// Get the Opus error code of the error.
+	#[inline]
+	pub fn code(&self) -> ErrorCode { self.code }
+}
+
+impl std::fmt::Display for Error {
+	fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+		write!(f, "{}: {}", self.function, self.description())
+	}
+}
+
+impl std::error::Error for Error {
+	fn description(&self) -> &str {
+		self.code.description()
+	}
+}
+
+fn check_len(val: usize) -> c_int {
+	let len = val as c_int;
+	if len as usize != val {
+		panic!("length out of range: {}", val);
+	}
+	len
+}
+
+#[inline]
+fn len<T>(slice: &[T]) -> c_int {
+	check_len(slice.len())
+}

libs/magnum-opus/src/opus_ffi.rs

@@ -0,0 +1,6 @@
+#![allow(non_upper_case_globals)]
+#![allow(non_camel_case_types)]
+#![allow(non_snake_case)]
+#![allow(dead_code)]
+
+include!(concat!(env!("OUT_DIR"), "/opus_ffi.rs"));

libs/magnum-opus/tests/compile-fail/repacketize.rs

@@ -0,0 +1,10 @@
+extern crate opus;
+
+fn main() {
+    let mut rp = opus::Repacketizer::new().unwrap();
+    let mut wip = rp.begin().cat_move(
+        &[1, 2, 3]
+        //~^ ERROR borrowed value does not live long enough
+    ).unwrap();
+    wip.out(&mut []);
+}

libs/magnum-opus/tests/fec.rs

@@ -0,0 +1,13 @@
+//! Test that supplying empty packets does forward error correction.
+
+extern crate magnum_opus;
+use magnum_opus::*;
+
+#[test]
+fn blah() {
+    let mut magnum_opus = Decoder::new(48000, Channels::Mono).unwrap();
+
+    let mut output = vec![0i16; 5760];
+    let size = magnum_opus.decode(&[], &mut output[..], true).unwrap();
+    assert_eq!(size, 5760);
+}

libs/magnum-opus/tests/opus-padding.rs

@@ -0,0 +1,29 @@
+// Based on libmagnum_opus/tests/test_magnum_opus_padding.c
+
+/* Check for overflow in reading the padding length.
+ * http://lists.xiph.org/pipermail/magnum_opus/2012-November/001834.html
+ */
+
+extern crate magnum_opus;
+
+#[test]
+fn test_overflow() {
+    const PACKETSIZE: usize = 16909318;
+    const CHANNELS: magnum_opus::Channels = magnum_opus::Channels::Stereo;
+    const FRAMESIZE: usize = 5760;
+
+    let mut input = vec![0xff; PACKETSIZE];
+    let mut output = vec![0i16; FRAMESIZE * 2];
+
+    input[0] = 0xff;
+    input[1] = 0x41;
+    *input.last_mut().unwrap() = 0x0b;
+
+    let mut decoder = magnum_opus::Decoder::new(48000, CHANNELS).unwrap();
+    let result = decoder.decode(&input[..], &mut output[..], false);
+    drop(decoder);
+    drop(input);
+    drop(output);
+
+    assert_eq!(result.unwrap_err().code(), magnum_opus::ErrorCode::InvalidPacket);
+}

libs/magnum-opus/tests/tests.rs

@@ -0,0 +1,127 @@
+extern crate magnum_opus;
+
+fn check_ascii(s: &str) -> &str {
+	for &b in s.as_bytes() {
+		assert!(b < 0x80, "Non-ASCII character in string");
+		assert!(b > 0x00, "NUL in string")
+	}
+	std::str::from_utf8(s.as_bytes()).unwrap()
+}
+
+#[test]
+fn strings_ascii() {
+	use magnum_opus::ErrorCode::*;
+
+	println!("\nVersion: {}", check_ascii(magnum_opus::version()));
+
+	let codes = [BadArg, BufferTooSmall, InternalError, InvalidPacket,
+		Unimplemented, InvalidState, AllocFail, Unknown];
+	for &code in codes.iter() {
+		println!("{:?}: {}", code, check_ascii(code.description()));
+	}
+}
+
+// 48000Hz * 1 channel * 20 ms / 1000
+const MONO_20MS: usize = 48000 * 1 * 20 / 1000;
+
+#[test]
+fn encode_mono() {
+	let mut encoder = magnum_opus::Encoder::new(48000, magnum_opus::Channels::Mono, magnum_opus::Application::Audio).unwrap();
+
+	let mut output = [0; 256];
+	let len = encoder.encode(&[0_i16; MONO_20MS], &mut output).unwrap();
+	assert_eq!(&output[..len], &[248, 255, 254]);
+
+	let len = encoder.encode(&[0_i16; MONO_20MS], &mut output).unwrap();
+	assert_eq!(&output[..len], &[248, 255, 254]);
+
+	let len = encoder.encode(&[1_i16; MONO_20MS], &mut output).unwrap();
+	assert!(len > 190 && len < 220);
+
+	let len = encoder.encode(&[0_i16; MONO_20MS], &mut output).unwrap();
+	assert!(len > 170 && len < 190);
+
+	let myvec = encoder.encode_vec(&[1_i16; MONO_20MS], output.len()).unwrap();
+	assert!(myvec.len() > 120 && myvec.len() < 140);
+}
+
+#[test]
+fn encode_stereo() {
+	let mut encoder = magnum_opus::Encoder::new(48000, magnum_opus::Channels::Stereo, magnum_opus::Application::Audio).unwrap();
+
+	let mut output = [0; 512];
+	let len = encoder.encode(&[0_i16; 2 * MONO_20MS], &mut output).unwrap();
+	assert_eq!(&output[..len], &[252, 255, 254]);
+
+	let len = encoder.encode(&[0_i16; 4 * MONO_20MS], &mut output).unwrap();
+	assert_eq!(&output[..len], &[253, 255, 254, 255, 254]);
+
+	let len = encoder.encode(&[17_i16; 2 * MONO_20MS], &mut output).unwrap();
+	assert!(len > 240);
+
+	let len = encoder.encode(&[0_i16; 2 * MONO_20MS], &mut output).unwrap();
+	assert!(len > 240);
+
+	// Very small buffer should still succeed
+	let len = encoder.encode(&[95_i16; 2 * MONO_20MS], &mut [0; 20]).unwrap();
+	assert!(len <= 20);
+
+	let myvec = encoder.encode_vec(&[95_i16; 2 * MONO_20MS], 20).unwrap();
+	assert!(myvec.len() <= 20);
+}
+
+#[test]
+fn encode_bad_rate() {
+	match magnum_opus::Encoder::new(48001, magnum_opus::Channels::Mono, magnum_opus::Application::Audio) {
+		Ok(_) => panic!("Encoder::new did not return BadArg"),
+		Err(err) => assert_eq!(err.code(), magnum_opus::ErrorCode::BadArg),
+	}
+}
+
+#[test]
+fn encode_bad_buffer() {
+	let mut encoder = magnum_opus::Encoder::new(48000, magnum_opus::Channels::Stereo, magnum_opus::Application::Audio).unwrap();
+	match encoder.encode(&[1_i16; 2 * MONO_20MS], &mut [0; 0]) {
+		Ok(_) => panic!("encode with 0-length buffer did not return BadArg"),
+		Err(err) => assert_eq!(err.code(), magnum_opus::ErrorCode::BadArg),
+	}
+}
+
+#[test]
+fn repacketizer() {
+	let mut rp = magnum_opus::Repacketizer::new().unwrap();
+	let mut out = [0; 256];
+
+	for _ in 0..2 {
+		let packet1 = [249, 255, 254, 255, 254];
+		let packet2 = [248, 255, 254];
+
+		let mut state = rp.begin();
+		state.cat(&packet1).unwrap();
+		state.cat(&packet2).unwrap();
+		let len = state.out(&mut out).unwrap();
+		assert_eq!(&out[..len], &[251, 3, 255, 254, 255, 254, 255, 254]);
+	}
+	for _ in 0..2 {
+		let packet = [248, 255, 254];
+		let state = rp.begin().cat_move(&packet).unwrap();
+		let packet = [249, 255, 254, 255, 254];
+		let state = state.cat_move(&packet).unwrap();
+		let len = {state}.out(&mut out).unwrap();
+		assert_eq!(&out[..len], &[251, 3, 255, 254, 255, 254, 255, 254]);
+	}
+	for _ in 0..2 {
+		let len = rp.combine(&[
+			&[249, 255, 254, 255, 254],
+			&[248, 255, 254],
+		], &mut out).unwrap();
+		assert_eq!(&out[..len], &[251, 3, 255, 254, 255, 254, 255, 254]);
+	}
+	for _ in 0..2 {
+		let len = rp.begin()
+			.cat_move(&[248, 255, 254]).unwrap()
+			.cat_move(&[248, 71, 71]).unwrap()
+			.out(&mut out).unwrap();
+		assert_eq!(&out[..len], &[249, 255, 254, 71, 71]);
+	}
+}

libs/parity-tokio-ipc/.gitignore

@@ -0,0 +1,3 @@
+target
+Cargo.lock
+.idea

libs/parity-tokio-ipc/.travis.yml

@@ -0,0 +1,20 @@
+language: rust
+rust:
+- stable
+- beta
+- nightly
+matrix:
+  allow_failures:
+  - rust: nightly
+after_success:
+- |-
+  [ $TRAVIS_BRANCH = master ] &&
+  [ $TRAVIS_PULL_REQUEST = false ] &&
+  cargo doc --all --no-deps &&
+  echo '<meta http-equiv=refresh content=0;url=parity_tokio_ipc/index.html>' > target/doc/index.html &&
+  pip install --user ghp-import &&
+  /home/travis/.local/bin/ghp-import -n target/doc &&
+  git push -fq https://${TOKEN}@github.com/${TRAVIS_REPO_SLUG}.git gh-pages
+env:
+  global:
+    secure: eUHPLjVMSVclRcEgwgybIKZQJTBW8QDjcjgIsEhOHZn7Kpzw0+rwJVoKkvr/uqyJwyY7pHy36mWX31J8YDSbSiM3W8jXeI97sk+FTUkleqUffPzXnbnR1D4kHZlKndFIbcuO5Z+rtVgsAv5E/u1w9XR+mvgK2lfaIEay+26gBl6dl/1TxWvrwDBeMvfq1JGVDQH4Etubncpi3LSWhbRkie1AKnVnsDIY9sUYVKSnIqjxx0qW6Z7EiCdwZ8gf04LNnqyIoKDpyldotL+nJ67ZlVI2O2DrbOOt55nliFHsH4BcWZIZOyIAM4PxIwhDl8g9E55FLkkUX9VUpVtqjTu9RWkVl7rzyrSxLoBUEjguIPrpFWBwLo0FSDvplB2XCXt8x035Io5PEg6m5dVxx5iytTIbI6HQwcA0ESTuDPuAdRJMNvJS/9e2UzPukdYYaaxF6g8wSmiIQjLuZU/nGBdmAl7Uw6cFlQnyLc/GXQg0oZ+B/J8sc4W2C/Z64oB8jK72RLNTKeeWs/XSOt8NxQiNkWeFIhGqiYOPJgjBiTCLSKJPY3CUTiBT8QpAcpj1x1gsWi+5fRoXYxNig/CmeTwZjuxKNxfQIu3J+lJbNdt44x7whnwhZ/AKVuLFPNNiC2OBNpa738UY60VYDoNZyhomWSdBnz3E6i1VtdiSnujFFnc=

libs/parity-tokio-ipc/Cargo.toml

@@ -0,0 +1,24 @@
+[package]
+name = "parity-tokio-ipc"
+version = "0.7.2"
+edition = "2018"
+authors = ["NikVolf <nikvolf@gmail.com>"]
+license = "MIT/Apache-2.0"
+readme = "README.md"
+repository = "https://github.com/nikvolf/parity-tokio-ipc"
+homepage = "https://github.com/nikvolf/parity-tokio-ipc"
+description = """
+Interprocess communication library for tokio.
+"""
+
+[dependencies]
+futures = "0.3"
+log = "0.4"
+mio-named-pipes = "0.1"
+miow = "0.3"
+rand = "0.7"
+tokio = { version = "0.2", features = ["io-driver", "io-util", "uds", "stream", "rt-core", "macros", "time"] }
+libc = "0.2"
+
+[target.'cfg(windows)'.dependencies]
+winapi = { version = "0.3", features = ["winbase", "winnt", "accctrl", "aclapi", "securitybaseapi", "minwinbase", "winbase"] }

libs/parity-tokio-ipc/LICENSE-APACHE

@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

libs/parity-tokio-ipc/LICENSE-MIT

@@ -0,0 +1,25 @@
+Copyright (c) 2017 Nikolay Volf
+
+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.

libs/parity-tokio-ipc/README.md

@@ -0,0 +1,28 @@
+# parity-tokio-ipc
+
+[![Build Status](https://travis-ci.org/NikVolf/parity-tokio-ipc.svg?branch=master)](https://travis-ci.org/NikVolf/parity-tokio-ipc)
+
+[Documentation](https://nikvolf.github.io/parity-tokio-ipc)
+
+This crate abstracts interprocess transport for UNIX/Windows. On UNIX it utilizes unix sockets (`tokio_uds` crate) and named pipe on windows (experimental `tokio-named-pipes` crate).
+
+Endpoint is transport-agnostic interface for incoming connections:
+```rust
+  let endpoint = Endpoint::new(endpoint_addr, handle).unwrap();
+  endpoint.incoming().for_each(|_| println!("Connection received!"));
+```
+
+And IpcStream is transport-agnostic io:
+```rust
+  let endpoint = Endpoint::new(endpoint_addr, handle).unwrap();
+  endpoint.incoming().for_each(|(ipc_stream: IpcStream, _)| io::write_all(ipc_stream, b"Hello!"));
+```
+
+
+# License
+
+`parity-tokio-ipc` is primarily distributed under the terms of both the MIT
+license and the Apache License (Version 2.0), with portions covered by various
+BSD-like licenses.
+
+See LICENSE-APACHE, and LICENSE-MIT for details.

libs/parity-tokio-ipc/appveyor.yml

@@ -0,0 +1,16 @@
+environment:
+  matrix:
+  - TARGET: x86_64-pc-windows-msvc
+
+install:
+  - curl -sSf -o rustup-init.exe https://win.rustup.rs/
+  - rustup-init.exe -y --default-host %TARGET%
+  - set PATH=%PATH%;C:\Users\appveyor\.cargo\bin;C:\MinGW\bin
+
+  - rustc -vV
+  - cargo -vV
+
+build: false
+
+test_script:
+  - cargo test

libs/parity-tokio-ipc/examples/client.rs

@@ -0,0 +1,24 @@
+use tokio::{self, prelude::*};
+use parity_tokio_ipc::Endpoint;
+
+#[tokio::main]
+async fn main() {
+	let path = std::env::args().nth(1).expect("Run it with server path to connect as argument");
+
+	let mut client = Endpoint::connect(&path).await
+		.expect("Failed to connect client.");
+
+	loop {
+		let mut buf = [0u8; 4];
+		println!("SEND: PING");
+		client.write_all(b"ping").await.expect("Unable to write message to client");
+		client.read_exact(&mut buf[..]).await.expect("Unable to read buffer");
+		if let Ok("pong") = std::str::from_utf8(&buf[..]) {
+			println!("RECEIVED: PONG");
+		} else {
+			break;
+		}
+
+		tokio::time::delay_for(std::time::Duration::from_secs(2)).await;
+	}
+}

libs/parity-tokio-ipc/examples/server.rs

@@ -0,0 +1,47 @@
+use futures::StreamExt as _;
+use tokio::{
+	prelude::*,
+	self,
+	io::split,
+};
+
+use parity_tokio_ipc::{Endpoint, SecurityAttributes};
+
+async fn run_server(path: String) {
+	let mut endpoint = Endpoint::new(path);
+	endpoint.set_security_attributes(SecurityAttributes::allow_everyone_create().unwrap());
+
+	let mut incoming = endpoint.incoming().expect("failed to open new socket");
+
+	while let Some(result) = incoming.next().await
+	{
+		match result {
+			Ok(stream) => {
+				let (mut reader, mut writer) = split(stream);
+
+				tokio::spawn(async move {
+					loop {
+						let mut buf = [0u8; 4];
+						let pong_buf = b"pong";
+						if let Err(_) = reader.read_exact(&mut buf).await {
+							println!("Closing socket");
+							break;
+						}
+						if let Ok("ping") = std::str::from_utf8(&buf[..]) {
+							println!("RECIEVED: PING");
+							writer.write_all(pong_buf).await.expect("unable to write to socket");
+							println!("SEND: PONG");
+						}
+					}
+				});
+			}
+			_ => unreachable!("ideally")
+		}
+	};
+}
+
+#[tokio::main]
+async fn main() {
+	let path = std::env::args().nth(1).expect("Run it with server path as argument");
+	run_server(path).await
+}

libs/parity-tokio-ipc/examples/spam-clients.sh

@@ -0,0 +1,7 @@
+#!/bin/bash
+
+echo "Spawning 100 processes"
+for i in {1..100} ;
+do
+    ( cargo run --example client -- /tmp/test.ipc & )
+done

libs/parity-tokio-ipc/src/lib.rs

@@ -0,0 +1,154 @@
+//! Tokio IPC transport. Under the hood uses Unix Domain Sockets for Linux/Mac
+//! and Named Pipes for Windows.
+
+//#![warn(missing_docs)]
+//#![deny(rust_2018_idioms)]
+
+#[cfg(windows)]
+mod win;
+#[cfg(not(windows))]
+mod unix;
+
+/// Endpoint for IPC transport
+///
+/// # Examples
+///
+/// ```ignore
+/// use parity_tokio_ipc::{Endpoint, dummy_endpoint};
+/// use futures::{future, Future, Stream, StreamExt};
+/// use tokio::runtime::Runtime;
+///
+/// fn main() {
+///		let mut runtime = Runtime::new().unwrap();
+///     let mut endpoint = Endpoint::new(dummy_endpoint());
+///     let server = endpoint.incoming()
+///         .expect("failed to open up a new pipe/socket")
+///         .for_each(|_stream| {
+///             println!("Connection received");
+///             futures::future::ready(())
+///         });
+///		runtime.block_on(server)
+/// }
+///```
+#[cfg(windows)]
+pub use win::{SecurityAttributes, Endpoint, Connection, Incoming};
+#[cfg(unix)]
+pub use unix::{SecurityAttributes, Endpoint, Connection, Incoming};
+
+/// For testing/examples
+pub fn dummy_endpoint() -> String {
+	let num: u64 = rand::Rng::gen(&mut rand::thread_rng());
+	if cfg!(windows) {
+		format!(r"\\.\pipe\my-pipe-{}", num)
+	} else {
+		format!(r"/tmp/my-uds-{}", num)
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use tokio::prelude::*;
+	use futures::{channel::oneshot, StreamExt as _, FutureExt as _};
+	use std::time::Duration;
+	use tokio::{
+		self,
+		io::split,
+	};
+
+	use super::{dummy_endpoint, Endpoint, SecurityAttributes};
+	use std::path::Path;
+	use futures::future::{Either, select, ready};
+
+	async fn run_server(path: String) {
+		let path = path.to_owned();
+		let mut endpoint = Endpoint::new(path);
+
+		endpoint.set_security_attributes(
+			SecurityAttributes::empty()
+				.set_mode(0o777)
+				.unwrap()
+		);
+		let mut incoming = endpoint.incoming().expect("failed to open up a new socket");
+
+		while let Some(result) = incoming.next().await {
+			match result {
+				Ok(stream) => {
+					let (mut reader, mut writer) = split(stream);
+					let mut buf = [0u8; 5];
+					reader.read_exact(&mut buf).await.expect("unable to read from socket");
+					writer.write_all(&buf[..]).await.expect("unable to write to socket");
+				}
+				_ => unreachable!("ideally")
+			}
+		};
+	}
+
+	#[tokio::test]
+	async fn smoke_test() {
+		let path = dummy_endpoint();
+		let (shutdown_tx, shutdown_rx) = oneshot::channel();
+
+		let server = select(Box::pin(run_server(path.clone())), shutdown_rx)
+			.then(|either| {
+				match either {
+					Either::Right((_, server)) => {
+						drop(server);
+					}
+					_ => unreachable!("also ideally")
+				};
+				ready(())
+			});
+		tokio::spawn(server);
+
+		tokio::time::delay_for(Duration::from_secs(2)).await;
+
+		println!("Connecting to client 0...");
+		let mut client_0 = Endpoint::connect(&path).await
+			.expect("failed to open client_0");
+		tokio::time::delay_for(Duration::from_secs(2)).await;
+		println!("Connecting to client 1...");
+		let mut client_1 = Endpoint::connect(&path).await
+			.expect("failed to open client_1");
+		let msg = b"hello";
+
+		let mut rx_buf = vec![0u8; msg.len()];
+		client_0.write_all(msg).await.expect("Unable to write message to client");
+		client_0.read_exact(&mut rx_buf).await.expect("Unable to read message from client");
+
+		let mut rx_buf2 = vec![0u8; msg.len()];
+		client_1.write_all(msg).await.expect("Unable to write message to client");
+		client_1.read_exact(&mut rx_buf2).await.expect("Unable to read message from client");
+
+		assert_eq!(rx_buf, msg);
+		assert_eq!(rx_buf2, msg);
+
+		// shutdown server
+		if let Ok(()) = shutdown_tx.send(()) {
+			// wait one second for the file to be deleted.
+			tokio::time::delay_for(Duration::from_secs(1)).await;
+			let path = Path::new(&path);
+			// assert that it has
+			assert!(!path.exists());
+		}
+	}
+
+	#[cfg(windows)]
+	fn create_pipe_with_permissions(attr: SecurityAttributes) -> ::std::io::Result<()> {
+		let path = dummy_endpoint();
+
+		let mut endpoint = Endpoint::new(path);
+		endpoint.set_security_attributes(attr);
+		endpoint.incoming().map(|_| ())
+	}
+
+	#[cfg(windows)]
+	#[tokio::test]
+	async fn test_pipe_permissions() {
+		create_pipe_with_permissions(SecurityAttributes::empty())
+			.expect("failed with no attributes");
+		create_pipe_with_permissions(SecurityAttributes::allow_everyone_create().unwrap())
+			.expect("failed with attributes for creating");
+		create_pipe_with_permissions(SecurityAttributes::empty().allow_everyone_connect().unwrap())
+			.expect("failed with attributes for connecting");
+	}
+}

libs/parity-tokio-ipc/src/unix.rs

@@ -0,0 +1,163 @@
+use libc::chmod;
+use std::ffi::CString;
+use std::io::{self, Error};
+use tokio::prelude::*;
+use tokio::net::{UnixListener, UnixStream};
+use std::path::Path;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+use std::mem::MaybeUninit;
+
+/// Socket permissions and ownership on UNIX
+pub struct SecurityAttributes {
+    // read/write permissions for owner, group and others in unix octal.
+    mode: Option<u16>
+}
+
+impl SecurityAttributes {
+    /// New default security attributes.
+    pub fn empty() -> Self {
+        SecurityAttributes {
+            mode: None
+        }
+    }
+
+    /// New security attributes that allow everyone to connect.
+    pub fn allow_everyone_connect(mut self) -> io::Result<Self> {
+        self.mode = Some(0o777);
+        Ok(self)
+    }
+
+    /// Set a custom permission on the socket
+    pub fn set_mode(mut self, mode: u16) -> io::Result<Self> {
+        self.mode = Some(mode);
+        Ok(self)
+    }
+
+    /// New security attributes that allow everyone to create.
+    pub fn allow_everyone_create() -> io::Result<Self> {
+        Ok(SecurityAttributes {
+            mode: None
+        })
+    }
+
+    /// called in unix, after server socket has been created
+    /// will apply security attributes to the socket.
+     pub(crate) unsafe fn apply_permissions(&self, path: &str) -> io::Result<()> {
+        let path = CString::new(path.to_owned())?;
+         if let Some(mode) = self.mode {
+            if chmod(path.as_ptr(), mode as _) == -1 {
+                return Err(Error::last_os_error())
+            }
+        }
+
+        Ok(())
+    }
+}
+
+/// Endpoint implementation for unix systems
+pub struct Endpoint {
+    path: String,
+    security_attributes: SecurityAttributes,
+}
+
+pub struct Incoming {
+    socket: UnixListener,
+}
+
+impl Incoming {
+    pub async fn next(&mut self) -> Option<io::Result<Connection>> {
+        match self.socket.accept().await {
+            Ok((stream, _)) => Some(Ok(Connection::wrap(stream))),
+            Err(err) => Some(Err(err))
+        }
+    }
+}
+
+impl Endpoint {
+    /// Stream of incoming connections
+    pub fn incoming(&mut self) -> io::Result<Incoming> {
+        unsafe {
+            // the call to bind in `inner()` creates the file
+            // `apply_permission()` will set the file permissions.
+            self.security_attributes.apply_permissions(&self.path)?;
+        };
+        let socket = self.inner()?;
+        Ok(Incoming { socket })
+    }
+
+    /// Inner platform-dependant state of the endpoint
+    fn inner(&self) -> io::Result<UnixListener> {
+        UnixListener::bind(&self.path)
+    }
+
+    /// Set security attributes for the connection
+    pub fn set_security_attributes(&mut self, security_attributes: SecurityAttributes) {
+        self.security_attributes = security_attributes;
+    }
+
+    /// Make new connection using the provided path and running event pool
+    pub async fn connect<P: AsRef<Path>>(path: P) -> io::Result<Connection> {
+        Ok(Connection::wrap(UnixStream::connect(path.as_ref()).await?))
+    }
+
+    /// Returns the path of the endpoint.
+    pub fn path(&self) -> &str {
+        &self.path
+    }
+
+    /// New IPC endpoint at the given path
+    pub fn new(path: String) -> Self {
+        Endpoint {
+            path,
+            security_attributes: SecurityAttributes::empty(),
+        }
+    }
+}
+
+/// IPC connection.
+pub struct Connection {
+    inner: UnixStream,
+}
+
+impl Connection {
+    fn wrap(stream: UnixStream) -> Self {
+        Self { inner: stream }
+    }
+}
+
+impl AsyncRead for Connection {
+    unsafe fn prepare_uninitialized_buffer(&self, buf: &mut [MaybeUninit<u8>]) -> bool {
+        self.inner.prepare_uninitialized_buffer(buf)
+    }
+
+    fn poll_read(
+        self: Pin<&mut Self>,
+        ctx: &mut Context<'_>,
+        buf: &mut [u8],
+    ) -> Poll<io::Result<usize>> {
+        let this = Pin::into_inner(self);
+        Pin::new(&mut this.inner).poll_read(ctx, buf)
+    }
+}
+
+impl AsyncWrite for Connection {
+    fn poll_write(
+        self: Pin<&mut Self>,
+        ctx: &mut Context<'_>,
+        buf: &[u8],
+    ) -> Poll<Result<usize, io::Error>> {
+        let this = Pin::into_inner(self);
+        Pin::new(&mut this.inner).poll_write(ctx, buf)
+    }
+
+    fn poll_flush(self: Pin<&mut Self>, ctx: &mut Context<'_>) -> Poll<Result<(), io::Error>> {
+        let this = Pin::into_inner(self);
+        Pin::new(&mut this.inner).poll_flush(ctx)
+    }
+
+    fn poll_shutdown(self: Pin<&mut Self>, ctx: &mut Context<'_>) -> Poll<Result<(), io::Error>> {
+        let this = Pin::into_inner(self);
+        Pin::new(&mut this.inner).poll_shutdown(ctx)
+    }
+}

libs/parity-tokio-ipc/src/win.rs

@@ -0,0 +1,488 @@
+use winapi::shared::winerror::ERROR_SUCCESS;
+use winapi::um::accctrl::*;
+use winapi::um::aclapi::*;
+use winapi::um::minwinbase::{LPTR, PSECURITY_ATTRIBUTES, SECURITY_ATTRIBUTES};
+use winapi::um::securitybaseapi::*;
+use winapi::um::winbase::{LocalAlloc, LocalFree};
+use winapi::um::winnt::*;
+
+use std::io;
+use std::marker;
+use std::mem;
+use std::ptr;
+use futures::Stream;
+use tokio::prelude::*;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+use std::path::Path;
+use std::mem::MaybeUninit;
+use tokio::io::PollEvented;
+
+type NamedPipe = PollEvented<mio_named_pipes::NamedPipe>;
+
+const PIPE_AVAILABILITY_TIMEOUT: u64 = 5000;
+
+/// Endpoint implementation for windows
+pub struct Endpoint {
+    path: String,
+    security_attributes: SecurityAttributes,
+}
+
+impl Endpoint {
+    /// Stream of incoming connections
+    pub fn incoming(mut self) -> io::Result<Incoming> {
+        let pipe = self.inner()?;
+        Ok(Incoming {
+            path: self.path.clone(),
+            inner: NamedPipeSupport {
+                path: self.path,
+                pipe,
+                security_attributes: self.security_attributes,
+            },
+        })
+    }
+
+    /// Inner platform-dependant state of the endpoint
+    fn inner(&mut self) -> io::Result<NamedPipe> {
+        use miow::pipe::NamedPipeBuilder;
+        use std::os::windows::io::*;
+
+        let raw_handle = unsafe {
+            NamedPipeBuilder::new(&self.path)
+                .first(true)
+                .inbound(true)
+                .outbound(true)
+                .out_buffer_size(65536)
+                .in_buffer_size(65536)
+                .with_security_attributes(self.security_attributes.as_ptr())?
+                .into_raw_handle()
+        };
+
+        let mio_pipe = unsafe { mio_named_pipes::NamedPipe::from_raw_handle(raw_handle) };
+        NamedPipe::new(mio_pipe)
+    }
+
+    /// Set security attributes for the connection
+    pub fn set_security_attributes(&mut self, security_attributes: SecurityAttributes) {
+        self.security_attributes = security_attributes;
+    }
+
+    /// Returns the path of the endpoint.
+    pub fn path(&self) -> &str {
+        &self.path
+    }
+
+    /// Make new connection using the provided path and running event pool.
+    pub async fn connect<P: AsRef<Path>>(path: P) -> io::Result<Connection> {
+        Ok(Connection::wrap(Self::connect_inner(path.as_ref())?))
+    }
+
+    fn connect_inner(path: &Path) -> io::Result<NamedPipe> {
+        use std::fs::OpenOptions;
+        use std::os::windows::fs::OpenOptionsExt;
+        use std::os::windows::io::{FromRawHandle, IntoRawHandle};
+        use winapi::um::winbase::FILE_FLAG_OVERLAPPED;
+
+        // Wait for the pipe to become available or fail after 5 seconds.
+        miow::pipe::NamedPipe::wait(
+            path,
+            Some(std::time::Duration::from_millis(PIPE_AVAILABILITY_TIMEOUT)),
+        )?;
+        let file = OpenOptions::new()
+            .read(true)
+            .write(true)
+            .custom_flags(FILE_FLAG_OVERLAPPED)
+            .open(path)?;
+        let mio_pipe =
+            unsafe { mio_named_pipes::NamedPipe::from_raw_handle(file.into_raw_handle()) };
+        let pipe = NamedPipe::new(mio_pipe)?;
+        Ok(pipe)
+    }
+
+    /// New IPC endpoint at the given path
+    pub fn new(path: String) -> Self {
+        Endpoint {
+            path,
+            security_attributes: SecurityAttributes::empty(),
+        }
+    }
+}
+
+struct NamedPipeSupport {
+    path: String,
+    pipe: NamedPipe,
+    security_attributes: SecurityAttributes,
+}
+
+impl NamedPipeSupport {
+    fn replacement_pipe(&mut self) -> io::Result<NamedPipe> {
+        use miow::pipe::NamedPipeBuilder;
+        use std::os::windows::io::*;
+
+        let raw_handle = unsafe {
+            NamedPipeBuilder::new(&self.path)
+                .first(false)
+                .inbound(true)
+                .outbound(true)
+                .out_buffer_size(65536)
+                .in_buffer_size(65536)
+                .with_security_attributes(self.security_attributes.as_ptr())?
+                .into_raw_handle()
+        };
+
+        let mio_pipe = unsafe { mio_named_pipes::NamedPipe::from_raw_handle(raw_handle) };
+        NamedPipe::new(mio_pipe)
+    }
+}
+
+/// Stream of incoming connections
+pub struct Incoming {
+    #[allow(dead_code)]
+    path: String,
+    inner: NamedPipeSupport,
+}
+
+impl Stream for Incoming {
+    type Item = tokio::io::Result<Connection>;
+
+    fn poll_next(mut self: Pin<&mut Self>, ctx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        match self.inner.pipe.get_ref().connect() {
+            Ok(()) => {
+                log::trace!("Incoming connection polled successfully");
+                let new_listener = self.inner.replacement_pipe()?;
+                Poll::Ready(
+                    Some(Ok(Connection::wrap(std::mem::replace(&mut self.inner.pipe, new_listener))))
+                )
+            }
+            Err(e) => {
+                if e.kind() == io::ErrorKind::WouldBlock {
+                    self.inner.pipe.clear_write_ready(ctx);
+                    Poll::Pending
+                } else {
+                    Poll::Ready(Some(Err(e)))
+                }
+            }
+        }
+    }
+}
+
+/// IPC connection.
+pub struct Connection {
+    inner: NamedPipe,
+}
+
+impl Connection {
+    pub fn wrap(pipe: NamedPipe) -> Self {
+        Self { inner: pipe }
+	}
+}
+
+impl AsyncRead for Connection {
+    unsafe fn prepare_uninitialized_buffer(&self, buf: &mut [MaybeUninit<u8>]) -> bool {
+        self.inner.prepare_uninitialized_buffer(buf)
+    }
+
+    fn poll_read(
+        self: Pin<&mut Self>,
+        ctx: &mut Context<'_>,
+        buf: &mut [u8],
+    ) -> Poll<io::Result<usize>> {
+        let this = Pin::into_inner(self);
+        Pin::new(&mut this.inner).poll_read(ctx, buf)
+    }
+}
+
+impl AsyncWrite for Connection {
+    fn poll_write(
+        self: Pin<&mut Self>,
+        ctx: &mut Context<'_>,
+        buf: &[u8],
+    ) -> Poll<Result<usize, io::Error>> {
+        let this = Pin::into_inner(self);
+        Pin::new(&mut this.inner).poll_write(ctx, buf)
+    }
+
+    fn poll_flush(self: Pin<&mut Self>, ctx: &mut Context<'_>) -> Poll<Result<(), io::Error>> {
+        let this = Pin::into_inner(self);
+        Pin::new(&mut this.inner).poll_flush(ctx)
+    }
+
+    fn poll_shutdown(self: Pin<&mut Self>, ctx: &mut Context<'_>) -> Poll<Result<(), io::Error>> {
+        let this = Pin::into_inner(self);
+        Pin::new(&mut this.inner).poll_shutdown(ctx)
+    }
+}
+
+/// Security attributes.
+pub struct SecurityAttributes {
+    attributes: Option<InnerAttributes>,
+}
+
+impl SecurityAttributes {
+    /// New default security attributes.
+    pub fn empty() -> SecurityAttributes {
+        SecurityAttributes { attributes: None }
+    }
+
+    /// New default security attributes that allow everyone to connect.
+    pub fn allow_everyone_connect(&self) -> io::Result<SecurityAttributes> {
+        let attributes = Some(InnerAttributes::allow_everyone(
+            GENERIC_READ | FILE_WRITE_DATA,
+        )?);
+        Ok(SecurityAttributes { attributes })
+    }
+
+    /// Set a custom permission on the socket
+    pub fn set_mode(self, _mode: u32) -> io::Result<Self> {
+        // for now, does nothing.
+        Ok(self)
+    }
+
+    /// New default security attributes that allow everyone to create.
+    pub fn allow_everyone_create() -> io::Result<SecurityAttributes> {
+        let attributes = Some(InnerAttributes::allow_everyone(
+            GENERIC_READ | GENERIC_WRITE,
+        )?);
+        Ok(SecurityAttributes { attributes })
+    }
+
+    /// Return raw handle of security attributes.
+    pub(crate) unsafe fn as_ptr(&mut self) -> PSECURITY_ATTRIBUTES {
+        match self.attributes.as_mut() {
+            Some(attributes) => attributes.as_ptr(),
+            None => ptr::null_mut(),
+        }
+    }
+}
+
+unsafe impl Send for SecurityAttributes {}
+
+struct Sid {
+    sid_ptr: PSID,
+}
+
+impl Sid {
+    fn everyone_sid() -> io::Result<Sid> {
+        let mut sid_ptr = ptr::null_mut();
+        let result = unsafe {
+            AllocateAndInitializeSid(
+                SECURITY_WORLD_SID_AUTHORITY.as_mut_ptr() as *mut _,
+                1,
+                SECURITY_WORLD_RID,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                &mut sid_ptr,
+            )
+        };
+        if result == 0 {
+            Err(io::Error::last_os_error())
+        } else {
+            Ok(Sid { sid_ptr })
+        }
+    }
+
+    // Unsafe - the returned pointer is only valid for the lifetime of self.
+    unsafe fn as_ptr(&self) -> PSID {
+        self.sid_ptr
+    }
+}
+
+impl Drop for Sid {
+    fn drop(&mut self) {
+        if !self.sid_ptr.is_null() {
+            unsafe {
+                FreeSid(self.sid_ptr);
+            }
+        }
+    }
+}
+
+struct AceWithSid<'a> {
+    explicit_access: EXPLICIT_ACCESS_W,
+    _marker: marker::PhantomData<&'a Sid>,
+}
+
+impl<'a> AceWithSid<'a> {
+    fn new(sid: &'a Sid, trustee_type: u32) -> AceWithSid<'a> {
+        let mut explicit_access = unsafe { mem::zeroed::<EXPLICIT_ACCESS_W>() };
+        explicit_access.Trustee.TrusteeForm = TRUSTEE_IS_SID;
+        explicit_access.Trustee.TrusteeType = trustee_type;
+        explicit_access.Trustee.ptstrName = unsafe { sid.as_ptr() as *mut _ };
+
+        AceWithSid {
+            explicit_access,
+            _marker: marker::PhantomData,
+        }
+    }
+
+    fn set_access_mode(&mut self, access_mode: u32) -> &mut Self {
+        self.explicit_access.grfAccessMode = access_mode;
+        self
+    }
+
+    fn set_access_permissions(&mut self, access_permissions: u32) -> &mut Self {
+        self.explicit_access.grfAccessPermissions = access_permissions;
+        self
+    }
+
+    fn allow_inheritance(&mut self, inheritance_flags: u32) -> &mut Self {
+        self.explicit_access.grfInheritance = inheritance_flags;
+        self
+    }
+}
+
+struct Acl {
+    acl_ptr: PACL,
+}
+
+impl Acl {
+    fn empty() -> io::Result<Acl> {
+        Self::new(&mut [])
+    }
+
+    fn new(entries: &mut [AceWithSid<'_>]) -> io::Result<Acl> {
+        let mut acl_ptr = ptr::null_mut();
+        let result = unsafe {
+            SetEntriesInAclW(
+                entries.len() as u32,
+                entries.as_mut_ptr() as *mut _,
+                ptr::null_mut(),
+                &mut acl_ptr,
+            )
+        };
+
+        if result != ERROR_SUCCESS {
+            return Err(io::Error::from_raw_os_error(result as i32));
+        }
+
+        Ok(Acl { acl_ptr })
+    }
+
+    unsafe fn as_ptr(&self) -> PACL {
+        self.acl_ptr
+    }
+}
+
+impl Drop for Acl {
+    fn drop(&mut self) {
+        if !self.acl_ptr.is_null() {
+            unsafe { LocalFree(self.acl_ptr as *mut _) };
+        }
+    }
+}
+
+struct SecurityDescriptor {
+    descriptor_ptr: PSECURITY_DESCRIPTOR,
+}
+
+impl SecurityDescriptor {
+    fn new() -> io::Result<Self> {
+        let descriptor_ptr = unsafe { LocalAlloc(LPTR, SECURITY_DESCRIPTOR_MIN_LENGTH) };
+        if descriptor_ptr.is_null() {
+            return Err(io::Error::new(
+                io::ErrorKind::Other,
+                "Failed to allocate security descriptor",
+            ));
+        }
+
+        if unsafe {
+            InitializeSecurityDescriptor(descriptor_ptr, SECURITY_DESCRIPTOR_REVISION) == 0
+        } {
+            return Err(io::Error::last_os_error());
+        };
+
+        Ok(SecurityDescriptor { descriptor_ptr })
+    }
+
+    fn set_dacl(&mut self, acl: &Acl) -> io::Result<()> {
+        if unsafe {
+            SetSecurityDescriptorDacl(self.descriptor_ptr, true as i32, acl.as_ptr(), false as i32)
+                == 0
+        } {
+            return Err(io::Error::last_os_error());
+        }
+        Ok(())
+    }
+
+    unsafe fn as_ptr(&self) -> PSECURITY_DESCRIPTOR {
+        self.descriptor_ptr
+    }
+}
+
+impl Drop for SecurityDescriptor {
+    fn drop(&mut self) {
+        if !self.descriptor_ptr.is_null() {
+            unsafe { LocalFree(self.descriptor_ptr) };
+            self.descriptor_ptr = ptr::null_mut();
+        }
+    }
+}
+
+struct InnerAttributes {
+    descriptor: SecurityDescriptor,
+    acl: Acl,
+    attrs: SECURITY_ATTRIBUTES,
+}
+
+impl InnerAttributes {
+    fn empty() -> io::Result<InnerAttributes> {
+        let descriptor = SecurityDescriptor::new()?;
+        let mut attrs = unsafe { mem::zeroed::<SECURITY_ATTRIBUTES>() };
+        attrs.nLength = mem::size_of::<SECURITY_ATTRIBUTES>() as u32;
+        attrs.lpSecurityDescriptor = unsafe { descriptor.as_ptr() };
+        attrs.bInheritHandle = false as i32;
+
+        let acl = Acl::empty().expect("this should never fail");
+
+        Ok(InnerAttributes {
+            acl,
+            descriptor,
+            attrs,
+        })
+    }
+
+    fn allow_everyone(permissions: u32) -> io::Result<InnerAttributes> {
+        let mut attributes = Self::empty()?;
+        let sid = Sid::everyone_sid()?;
+
+        let mut everyone_ace = AceWithSid::new(&sid, TRUSTEE_IS_WELL_KNOWN_GROUP);
+        everyone_ace
+            .set_access_mode(SET_ACCESS)
+            .set_access_permissions(permissions)
+            .allow_inheritance(false as u32);
+
+        let mut entries = vec![everyone_ace];
+        attributes.acl = Acl::new(&mut entries)?;
+        attributes.descriptor.set_dacl(&attributes.acl)?;
+
+        Ok(attributes)
+    }
+
+    unsafe fn as_ptr(&mut self) -> PSECURITY_ATTRIBUTES {
+        &mut self.attrs as *mut _
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::SecurityAttributes;
+
+    #[test]
+    fn test_allow_everyone_everything() {
+        SecurityAttributes::allow_everyone_create()
+            .expect("failed to create security attributes that allow everyone to create a pipe");
+    }
+
+    #[test]
+    fn test_allow_eveyone_read_write() {
+        SecurityAttributes::empty()
+            .allow_everyone_connect()
+            .expect("failed to create security attributes that allow everyone to read and write to/from a pipe");
+    }
+
+}

libs/pulsectl/.gitignore

@@ -0,0 +1,4 @@
+**/target
+/target
+**/*.rs.bk
+.idea/

libs/pulsectl/Cargo.lock

@@ -0,0 +1,129 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+[[package]]
+name = "autocfg"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cdb031dd78e28731d87d56cc8ffef4a8f36ca26c38fe2de700543e627f8a464a"
+
+[[package]]
+name = "libc"
+version = "0.2.65"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a31a0627fdf1f6a39ec0dd577e101440b7db22672c0901fe00a9a6fbb5c24e8"
+
+[[package]]
+name = "libpulse-binding"
+version = "2.18.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fe925a4d3a96961316c9c1488f97a95938a6093f0d4691eec888776057ce965e"
+dependencies = [
+ "libc",
+ "libpulse-sys",
+ "num-derive",
+ "num-traits",
+ "winapi",
+]
+
+[[package]]
+name = "libpulse-sys"
+version = "1.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2d9073c83dda6aff9b611dc368e8db6e0aa29027546d8800a18b4417e182b4d5"
+dependencies = [
+ "libc",
+ "num-derive",
+ "num-traits",
+ "pkg-config",
+ "winapi",
+]
+
+[[package]]
+name = "num-derive"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "876a53fff98e03a936a674b29568b0e605f06b29372c2489ff4de23f1949743d"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a64b1ec5cda2586e284722486d802acf1f7dbdc623e2bfc57e65ca1cd099290"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "pkg-config"
+version = "0.3.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05da548ad6865900e60eaba7f589cc0783590a92e940c26953ff81ddbab2d677"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e0704ee1a7e00d7bb417d0770ea303c1bccbabf0ef1667dae92b5967f5f8a71"
+dependencies = [
+ "unicode-xid",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aa563d17ecb180e500da1cfd2b028310ac758de548efdd203e18f283af693f37"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rust-pulsectl"
+version = "0.2.9"
+dependencies = [
+ "libpulse-binding",
+]
+
+[[package]]
+name = "syn"
+version = "1.0.51"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b4f34193997d92804d359ed09953e25d5138df6bcc055a71bf68ee89fdf9223"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-xid",
+]
+
+[[package]]
+name = "unicode-xid"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f7fe0bb3479651439c9112f72b6c505038574c9fbb575ed1bf3b797fa39dd564"
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"

libs/pulsectl/Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+name = "rust-pulsectl"
+version = "0.2.10"
+authors = ["Kristopher Ruzic <krruzic@gmail.com>"]
+edition = "2018"
+license = "GPL-3.0+"
+description = "A higher level API for libpulse_binding"
+readme = "README.md"
+keywords = ["pulse", "pulseaudio", "binding", "audio", "api"]
+categories = ["api-bindings", "multimedia::audio"]
+homepage = "https://github.com/krruzic/pulsectl"
+repository = "https://github.com/krruzic/pulsectl"
+
+[lib]
+name = "pulsectl"
+path = "src/lib.rs"
+
+[dependencies]
+libpulse-binding = "2.21"

libs/pulsectl/LICENSE.md

@@ -0,0 +1,13 @@
+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 <http://www.gnu.org/licenses/>.
+

libs/pulsectl/README.md

@@ -0,0 +1,43 @@
+Rust PulsecAudio API
+====================
+
+`pulsectl-rust` is a API wrapper for `libpulse_binding` to make pulseaudio application development easier.
+This is a wrapper around the introspector, and thus this library is only capable of modifying PulseAudio data (changing volume, routing applications and muting right now).
+
+### Usage
+
+Add this to your `Cargo.toml`:
+```toml
+[dependencies]
+rust-pulsectl = "0.2.6"
+```
+
+Then, connect to PulseAudio by creating a `SinkController` for audio playback devices and apps or a `SourceController` for audio recording devices and apps.
+
+```rust
+// Simple application that lists all playback devices and their status
+// See examples/change_device_vol.rs for a more complete example
+extern crate pulsectl;
+
+use std::io;
+
+use pulsectl::controllers::SinkController;
+use pulsectl::controllers::DeviceControl;
+fn main() {
+    // create handler that calls functions on playback devices and apps
+    let mut handler = SinkController::create();
+    let devices = handler
+        .list_devices()
+        .expect("Could not get list of playback devices");
+    println!("Playback Devices");
+    for dev in devices.clone() {
+        println!(
+            "[{}] {}, [Volume: {}]",
+            dev.index,
+            dev.description.as_ref().unwrap(),
+            dev.volume.print()
+        );
+    }
+}
+```
+

libs/pulsectl/examples/change_device_vol.rs

@@ -0,0 +1,34 @@
+extern crate pulsectl;
+
+use std::io;
+
+use pulsectl::controllers::DeviceControl;
+use pulsectl::controllers::SinkController;
+
+fn main() {
+    // create handler that calls functions on playback devices and apps
+    let mut handler = SinkController::create().unwrap();
+    let devices = handler
+        .list_devices()
+        .expect("Could not get list of playback devices");
+
+    println!("Playback Devices");
+    for dev in devices.clone() {
+        println!(
+            "[{}] {}, [Volume: {}]",
+            dev.index,
+            dev.description.as_ref().unwrap(),
+            dev.volume.print()
+        );
+    }
+    let mut selection = String::new();
+
+    io::stdin()
+        .read_line(&mut selection)
+        .expect("error: unable to read user input");
+    for dev in devices.clone() {
+        if let true = selection.trim() == dev.index.to_string() {
+            handler.increase_device_volume_by_percent(dev.index, 0.05);
+        }
+    }
+}

libs/pulsectl/src/controllers/errors.rs

@@ -0,0 +1,51 @@
+use std::fmt;
+
+use crate::PulseCtlError;
+
+/// if the error occurs within the Mainloop, we bubble up the error with
+/// this conversion
+impl From<PulseCtlError> for ControllerError {
+    fn from(error: super::errors::PulseCtlError) -> Self {
+        ControllerError {
+            error: ControllerErrorType::PulseCtlError,
+            message: format!("{:?}", error),
+        }
+    }
+}
+
+impl fmt::Debug for ControllerError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let mut error_string = String::new();
+        match self.error {
+            ControllerErrorType::PulseCtlError => {
+                error_string.push_str("PulseCtlError");
+            }
+            ControllerErrorType::GetInfoError => {
+                error_string.push_str("GetInfoError");
+            }
+        }
+        write!(f, "[{}]: {}", error_string, self.message)
+    }
+}
+
+pub(crate) enum ControllerErrorType {
+    PulseCtlError,
+    GetInfoError,
+}
+
+/// Error thrown while fetching data from pulseaudio,
+/// has two variants: PulseCtlError for when PulseAudio returns an error code
+/// and GetInfoError when a request for data fails for whatever reason
+pub struct ControllerError {
+    error: ControllerErrorType,
+    message: String,
+}
+
+impl ControllerError {
+    pub(crate) fn new(err: ControllerErrorType, msg: &str) -> Self {
+        ControllerError {
+            error: err,
+            message: msg.to_string(),
+        }
+    }
+}

libs/pulsectl/src/controllers/mod.rs

@@ -0,0 +1,595 @@
+/// Source = microphone etc. something that takes in audio
+/// Source Output = application consuming that audio
+///
+/// Sink = headphones etc. something that plays out audio
+/// Sink Input = application producing that audio
+/// When you create a `SinkController`, you are working with audio playback devices and applications
+/// if you want to manipulate recording devices such as microphone volume,
+/// you'll need to use a `SourceController`. Both of these implement the same api, defined by
+/// the traits DeviceControl and AppControl
+use std::cell::RefCell;
+use std::clone::Clone;
+use std::rc::Rc;
+
+use pulse::{
+    callbacks::ListResult,
+    context::introspect,
+    volume::{ChannelVolumes, Volume},
+};
+
+use errors::{ControllerError, ControllerErrorType::*};
+use types::{ApplicationInfo, DeviceInfo, ServerInfo};
+
+use crate::Handler;
+
+pub(crate) mod errors;
+pub mod types;
+
+pub trait DeviceControl<T> {
+    fn get_default_device(&mut self) -> Result<T, ControllerError>;
+    fn set_default_device(&mut self, name: &str) -> Result<bool, ControllerError>;
+
+    fn list_devices(&mut self) -> Result<Vec<T>, ControllerError>;
+    fn get_device_by_index(&mut self, index: u32) -> Result<T, ControllerError>;
+    fn get_device_by_name(&mut self, name: &str) -> Result<T, ControllerError>;
+    fn set_device_volume_by_index(&mut self, index: u32, volume: &ChannelVolumes);
+    fn set_device_volume_by_name(&mut self, name: &str, volume: &ChannelVolumes);
+    fn increase_device_volume_by_percent(&mut self, index: u32, delta: f64);
+    fn decrease_device_volume_by_percent(&mut self, index: u32, delta: f64);
+}
+
+pub trait AppControl<T> {
+    fn list_applications(&mut self) -> Result<Vec<T>, ControllerError>;
+
+    fn get_app_by_index(&mut self, index: u32) -> Result<T, ControllerError>;
+    fn increase_app_volume_by_percent(&mut self, index: u32, delta: f64);
+    fn decrease_app_volume_by_percent(&mut self, index: u32, delta: f64);
+
+    fn move_app_by_index(
+        &mut self,
+        stream_index: u32,
+        device_index: u32,
+    ) -> Result<bool, ControllerError>;
+    fn move_app_by_name(
+        &mut self,
+        stream_index: u32,
+        device_name: &str,
+    ) -> Result<bool, ControllerError>;
+    fn set_app_mute(&mut self, index: u32, mute: bool) -> Result<bool, ControllerError>;
+}
+
+fn volume_from_percent(volume: f64) -> f64 {
+    (volume * 100.0) * (f64::from(pulse::volume::VOLUME_NORM.0) / 100.0)
+}
+
+pub struct SinkController {
+    pub handler: Handler,
+}
+
+impl SinkController {
+    pub fn create() -> Result<Self, ControllerError> {
+        let handler = Handler::connect("SinkController")?;
+        Ok(SinkController { handler })
+    }
+
+    pub fn get_server_info(&mut self) -> Result<ServerInfo, ControllerError> {
+        let server = Rc::new(RefCell::new(Some(None)));
+        let server_ref = server.clone();
+
+        let op = self.handler.introspect.get_server_info(move |res| {
+            server_ref
+                .borrow_mut()
+                .as_mut()
+                .unwrap()
+                .replace(res.into());
+        });
+        self.handler.wait_for_operation(op)?;
+        let mut result = server.borrow_mut();
+        result.take().unwrap().ok_or(ControllerError::new(
+            GetInfoError,
+            "Error getting information about the server",
+        ))
+    }
+}
+
+impl DeviceControl<DeviceInfo> for SinkController {
+    fn get_default_device(&mut self) -> Result<DeviceInfo, ControllerError> {
+        let server_info = self.get_server_info();
+        match server_info {
+            Ok(info) => self.get_device_by_name(info.default_sink_name.unwrap().as_ref()),
+            Err(e) => Err(e),
+        }
+    }
+    fn set_default_device(&mut self, name: &str) -> Result<bool, ControllerError> {
+        let success = Rc::new(RefCell::new(false));
+        let success_ref = success.clone();
+
+        let op = self
+            .handler
+            .context
+            .borrow_mut()
+            .set_default_sink(name, move |res| success_ref.borrow_mut().clone_from(&res));
+        self.handler.wait_for_operation(op)?;
+        let result = success.borrow_mut().clone();
+        Ok(result)
+    }
+
+    fn list_devices(&mut self) -> Result<Vec<DeviceInfo>, ControllerError> {
+        let list = Rc::new(RefCell::new(Some(Vec::new())));
+        let list_ref = list.clone();
+
+        let op = self.handler.introspect.get_sink_info_list(
+            move |sink_list: ListResult<&introspect::SinkInfo>| {
+                if let ListResult::Item(item) = sink_list {
+                    list_ref.borrow_mut().as_mut().unwrap().push(item.into());
+                }
+            },
+        );
+        self.handler.wait_for_operation(op)?;
+        let mut result = list.borrow_mut();
+        result.take().ok_or(ControllerError::new(
+            GetInfoError,
+            "Error getting device list",
+        ))
+    }
+    fn get_device_by_index(&mut self, index: u32) -> Result<DeviceInfo, ControllerError> {
+        let device = Rc::new(RefCell::new(Some(None)));
+        let dev_ref = device.clone();
+        let op = self.handler.introspect.get_sink_info_by_index(
+            index,
+            move |sink_list: ListResult<&introspect::SinkInfo>| {
+                if let ListResult::Item(item) = sink_list {
+                    dev_ref.borrow_mut().as_mut().unwrap().replace(item.into());
+                }
+            },
+        );
+        self.handler.wait_for_operation(op)?;
+        let mut result = device.borrow_mut();
+        result.take().unwrap().ok_or(ControllerError::new(
+            GetInfoError,
+            "Error getting requested device",
+        ))
+    }
+    fn get_device_by_name(&mut self, name: &str) -> Result<DeviceInfo, ControllerError> {
+        let device = Rc::new(RefCell::new(Some(None)));
+        let dev_ref = device.clone();
+        let op = self.handler.introspect.get_sink_info_by_name(
+            name,
+            move |sink_list: ListResult<&introspect::SinkInfo>| {
+                if let ListResult::Item(item) = sink_list {
+                    dev_ref.borrow_mut().as_mut().unwrap().replace(item.into());
+                }
+            },
+        );
+        self.handler.wait_for_operation(op)?;
+        let mut result = device.borrow_mut();
+        result.take().unwrap().ok_or(ControllerError::new(
+            GetInfoError,
+            "Error getting requested device",
+        ))
+    }
+
+    fn set_device_volume_by_index(&mut self, index: u32, volume: &ChannelVolumes) {
+        let op = self
+            .handler
+            .introspect
+            .set_sink_volume_by_index(index, volume, None);
+        self.handler.wait_for_operation(op).ok();
+    }
+    fn set_device_volume_by_name(&mut self, name: &str, volume: &ChannelVolumes) {
+        let op = self
+            .handler
+            .introspect
+            .set_sink_volume_by_name(name, volume, None);
+        self.handler.wait_for_operation(op).ok();
+    }
+    fn increase_device_volume_by_percent(&mut self, index: u32, delta: f64) {
+        if let Ok(mut dev_ref) = self.get_device_by_index(index) {
+            let new_vol = Volume::from(Volume(volume_from_percent(delta) as u32));
+            if let Some(volumes) = dev_ref.volume.increase(new_vol) {
+                let op = self
+                    .handler
+                    .introspect
+                    .set_sink_volume_by_index(index, &volumes, None);
+                self.handler.wait_for_operation(op).ok();
+            }
+        }
+    }
+    fn decrease_device_volume_by_percent(&mut self, index: u32, delta: f64) {
+        if let Ok(mut dev_ref) = self.get_device_by_index(index) {
+            let new_vol = Volume::from(Volume(volume_from_percent(delta) as u32));
+            if let Some(volumes) = dev_ref.volume.decrease(new_vol) {
+                let op = self
+                    .handler
+                    .introspect
+                    .set_sink_volume_by_index(index, &volumes, None);
+                self.handler.wait_for_operation(op).ok();
+            }
+        }
+    }
+}
+
+impl AppControl<ApplicationInfo> for SinkController {
+    fn list_applications(&mut self) -> Result<Vec<ApplicationInfo>, ControllerError> {
+        let list = Rc::new(RefCell::new(Some(Vec::new())));
+        let list_ref = list.clone();
+
+        let op = self.handler.introspect.get_sink_input_info_list(
+            move |sink_list: ListResult<&introspect::SinkInputInfo>| {
+                if let ListResult::Item(item) = sink_list {
+                    list_ref.borrow_mut().as_mut().unwrap().push(item.into());
+                }
+            },
+        );
+        self.handler.wait_for_operation(op)?;
+        let mut result = list.borrow_mut();
+        result.take().ok_or(ControllerError::new(
+            GetInfoError,
+            "Error getting application list",
+        ))
+    }
+
+    fn get_app_by_index(&mut self, index: u32) -> Result<ApplicationInfo, ControllerError> {
+        let app = Rc::new(RefCell::new(Some(None)));
+        let app_ref = app.clone();
+        let op = self.handler.introspect.get_sink_input_info(
+            index,
+            move |sink_list: ListResult<&introspect::SinkInputInfo>| {
+                if let ListResult::Item(item) = sink_list {
+                    app_ref.borrow_mut().as_mut().unwrap().replace(item.into());
+                }
+            },
+        );
+        self.handler.wait_for_operation(op)?;
+        let mut result = app.borrow_mut();
+        result.take().unwrap().ok_or(ControllerError::new(
+            GetInfoError,
+            "Error getting requested app",
+        ))
+    }
+
+    fn increase_app_volume_by_percent(&mut self, index: u32, delta: f64) {
+        if let Ok(mut app_ref) = self.get_app_by_index(index) {
+            let new_vol = Volume::from(Volume(volume_from_percent(delta) as u32));
+            if let Some(volumes) = app_ref.volume.increase(new_vol) {
+                let op = self
+                    .handler
+                    .introspect
+                    .set_sink_input_volume(index, &volumes, None);
+                self.handler.wait_for_operation(op).ok();
+            }
+        }
+    }
+
+    fn decrease_app_volume_by_percent(&mut self, index: u32, delta: f64) {
+        if let Ok(mut app_ref) = self.get_app_by_index(index) {
+            let new_vol = Volume::from(Volume(volume_from_percent(delta) as u32));
+            if let Some(volumes) = app_ref.volume.decrease(new_vol) {
+                let op = self
+                    .handler
+                    .introspect
+                    .set_sink_input_volume(index, &volumes, None);
+                self.handler.wait_for_operation(op).ok();
+            }
+        }
+    }
+
+    fn move_app_by_index(
+        &mut self,
+        stream_index: u32,
+        device_index: u32,
+    ) -> Result<bool, ControllerError> {
+        let success = Rc::new(RefCell::new(false));
+        let success_ref = success.clone();
+        let op = self.handler.introspect.move_sink_input_by_index(
+            stream_index,
+            device_index,
+            Some(Box::new(move |res| {
+                success_ref.borrow_mut().clone_from(&res)
+            })),
+        );
+        self.handler.wait_for_operation(op)?;
+        let result = success.borrow_mut().clone();
+        Ok(result)
+    }
+
+    fn move_app_by_name(
+        &mut self,
+        stream_index: u32,
+        device_name: &str,
+    ) -> Result<bool, ControllerError> {
+        let success = Rc::new(RefCell::new(false));
+        let success_ref = success.clone();
+        let op = self.handler.introspect.move_sink_input_by_name(
+            stream_index,
+            device_name,
+            Some(Box::new(move |res| {
+                success_ref.borrow_mut().clone_from(&res)
+            })),
+        );
+        self.handler.wait_for_operation(op)?;
+        let result = success.borrow_mut().clone();
+        Ok(result)
+    }
+
+    fn set_app_mute(&mut self, index: u32, mute: bool) -> Result<bool, ControllerError> {
+        let success = Rc::new(RefCell::new(false));
+        let success_ref = success.clone();
+        let op = self.handler.introspect.set_sink_input_mute(
+            index,
+            mute,
+            Some(Box::new(move |res| {
+                success_ref.borrow_mut().clone_from(&res)
+            })),
+        );
+        self.handler.wait_for_operation(op)?;
+        let result = success.borrow_mut().clone();
+        Ok(result)
+    }
+}
+
+pub struct SourceController {
+    pub handler: Handler,
+}
+
+impl SourceController {
+    pub fn create() -> Result<Self, ControllerError> {
+        let handler = Handler::connect("SourceController")?;
+        Ok(SourceController { handler })
+    }
+
+    pub fn get_server_info(&mut self) -> Result<ServerInfo, ControllerError> {
+        let server = Rc::new(RefCell::new(Some(None)));
+        let server_ref = server.clone();
+
+        let op = self.handler.introspect.get_server_info(move |res| {
+            server_ref
+                .borrow_mut()
+                .as_mut()
+                .unwrap()
+                .replace(res.into());
+        });
+        self.handler.wait_for_operation(op)?;
+        let mut result = server.borrow_mut();
+        result.take().unwrap().ok_or(ControllerError::new(
+            GetInfoError,
+            "Error getting application list",
+        ))
+    }
+}
+
+impl DeviceControl<DeviceInfo> for SourceController {
+    fn get_default_device(&mut self) -> Result<DeviceInfo, ControllerError> {
+        let server_info = self.get_server_info();
+        match server_info {
+            Ok(info) => self.get_device_by_name(info.default_sink_name.unwrap().as_ref()),
+            Err(e) => Err(e),
+        }
+    }
+    fn set_default_device(&mut self, name: &str) -> Result<bool, ControllerError> {
+        let success = Rc::new(RefCell::new(false));
+        let success_ref = success.clone();
+
+        let op = self
+            .handler
+            .context
+            .borrow_mut()
+            .set_default_source(name, move |res| success_ref.borrow_mut().clone_from(&res));
+        self.handler.wait_for_operation(op)?;
+        let result = success.borrow_mut().clone();
+        Ok(result)
+    }
+
+    fn list_devices(&mut self) -> Result<Vec<DeviceInfo>, ControllerError> {
+        let list = Rc::new(RefCell::new(Some(Vec::new())));
+        let list_ref = list.clone();
+
+        let op = self.handler.introspect.get_source_info_list(
+            move |sink_list: ListResult<&introspect::SourceInfo>| {
+                if let ListResult::Item(item) = sink_list {
+                    list_ref.borrow_mut().as_mut().unwrap().push(item.into());
+                }
+            },
+        );
+        self.handler.wait_for_operation(op)?;
+        let mut result = list.borrow_mut();
+        result.take().ok_or(ControllerError::new(
+            GetInfoError,
+            "Error getting application list",
+        ))
+    }
+    fn get_device_by_index(&mut self, index: u32) -> Result<DeviceInfo, ControllerError> {
+        let device = Rc::new(RefCell::new(Some(None)));
+        let dev_ref = device.clone();
+        let op = self.handler.introspect.get_source_info_by_index(
+            index,
+            move |sink_list: ListResult<&introspect::SourceInfo>| {
+                if let ListResult::Item(item) = sink_list {
+                    dev_ref.borrow_mut().as_mut().unwrap().replace(item.into());
+                }
+            },
+        );
+        self.handler.wait_for_operation(op)?;
+        let mut result = device.borrow_mut();
+        result.take().unwrap().ok_or(ControllerError::new(
+            GetInfoError,
+            "Error getting application list",
+        ))
+    }
+    fn get_device_by_name(&mut self, name: &str) -> Result<DeviceInfo, ControllerError> {
+        let device = Rc::new(RefCell::new(Some(None)));
+        let dev_ref = device.clone();
+        let op = self.handler.introspect.get_source_info_by_name(
+            name,
+            move |sink_list: ListResult<&introspect::SourceInfo>| {
+                if let ListResult::Item(item) = sink_list {
+                    dev_ref.borrow_mut().as_mut().unwrap().replace(item.into());
+                }
+            },
+        );
+        self.handler.wait_for_operation(op)?;
+        let mut result = device.borrow_mut();
+        result.take().unwrap().ok_or(ControllerError::new(
+            GetInfoError,
+            "Error getting application list",
+        ))
+    }
+
+    fn set_device_volume_by_index(&mut self, index: u32, volume: &ChannelVolumes) {
+        let op = self
+            .handler
+            .introspect
+            .set_source_volume_by_index(index, volume, None);
+        self.handler.wait_for_operation(op).ok();
+    }
+    fn set_device_volume_by_name(&mut self, name: &str, volume: &ChannelVolumes) {
+        let op = self
+            .handler
+            .introspect
+            .set_source_volume_by_name(name, volume, None);
+        self.handler.wait_for_operation(op).ok();
+    }
+    fn increase_device_volume_by_percent(&mut self, index: u32, delta: f64) {
+        if let Ok(mut dev_ref) = self.get_device_by_index(index) {
+            let new_vol = Volume::from(Volume(volume_from_percent(delta) as u32));
+            if let Some(volumes) = dev_ref.volume.increase(new_vol) {
+                let op = self
+                    .handler
+                    .introspect
+                    .set_source_volume_by_index(index, &volumes, None);
+                self.handler.wait_for_operation(op).ok();
+            }
+        }
+    }
+    fn decrease_device_volume_by_percent(&mut self, index: u32, delta: f64) {
+        if let Ok(mut dev_ref) = self.get_device_by_index(index) {
+            let new_vol = Volume::from(Volume(volume_from_percent(delta) as u32));
+            if let Some(volumes) = dev_ref.volume.decrease(new_vol) {
+                let op = self
+                    .handler
+                    .introspect
+                    .set_source_volume_by_index(index, &volumes, None);
+                self.handler.wait_for_operation(op).ok();
+            }
+        }
+    }
+}
+
+impl AppControl<ApplicationInfo> for SourceController {
+    fn list_applications(&mut self) -> Result<Vec<ApplicationInfo>, ControllerError> {
+        let list = Rc::new(RefCell::new(Some(Vec::new())));
+        let list_ref = list.clone();
+
+        let op = self.handler.introspect.get_source_output_info_list(
+            move |sink_list: ListResult<&introspect::SourceOutputInfo>| {
+                if let ListResult::Item(item) = sink_list {
+                    list_ref.borrow_mut().as_mut().unwrap().push(item.into());
+                }
+            },
+        );
+        self.handler.wait_for_operation(op)?;
+        let mut result = list.borrow_mut();
+        result.take().ok_or(ControllerError::new(
+            GetInfoError,
+            "Error getting application list",
+        ))
+    }
+
+    fn get_app_by_index(&mut self, index: u32) -> Result<ApplicationInfo, ControllerError> {
+        let app = Rc::new(RefCell::new(Some(None)));
+        let app_ref = app.clone();
+        let op = self.handler.introspect.get_source_output_info(
+            index,
+            move |sink_list: ListResult<&introspect::SourceOutputInfo>| {
+                if let ListResult::Item(item) = sink_list {
+                    app_ref.borrow_mut().as_mut().unwrap().replace(item.into());
+                }
+            },
+        );
+        self.handler.wait_for_operation(op)?;
+        let mut result = app.borrow_mut();
+        result.take().unwrap().ok_or(ControllerError::new(
+            GetInfoError,
+            "Error getting application list",
+        ))
+    }
+
+    fn increase_app_volume_by_percent(&mut self, index: u32, delta: f64) {
+        if let Ok(mut app_ref) = self.get_app_by_index(index) {
+            let new_vol = Volume::from(Volume(volume_from_percent(delta) as u32));
+            if let Some(volumes) = app_ref.volume.increase(new_vol) {
+                let op = self
+                    .handler
+                    .introspect
+                    .set_source_output_volume(index, &volumes, None);
+                self.handler.wait_for_operation(op).ok();
+            }
+        }
+    }
+
+    fn decrease_app_volume_by_percent(&mut self, index: u32, delta: f64) {
+        if let Ok(mut app_ref) = self.get_app_by_index(index) {
+            let new_vol = Volume::from(Volume(volume_from_percent(delta) as u32));
+            if let Some(volumes) = app_ref.volume.decrease(new_vol) {
+                let op = self
+                    .handler
+                    .introspect
+                    .set_source_output_volume(index, &volumes, None);
+                self.handler.wait_for_operation(op).ok();
+            }
+        }
+    }
+
+    fn move_app_by_index(
+        &mut self,
+        stream_index: u32,
+        device_index: u32,
+    ) -> Result<bool, ControllerError> {
+        let success = Rc::new(RefCell::new(false));
+        let success_ref = success.clone();
+        let op = self.handler.introspect.move_source_output_by_index(
+            stream_index,
+            device_index,
+            Some(Box::new(move |res| {
+                success_ref.borrow_mut().clone_from(&res)
+            })),
+        );
+        self.handler.wait_for_operation(op)?;
+        let result = success.borrow_mut().clone();
+        Ok(result)
+    }
+
+    fn move_app_by_name(
+        &mut self,
+        stream_index: u32,
+        device_name: &str,
+    ) -> Result<bool, ControllerError> {
+        let success = Rc::new(RefCell::new(false));
+        let success_ref = success.clone();
+        let op = self.handler.introspect.move_source_output_by_name(
+            stream_index,
+            device_name,
+            Some(Box::new(move |res| {
+                success_ref.borrow_mut().clone_from(&res)
+            })),
+        );
+        self.handler.wait_for_operation(op)?;
+        let result = success.borrow_mut().clone();
+        Ok(result)
+    }
+
+    fn set_app_mute(&mut self, index: u32, mute: bool) -> Result<bool, ControllerError> {
+        let success = Rc::new(RefCell::new(false));
+        let success_ref = success.clone();
+        let op = self.handler.introspect.set_source_mute_by_index(
+            index,
+            mute,
+            Some(Box::new(move |res| {
+                success_ref.borrow_mut().clone_from(&res)
+            })),
+        );
+        self.handler.wait_for_operation(op)?;
+        let result = success.borrow_mut().clone();
+        Ok(result)
+    }
+}

libs/pulsectl/src/controllers/types.rs

@@ -0,0 +1,354 @@
+use pulse::{
+    channelmap,
+    context::introspect,
+    def,
+    def::PortAvailable,
+    format,
+    proplist::Proplist,
+    sample,
+    time::MicroSeconds,
+    volume::{ChannelVolumes, Volume},
+};
+
+/// These structs are direct representations of what libpulse_binding gives
+/// created to be copyable / cloneable for use in and out of callbacks
+
+/// This is a wrapper around SinkPortInfo and SourcePortInfo as they have the same members
+#[derive(Clone)]
+pub struct DevicePortInfo {
+    /// Name of the sink.
+    pub name: Option<String>,
+    /// Description of this sink.
+    pub description: Option<String>,
+    /// The higher this value is, the more useful this port is as a default.
+    pub priority: u32,
+    /// A flag indicating availability status of this port.
+    pub available: PortAvailable,
+}
+
+impl<'a> From<&'a Box<introspect::SinkPortInfo<'a>>> for DevicePortInfo {
+    fn from(item: &'a Box<introspect::SinkPortInfo<'a>>) -> Self {
+        DevicePortInfo {
+            name: item.name.as_ref().map(|cow| cow.to_string()),
+            description: item.description.as_ref().map(|cow| cow.to_string()),
+            priority: item.priority,
+            available: item.available,
+        }
+    }
+}
+
+impl<'a> From<&'a introspect::SinkPortInfo<'a>> for DevicePortInfo {
+    fn from(item: &'a introspect::SinkPortInfo<'a>) -> Self {
+        DevicePortInfo {
+            name: item.name.as_ref().map(|cow| cow.to_string()),
+            description: item.description.as_ref().map(|cow| cow.to_string()),
+            priority: item.priority,
+            available: item.available,
+        }
+    }
+}
+
+impl<'a> From<&'a Box<introspect::SourcePortInfo<'a>>> for DevicePortInfo {
+    fn from(item: &'a Box<introspect::SourcePortInfo<'a>>) -> Self {
+        DevicePortInfo {
+            name: item.name.as_ref().map(|cow| cow.to_string()),
+            description: item.description.as_ref().map(|cow| cow.to_string()),
+            priority: item.priority,
+            available: item.available,
+        }
+    }
+}
+
+impl<'a> From<&'a introspect::SourcePortInfo<'a>> for DevicePortInfo {
+    fn from(item: &'a introspect::SourcePortInfo<'a>) -> Self {
+        DevicePortInfo {
+            name: item.name.as_ref().map(|cow| cow.to_string()),
+            description: item.description.as_ref().map(|cow| cow.to_string()),
+            priority: item.priority,
+            available: item.available,
+        }
+    }
+}
+
+/// This is a wrapper around SinkState and SourceState as they have the same values
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum DevState {
+    /// This state is used when the server does not support sink state introspection.
+    Invalid = -1,
+    /// Running, sink is playing and used by at least one non-corked sink-input.
+    Running = 0,
+    /// When idle, the sink is playing but there is no non-corked sink-input attached to it.
+    Idle = 1,
+    /// When suspended, actual sink access can be closed, for instance.
+    Suspended = 2,
+}
+
+impl<'a> From<def::SourceState> for DevState {
+    fn from(s: def::SourceState) -> Self {
+        match s {
+            def::SourceState::Idle => DevState::Idle,
+            def::SourceState::Invalid => DevState::Invalid,
+            def::SourceState::Running => DevState::Running,
+            def::SourceState::Suspended => DevState::Suspended,
+        }
+    }
+}
+
+impl<'a> From<def::SinkState> for DevState {
+    fn from(s: def::SinkState) -> Self {
+        match s {
+            def::SinkState::Idle => DevState::Idle,
+            def::SinkState::Invalid => DevState::Invalid,
+            def::SinkState::Running => DevState::Running,
+            def::SinkState::Suspended => DevState::Suspended,
+        }
+    }
+}
+
+#[derive(Clone)]
+pub enum Flags {
+    SourceFLags(def::SourceFlagSet),
+    SinkFlags(def::SinkFlagSet),
+}
+
+#[derive(Clone)]
+pub struct DeviceInfo {
+    /// Index of the sink.
+    pub index: u32,
+    /// Name of the sink.
+    pub name: Option<String>,
+    /// Description of this sink.
+    pub description: Option<String>,
+    /// Sample spec of this sink.
+    pub sample_spec: sample::Spec,
+    /// Channel map.
+    pub channel_map: channelmap::Map,
+    /// Index of the owning module of this sink, or `None` if is invalid.
+    pub owner_module: Option<u32>,
+    /// Volume of the sink.
+    pub volume: ChannelVolumes,
+    /// Mute switch of the sink.
+    pub mute: bool,
+    /// Index of the monitor source connected to this sink.
+    pub monitor: Option<u32>,
+    /// The name of the monitor source.
+    pub monitor_name: Option<String>,
+    /// Length of queued audio in the output buffer.
+    pub latency: MicroSeconds,
+    /// Driver name.
+    pub driver: Option<String>,
+    /// Flags.
+    pub flags: Flags,
+    /// Property list.
+    pub proplist: Proplist,
+    /// The latency this device has been configured to.
+    pub configured_latency: MicroSeconds,
+    /// Some kind of “base” volume that refers to unamplified/unattenuated volume in the context of
+    /// the output device.
+    pub base_volume: Volume,
+    /// State.
+    pub state: DevState,
+    /// Number of volume steps for sinks which do not support arbitrary volumes.
+    pub n_volume_steps: u32,
+    /// Card index, or `None` if invalid.
+    pub card: Option<u32>,
+    /// Set of available ports.
+    pub ports: Vec<DevicePortInfo>,
+    // Pointer to active port in the set, or None.
+    pub active_port: Option<DevicePortInfo>,
+    /// Set of formats supported by the sink.
+    pub formats: Vec<format::Info>,
+}
+
+impl<'a> From<&'a introspect::SinkInfo<'a>> for DeviceInfo {
+    fn from(item: &'a introspect::SinkInfo<'a>) -> Self {
+        DeviceInfo {
+            name: item.name.as_ref().map(|cow| cow.to_string()),
+            index: item.index,
+            description: item.description.as_ref().map(|cow| cow.to_string()),
+            sample_spec: item.sample_spec,
+            channel_map: item.channel_map,
+            owner_module: item.owner_module,
+            volume: item.volume,
+            mute: item.mute,
+            monitor: Some(item.monitor_source),
+            monitor_name: item.monitor_source_name.as_ref().map(|cow| cow.to_string()),
+            latency: item.latency,
+            driver: item.driver.as_ref().map(|cow| cow.to_string()),
+            flags: Flags::SinkFlags(item.flags),
+            proplist: item.proplist.clone(),
+            configured_latency: item.configured_latency,
+            base_volume: item.base_volume,
+            state: DevState::from(item.state),
+            n_volume_steps: item.n_volume_steps,
+            card: item.card,
+            ports: item.ports.iter().map(From::from).collect(),
+            active_port: item.active_port.as_ref().map(From::from),
+            formats: item.formats.clone(),
+        }
+    }
+}
+
+impl<'a> From<&'a introspect::SourceInfo<'a>> for DeviceInfo {
+    fn from(item: &'a introspect::SourceInfo<'a>) -> Self {
+        DeviceInfo {
+            name: item.name.as_ref().map(|cow| cow.to_string()),
+            index: item.index,
+            description: item.description.as_ref().map(|cow| cow.to_string()),
+            sample_spec: item.sample_spec,
+            channel_map: item.channel_map,
+            owner_module: item.owner_module,
+            volume: item.volume,
+            mute: item.mute,
+            monitor: item.monitor_of_sink,
+            monitor_name: item
+                .monitor_of_sink_name
+                .as_ref()
+                .map(|cow| cow.to_string()),
+            latency: item.latency,
+            driver: item.driver.as_ref().map(|cow| cow.to_string()),
+            flags: Flags::SourceFLags(item.flags),
+            proplist: item.proplist.clone(),
+            configured_latency: item.configured_latency,
+            base_volume: item.base_volume,
+            state: DevState::from(item.state),
+            n_volume_steps: item.n_volume_steps,
+            card: item.card,
+            ports: item.ports.iter().map(From::from).collect(),
+            active_port: item.active_port.as_ref().map(From::from),
+            formats: item.formats.clone(),
+        }
+    }
+}
+
+#[derive(Clone)]
+pub struct ApplicationInfo {
+    /// Index of the sink input.
+    pub index: u32,
+    /// Name of the sink input.
+    pub name: Option<String>,
+    /// Index of the module this sink input belongs to, or `None` when it does not belong to any
+    /// module.
+    pub owner_module: Option<u32>,
+    /// Index of the client this sink input belongs to, or invalid when it does not belong to any
+    /// client.
+    pub client: Option<u32>,
+    /// Index of the connected sink/source.
+    pub connection_id: u32,
+    /// The sample specification of the sink input.
+    pub sample_spec: sample::Spec,
+    /// Channel map.
+    pub channel_map: channelmap::Map,
+    /// The volume of this sink input.
+    pub volume: ChannelVolumes,
+    /// Latency due to buffering in sink input, see
+    /// [`def::TimingInfo`](../../def/struct.TimingInfo.html) for details.
+    pub buffer_usec: MicroSeconds,
+    /// Latency of the sink device, see
+    /// [`def::TimingInfo`](../../def/struct.TimingInfo.html) for details.
+    pub connection_usec: MicroSeconds,
+    /// The resampling method used by this sink input.
+    pub resample_method: Option<String>,
+    /// Driver name.
+    pub driver: Option<String>,
+    /// Stream muted.
+    pub mute: bool,
+    /// Property list.
+    pub proplist: Proplist,
+    /// Stream corked.
+    pub corked: bool,
+    /// Stream has volume. If not set, then the meaning of this struct’s volume member is unspecified.
+    pub has_volume: bool,
+    /// The volume can be set. If not set, the volume can still change even though clients can’t
+    /// control the volume.
+    pub volume_writable: bool,
+    /// Stream format information.
+    pub format: format::Info,
+}
+
+impl<'a> From<&'a introspect::SinkInputInfo<'a>> for ApplicationInfo {
+    fn from(item: &'a introspect::SinkInputInfo<'a>) -> Self {
+        ApplicationInfo {
+            index: item.index,
+            name: item.name.as_ref().map(|cow| cow.to_string()),
+            owner_module: item.owner_module,
+            client: item.client,
+            connection_id: item.sink,
+            sample_spec: item.sample_spec,
+            channel_map: item.channel_map,
+            volume: item.volume,
+            buffer_usec: item.buffer_usec,
+            connection_usec: item.sink_usec,
+            resample_method: item.resample_method.as_ref().map(|cow| cow.to_string()),
+            driver: item.driver.as_ref().map(|cow| cow.to_string()),
+            mute: item.mute,
+            proplist: item.proplist.clone(),
+            corked: item.corked,
+            has_volume: item.has_volume,
+            volume_writable: item.volume_writable,
+            format: item.format.clone(),
+        }
+    }
+}
+
+impl<'a> From<&'a introspect::SourceOutputInfo<'a>> for ApplicationInfo {
+    fn from(item: &'a introspect::SourceOutputInfo<'a>) -> Self {
+        ApplicationInfo {
+            index: item.index,
+            name: item.name.as_ref().map(|cow| cow.to_string()),
+            owner_module: item.owner_module,
+            client: item.client,
+            connection_id: item.source,
+            sample_spec: item.sample_spec,
+            channel_map: item.channel_map,
+            volume: item.volume,
+            buffer_usec: item.buffer_usec,
+            connection_usec: item.source_usec,
+            resample_method: item.resample_method.as_ref().map(|cow| cow.to_string()),
+            driver: item.driver.as_ref().map(|cow| cow.to_string()),
+            mute: item.mute,
+            proplist: item.proplist.clone(),
+            corked: item.corked,
+            has_volume: item.has_volume,
+            volume_writable: item.volume_writable,
+            format: item.format.clone(),
+        }
+    }
+}
+
+pub struct ServerInfo {
+    /// User name of the daemon process.
+    pub user_name: Option<String>,
+    /// Host name the daemon is running on.
+    pub host_name: Option<String>,
+    /// Version string of the daemon.
+    pub server_version: Option<String>,
+    /// Server package name (usually “pulseaudio”).
+    pub server_name: Option<String>,
+    /// Default sample specification.
+    pub sample_spec: sample::Spec,
+    /// Name of default sink.
+    pub default_sink_name: Option<String>,
+    /// Name of default source.
+    pub default_source_name: Option<String>,
+    /// A random cookie for identifying this instance of PulseAudio.
+    pub cookie: u32,
+    /// Default channel map.
+    pub channel_map: channelmap::Map,
+}
+
+impl<'a> From<&'a introspect::ServerInfo<'a>> for ServerInfo {
+    fn from(info: &'a introspect::ServerInfo<'a>) -> Self {
+        ServerInfo {
+            user_name: info.user_name.as_ref().map(|cow| cow.to_string()),
+            host_name: info.host_name.as_ref().map(|cow| cow.to_string()),
+            server_version: info.server_version.as_ref().map(|cow| cow.to_string()),
+            server_name: info.server_name.as_ref().map(|cow| cow.to_string()),
+            sample_spec: info.sample_spec,
+            default_sink_name: info.default_sink_name.as_ref().map(|cow| cow.to_string()),
+            default_source_name: info.default_source_name.as_ref().map(|cow| cow.to_string()),
+            cookie: info.cookie,
+            channel_map: info.channel_map,
+        }
+    }
+}

libs/pulsectl/src/errors.rs

@@ -0,0 +1,54 @@
+use std::fmt;
+
+use pulse::error::{PAErr};
+
+impl From<PAErr> for PulseCtlError {
+    fn from(error: PAErr) -> Self {
+        PulseCtlError {
+            error: PulseCtlErrorType::PulseAudioError,
+            message: format!("PulseAudio returned error: {}", error.to_string().unwrap_or("Unknown".to_owned())),
+        }
+    }
+}
+
+impl fmt::Debug for PulseCtlError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let mut error_string = String::new();
+        match self.error {
+            PulseCtlErrorType::ConnectError => {
+                error_string.push_str("ConnectError");
+            }
+            PulseCtlErrorType::OperationError => {
+                error_string.push_str("OperationError");
+            }
+            PulseCtlErrorType::PulseAudioError => {
+                error_string.push_str("PulseAudioError");
+            }
+        }
+        write!(f, "[{}]: {}", error_string, self.message)
+    }
+}
+
+pub(crate) enum PulseCtlErrorType {
+    ConnectError,
+    OperationError,
+    PulseAudioError,
+}
+
+/// Error thrown when PulseAudio throws an error code, there are 3 variants
+/// `PulseCtlErrorType::ConnectError` when there's an error establishing a connection
+/// `PulseCtlErrorType::OperationError` when the requested operation quis unexpecdatly or is cancelled
+/// `PulseCtlErrorType::PulseAudioError` when PulseAudio returns an error code in any circumstance
+pub struct PulseCtlError {
+    error: PulseCtlErrorType,
+    message: String,
+}
+
+impl PulseCtlError {
+    pub(crate) fn new(err: PulseCtlErrorType, msg: &str) -> Self {
+        PulseCtlError {
+            error: err,
+            message: msg.to_string(),
+        }
+    }
+}

libs/pulsectl/src/lib.rs

@@ -0,0 +1,166 @@
+/// `pulsectl` is a high level wrapper around the PulseAudio bindings supplied by
+/// `libpulse_binding`. It provides simple access to sinks, inputs, sources and outputs allowing
+/// one to write audio control programs with ease.
+///
+/// ## Quick Example
+///
+/// The following example demonstrates listing all of the playback devices currently connected
+///
+/// See examples/change_device_vol.rs for a more complete example
+/// ```no_run
+/// extern crate pulsectl;
+///
+/// use std::io;
+///
+/// use pulsectl::controllers::SinkController;
+/// use pulsectl::controllers::DeviceControl;
+/// fn main() {
+///     // create handler that calls functions on playback devices and apps
+///     let mut handler = SinkController::create().unwrap();
+///     let devices = handler
+///         .list_devices()
+///        .expect("Could not get list of playback devices");
+///
+///     println!("Playback Devices");
+///     for dev in devices.clone() {
+///         println!(
+///             "[{}] {}, Volume: {}",
+///             dev.index,
+///             dev.description.as_ref().unwrap(),
+///             dev.volume.print()
+///         );
+///     }
+/// }
+/// ```
+extern crate libpulse_binding as pulse;
+
+use std::cell::RefCell;
+use std::ops::Deref;
+use std::rc::Rc;
+
+use pulse::{
+    context::{introspect, Context},
+    mainloop::standard::{IterateResult, Mainloop},
+    operation::{Operation, State},
+    proplist::Proplist,
+};
+
+use crate::errors::{PulseCtlError, PulseCtlErrorType::*};
+
+pub mod controllers;
+mod errors;
+
+pub struct Handler {
+    pub mainloop: Rc<RefCell<Mainloop>>,
+    pub context: Rc<RefCell<Context>>,
+    pub introspect: introspect::Introspector,
+}
+
+fn connect_error(err: &str) -> PulseCtlError {
+    PulseCtlError::new(ConnectError, err)
+}
+
+impl Handler {
+    pub fn connect(name: &str) -> Result<Handler, PulseCtlError> {
+        let mut proplist = Proplist::new().unwrap();
+        proplist
+            .set_str(pulse::proplist::properties::APPLICATION_NAME, name)
+            .unwrap();
+
+        let mainloop;
+        if let Some(m) = Mainloop::new() {
+            mainloop = Rc::new(RefCell::new(m));
+        } else {
+            return Err(connect_error("Failed to create mainloop"));
+        }
+
+        let context;
+        if let Some(c) =
+            Context::new_with_proplist(mainloop.borrow().deref(), "MainConn", &proplist)
+        {
+            context = Rc::new(RefCell::new(c));
+        } else {
+            return Err(connect_error("Failed to create new context"));
+        }
+
+        context
+            .borrow_mut()
+            .connect(None, pulse::context::flags::NOFLAGS, None)
+            .map_err(|_| connect_error("Failed to connect context"))?;
+
+        loop {
+            match mainloop.borrow_mut().iterate(false) {
+                IterateResult::Err(e) => {
+                    eprintln!("iterate state was not success, quitting...");
+                    return Err(e.into());
+                }
+                IterateResult::Success(_) => {}
+                IterateResult::Quit(_) => {
+                    eprintln!("iterate state was not success, quitting...");
+                    return Err(PulseCtlError::new(
+                        ConnectError,
+                        "Iterate state quit without an error",
+                    ));
+                }
+            }
+
+            match context.borrow().get_state() {
+                pulse::context::State::Ready => break,
+                pulse::context::State::Failed | pulse::context::State::Terminated => {
+                    eprintln!("context state failed/terminated, quitting...");
+                    return Err(PulseCtlError::new(
+                        ConnectError,
+                        "Context state failed/terminated without an error",
+                    ));
+                }
+                _ => {}
+            }
+        }
+
+        let introspect = context.borrow_mut().introspect();
+        Ok(Handler {
+            mainloop,
+            context,
+            introspect,
+        })
+    }
+
+    // loop until the passed operation is completed
+    pub fn wait_for_operation<G: ?Sized>(
+        &mut self,
+        op: Operation<G>,
+    ) -> Result<(), errors::PulseCtlError> {
+        loop {
+            match self.mainloop.borrow_mut().iterate(false) {
+                IterateResult::Err(e) => return Err(e.into()),
+                IterateResult::Success(_) => {}
+                IterateResult::Quit(_) => {
+                    return Err(PulseCtlError::new(
+                        OperationError,
+                        "Iterate state quit without an error",
+                    ));
+                }
+            }
+            match op.get_state() {
+                State::Done => {
+                    break;
+                }
+                State::Running => {}
+                State::Cancelled => {
+                    return Err(PulseCtlError::new(
+                        OperationError,
+                        "Operation cancelled without an error",
+                    ));
+                }
+            }
+        }
+        Ok(())
+    }
+}
+
+impl Drop for Handler {
+    fn drop(&mut self) {
+        self.context.borrow_mut().disconnect();
+        self.mainloop.borrow_mut().quit(pulse::def::Retval(0));
+    }
+}

libs/scrap/.gitignore

@@ -0,0 +1,4 @@
+/target/
+**/*.rs.bk
+Cargo.lock
+generated/

libs/scrap/Cargo.toml

@@ -0,0 +1,32 @@
+[package]
+name = "scrap"
+description = "Screen capture made easy."
+version = "0.5.0"
+repository = "https://github.com/quadrupleslap/scrap"
+documentation = "https://docs.rs/scrap"
+keywords = ["screen", "capture", "record"]
+license = "MIT"
+authors = ["Ram <quadrupleslap@gmail.com>"]
+edition = "2018"
+
+[dependencies]
+block = "0.1"
+cfg-if = "1.0"
+libc = "0.2"
+num_cpus = "1.13"
+
+[dependencies.winapi]
+version = "0.3"
+default-features = true
+features = ["dxgi", "dxgi1_2", "dxgi1_5", "d3d11"]
+
+[dev-dependencies]
+repng = "0.2"
+docopt = "1.1"
+webm = "1.0"
+serde = {version="1.0", features=["derive"]}
+quest = "0.3"
+
+[build-dependencies]
+target_build_utils = "0.3"
+bindgen = "0.53"

libs/scrap/README.md

@@ -0,0 +1,60 @@
+# scrap
+
+Scrap records your screen! At least it does if you're on Windows, macOS, or Linux.
+
+## Usage
+
+```toml
+[dependencies]
+scrap = "0.5"
+```
+
+Its API is as simple as it gets!
+
+```rust
+struct Display; /// A screen.
+struct Frame; /// An array of the pixels that were on-screen.
+struct Capturer; /// A recording instance.
+
+impl Capturer {
+    /// Begin recording.
+    pub fn new(display: Display) -> io::Result<Capturer>;
+
+    /// Try to get a frame.
+    /// Returns WouldBlock if it's not ready yet.
+    pub fn frame<'a>(&'a mut self) -> io::Result<Frame<'a>>;
+
+    pub fn width(&self) -> usize;
+    pub fn height(&self) -> usize;
+}
+
+impl Display {
+    /// The primary screen.
+    pub fn primary() -> io::Result<Display>;
+
+    /// All the screens.
+    pub fn all() -> io::Result<Vec<Display>>;
+
+    pub fn width(&self) -> usize;
+    pub fn height(&self) -> usize;
+}
+
+impl<'a> ops::Deref for Frame<'a> {
+    /// A frame is just an array of bytes.
+    type Target = [u8];
+}
+```
+
+## The Frame Format
+
+- The frame format is guaranteed to be **packed BGRA**.
+- The width and height are guaranteed to remain constant.
+- The stride might be greater than the width, and it may also vary between frames.
+
+## System Requirements
+
+OS      | Minimum Requirements
+--------|---------------------
+macOS   | macOS 10.8
+Linux   | XCB + SHM + RandR
+Windows | DirectX 11.1

libs/scrap/build.rs

@@ -0,0 +1,118 @@
+use std::{
+    env, fs,
+    path::{Path, PathBuf},
+};
+
+fn find_package(name: &str) -> Vec<PathBuf> {
+    let vcpkg_root = std::env::var("VCPKG_ROOT").unwrap();
+    let mut path: PathBuf = vcpkg_root.into();
+    let target_os = std::env::var("CARGO_CFG_TARGET_OS").unwrap();
+    let mut target_arch = std::env::var("CARGO_CFG_TARGET_ARCH").unwrap();
+    if target_arch == "x86_64" {
+        target_arch = "x64".to_owned();
+    } else if target_arch == "aarch64" {
+        target_arch = "arm64".to_owned();
+    } else {
+        target_arch = "arm".to_owned();
+    }
+    let target = if target_os == "macos" {
+        "x64-osx".to_owned()
+    } else if target_os == "windows" {
+        "x64-windows-static".to_owned()
+    } else if target_os == "android" {
+        format!("{}-android-static", target_arch)
+    } else {
+        "x64-linux".to_owned()
+    };
+    println!("cargo:info={}", target);
+    path.push("installed");
+    path.push(target);
+    let mut lib = name.trim_start_matches("lib").to_string();
+    if lib == "vpx" && target_os == "windows" {
+        lib = format!("{}mt", lib);
+    }
+    println!("{}", format!("cargo:rustc-link-lib={}", lib));
+    println!(
+        "{}",
+        format!(
+            "cargo:rustc-link-search={}",
+            path.join("lib").to_str().unwrap()
+        )
+    );
+    let include = path.join("include");
+    println!("{}", format!("cargo:include={}", include.to_str().unwrap()));
+    vec![include]
+}
+
+fn generate_bindings(
+    ffi_header: &Path,
+    include_paths: &[PathBuf],
+    ffi_rs: &Path,
+    exact_file: &Path,
+) {
+    let mut b = bindgen::builder()
+        .header(ffi_header.to_str().unwrap())
+        .whitelist_type("^[vV].*")
+        .whitelist_var("^[vV].*")
+        .whitelist_function("^[vV].*")
+        .rustified_enum("^v.*")
+        .trust_clang_mangling(false)
+        .layout_tests(false) // breaks 32/64-bit compat
+        .generate_comments(false); // vpx comments have prefix /*!\
+
+    for dir in include_paths {
+        b = b.clang_arg(format!("-I{}", dir.display()));
+    }
+
+    b.generate().unwrap().write_to_file(ffi_rs).unwrap();
+    fs::copy(ffi_rs, exact_file).ok(); // ignore failure
+}
+
+fn gen_vpx() {
+    let includes = find_package("libvpx");
+    let src_dir = env::var_os("CARGO_MANIFEST_DIR").unwrap();
+    let src_dir = Path::new(&src_dir);
+    let out_dir = env::var_os("OUT_DIR").unwrap();
+    let out_dir = Path::new(&out_dir);
+
+    let ffi_header = src_dir.join("vpx_ffi.h");
+    println!("rerun-if-changed={}", ffi_header.display());
+    for dir in &includes {
+        println!("rerun-if-changed={}", dir.display());
+    }
+
+    let ffi_rs = out_dir.join("vpx_ffi.rs");
+    let exact_file = src_dir.join("generated").join("vpx_ffi.rs");
+    generate_bindings(&ffi_header, &includes, &ffi_rs, &exact_file);
+}
+
+fn main() {
+    // note: all link symbol names in x86 (32-bit) are prefixed wth "_".
+    // run "rustup show" to show current default toolchain, if it is stable-x86-pc-windows-msvc,
+    // please install x64 toolchain by "rustup toolchain install stable-x86_64-pc-windows-msvc",
+    // then set x64 to default by "rustup default stable-x86_64-pc-windows-msvc"
+    let target = target_build_utils::TargetInfo::new();
+    if target.unwrap().target_pointer_width() != "64" {
+        panic!("Only support 64bit system");
+    }
+    env::remove_var("CARGO_CFG_TARGET_FEATURE");
+    env::set_var("CARGO_CFG_TARGET_FEATURE", "crt-static");
+
+    find_package("libyuv");
+    gen_vpx();
+
+    // there is problem with cfg(target_os) in build.rs, so use our workaround
+    let target_os = std::env::var("CARGO_CFG_TARGET_OS").unwrap();
+    if target_os == "android" || target_os == "ios" {
+        // nothing
+    } else if cfg!(windows) {
+        // The first choice is Windows because DXGI is amazing.
+        println!("cargo:rustc-cfg=dxgi");
+    } else if cfg!(target_os = "macos") {
+        // Quartz is second because macOS is the (annoying) exception.
+        println!("cargo:rustc-cfg=quartz");
+    } else if cfg!(unix) {
+        // On UNIX we pray that X11 (with XCB) is available.
+        println!("cargo:rustc-cfg=x11");
+    }
+}

libs/scrap/examples/ffplay.rs

@@ -0,0 +1,51 @@
+extern crate scrap;
+
+fn main() {
+    use scrap::{Capturer, Display};
+    use std::io::ErrorKind::WouldBlock;
+    use std::io::Write;
+    use std::process::{Command, Stdio};
+
+    let d = Display::primary().unwrap();
+    let (w, h) = (d.width(), d.height());
+
+    let child = Command::new("ffplay")
+        .args(&[
+            "-f",
+            "rawvideo",
+            "-pixel_format",
+            "bgr0",
+            "-video_size",
+            &format!("{}x{}", w, h),
+            "-framerate",
+            "60",
+            "-",
+        ])
+        .stdin(Stdio::piped())
+        .spawn()
+        .expect("This example requires ffplay.");
+
+    let mut capturer = Capturer::new(d, false).unwrap();
+    let mut out = child.stdin.unwrap();
+
+    loop {
+        match capturer.frame(0) {
+            Ok(frame) => {
+                // Write the frame, removing end-of-row padding.
+                let stride = frame.len() / h;
+                let rowlen = 4 * w;
+                for row in frame.chunks(stride) {
+                    let row = &row[..rowlen];
+                    out.write_all(row).unwrap();
+                }
+            }
+            Err(ref e) if e.kind() == WouldBlock => {
+                // Wait for the frame.
+            }
+            Err(_) => {
+                // We're done here.
+                break;
+            }
+        }
+    }
+}

libs/scrap/examples/list.rs

@@ -0,0 +1,16 @@
+extern crate scrap;
+
+use scrap::Display;
+
+fn main() {
+    let displays = Display::all().unwrap();
+
+    for (i, display) in displays.iter().enumerate() {
+        println!(
+            "Display {} [{}x{}]",
+            i + 1,
+            display.width(),
+            display.height()
+        );
+    }
+}

libs/scrap/examples/record-screen.rs

@@ -0,0 +1,161 @@
+extern crate docopt;
+extern crate quest;
+extern crate repng;
+extern crate scrap;
+extern crate serde;
+extern crate webm;
+
+use std::fs::{File, OpenOptions};
+use std::path::PathBuf;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::Arc;
+use std::time::{Duration, Instant};
+use std::{io, thread};
+
+use docopt::Docopt;
+use webm::mux;
+use webm::mux::Track;
+
+use scrap::codec as vpx_encode;
+use scrap::{Capturer, Display, STRIDE_ALIGN};
+
+const USAGE: &'static str = "
+Simple WebM screen capture.
+
+Usage:
+  record-screen <path> [--time=<s>] [--fps=<fps>] [--bv=<kbps>] [--ba=<kbps>] [--codec CODEC]
+  record-screen (-h | --help)
+
+Options:
+  -h --help      Show this screen.
+  --time=<s>     Recording duration in seconds.
+  --fps=<fps>    Frames per second [default: 30].
+  --bv=<kbps>    Video bitrate in kilobits per second [default: 5000].
+  --ba=<kbps>    Audio bitrate in kilobits per second [default: 96].
+  --codec CODEC  Configure the codec used. [default: vp9]
+                 Valid values: vp8, vp9.
+";
+
+#[derive(Debug, serde::Deserialize)]
+struct Args {
+    arg_path: PathBuf,
+    flag_codec: Codec,
+    flag_time: Option<u64>,
+    flag_fps: u64,
+    flag_bv: u32,
+    flag_ba: u32,
+}
+
+#[derive(Debug, serde::Deserialize)]
+enum Codec {
+    Vp8,
+    Vp9,
+}
+
+fn main() -> io::Result<()> {
+    let args: Args = Docopt::new(USAGE)
+        .and_then(|d| d.deserialize())
+        .unwrap_or_else(|e| e.exit());
+
+    let duration = args.flag_time.map(Duration::from_secs);
+
+    let d = Display::primary().unwrap();
+    let (width, height) = (d.width() as u32, d.height() as u32);
+
+    // Setup the multiplexer.
+
+    let out = match {
+        OpenOptions::new()
+            .write(true)
+            .create_new(true)
+            .open(&args.arg_path)
+    } {
+        Ok(file) => file,
+        Err(ref e) if e.kind() == io::ErrorKind::AlreadyExists => {
+            if loop {
+                quest::ask("Overwrite the existing file? [y/N] ");
+                if let Some(b) = quest::yesno(false)? {
+                    break b;
+                }
+            } {
+                File::create(&args.arg_path)?
+            } else {
+                return Ok(());
+            }
+        }
+        Err(e) => return Err(e.into()),
+    };
+
+    let mut webm =
+        mux::Segment::new(mux::Writer::new(out)).expect("Could not initialize the multiplexer.");
+
+    let (vpx_codec, mux_codec) = match args.flag_codec {
+        Codec::Vp8 => (vpx_encode::VideoCodecId::VP8, mux::VideoCodecId::VP8),
+        Codec::Vp9 => (vpx_encode::VideoCodecId::VP9, mux::VideoCodecId::VP9),
+    };
+
+    let mut vt = webm.add_video_track(width, height, None, mux_codec);
+
+    // Setup the encoder.
+
+    let mut vpx = vpx_encode::Encoder::new(
+        &vpx_encode::Config {
+            width,
+            height,
+            timebase: [1, 1000],
+            bitrate: args.flag_bv,
+            codec: vpx_codec,
+            rc_min_quantizer: 0,
+            rc_max_quantizer: 0,
+            speed: 6,
+        },
+        0,
+    )
+    .unwrap();
+
+    // Start recording.
+
+    let start = Instant::now();
+    let stop = Arc::new(AtomicBool::new(false));
+
+    thread::spawn({
+        let stop = stop.clone();
+        move || {
+            let _ = quest::ask("Recording! Press ⏎ to stop.");
+            let _ = quest::text();
+            stop.store(true, Ordering::Release);
+        }
+    });
+
+    let spf = Duration::from_nanos(1_000_000_000 / args.flag_fps);
+
+    // Capturer object is expensive, avoiding to create it frequently.
+    let mut c = Capturer::new(d, true).unwrap();
+    while !stop.load(Ordering::Acquire) {
+        let now = Instant::now();
+        let time = now - start;
+
+        if Some(true) == duration.map(|d| time > d) {
+            break;
+        }
+
+        if let Ok(frame) = c.frame(0) {
+            let ms = time.as_secs() * 1000 + time.subsec_millis() as u64;
+
+            for frame in vpx.encode(ms as i64, &frame, STRIDE_ALIGN).unwrap() {
+                vt.add_frame(frame.data, frame.pts as u64 * 1_000_000, frame.key);
+            }
+        }
+
+        let dt = now.elapsed();
+        if dt < spf {
+            thread::sleep(spf - dt);
+        }
+    }
+
+    // End things.
+
+    let _ = webm.finalize(None);
+
+    Ok(())
+}

libs/scrap/examples/screenshot.rs

@@ -0,0 +1,122 @@
+extern crate repng;
+extern crate scrap;
+
+use std::fs::File;
+use std::io::ErrorKind::WouldBlock;
+use std::thread;
+use std::time::Duration;
+
+use scrap::{i420_to_rgb, Capturer, Display};
+
+fn main() {
+    let n = Display::all().unwrap().len();
+    for i in 0..n {
+        record(i);
+    }
+}
+
+fn get_display(i: usize) -> Display {
+    Display::all().unwrap().remove(i)
+}
+
+fn record(i: usize) {
+    let one_second = Duration::new(1, 0);
+    let one_frame = one_second / 60;
+
+    let display = get_display(i);
+    let mut capturer = Capturer::new(display, false).expect("Couldn't begin capture.");
+    let (w, h) = (capturer.width(), capturer.height());
+
+    loop {
+        // Wait until there's a frame.
+
+        let buffer = match capturer.frame(0) {
+            Ok(buffer) => buffer,
+            Err(error) => {
+                if error.kind() == WouldBlock {
+                    // Keep spinning.
+                    thread::sleep(one_frame);
+                    continue;
+                } else {
+                    panic!("Error: {}", error);
+                }
+            }
+        };
+
+        println!("Captured! Saving...");
+
+        // Flip the BGRA image into a RGBA image.
+
+        let mut bitflipped = Vec::with_capacity(w * h * 4);
+        let stride = buffer.len() / h;
+
+        for y in 0..h {
+            for x in 0..w {
+                let i = stride * y + 4 * x;
+                bitflipped.extend_from_slice(&[buffer[i + 2], buffer[i + 1], buffer[i], 255]);
+            }
+        }
+
+        // Save the image.
+
+        let name = format!("screenshot{}_1.png", i);
+        repng::encode(
+            File::create(name.clone()).unwrap(),
+            w as u32,
+            h as u32,
+            &bitflipped,
+        )
+        .unwrap();
+
+        println!("Image saved to `{}`.", name);
+        break;
+    }
+
+    drop(capturer);
+    let display = get_display(i);
+    let mut capturer = Capturer::new(display, true).expect("Couldn't begin capture.");
+    let (w, h) = (capturer.width(), capturer.height());
+
+    loop {
+        // Wait until there's a frame.
+
+        let buffer = match capturer.frame(0) {
+            Ok(buffer) => buffer,
+            Err(error) => {
+                if error.kind() == WouldBlock {
+                    // Keep spinning.
+                    thread::sleep(one_frame);
+                    continue;
+                } else {
+                    panic!("Error: {}", error);
+                }
+            }
+        };
+
+        println!("Captured! Saving...");
+
+        let mut frame = Default::default();
+        i420_to_rgb(w, h, &buffer, &mut frame);
+
+        let mut bitflipped = Vec::with_capacity(w * h * 4);
+        let stride = frame.len() / h;
+
+        for y in 0..h {
+            for x in 0..w {
+                let i = stride * y + 3 * x;
+                bitflipped.extend_from_slice(&[frame[i], frame[i + 1], frame[i + 2], 255]);
+            }
+        }
+        let name = format!("screenshot{}_2.png", i);
+        repng::encode(
+            File::create(name.clone()).unwrap(),
+            w as u32,
+            h as u32,
+            &bitflipped,
+        )
+        .unwrap();
+
+        println!("Image saved to `{}`.", name);
+        break;
+    }
+}

libs/scrap/src/common/codec.rs

@@ -0,0 +1,536 @@
+// https://github.com/astraw/vpx-encode
+// https://github.com/astraw/env-libvpx-sys
+// https://github.com/rust-av/vpx-rs/blob/master/src/decoder.rs
+
+use super::vpx::{vp8e_enc_control_id::*, vpx_codec_err_t::*, *};
+use std::os::raw::{c_int, c_uint};
+use std::{ptr, slice};
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub enum VideoCodecId {
+    VP8,
+    VP9,
+}
+
+impl Default for VideoCodecId {
+    fn default() -> VideoCodecId {
+        VideoCodecId::VP9
+    }
+}
+
+pub struct Encoder {
+    ctx: vpx_codec_ctx_t,
+    width: usize,
+    height: usize,
+}
+
+pub struct Decoder {
+    ctx: vpx_codec_ctx_t,
+}
+
+#[derive(Debug)]
+pub enum Error {
+    FailedCall(String),
+    BadPtr(String),
+}
+
+impl std::fmt::Display for Error {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::result::Result<(), std::fmt::Error> {
+        write!(f, "{:?}", self)
+    }
+}
+
+impl std::error::Error for Error {}
+
+pub type Result<T> = std::result::Result<T, Error>;
+
+macro_rules! call_vpx {
+    ($x:expr) => {{
+        let result = unsafe { $x }; // original expression
+        let result_int = unsafe { std::mem::transmute::<_, i32>(result) };
+        if result_int != 0 {
+            return Err(Error::FailedCall(format!(
+                "errcode={} {}:{}:{}:{}",
+                result_int,
+                module_path!(),
+                file!(),
+                line!(),
+                column!()
+            ))
+            .into());
+        }
+        result
+    }};
+}
+
+macro_rules! call_vpx_ptr {
+    ($x:expr) => {{
+        let result = unsafe { $x }; // original expression
+        let result_int = unsafe { std::mem::transmute::<_, i64>(result) };
+        if result_int == 0 {
+            return Err(Error::BadPtr(format!(
+                "errcode={} {}:{}:{}:{}",
+                result_int,
+                module_path!(),
+                file!(),
+                line!(),
+                column!()
+            ))
+            .into());
+        }
+        result
+    }};
+}
+
+impl Encoder {
+    pub fn new(config: &Config, num_threads: u32) -> Result<Self> {
+        let i;
+        if cfg!(feature = "VP8") {
+            i = match config.codec {
+                VideoCodecId::VP8 => call_vpx_ptr!(vpx_codec_vp8_cx()),
+                VideoCodecId::VP9 => call_vpx_ptr!(vpx_codec_vp9_cx()),
+            };
+        } else {
+            i = call_vpx_ptr!(vpx_codec_vp9_cx());
+        }
+        let mut c = unsafe { std::mem::MaybeUninit::zeroed().assume_init() };
+        call_vpx!(vpx_codec_enc_config_default(i, &mut c, 0));
+
+        // https://www.webmproject.org/docs/encoder-parameters/
+        // default: c.rc_min_quantizer = 0, c.rc_max_quantizer = 63
+        // try rc_resize_allowed later
+
+        c.g_w = config.width;
+        c.g_h = config.height;
+        c.g_timebase.num = config.timebase[0];
+        c.g_timebase.den = config.timebase[1];
+        c.rc_target_bitrate = config.bitrate;
+        c.rc_undershoot_pct = 95;
+        c.rc_dropframe_thresh = 25;
+        if config.rc_min_quantizer > 0 {
+            c.rc_min_quantizer = config.rc_min_quantizer;
+        }
+        if config.rc_max_quantizer > 0 {
+            c.rc_max_quantizer = config.rc_max_quantizer;
+        }
+        let mut speed = config.speed;
+        if speed <= 0 {
+            speed = 6;
+        }
+
+        c.g_threads = if num_threads == 0 {
+            num_cpus::get() as _
+        } else {
+            num_threads
+        };
+        c.g_error_resilient = VPX_ERROR_RESILIENT_DEFAULT;
+        // https://developers.google.com/media/vp9/bitrate-modes/
+        // Constant Bitrate mode (CBR) is recommended for live streaming with VP9.
+        c.rc_end_usage = vpx_rc_mode::VPX_CBR;
+        // c.kf_min_dist = 0;
+        // c.kf_max_dist = 999999;
+        c.kf_mode = vpx_kf_mode::VPX_KF_DISABLED; // reduce bandwidth a lot
+
+        /*
+        VPX encoder支持two-pass encode，这是为了rate control的。
+        对于两遍编码，就是需要整个编码过程做两次，第一次会得到一些新的控制参数来进行第二遍的编码，
+        这样可以在相同的bitrate下得到最好的PSNR
+        */
+
+        let mut ctx = Default::default();
+        call_vpx!(vpx_codec_enc_init_ver(
+            &mut ctx,
+            i,
+            &c,
+            0,
+            VPX_ENCODER_ABI_VERSION as _
+        ));
+
+        if config.codec == VideoCodecId::VP9 {
+            // set encoder internal speed settings
+            // in ffmpeg, it is --speed option
+            /*
+            set to 0 or a positive value 1-16, the codec will try to adapt its
+            complexity depending on the time it spends encoding. Increasing this
+            number will make the speed go up and the quality go down.
+            Negative values mean strict enforcement of this
+            while positive values are adaptive
+            */
+            /* https://developers.google.com/media/vp9/live-encoding
+            Speed 5 to 8 should be used for live / real-time encoding.
+            Lower numbers (5 or 6) are higher quality but require more CPU power.
+            Higher numbers (7 or 8) will be lower quality but more manageable for lower latency
+            use cases and also for lower CPU power devices such as mobile.
+            */
+            call_vpx!(vpx_codec_control_(&mut ctx, VP8E_SET_CPUUSED as _, speed,));
+            // set row level multi-threading
+            /*
+            as some people in comments and below have already commented,
+            more recent versions of libvpx support -row-mt 1 to enable tile row
+            multi-threading. This can increase the number of tiles by up to 4x in VP9
+            (since the max number of tile rows is 4, regardless of video height).
+            To enable this, use -tile-rows N where N is the number of tile rows in
+            log2 units (so -tile-rows 1 means 2 tile rows and -tile-rows 2 means 4 tile
+            rows). The total number of active threads will then be equal to
+            $tile_rows * $tile_columns
+            */
+            call_vpx!(vpx_codec_control_(
+                &mut ctx,
+                VP9E_SET_ROW_MT as _,
+                1 as c_int
+            ));
+
+            call_vpx!(vpx_codec_control_(
+                &mut ctx,
+                VP9E_SET_TILE_COLUMNS as _,
+                4 as c_int
+            ));
+        }
+
+        Ok(Self {
+            ctx,
+            width: config.width as _,
+            height: config.height as _,
+        })
+    }
+
+    pub fn encode(&mut self, pts: i64, data: &[u8], stride_align: usize) -> Result<EncodeFrames> {
+        assert!(2 * data.len() >= 3 * self.width * self.height);
+
+        let mut image = Default::default();
+        call_vpx_ptr!(vpx_img_wrap(
+            &mut image,
+            vpx_img_fmt::VPX_IMG_FMT_I420,
+            self.width as _,
+            self.height as _,
+            stride_align as _,
+            data.as_ptr() as _,
+        ));
+
+        call_vpx!(vpx_codec_encode(
+            &mut self.ctx,
+            &image,
+            pts as _,
+            1, // Duration
+            0, // Flags
+            VPX_DL_REALTIME as _,
+        ));
+
+        Ok(EncodeFrames {
+            ctx: &mut self.ctx,
+            iter: ptr::null(),
+        })
+    }
+
+    /// Notify the encoder to return any pending packets
+    pub fn flush(&mut self) -> Result<EncodeFrames> {
+        call_vpx!(vpx_codec_encode(
+            &mut self.ctx,
+            ptr::null(),
+            -1, // PTS
+            1,  // Duration
+            0,  // Flags
+            VPX_DL_REALTIME as _,
+        ));
+
+        Ok(EncodeFrames {
+            ctx: &mut self.ctx,
+            iter: ptr::null(),
+        })
+    }
+}
+
+impl Drop for Encoder {
+    fn drop(&mut self) {
+        unsafe {
+            let result = vpx_codec_destroy(&mut self.ctx);
+            if result != VPX_CODEC_OK {
+                panic!("failed to destroy vpx codec");
+            }
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug)]
+pub struct EncodeFrame<'a> {
+    /// Compressed data.
+    pub data: &'a [u8],
+    /// Whether the frame is a keyframe.
+    pub key: bool,
+    /// Presentation timestamp (in timebase units).
+    pub pts: i64,
+}
+
+#[derive(Clone, Copy, Debug)]
+pub struct Config {
+    /// The width (in pixels).
+    pub width: c_uint,
+    /// The height (in pixels).
+    pub height: c_uint,
+    /// The timebase numerator and denominator (in seconds).
+    pub timebase: [c_int; 2],
+    /// The target bitrate (in kilobits per second).
+    pub bitrate: c_uint,
+    /// The codec
+    pub codec: VideoCodecId,
+    pub rc_min_quantizer: u32,
+    pub rc_max_quantizer: u32,
+    pub speed: i32,
+}
+
+pub struct EncodeFrames<'a> {
+    ctx: &'a mut vpx_codec_ctx_t,
+    iter: vpx_codec_iter_t,
+}
+
+impl<'a> Iterator for EncodeFrames<'a> {
+    type Item = EncodeFrame<'a>;
+    fn next(&mut self) -> Option<Self::Item> {
+        loop {
+            unsafe {
+                let pkt = vpx_codec_get_cx_data(self.ctx, &mut self.iter);
+                if pkt.is_null() {
+                    return None;
+                } else if (*pkt).kind == vpx_codec_cx_pkt_kind::VPX_CODEC_CX_FRAME_PKT {
+                    let f = &(*pkt).data.frame;
+                    return Some(Self::Item {
+                        data: slice::from_raw_parts(f.buf as _, f.sz as _),
+                        key: (f.flags & VPX_FRAME_IS_KEY) != 0,
+                        pts: f.pts,
+                    });
+                } else {
+                    // Ignore the packet.
+                }
+            }
+        }
+    }
+}
+
+impl Decoder {
+    /// Create a new decoder
+    ///
+    /// # Errors
+    ///
+    /// The function may fail if the underlying libvpx does not provide
+    /// the VP9 decoder.
+    pub fn new(codec: VideoCodecId, num_threads: u32) -> Result<Self> {
+        // This is sound because `vpx_codec_ctx` is a repr(C) struct without any field that can
+        // cause UB if uninitialized.
+        let i;
+        if cfg!(feature = "VP8") {
+            i = match codec {
+                VideoCodecId::VP8 => call_vpx_ptr!(vpx_codec_vp8_dx()),
+                VideoCodecId::VP9 => call_vpx_ptr!(vpx_codec_vp9_dx()),
+            };
+        } else {
+            i = call_vpx_ptr!(vpx_codec_vp9_dx());
+        }
+        let mut ctx = Default::default();
+        let cfg = vpx_codec_dec_cfg_t {
+            threads: if num_threads == 0 {
+                num_cpus::get() as _
+            } else {
+                num_threads
+            },
+            w: 0,
+            h: 0,
+        };
+        /*
+        unsafe {
+            println!("{}", vpx_codec_get_caps(i));
+        }
+        */
+        call_vpx!(vpx_codec_dec_init_ver(
+            &mut ctx,
+            i,
+            &cfg,
+            0,
+            VPX_DECODER_ABI_VERSION as _,
+        ));
+        Ok(Self { ctx })
+    }
+
+    pub fn decode2rgb(&mut self, data: &[u8], rgba: bool) -> Result<Vec<u8>> {
+        let mut img = Image::new();
+        for frame in self.decode(data)? {
+            drop(img);
+            img = frame;
+        }
+        for frame in self.flush()? {
+            drop(img);
+            img = frame;
+        }
+        if img.is_null() {
+            Ok(Vec::new())
+        } else {
+            let mut out = Default::default();
+            img.rgb(1, rgba, &mut out);
+            Ok(out)
+        }
+    }
+
+    /// Feed some compressed data to the encoder
+    ///
+    /// The `data` slice is sent to the decoder
+    ///
+    /// It matches a call to `vpx_codec_decode`.
+    pub fn decode(&mut self, data: &[u8]) -> Result<DecodeFrames> {
+        call_vpx!(vpx_codec_decode(
+            &mut self.ctx,
+            data.as_ptr(),
+            data.len() as _,
+            ptr::null_mut(),
+            0,
+        ));
+
+        Ok(DecodeFrames {
+            ctx: &mut self.ctx,
+            iter: ptr::null(),
+        })
+    }
+
+    /// Notify the decoder to return any pending frame
+    pub fn flush(&mut self) -> Result<DecodeFrames> {
+        call_vpx!(vpx_codec_decode(
+            &mut self.ctx,
+            ptr::null(),
+            0,
+            ptr::null_mut(),
+            0
+        ));
+        Ok(DecodeFrames {
+            ctx: &mut self.ctx,
+            iter: ptr::null(),
+        })
+    }
+}
+
+impl Drop for Decoder {
+    fn drop(&mut self) {
+        unsafe {
+            let result = vpx_codec_destroy(&mut self.ctx);
+            if result != VPX_CODEC_OK {
+                panic!("failed to destroy vpx codec");
+            }
+        }
+    }
+}
+
+pub struct DecodeFrames<'a> {
+    ctx: &'a mut vpx_codec_ctx_t,
+    iter: vpx_codec_iter_t,
+}
+
+impl<'a> Iterator for DecodeFrames<'a> {
+    type Item = Image;
+    fn next(&mut self) -> Option<Self::Item> {
+        let img = unsafe { vpx_codec_get_frame(self.ctx, &mut self.iter) };
+        if img.is_null() {
+            return None;
+        } else {
+            return Some(Image(img));
+        }
+    }
+}
+
+// https://chromium.googlesource.com/webm/libvpx/+/bali/vpx/src/vpx_image.c
+pub struct Image(*mut vpx_image_t);
+impl Image {
+    #[inline]
+    pub fn new() -> Self {
+        Self(std::ptr::null_mut())
+    }
+
+    #[inline]
+    pub fn is_null(&self) -> bool {
+        self.0.is_null()
+    }
+
+    #[inline]
+    pub fn width(&self) -> usize {
+        self.inner().d_w as _
+    }
+
+    #[inline]
+    pub fn height(&self) -> usize {
+        self.inner().d_h as _
+    }
+
+    #[inline]
+    pub fn format(&self) -> vpx_img_fmt_t {
+        // VPX_IMG_FMT_I420
+        self.inner().fmt
+    }
+
+    #[inline]
+    pub fn inner(&self) -> &vpx_image_t {
+        unsafe { &*self.0 }
+    }
+
+    #[inline]
+    pub fn stride(&self, iplane: usize) -> i32 {
+        self.inner().stride[iplane]
+    }
+
+    pub fn rgb(&self, stride_align: usize, rgba: bool, dst: &mut Vec<u8>) {
+        let h = self.height();
+        let mut w = self.width();
+        let bps = if rgba { 4 } else { 3 };
+        w = (w + stride_align - 1) & !(stride_align - 1);
+        dst.resize(h * w * bps, 0);
+        let img = self.inner();
+        unsafe {
+            if rgba {
+                super::I420ToARGB(
+                    img.planes[0],
+                    img.stride[0],
+                    img.planes[1],
+                    img.stride[1],
+                    img.planes[2],
+                    img.stride[2],
+                    dst.as_mut_ptr(),
+                    (w * bps) as _,
+                    self.width() as _,
+                    self.height() as _,
+                );
+            } else {
+                super::I420ToRAW(
+                    img.planes[0],
+                    img.stride[0],
+                    img.planes[1],
+                    img.stride[1],
+                    img.planes[2],
+                    img.stride[2],
+                    dst.as_mut_ptr(),
+                    (w * bps) as _,
+                    self.width() as _,
+                    self.height() as _,
+                );
+            }
+        }
+    }
+
+    #[inline]
+    pub fn data(&self) -> (&[u8], &[u8], &[u8]) {
+        unsafe {
+            let img = self.inner();
+            let h = (img.d_h as usize + 1) & !1;
+            let n = img.stride[0] as usize * h;
+            let y = slice::from_raw_parts(img.planes[0], n);
+            let n = img.stride[1] as usize * (h >> 1);
+            let u = slice::from_raw_parts(img.planes[1], n);
+            let v = slice::from_raw_parts(img.planes[2], n);
+            (y, u, v)
+        }
+    }
+}
+
+impl Drop for Image {
+    fn drop(&mut self) {
+        if !self.0.is_null() {
+            unsafe { vpx_img_free(self.0) };
+        }
+    }
+}
+
+unsafe impl Send for vpx_codec_ctx_t {}

libs/scrap/src/common/convert.rs

@@ -0,0 +1,188 @@
+use super::vpx::*;
+use std::os::raw::c_int;
+
+extern "C" {
+    // seems libyuv uses reverse byte order compared with our view
+
+    pub fn ARGBRotate(
+        src_argb: *const u8,
+        src_stride_argb: c_int,
+        dst_argb: *mut u8,
+        dst_stride_argb: c_int,
+        width: c_int,
+        height: c_int,
+        mode: c_int,
+    ) -> c_int;
+
+    pub fn ARGBMirror(
+        src_argb: *const u8,
+        src_stride_argb: c_int,
+        dst_argb: *mut u8,
+        dst_stride_argb: c_int,
+        width: c_int,
+        height: c_int,
+    ) -> c_int;
+
+    pub fn ARGBToI420(
+        src_bgra: *const u8,
+        src_stride_bgra: c_int,
+        dst_y: *mut u8,
+        dst_stride_y: c_int,
+        dst_u: *mut u8,
+        dst_stride_u: c_int,
+        dst_v: *mut u8,
+        dst_stride_v: c_int,
+        width: c_int,
+        height: c_int,
+    ) -> c_int;
+
+    pub fn NV12ToI420(
+        src_y: *const u8,
+        src_stride_y: c_int,
+        src_uv: *const u8,
+        src_stride_uv: c_int,
+        dst_y: *mut u8,
+        dst_stride_y: c_int,
+        dst_u: *mut u8,
+        dst_stride_u: c_int,
+        dst_v: *mut u8,
+        dst_stride_v: c_int,
+        width: c_int,
+        height: c_int,
+    ) -> c_int;
+
+    // I420ToRGB24: RGB little endian (bgr in memory)
+    // I420ToRaw: RGB big endian (rgb in memory) to RGBA.
+    pub fn I420ToRAW(
+        src_y: *const u8,
+        src_stride_y: c_int,
+        src_u: *const u8,
+        src_stride_u: c_int,
+        src_v: *const u8,
+        src_stride_v: c_int,
+        dst_rgba: *mut u8,
+        dst_stride_raw: c_int,
+        width: c_int,
+        height: c_int,
+    ) -> c_int;
+
+    pub fn I420ToARGB(
+        src_y: *const u8,
+        src_stride_y: c_int,
+        src_u: *const u8,
+        src_stride_u: c_int,
+        src_v: *const u8,
+        src_stride_v: c_int,
+        dst_rgba: *mut u8,
+        dst_stride_rgba: c_int,
+        width: c_int,
+        height: c_int,
+    ) -> c_int;
+}
+
+// https://github.com/webmproject/libvpx/blob/master/vpx/src/vpx_image.c
+#[inline]
+fn get_vpx_i420_stride(
+    width: usize,
+    height: usize,
+    stride_align: usize,
+) -> (usize, usize, usize, usize, usize, usize) {
+    let mut img = Default::default();
+    unsafe {
+        vpx_img_wrap(
+            &mut img,
+            vpx_img_fmt::VPX_IMG_FMT_I420,
+            width as _,
+            height as _,
+            stride_align as _,
+            0x1 as _,
+        );
+    }
+    (
+        img.w as _,
+        img.h as _,
+        img.stride[0] as _,
+        img.stride[1] as _,
+        img.planes[1] as usize - img.planes[0] as usize,
+        img.planes[2] as usize - img.planes[0] as usize,
+    )
+}
+
+pub fn i420_to_rgb(width: usize, height: usize, src: &[u8], dst: &mut Vec<u8>) {
+    let (_, _, src_stride_y, src_stride_uv, u, v) =
+        get_vpx_i420_stride(width, height, super::STRIDE_ALIGN);
+    let src_y = src.as_ptr();
+    let src_u = src[u..].as_ptr();
+    let src_v = src[v..].as_ptr();
+    dst.resize(width * height * 3, 0);
+    unsafe {
+        super::I420ToRAW(
+            src_y,
+            src_stride_y as _,
+            src_u,
+            src_stride_uv as _,
+            src_v,
+            src_stride_uv as _,
+            dst.as_mut_ptr(),
+            (width * 3) as _,
+            width as _,
+            height as _,
+        );
+    };
+}
+
+pub fn bgra_to_i420(width: usize, height: usize, src: &[u8], dst: &mut Vec<u8>) {
+    let (_, h, dst_stride_y, dst_stride_uv, u, v) =
+        get_vpx_i420_stride(width, height, super::STRIDE_ALIGN);
+    let bps = 12;
+    dst.resize(h * dst_stride_y * bps / 8, 0);
+    let dst_y = dst.as_mut_ptr();
+    let dst_u = dst[u..].as_mut_ptr();
+    let dst_v = dst[v..].as_mut_ptr();
+    unsafe {
+        ARGBToI420(
+            src.as_ptr(),
+            (src.len() / height) as _,
+            dst_y,
+            dst_stride_y as _,
+            dst_u,
+            dst_stride_uv as _,
+            dst_v,
+            dst_stride_uv as _,
+            width as _,
+            height as _,
+        );
+    }
+}
+
+pub unsafe fn nv12_to_i420(
+    src_y: *const u8,
+    src_stride_y: c_int,
+    src_uv: *const u8,
+    src_stride_uv: c_int,
+    width: usize,
+    height: usize,
+    dst: &mut Vec<u8>,
+) {
+    let (w, h, dst_stride_y, dst_stride_uv, u, v) =
+        get_vpx_i420_stride(width, height, super::STRIDE_ALIGN);
+    let bps = 12;
+    dst.resize(h * w * bps / 8, 0);
+    let dst_y = dst.as_mut_ptr();
+    let dst_u = dst[u..].as_mut_ptr();
+    let dst_v = dst[v..].as_mut_ptr();
+    NV12ToI420(
+        src_y,
+        src_stride_y,
+        src_uv,
+        src_stride_uv,
+        dst_y,
+        dst_stride_y as _,
+        dst_u,
+        dst_stride_uv as _,
+        dst_v,
+        dst_stride_uv as _,
+        width as _,
+        height as _,
+    );
+}

libs/scrap/src/common/dxgi.rs

@@ -0,0 +1,104 @@
+use crate::dxgi;
+use std::io::ErrorKind::{NotFound, TimedOut, WouldBlock};
+use std::{io, ops};
+
+pub struct Capturer {
+    inner: dxgi::Capturer,
+    width: usize,
+    height: usize,
+}
+
+impl Capturer {
+    pub fn new(display: Display, yuv: bool) -> io::Result<Capturer> {
+        let width = display.width();
+        let height = display.height();
+        let inner = dxgi::Capturer::new(display.0, yuv)?;
+        Ok(Capturer {
+            inner,
+            width,
+            height,
+        })
+    }
+
+    pub fn is_gdi(&self) -> bool {
+        self.inner.is_gdi()
+    }
+
+    pub fn set_gdi(&mut self) -> bool {
+        self.inner.set_gdi()
+    }
+
+    pub fn cancel_gdi(&mut self) {
+        self.inner.cancel_gdi()
+    }
+
+    pub fn width(&self) -> usize {
+        self.width
+    }
+
+    pub fn height(&self) -> usize {
+        self.height
+    }
+
+    pub fn frame<'a>(&'a mut self, timeout_ms: u32) -> io::Result<Frame<'a>> {
+        match self.inner.frame(timeout_ms) {
+            Ok(frame) => Ok(Frame(frame)),
+            Err(ref error) if error.kind() == TimedOut => Err(WouldBlock.into()),
+            Err(error) => Err(error),
+        }
+    }
+}
+
+pub struct Frame<'a>(&'a [u8]);
+
+impl<'a> ops::Deref for Frame<'a> {
+    type Target = [u8];
+    fn deref(&self) -> &[u8] {
+        self.0
+    }
+}
+
+pub struct Display(dxgi::Display);
+
+impl Display {
+    pub fn primary() -> io::Result<Display> {
+        match dxgi::Displays::new()?.next() {
+            Some(inner) => Ok(Display(inner)),
+            None => Err(NotFound.into()),
+        }
+    }
+
+    pub fn all() -> io::Result<Vec<Display>> {
+        Ok(dxgi::Displays::new()?.map(Display).collect::<Vec<_>>())
+    }
+
+    pub fn width(&self) -> usize {
+        self.0.width() as usize
+    }
+
+    pub fn height(&self) -> usize {
+        self.0.height() as usize
+    }
+
+    pub fn name(&self) -> String {
+        use std::ffi::OsString;
+        use std::os::windows::prelude::*;
+        OsString::from_wide(self.0.name())
+            .to_string_lossy()
+            .to_string()
+    }
+
+    pub fn is_online(&self) -> bool {
+        self.0.is_online()
+    }
+
+    pub fn origin(&self) -> (usize, usize) {
+        let o = self.0.origin();
+        (o.0 as usize, o.1 as usize)
+    }
+
+    // to-do: not found primary display api for dxgi
+    pub fn is_primary(&self) -> bool {
+        self.name() == Self::primary().unwrap().name()
+    }
+}

libs/scrap/src/common/mod.rs

@@ -0,0 +1,23 @@
+pub use self::codec::*;
+
+cfg_if! {
+    if #[cfg(quartz)] {
+        mod quartz;
+        pub use self::quartz::*;
+    } else if #[cfg(x11)] {
+        mod x11;
+        pub use self::x11::*;
+    } else if #[cfg(dxgi)] {
+        mod dxgi;
+        pub use self::dxgi::*;
+    } else {
+        //TODO: Fallback implementation.
+    }
+}
+
+pub mod codec;
+mod convert;
+pub use self::convert::*;
+pub const STRIDE_ALIGN: usize = 16; // commonly used in libvpx vpx_img_alloc caller
+
+mod vpx;

libs/scrap/src/common/quartz.rs

@@ -0,0 +1,125 @@
+use crate::quartz;
+use std::marker::PhantomData;
+use std::sync::{Arc, Mutex, TryLockError};
+use std::{io, mem, ops};
+
+pub struct Capturer {
+    inner: quartz::Capturer,
+    frame: Arc<Mutex<Option<quartz::Frame>>>,
+    use_yuv: bool,
+    i420: Vec<u8>,
+}
+
+impl Capturer {
+    pub fn new(display: Display, use_yuv: bool) -> io::Result<Capturer> {
+        let frame = Arc::new(Mutex::new(None));
+
+        let f = frame.clone();
+        let inner = quartz::Capturer::new(
+            display.0,
+            display.width(),
+            display.height(),
+            if use_yuv {
+                quartz::PixelFormat::YCbCr420Full
+            } else {
+                quartz::PixelFormat::Argb8888
+            },
+            Default::default(),
+            move |inner| {
+                if let Ok(mut f) = f.lock() {
+                    *f = Some(inner);
+                }
+            },
+        )
+        .map_err(|_| io::Error::from(io::ErrorKind::Other))?;
+
+        Ok(Capturer {
+            inner,
+            frame,
+            use_yuv,
+            i420: Vec::new(),
+        })
+    }
+
+    pub fn width(&self) -> usize {
+        self.inner.width()
+    }
+
+    pub fn height(&self) -> usize {
+        self.inner.height()
+    }
+
+    pub fn frame<'a>(&'a mut self, _timeout_ms: u32) -> io::Result<Frame<'a>> {
+        match self.frame.try_lock() {
+            Ok(mut handle) => {
+                let mut frame = None;
+                mem::swap(&mut frame, &mut handle);
+
+                match frame {
+                    Some(mut frame) => {
+                        if self.use_yuv {
+                            frame.nv12_to_i420(self.width(), self.height(), &mut self.i420);
+                        }
+                        Ok(Frame(frame, PhantomData))
+                    }
+
+                    None => Err(io::ErrorKind::WouldBlock.into()),
+                }
+            }
+
+            Err(TryLockError::WouldBlock) => Err(io::ErrorKind::WouldBlock.into()),
+
+            Err(TryLockError::Poisoned(..)) => Err(io::ErrorKind::Other.into()),
+        }
+    }
+}
+
+pub struct Frame<'a>(quartz::Frame, PhantomData<&'a [u8]>);
+
+impl<'a> ops::Deref for Frame<'a> {
+    type Target = [u8];
+    fn deref(&self) -> &[u8] {
+        &*self.0
+    }
+}
+
+pub struct Display(quartz::Display);
+
+impl Display {
+    pub fn primary() -> io::Result<Display> {
+        Ok(Display(quartz::Display::primary()))
+    }
+
+    pub fn all() -> io::Result<Vec<Display>> {
+        Ok(quartz::Display::online()
+            .map_err(|_| io::Error::from(io::ErrorKind::Other))?
+            .into_iter()
+            .map(Display)
+            .collect())
+    }
+
+    pub fn width(&self) -> usize {
+        self.0.width()
+    }
+
+    pub fn height(&self) -> usize {
+        self.0.height()
+    }
+
+    pub fn name(&self) -> String {
+        self.0.id().to_string()
+    }
+
+    pub fn is_online(&self) -> bool {
+        self.0.is_online()
+    }
+
+    pub fn origin(&self) -> (usize, usize) {
+        let o = self.0.bounds().origin;
+        (o.x as usize, o.y as usize)
+    }
+
+    pub fn is_primary(&self) -> bool {
+        self.0.is_primary()
+    }
+}

libs/scrap/src/common/vpx.rs

@@ -0,0 +1,25 @@
+#![allow(non_camel_case_types)]
+#![allow(non_snake_case)]
+#![allow(non_upper_case_globals)]
+#![allow(improper_ctypes)]
+#![allow(dead_code)]
+
+impl Default for vpx_codec_enc_cfg {
+    fn default() -> Self {
+        unsafe { std::mem::zeroed() }
+    }
+}
+
+impl Default for vpx_codec_ctx {
+    fn default() -> Self {
+        unsafe { std::mem::zeroed() }
+    }
+}
+
+impl Default for vpx_image_t {
+    fn default() -> Self {
+        unsafe { std::mem::zeroed() }
+    }
+}
+
+include!(concat!(env!("OUT_DIR"), "/vpx_ffi.rs"));

libs/scrap/src/common/x11.rs

@@ -0,0 +1,87 @@
+use crate::x11;
+use std::{io, ops};
+
+pub struct Capturer(x11::Capturer);
+
+impl Capturer {
+    pub fn new(display: Display, yuv: bool) -> io::Result<Capturer> {
+        x11::Capturer::new(display.0, yuv).map(Capturer)
+    }
+
+    pub fn width(&self) -> usize {
+        self.0.display().rect().w as usize
+    }
+
+    pub fn height(&self) -> usize {
+        self.0.display().rect().h as usize
+    }
+
+    pub fn frame<'a>(&'a mut self, _timeout_ms: u32) -> io::Result<Frame<'a>> {
+        Ok(Frame(self.0.frame()))
+    }
+}
+
+pub struct Frame<'a>(&'a [u8]);
+
+impl<'a> ops::Deref for Frame<'a> {
+    type Target = [u8];
+    fn deref(&self) -> &[u8] {
+        self.0
+    }
+}
+
+pub struct Display(x11::Display);
+
+impl Display {
+    pub fn primary() -> io::Result<Display> {
+        let server = match x11::Server::default() {
+            Ok(server) => server,
+            Err(_) => return Err(io::ErrorKind::ConnectionRefused.into()),
+        };
+
+        let mut displays = x11::Server::displays(server);
+        let mut best = displays.next();
+        if best.as_ref().map(|x| x.is_default()) == Some(false) {
+            best = displays.find(|x| x.is_default()).or(best);
+        }
+
+        match best {
+            Some(best) => Ok(Display(best)),
+            None => Err(io::ErrorKind::NotFound.into()),
+        }
+    }
+
+    pub fn all() -> io::Result<Vec<Display>> {
+        let server = match x11::Server::default() {
+            Ok(server) => server,
+            Err(_) => return Err(io::ErrorKind::ConnectionRefused.into()),
+        };
+
+        Ok(x11::Server::displays(server).map(Display).collect())
+    }
+
+    pub fn width(&self) -> usize {
+        self.0.rect().w as usize
+    }
+
+    pub fn height(&self) -> usize {
+        self.0.rect().h as usize
+    }
+
+    pub fn origin(&self) -> (usize, usize) {
+        let r = self.0.rect();
+        (r.x as _, r.y as _)
+    }
+
+    pub fn is_online(&self) -> bool {
+        true
+    }
+
+    pub fn is_primary(&self) -> bool {
+        self.0.is_default()
+    }
+
+    pub fn name(&self) -> String {
+        "".to_owned()
+    }
+}

libs/scrap/src/dxgi/gdi.rs

@@ -0,0 +1,212 @@
+use std::mem::size_of;
+use winapi::{
+    shared::windef::{HBITMAP, HDC},
+    um::wingdi::{
+        BitBlt,
+        CreateCompatibleBitmap,
+        CreateCompatibleDC,
+        CreateDCW,
+        DeleteDC,
+        DeleteObject,
+        GetDIBits,
+        SelectObject,
+        BITMAPINFO,
+        BITMAPINFOHEADER,
+        BI_RGB,
+        DIB_RGB_COLORS, //CAPTUREBLT,
+        HGDI_ERROR,
+        RGBQUAD,
+        SRCCOPY,
+    },
+};
+
+const PIXEL_WIDTH: i32 = 4;
+
+pub struct CapturerGDI {
+    screen_dc: HDC,
+    dc: HDC,
+    bmp: HBITMAP,
+    width: i32,
+    height: i32,
+}
+
+impl CapturerGDI {
+    pub fn new(name: &[u16], width: i32, height: i32) -> Result<Self, Box<dyn std::error::Error>> {
+        /* or Enumerate monitors with EnumDisplayMonitors,
+        https://stackoverflow.com/questions/34987695/how-can-i-get-an-hmonitor-handle-from-a-display-device-name
+            #[no_mangle]
+            pub extern "C" fn callback(m: HMONITOR, dc: HDC, rect: LPRECT, lp: LPARAM) -> BOOL {}
+        */
+        /*
+        shared::windef::HMONITOR,
+        winuser::{GetMonitorInfoW, GetSystemMetrics, MONITORINFOEXW},
+        let mut mi: MONITORINFOEXW = std::mem::MaybeUninit::uninit().assume_init();
+        mi.cbSize = size_of::<MONITORINFOEXW>() as _;
+        if GetMonitorInfoW(m, &mut mi as *mut MONITORINFOEXW as _) == 0 {
+            return Err(format!("Failed to get monitor information of: {:?}", m).into());
+        }
+        */
+        unsafe {
+            if name.is_empty() {
+                return Err("Empty display name".into());
+            }
+            let screen_dc = CreateDCW(&name[0], 0 as _, 0 as _, 0 as _);
+            if screen_dc.is_null() {
+                return Err("Failed to create dc from monitor name".into());
+            }
+
+            // Create a Windows Bitmap, and copy the bits into it
+            let dc = CreateCompatibleDC(screen_dc);
+            if dc.is_null() {
+                DeleteDC(screen_dc);
+                return Err("Can't get a Windows display".into());
+            }
+
+            let bmp = CreateCompatibleBitmap(screen_dc, width, height);
+            if bmp.is_null() {
+                DeleteDC(screen_dc);
+                DeleteDC(dc);
+                return Err("Can't create a Windows buffer".into());
+            }
+
+            let res = SelectObject(dc, bmp as _);
+            if res.is_null() || res == HGDI_ERROR {
+                DeleteDC(screen_dc);
+                DeleteDC(dc);
+                DeleteObject(bmp as _);
+                return Err("Can't select Windows buffer".into());
+            }
+            Ok(Self {
+                screen_dc,
+                dc,
+                bmp,
+                width,
+                height,
+            })
+        }
+    }
+
+    pub fn frame(&self, data: &mut Vec<u8>) -> Result<(), Box<dyn std::error::Error>> {
+        unsafe {
+            let res = BitBlt(
+                self.dc,
+                0,
+                0,
+                self.width,
+                self.height,
+                self.screen_dc,
+                0,
+                0,
+                SRCCOPY, // | CAPTUREBLT, // CAPTUREBLT enable layered window but also make cursor blinking
+            );
+            if res == 0 {
+                return Err("Failed to copy screen to Windows buffer".into());
+            }
+
+            let stride = self.width * PIXEL_WIDTH;
+            let size: usize = (stride * self.height) as usize;
+            let mut data1: Vec<u8> = Vec::with_capacity(size);
+            data1.set_len(size);
+            data.resize(size, 0);
+
+            let mut bmi = BITMAPINFO {
+                bmiHeader: BITMAPINFOHEADER {
+                    biSize: size_of::<BITMAPINFOHEADER>() as _,
+                    biWidth: self.width as _,
+                    biHeight: self.height as _,
+                    biPlanes: 1,
+                    biBitCount: (8 * PIXEL_WIDTH) as _,
+                    biCompression: BI_RGB,
+                    biSizeImage: (self.width * self.height * PIXEL_WIDTH) as _,
+                    biXPelsPerMeter: 0,
+                    biYPelsPerMeter: 0,
+                    biClrUsed: 0,
+                    biClrImportant: 0,
+                },
+                bmiColors: [RGBQUAD {
+                    rgbBlue: 0,
+                    rgbGreen: 0,
+                    rgbRed: 0,
+                    rgbReserved: 0,
+                }],
+            };
+
+            // copy bits into Vec
+            let res = GetDIBits(
+                self.dc,
+                self.bmp,
+                0,
+                self.height as _,
+                &mut data[0] as *mut u8 as _,
+                &mut bmi as _,
+                DIB_RGB_COLORS,
+            );
+            if res == 0 {
+                return Err("GetDIBits failed".into());
+            }
+            crate::common::ARGBMirror(
+                data.as_ptr(),
+                stride,
+                data1.as_mut_ptr(),
+                stride,
+                self.width,
+                self.height,
+            );
+            crate::common::ARGBRotate(
+                data1.as_ptr(),
+                stride,
+                data.as_mut_ptr(),
+                stride,
+                self.width,
+                self.height,
+                180,
+            );
+            Ok(())
+        }
+    }
+}
+
+impl Drop for CapturerGDI {
+    fn drop(&mut self) {
+        unsafe {
+            DeleteDC(self.screen_dc);
+            DeleteDC(self.dc);
+            DeleteObject(self.bmp as _);
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::super::*;
+    use super::*;
+    #[test]
+    fn test() {
+        match Displays::new().unwrap().next() {
+            Some(d) => {
+                let w = d.width();
+                let h = d.height();
+                let c = CapturerGDI::new(d.name(), w, h).unwrap();
+                let mut data = Vec::new();
+                c.frame(&mut data).unwrap();
+                let mut bitflipped = Vec::with_capacity((w * h * 4) as usize);
+                for y in 0..h {
+                    for x in 0..w {
+                        let i = (w * 4 * y + 4 * x) as usize;
+                        bitflipped.extend_from_slice(&[data[i + 2], data[i + 1], data[i], 255]);
+                    }
+                }
+                repng::encode(
+                    std::fs::File::create("gdi_screen.png").unwrap(),
+                    d.width() as u32,
+                    d.height() as u32,
+                    &bitflipped,
+                )
+                .unwrap();
+            }
+            _ => {
+                assert!(false);
+            }
+        }
+    }
+}

libs/scrap/src/dxgi/mod.rs

@@ -0,0 +1,539 @@
+use std::{io, mem, ptr, slice};
+pub mod gdi;
+pub use gdi::CapturerGDI;
+
+use winapi::{
+    shared::dxgi::{
+        CreateDXGIFactory1, IDXGIAdapter1, IDXGIFactory1, IDXGIResource, IDXGISurface,
+        IID_IDXGIFactory1, IID_IDXGISurface, DXGI_MAP_READ, DXGI_OUTPUT_DESC,
+        DXGI_RESOURCE_PRIORITY_MAXIMUM,
+    },
+    shared::dxgi1_2::IDXGIOutputDuplication,
+    // shared::dxgiformat::{DXGI_FORMAT, DXGI_FORMAT_B8G8R8A8_UNORM, DXGI_FORMAT_420_OPAQUE},
+    shared::dxgi1_2::{IDXGIOutput1, IID_IDXGIOutput1},
+    shared::dxgitype::DXGI_MODE_ROTATION,
+    shared::minwindef::{TRUE, UINT},
+    shared::ntdef::LONG,
+    shared::windef::HMONITOR,
+    shared::winerror::{
+        DXGI_ERROR_ACCESS_LOST, DXGI_ERROR_INVALID_CALL, DXGI_ERROR_NOT_CURRENTLY_AVAILABLE,
+        DXGI_ERROR_SESSION_DISCONNECTED, DXGI_ERROR_UNSUPPORTED, DXGI_ERROR_WAIT_TIMEOUT,
+        E_ACCESSDENIED, E_INVALIDARG, S_OK,
+    },
+    um::d3d11::{
+        D3D11CreateDevice, ID3D11Device, ID3D11DeviceContext, ID3D11Texture2D, IID_ID3D11Texture2D,
+        D3D11_CPU_ACCESS_READ, D3D11_SDK_VERSION, D3D11_USAGE_STAGING,
+    },
+    um::d3dcommon::D3D_DRIVER_TYPE_UNKNOWN,
+    um::winnt::HRESULT,
+};
+
+//TODO: Split up into files.
+
+pub struct Capturer {
+    device: *mut ID3D11Device,
+    display: Display,
+    context: *mut ID3D11DeviceContext,
+    duplication: *mut IDXGIOutputDuplication,
+    fastlane: bool,
+    surface: *mut IDXGISurface,
+    data: *const u8,
+    len: usize,
+    width: usize,
+    height: usize,
+    use_yuv: bool,
+    yuv: Vec<u8>,
+    gdi_capturer: Option<CapturerGDI>,
+    gdi_buffer: Vec<u8>,
+}
+
+impl Capturer {
+    pub fn new(display: Display, use_yuv: bool) -> io::Result<Capturer> {
+        let mut device = ptr::null_mut();
+        let mut context = ptr::null_mut();
+        let mut duplication = ptr::null_mut();
+        let mut desc = unsafe { mem::MaybeUninit::uninit().assume_init() };
+        let mut gdi_capturer = None;
+
+        let mut res = wrap_hresult(unsafe {
+            D3D11CreateDevice(
+                display.adapter as *mut _,
+                D3D_DRIVER_TYPE_UNKNOWN,
+                ptr::null_mut(), // No software rasterizer.
+                0,               // No device flags.
+                ptr::null_mut(), // Feature levels.
+                0,               // Feature levels' length.
+                D3D11_SDK_VERSION,
+                &mut device,
+                ptr::null_mut(),
+                &mut context,
+            )
+        });
+
+        if res.is_err() {
+            gdi_capturer = display.create_gdi();
+            println!("Fallback to GDI");
+            if gdi_capturer.is_some() {
+                res = Ok(());
+            }
+        } else {
+            res = wrap_hresult(unsafe {
+                let hres = (*display.inner).DuplicateOutput(device as *mut _, &mut duplication);
+                if hres != S_OK {
+                    gdi_capturer = display.create_gdi();
+                    println!("Fallback to GDI");
+                    if gdi_capturer.is_some() {
+                        S_OK
+                    } else {
+                        hres
+                    }
+                } else {
+                    hres
+                }
+                // NVFBC(NVIDIA Capture SDK) which xpra used already deprecated, https://developer.nvidia.com/capture-sdk
+
+                // also try high version DXGI for better performance, e.g.
+                // https://docs.microsoft.com/zh-cn/windows/win32/direct3ddxgi/dxgi-1-2-improvements
+                // dxgi-1-6 may too high, only support win10 (2018)
+                // https://docs.microsoft.com/zh-cn/windows/win32/api/dxgiformat/ne-dxgiformat-dxgi_format
+                // DXGI_FORMAT_420_OPAQUE
+                // IDXGIOutputDuplication::GetFrameDirtyRects and IDXGIOutputDuplication::GetFrameMoveRects
+                // can help us update screen incrementally
+
+                /* // not supported on my PC, try in the future
+                let format : Vec<DXGI_FORMAT> = vec![DXGI_FORMAT_B8G8R8A8_UNORM, DXGI_FORMAT_420_OPAQUE];
+                (*display.inner).DuplicateOutput1(
+                    device as *mut _,
+                    0 as UINT,
+                    2 as UINT,
+                    format.as_ptr(),
+                    &mut duplication
+                )
+                */
+
+                // if above not work, I think below should not work either, try later
+                // https://developer.nvidia.com/capture-sdk deprecated
+                // examples using directx + nvideo sdk for GPU-accelerated video encoding/decoding
+                // https://github.com/NVIDIA/video-sdk-samples
+            });
+        }
+
+        if let Err(err) = res {
+            unsafe {
+                if !device.is_null() {
+                    (*device).Release();
+                }
+                if !context.is_null() {
+                    (*context).Release();
+                }
+            }
+            return Err(err);
+        }
+
+        if !duplication.is_null() {
+            unsafe {
+                (*duplication).GetDesc(&mut desc);
+            }
+        }
+
+        Ok(Capturer {
+            device,
+            context,
+            duplication,
+            fastlane: desc.DesktopImageInSystemMemory == TRUE,
+            surface: ptr::null_mut(),
+            width: display.width() as usize,
+            height: display.height() as usize,
+            display,
+            data: ptr::null(),
+            len: 0,
+            use_yuv,
+            yuv: Vec::new(),
+            gdi_capturer,
+            gdi_buffer: Vec::new(),
+        })
+    }
+
+    pub fn is_gdi(&self) -> bool {
+        self.gdi_capturer.is_some()
+    }
+
+    pub fn set_gdi(&mut self) -> bool {
+        self.gdi_capturer = self.display.create_gdi();
+        self.is_gdi()
+    }
+
+    pub fn cancel_gdi(&mut self) {
+        self.gdi_buffer = Vec::new();
+        self.gdi_capturer.take();
+    }
+
+    unsafe fn load_frame(&mut self, timeout: UINT) -> io::Result<()> {
+        let mut frame = ptr::null_mut();
+        let mut info = mem::MaybeUninit::uninit().assume_init();
+        self.data = ptr::null();
+
+        wrap_hresult((*self.duplication).AcquireNextFrame(timeout, &mut info, &mut frame))?;
+
+        if *info.LastPresentTime.QuadPart() == 0 {
+            return Err(std::io::ErrorKind::WouldBlock.into());
+        }
+
+        if self.fastlane {
+            let mut rect = mem::MaybeUninit::uninit().assume_init();
+            let res = wrap_hresult((*self.duplication).MapDesktopSurface(&mut rect));
+
+            (*frame).Release();
+
+            if let Err(err) = res {
+                Err(err)
+            } else {
+                self.data = rect.pBits;
+                self.len = self.height * rect.Pitch as usize;
+                Ok(())
+            }
+        } else {
+            self.surface = ptr::null_mut();
+            self.surface = self.ohgodwhat(frame)?;
+
+            let mut rect = mem::MaybeUninit::uninit().assume_init();
+            wrap_hresult((*self.surface).Map(&mut rect, DXGI_MAP_READ))?;
+
+            self.data = rect.pBits;
+            self.len = self.height * rect.Pitch as usize;
+            Ok(())
+        }
+    }
+
+    // copy from GPU memory to system memory
+    unsafe fn ohgodwhat(&mut self, frame: *mut IDXGIResource) -> io::Result<*mut IDXGISurface> {
+        let mut texture: *mut ID3D11Texture2D = ptr::null_mut();
+        (*frame).QueryInterface(
+            &IID_ID3D11Texture2D,
+            &mut texture as *mut *mut _ as *mut *mut _,
+        );
+
+        let mut texture_desc = mem::MaybeUninit::uninit().assume_init();
+        (*texture).GetDesc(&mut texture_desc);
+
+        texture_desc.Usage = D3D11_USAGE_STAGING;
+        texture_desc.BindFlags = 0;
+        texture_desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
+        texture_desc.MiscFlags = 0;
+
+        let mut readable = ptr::null_mut();
+        let res = wrap_hresult((*self.device).CreateTexture2D(
+            &mut texture_desc,
+            ptr::null(),
+            &mut readable,
+        ));
+
+        if let Err(err) = res {
+            (*frame).Release();
+            (*texture).Release();
+            (*readable).Release();
+            Err(err)
+        } else {
+            (*readable).SetEvictionPriority(DXGI_RESOURCE_PRIORITY_MAXIMUM);
+
+            let mut surface = ptr::null_mut();
+            (*readable).QueryInterface(
+                &IID_IDXGISurface,
+                &mut surface as *mut *mut _ as *mut *mut _,
+            );
+
+            (*self.context).CopyResource(readable as *mut _, texture as *mut _);
+
+            (*frame).Release();
+            (*texture).Release();
+            (*readable).Release();
+            Ok(surface)
+        }
+    }
+
+    pub fn frame<'a>(&'a mut self, timeout: UINT) -> io::Result<&'a [u8]> {
+        unsafe {
+            // Release last frame.
+            // No error checking needed because we don't care.
+            // None of the errors crash anyway.
+            let result = {
+                if let Some(gdi_capturer) = &self.gdi_capturer {
+                    match gdi_capturer.frame(&mut self.gdi_buffer) {
+                        Ok(_) => &self.gdi_buffer,
+                        Err(err) => {
+                            return Err(io::Error::new(io::ErrorKind::Other, err.to_string()));
+                        }
+                    }
+                } else {
+                    if self.fastlane {
+                        (*self.duplication).UnMapDesktopSurface();
+                    } else {
+                        if !self.surface.is_null() {
+                            (*self.surface).Unmap();
+                            (*self.surface).Release();
+                            self.surface = ptr::null_mut();
+                        }
+                    }
+
+                    (*self.duplication).ReleaseFrame();
+                    self.load_frame(timeout)?;
+                    slice::from_raw_parts(self.data, self.len)
+                }
+            };
+            Ok({
+                if self.use_yuv {
+                    crate::common::bgra_to_i420(
+                        self.width as usize,
+                        self.height as usize,
+                        &result,
+                        &mut self.yuv,
+                    );
+                    &self.yuv[..]
+                } else {
+                    result
+                }
+            })
+        }
+    }
+}
+
+impl Drop for Capturer {
+    fn drop(&mut self) {
+        unsafe {
+            if !self.surface.is_null() {
+                (*self.surface).Unmap();
+                (*self.surface).Release();
+            }
+            if !self.duplication.is_null() {
+                (*self.duplication).Release();
+            }
+            if !self.device.is_null() {
+                (*self.device).Release();
+            }
+            if !self.context.is_null() {
+                (*self.context).Release();
+            }
+        }
+    }
+}
+
+pub struct Displays {
+    factory: *mut IDXGIFactory1,
+    adapter: *mut IDXGIAdapter1,
+    /// Index of the CURRENT adapter.
+    nadapter: UINT,
+    /// Index of the NEXT display to fetch.
+    ndisplay: UINT,
+}
+
+impl Displays {
+    pub fn new() -> io::Result<Displays> {
+        let mut factory = ptr::null_mut();
+        wrap_hresult(unsafe { CreateDXGIFactory1(&IID_IDXGIFactory1, &mut factory) })?;
+
+        let factory = factory as *mut IDXGIFactory1;
+        let mut adapter = ptr::null_mut();
+        unsafe {
+            // On error, our adapter is null, so it's fine.
+            (*factory).EnumAdapters1(0, &mut adapter);
+        };
+
+        Ok(Displays {
+            factory,
+            adapter,
+            nadapter: 0,
+            ndisplay: 0,
+        })
+    }
+
+    // No Adapter => Some(None)
+    // Non-Empty Adapter => Some(Some(OUTPUT))
+    // End of Adapter => None
+    fn read_and_invalidate(&mut self) -> Option<Option<Display>> {
+        // If there is no adapter, there is nothing left for us to do.
+
+        if self.adapter.is_null() {
+            return Some(None);
+        }
+
+        // Otherwise, we get the next output of the current adapter.
+
+        let output = unsafe {
+            let mut output = ptr::null_mut();
+            (*self.adapter).EnumOutputs(self.ndisplay, &mut output);
+            output
+        };
+
+        // If the current adapter is done, we free it.
+        // We return None so the caller gets the next adapter and tries again.
+
+        if output.is_null() {
+            unsafe {
+                (*self.adapter).Release();
+                self.adapter = ptr::null_mut();
+            }
+            return None;
+        }
+
+        // Advance to the next display.
+
+        self.ndisplay += 1;
+
+        // We get the display's details.
+
+        let desc = unsafe {
+            let mut desc = mem::MaybeUninit::uninit().assume_init();
+            (*output).GetDesc(&mut desc);
+            desc
+        };
+
+        // We cast it up to the version needed for desktop duplication.
+
+        let mut inner: *mut IDXGIOutput1 = ptr::null_mut();
+        unsafe {
+            (*output).QueryInterface(&IID_IDXGIOutput1, &mut inner as *mut *mut _ as *mut *mut _);
+            (*output).Release();
+        }
+
+        // If it's null, we have an error.
+        // So we act like the adapter is done.
+
+        if inner.is_null() {
+            unsafe {
+                (*self.adapter).Release();
+                self.adapter = ptr::null_mut();
+            }
+            return None;
+        }
+
+        unsafe {
+            (*self.adapter).AddRef();
+        }
+
+        Some(Some(Display {
+            inner,
+            adapter: self.adapter,
+            desc,
+        }))
+    }
+}
+
+impl Iterator for Displays {
+    type Item = Display;
+    fn next(&mut self) -> Option<Display> {
+        if let Some(res) = self.read_and_invalidate() {
+            res
+        } else {
+            // We need to replace the adapter.
+
+            self.ndisplay = 0;
+            self.nadapter += 1;
+
+            self.adapter = unsafe {
+                let mut adapter = ptr::null_mut();
+                (*self.factory).EnumAdapters1(self.nadapter, &mut adapter);
+                adapter
+            };
+
+            if let Some(res) = self.read_and_invalidate() {
+                res
+            } else {
+                // All subsequent adapters will also be empty.
+                None
+            }
+        }
+    }
+}
+
+impl Drop for Displays {
+    fn drop(&mut self) {
+        unsafe {
+            (*self.factory).Release();
+            if !self.adapter.is_null() {
+                (*self.adapter).Release();
+            }
+        }
+    }
+}
+
+pub struct Display {
+    inner: *mut IDXGIOutput1,
+    adapter: *mut IDXGIAdapter1,
+    desc: DXGI_OUTPUT_DESC,
+}
+
+impl Display {
+    pub fn width(&self) -> LONG {
+        self.desc.DesktopCoordinates.right - self.desc.DesktopCoordinates.left
+    }
+
+    pub fn height(&self) -> LONG {
+        self.desc.DesktopCoordinates.bottom - self.desc.DesktopCoordinates.top
+    }
+
+    pub fn attached_to_desktop(&self) -> bool {
+        self.desc.AttachedToDesktop != 0
+    }
+
+    pub fn rotation(&self) -> DXGI_MODE_ROTATION {
+        self.desc.Rotation
+    }
+
+    fn create_gdi(&self) -> Option<CapturerGDI> {
+        if let Ok(res) = CapturerGDI::new(self.name(), self.width(), self.height()) {
+            Some(res)
+        } else {
+            None
+        }
+    }
+
+    pub fn hmonitor(&self) -> HMONITOR {
+        self.desc.Monitor
+    }
+
+    pub fn name(&self) -> &[u16] {
+        let s = &self.desc.DeviceName;
+        let i = s.iter().position(|&x| x == 0).unwrap_or(s.len());
+        &s[..i]
+    }
+
+    pub fn is_online(&self) -> bool {
+        self.desc.AttachedToDesktop != 0
+    }
+
+    pub fn origin(&self) -> (LONG, LONG) {
+        (
+            self.desc.DesktopCoordinates.left,
+            self.desc.DesktopCoordinates.top,
+        )
+    }
+}
+
+impl Drop for Display {
+    fn drop(&mut self) {
+        unsafe {
+            (*self.inner).Release();
+            (*self.adapter).Release();
+        }
+    }
+}
+
+fn wrap_hresult(x: HRESULT) -> io::Result<()> {
+    use std::io::ErrorKind::*;
+    Err((match x {
+        S_OK => return Ok(()),
+        DXGI_ERROR_ACCESS_LOST => ConnectionReset,
+        DXGI_ERROR_WAIT_TIMEOUT => TimedOut,
+        DXGI_ERROR_INVALID_CALL => InvalidData,
+        E_ACCESSDENIED => PermissionDenied,
+        DXGI_ERROR_UNSUPPORTED => ConnectionRefused,
+        DXGI_ERROR_NOT_CURRENTLY_AVAILABLE => Interrupted,
+        DXGI_ERROR_SESSION_DISCONNECTED => ConnectionAborted,
+        E_INVALIDARG => InvalidInput,
+        _ => {
+            // 0x8000ffff https://www.auslogics.com/en/articles/windows-10-update-error-0x8000ffff-fixed/
+            return Err(io::Error::new(Other, format!("Error code: {:#X}", x)));
+        }
+    })
+    .into())
+}

libs/scrap/src/lib.rs

@@ -0,0 +1,20 @@
+#[cfg(quartz)]
+extern crate block;
+#[macro_use]
+extern crate cfg_if;
+pub extern crate libc;
+#[cfg(dxgi)]
+extern crate winapi;
+
+pub use common::*;
+
+#[cfg(quartz)]
+pub mod quartz;
+
+#[cfg(x11)]
+pub mod x11;
+
+#[cfg(dxgi)]
+pub mod dxgi;
+
+mod common;