Compare commits

...

951 Commits
0.7.0 ... 1.0.3

Author SHA1 Message Date
bd7e4ab695 VERSION 1.0.3: public preview release
After many months of intense development, ZeroTier is proud to release version
1.0.3 of ZeroTier One.

This version focuses on under-the-hood and network level improvements to
prepare the way for more user-facing improvements in the months to come, as
well as new products built around the ZeroTier core.

1.0.3 contains a large number of changes, so we're not going to push it out
via our auto-update mechanism yet. We're going to update the download links
on the web site and let users try it out for a while first. If problems are
found, we'll do a 1.0.4 before we push it out to existing installations.

--
Important note for Linux users: we've decided to stop pushing auto-updates for
Linux, and this version's official Linux binaries are built without update
checking enabled. Linux is used mostly on servers, and based on user feedback
we've found that most users don't like anything auto-updating outside of the
normal package management channels. Instead, we'll be working over the next
few months to get ZeroTier One included in a number of upstream Linux
distributions. That way you'll be able to 'apt-get' or 'yum' install it and
stay up to date that way. Auto-updates will remain for Macintosh and Windows
users until/unless we can move to 'app store' deployment on those platforms.
--

Now for the change list. It's a big one!

NEW FEATURES and IMPROVEMENTS

 * Client support is in place for preferred relays on a per-network basis.
   This allows you to define statically assigned nodes that act as relays for
   indirect communication and connection setup for communication between peers
   on a given virtual network. If defined, they'll be used in preference to
   supernodes for this purpose. If they're offline, ZeroTier will fall back to
   global supernodes. This will require support on the web control panel for
   most users to use.

 * This version sends NAT "keepalive" packets every 20 seconds, which is
   similar to the behavior of most SIP phones. This should improve reliability
   behind NATs with short timeouts and certain cheap consumer NAT devices.

 * Improvements have been made to NAT traversal to traverse more symmetric
   NAT configurations, and to rate limit traversal attempts to avoid looking
   like a port scan.

 * New direct paths are now confirmed prior to use. This should improve
   reliability in cases where a NAT traversal attempt "half succeeds" by
   preventing the use of direct links that aren't actually usable.

 * A new geo-located TCP tunneling fallback implementation should improve
   performance for heavily firewalled users who can't use UDP.

 * ZeroTier now uses remotely reported accounts of your external IP address
   to detect changes in your network connectivity instead of relying on
   "fingerprinting" of the OS-level local network environment. This should
   improve reliability in cases where external routers have dynamic IPs or
   when changing between networks with different external IPs but similar
   internal addressing schemes. This should also improve reliability for
   use within virtual machines, since the external link address might change
   but the VM's link addresses will not.

 * We've eliminated the old Unix domain socket (or named pipe on Windows)
   control bus in favor of a local HTTP JSON API. It runs on 127.0.0.1
   port 9993 and can be accessed via standard HTTP. This improves
   interoperability with scripts and other tools and allows us to use
   HTML5 for the desktop UI component. See README.md in the service/
   subfolder of the source tree for JSON API documentation.

 * The old Qt GUI has been dropped in favor of a React-based HTML5 UI. The
   code for this is found in ui/, and if ui/ is present in the ZeroTier
   home folder the JSON API HTTP server will serve it on 127.0.0.1/9993.
   The Windows and Mac UIs are now web control wrappers which access this
   UI locally and automate the process of token lookup and login.

PACKAGING / INSTALLATION IMPROVEMENTS

 * The Macintosh version is now packaged as a .pkg file instead of the old
   .app that would download its components and bootstrap itself. Several
   Mac users had problems with this, so we made it a package instead.

 * The Windows installer now includes a cleaner driver installation module
   that installs the driver as part of the main MSI file instead of spawning
   a subprocess.

BUG FIXES

 * Windows now comes with an updated NDIS6 Ethernet tap device driver.
   If you still have the old NDIS5 driver installed you'll keep using it,
   so if you want to switch to the NDIS6 driver uninstall your old version
   and do a fresh install of the new one. NDIS5 is deprecated, so we are
   hoping an NDIS6 driver will fix a number of difficult to reproduce
   issues that some Windows users have reported. It will also likely
   improve performance.

 * Fixed a "pseudo" memory leak related to the old auto-update code. The
   amount of "committed" (but not used) memory would increase over time.
   Since this was not actual used memory it didn't cause real problems,
   but the issue is gone now.

 * A very rare threading deadlock was fixed.

 * Fix for Linux installer that would falsely recognize systemd on some
   Ubuntu systems.

DEEP UNDER THE HOOD

 * This version has been heavily refactored at the source code level! The
   node/ subfolder now contains the core ZeroTier network virtualization
   engine without any OS-specific or transport-specific code. This is in
   preparation for future plans around embedded devices, etc. There is now
   a public C-level API in include/ZeroTierOne.h that defines an interface
   to the node core.

 * A new network controller implementation is in 1.0.3 based on SQLite and
   the local JSON API control bus. IT HAS NOT BEEN HEAVILY TESTED YET, so we
   do not recommend using it in production until the next version. You are
   welcome to experiment with it.
2015-06-03 19:34:00 -07:00
ee1a008f2d Product code for 1.0.3 etc. 2015-06-03 18:53:54 -07:00
4c687fca45 No auto-updates on BSD either. 2015-06-03 18:13:42 -07:00
753a80d419 Linux auto-update is going away. 2015-06-03 17:53:21 -07:00
7213a6cf0b Make max HTTP message size (max update size) larger since Windows MSI is about 8MB already. 2015-06-03 17:20:30 -07:00
9b0c8965bb Make status line in UI show "TUNNELED" if slow TCP tunneling mode is active. 2015-06-03 16:47:07 -07:00
7e647c5303 NOHUP-ify the child process on OSX auto-update. 2015-06-03 16:37:24 -07:00
fe87136870 Auto-update fix -- signature is in hex. 2015-06-03 16:25:16 -07:00
b897ec1efd Put version back to 1.0.3. 2015-06-03 16:19:44 -07:00
6a11c76248 Temporarily bump version to fake 1.0.99 to test auto-update within network. 2015-06-03 16:09:56 -07:00
3512402558 OSX .pkg files must be signed with productsign and an installer cert. 2015-06-02 19:17:39 -07:00
4fe12756d4 Get rid of "autoupdating" in Linux package names. 2015-06-02 17:14:18 -07:00
bf415bdeb9 docs 2015-06-02 17:05:31 -07:00
c5a3e80113 Linux installer tweaks, and Mac updater tweak. 2015-06-02 16:54:27 -07:00
806ea79f37 docs 2015-06-02 16:44:43 -07:00
cd58614c23 docs 2015-06-02 16:42:31 -07:00
0b68344fc8 docs 2015-06-02 16:41:57 -07:00
191b8f8164 docs 2015-06-02 16:39:21 -07:00
29e3437350 gcc not g++ for CC 2015-06-02 16:30:42 -07:00
65999611d7 Eliminate "which" dependency in Linux makefile. 2015-06-02 16:29:23 -07:00
9d49e8f237 docs 2015-06-02 16:24:44 -07:00
855d893c67 docs 2015-06-02 16:23:43 -07:00
a2690047bb docs 2015-06-02 16:16:14 -07:00
648efff1f6 Delete merge temp file. 2015-06-02 12:50:32 -07:00
3d6c1860ca Merge branch 'adamierymenko-dev' into android-jni 2015-06-02 12:49:36 -07:00
f0be5e814e Merge organized .gitignore 2015-06-02 12:49:32 -07:00
79efceb57b Organize .gitignore and merge stuff from Android-JNI branch. 2015-06-02 12:48:59 -07:00
b8f40c0b91 Yet another /Users/api path in packages script. 2015-06-02 12:01:00 -07:00
97dd8d864f Fix paths again in Mac pkg build. 2015-06-02 11:59:05 -07:00
1afd02df54 Path fix in Packages build file for Mac 2015-06-02 11:47:32 -07:00
fb0bf52b1b Fixed sending a port number of 0 to ZT1.
Fixed VirtualNetworkConfigFunction (creating array to send to Java)
Fixed the creating InetAddress instead of InetSocketAddress in virtual network config callback
2015-06-01 20:03:28 -07:00
74f7d5377d Enable ZT_TRACE and more verbose build output 2015-06-01 20:01:37 -07:00
a9a390a930 Apply @marning suggested SSE auto-detect to make builds easier on non-x86 platforms: aa2fd044cb 2015-06-01 19:43:06 -07:00
d7344871e6 Linux build fix. 2015-06-01 19:27:53 -07:00
aab17d9f1f Kill obsolete amSupernode method -- we now have no differing behaviors. 2015-06-01 19:18:26 -07:00
ecb6a1d84f docs 2015-06-01 19:12:20 -07:00
5341e32729 Fix to GitHub issue #140 -- network preferred relays. Also go ahead and allow RENDEZVOUS from regular peers. 2015-06-01 19:05:27 -07:00
960ceb4791 Rest of GitHub issue #140 implementation. 2015-06-01 17:50:44 -07:00
318c2f025b Call it _relays since there might be other kinds later. 2015-06-01 17:09:37 -07:00
5bc89034bc Always ping / contact network preferred relays (if any). 2015-06-01 16:53:58 -07:00
229195166a Add BackgroundResolver to Windows build. 2015-06-01 16:06:50 -07:00
b3b9af0dd8 Fix for GitHub issue #170 2015-06-01 11:56:15 -07:00
5015c0ae78 more logging 2015-05-28 21:03:37 -07:00
b6196a53de Fix DataStoreGetFunction. 2015-05-28 20:37:16 -07:00
58ca657da6 Use object arrays rather than ArrayList. JNI side 2015-05-28 20:36:54 -07:00
7822616966 Replace ArrayList instances with [] 2015-05-28 20:01:30 -07:00
e3feac17b1 Merge branch 'adamierymenko-dev' into android-jni 2015-05-27 20:43:30 -07:00
4c680e3126 LOTS more error checking and logging.
Running into a wall attempting to add items to an ArrayList from the JNI side
2015-05-27 20:42:54 -07:00
ea419c21d0 Fix installer path, add netconf option to make-linux. 2015-05-28 03:13:23 +00:00
502cd6921f Fix for GitHub issue #133, and move restart out of installer to address restart problem. Installer probably should NOT mess with the running service, since Linux servers are likely to be production. 2015-05-27 13:50:11 -07:00
09631ad382 fix datastore get call in JNI
Just delete the local reference rather than do an array delete.  Array delete was causing a crash on loading network config files.  Deleting the local ref works fine, though, as it still lets the JVM garbage collecter know that the native code is done with the array
2015-05-26 21:32:56 -07:00
2d67196667 added the android verbose log level and moved most jni debug messages to verbose 2015-05-26 21:31:34 -07:00
9755dad7ff add a missing break from a switch 2015-05-26 21:30:33 -07:00
adaf9cf32b still getting re-used to all the places you have to put access modifiers in Java 2015-05-26 20:03:47 -07:00
703c311e07 Merge branch 'adamierymenko-dev' into android-jni 2015-05-26 19:17:29 -07:00
e184aa4cb4 Clean old netconf-service from attic. 2015-05-26 18:16:12 -07:00
fbb990f8a3 Mac uninstall.sh update. 2015-05-26 14:36:04 -07:00
ff2272d59a Delete some temporary code. 2015-05-26 13:34:08 -07:00
c075e68c6c More work on ZT1 NodeJS API client library. 2015-05-26 13:32:47 -07:00
ecb1ee8e0d Renaming... 2015-05-26 09:03:39 -07:00
ba7809367a JS stuff reorg. 2015-05-26 09:01:58 -07:00
5e3c6d9e0d Some nodeJS work, and apply fix from GitHub issue #166 plus a small optimization to avoid repeated calls to _allMulticastGroups(). 2015-05-25 14:21:05 -07:00
d8ad555b9a Go ahead and add flags and invFlags to the Rule table. 2015-05-25 13:20:10 -07:00
d29f2ce858 Clean up attic/ 2015-05-25 11:55:27 -07:00
af1d29cc6f Remove obsolete method. 2015-05-25 11:54:32 -07:00
91f02d699e Right now only FreeBSD can use BSDEthernetTap, which will probably get renamed accordingly. NetBSD and OpenBSD do not support tap, only tun, so they will have to wait. 2015-05-25 11:11:37 -07:00
6e998efd15 fixing up data store stuff 2015-05-23 18:29:16 -07:00
5c2aaad365 Merge branch 'adamierymenko-dev' into android-jni 2015-05-23 13:34:21 -07:00
d8783b14eb Build fix. 2015-05-22 15:46:06 -07:00
6867922d9e typo 2015-05-22 15:33:33 -07:00
9774f789f2 TCP fallback tunneling is now working. That hurt more than expected. 2015-05-22 14:52:23 -07:00
cdec05af24 One second delay between NAT-t events. 2015-05-22 13:12:14 -07:00
196f27f1f0 Add delay to NAT-t escalation stuff to try to address GitHub issue #167 2015-05-22 13:11:55 -07:00
b388d9fdc9 TCP proxy should actually bind to its TCP port. Seems like a good idea. 2015-05-22 10:14:44 -07:00
1e043a3f66 Remove link desperation from java API 2015-05-21 19:34:19 -07:00
c430d88bd4 Merge branch 'adamierymenko-dev' into android-jni
Conflicts:
	.gitignore
2015-05-21 19:14:49 -07:00
50aedda54d Basic TCP fallback -- now to test. 2015-05-21 18:33:52 -07:00
d9006712f6 Completely factor out "desperation" from the core. I thought of a significantly simpler way to move all of this logic entirely into the containing service, liberating the core from any concern over the nature of its pipe to the outside world. 2015-05-21 15:58:26 -07:00
123ff28863 Build fix. 2015-05-21 15:24:58 -07:00
0f7dcb3ef2 Add some proxy debugging, and auto-resolve and periodically re-resolve TCP fallback tunnel hostname. 2015-05-21 15:22:41 -07:00
61021fc778 BackgroundResolver test. 2015-05-21 14:11:44 -07:00
2ad69237cf Background resolver. 2015-05-21 13:44:33 -07:00
82f6b3f550 Clean old update code out of Windows service wrapper. 2015-05-20 20:21:20 -07:00
905d2e91e5 Windows auto-update integration into OneService. 2015-05-20 20:17:56 -07:00
1213073916 Apple auto-update stuff, now for Windows. 2015-05-20 19:38:49 -07:00
b6698d8415 Ground work for reincorporating software updater for select platforms. 2015-05-20 16:35:33 -07:00
e285a6e75f . 2015-05-20 15:20:05 -07:00
6fc090eb00 Don't actually "power cycle" the interface except on startup. Doing that after we're running could lose IP configuration. 2015-05-20 14:21:14 -07:00
0caac25d28 . 2015-05-19 20:13:19 -07:00
dd70188643 Make tap driver even more defensive... seems to maybe fix the new network problem. Have to test a bit more. 2015-05-19 18:40:34 -07:00
c7eb5f0c81 Windows build warning removal, be more defensive in Windows tap driver code, and clean up service start/stop in installer. 2015-05-19 18:13:20 -07:00
68cb7ad4cd Few more fixes to installer firewall rule settings. 2015-05-19 16:31:00 -07:00
9682f50b15 Get rid of old _winPokeAHole() hack in one.cpp and use Advanced Installer to configure firewall rules (because we can now). 2015-05-19 16:26:41 -07:00
63cea7d337 Try to automatically enable access to http://127.0.0.1 in web wrapper if IE is in enhanced security mode. 2015-05-19 16:02:26 -07:00
44d1bd14bd Enable right-click menu for copy/paste/etc. in Windows UI wrapper. 2015-05-19 14:48:57 -07:00
b4a34cc105 Add 32-bit chained MSI for NDIS6 driver... now to go test on 32-bit Windows (clean). (And Windows 10, and Windows Server, and ...) 2015-05-19 13:01:55 -07:00
32588b3d84 A visit to the Windows house of pain:
(1) Yes, you *can* create a mixed 32/64 bit Windows MSI installer that installs drivers. All you have to do is... umm... create individual sub-MSI files for each driver (one for 32, one for 64) and then package those in the main MSI files as "chained" MSI installers. Each of these must only be considered a prerequisite on 32 or 64 bit machines, respectively.

(2) Upgrade Advanced Installer version, add rules to uninstall NDIS6 tap device on uninstall.

(3) Fix IE issue in UI code.
2015-05-18 20:30:54 -07:00
992438f054 Confirm leaving networks. 2015-05-18 16:02:37 -07:00
8c7a4efe1a Small cosmetic fix to bottom bar. 2015-05-18 15:56:18 -07:00
e0313455e7 Hide unneeded menus in MacGap. 2015-05-18 15:53:49 -07:00
ac629150ac Create symlinks in Mac postinst script. 2015-05-17 21:26:38 -07:00
89027d78ac Mac .pkg building using Packages (third party app) instead of old bootstrapping .app and installer script. 2015-05-17 21:24:02 -07:00
f48509d50c Mac script to get HTTP proxy settings -- will be used by Mac updater. 2015-05-17 20:28:09 -07:00
c76217c2d4 Delete old UI code -- officially dead. 2015-05-17 19:50:19 -07:00
2d700f644b Add signed binary build of Mac GUI wrapper. 2015-05-17 19:48:21 -07:00
c76b9d1340 Respect user home directory copies of authtoken.secret or ~/.zeroTierOneAuthToken in CLI like we do in GUI wrappers. 2015-05-17 19:13:22 -07:00
0e87002d78 BSDEthernetTap build fixes. 2015-05-17 18:31:41 -07:00
ddaf3ef347 Bring BSDEthernetTap into the current century. 2015-05-17 18:28:04 -07:00
2810cd7c15 Build fixes for G++, building without SQLite3 present, and warning removal. 2015-05-17 23:56:47 +00:00
0af18b164c /var/db is for all of xBSD 2015-05-17 16:06:29 -07:00
086f21ed70 Refactor and simplify controller integration with JSON API and OneService. 2015-05-17 15:51:07 -07:00
7649d6746b docs 2015-05-17 15:38:01 -07:00
0e00981059 docs 2015-05-17 14:01:25 -07:00
d41b6eb0c8 docs 2015-05-17 10:14:12 -07:00
651e67f2e5 Add a feature to generate a new network ID on POST. 2015-05-17 09:36:35 -07:00
e0090e56f4 Build fix on OSX -- cannot call SqliteNetworkController if not compiled in. 2015-05-16 18:59:11 -07:00
9a00366b18 Merge branch 'adamierymenko-dev' into android-jni 2015-05-16 18:55:19 -07:00
69ceb7e730 Basic controller JSON API seems to be working. 2015-05-16 17:12:29 -07:00
cf51961d52 . 2015-05-16 16:32:13 -07:00
c9fd8de007 . 2015-05-16 16:22:38 -07:00
a187d290f1 Fixes to control plane, API, eliminate problematic inheritance pattern, and start on a NodeJS class for talking to the network controller. 2015-05-16 16:09:28 -07:00
27c5f04d68 Add -U option to skip root check and permit run as non-privileged user. 2015-05-16 14:52:09 -07:00
d0935f667f Merge branch 'adamierymenko-dev' into android-jni 2015-05-16 14:35:35 -07:00
4be4908914 Fix some prepared statement problems. 2015-05-16 14:34:51 -07:00
38243e5eff OSX build fix 2015-05-16 14:07:15 -07:00
0bb92715f4 DELETE function in network controller JSON API, and a newIdentity convenience request in ControlPlane for scripted testing. 2015-05-16 13:42:53 -07:00
78769900a9 More network controller cleanup, and some features to permit scripted testing. 2015-05-16 12:50:42 -07:00
65a9a9a6f2 typo 2015-05-15 15:30:44 -07:00
e269846f84 Netconf docs, add clock field to status, simplify netconf a bit by eliminating caching for now. We will re-add if it is needed. 2015-05-15 15:20:12 -07:00
6d2376eb9c Controller API status message. 2015-05-15 09:41:45 -07:00
f693d4d0c8 Network controller cleanup and an extra sanity check. 2015-05-15 09:32:10 -07:00
0bdd56ebd6 A few revisions to PFS design. 2015-05-15 09:04:39 -07:00
d0e0f5dd12 Basic OpenBSD compile fixes -- still need to update BSDEthernetTap, will do that later. Should be able to re-use FreeBSD port for OpenBSD, but we will see. 2015-05-15 08:48:53 -07:00
e94518590d First stab of PFS design work with PKC security -- may not implement in 1.0.3 but stubbing out. 2015-05-14 17:41:05 -07:00
4a0280686c Merge branch 'adamierymenko-dev' into android-jni 2015-05-13 20:52:23 -07:00
a8835cd8b3 Some prep work to make room for perfect forward security (PFS). Will not affect existing clients. 2015-05-13 18:53:37 -07:00
bdce679d84 Should fix deadlock issue in GitHub issue #166 2015-05-13 16:55:18 -07:00
241f308334 Fix to tap reset code in Windows tap connector. 2015-05-08 16:49:08 -07:00
e744580b89 Fix a bunch of Windows tap issues. Turns out NDIS6 allowed us to ditch some NDIS5 cruft, but I did have to add one hack specific to that one instead. Seems reliable now. 2015-05-08 16:31:50 -07:00
1b895c45eb Make peer list font a bit smaller. 2015-05-08 15:04:01 -07:00
2158d26bd7 Show last unicast and multicast frames. 2015-05-08 15:01:05 -07:00
4565e9948f Now this works... Windows UI wrapper. Turns out there were workarounds, but IE does indeed suck. 2015-05-08 14:58:29 -07:00
c1e5c1c710 Fix some settings on WebControl implementation. 2015-05-08 14:51:24 -07:00
257187a284 Fixes for Windows WebControl. 2015-05-08 14:47:01 -07:00
8e888f8df9 Hmm... will this work? Very first child of <head> 2015-05-08 12:41:06 -07:00
8594e17f2b Move mac-ui into src/ 2015-05-08 12:35:41 -07:00
a40192a40b Scratch that wrapper... it was easy to make, but it turns out WebControl is IE4 (!!!?!). Also prefer NDIS5 to NDIS6 *if* NDIS5 is installed. We will no longer ship it, but this will make older installs use the same driver they are already using. Should ease upgrade. 2015-05-08 12:35:03 -07:00
92ca53e141 Add pre-build signed UI wrapper .exe. 2015-05-08 12:16:02 -07:00
a913f00670 Windows WebControl based wrapper for web UI. 2015-05-08 11:55:09 -07:00
b1164ed181 icons 2015-05-08 11:08:06 -07:00
c0caba8944 docs 2015-05-08 10:31:01 -07:00
0be3190d49 UI spacing tweaks. 2015-05-08 10:20:38 -07:00
bd2ce82ea6 Minify JS in UI, add Makefile. 2015-05-08 10:03:35 -07:00
a4a62be698 UI tweaks, get JSXTransformer out. 2015-05-08 09:39:07 -07:00
da45840e5a Merge branch 'adamierymenko-dev' into android-jni
Conflicts:
	.gitignore
2015-05-07 19:16:35 -07:00
4426899e8c Add support for local user account caching of authtoken.secret as in old UI -- this is now pretty much working. 2015-05-06 21:02:59 -07:00
d56e9fce41 Get user data out of repo. 2015-05-06 20:45:02 -07:00
5b54612d91 Pass authtoken in from user, and add a wrapper for web UI on Mac. 2015-05-06 20:41:51 -07:00
8130b2a0de Merge branch 'adamierymenko-dev' into android-jni 2015-05-06 20:24:01 -07:00
e58047eaa0 UI work... 2015-05-06 19:39:45 -07:00
03dbec960a UI tweaks 2015-05-06 17:42:29 -07:00
20b76d266d Merge branch 'adamierymenko-dev' into android-jni 2015-05-06 17:37:11 -07:00
4a2c46e008 Well that works... pretty web UI (currently only works on test node with hard-coded auth code... need to figure out how to plumb that) 2015-05-06 17:28:11 -07:00
b2b32e5969 Beginning of HTML+Bootstrap+React UI for new desktop client -- looking like it will be easier than retrofitting the old Qt client for the new API. 2015-05-05 20:53:30 -07:00
bdc5b3d3a5 Merge branch 'adamierymenko-dev' into android-jni 2015-05-04 20:12:26 -07:00
e28712555d build & package libZeroTierOneSDK.jnilib on Mac oS
Signed-off-by: Grant Limberg <glimberg@gmail.com>
2015-05-04 20:04:44 -07:00
40f312a827 When we reset within scope, erase the other entries for that scope so we won't keep resetting the same scope repeatedly. 2015-05-04 19:02:36 -07:00
18ca6f34ff Always update timestamp. 2015-05-04 18:45:39 -07:00
59fa687830 Make timeout also apply to null check in iam() 2015-05-04 18:43:24 -07:00
e922324bc6 Stop inlining all the Packet armor/dearmor stuff to reduce binary bloat. This stuff is called all over the place. 2015-05-04 18:39:53 -07:00
b4b067bf12 So we need to keep track of external surface per reporter, since some NATs assign different external IPs for each external destination. Keeping just one known surface could create a race condition. 2015-05-04 18:34:30 -07:00
625ddf41a7 docs 2015-05-04 17:41:48 -07:00
af66f14761 Merge branch 'adamierymenko-dev' into android-jni 2015-05-04 16:47:18 -07:00
da254d967f Hack around GitHub issue #165 (?) 2015-05-04 14:11:54 -07:00
7054c365f2 put a read timeout on the socket 2015-05-02 18:34:47 -07:00
06ab338ecc added naive OneService implementation.
Does nothing but send packets to master nodes and listen for packets back.
2015-05-02 18:24:52 -07:00
ad6ec22857 DataStore now works 2015-05-02 18:22:56 -07:00
a9307693a6 Adding Data Store implementations for Android and normal Java 2015-05-02 17:32:12 -07:00
742c59a7c7 Refactor package name from com.zerotierone.sdk to com.zerotier.sdk 2015-05-02 16:54:00 -07:00
e79a6915ff ensure java is compiled for JVM 1.7. Android cant read .class files compiled for 1.8 2015-05-02 12:06:07 -07:00
818339f966 replace old direct calls to FindClass, GetMethodID, etc with calls that use the cache 2015-05-02 12:05:40 -07:00
079d248eab added a JniCache objectet for caching jclass, jmethodID, and jfieldID objects 2015-05-02 12:05:02 -07:00
9f2732d661 add the basedir to the ant buildfile 2015-05-02 10:16:10 -07:00
fb6b56a85f clean up unused imports 2015-05-01 18:27:34 -07:00
02b33e3763 Yeah it helps to byte swap the port back to little-endian before sending the port off to Java 2015-04-30 22:07:14 -07:00
b242886c33 Merge branch 'adamierymenko-dev' into android-jni 2015-04-30 21:51:05 -07:00
0a15eae00f Setup native build for Windows Java.
Still need to do Mac & Linux
2015-04-30 21:50:28 -07:00
75d7137025 added a class I found to load JNI code from within JAR files on non-android platforms.
That doesn't come for free, unlike android.
2015-04-30 21:50:05 -07:00
9279bac385 Fix deadlock in SelfAwareness by deferring reconnects. 2015-04-30 21:09:41 -07:00
105e1a016f Get rid of G++ compiler warning. 2015-04-30 20:41:25 -07:00
604576075e Add some missing includes that older G++ cares about. 2015-04-30 20:40:33 -07:00
52df59c552 Merge branch 'adamierymenko-dev' into android-jni
Conflicts:
	.gitignore
2015-04-30 19:19:45 -07:00
d3820049b8 Add reported external address to OK(HELLO) TRACE to verify SN behavior. 2015-04-30 18:25:31 -07:00
9eb7698f0e Learn external IP addresses on OK(HELLO) too. 2015-04-30 16:40:04 -07:00
5185103692 Fix to create-test-root-topology. 2015-04-30 16:13:17 -07:00
3ac23165c7 Kill old testnet -- was useful in its time, but Docker make running real test networks locally stupid easy and a more realistic simulation. 2015-04-30 16:04:17 -07:00
9a34fde8a5 Make sure identity.public exists and stays in sync, cleanup extra new in Node, and test script for local testnets. 2015-04-30 16:03:44 -07:00
918fc8884b Update mktopology so it works again and can easily be used to create test dictionaries. 2015-04-30 15:31:01 -07:00
f3d7c9d681 Helps to index the array when enumerating a C array. 2015-04-30 15:16:21 -07:00
226e0f8722 docs and Makefile for tcp-proxy 2015-04-30 10:56:45 -07:00
288d73a4ad A few more refinements to TCP code, ready to integrate with "desperation" stuff and test. 2015-04-30 10:47:27 -07:00
9464504e4a DataStoreGet and Put and EventListener appear to work 2015-04-29 21:20:50 -07:00
7e0cc28a89 Fixes for bugs pointed out by updating warnings 2015-04-29 19:29:35 -07:00
0a2d1e7a66 Ignore windows debug build files 2015-04-29 19:29:18 -07:00
9bf9670ff9 add more warnings to the JNI build 2015-04-29 19:14:52 -07:00
a9a3705877 TCP tunneling implementation -- not tested yet and no initiation yet. 2015-04-28 12:43:10 -07:00
5983b4367b jclass pointers aren't as cacheable as originally thought.
There is a way to do it.  We can try it later if we determine it's needed for performance reasons.  Otherwise, don't use static to cache them
2015-04-27 18:38:13 -07:00
d1ed269537 Switch to InetSockAddress instead of InetAddress so we can send the port # to java as well 2015-04-27 17:48:37 -07:00
73d68c0c98 Merge branch 'adamierymenko-dev' into android-jni 2015-04-27 17:24:55 -07:00
7dcde7503a For now just bind TCP to localhost, since we do not permit remote use of the control bus at all yet. 2015-04-26 18:15:40 -07:00
b9f7f75ddf TCP proxy for tunneling (desperation > 0). 2015-04-26 16:38:39 -07:00
a1005ca858 Do not unite() peers across different IP scopes as this would pretty much never work. 2015-04-26 16:03:16 -07:00
8c5ec54711 . 2015-04-26 14:05:36 -07:00
ab3f4d7539 Was thinking about this HTTP tunneling stuff but decided against for now. Stash unfinished code in attic/ 2015-04-26 14:05:13 -07:00
a1d6df4bf8 Starting on new external updater binary. 2015-04-26 10:01:07 -07:00
4c71e92a67 It's now possible to actually create a Node object in Java/Android!!! 2015-04-25 20:47:21 -07:00
3bdbc6390f Added logging to Android logcat 2015-04-25 20:46:56 -07:00
8a09e0ec3c added NodeException 2015-04-25 20:46:41 -07:00
db80070ccb fix strings pointing to enum fields in ResultCode java class 2015-04-25 19:19:58 -07:00
042f914dc5 If we could not recursively add ZeroTierOneSDK.jar to ZeroTierOneSDK.jar, that would be greeeaaaaat 2015-04-25 19:09:30 -07:00
ec45aeb42a Merge branch 'adamierymenko-dev' into android-jni 2015-04-25 18:59:52 -07:00
a86a0ab2b1 Package the Android native libraries right in the .jar file 2015-04-25 18:59:00 -07:00
29bb2a9004 fix for a previously renamed class 2015-04-25 18:58:43 -07:00
56f8160af8 generate javadocs for the Java SDK 2015-04-25 17:29:07 -07:00
7af1f3a79a attic cleanup 2015-04-25 17:25:06 -07:00
e78899fddf Rebuild and re-sign the x86 driver... previous attempt was somehow borked but this one loads on Win7/x86 fine. 2015-04-25 16:00:25 -07:00
9325535ced x86 version of signed NDIS6 driver. 2015-04-25 15:31:27 -07:00
720ac93ba9 Use NDIS6 driver preferentially if available. 2015-04-25 15:22:43 -07:00
42b4148876 NDIS6 driver signed x64 build (not fully tested yet, but committing work) 2015-04-25 14:52:02 -07:00
4b658d83bc Rename old driver to -ndis5. 2015-04-25 13:11:58 -07:00
d4c06e924d Do the same modifications to the NDIS 6 code base as were done to the old 5 driver: disable all the 'tun' functionality, and add the IOCTL for querying the multicast list at Ethernet (L2) level. 2015-04-25 12:21:08 -07:00
1ebe2ad920 NDIS6 driver with VS project to build -- builds correctly, not customized for ZT yet. 2015-04-24 23:31:51 -07:00
0d4283a3fa Cache jclass and jmethod instances for callbacks on the JniRef struct.
This is safe to cache as none of the instantiated callback interfaces can be changed once a Node object is created.
2015-04-24 20:34:36 -07:00
9c62ce9e6f implemented EventCallback
All callback methods are now implemented
2015-04-24 20:13:21 -07:00
f2eed5a65f implemented WirePacketSendFunction 2015-04-24 19:43:17 -07:00
5e1fb4e253 Realized that the jclass and jmethodID variables in the callbacks cannot be static
There's no guarantee that ALL calls to the callbacks will be on the same class as they're just interfaces and user defined
2015-04-24 19:35:18 -07:00
dc00ce4f44 added DataStorePutFunction implementation
updated  DataStorePutListener to also have an onDelete() method
2015-04-24 19:28:44 -07:00
53ebd5a9a5 don't need to pass buffer size because java arrays have a .length member 2015-04-24 19:14:59 -07:00
d5fc2b39aa implemented DataStoreGetFunction callback 2015-04-24 19:11:49 -07:00
4137246653 implemented VirtualNetworkFrameFunctionCallback 2015-04-24 18:49:52 -07:00
28168fa673 implement VirtualNetworkConfigFunctionCallback 2015-04-24 18:39:17 -07:00
99af0f3a88 moved creation of VirtualNetworkConfig objects to ZT1_jniutils
added implementation of networks() method
2015-04-24 18:20:10 -07:00
6f07a476a6 create and return the peer array 2015-04-24 18:06:26 -07:00
52a20b4b0f create PeerRole and PeerPhysicalPath objects 2015-04-24 17:58:59 -07:00
f3c29d3f0d rename PhysicalPeerPath -> PeerPhysicalPath to reflect C API 2015-04-24 17:58:31 -07:00
b3429481cd update build instructions
Signed-off-by: Grant Limberg <glimberg@gmail.com>
2015-04-24 17:04:08 -07:00
0f808e11df Merge branch 'adamierymenko-dev' into android-jni 2015-04-24 16:48:48 -07:00
ce09e363dc Destroy tap devices on Windows 'leave'. 2015-04-24 16:31:19 -07:00
e2c65bf16a Bring Windows service code up to date and into sync. 2015-04-24 15:44:39 -07:00
0e31551349 Take winhttp out of lib list, since we don't use it anymore. 2015-04-24 15:15:14 -07:00
f5848972f9 Windows now builds and runs selftest correctly, and fixed a Windows (and possibly other platforms) issue in Phy<>. 2015-04-24 15:05:28 -07:00
54954f5b88 First pass of Windows cleanup and build fixes... 2015-04-24 13:35:17 -07:00
883a216d2a Build fixes. 2015-04-24 12:29:31 -07:00
1a65a79e57 set 'build' as the default ant target
Signed-off-by: Grant Limberg <glimberg@gmail.com>
2015-04-23 23:14:09 -07:00
6dd3c07b25 removing unneeded jni headers
Signed-off-by: Grant Limberg <glimberg@gmail.com>
2015-04-23 23:09:42 -07:00
1df6bc6bc3 just adjusting some alignment
Signed-off-by: Grant Limberg <glimberg@gmail.com>
2015-04-23 23:09:30 -07:00
9ab7280703 added infrastructure for Node.peers() and Node.networks() functions
Signed-off-by: Grant Limberg <glimberg@gmail.com>
2015-04-23 23:08:28 -07:00
7f6556eba0 node.networkConfig() now creates ArrayLists of multicast subscriptions and assigned addresses
Signed-off-by: Grant Limberg <glimberg@gmail.com>
2015-04-23 22:48:56 -07:00
1bea940323 fix field ID signatures
Signed-off-by: Grant Limberg <glimberg@gmail.com>
2015-04-23 22:47:56 -07:00
6ff2e6ecfe move findNode method back
Signed-off-by: Grant Limberg <glimberg@gmail.com>
2015-04-23 22:46:54 -07:00
d66f2cd54d Node.networkConfig now only needs to populate the lists of assigned addresses and multicast subscriptions and then it's finished
Signed-off-by: Grant Limberg <glimberg@gmail.com>
2015-04-23 21:43:16 -07:00
46adf870a1 move utility functions from anon namespace to ZT1_jniutils
Signed-off-by: Grant Limberg <glimberg@gmail.com>
2015-04-23 21:39:07 -07:00
4906f8e848 added stub utility functions for creating ArrayLists, appending items to ArrayLists, creating InetAddress objects, and MulticastGroup objects
Signed-off-by: Grant Limberg <glimberg@gmail.com>
2015-04-23 21:36:33 -07:00
fa9d42b7e5 finished the JNI implementation of the status() method on Node
Signed-off-by: Grant Limberg <glimberg@gmail.com>
2015-04-23 20:52:47 -07:00
1a528aec76 don't require clean before build
Signed-off-by: Grant Limberg <glimberg@gmail.com>
2015-04-23 20:34:59 -07:00
ffb9e2901e fix a build error
Signed-off-by: Grant Limberg <glimberg@gmail.com>
2015-04-23 20:29:23 -07:00
407e2fc7de Added ant build script. Requires NDK_BUILD_LOC environment variable pointing to the ndk-build script
fixed compile erros in Node and VirutalNetworkConfig

Signed-off-by: Grant Limberg <glimberg@gmail.com>
2015-04-23 20:17:29 -07:00
667a103a6a added functions to create Event, and VirtualNetworkStatus objects
Signed-off-by: Grant Limberg <glimberg@gmail.com>
2015-04-23 19:16:45 -07:00
32a35e6808 scaffolding for implementation of status() and networkConfig()
They should be able to be called, but will not return valid objects yet

Signed-off-by: Grant Limberg <glimberg@gmail.com>
2015-04-22 21:31:17 -07:00
34028aa7c8 Added implemenation for node.address()
Signed-off-by: Grant Limberg <glimberg@gmail.com>
2015-04-22 21:30:37 -07:00
3ccaef88b7 Added implementation for Node.version()
Signed-off-by: Grant Limberg <glimberg@gmail.com>
2015-04-22 21:29:45 -07:00
f5bb57d5aa fix call to networkConfig to pass the network id
Signed-off-by: Grant Limberg <glimberg@gmail.com>
2015-04-22 21:28:42 -07:00
a1a35e0279 Can't instantiate enum objects. Fix createResultObject() function so that it still works properly
Signed-off-by: Grant Limberg <glimberg@gmail.com>
2015-04-22 21:14:55 -07:00
1308f02b93 multicastSubscribe() and multicastUnsubscribe()
Signed-off-by: Grant Limberg <glimberg@gmail.com>
2015-04-22 20:33:38 -07:00
b078d69372 join() and leave() functions
Signed-off-by: Grant Limberg <glimberg@gmail.com>
2015-04-22 20:29:34 -07:00
e31e54483c added processBackgroundTasks function
Signed-off-by: Grant Limberg <glimberg@gmail.com>
2015-04-22 20:25:35 -07:00
3c499777c8 added implementation for processWirePacket
Signed-off-by: Grant Limberg <glimberg@gmail.com>
2015-04-22 20:21:12 -07:00
9c038d3ecd added a few missing function calls in the ZT1 Node API
Signed-off-by: Grant Limberg <glimberg@gmail.com>
2015-04-22 19:36:46 -07:00
6187a91f4c delete the ZT1_Node object when calling Java_com_zerotierone_sdk_Node_node_1delete
Signed-off-by: Grant Limberg <glimberg@gmail.com>
2015-04-22 19:29:45 -07:00
321b67c73c add a findNode() function to reduce copypasta
Signed-off-by: Grant Limberg <glimberg@gmail.com>
2015-04-22 19:29:13 -07:00
5df253fa69 added implementation for processVirtualNetworkFrame
Signed-off-by: Grant Limberg <glimberg@gmail.com>
2015-04-22 19:19:45 -07:00
3a6807d584 add assignedAddresses member to VirtualNetworConfig class
Signed-off-by: Grant Limberg <glimberg@gmail.com>
2015-04-22 19:19:08 -07:00
787b4a8e50 * Change a few method signatures from java.lang.Long to long[] so that values can be passed back.
Signed-off-by: Grant Limberg <glimberg@gmail.com>
2015-04-22 19:18:49 -07:00
b33e4af49f Merge branch 'adamierymenko-dev' into android-jni 2015-04-22 18:14:14 -07:00
5202fbdaf3 CRUD 2015-04-22 18:06:26 -07:00
103dcb072d CRUD 2015-04-21 19:49:04 -07:00
79f63ba30a Fix: make sure we do not assign broadcast address as an IP to new members. 2015-04-21 18:37:17 -07:00
71f006cbeb More CRUD, almost done... 2015-04-21 18:08:33 -07:00
e4046964f0 Forgot to run schema2c. 2015-04-21 16:50:02 -07:00
ddebe2d4c7 Network controller CRUD... :P 2015-04-21 16:41:35 -07:00
0c8051da15 Move JNI methods to the bottom of the class
Signed-off-by: Grant Limberg <glimberg@gmail.com>
2015-04-20 20:44:31 -07:00
e0c8ddb65b call close() from the Node class's finalize method
Signed-off-by: Grant Limberg <glimberg@gmail.com>
2015-04-20 20:36:59 -07:00
bd4049fdc0 Added JNI code for construction/destruction of ZT1_Node objects
Signed-off-by: Grant Limberg <glimberg@gmail.com>
2015-04-20 20:33:42 -07:00
5f314f209e Updated Java Node class native methods to pass the node ID
This is so that we know which C-based ZT1_Node struct is being operated on

Signed-off-by: Grant Limberg <glimberg@gmail.com>
2015-04-20 20:32:29 -07:00
99a1a4e65b Generated header files for JNI
Signed-off-by: Grant Limberg <glimberg@gmail.com>
2015-04-20 18:31:42 -07:00
ec3a1c87d1 first revision of the java API for ZeroTier One
Signed-off-by: Grant Limberg <glimberg@gmail.com>
2015-04-20 18:27:15 -07:00
f40eb665c5 Add build files for compiling ZeroTier One SDK for Android targets
Signed-off-by: Grant Limberg <glimberg@gmail.com>
2015-04-20 18:26:23 -07:00
ed107c4daf Network preferred relay stuff in netconf controller. 2015-04-20 17:47:12 -07:00
8a13cfdace Add per-network relays to NetworkConfig. 2015-04-20 17:14:16 -07:00
86c87875a7 OSUtils::resolve() 2015-04-20 16:07:38 -07:00
69076f8a45 Add per-network relay stuff to sqlite table schema. 2015-04-20 15:46:20 -07:00
60f05518aa (1) now builds and works on Linux, (2) fix a threading problem causing carsh on shutdown, (3) cleanup in selftest, re-enable Phy and Http tests. 2015-04-20 15:12:31 -07:00
740121504f Add a timestamp to netconf cache, fix some SQL queries in NC. 2015-04-17 15:21:53 -07:00
417f56de2f Add some TRACE instrumentation to external surface address awareness. 2015-04-17 12:19:01 -07:00
b51d00146b docs 2015-04-17 10:45:16 -07:00
8715242e7f build fix 2015-04-16 16:43:35 -07:00
895c32a0d2 Stash old software updater code, will refactor into separate utility. 2015-04-16 16:17:28 -07:00
489cc66b78 Don't need these files anymore. 2015-04-16 16:16:25 -07:00
ce77e67e00 docs 2015-04-16 16:15:25 -07:00
1f5700191f zerotier-cli suspiciously working... that didn't hurt *too* badly. 2015-04-16 16:12:10 -07:00
c4c5fa63d1 Almost done with JSON parsing for tabular output. 2015-04-16 15:51:56 -07:00
13d5073e5b CLI work and Makefile cleanup. 2015-04-16 15:07:58 -07:00
8333bf065e Basic CLI working with JSON output. Now to parse and support old tabular form. 2015-04-16 14:55:36 -07:00
53cbe485f0 Some cleanup, and bite the bullet and go ahead and write a simple Http client. Need a cross-platform built-in one to do cli right. 2015-04-16 14:13:44 -07:00
6c29e966dd Include a BSD licensed JSON parser for the CLI. 2015-04-16 12:27:51 -07:00
377367175c Update LZ4 in ext/ 2015-04-16 12:18:47 -07:00
12b4646ce8 Prettify JSON output. 2015-04-16 12:06:40 -07:00
4e5d2d2c72 Write a zerotier-one.port file to the home path to make CLI easy to write, and do a backward compatiable CLI in bash instead of as part of the executable. 2015-04-15 19:38:01 -07:00
21a7e774bb Wire API auth token stuff. 2015-04-15 19:14:12 -07:00
c301d8e438 Remove network/controller -- we will do this in Ruby instead since it will be part of the whole OnePoint project anyway. 2015-04-15 19:01:38 -07:00
d2503172d8 Add some additional detail to the peer record in CAPI and JSON control plane. 2015-04-15 19:00:26 -07:00
91ca238163 Compile fixes. 2015-04-15 18:47:38 -07:00
33c8d3c50b Compile fixes. 2015-04-15 18:36:32 -07:00
ea1859541c More cleanup, and fix for the extremely unlikely case of identity collision. 2015-04-15 18:32:25 -07:00
f7b1437154 Putting the main binary back together... 2015-04-15 17:00:26 -07:00
6369c264e2 Rename netconf to controller and NetworkConfigMaster to NetworkController for consistency. 2015-04-15 15:12:09 -07:00
871473255b Cleanup, drop 32-bit from Mac build flags since i386 is pretty thoroughly deprecated and dead on OSX. We will have to make our updater stop updating on any 32-bit Macs that might actually still be running ZT1. 2015-04-15 14:54:37 -07:00
a0f8685453 cleanup 2015-04-15 14:44:30 -07:00
8639538299 Rename One to OneService, create separate sources for other tools. 2015-04-15 14:42:26 -07:00
98bcc3d4b5 Disable a few noisy TRACEs, and limit how often we confirm new paths to avoid flooding. 2015-04-15 13:15:09 -07:00
1c9ca73065 Fix some deadlock issues, move awareness of broadcast subscription into core, other bug fixes. 2015-04-15 13:09:20 -07:00
508519b62a Tap driver load fix. 2015-04-14 19:21:56 -07:00
c9af603b9f Add beacon broadcasting back into Node. 2015-04-14 18:20:03 -07:00
aeb4b42ab3 Make tap itself handle remembering sticky device to nwid mappings. 2015-04-14 18:13:46 -07:00
67f1f1892f Bunch of tap stuff, IP address assignment hookups, etc. 2015-04-14 17:57:51 -07:00
e205e5fdfe Include tap device name in JSON output for network info. 2015-04-14 15:55:03 -07:00
347e98dcd2 Just return files from listDirectory() since that is all we need, fix network request on network restore logic, and remember saved networks in service/One 2015-04-14 15:32:05 -07:00
29a2175b7a Fix missed closedir() 2015-04-14 15:17:59 -07:00
49d31613b9 Fix some minor issues, now to reintegrate taps. 2015-04-14 15:16:04 -07:00
758b5caf94 Fix < logic. 2015-04-14 14:52:23 -07:00
6f4b30add8 Turns out you do have to unpack and compare sockaddr structures due to sin_len / sin6_len not present on all platforms and other junk. 2015-04-14 14:49:34 -07:00
1cfa67bbdd Bunch more control plane work, and shelve old UI -- React FTW. 2015-04-14 13:56:28 -07:00
a2605561af Basic control plane queries working. 2015-04-13 18:43:33 -07:00
b888e033c0 JSON control plane, almost done... 2015-04-13 18:12:45 -07:00
ff0eff4b7c Decided to back out of doing HTTP/TCP server *and* client within ZT itself. Instead we'll do the TCP tunneling endpoint as a separate little daemon. It will appear here shortly. 2015-04-13 12:27:29 -07:00
5c1262f324 Basic framework of HTTP server is there. 2015-04-10 19:36:29 -07:00
daef54ba32 HTTP server is in, and works. 2015-04-10 19:08:49 -07:00
5572b7ffb6 Simplify Phy<> to get rid of more indirections. 2015-04-10 17:07:06 -07:00
7576911951 Temporarily shelve testnet/ -- will resurrect self-contained testnet later perhaps, but probably will not by the time next version ships. Was mostly for debugging multicast anyway and that is now quite stable. 2015-04-10 11:42:02 -07:00
9e651b39e4 Add some TRACE around pinging (for now), and refactor service/One to just run in the foreground as some platforms may not require threads at all. 2015-04-10 11:40:45 -07:00
08a11a6f32 Since which tap to use is chosen statically at compile time and the factories are gone, there is now no need for inheritance or virtual methods (indirect calls) here. Should improve performance slightly to get rid of them. 2015-04-10 10:19:45 -07:00
5e331d6733 Restrict unite() to desperation==0 since NAT-t only works right now with direct links. 2015-04-10 10:13:50 -07:00
068d311ecc TRACE compile fixes, other fixes, and it basically works! It says HELLO. 2015-04-09 20:54:00 -07:00
38200cc6a5 Add data store functions to service/One, and shelve old main.cpp since it will get rebuilt. 2015-04-09 19:58:04 -07:00
6615a70027 Service code builds now. 2015-04-09 18:22:04 -07:00
46ecad451c Starting on new service/ code to encapsulate node/ with osdep/ stuff, and add a user pointer to the CAPI. 2015-04-09 18:14:27 -07:00
9342380146 docs 2015-04-09 11:27:23 -07:00
7192fe6d15 osdep/ compile fixes, and remove some lingering OS-specific stuff from node/Defaults 2015-04-08 19:03:30 -07:00
d761330465 No more tap factories. 2015-04-08 18:47:06 -07:00
ccc73b920e Node peer list function for CAPI, and some Peer cleanup. 2015-04-08 18:45:21 -07:00
d9e9b60a98 Node status and network list. 2015-04-08 18:25:40 -07:00
e34bc961db Add awareness of online status, and put old OS-dep utils in OSUtils. 2015-04-08 17:10:21 -07:00
0751eaabd8 Clean OS-dep stuff out of node/Utils. 2015-04-08 16:55:00 -07:00
12431ce95d Clean out attic. 2015-04-08 16:50:14 -07:00
4d5a6a25d3 Add events for packet decode errors, etc., and re-implement TRACE as an event. 2015-04-08 16:49:21 -07:00
9d9d0ef12c Rename StatusCallback to more descriptive EventCallback. 2015-04-08 16:07:47 -07:00
c894710ac1 Remove Logger.hpp references. 2015-04-08 16:00:48 -07:00
608b5ca13a . 2015-04-08 15:56:19 -07:00
37bd6fdb9c Move Logger to attic -- last bit of OS-specific stuff to get out of core. 2015-04-08 15:56:11 -07:00
7529d050c7 All of node/ now compiles again! 2015-04-08 15:42:23 -07:00
bf2ff964e1 Utils::now() removal and a bunch of compile fixes. 2015-04-08 15:26:45 -07:00
ee2f51f48e Make Toplogy use dataStoreXX() methods from Node, and get rid of old TCP stuff. 2015-04-08 15:12:04 -07:00
40bfe37a19 Use max of core or most recent path desperation for pings. 2015-04-08 14:58:23 -07:00
59af674e74 Announce multicast groups on multicast subscribe. 2015-04-07 19:35:16 -07:00
6de7996218 Math fix. 2015-04-07 19:32:26 -07:00
49f031ccb4 Tons of refactoring, change to desperation algorithm to use max of core or link, porting over core loop code from old Node.cpp to new CAPI version, etc. 2015-04-07 19:31:11 -07:00
9e55f882d3 Starting to port from old Node() -- identity generation. 2015-04-07 16:41:56 -07:00
8210ed4805 Implement read from object store. 2015-04-07 14:11:47 -07:00
0a90681849 Add ping(), and a logic fix in SelfAwareness. 2015-04-07 12:32:05 -07:00
24608d5ca3 Always use HELLO to contact, and we now confirm newly learned paths via a two-way handshake to prevent half-connects. 2015-04-07 12:22:33 -07:00
eae2c89b09 Mutex locking fix. 2015-04-07 11:58:41 -07:00
52c3b7c34e Implemented empirical determination of external addressing, paritioned per scope. 2015-04-07 11:56:10 -07:00
817824b88b Some external surface awareness work, and IP scope classification. 2015-04-07 10:57:59 -07:00
a2821e9000 Add code to check external surface against reported surface from other trusted peers, and also rename ExternalSurface to SelfAwareness because lulz. 2015-04-06 20:17:21 -07:00
76ad19f411 Use binary_search for multicast groups, which are kept in sorted order. 2015-04-06 19:41:55 -07:00
758bf949db Check for subscribed multicast groups should be able to check groups bridged behind me. 2015-04-06 19:34:36 -07:00
4e691c8e22 build fixes 2015-04-06 18:56:08 -07:00
6807ccd710 Don't need to announce on multicast leave. 2015-04-06 18:28:18 -07:00
51f46a009a Multicast group join/leave and group membership announcement. 2015-04-06 18:27:24 -07:00
8001b2c0cb Network now calls port config function as per new API. 2015-04-06 16:52:52 -07:00
a86300c58f Network build fixes and cleanup of remaining internal references to _tap 2015-04-06 15:47:57 -07:00
488f5bf977 More build fixes, and attic/ some stuff. 2015-04-06 15:14:54 -07:00
197d272287 More NAT strategy cleanup. 2015-04-06 15:08:45 -07:00
be4683a96d Get rid of random port strategy -- research does not support. 2015-04-06 15:03:08 -07:00
5f351f2f6b build fixes. 2015-04-06 14:55:40 -07:00
f4fd2d4971 Bring IncomingPacket into line with new changes. 2015-04-06 14:50:53 -07:00
a95f1e1418 Eliminate redundant SharedPtr assignment. 2015-04-03 17:01:07 -07:00
6eb9289367 Bunch more cleanup, improvements to NAT traversal logic, finished updating Switch. 2015-04-03 16:52:53 -07:00
ee0f56355b Send path simplification. 2015-04-03 13:14:37 -07:00
a69e1876f1 The concept of link desperation (escalating to less desirable transports) simplifies a ton of stuff. Loads of spaghetti logic can die since we no longer have to make these decisions down in the core. 2015-04-02 17:54:56 -07:00
5f51653f9c More cleanup. 2015-04-01 19:16:07 -07:00
0214dbc277 More cleanup. 2015-04-01 19:15:21 -07:00
1f28ce3980 Tons more refactoring: simplify Network, move explicit management of Tap out, redo COM serialization, etc. 2015-04-01 19:09:18 -07:00
49349470a0 ... 2015-04-01 16:27:14 -07:00
8130848020 More refactoring... and update the API a bit... turns out my strategy for reducing indirect function calls also increased memcpy()s which are more expensive. This is simpler and faster. 2015-04-01 14:59:44 -07:00
7ff0cab1b7 docs 2015-03-31 18:33:39 -07:00
b723855751 Refactoring... lalalala... 2015-03-31 18:17:11 -07:00
36eab4f1a9 Whole heap more cleanup and refactoring... 2015-03-31 17:53:34 -07:00
647ce82b86 Move more stuff into osdep/ -- node/ will not use threads directly. 2015-03-31 15:23:14 -07:00
e61a40a956 docs 2015-03-31 14:12:33 -07:00
a61acf36d2 osnet -> osdep 2015-03-31 14:11:21 -07:00
8990fb8267 osnet -> osdep 2015-03-31 14:10:02 -07:00
2c5dbecb3c More CAPI work, and move old control/ and old node/Node to attic. 2015-03-31 13:54:50 -07:00
fe94c9460b Phy is a better name than Wire, and other cleanup. 2015-03-31 11:52:10 -07:00
fe87c1db67 Work on new simplified C API -- required for embedded, language bindings, mobile (language bindings again), etc. 2015-03-30 19:46:07 -07:00
60158aa5dd Turns out that node/ likely has no business with or need for the system IP routing table. So shelve that code for now. 2015-03-30 17:48:48 -07:00
3c1a59fa24 Wire selftest, and passes all tests. 2015-03-30 15:37:44 -07:00
b6241f6cb1 Build fixes. 2015-03-30 13:21:35 -07:00
4445bfc869 Wire should be good to test. 2015-03-26 14:44:31 -07:00
8d409def74 More Wire cleanup/docs and minor fixes. 2015-03-24 13:45:31 -07:00
91810c5f44 A bit more cleanup and doc work on new select abstraction 2015-03-24 10:09:05 -07:00
64ea58d523 Most of new cleaner IO abstraction. 2015-03-23 17:07:47 -07:00
96737368aa Add MIT-licensed Joyent http-parser lib to ext/ for use with new control plane. 2015-03-20 13:32:31 -07:00
7ee1a1151f Add SqliteNetworkConfigMaster::DBC for external access to raw sqlite3 db. 2015-03-20 12:21:18 -07:00
a8a92c5b89 A whole lot of Sqlite netconf master work, and some fixes elsewhere in the code. 2015-03-18 16:10:48 -07:00
cea3f28155 DB init works now. 2015-03-17 16:27:52 -07:00
ba69240bcb Sqlite auto-init and version check. 2015-03-17 15:20:45 -07:00
49a2450e76 Include the Sqlite schema to auto-init the database. 2015-03-17 14:54:13 -07:00
278c8fd9f1 Wire up externally specified NetworkConfigMaster 2015-03-13 13:53:15 -07:00
61d89bd118 docs 2015-03-12 14:27:14 -07:00
1b0908fab2 Delete duplicate redis-schema.md 2015-03-12 14:04:21 -07:00
31bf0a4ea6 Netconf build fixes, schema, etc. 2015-03-12 14:03:53 -07:00
fab951e98a Sqlite schema for netconf. 2015-03-12 09:56:03 -07:00
ab211cf599 Changed my mind design-wise on netconf/ -- will embed using SQLite. This fits much better into the OnePoint plans. I am also officially sick of NoSQL, which in this cases forces you to invent things that SQL gives you for free. 2015-03-11 08:44:38 -07:00
badf260e1f Add historic protocol docs exhibit. 2015-03-02 06:50:42 -08:00
66f29f09da Make clean fixes. 2015-02-26 14:54:56 -08:00
ecffa9f5e7 Redis network config master work, and the beginnings of some actual unit test code. 2015-02-24 16:15:01 -08:00
b6fba5934a RedisNetworkConfigMaster in its own folder. Also fix some hex/decimal Redis database confusion. 2015-02-24 14:17:57 -08:00
78fc62d967 netconf/ is where Redis code lives 2015-02-24 12:41:24 -08:00
ff255a34de Make NetworkConfigMaster a plugin to get Redis and other non-endpoint code out of node/ 2015-02-24 12:28:58 -08:00
93012b0ee5 Re-incorporation: ZeroTier Networks -> ZeroTier, Inc. [Delaware] 2015-02-17 13:11:34 -08:00
89f0c948f8 Physical address change message verb. 2015-02-04 11:59:02 -08:00
eeed31b396 Ping supernodes on surface change, and also reset TCP flag. 2015-02-02 17:02:23 -08:00
b7148c107d Rip out network environment fingerprint. This will be replaced by constant monitoring of actual external address surface. 2015-02-02 16:40:57 -08:00
b1bf3f68c3 Drop support for legacy P5 multicast, as there are fewer than 1% of these remaining on the network. 2015-02-02 16:34:01 -08:00
37d23336ed Surface logic in Topology. 2015-02-02 16:23:26 -08:00
61cff47f5b Code to track externally visible address surface. 2015-02-02 15:24:05 -08:00
c30bf7957e Hash code method for InetAddress 2015-02-02 14:44:24 -08:00
d73a11b60b Add netconf build option to Mac build file too. 2015-01-13 16:45:23 -08:00
83227dc386 Now demote Amsterdam supernode. Appears to be having issues due to some sort of poor hosting provider performance. 2015-01-13 08:43:38 -08:00
fbc6ca28b7 Merge branch 'adamierymenko-dev' of ssh://earth.zerotier.net:55522/git/ZeroTierOne into adamierymenko-dev 2015-01-12 09:49:11 -08:00
72f926dc41 Add new faster supernode in Paris, France. 2015-01-12 09:22:37 -08:00
eab3ca1401 docs 2015-01-09 18:44:17 -05:00
c8c5d3b06e Create netconf master if redis options are in local.conf. 2015-01-09 18:25:41 -05:00
0b84c10ccc Add confirmation step to new netconf, with the caveat that it will be disabled for older netconf servers to avoid race. Also add some comments. 2015-01-09 16:35:20 -05:00
afea153a0b Build fixes. 2015-01-08 18:17:02 -05:00
64ba596e0b C++ network config master ready to test. 2015-01-08 14:27:55 -08:00
60fb28a90a Cleanup, new C++ netconf code is almost ready to test! 2015-01-06 17:16:54 -08:00
a369c69091 C++ netconf master Redis plumbing. 2015-01-06 13:45:10 -08:00
f043321281 Revised Redis schema. 2015-01-06 11:04:53 -08:00
b644d2a893 Add timestamp field to network config requests. 2015-01-05 17:51:50 -08:00
4e95384ad6 Cleanup, add tristate to config code in Network, and happy new year! 2015-01-05 17:47:59 -08:00
08ba2ff752 Upgrade LZ4. 2015-01-05 16:23:32 -08:00
efa0bab296 Stash old Node.JS netconf-service in attic/ 2015-01-05 16:20:20 -08:00
96e9a90e8e docs 2015-01-05 16:19:56 -08:00
87c599df5c Back out service message type -- YAGNI violation. 2015-01-05 15:52:02 -08:00
56cfe1d603 Strip out old Service code, add new service message type. 2015-01-05 11:47:22 -08:00
95e303d6f3 VERSION 1.0.2: Experimental FreeBSD support!
Version 1.0.2 brings experimental FreeBSD support. It has ONLY been tested
on FreeBSD 10 on an x64 system, and should be considered alpha for this
platform for now.

This version is not going to be pushed out to the entire world via software
update, and the binary version distributed for other platforms via the
zerotier.com web site will remain 1.0.1 as there are no other meaningful
user-facing changes. This is just an interim release to let FreeBSD users
try it out. If you find bugs, please enter them on GitHub or do a pull
request and fix them yourself.
2014-12-19 15:25:28 -08:00
ebb63cce70 Merge branch 'adamierymenko-dev' of ssh://earth.zerotier.net:55522/git/ZeroTierOne into adamierymenko-dev 2014-12-19 15:24:23 -08:00
f24283a674 VERSION 1.0.2: Experimental FreeBSD support!
Version 1.0.2 brings experimental FreeBSD support. It has ONLY been tested
on FreeBSD 10 on an x64 system, and should be considered alpha for this
platform for now.

This version is not going to be pushed out to the entire world via software
update, and the binary version distributed for other platforms via the
zerotier.com web site will remain 1.0.1 as there are no other meaningful
user-facing changes. This is just an interim release to let FreeBSD users
try it out. If you find bugs, please enter them on GitHub or do a pull
request and fix them yourself.
2014-12-19 15:20:47 -08:00
f60dfe4963 FreeBSD works, and some documentation fixes. 2014-12-19 15:18:20 -08:00
536bcf6505 FreeBSD builds! 2014-12-19 14:33:58 -08:00
1a02bcc9f5 Fork OSXEthernetTapFactory -> BSDEthernetTapFactory 2014-12-19 13:34:06 -08:00
d10abab786 Remove &s from restarts in installer -- probably part of the restart problem. 2014-12-16 12:32:53 -05:00
ff539c22f9 locallyValidate() is expensive -- stop doing it on every HELLO since in most cases we already know the identity and know it is valid 2014-12-16 09:29:40 -08:00
0324ef2a47 VERSION 1.0.1
This version is mostly a bug fix release. It fixes a bug that could cause
the service to crash on Windows while running the GUI application. It also
contains a number of fixes to the Linux installer and Linux support for
systemd-based init systems.

It also includes a minor tweak to the multicast algorithm. Version 1.0.0
sent multicasts in a deterministic order, while this version randomizes
the order. The vast majority of users will notice nothing, but this may result
in superior coverage for service announcements on very large networks. It's
a hard variation to test, so we're releasing like this to gather information
from users about the effect. Nothing will change on small networks, and
ordinary multicast functions like ARP and NDP should be unaffected.

The next version will likely focus on additional improvements to Microsoft
Windows support, since there are several known Windows issues in need of
attention. We're working on an NDIS6-based Tap driver that should address
the driver issues experienced by a small number of Windows 7 users.
2014-12-05 12:10:18 -08:00
cd2bf6f4b3 Stash make-freebsd.mk in attic/ to indicate that the FreeBSD port is not done net. Coming soon! 2014-12-05 09:36:16 -08:00
ad4923846a Add .autoupdating to Debian package version too. 2014-12-05 17:34:05 +00:00
83a6edd08e Make RPM version contain .autoupdating to indicate that it auto updates outside normal RPM channels. 2014-12-05 12:26:53 -05:00
58f2dc5cf3 RPM build support in buildinstaller.sh 2014-12-04 20:13:41 -05:00
3a786ccc17 Set Debian arch correctly on armv6l (armhf) 2014-12-04 22:38:49 +00:00
b3a9bfca4d Fix Debian package upgrade process. 2014-12-04 21:28:03 +00:00
03c7dc2b4c Add .service to unit name in uninstall too. 2014-12-04 00:16:10 +00:00
000eac5a2b Another systemd change... should fix problems on some systems. 2014-12-03 16:05:18 -08:00
62c31e70d4 Systemd permission fix in Linux installer. 2014-12-03 23:57:08 +00:00
1b6af7836e Don't restart ZeroTier One service if version has not changed. 2014-12-03 23:25:06 +00:00
638ae153cc fix service command, eliminate all uses of killall since it might be missing 2014-12-03 22:46:44 +00:00
059aaae7a9 Preinst and postinst Debian scripts. 2014-12-03 22:09:17 +00:00
4bf2fa3edb Basic Debian package support in buildinstaller.sh 2014-12-03 21:40:33 +00:00
149dbff3ea Windows Visual Studio meaningless-warning-ectomy. 2014-12-02 16:50:53 -08:00
c030294bf5 Clean up some unused Windows files. 2014-12-02 16:43:01 -08:00
30e82a4d9c Fix network enumeration buffer size bug -- reported by user Neal Symms via LiveAgent 2014-12-02 12:53:30 -08:00
8c64046a53 docs 2014-11-26 14:59:43 -08:00
04e4c5263e Remove more legacy code -- just doing the supernode redist for old multicast is now good enough given the small number of legacy nodes left. 2014-11-26 13:39:57 -08:00
4303376ba6 cleanup and docs 2014-11-26 13:30:00 -08:00
cda61fe2d9 docs and cleanup 2014-11-26 13:14:18 -08:00
0f505411cf Enable legacy multicast in Constants. 2014-11-25 14:12:33 -08:00
15d3e383e6 Add ZT_SUPPORT_LEGACY_MULTICAST ifdef to enable the legacy code to all be toggled. 2014-11-25 12:46:51 -08:00
6888c6482c Re-enable legacy multicast distribution -- still too many pre1.0.0 nodes online. 2014-11-24 10:37:34 -08:00
d772639cc6 Multicast code cleanup. 2014-11-24 10:05:16 -08:00
acac88cf77 A few more tweaks to MC algo... 2014-11-23 14:00:27 -08:00
0bcac1fd79 Add a bunch of high-resolution try/catch safety in Node main loop to attempt to snare gremlin. 2014-11-21 11:54:06 -08:00
959f611a65 Fix thinko in multicast changes... works now! 2014-11-21 11:27:53 -08:00
7619b0ecbd Send multicasts in random order.
This should not affect most users, but on large networks it should cause service
announcements to work a lot better. This is the result of a prolonged discussion
with a user about the visibility of game servers on a large network. The old
multicast algorithm was de-facto randomized due to its distributed nature, while
the new algorithm is more deterministic. This will restore some randomization
beyond limit-overflow conditions.

It won't affect small networks at all.
2014-11-21 10:50:27 -08:00
0c85b4ef5f Tweak to symmetric NAT buster to add one to the number of ports above the current one it attempts. 2014-11-20 13:42:18 -08:00
ee9e6a3c6b Change path selection logic to exclude non-fixed and non-active paths -- possible fix for "NAT traversal coma" issue. Also fix a typo. 2014-11-20 13:20:16 -08:00
7b6f10e859 Optimization: we don't need to verify signatures on certs if they're certs we already have and have verified. 2014-11-13 12:40:51 -08:00
c61e9c0ef9 Prevent "software laser" in legacy multicast support. Already hotpatched in supernodes. 2014-11-13 14:21:06 -05:00
b1b37d9d72 Increase paltry listen() backlog size to prevent Linux kernel syn flood fallback (only really affects supernodes). 2014-11-12 14:05:03 -08:00
1bd5a1ebcd Make selftest build and run on FreeBSD 10 with gmake 2014-11-04 11:20:38 -08:00
14e4ffd15f VERSION 1.0.0
ZeroTier 1.0.0 brings a number of under the hood improvements and bug
fixes. These include but are not limited to:

 * A simpler, faster multicast algorithm that places full burden
   for multicast propagation on the sender. This results in better
   fairness without CPU-intensive signature/verify on every packet,
   lower latency for intra-data-center SDN operations, and avoids
   distributed burdens that are intrinsically unfriendly to mobile
   clients subject to wake frequency limits and battery life
   constraints. In the future this may be augmented to allow
   optimized delivery to multiple recipients at the same site via
   federation.

 * Significant code reorg to move toward mobile support (iOS, Android)
   and future SDK packaging.

 * A number of efficiency and stability improvements.

 * Bug fixes for Linux and ARM users.

 * Improved NAT traversal, including limited support for port
   numbering scheme guessing to traverse some symmetric NATs.

Upgrade from 0.9.x is not required but is strongly recommended. Older
clients using the old multicast algorithm are presently supported via
legacy hooks, and these may go away at some point in the future. We'll
monitor the status of the network and try to keep legacy support around
as long as people need it, but it'll probably be pulled once 95%+ of
clients are 1.0.0 or newer.

The next versions will bring further bug fixes, improved user experience,
more enterprise-grade features for intra-data-center use, and more!
2014-10-30 12:49:16 -07:00
16461eca1f docs 2014-10-30 12:47:26 -07:00
8f29f19e98 Fix for UI client. 2014-10-30 00:12:45 -07:00
5ca20da7af Windows service fix -- it helps if we actually launch the control socket thing. 2014-10-29 23:57:54 -07:00
8bd9f7d51d Build fix for UI and mac. 2014-10-29 19:54:24 -07:00
0e84eb3852 Back off default multicast limit just a little. 2014-10-29 18:25:24 -07:00
4923ab2945 Windows build fix, set up Windows solution with new layout. 2014-10-29 17:40:23 -07:00
4c59497b95 Linux build fixes for testnet. 2014-10-29 16:32:24 -07:00
5484cf4309 More cleanup, and fix a bug in Multicaster::gather() 2014-10-29 16:24:19 -07:00
22d8aa4dc9 Moderate efficiency improvement on multicast gather result parsing, and go ahead and keep track of total known peers. 2014-10-29 15:26:32 -07:00
95f421024a Code cleanup, and fix some unsafe pointer handling in Network. 2014-10-29 13:57:37 -07:00
f65b48d447 Thread sync bug... 2014-10-28 17:29:45 -07:00
5bb854e504 Fix a nasty bug introduced in packet fragmentation a while back during refactoring, and a few other things related to multicast. 2014-10-28 17:25:34 -07:00
faff84e63a docs 2014-10-28 16:14:05 -07:00
9a5f6f020f docs 2014-10-28 15:53:11 -07:00
4dec598fb8 Make multicast gather slightly more aggressive, and add total to list command in testnet. 2014-10-28 15:33:10 -07:00
3e948fcd93 .... aaaaaaand multicast testnet functionsa are in! 2014-10-28 15:06:43 -07:00
8aa75321e2 docs 2014-10-28 14:46:15 -07:00
ffbf0781fe docs 2014-10-28 14:27:21 -07:00
e4966c7a07 docs 2014-10-28 14:25:44 -07:00
ac23f74547 docs 2014-10-28 14:24:07 -07:00
fa60463da5 docs 2014-10-28 14:23:39 -07:00
3d85a615fb NULL dereference on still-initializing node bug fix in status query commands, and doc updates. 2014-10-28 14:17:39 -07:00
f873881a0d Helps to use a proper multithreaded queue instead of ugly plebian hackery. 2014-10-28 12:28:45 -07:00
934a575a74 Testnet seems to work a bit better now... 2014-10-27 18:23:10 -07:00
fe7b429866 ... 2014-10-27 17:32:37 -07:00
295f6a20e0 Testnet works! sort of... 2014-10-27 14:25:00 -07:00
6a94a4a51b Testnet WIP 2014-10-27 09:03:38 -07:00
8672ca9cf8 Prep for real tests like alltoall. 2014-10-24 17:29:09 -07:00
a75a7547b4 Deadlock fix... 2014-10-24 17:11:23 -07:00
3857116724 More testnet work. 2014-10-24 16:35:06 -07:00
5c7cd53f13 Testnet sort of works! spins up supernodes. 2014-10-24 08:48:44 -07:00
4fbb098daa Testnet work... getting there! 2014-10-23 16:46:09 -07:00
0a195e7bc0 Some work on simulated net... 2014-10-22 09:52:29 -07:00
ae228ade8c Starting on simulated socket manager. 2014-10-21 17:00:25 -07:00
4a5756e7fb cleanup 2014-10-21 16:21:45 -07:00
29ba34ab7c Kill old testnet stuff, update main.cpp for new SocketManager abstraction. 2014-10-21 15:33:35 -07:00
2436e22f46 More work on abstracting socket manager. 2014-10-21 15:18:50 -07:00
128a131070 About halfway there in refactoring to support pluggable SocketManager. 2014-10-21 14:26:10 -07:00
6bc9a938cf Move socket manager implementation into osnet/ 2014-10-21 11:25:31 -07:00
0e47f13f14 Simplify locking semantics some more to address a deadlock. 2014-10-21 10:42:04 -07:00
7c0f5e97e1 Don't need to check peer version for every item in txQueue since there is only one peer. 2014-10-19 15:20:19 -07:00
0fd562bebc One more Windows build fix. 2014-10-19 13:10:23 -07:00
8730d30575 Now for some clang compile fixes... 2014-10-19 13:07:50 -07:00
babf3787c6 Switch VS2012 build back to real, not self-test. 2014-10-19 12:58:13 -07:00
74f36f5dc0 Windows build fixes. 2014-10-19 12:56:39 -07:00
2eeb3dee9e Merge branch 'adamierymenko-dev' of ssh://shub-niggurath.zerotier.com:222/git/ZeroTierOne into adamierymenko-dev 2014-10-18 15:02:03 +02:00
4951e5e1b5 This is a --strategy=ours merge to allow adamierymenko-dev to replace
the current content of detached-network-test. This is ready for another
test in 'headless' mode.

Merge branch 'detached-network-test' into adamierymenko-dev
2014-10-18 15:00:47 +02:00
6429c51ec7 Merge branch 'detached-network-test' into adamierymenko-dev 2014-10-18 14:57:04 +02:00
a8bd8fff93 Make several changes to eliminate potential deadlock or recursive lock conditions, and add back rescan of multicast groups on network startup. 2014-10-14 16:38:27 -07:00
a94b0e6a43 Get rid of rescanMulticastGroups() in Network thread since this can deadlock... the fact that this can happen is probably bad design. 2014-10-14 15:58:03 -07:00
7a37326cc0 Fix sleeper bug that probably did nothing in setSupernodes(). 2014-10-14 14:59:17 -07:00
42d644a57e More fixes to legacy support, and to a potential issue on quit. 2014-10-14 12:37:35 -07:00
023cac4ebb Add -g to optimized crypto code in ZT_DEBUG=1 build mode. 2014-10-14 10:22:27 -07:00
2416491cbc Permanently retire peers.persist, but make iddb.d always enabled instead since identities are what we really want to cache. 2014-10-13 14:12:51 -07:00
6e23986bb3 Another build fix. 2014-10-13 13:09:02 -07:00
1921e28c5f Build fix. 2014-10-13 12:35:43 -07:00
52314dcdf6 GitHub issue #111 2014-10-13 11:47:14 -07:00
d8d4aace42 Fix for init.d/zerotier-one (again) 2014-10-13 12:55:16 -04:00
05309037a8 Yank potentially costly support for TTL out of UdpSocket since we dont use this anymore. 2014-10-13 09:37:17 -07:00
7943414c89 Part two of fix to GitHub issue #118 -- need to test thoroughly though. 2014-10-13 08:15:00 -07:00
c7c545bf6c Fix for part one of GitHub issue #118 2014-10-13 08:11:19 -07:00
6316011024 Make crypto and compression build optimized in debug, and also try disabling peers.persist -- might ship this way as it seems more trouble than its worth. 2014-10-12 11:42:49 -07:00
8b0846d077 Delete bunch of commented out code. 2014-10-11 16:53:21 -07:00
0d017c043f Stop persisting last announcement time since Multicaster is volatile. Also some more legacy multicast fixes. 2014-10-11 16:26:02 -07:00
c2aac69a9f Fixes to legacy peer support. 2014-10-11 15:49:31 -07:00
a9c6913f12 . 2014-10-11 10:38:52 -07:00
e071c05f1b Add a sanity limit to legacy multicast repeater function in supernode-mode nodes, and change netconf-master to issue multicast limit (ml) instead of old p5 stuff. 2014-10-10 14:59:07 -07:00
03dc823ad7 (1) Back off a little on default max multicast limit since 128 is pretty bandwidth heavy, (2) add a little to default multicast rate limit since new MC algo is fairerererer, (3) decided not to involve netconf masters in multicast so take that out of list of who gets LIKEs. 2014-10-10 12:55:06 -07:00
1774e615a1 <= MTU 2014-10-10 09:09:56 -07:00
56f8f8aa24 Return self in GATHER requests if self is a member of multicast group, and reinstate legacy support. 2014-10-09 18:32:05 -07:00
4941c8a1f3 New multicast bug fixes, TRACE improvements, and temporarily disable legacy multicast for debugging purposes. 2014-10-09 17:58:31 -07:00
d5e0f7e3e4 Reorg multicast packet, and a whole bunch of refactoring around the pushing of certificates of membership. 2014-10-09 12:42:25 -07:00
620e64c58f Supernode propagation of legacy multicast frames was brokezored. 2014-10-09 09:03:12 -07:00
b809dad94a Bug fix in zerotier-cli (Unix) 2014-10-07 16:16:22 -07:00
b13845e528 . 2014-10-07 15:26:12 -07:00
3f15752f73 Add IPv4 address assignment to ffffffffffffffff test network. 2014-10-07 14:34:00 -07:00
cb6fd3afb3 g++ compiler warning fix 2014-10-07 13:18:08 -07:00
7788a3d45d . 2014-10-06 14:56:49 -07:00
923c325a40 Add another private-testnet root topology debug option using 10.0.0.1 as the supernode. 2014-10-06 13:19:04 -07:00
87f1b1b1e3 Bug fix in new multicast frame handler, handling of old "P5" multicast frames in new way. 2014-10-06 13:16:16 -07:00
ab22feba9a Bump version to 1.0.0, add legacy support code to Multicaster to not send new frame to known-to-be-old peers. 2014-10-05 10:34:25 -07:00
10c196df50 Send a VERB_P5_MULTICAST_FRAME to the supernode for each multicast -- for now. This will allow supernodes to echo these down to pre-1.0.0 peers. 2014-10-04 13:46:29 -07:00
2c8321be1f Pull logic to always send new multicasts to supernode since we need to do that differently, re-add support for active bridges, and remove some gratuitous use of std::set where not needed. 2014-10-04 13:15:02 -07:00
62da7e67b6 Add some rate limiting to implicit gathers, and always send multicasts to at least one supernode so they can broadcast to old peers (temporary). 2014-10-03 22:30:10 -07:00
e7c81ef34e Turns out that needed to be a list after all. Also clean up Multicaster::gather(). 2014-10-03 22:03:19 -07:00
3f7e7e8a88 Do not multicast to self. 2014-10-03 18:42:41 -07:00
496109fdcc Announce multicast group changes on network rescanMulticastGroups() 2014-10-03 18:27:42 -07:00
aad344bb84 Add test network support to Network. 2014-10-03 16:14:34 -07:00
13fc20b0ee Add inject (undocumented in help) to NodeControlService. 2014-10-03 15:59:49 -07:00
351db7f1a0 Plumb injectPacketFromHost through to API. 2014-10-03 14:49:11 -07:00
6ab7b1b915 Add local-testnet clean script, and make a really ugly hacky fix in main.c for the -q option. (All that personality stuff needs to be rewritten. Yuck.) 2014-10-03 13:41:52 -07:00
f853bc6a86 Fix root topology override 2014-10-03 13:19:13 -07:00
d7189dd6c7 . 2014-10-03 13:06:13 -07:00
5fc3c0812a run-local-testnet script 2014-10-03 13:02:36 -07:00
67aa23530b More work on adding testnet and user-mode capabilities for local network simulation. 2014-10-03 11:59:50 -07:00
2a58c3fb98 Root topology testnet stuff... will ship this so people can easily run the local testnet app. 2014-10-03 09:36:39 -07:00
96fa3f7550 Work on in-place testnet support. 2014-10-02 16:33:08 -07:00
1109046782 Last steps before test: parse OK(MULTICAST_GATHER) and OK(MULTICAST_FRAME) 2014-10-02 13:50:37 -07:00
49dc47ff38 Make multicast gathering a bit smarter. 2014-10-02 11:35:37 -07:00
dee86e2448 But since we are now using middle 3 bits we can assign sane values for the cipher suite enum. 2014-10-02 11:13:53 -07:00
17da733f97 Gotta support old encrypted flag, move cipher spec to middle 3 bits... due to some shortsighted design early-on. In the future this can die once there are no old peers. 2014-10-02 11:08:59 -07:00
23836d4c11 Change "encrypted" flag to full cipher suite selector. Go ahead and reserve AES256-GCM which might be added in the future. 2014-10-02 10:54:34 -07:00
e53d208ea4 Improve security posture by eliminating non-const data() accessor from Buffer. 2014-10-02 10:06:29 -07:00
e8c5495b61 Yes, zero my secret key data. Yes I really, really mean it. 2014-10-02 09:08:31 -07:00
28646eee0a A bit more IncomingPacket cleanup... almost ready to test, just need OK() handling. 2014-10-01 16:29:52 -07:00
e1882b614b Some cleanup, Multicaster now sends multicasts as it gets additional members. 2014-10-01 14:05:25 -07:00
ae082c3cb8 Yay... now everything compiles! Getting close to testing on this. Still have not added backward compatibility support for relaying of multicasts to 0.9.X clients yet but that will be easy. Will test with heterogenous 1.0.0 clients only first. 2014-10-01 12:41:48 -07:00
ea6124dd2f IncomingPacket builds! 2014-09-30 17:33:20 -07:00
b41437780b Add origin to new MULTICAST_FRAME, move security check for certs into Network to remove redundant code and bug-proneness, more work on IncomingPacket... 2014-09-30 17:26:34 -07:00
2659427864 Multicaster needs to be global, not per-network, and a bunch of other stuff. 2014-09-30 16:28:25 -07:00
8607aa7c3c Everything in for new multicast except IncomingPacket parsing... 2014-09-30 08:38:03 -07:00
ed0ba49502 A few more revisions to new multicast verbs. 2014-09-26 14:18:25 -07:00
2d41055bdc Some Network code cleanup. 2014-09-26 12:23:43 -07:00
027060dad1 Most of new multicast code builds... now on to packet parsing. 2014-09-25 22:13:31 -07:00
0778332747 . 2014-09-25 22:08:52 -07:00
9e186bbd89 . 2014-09-25 15:57:43 -07:00
050a0ce85d . 2014-09-25 15:08:29 -07:00
6c87f9f765 Rename MulticastTopology to Multicaster -- same name as old multicast controller but different code. More descriptive though. 2014-09-24 14:02:16 -07:00
81b12b6826 Rename the ubiquitous _r pointer to RuntimeEnvironment to RR just to be a little more consistent about using _ to denote private member variables. 2014-09-24 13:53:03 -07:00
431476e2e4 Some more multicast algo work... 2014-09-24 13:45:58 -07:00
557801a09e Rename PacketDecoder to much more descriptive IncomingPacket 2014-09-24 09:04:09 -07:00
9180a30986 . 2014-09-24 09:01:58 -07:00
61d0f27d2a Make MulticastTopology have its own mutex. 2014-09-23 10:26:30 -07:00
c49e253e21 . 2014-09-22 15:03:16 -07:00
954f9cbc13 Yet more WIP on mulitcast algo... 2014-09-22 13:18:24 -07:00
d9abd4d9be Work on defining new direct broadcast multicast algorithm. 2014-09-18 18:28:14 -07:00
d37c3ad30f VERSION 0.9.3: unreleased update with some fixes for Pi users
This version is being tagged and bagged, despite the fact that it's not
going to be released and won't be merged into master until 1.0.0 is ready.

It contains several Linux build fixes, a fix for a unix domain socket resource
leak, and build fixes for the Raspberry Pi.
2014-09-18 13:40:58 -07:00
4708231046 Fix for GitHub issue #122 and other fixes 2014-09-18 10:01:30 -07:00
924f030994 docs 2014-09-18 09:41:12 -07:00
6b76cac6cf Back off from thrashing shutdownIfUnreadableCheck, fix bug in control service. 2014-09-17 14:19:58 -07:00
2762db8408 More work on control bus refactor... 2014-09-17 12:54:39 -07:00
edff13dcae More control/ refactoring 2014-09-17 09:50:49 -07:00
e22fae2397 it compiles again! 2014-09-16 15:47:00 -07:00
73dd9d3b74 Make sure open() has third argument 2014-09-16 08:58:49 -07:00
8d2e20ede6 Get rid of __align stuff in Salsa20 -- not portable, does not seem to help much on newer chips. 2014-09-16 08:53:18 -07:00
5c1c70a604 cleanup 2014-09-16 08:19:39 -07:00
fb22ef053b Move rest of NodeControl stuff out of node/ and into control/ 2014-09-15 16:32:55 -07:00
4ba4269344 cleanup 2014-09-15 09:45:57 -07:00
2dcf584834 rename ipc/ to control/ 2014-09-15 09:44:29 -07:00
13aba7640b refactoring for SDK 2014-09-15 09:43:57 -07:00
2e46bb4264 build fixes 2014-09-13 14:15:26 -07:00
1d37204a37 Refactoring in progress... pardon our dust... 2014-09-12 16:57:37 -07:00
6b4346d1ac work in progress on API refactor 2014-09-10 17:16:40 -07:00
ea0f836ef1 Turns out we do want to propagate packets unauthenticated in the supernode case. This is fine. 2014-09-08 14:33:12 -04:00
b8729de9da Temporarily DISABLE multicast authentication (doing in branch, will reenable in dev) 2014-09-08 08:25:06 -07:00
4e9280fc7a Rip out dead "firewall opener" code, replace in pipeline with anti-symmetric-NAT tactics. 2014-09-05 16:23:24 -07:00
d02ecfb288 IP assignment and change cleanup -- leave IPs that were never configured via ZT static assignment alone. 2014-09-05 15:35:09 -07:00
3afc629ac5 Bit of network config parser cleanup. 2014-09-05 14:56:11 -07:00
6e1339fedf Remove zerotier-idtool symlink on mac uninstall.sh 2014-09-05 11:39:54 -07:00
7d4b6767eb Old-school GCC build fix -- make sure __GCC__ is defined 2014-09-05 17:48:59 +00:00
93f9b4392d Enable configuration of multicast algorithm parameters in netconf 2014-09-04 14:25:07 -07:00
6df9546742 Fix for missing broadcast address on Linux Ethernet taps. 2014-09-04 13:36:25 -04:00
4dbeb97eb9 docs 2014-09-03 16:50:06 -07:00
34349d1a61 docs 2014-09-03 16:48:02 -07:00
6497a4a0f6 initdb changes 2014-09-03 19:15:53 -04:00
b8d29cb6ba Some netconf-service renames and add initdb script for user use. 2014-09-03 20:04:58 +00:00
e77e224171 bin2c warning removed 2014-09-03 12:25:28 -07:00
dcea212e40 Add noupdate flag in root topologies, add ability for mktopology to read from a template. 2014-09-03 11:56:36 -07:00
644db7a04a Let people build installers for any machine type on Linux, just canonicalize the x86 and x86_64 types. 2014-08-27 20:15:41 -04:00
00b16f6aa6 Fix for GitHub issue #110 -- failure to bind IPv6 now non-fatal 2014-08-27 20:09:56 -04:00
1952db5069 Only enable SSE Salsa20 on x86 and x86_64 Linux 2014-08-27 20:01:24 -04:00
6f8364ba59 VERSION 0.9.2:
The primary focus of this version is better integration with the
Microsoft Windows operating system.

Virtual networks should now be detected as "real" networks. For
each network, a message box should pop up the first time the network
is detected and classified allowing the user to choose its services
and security designation. On Windows 7 this is "work," "home," or
"public." On Windows 8 it's a simple choice of whether or not to
enable file and printer sharing and other services.

Several bugs have been fixed. Among these are a Windows threading
issue, several minor threading deadlock issues that could manifest
if rapidly adding and removing networks, and a command line interface
issue. The network list now shows the network MAC address as well,
a UI oversight in previous versions. A vectorized SSE implementation
of Salsa20 is now included for improved encrypt/decrypt performance.

The sending of low-TTL "firewall opener" packets has been disabled
in this version, since they may not be necessary and may harm NAT
traversal in some configurations. We will measure the effectiveness
of NAT traversal and see if this change improves performance in the
field.

Finally, this version obsoletes both the Tokyo and Sydney supernodes
in favor of a single larger supernode in Singapore. This decision was
made on the basis of bandwidth costs-- both Tokyo and Sydney are
significantly more expensive. We'd like to keep the basic service free,
so keeping bandwidth costs for relaying low is important. Since NAT
traversal works well and is constantly being improved, most users will
not see a speed decrease from this. Some Chinese users may see
improved performance since Singapore may be closer than Tokyo to many
Chinese cities.

The next major releases will focus on better Macintosh platform integration,
further improvements to NAT traversal, and UI improvements.
2014-08-22 12:05:56 -07:00
eadff71d37 Another fix to Network life cycle. 2014-08-21 18:07:27 -07:00
af62a6cade Forgot to uncomment secret debug #define of death. 2014-08-21 17:49:46 -07:00
de4e29288d Fix for crazy Windows threading bug... repeatedly adding and removing a network now doesn't leave networks in limbo. 2014-08-21 17:49:05 -07:00
44d58ee871 Change 1.1.1.1 pseudo-IP used for default route hack to 25.255.255.254, since 1.1.1.1 is from a now-in-use IPv4 block while 25.0.0.0/8 is still unrouted. It can be changed in the future without impacting anything, since Windows keys off the MAC not the IP to classify networks. 2014-08-21 08:26:39 -07:00
9d5819ff44 Version bump to 0.9.2 -- preparing for release... 2014-08-20 18:29:27 -07:00
08d7fe0432 Fix for GitHub issue #102 2014-08-20 12:36:11 -07:00
9f2571cc01 Some UI fixes for Windows. 2014-08-20 10:22:30 -07:00
b4b2e2ed9f ... 2014-08-19 18:21:21 -07:00
17ebd0afc7 Disable service management in UI -- installer should automatically start service and this is annoying for testing purposes. 2014-08-19 18:14:50 -07:00
351b7f3a09 UI stuff and sign .dmg on build. 2014-08-19 17:42:17 -07:00
721625d512 Add MAC to listnetworks, and some other make stuff. 2014-08-19 14:11:02 -07:00
282114e96c Makefile changes, and make Topology::getBestSupernode() return the "next" supernode if I am a supernode. Also some comment cleanup. 2014-08-19 10:09:21 -07:00
95d123cfc2 Do HttpClient refactoring for Windows. 2014-08-18 14:34:04 -07:00
f5cbb45ab9 Increase sleep/wake detection threshold... might want to switch to using native interfaces to really detect this in the future since this is not 100% reliable. 2014-08-18 10:13:25 -04:00
b7b9b9c0b7 Add "make debug" to make building debug one-offs easier (Linux). 2014-08-18 10:07:03 -04:00
715afc0314 Default to built-in root topology if signature check fails (instead of exiting) 2014-08-16 14:01:25 -07:00
f281886bfd Small thread safety fix in HttpClient. 2014-08-16 13:32:33 -07:00
4f0fcc582e Refactor HttpClient a bit. 2014-08-16 09:08:52 -07:00
aa59cfd545 Web request part of supernode resync (not quite done, needs test) 2014-08-15 23:37:35 -04:00
f696299cfc docs 2014-08-15 12:59:49 -04:00
b0719eacf9 Add encrypt/decrypt to attic. 2014-08-15 12:59:07 -04:00
c2187c8759 (1) distribute default root-topology in new dictionary format, (2) bump peer serialization version to force obsolescence of old supernodes, (3) stop outputting a log message every time we poll for software updates 2014-08-14 19:52:22 -04:00
56296f96db Regenerate root topology dictionary with field fix. 2014-08-14 18:54:53 -04:00
be6b61b1bc Accept supernode dictionaries in Topology, also fix (unused) field name in one of these. 2014-08-14 18:06:18 -04:00
f8d4611d15 (1) Tweak LAN locator beacon frequencies, (2) Windows virtual networks
now show up as *real* networks and prompt the user to set their
location and firewall status (public, private, home/work, etc.).

The hack used to achieve #2 should not be examined by children or those
suffering from epilepsy or heart conditions.
2014-08-12 17:20:34 -07:00
f25bd41a03 Some fixes to firewall config code. 2014-08-08 15:53:27 -07:00
fe3ad5e2cc Fix a Windows bug in refactored tap code, and always make sure we have a firewall exception rule on startup. 2014-08-08 14:57:13 -07:00
502ea66f15 Kill ugly old getSecureRandom() and replace with simple wrapper for Windows CAPI and *nix /dev/urandom, and some build fixes. 2014-08-08 11:53:55 -07:00
673aab5ba2 Fix an oversight in signed dictionaries: the timestamp and signing identity should themselves be part of the signature. Also include the raw dictionary in addition to the bin2c version in root-topology/ 2014-08-08 12:46:00 -04:00
77457cbff1 Windows compile fixes, compiler warning fix, unfreed memory fix in main.c (though it would not have mattered since program exits immediately after). 2014-08-07 19:08:41 -07:00
db0d17cebb Change topology URL to something prettier. 2014-08-07 20:27:05 -04:00
dd58006d65 Rename topology/ to be more descriptive, and some more updates. 2014-08-07 20:21:07 -04:00
f0ebb0b0f1 More root topology stuff. 2014-08-07 20:14:24 -04:00
8c9d3146df make clean fix 2014-08-07 18:46:04 -04:00
117f977ce3 mktopology for making new signed topology root server dictionaries 2014-08-07 18:45:11 -04:00
d8e5d9d6e8 Singapore supernode -- its baaaack 2014-08-07 21:19:34 +00:00
1f5feb75fb LinuxEthernetTap refactor. 2014-08-07 20:40:23 +00:00
05031ff938 Linux build stuff. 2014-08-07 13:05:17 -04:00
adfb71fa6b Compile for for TRACE, remove old TESTNET cruft. 2014-08-07 08:49:43 -07:00
37341048a9 Silence kextload/kextunload output, error handling improvements. 2014-08-07 08:41:57 -07:00
b3491f9de1 ifdef out Unix-only output redirect function on Windows 2014-08-07 06:36:46 -07:00
80fc584923 Fix for GitHub issue #97 2014-08-07 06:35:54 -07:00
b7389995f4 Make install scripts also symlink zerotier-idtool script, and doc updates. 2014-08-07 06:25:01 -07:00
92d9ad4a7f Some tap interface changes and integration into main.cpp for *nix systems. 2014-08-06 16:24:30 -07:00
8a804b5257 (1) Disable firewall openers (its easy to re-enable), (2) Do some prep work for making supernode topology hot-updatable. 2014-08-05 14:05:50 -07:00
e3c5ada3a7 Add signatures to Dictionary, and fix unhex() API in Utils to be a little safer. 2014-08-05 09:56:49 -07:00
7adf0eac7e Windows Ethernet tap refactoring complete. 2014-08-04 21:48:59 -07:00
df0a8e8450 Linux routing table now works. 2014-07-31 20:13:29 -04:00
526435859f Newly broken out OSX tap driver builds now. 2014-07-31 15:13:48 -07:00
98d426e1d5 Path fixes in osnet/ stuff 2014-07-31 14:31:32 -07:00
b80c229d87 Tons of code cleanup, refactor Network to use EthernetTapFactory, probably also fix GitHub issue #90 2014-07-31 14:09:32 -07:00
9b93141dd0 Upgrade LZ4 to latest version. 2014-07-30 15:34:15 -07:00
59ebc9d41e docs 2014-07-28 09:10:56 -07:00
f0199d6770 Windows routing table interface (untested). 2014-07-28 09:08:56 -07:00
f2d372545a Salsa20 SSE Windows build fix -- turns out you can't be as loose with SSE intrinsics in Visual Studio 2014-07-26 20:07:38 -07:00
9809511c4c Another rename... 2014-07-26 13:11:45 -07:00
538e8a86c8 Move node/osdep/ to sys/ 2014-07-26 13:10:41 -07:00
27aa6ea44e Linux routing table support work. 2014-07-25 16:16:05 -04:00
7475c4047e A bunch more osdep/ work... 2014-07-23 09:14:53 -07:00
5e58a7d54a Split UnixEthernetTap by platform to get rid of ifdef spaghetti. 2014-07-21 09:18:33 -07:00
6a174483d8 Ethernet tap factory interface. 2014-07-18 17:26:08 -07:00
a76d9d4408 Move OS-dependent implementations of generic interfaces to osdep/ in preparation for TapFactory refactor. 2014-07-17 17:19:18 -07:00
1189f4a568 Set/delete functionality in BSD routing table. 2014-07-17 17:17:59 -07:00
51766e6549 BSD routing table works... that hurt much worse than it should have. 2014-07-17 13:08:37 -07:00
d315156733 BSD routing table implementation work. 2014-07-16 15:13:53 -07:00
4c4675e3ac Cleanup, add __BSD__ 2014-07-15 20:49:13 -07:00
49ef980ecf Scale back Salsa20 benchmark a bit to not take too long on slow boxes. 2014-07-15 21:02:56 -04:00
12692c551e SSE optimized Salsa20 -- anywhere from 20% to 50% faster than plain C version 2014-07-15 17:56:09 -07:00
00f9305ad8 Routing table base class. 2014-07-15 13:48:42 -07:00
0097949ba9 . 2014-07-15 12:32:06 -07:00
1b33a9e807 . 2014-07-15 12:21:24 -07:00
4a0b33561c Starting to define system network stack interface. 2014-07-13 12:57:30 -07:00
96faaa85cf VERSION 0.9.1: bug fixes and experimental bridging support
This version fixes several bugs including an issue with networks that have
EtherType filtering disabled, a file permission issue that affected non-English
versions of Windows, a multicast propagation bug that caused multicasts to
be dropped more often than they should be, and an issue with IP auto-configuration.

It also introduces experimental support for bridging between physical and virtual
networks, a much-requested and powerful ability that's been planned from the start.
ZeroTier One can now replace the functionality of ordinary VPNs, link multiple
offices into a single LAN, and connect virtual machine backplanes in the cloud to
physical networks at home, among other things.

Bridging support isn't "officially" out yet, since the web UI part is still
in development. But when that is done, an official announcement will be
made on the blog and users can try it out. So far bridging has only
been tested under Linux with the Linux kernel's native bridging driver.
YMMV on other platforms. Try it out and let us know by filing bugs at GitHub
or e-mailing them to "contact@zerotier.com".
2014-07-03 13:32:53 -07:00
f82c7006ea Leave IP addresses alone instead of deleting them from tap if they are not members of any of the networks under management. 2014-07-02 15:59:08 -07:00
681af253ef Fix for GitHub issue #88 - actually do in the code what the web UI expects it to do. 2014-07-01 09:27:33 -07:00
88bdb81791 Keep track of basic aliveness for peers regardless if direct or indirect connectivity and use this for multicast propagation. Also consolidate adding of active bridges via the same functor as regular multicast next hops. 2014-06-30 11:31:04 -07:00
458f6ae7c3 Only add active bridges to top of MC propagation list if they are alive. Otherwise a dead active bridge might kill multicast for us. 2014-06-26 18:13:48 -07:00
999e963533 Fix for network not found in netconf. 2014-06-27 00:47:07 +00:00
5336f2600a Send ACCESS_DENIED if network not found. 2014-06-26 17:38:33 -07:00
38433e85bf More little stuff in crypto code. 2014-06-26 17:23:10 -07:00
c3cbc92757 Some crypto comment fixes. 2014-06-26 17:15:20 -07:00
45a1e048bb Add enabled/disabled status to network. 2014-06-26 17:05:07 -07:00
40bd460b1c Some comment revisions and additional sanity checks. 2014-06-23 08:19:41 -07:00
ae7143d693 Comments and cleanup. 2014-06-21 12:19:10 -07:00
aead1050fb Bridging (GitHub issue #68) does indeed work! Just needed to fix a packet size thinko. 2014-06-21 12:29:33 -04:00
6e485833ef . 2014-06-21 12:25:10 -04:00
be0a8ec1f1 . 2014-06-21 12:16:25 -04:00
11e1f7a3fb . 2014-06-21 12:01:26 -04:00
0b0d5fabac Bridging #68 should work now! 2014-06-21 11:59:08 -04:00
35aa0921ee . 2014-06-21 11:47:26 -04:00
2f8936181c Debug code -- temporary. 2014-06-21 08:36:23 -07:00
4c3fb8cf10 Don't list node as an active bridge if it's not authorized. (Wouldn't work anyway.) 2014-06-20 16:04:53 -07:00
c3cea55493 Some cleanup in PacketDecoder. 2014-06-18 09:00:53 -07:00
5d467f0f45 Some TRACE improvements and comment revs. 2014-06-18 08:25:30 -07:00
2162a419e3 Some logging fixes. 2014-06-17 13:52:55 -07:00
f15271f31f Get rid of pointer type punning warning/issue on g++. 2014-06-17 15:54:35 -04:00
9d6488c31a Typo fix. 2014-06-16 20:41:23 +00:00
adc922d7fb Support for bridging fields in netconf. 2014-06-16 13:26:46 -07:00
cf4700bc26 Simplify network briding modes -- we only need passive toggle and active bridge list, not three mode types. Also change isOpen to isPublic for terminology consistency. 2014-06-14 20:24:19 +00:00
367b5439e1 Run icacls.exe twice, once for each change - GitHub issue #71 2014-06-14 12:52:06 -07:00
6802da457e Bridging pretty much ready to test! Got Switch all wired up. Also fix a latent probably-never-triggered bug in MULTICAST_FRAME handling. GitHub issue #68 2014-06-13 21:06:34 -07:00
5682f0b772 Some more bridging work... wiring up in Switch - GitHub issue #68 2014-06-13 17:49:33 -07:00
08b7bb3c7a Network memory for bridge-side multicast groups that we learn - GitHub issue #68 2014-06-13 14:06:34 -07:00
d6a4f8d77b Add flags to EXT_FRAME for better future proofness. 2014-06-12 11:40:30 -07:00
c30f9832b0 Packet decoder work for EXT_FRAME for bridging - GitHub issue #68 2014-06-10 21:41:34 -07:00
d44e1349d8 Bridge routing table - GitHub issue #68 2014-06-10 17:18:59 -07:00
6f831d5370 Bridging fields in Redis schema for netconf master. 2014-06-10 15:51:54 -07:00
4e1f49258b Bridging in NetworkConfig - GitHub Issue #68 2014-06-10 15:47:20 -07:00
fb31f93c52 Protocol messages for bridging. GitHub issue #68 2014-06-10 15:25:15 -07:00
f720f04fa0 Installer updates from 0.9.0 release -- only useful to me. 2014-05-29 20:23:25 -07:00
7a56c3c396 VERSION 0.9.0: upgrade required!
Version 0.9.0 adds a network-wide toggle for blanket broadcast (ff:ff:ff:ff:ff:ff), contains changes for compatibility with the new web site and netconf server code, and most importantly introduces unique non-conflicting MAC address schemes on a per-virtual-network basis.

The MAC address change is necessary to support bridging, which is the next major feature to be added. It's not absolutely required, but it makes sure that things work properly in the (probably very rare) case that two virtual networks happen to be directly or indirectly bridged together.

The MAC change means that 0.9.0 is a required update. Clients not updating will find themselves unable to communicate with older versions. The underlying protocol is the same, but MAC address resolution and routing will not work properly. Those running binary releases will be updated automatically, while those running from source must download and rebuild.

This version also fixes two minor security issues, including one involving file permissions on non-English Windows versions.
2014-05-29 17:53:30 -07:00
994565bdeb Fix for GitHub issue #71 2014-05-29 15:06:05 -07:00
67498e576c Delete some obsolete stuff. 2014-05-29 18:36:17 +00:00
eae130467b Build fix for Windows setsockopt(). 2014-05-29 11:22:35 -07:00
f764cf8d31 Make UDP send and receive buffers as big as possible to reduce packet loss. 2014-05-28 12:17:43 -07:00
49247180dc Add lastSeen and identity to member record if not present. 2014-05-28 01:32:27 +00:00
914bebba31 Re-enable exit on stream close in netconf service. 2014-05-27 15:59:09 +00:00
4b773b61f5 Netconf fixes. 2014-05-24 00:10:23 +00:00
657f6ae342 Don't transmit broadcasts if enableBroadcast is false on a network. 2014-05-23 19:52:39 -04:00
2861229558 Windows build fixes for MAC changes (in tap driver), some comments and cleanup in MAC.hpp. 2014-05-23 16:21:57 -07:00
f939d0ee62 Upgrade AIP for new version of Advanced Installer, bump to 0.9.0. 2014-05-23 16:08:05 -07:00
77c58e741d GitHub issue #58 - options after path on command line were ignored, fixed. 2014-05-23 15:21:28 -07:00
66a38a9e7c Default for private should be true. 2014-05-23 15:15:44 -07:00
31ddc49da2 GitHub issue #67 2014-05-23 15:13:34 -07:00
317995b921 Fixed for Linux tap for GitHub Issue #69 2014-05-23 17:35:35 -04:00
beb7b5bbe5 GitHub Issue #69 - make MAC assignment schema differ between virtual networks. 2014-05-23 14:32:31 -07:00
05f5755bb1 Allow Redis DB# select. 2014-05-23 00:35:11 +00:00
cfd92cb18d Remove old netconf code. 2014-05-22 21:05:49 +00:00
2456d3a197 Node redis module update. 2014-05-22 21:05:08 +00:00
f0b821f880 . 2014-05-21 02:48:58 +00:00
319f9a9346 Netconf testing and fixes. 2014-05-20 20:05:11 +00:00
596e5dd583 Another sanity check on filename for GitHub issue #72 2014-05-19 16:16:34 +00:00
b958a2d30c Redis schema updates and fix for GitHub issue #72 2014-05-19 16:13:42 +00:00
e270887391 Some Redis schema changes. 2014-05-14 17:48:50 +00:00
986773cc9c ZT_USE_TESTNET define in makefiles. 2014-05-09 11:52:53 -07:00
ecbcc9eb2c TESTNET supernodes need different addresses. 2014-05-09 11:45:38 -07:00
1ad29fe31f Merge branch 'adamierymenko-dev' of ssh://shub-niggurath.zerotier.com:222/git/ZeroTierOne into adamierymenko-dev 2014-05-09 15:40:08 +00:00
42f6aae259 More netconf work... set ZT_HOME and chdir there on service launch. 2014-05-09 15:39:51 +00:00
de485ad900 Add testnet ports and ZT_USE_TESTNET define for contacting the test.zerotier.com net instead of the live net. 2014-05-08 17:53:22 -07:00
99c5fae9da Make Service communicate via empty-line-delimited Dictionary objects instead of the old size prefix way. 2014-05-08 21:27:59 +00:00
98f0418fb9 A little more cleanup in node code. 2014-05-08 00:47:46 +00:00
d7977fa3e1 Make certificate of membership works in node code! 2014-05-08 00:22:20 +00:00
1e6475fad6 Clean out unused netconf fields, rename a few, work on new netconf server. 2014-05-08 00:11:50 +00:00
d5f95b721d Yet more work on netconf master, add redis docs. 2014-05-07 02:45:15 +00:00
ae2eeff5c6 . 2014-05-06 00:24:21 +00:00
08da4b8c7b Add mkcom functionality to zerotier-idtool for use by new NodeJS netconf-master code. 2014-05-06 00:15:21 +00:00
0ba0c6d04d New netconf... 2014-05-06 00:05:11 +00:00
93f24ea86a Some work on new netconf service... 2014-05-05 22:11:21 +00:00
f8eae84e15 Retire old netconf mess. 2014-05-05 15:05:11 +00:00
7831c4bfef Cleanup, dead code removal, some pretty insignificant security stuff that's based on recommendations. 2014-04-18 00:14:12 -07:00
5f45977e3e Update GitHub README 2014-04-16 11:40:48 -07:00
d187ec82d4 Adding supernode yig.zerotier.com (Sydney, Australia) and removing mi-go.zerotier.com (Singapore) due to real-world usage data. 2014-04-15 14:37:19 -07:00
42c3474223 VERSION 0.8.2
This version fixes a few more issues with TCP tunneling including GitHub issue #63.
It also adds automatic announcement and location of peers on physical LANs (GitHub
issue #56) which should greatly improve performance if you happen to be on the same
LAN or WiFi network as another peer. It can take 60 seconds or so for this to occur,
but it should.
2014-04-10 22:46:17 -07:00
aee742e767 More toward GitHub issue #56 2014-04-10 16:30:15 -07:00
c9294c1a78 Prevent recursive transit of ZeroTier packets, toward GitHub issue #56 2014-04-10 14:22:25 -07:00
b117ff5435 Probable fix for GitHub issue #63 - do not unite() if either path is TCP, since doing so can result in asymmetric failed NAT-t over UDP if one side has a firewall that permits outgoing UDP but not incoming. 2014-04-10 11:17:54 -07:00
119ef5ecbf More logic cleanup and some documentation / comment improvements. 2014-04-10 10:00:20 -07:00
8fb442d81a Yet more cleanup to TCP logic, this time adding a master switch and adding UDP preference in send(). 2014-04-09 17:08:35 -07:00
73153b89b4 Some cleanup, and use best (not first) UDP addresses for NAT-t VERB_RENDEZVOUS computation. 2014-04-09 16:00:25 -07:00
d9836adbf6 .... aaaaaand... GitHub issue #61 was caused by the fact that we were no longer deleting taps on Windows! 2014-04-09 15:34:03 -07:00
420edf23ad Was not closing _shutdownSignalPipe in UnixEthernetTap either... 2014-04-09 15:32:37 -07:00
6c5f6feb5e Set close-on-exec in attempt to head off GitHub issue #61 2014-04-09 15:22:08 -07:00
a1c1c82b0d VERSION 0.8.1
This, quick on the heels of 0.8.0, fixes the fact that TCP tunneling was
broken. :)

There was a bug that only manifested in some cases, and not on my testnet.
I took the opportunity to clean up some of that logic generally. I need a
better testnet, but that will have to wait until we exit beta and hopefully
I can earn a little bit of money off this. A better testnet will require
a big beefy virtualization box or two to run hundreds to thousands of KVMs.

Also fixed a tiny cosmetic issue on Windows. Other than that no changes.
2014-04-09 13:03:33 -07:00
83a0d988ec Text point size readjustment not needed on child windows in Windows? 2014-04-09 12:19:46 -07:00
a8c12369fd More tweaks to TCP logic for GitHub issue #60 2014-04-09 12:10:05 -07:00
28a6d328a5 Some adjustments to TCP logic for GitHub issue #60 2014-04-09 11:55:24 -07:00
dd404b8ba3 VERSION 0.8.0
This version introduces a major new feature requested by several users,
both via the user survey and otherwise: TCP tunneling.

If you are not able to communicate over UDP/9993, ZeroTier One will switch to
TCP connections to ZeroTier's supernodes. This is always slower than UDP, but
will allow you to communicate behind all but the most extremely restrictive
firewalls. This TCP traffic travels over port 443 and looks like HTTPS (SSL)
traffic (though it isn't), since that port is almost always open.

This also fixes several minor bugs and attempts to improve the robustness of
Windows tap driver management. Several users have reported spurious issues
with the Windows tap device, though I was unable to reproduce any of these with
clean VMs. (Tried Windows 7 and 8.1, both x86 and x64. No luck.) But I tried
to beef up the tap code anyway in the hopes of catching it. It now tries a lot
harder to make sure the tap is up and running.

There was some significant under the hood refactoring in support of TCP, so
this was a non-trivial change.

I bumped the version to 0.8 to indicate that more and more features are being
crossed off the list as we approach 1.0 and exit from beta. After this, the next
major feature will be LAN announcement to find direct paths to peers on the
same physical LAN. But assuming that 0.8.0 goes smoothly, I am going to divert
attention to the web site. A new design is coming that is much cleaner, sharper,
and easier to use.

Thank you all for all your excellent feedback! We're well on the way to a killer
product that makes conventional VPNs and other kludges obsolete.
2014-04-08 22:38:51 -07:00
1c636afe3f Fix typo. 2014-04-08 16:43:36 -07:00
48a1799f49 More Windows tap cleanup... seems solid. We'll see. 2014-04-08 16:10:48 -07:00
bf24de43fe Windows tap: be REAL REAL REAL PARANOID. Wake up sheeple. 2014-04-08 15:47:33 -07:00
76d9ea911d Another Qt build fix... need the right tap driver in build just to make symbols work even though UI doesn't use that code. 2014-04-08 14:16:45 -07:00
ff773def26 Remove EthernetTap.cpp from UI build project. 2014-04-08 13:59:31 -07:00
5abfb11813 Some installer stuff, complete refactoring of Windows side of newly split tap driver. Seems to work. Now to see if the cleanup we did here gets rid of the zombie tap device issue on Windows. 2014-04-08 12:00:21 -07:00
0b8d6c7f4a Builds and runs on Unix with EthernetTap changes, now for Windows... and for what we did this for: a refactor of the Windows tap connector. 2014-04-07 15:39:33 -07:00
6c60305a96 Split EthernetTap into subclasses, work in progress... 2014-04-07 14:47:39 -07:00
19c4d82512 Intaller upgrade and stuff, fix to Windows service for new Node API changes. 2014-04-04 16:59:02 -07:00
e11149bcae Fix network widget spacer issue on Windows. 2014-04-04 12:25:48 -07:00
fe85426df6 A few more tweaks to TCP failover... seems to be switching back and forth pretty well now! 2014-04-03 17:12:34 -07:00
158002d2d1 Tweak some timings and stuff. 2014-04-03 16:19:41 -07:00
c96d3ebf8c Such ping logic. So edge case. 2014-04-03 14:36:52 -07:00
b1088a6bd7 Make Unix domain sockets mode 0777 so that properly authorized non-privileged users can access them (if they have auth token). 2014-04-02 17:21:26 -07:00
f0223490be Make GUI work with new control client API, make control client look for user authtoken.secret if system unreadable. 2014-04-02 17:12:04 -07:00
81e5690410 More tweaks to TCP failover logic. Such edge case. 2014-04-02 17:32:47 -04:00
700a450806 More tweaks to algorithm for determining when to fail over to TCP, and stop supernodes from resynchronizing unless explicitly ordered. 2014-04-01 18:39:10 -07:00
0e1fc06a6f The remove paths on send fail thing in Peer.cpp was not well thought out, and there is no point in mallocing the TCP write buffer. 2014-04-01 15:55:05 -07:00
c3b41c289d Resynchronize on startup. 2014-04-01 14:12:54 -07:00
6ab95e0391 Get : out of Path.toString() since this will conflict with : in IPv6 IPs. 2014-04-01 08:52:52 -07:00
67b3fa9311 Clean up main.o in Linux make clean. 2014-03-31 22:38:46 -07:00
316e8d1939 Build fix. 2014-03-31 22:30:08 -07:00
f13493edb2 Oops... turns out we need to differentiate incoming from outgoing TCP and indeed learn incoming TCP paths. Otherwise the recipient of a TCP connection does not know to reply via TCP! Heh. 2014-03-31 22:23:55 -07:00
595b386afc Increase maximum packet fragments to make room for huge multicasts with certificates of membership tagged onto them. This likely will not actually increase the number of fragments in practice much, since these are then subsequently compressed. But the buffer needs to be allocated with room for them, otherwise these packets get dropped with a range_error exception internally. 2014-03-31 14:53:33 -07:00
8e587ae481 Clean dead paths from peers. 2014-03-31 11:41:14 -07:00
acb056e3b1 Small readability fix. 2014-03-28 21:04:15 -07:00
5ef2c6fd6f Add TCP/443 to all supernodes in Defaults. 2014-03-28 15:51:19 -07:00
1a0572d7e7 Remove UDP-breaking debug code. 2014-03-28 13:58:18 -07:00
7957ab6b1d Windows uses exceptfds to report failed async connect() in select(). TCP now done on Windows (I think). 2014-03-28 13:37:21 -07:00
e8b613e625 TCP connections work on Windows now. 2014-03-28 12:26:33 -07:00
9c68a343f6 Reduce some TRACE noise. 2014-03-27 18:57:20 -07:00
881ff08269 Make multiple attempts to open the tap device on Windows. 2014-03-27 18:50:10 -07:00
e3239d23f4 Windows build fix. 2014-03-27 18:39:58 -07:00
f9c92b0351 Build fix from merge. 2014-03-27 18:24:57 -07:00
b73c36acbf Merge branch 'adamierymenko-dev' of ssh://shub-niggurath.zerotier.com:222/git/ZeroTierOne into adamierymenko-dev 2014-03-27 18:23:02 -07:00
181369964f Make TCP optional, rename port constant. 2014-03-27 18:22:53 -07:00
d2c5d71502 Finally fixed TCP sockets. 2014-03-27 17:42:02 -07:00
c231510f8b More TCP-related fixes and tweaks to ping timing, resynchronize, and startup. 2014-03-27 17:02:52 -07:00
2ac56fd120 Fix TCP connection accumulation problem, still having issues with TCP tunneling. 2014-03-26 17:59:45 -07:00
e6b23059ac Change the way TCP failover is invoked. 2014-03-26 16:44:58 -07:00
04169b5150 If I want it to pick the first, actually picking the first is helpful. 2014-03-26 15:44:24 -07:00
daaec84c6b Add TCP channel support for supernode list, make Peer pick the first path if all paths are equally dead. 2014-03-26 15:35:15 -07:00
73c1d43f2f Crank down default multicast preload and max balance just a little bit... should not impact non-lame protocols. 2014-03-25 21:48:16 -07:00
ab5a460177 Apply multicast rate limits on a network to ourselves and do not send multicasts that would exceed limits, for GitHub issue #55 2014-03-25 21:38:54 -07:00
67a85221d5 WINDOWS IS SUFFERING 2014-03-25 17:31:03 -07:00
328be8f846 Make Windows build, add (untested) Windows named pipe based IPC code. 2014-03-25 08:37:08 -07:00
d9b91758e0 Fix command line interface. 2014-03-21 14:58:35 -07:00
4e26ade2df Fix deadlock in refactored code. 2014-03-21 14:31:10 -07:00
8d3eb1a258 A few renamings to be consistent. 2014-03-21 14:18:35 -07:00
33ad3deaee Builds with new Path code. 2014-03-21 13:46:55 -07:00
ba3f04deed Work in progress: refactoring paths, adding TCP fallback. 2014-03-20 20:07:35 -07:00
45e823d27c Reworking of paths in Peer work-in-progress, and TCP connect support in SocketManager. Also add FD_SETSIZE checking for the default select implementation of sockets. 2014-03-20 18:49:33 -07:00
70b736f440 Put mac back to release default build flags. 2014-03-20 14:44:13 -07:00
97e6b38144 MULTICAST_FRAME TRACE improvements. 2014-03-20 14:24:15 -07:00
7a45ff460d More deadlock fixes in new I/O. 2014-03-20 14:00:05 -07:00
6f5a4d7e29 Fix blocking socket issues in new socket I/O code. 2014-03-20 13:21:58 -07:00
4d0ad9abb6 Fix TRACE bug and new UDP socket code issue. 2014-03-19 23:10:34 -07:00
15e8c18106 Bug fixes. 2014-03-19 22:01:32 -07:00
1c555e4b96 command bus fix 2014-03-19 16:59:23 -07:00
6fdb360e2a More IPC work. 2014-03-19 16:05:03 -07:00
0d847d9410 More build fixes. 2014-03-19 15:29:00 -07:00
abc82d6a52 IPC changes and SocketManager changes all build! 2014-03-19 13:56:48 -07:00
acf7d70d24 Integrate IPC stuff into NodeConfig. 2014-03-19 08:20:09 -07:00
3be4c38946 IPC stuff for Unix. 2014-03-18 18:44:44 -07:00
6a1bd52854 New IPC work... 2014-03-18 17:19:32 -07:00
0b75992737 Everything but the local config bus... blech. 2014-03-18 14:33:57 -07:00
91fef21973 More ripping out of old condition stuff. 2014-03-18 12:21:22 -07:00
dc0f3559be Rip out old condition and Demarc stuff... 2014-03-18 12:00:15 -07:00
bb25128406 TCP socket. 2014-03-18 11:53:53 -07:00
bf5d8de999 More new socket I/O work... 2014-03-17 16:29:53 -07:00
1a0a6755b1 UDP socket implementation. 2014-03-17 16:18:44 -07:00
8adbbe092d Drop old Demarc.cpp code. 2014-03-17 15:15:02 -07:00
bd749e040d Compile fixes. 2014-03-17 15:14:22 -07:00
7e80d7e551 Bunch of work in progress on new socket multiplexer and plumbing for TCP jailbreaking... Don't try to build, won't yet. 2014-03-17 09:05:43 -07:00
ce09d00679 Security improvements to Linux build flags mirroring OSX improvements. 2014-03-11 11:50:04 -07:00
dbd7a06ea9 Enable PIE to allow ASLR (security) 2014-03-11 10:56:38 -07:00
74c2e644a9 Change -O4 to -O3 -flto on OSX for new clang (should work with older one too) 2014-03-11 10:18:39 -07:00
dfee7e0389 VERSION 0.7.2: first Windows release!
Version 0.7.2 marks the first release of ZeroTier One for Windows. Binaries will be
released to a few select testers at first, then to the whole world. Installation from
MSI and auto-update appear to be working. So far Windows 7 and 8 and Windows Server
2008 or newer are supported. Vista has issues so it's not supported at the moment,
and may not be since nobody seems to use it (according to Google Analytics).
2014-03-07 15:20:37 -08:00
60f25ccdf9 Some text changes, remove unused modules from installer project. 2014-03-07 14:25:24 -08:00
2b0dbead17 Disable Vista in installer. 2014-03-06 15:32:30 -08:00
d0b506c12b Fix crash on uninitialized taps. 2014-03-06 15:11:08 -08:00
742261c7fc (1) Fix menu bar item font size on Windows, (2) fix for possible Windows EthernetTap infinite loop while enumerating registry. 2014-03-06 14:06:31 -08:00
939cdc82a2 VERSION 0.7.1: small Linux compile fix on g++, does not merit new release 2014-03-05 15:40:31 -08:00
a207ce13c0 VERSION 0.7.1: installation fixes, new supernode
This version contains fixes to Linux installation and deployment and adds a
new supernode in Tokyo, Japan. It also has a working Windows installer, though
a bit more testing is going to take place before Windows binaries are
actually released.
2014-03-05 15:19:45 -08:00
17c77da38f Fix GitHub issue #45 - Linux install issues 2014-03-05 23:57:25 +01:00
54313212a4 New supernode: shoggoth.zerotier.com in Tokyo, Japan! This just about covers the entire world for global low-latency peer location and relaying. 2014-03-05 23:21:23 +01:00
b2673eab55 Revisions to Linux install script, and support for init.d or upstart systems without chkconfig (Ubuntu). 2014-03-05 22:33:58 +01:00
282d41bc94 Script to build UI against our own new precompiled Win32 static Qt binary, which paradoxiclally results in a smaller executable than dynamic Qt and doesn't require us to bundle a million DLLs. Also update installer to reflect that. Finally, add a step to the installer to remove all instances of the tap device on full uninstall so as not to leave orphaned junk in your network connections or device manager. Looking good! 2014-03-05 09:52:59 -08:00
b72c2c6358 Disable SSE on 32-bit Windows builds since people might still be using old school chips... x64 builds with SSE since pretty much all AMD64/x86_64 chips have it. 2014-03-04 11:18:34 -08:00
5581339d5b Build with /MT on Windows so we can stop having to install a redistributable... makes installer less noisy but unfortunately makes binary bigger. Oh well. 2014-03-04 11:16:39 -08:00
78f3966d66 Make sysV init script run as daemon, for GitHub issue #45 2014-03-03 12:00:26 -08:00
bae9fa1480 -d switch for daemonizing on Unix 2014-03-03 11:53:43 -08:00
cef750d1d2 Add option to install drivers in driver cache on Windows, needed for Windows installer. Blech. 2014-03-03 10:23:19 -08:00
be36eda858 Add prerequisites (VS2012 redistributables) to installer. 2014-02-28 16:09:42 -08:00
13fbf9a200 *nix build fix 2014-02-28 15:05:56 -08:00
f2a03f68bd Add code to clean unused permanent tap interfaces on Windows (but not used yet). 2014-02-28 15:04:50 -08:00
d997c1a32a Installer work... 2014-02-28 12:20:05 -08:00
d27251ec4e Make AtomicCounter use <atomic> on Windows (eventually this will replace it on other platforms), and some installer work. 2014-02-28 09:15:29 -08:00
9ae6403346 Installer works, and fix for ugly fonts in pulldown menus in main windows in UI. Also remove dummy installer, which we don't need anymore. 2014-02-27 21:56:57 -08:00
39d411ce0b Installer work... 2014-02-27 21:28:34 -08:00
93fe848bb6 Ignore a build dir. 2014-02-27 16:39:02 -08:00
9d05897f7a Windows service works now! 2014-02-27 16:28:55 -08:00
cbeb9c5236 Installer work, sign devcon. 2014-02-26 16:32:32 -08:00
2203958798 Windows auto-updater invocation works... time to try an installer! 2014-02-26 14:37:21 -08:00
268ec8d1e0 Fix for GitHub issue #40: updates.d not being cleared. 2014-02-24 13:23:03 -08:00
093d745b86 ZT_OFFICIAL_RELEASE and ZT_AUTO_UPDATE in Windows build in Release mode. 2014-02-23 09:06:55 -08:00
655b6d1996 Windows auto-update URL and dummy Windows update for testing. 2014-02-23 08:01:52 -08:00
833a0621fa Windows service auto-update work. 2014-02-21 23:49:24 -08:00
b5c3a92be2 Boring stuff: update dates in copyrights across all files. 2014-02-16 12:40:22 -08:00
78694bb2f5 VERSION 0.7.0: another documentation update (no version change or code changes) 2014-02-16 12:10:43 -08:00
297cfd86fa VERSION 0.7.0: updated docs (no version change)
See previous commit message for 0.7.0 release notes.
2014-02-16 12:08:13 -08:00
415 changed files with 61860 additions and 19701 deletions

71
.gitignore vendored
View File

@ -1,32 +1,73 @@
/ext/llvm-g++-Xcode4.6.2
/ext/llvm-g++-Xcode4.6.2.tar.bz2
# Main binaries created in *nix builds
/zerotier-*
/ZeroTierUI/*.user
*.o
# OS-created garbage files from various platforms
.DS_Store
.Apple*
*.dSYM
/netconf-service/netconf-test
/netconf-service/netconf.service
/ipch
Thumbs.db
# Windows build droppings
/windows/ZeroTierOne.sdf
/windows/ZeroTierOne.v11.suo
/windows/x64
/windows/Win32
/windows/*/x64
/windows/*/Win32
/windows/ZeroTierOne/Release
/windows/ZeroTierOneService/obj
/windows/ZeroTierOneService/bin
/windows/Build
/windows/Debug
/windows/Release
/windows/WebUIWrapper/bin
/windows/WebUIWrapper/obj
/ext/installfiles/windows/ZeroTier One-SetupFiles
/ext/installfiles/windows/Prerequisites
/ext/installfiles/windows/*-cache
/ZeroTier One.msi
# *nix/Mac build droppings
/build-*
/ZeroTierOneInstaller-*
# Miscellaneous file types that we don't want to check in
*.log
*.opensdf
*.user
*.cache
*.obj
*.tlog
/build-*
/ZeroTierOneInstaller-*
.qmake.stash
*.pid
*.pkg
*.o
*.core
*.deb
*.rpm
*.autosave
/ZeroTier One.zip
/ZeroTier One.dmg
/windows/x64
/windows/ZeroTierOneInstaller/ZeroTierOneInstaller
*.tmp
# Root topology build files, temporaries, and never check in secrets
/root-topology/bin2c
/root-topology/mktopology
/root-topology/*.secret
/root-topology/test/supernodes
/root-topology/test/test-root-topology
# MacGap wrapper build files
/ext/mac-ui-macgap1-wrapper/src/MacGap.xcodeproj/project.xcworkspace/xcuserdata/*
/ext/mac-ui-macgap1-wrapper/src/MacGap.xcodeproj/xcuserdata/*
/ext/mac-ui-macgap1-wrapper/src/build
# Web UI dev temporaries
/ui/.module-cache
node_modules
# Java/Android/JNI build droppings
java/obj/
java/libs/
java/bin/
java/classes/
java/doc/
java/build_win64/
java/build_win32/
/java/mac32_64/

View File

@ -9,6 +9,12 @@ ZeroTier One includes the following third party code:
* LZ4 compression algorithm by Yann Collet (BSD license)
http://code.google.com/p/lz4/
* http-parser by many authors (MIT license)
https://github.com/joyent/http-parser
* json-parser by James McLaughlin (BSD license)
https://github.com/udp/json-parser
* TunTapOSX by Mattias Nissler (forked for ZT1) (BSD license)
http://tuntaposx.sourceforge.net

View File

@ -1,45 +0,0 @@
Building ZeroTier One on different platforms:
(See RUNNING.txt for what to do next.)
Developers note: there is currently no management of dependencies on *nix
platforms, so you should make clean ; make if you change a header. Will
do this eventually.
-- Linux
make
That's it. Add ZT_AUTO_UPDATE=1 to the make command line to build an
auto-update-enabled version that will update from ZeroTier's servers.
This is disabled by default since such a build will automatically
replace itself with our binary distributions.
-- MacOS
make
The same ZT_AUTO_UPDATE=1 option as Linux supports can be used here to
build an auto-update-enabled version. By default auto-updates are not
enabled.
If you are building ext/tap-mac you will need a different version of the
OSX gcc compiler chain than what currently ships (clang). We've got a copy
available here:
http://download.zerotier.com/dev/llvm-g++-Xcode4.6.2.tar.bz2
Un-tar this into ext/ (it's excluded in .gitignore) and then 'make' in
ext/tap-mac/tuntap/src/tap.
Most users should not need to build tap-mac, since a binary is included
in ext/bin.
To build the UI you will need Qt version 5.0 or later. The Qt home must
be symbolically linked into "Qt" in the parent directory of the ZeroTier
One source tree. Then you can type "make mac-ui" and the UI should build.
You can also load the UI in Qt Creator and build/test it that way.
-- Windows
Here be dragons.

View File

@ -9,3 +9,10 @@ endif
ifeq ($(OSTYPE),Linux)
include make-linux.mk
endif
ifeq ($(OSTYPE),FreeBSD)
include make-freebsd.mk
endif
ifeq ($(OSTYPE),OpenBSD)
include make-freebsd.mk
endif

169
README.md
View File

@ -1,18 +1,171 @@
ZeroTier One
======
ZeroTier One creates flat virtual Ethernet networks of almost unlimited size. [Visit ZeroTier Networks on the web](https://www.zerotier.com/) for more information.
ZeroTier is a software defined networking layer for Earth.
This project is now in beta, which means that major incompatible protocol shifts should now become considerably more rare. You should still update very often if you plan to use it. Binary packages with auto-update are coming very soon.
It can be used for on-premise network virtualization, as a peer to peer VPN for mobile teams, for hybrid or multi-data-center cloud deployments, or just about anywhere else secure software defined virtual networking is useful.
Follow the [ZeroTier blog](http://blog.zerotier.com/) and the [GitHub project](https://github.com/zerotier/ZeroTierOne) to stay up to date.
ZeroTier One is our OS-level client service. It allows Mac, Linux, Windows, FreeBSD, and soon other types of clients to join ZeroTier virtual networks like conventional VPNs or VLANs. It can run on native systems, VMs, or containers (Docker, OpenVZ, etc.).
See BUILDING.txt and RUNNING.txt for instructions. It currently runs on Mac and Linux. A Windows port is well along the way to completion. If you're brave you can load the Visual Studio 2012 solution and play around.
Visit [ZeroTier's site](https://www.zerotier.com/) for more information. You can also download professionally packaged binary installers/packages for a variety of supported OSes there if you don't want to build ZeroTier One from source.
Once you have it running you can join the Earth network -- a LAN for the planet -- by using the 'zerotier-cli' tool: 'sudo zerotier-cli join 8056c2e21c000001'. Right now Earth is the only network. Ability to create private networks, as well as some additional special-purpose public ones, will be coming soon. (Note: previous alpha versions auto-joined Earth, but since 0.5.0 it no longer does this.)
### Building from Source
Note that this won't work if your firewall does not allow outbound UDP. It must allow two way UDP conversations on port 9993 at a minimum.
For Mac, Linux, and BSD, just type "make" (or "gmake" on BSD). You won't need much installed; here are the requirements for various platforms:
ZeroTier One is licensed under the GNU General Public License version 3. You are free to use, modify, or redistribute it under the terms of that license. If you would like to embed ZeroTier One in a closed source product or create a closed source derivative product, contact ZeroTier Networks LLC.
* Mac: Xcode command line tools, and [Packages](http://s.sudre.free.fr/Software/Packages/about.html) if you want to build an OSX .pkg installer ("make mac-dist-pkg"). It should build on OSX 10.7 or newer.
* Linux: gcc/g++ or clang/clang++ (Makefile will use clang by default if available.)
* FreeBSD (and other BSD): C++ compiler (G++ usually) and GNU make (gmake).
(c)2012-2013 [ZeroTier Networks LLC](https://www.zerotier.com/)
Each supported platform has its own *make-XXX.mk* file that contains the actual make rules for the platform. The right .mk file is included by the main Makefile based on the GNU make *OSTYPE* variable. Take a look at the .mk file for your platform for other targets, debug build rules, etc.
Windows, of course, is special. We build for Windows with Microsoft Visual Studio 2012 on Windows 7. A solution file is located in the *windows* subfolder. Newer versions of Visual Studio (and Windows) may work but haven't been tested. Older versions almost certainly will not, since they lack things like *stdint.h* and certain STL features. MinGW or other ports of gcc/clang to Windows should also work but haven't been tested. Build steps for Windows are a bit more complicated. For the moment you are on your own there.
Mobile versions are in progress. They don't work yet, and in any case only the glue code will be included in this repository. The full mobile apps are in private repositories on our own git server.
### Supported Platforms
CPU architecture shouldn't matter unless it's smaller than 32-bit or something really bizarre like a "middle-endian" processor. We have reports of ZeroTier One running on arm32, arm64, and MIPS. It builds and runs out of the box on Raspberry Pi, BeagleBone, BananaPi, and other ARM-based developer/hobbyist boards.
ZeroTier is written in C and C++ (C++03 / ISO/IEC 14882:2003) and uses data structures and algorithms from the C++03 STL. We do not use any C++11 features (yet), since we want to support a few old and embedded platforms that don't have C++11 compilers. You *will* require a compiler and headers new enough to support 64-bit integers (long long) and the *stdint.h* header. The latter could also be faked by adding defines for things like *uint32\_t*, *int64\_t*, etc.
Typing "make selftest" will build a *zerotier-selftest* binary which unit tests various internals and reports on a few aspects of the build environment. It's a good idea to try this on novel platforms or architectures.
### Running
Running *zerotier-one* with -h will show help.
On Linux and BSD you can start the service with:
sudo ./zerotier-one -d
A home folder for your system will automatically be created.
The service is controlled via the JSON API, which by default is available at 127.0.0.1 port 9993. We include a *zerotier-cli* command line utility to make API calls for standard things like joining and leaving networks. The *authtoken.secret* file in the home folder contains the secret token for accessing this API. See README.md in [service/](service/) for API documentation.
Here's where home folders live (by default) on each OS:
* Linux: /var/lib/zerotier-one
* BSD: /var/db/zerotier-one
* Mac: /Library/Application Support/ZeroTier/One
* Windows: \\ProgramData\\ZeroTier\\One (That's for Windows 7. The base 'shared app data' folder might be different on different Windows versions.)
Running ZeroTier One on a Mac is the same, but OSX requires a kernel extension. We ship a signed binary build of the ZeroTier tap device driver, which can be installed on Mac with:
sudo make install-mac-tap
This will create the home folder for Mac, place *tap.kext* there, and set its modes correctly to enable ZeroTier One to manage it with *kextload* and *kextunload*.
We recommend using our binary packages on Windows, since there are several prerequisites such as a tap driver that must be installed on the system *and* in the home folder.
### Joining A Network
ZeroTier virtual networks are identified by 16-digit hexadecimal network IDs, while devices are identified by 10-digit addresses. To get your address run:
sudo zerotier-cli status
(Use ./zerotier-cli if you're running it right from your build folder.)
You should see something like:
200 info ########## ONLINE #.#.#
That 10-digit hex code is you. It's derived via a one-way proof of work function from your cryptographic public key. Your public key can be found in *identity.public* in ZeroTier's home folder, while *identity.secret* contains your full identity including the secret portion of the key pair.
(The identity files define your device's *identity*. Moving them to another system will move that identity. Be careful when cloning virtual machines that have identities stored on them. If two devices have the same identity, they'll "fight" over it and you won't know which device will receive network packets.)
If you want to do a quick test, you can join [Earth](https://www.zerotier.com/earth.html). It's a global public network that anyone can join. Type:
sudo zerotier-cli join 8056c2e21c000001
Then:
sudo zerotier-cli listnetworks
At first it'll be in *REQUESTING\_CONFIGURATION* state. In a few seconds to a minute you should see something like:
200 listnetworks 8056c2e21c000001 earth.zerotier.net ##:##:##:##:##:## OK PUBLIC zt0 ##.##.##.##/##
Earth will assign you an IP address in the "unofficially available" globally unrouted 28.0.0.0/7 IP block so as to avoid conflicts with local networks. (Your networks can use any IP scheme, or can even leave IP addresses unmanaged.) Once you get an IP, you should be able to ping something:
ping earth.zerotier.net
Go to [http://earth.zerotier.net/](http://earth.zerotier.net/) to see a short little welcome page that will tell you your IP and Ethernet MAC address.
Earth is a public place. If you don't want to stick around run:
sudo zerotier-cli leave 8056c2e21c000001
The network (and associated interface) should be gone.
Networks are created and administrated by network controllers. Most users will want to use our hosted controllers. Visit [our web site](https://www.zerotier.com/) for more information. Later in this README there are brief instructions about building ZeroTier One with network controller support for those who want to try running their own.
Macintosh and Windows installers also install a GUI application.
### Installing
We don't have a "make install" rule quite yet. On Linux you can type:
make installer
This will build a binary that, when run, will install ZeroTier One on most current Linux distributions. We also have RPM and DEB build files in *ext/installfiles/linux* that wrap this installer in packages for RedHat/CentOS and Debian/Ubuntu derived distributions. If *rpmbuild* is present on the system, the RPM will be built. If *dpkg-deb* is present, the DEB package will be built.
On Mac the best way is to install [Packages](http://s.sudre.free.fr/Software/Packages/about.html) and use:
make mac-dist-pkg
This builds a .pkg file that can be installed.
BSD has no installer yet. We're working on it.
Linux/BSD and Mac installations have an *uninstall.sh* file in their ZeroTier home folder that cleanly removes ZeroTier One from the system. Run this with:
sudo /path/to/ZeroTier/home/folder/uninstall.sh
Windows installers are insane. We build our .MSI installers with [Advanced Installer Enterprise](http://www.advancedinstaller.com). The Advanced Installer project file is in *ext/installfiles/windows*. To avoid lasting psychological trauma we recommend leaving Windows installers alone and using the pre-built Windows binaries on our web site.
### Using ZeroTier One in Docker Containers
To run the ZeroTier One service in a Docker container, run it with "--device=/dev/net/tun --cap-add=NET_ADMIN". This will allow ZeroTier One to open a "tap" virtual network port inside the container.
Alternately, you can use Ethernet bridging to bridge the *docker0* device on your system to a ZeroTier virtual network. This allows you to run ZeroTier One on the host and bridge the entire Docker network backplane to a virtual network or other hosts.
We're working on better "official" Docker support. In the meantime there is a [user-contributed project here](https://github.com/davide/docker-zerotier).
### Building with Network Controller Support
**Warning: as of beta version 1.0.3 the new network controller is not heavily tested. We recommend waiting for 1.0.4 to deploy this in production.**
Network controllers are nodes responsible for issuing configurations and certificates to members of ZeroTier virtual networks. Most users won't need to run their own, so this code is by default not included in the ZeroTier One binary.
You can build a network controller on Linux or Mac with:
make ZT_ENABLE_NETWORK_CONTROLLER=1
This will build a version that contains the Sqlite-backed network controller and associated extensions to the JSON local service control API. You will need the development headers for sqlite3 installed. On Mac these ship as part of Xcode, while on Linux they'll be found in packages for the various distributions.
See the JSON API documentation in [service/](service/) for more information about how to control controllers.
### Troubleshooting
For most users, it just works.
If you are running a local system firewall, we recommend adding a rule permitting UDP port 9993 inbound and outbound. If you installed binaries for Windows this should be done automatically. Other platforms might require manual editing of local firewall rules depending on your configuration.
The Mac firewall can be founder under "Security" in System Preferences. Linux has a variety of firewall configuration systems and tools. If you're using Ubuntu's *ufw*, you can do this:
sudo ufw allow 9993/udp
On CentOS check */etc/sysconfig/iptables* for IPTables rules. For other distributions consult your distribution's documentation. You'll also have to check the UIs or documentation for commercial third party firewall applications like Little Snitch (Mac), McAfee Firewall Enterprise (Windows), etc. if you are running any of those. Some corporate environments might have centrally managed firewall software, so you might also have to contact IT.
ZeroTier One peers will automatically locate each other and communicate directly over a local wired LAN *if UDP port 9993 inbound is open*. If that port is filtered, they won't be able to see each others' LAN announcement packets. If you're experiencing poor performance between devices on the same physical network, check their firewall settings. Without LAN auto-location peers must attempt "loopback" NAT traversal, which sometimes fails and in any case requires that every packet traverse your external router twice.
Users behind certain types of firewalls and "symmetric" NAT devices may not able able to connect to external peers directly at all. ZeroTier has limited support for port prediction and will *attempt* to traverse symmetric NATs, but this doesn't always work. If P2P connectivity fails you'll be bouncing UDP packets off our relay servers resulting in slower performance. Some NAT router(s) have a configurable NAT mode, and setting this to "full cone" will eliminate this problem. If you do this you may also see a magical improvement for things like VoIP phones, Skype, BitTorrent, WebRTC, certain games, etc., since all of these use NAT traversal techniques similar to ours.
If you're interested, there's a [technical deep dive about NAT traversal on our blog](https://www.zerotier.com/blog/?p=226). A troubleshooting tool to help you diagnose NAT issues is planned for the future as are uPnP/IGD/NAT-PMP and IPv6 transport.
If a firewall between you and the Internet blocks ZeroTier's UDP traffic, you will fall back to last-resort TCP tunneling to supernodes over port 443 (https impersonation). This will work almost anywhere but is *very slow* compared to UDP or direct peer to peer connectivity.
### License
The ZeroTier source code is open source and is licensed under the GNU GPL v3 (not LGPL). If you'd like to embed it in a closed-source commercial product or appliance, please e-mail [contact@zerotier.com](mailto:contact@zerotier.com) to discuss commercial licensing. Otherwise it can be used for free.

View File

@ -1,78 +0,0 @@
First build it -- see BUILDING.txt -- then...
-- MacOS --
By convention, ZeroTier One will keep its state here on mac:
/Library/Application Support/ZeroTier/One
ZeroTier ships with a kernel extension for its own tap device, which it
stores in the above directory. To install this, type:
sudo make -f Makefile.mac install-mac-tap
This will create the ZeroTier One home above if it does not exist and install
the kext there. Note that the kext must be owned by root:wheel. The make
rule for install-mac-tap takes care of that.
Next, simply run the binary. It must be run as root to open the tap device.
If run with no options, it will use the default home directory above.
sudo ./zerotier-one &
Finally, join the Earth network (the big public LAN and the only net for now):
sudo zerotier-cli join 8056c2e21c000001
Try pinging earth.zerotier.net and going to http://earth.zerotier.net/ in a
browser to see if you're online.
-- Linux
On Linux, the default ZeroTier home is:
/var/lib/zerotier-one
Just type:
sudo mkdir /var/lib/zerotier-one
sudo ./zerotier-one &
When run with no options, ZT1 uses its default home path on the current
platform. Note that ZT1 requires the Linux tap driver, so it must be
available in the kernel or as a module. In most Linux distributions it's
included out of the box and should just work.
Finally, join the Earth network (the big public LAN and the only net for now):
sudo zerotier-cli join bc8f9a8ee3000001
Try pinging earth.zerotier.net and going to http://earth.zerotier.net/ in a
browser to see if you're online.
-- Windows
Port in progress, and it's going to pretty much always be more painful to
build than *nix systems. Just wait for the binary release unless you're
brave, in which case you can load the VS2012 solution and play around.
-- Open UDP port 9993
As noted in README.md, to actually function properly, you need to open
UDP port 9993 in your firewall. Following are instructions to open UDP port
9993 for specific operating systems.
--- Ubuntu (version 12.04 and possibly other versions, too)
Follow the Ubuntu documentation about UFW https://help.ubuntu.com/community/UFW
Check if your UFW is active.
sudo ufw status verbose
If it is active, open UDP port 9993
sudo ufw allow 9993/udp
You should now be able to ping and browse earth.zerotier.net

View File

@ -1,20 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist SYSTEM "file://localhost/System/Library/DTDs/PropertyList.dtd">
<plist version="0.9">
<dict>
<key>NSPrincipalClass</key>
<string>NSApplication</string>
<key>CFBundleIconFile</key>
<string>zt1icon.icns</string>
<key>CFBundlePackageType</key>
<string>APPL</string>
<key>CFBundleGetInfoString</key>
<string>ZeroTier One (Mac GUI)</string>
<key>CFBundleSignature</key>
<string>????</string>
<key>CFBundleExecutable</key>
<string>ZeroTier One</string>
<key>CFBundleIdentifier</key>
<string>com.zerotier.ZeroTierOne</string>
</dict>
</plist>

Binary file not shown.

Before

Width:  |  Height:  |  Size: 52 KiB

Binary file not shown.

View File

@ -1,120 +0,0 @@
QT += core gui widgets network
TARGET = "ZeroTier One"
TEMPLATE = app
win32:RC_FILE = ZeroTierUI.rc
win32:LIBS += winhttp.lib Iphlpapi.lib ws2_32.lib advapi32.lib Shell32.lib Rpcrt4.lib
win32:QMAKE_LFLAGS += /MANIFESTUAC:\"level=\'requireAdministrator\' uiAccess=\'false\'\"
mac:ICON = zt1icon.icns
mac:QMAKE_MACOSX_DEPLOYMENT_TARGET = 10.6
mac:QMAKE_INFO_PLIST = Info.plist
mac:LIBS += -framework Cocoa
SOURCES += main.cpp \
mainwindow.cpp \
aboutwindow.cpp \
../node/C25519.cpp \
../node/CertificateOfMembership.cpp \
../node/Defaults.cpp \
../node/Demarc.cpp \
../node/EthernetTap.cpp \
../node/HttpClient.cpp \
../node/Identity.cpp \
../node/InetAddress.cpp \
../node/Logger.cpp \
../node/Multicaster.cpp \
../node/Network.cpp \
../node/NetworkConfig.cpp \
../node/Node.cpp \
../node/NodeConfig.cpp \
../node/Packet.cpp \
../node/PacketDecoder.cpp \
../node/Peer.cpp \
../node/Poly1305.cpp \
../node/Salsa20.cpp \
../node/Service.cpp \
../node/SHA512.cpp \
../node/SoftwareUpdater.cpp \
../node/Switch.cpp \
../node/SysEnv.cpp \
../node/Topology.cpp \
../node/UdpSocket.cpp \
../node/Utils.cpp \
../ext/lz4/lz4.c \
../ext/lz4/lz4hc.c \
networkwidget.cpp \
installdialog.cpp \
licensedialog.cpp \
onetimedialog.cpp
HEADERS += mainwindow.h \
aboutwindow.h \
../node/Node.hpp \
../node/Utils.hpp \
../node/Defaults.hpp \
../node/Address.hpp \
../node/Array.hpp \
../node/AtomicCounter.hpp \
../node/BandwidthAccount.hpp \
../node/Buffer.hpp \
../node/C25519.hpp \
../node/CertificateOfMembership.hpp \
../node/CMWC4096.hpp \
../node/Condition.hpp \
../node/Constants.hpp \
../node/Demarc.hpp \
../node/Dictionary.hpp \
../node/EthernetTap.hpp \
../node/HttpClient.hpp \
../node/Identity.hpp \
../node/InetAddress.hpp \
../node/Logger.hpp \
../node/MAC.hpp \
../node/Multicaster.hpp \
../node/MulticastGroup.hpp \
../node/Mutex.hpp \
../node/Network.hpp \
../node/NetworkConfig.hpp \
../node/NodeConfig.hpp \
../node/NonCopyable.hpp \
../node/Packet.hpp \
../node/PacketDecoder.hpp \
../node/Peer.hpp \
../node/Poly1305.hpp \
../node/RuntimeEnvironment.hpp \
../node/Salsa20.hpp \
../node/Service.hpp \
../node/SHA512.hpp \
../node/SharedPtr.hpp \
../node/SoftwareUpdater.hpp \
../node/Switch.hpp \
../node/SysEnv.hpp \
../node/Thread.hpp \
../node/Topology.hpp \
../node/UdpSocket.hpp \
../ext/lz4/lz4.h \
../ext/lz4/lz4hc.h \
networkwidget.h \
installdialog.h \
mac_doprivileged.h \
licensedialog.h \
main.h \
onetimedialog.h
FORMS += mainwindow.ui \
aboutwindow.ui \
networkwidget.ui \
installdialog.ui \
licensedialog.ui \
quickstartdialog.ui \
onetimedialog.ui
RESOURCES += \
resources.qrc
mac:OBJECTIVE_SOURCES += \
mac_doprivileged.mm
OTHER_FILES += \
stylesheet.css

View File

@ -1 +0,0 @@
IDI_ICON1 ICON DISCARDABLE "zt1icon.ico"

View File

@ -1,254 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>AboutWindow</class>
<widget class="QDialog" name="AboutWindow">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>508</width>
<height>261</height>
</rect>
</property>
<property name="windowTitle">
<string>About ZeroTier One</string>
</property>
<property name="windowIcon">
<iconset resource="resources.qrc">
<normaloff>:/img/zt1icon.png</normaloff>:/img/zt1icon.png</iconset>
</property>
<property name="sizeGripEnabled">
<bool>true</bool>
</property>
<layout class="QVBoxLayout" name="verticalLayout">
<property name="leftMargin">
<number>6</number>
</property>
<property name="topMargin">
<number>6</number>
</property>
<property name="rightMargin">
<number>6</number>
</property>
<property name="bottomMargin">
<number>6</number>
</property>
<item>
<widget class="QFrame" name="frame">
<property name="frameShape">
<enum>QFrame::StyledPanel</enum>
</property>
<property name="frameShadow">
<enum>QFrame::Raised</enum>
</property>
<layout class="QHBoxLayout" name="horizontalLayout">
<property name="leftMargin">
<number>6</number>
</property>
<property name="topMargin">
<number>6</number>
</property>
<property name="rightMargin">
<number>6</number>
</property>
<property name="bottomMargin">
<number>6</number>
</property>
<item>
<widget class="QWidget" name="widget" native="true">
<layout class="QVBoxLayout" name="verticalLayout_3">
<property name="leftMargin">
<number>0</number>
</property>
<property name="topMargin">
<number>0</number>
</property>
<property name="rightMargin">
<number>0</number>
</property>
<property name="bottomMargin">
<number>0</number>
</property>
<item>
<widget class="QLabel" name="iconLabel">
<property name="sizePolicy">
<sizepolicy hsizetype="Minimum" vsizetype="Minimum">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="minimumSize">
<size>
<width>128</width>
<height>128</height>
</size>
</property>
<property name="maximumSize">
<size>
<width>128</width>
<height>128</height>
</size>
</property>
<property name="text">
<string/>
</property>
<property name="textFormat">
<enum>Qt::PlainText</enum>
</property>
<property name="pixmap">
<pixmap resource="resources.qrc">:/img/zt1icon.png</pixmap>
</property>
<property name="scaledContents">
<bool>true</bool>
</property>
<property name="textInteractionFlags">
<set>Qt::NoTextInteraction</set>
</property>
</widget>
</item>
<item>
<spacer name="verticalSpacer">
<property name="orientation">
<enum>Qt::Vertical</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>20</width>
<height>40</height>
</size>
</property>
</spacer>
</item>
</layout>
</widget>
</item>
<item>
<widget class="QFrame" name="frame_2">
<property name="sizePolicy">
<sizepolicy hsizetype="Expanding" vsizetype="Expanding">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="frameShape">
<enum>QFrame::StyledPanel</enum>
</property>
<property name="frameShadow">
<enum>QFrame::Sunken</enum>
</property>
<layout class="QVBoxLayout" name="verticalLayout_2">
<item>
<widget class="QLabel" name="aboutTextLabel">
<property name="sizePolicy">
<sizepolicy hsizetype="Expanding" vsizetype="Expanding">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="font">
<font>
<weight>50</weight>
<bold>false</bold>
</font>
</property>
<property name="textFormat">
<enum>Qt::PlainText</enum>
</property>
<property name="alignment">
<set>Qt::AlignHCenter|Qt::AlignTop</set>
</property>
<property name="textInteractionFlags">
<set>Qt::NoTextInteraction</set>
</property>
</widget>
</item>
<item>
<widget class="QWidget" name="widget_2" native="true">
<layout class="QHBoxLayout" name="horizontalLayout_2">
<property name="leftMargin">
<number>0</number>
</property>
<property name="topMargin">
<number>0</number>
</property>
<property name="rightMargin">
<number>0</number>
</property>
<property name="bottomMargin">
<number>0</number>
</property>
<item>
<spacer name="horizontalSpacer">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>40</width>
<height>20</height>
</size>
</property>
</spacer>
</item>
</layout>
</widget>
</item>
</layout>
</widget>
</item>
</layout>
</widget>
</item>
<item>
<widget class="QDialogButtonBox" name="buttonBox">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="standardButtons">
<set>QDialogButtonBox::Ok</set>
</property>
<property name="centerButtons">
<bool>true</bool>
</property>
</widget>
</item>
</layout>
</widget>
<resources>
<include location="resources.qrc"/>
</resources>
<connections>
<connection>
<sender>buttonBox</sender>
<signal>accepted()</signal>
<receiver>AboutWindow</receiver>
<slot>accept()</slot>
<hints>
<hint type="sourcelabel">
<x>248</x>
<y>254</y>
</hint>
<hint type="destinationlabel">
<x>157</x>
<y>274</y>
</hint>
</hints>
</connection>
<connection>
<sender>buttonBox</sender>
<signal>rejected()</signal>
<receiver>AboutWindow</receiver>
<slot>reject()</slot>
<hints>
<hint type="sourcelabel">
<x>316</x>
<y>260</y>
</hint>
<hint type="destinationlabel">
<x>286</x>
<y>274</y>
</hint>
</hints>
</connection>
</connections>
</ui>

View File

@ -1,219 +0,0 @@
/*
* ZeroTier One - Global Peer to Peer Ethernet
* Copyright (C) 2012-2013 ZeroTier Networks LLC
*
* 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/>.
*
* --
*
* ZeroTier may be used and distributed under the terms of the GPLv3, which
* are available at: http://www.gnu.org/licenses/gpl-3.0.html
*
* If you would like to embed ZeroTier into a commercial application or
* redistribute it in a modified binary form, please contact ZeroTier Networks
* LLC. Start here: http://www.zerotier.com/
*/
#include "installdialog.h"
#include "mainwindow.h"
#include "ui_installdialog.h"
#include "../node/Constants.hpp"
#include "../node/Defaults.hpp"
#include "../node/SoftwareUpdater.hpp"
#ifdef __UNIX_LIKE__
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#endif
#ifdef __APPLE__
#include "mac_doprivileged.h"
#endif
#include <QMainWindow>
#include <QMessageBox>
#include <QByteArray>
#include <QSslSocket>
#include <QFile>
#include <QDir>
#include <QProcess>
InstallDialog::InstallDialog(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::InstallDialog),
nam(new QNetworkAccessManager(this)),
phase(FETCHING_NFO)
{
ui->setupUi(this);
QObject::connect(nam,SIGNAL(finished(QNetworkReply*)),this,SLOT(on_networkReply(QNetworkReply*)));
const char *nfoUrl = ZeroTier::ZT_DEFAULTS.updateLatestNfoURL.c_str();
if (!*nfoUrl) {
QMessageBox::critical(this,"Download Failed","Download failed: internal error: no update URL configured in build!",QMessageBox::Ok,QMessageBox::NoButton);
QApplication::exit(1);
return;
}
QNetworkReply *reply = nam->get(QNetworkRequest(QUrl(nfoUrl)));
QObject::connect(reply,SIGNAL(downloadProgress(qint64,qint64)),this,SLOT(on_downloadProgress(qint64,qint64)));
}
InstallDialog::~InstallDialog()
{
delete ui;
}
void InstallDialog::on_networkReply(QNetworkReply *reply)
{
reply->deleteLater();
if (reply->error() != QNetworkReply::NoError) {
QMessageBox::critical(this,"Download Failed",QString("Download failed: ") + reply->errorString() + "\n\nAre you connected to the Internet?",QMessageBox::Ok,QMessageBox::NoButton);
QApplication::exit(1);
} else {
if (reply->attribute(QNetworkRequest::HttpStatusCodeAttribute) == 200) {
QByteArray installerData(reply->readAll());
switch(phase) {
case FETCHING_NFO: {
unsigned int vMajor = 0,vMinor = 0,vRevision = 0;
installerData.append((char)0);
const char *err = ZeroTier::SoftwareUpdater::parseNfo(installerData.data(),vMajor,vMinor,vRevision,signedBy,signature,url);
if (err) {
QMessageBox::critical(this,"Download Failed","Download failed: there is a problem with the software update web site.\nTry agian later. (invalid .nfo file)",QMessageBox::Ok,QMessageBox::NoButton);
QApplication::exit(1);
return;
}
phase = FETCHING_INSTALLER;
reply = nam->get(QNetworkRequest(QUrl(url.c_str())));
QObject::connect(reply,SIGNAL(downloadProgress(qint64,qint64)),this,SLOT(on_downloadProgress(qint64,qint64)));
} break;
case FETCHING_INSTALLER: {
if (!ZeroTier::SoftwareUpdater::validateUpdate(installerData.data(),installerData.length(),signedBy,signature)) {
QMessageBox::critical(this,"Download Failed","Download failed: there is a problem with the software update web site. Try agian later. (downloaded data failed signature check)",QMessageBox::Ok,QMessageBox::NoButton);
QApplication::exit(1);
return;
}
#ifdef __APPLE__
{
std::string homePath(QDir::homePath().toStdString());
QString zt1Caches(QDir::homePath() + "/Library/Caches/ZeroTier/One");
QDir::root().mkpath(zt1Caches);
std::string instPath((zt1Caches + "/ZeroTierOneInstaller").toStdString());
std::string tmpPath((zt1Caches + "/inst.sh").toStdString());
int outfd = ::open(instPath.c_str(),O_CREAT|O_TRUNC|O_WRONLY,0755);
if (outfd <= 0) {
QMessageBox::critical(this,"Download Failed",QString("Installation failed: unable to write to ")+instPath.c_str(),QMessageBox::Ok,QMessageBox::NoButton);
QApplication::exit(1);
return;
}
if (::write(outfd,installerData.data(),installerData.length()) != installerData.length()) {
QMessageBox::critical(this,"Installation Failed",QString("Installation failed: unable to write to ")+instPath.c_str(),QMessageBox::Ok,QMessageBox::NoButton);
QApplication::exit(1);
return;
}
::close(outfd);
chmod(instPath.c_str(),0755);
FILE *scr = fopen(tmpPath.c_str(),"w");
if (!scr) {
QMessageBox::critical(this,"Installation Failed","Cannot write script to temporary Library/Caches/ZeroTier/One folder.",QMessageBox::Ok,QMessageBox::NoButton);
QApplication::exit(1);
return;
}
fprintf(scr,"#!/bin/bash\n");
fprintf(scr,"export PATH=\"/bin:/usr/bin:/sbin:/usr/sbin\"\n");
fprintf(scr,"'%s'\n",instPath.c_str());
fprintf(scr,"if [ -f '/Library/Application Support/ZeroTier/One/authtoken.secret' ]; then\n");
fprintf(scr," mkdir -p '%s/Library/Application Support/ZeroTier/One'\n",homePath.c_str());
fprintf(scr," chown %d '%s/Library/Application Support/ZeroTier'\n",(int)getuid(),homePath.c_str());
fprintf(scr," chgrp %d '%s/Library/Application Support/ZeroTier'\n",(int)getgid(),homePath.c_str());
fprintf(scr," chmod 0700 '%s/Library/Application Support/ZeroTier'\n",homePath.c_str());
fprintf(scr," chown %d '%s/Library/Application Support/ZeroTier/One'\n",(int)getuid(),homePath.c_str());
fprintf(scr," chgrp %d '%s/Library/Application Support/ZeroTier/One'\n",(int)getgid(),homePath.c_str());
fprintf(scr," chmod 0700 '%s/Library/Application Support/ZeroTier/One'\n",homePath.c_str());
fprintf(scr," cp -f '/Library/Application Support/ZeroTier/One/authtoken.secret' '%s/Library/Application Support/ZeroTier/One/authtoken.secret'\n",homePath.c_str());
fprintf(scr," chown %d '%s/Library/Application Support/ZeroTier/One/authtoken.secret'\n",(int)getuid(),homePath.c_str());
fprintf(scr," chgrp %d '%s/Library/Application Support/ZeroTier/One/authtoken.secret'\n",(int)getgid(),homePath.c_str());
fprintf(scr," chmod 0600 '%s/Library/Application Support/ZeroTier/One/authtoken.secret'\n",homePath.c_str());
fprintf(scr,"fi\n");
fprintf(scr,"exit 0\n");
fclose(scr);
chmod(tmpPath.c_str(),0755);
macExecutePrivilegedShellCommand((std::string("'")+tmpPath+"' >>/dev/null 2>&1").c_str());
unlink(tmpPath.c_str());
unlink(instPath.c_str());
// Restart the binary with whatever updates may have occurred
std::string appPath(QCoreApplication::applicationFilePath().toStdString());
execl(appPath.c_str(),appPath.c_str(),(const char *)0);
// We only make it here if execl() fails
QMessageBox::critical(this,"Re-Launch Failed","An error occurred re-launching ZeroTier One.app. Try launching it manually.",QMessageBox::Ok,QMessageBox::NoButton);
QApplication::exit(1);
return;
}
#endif
} break;
}
ui->progressBar->setMinimum(0);
ui->progressBar->setMaximum(100);
ui->progressBar->setValue(0);
} else {
QMessageBox::critical(this,"Download Failed",QString("Download failed: HTTP status code ") + reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toString(),QMessageBox::Ok,QMessageBox::NoButton);
QApplication::exit(1);
}
}
}
void InstallDialog::on_InstallDialog_rejected()
{
QApplication::exit();
}
void InstallDialog::on_cancelButton_clicked()
{
QApplication::exit();
}
void InstallDialog::on_downloadProgress(qint64 bytesReceived,qint64 bytesTotal)
{
if (bytesTotal <= 0) {
ui->progressBar->setValue(0);
ui->progressBar->setMinimum(0);
ui->progressBar->setMaximum(0);
} else {
double pct = ((double)bytesReceived / (double)bytesTotal) * 100.0;
if (pct > 100.0)
pct = 100.0;
ui->progressBar->setMinimum(0);
ui->progressBar->setMaximum(100);
ui->progressBar->setValue((int)pct);
}
}

View File

@ -1,124 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>InstallDialog</class>
<widget class="QMainWindow" name="InstallDialog">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>547</width>
<height>231</height>
</rect>
</property>
<property name="windowTitle">
<string>Install ZeroTier One Service</string>
</property>
<property name="windowIcon">
<iconset resource="resources.qrc">
<normaloff>:/img/zt1icon.png</normaloff>:/img/zt1icon.png</iconset>
</property>
<widget class="QWidget" name="centralWidget">
<layout class="QVBoxLayout" name="verticalLayout">
<property name="leftMargin">
<number>6</number>
</property>
<property name="topMargin">
<number>6</number>
</property>
<property name="rightMargin">
<number>6</number>
</property>
<property name="bottomMargin">
<number>6</number>
</property>
<item>
<widget class="QLabel" name="label">
<property name="sizePolicy">
<sizepolicy hsizetype="Preferred" vsizetype="Expanding">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="font">
<font>
<pointsize>14</pointsize>
</font>
</property>
<property name="text">
<string>Since this is your first time running ZeroTier One on this computer, the virtual Ethernet service must be downloaded and installed.
Please wait while the service downloads, then you will be prompted to enter an administrator password to install it.</string>
</property>
<property name="textFormat">
<enum>Qt::PlainText</enum>
</property>
<property name="alignment">
<set>Qt::AlignCenter</set>
</property>
<property name="wordWrap">
<bool>true</bool>
</property>
<property name="margin">
<number>10</number>
</property>
<property name="textInteractionFlags">
<set>Qt::NoTextInteraction</set>
</property>
</widget>
</item>
<item>
<widget class="QProgressBar" name="progressBar">
<property name="maximum">
<number>0</number>
</property>
<property name="value">
<number>0</number>
</property>
</widget>
</item>
<item>
<widget class="QWidget" name="widget" native="true">
<layout class="QHBoxLayout" name="horizontalLayout">
<property name="leftMargin">
<number>0</number>
</property>
<property name="topMargin">
<number>0</number>
</property>
<property name="rightMargin">
<number>0</number>
</property>
<property name="bottomMargin">
<number>0</number>
</property>
<item>
<spacer name="horizontalSpacer">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>40</width>
<height>20</height>
</size>
</property>
</spacer>
</item>
<item>
<widget class="QPushButton" name="cancelButton">
<property name="text">
<string>Cancel and Exit</string>
</property>
</widget>
</item>
</layout>
</widget>
</item>
</layout>
</widget>
</widget>
<resources>
<include location="resources.qrc"/>
</resources>
<connections/>
</ui>

View File

@ -1,42 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
#include "main.h"
#include "licensedialog.h"
#include "ui_licensedialog.h"
#include "../node/Constants.hpp"
LicenseDialog::LicenseDialog(QWidget *parent) :
QDialog(parent),
ui(new Ui::LicenseDialog)
{
ui->setupUi(this);
#ifdef __WINDOWS__
QWidgetList widgets = this->findChildren<QWidget*>();
foreach(QWidget *widget, widgets) {
QFont font(widget->font());
font.setPointSizeF(font.pointSizeF() * 0.75);
widget->setFont(font);
}
#endif
}
LicenseDialog::~LicenseDialog()
{
delete ui;
}
void LicenseDialog::on_buttonBox_accepted()
{
settings->setValue("acceptedLicenseV1",true);
settings->sync();
this->setResult(QDialog::Accepted);
}
void LicenseDialog::on_buttonBox_rejected()
{
::exit(0);
}

View File

@ -1,27 +0,0 @@
#ifndef LICENSEDIALOG_H
#define LICENSEDIALOG_H
#include <QDialog>
namespace Ui {
class LicenseDialog;
}
class LicenseDialog : public QDialog
{
Q_OBJECT
public:
explicit LicenseDialog(QWidget *parent = 0);
~LicenseDialog();
private slots:
void on_buttonBox_accepted();
void on_buttonBox_rejected();
private:
Ui::LicenseDialog *ui;
};
#endif // LICENSEDIALOG_H

View File

@ -1,256 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>LicenseDialog</class>
<widget class="QDialog" name="LicenseDialog">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>534</width>
<height>333</height>
</rect>
</property>
<property name="windowTitle">
<string>ZeroTier One</string>
</property>
<property name="windowIcon">
<iconset resource="resources.qrc">
<normaloff>:/img/zt1icon.png</normaloff>:/img/zt1icon.png</iconset>
</property>
<layout class="QVBoxLayout" name="verticalLayout">
<property name="spacing">
<number>6</number>
</property>
<property name="leftMargin">
<number>6</number>
</property>
<property name="topMargin">
<number>6</number>
</property>
<property name="rightMargin">
<number>6</number>
</property>
<property name="bottomMargin">
<number>6</number>
</property>
<item>
<widget class="QLabel" name="label">
<property name="font">
<font>
<pointsize>14</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="text">
<string>Do you agree to the terms of the license agreement?</string>
</property>
</widget>
</item>
<item>
<widget class="QTextEdit" name="licenseDisplayTextEdit">
<property name="undoRedoEnabled">
<bool>false</bool>
</property>
<property name="readOnly">
<bool>true</bool>
</property>
<property name="html">
<string notr="true">&lt;!DOCTYPE HTML PUBLIC &quot;-//W3C//DTD HTML 4.0//EN&quot; &quot;http://www.w3.org/TR/REC-html40/strict.dtd&quot;&gt;
&lt;html&gt;&lt;head&gt;&lt;meta name=&quot;qrichtext&quot; content=&quot;1&quot; /&gt;&lt;title&gt;GNU General Public License v3.0 - GNU Project - Free Software Foundation (FSF)&lt;/title&gt;&lt;style type=&quot;text/css&quot;&gt;
p, li { white-space: pre-wrap; }
&lt;/style&gt;&lt;/head&gt;&lt;body style=&quot; font-family:'.Lucida Grande UI'; font-size:13pt; font-weight:400; font-style:normal;&quot;&gt;
&lt;p style=&quot; margin-top:14px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;span style=&quot; font-size:large; font-weight:600;&quot;&gt;GNU GENERAL PUBLIC LICENSE&lt;/span&gt;&lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;Version 3, 29 June 2007 &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;Copyright © 2007 Free Software Foundation, Inc. &amp;lt;&lt;a href=&quot;http://fsf.org/&quot;&gt;&lt;span style=&quot; text-decoration: underline; color:#0000ff;&quot;&gt;http://fsf.org/&lt;/span&gt;&lt;/a&gt;&amp;gt;&lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. &lt;/p&gt;
&lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;a name=&quot;preamble&quot;&gt;&lt;/a&gt;&lt;span style=&quot; font-size:large; font-weight:600;&quot;&gt;P&lt;/span&gt;&lt;span style=&quot; font-size:large; font-weight:600;&quot;&gt;reamble&lt;/span&gt; &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;The GNU General Public License is a free, copyleft license for software and other kinds of works. &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;The precise terms and conditions for copying, distribution and modification follow. &lt;/p&gt;
&lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;a name=&quot;terms&quot;&gt;&lt;/a&gt;&lt;span style=&quot; font-size:large; font-weight:600;&quot;&gt;T&lt;/span&gt;&lt;span style=&quot; font-size:large; font-weight:600;&quot;&gt;ERMS AND CONDITIONS&lt;/span&gt; &lt;/p&gt;
&lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;a name=&quot;section0&quot;&gt;&lt;/a&gt;&lt;span style=&quot; font-size:medium; font-weight:600;&quot;&gt;0&lt;/span&gt;&lt;span style=&quot; font-size:medium; font-weight:600;&quot;&gt;. Definitions.&lt;/span&gt; &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;“This License” refers to version 3 of the GNU General Public License. &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;“Copyright” also means copyright-like laws that apply to other kinds of works, such as semiconductor masks. &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;“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. &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;A “covered work” means either the unmodified Program or a work based on the Program. &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/p&gt;
&lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;a name=&quot;section1&quot;&gt;&lt;/a&gt;&lt;span style=&quot; font-size:medium; font-weight:600;&quot;&gt;1&lt;/span&gt;&lt;span style=&quot; font-size:medium; font-weight:600;&quot;&gt;. Source Code.&lt;/span&gt; &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;The Corresponding Source need not include anything that users can regenerate automatically from other parts of the Corresponding Source. &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;The Corresponding Source for a work in source code form is that same work. &lt;/p&gt;
&lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;a name=&quot;section2&quot;&gt;&lt;/a&gt;&lt;span style=&quot; font-size:medium; font-weight:600;&quot;&gt;2&lt;/span&gt;&lt;span style=&quot; font-size:medium; font-weight:600;&quot;&gt;. Basic Permissions.&lt;/span&gt; &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;Conveying under any other circumstances is permitted solely under the conditions stated below. Sublicensing is not allowed; section 10 makes it unnecessary. &lt;/p&gt;
&lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;a name=&quot;section3&quot;&gt;&lt;/a&gt;&lt;span style=&quot; font-size:medium; font-weight:600;&quot;&gt;3&lt;/span&gt;&lt;span style=&quot; font-size:medium; font-weight:600;&quot;&gt;. Protecting Users' Legal Rights From Anti-Circumvention Law.&lt;/span&gt; &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/p&gt;
&lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;a name=&quot;section4&quot;&gt;&lt;/a&gt;&lt;span style=&quot; font-size:medium; font-weight:600;&quot;&gt;4&lt;/span&gt;&lt;span style=&quot; font-size:medium; font-weight:600;&quot;&gt;. Conveying Verbatim Copies.&lt;/span&gt; &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/p&gt;
&lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;a name=&quot;section5&quot;&gt;&lt;/a&gt;&lt;span style=&quot; font-size:medium; font-weight:600;&quot;&gt;5&lt;/span&gt;&lt;span style=&quot; font-size:medium; font-weight:600;&quot;&gt;. Conveying Modified Source Versions.&lt;/span&gt; &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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: &lt;/p&gt;
&lt;ul style=&quot;margin-top: 0px; margin-bottom: 0px; margin-left: 0px; margin-right: 0px; -qt-list-indent: 1;&quot;&gt;&lt;li style=&quot; margin-top:12px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;a) The work must carry prominent notices stating that you modified it, and giving a relevant date. &lt;/li&gt;
&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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”. &lt;/li&gt;
&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/li&gt;
&lt;li style=&quot; margin-top:0px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/li&gt;&lt;/ul&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/p&gt;
&lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;a name=&quot;section6&quot;&gt;&lt;/a&gt;&lt;span style=&quot; font-size:medium; font-weight:600;&quot;&gt;6&lt;/span&gt;&lt;span style=&quot; font-size:medium; font-weight:600;&quot;&gt;. Conveying Non-Source Forms.&lt;/span&gt; &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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: &lt;/p&gt;
&lt;ul style=&quot;margin-top: 0px; margin-bottom: 0px; margin-left: 0px; margin-right: 0px; -qt-list-indent: 1;&quot;&gt;&lt;li style=&quot; margin-top:12px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/li&gt;
&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/li&gt;
&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/li&gt;
&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/li&gt;
&lt;li style=&quot; margin-top:0px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/li&gt;&lt;/ul&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;“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. &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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). &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/p&gt;
&lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;a name=&quot;section7&quot;&gt;&lt;/a&gt;&lt;span style=&quot; font-size:medium; font-weight:600;&quot;&gt;7&lt;/span&gt;&lt;span style=&quot; font-size:medium; font-weight:600;&quot;&gt;. Additional Terms.&lt;/span&gt; &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;“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. &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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: &lt;/p&gt;
&lt;ul style=&quot;margin-top: 0px; margin-bottom: 0px; margin-left: 0px; margin-right: 0px; -qt-list-indent: 1;&quot;&gt;&lt;li style=&quot; margin-top:12px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;a) Disclaiming warranty or limiting liability differently from the terms of sections 15 and 16 of this License; or &lt;/li&gt;
&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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 &lt;/li&gt;
&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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 &lt;/li&gt;
&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;d) Limiting the use for publicity purposes of names of licensors or authors of the material; or &lt;/li&gt;
&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;e) Declining to grant rights under trademark law for use of some trade names, trademarks, or service marks; or &lt;/li&gt;
&lt;li style=&quot; margin-top:0px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/li&gt;&lt;/ul&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/p&gt;
&lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;a name=&quot;section8&quot;&gt;&lt;/a&gt;&lt;span style=&quot; font-size:medium; font-weight:600;&quot;&gt;8&lt;/span&gt;&lt;span style=&quot; font-size:medium; font-weight:600;&quot;&gt;. Termination.&lt;/span&gt; &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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). &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/p&gt;
&lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;a name=&quot;section9&quot;&gt;&lt;/a&gt;&lt;span style=&quot; font-size:medium; font-weight:600;&quot;&gt;9&lt;/span&gt;&lt;span style=&quot; font-size:medium; font-weight:600;&quot;&gt;. Acceptance Not Required for Having Copies.&lt;/span&gt; &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/p&gt;
&lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;a name=&quot;section10&quot;&gt;&lt;/a&gt;&lt;span style=&quot; font-size:medium; font-weight:600;&quot;&gt;1&lt;/span&gt;&lt;span style=&quot; font-size:medium; font-weight:600;&quot;&gt;0. Automatic Licensing of Downstream Recipients.&lt;/span&gt; &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/p&gt;
&lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;a name=&quot;section11&quot;&gt;&lt;/a&gt;&lt;span style=&quot; font-size:medium; font-weight:600;&quot;&gt;1&lt;/span&gt;&lt;span style=&quot; font-size:medium; font-weight:600;&quot;&gt;1. Patents.&lt;/span&gt; &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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”. &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/p&gt;
&lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;a name=&quot;section12&quot;&gt;&lt;/a&gt;&lt;span style=&quot; font-size:medium; font-weight:600;&quot;&gt;1&lt;/span&gt;&lt;span style=&quot; font-size:medium; font-weight:600;&quot;&gt;2. No Surrender of Others' Freedom.&lt;/span&gt; &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/p&gt;
&lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;a name=&quot;section13&quot;&gt;&lt;/a&gt;&lt;span style=&quot; font-size:medium; font-weight:600;&quot;&gt;1&lt;/span&gt;&lt;span style=&quot; font-size:medium; font-weight:600;&quot;&gt;3. Use with the GNU Affero General Public License.&lt;/span&gt; &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/p&gt;
&lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;a name=&quot;section14&quot;&gt;&lt;/a&gt;&lt;span style=&quot; font-size:medium; font-weight:600;&quot;&gt;1&lt;/span&gt;&lt;span style=&quot; font-size:medium; font-weight:600;&quot;&gt;4. Revised Versions of this License.&lt;/span&gt; &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/p&gt;
&lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;a name=&quot;section15&quot;&gt;&lt;/a&gt;&lt;span style=&quot; font-size:medium; font-weight:600;&quot;&gt;1&lt;/span&gt;&lt;span style=&quot; font-size:medium; font-weight:600;&quot;&gt;5. Disclaimer of Warranty.&lt;/span&gt; &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/p&gt;
&lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;a name=&quot;section16&quot;&gt;&lt;/a&gt;&lt;span style=&quot; font-size:medium; font-weight:600;&quot;&gt;1&lt;/span&gt;&lt;span style=&quot; font-size:medium; font-weight:600;&quot;&gt;6. Limitation of Liability.&lt;/span&gt; &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/p&gt;
&lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;a name=&quot;section17&quot;&gt;&lt;/a&gt;&lt;span style=&quot; font-size:medium; font-weight:600;&quot;&gt;1&lt;/span&gt;&lt;span style=&quot; font-size:medium; font-weight:600;&quot;&gt;7. Interpretation of Sections 15 and 16.&lt;/span&gt; &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;END OF TERMS AND CONDITIONS &lt;/p&gt;
&lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;a name=&quot;howto&quot;&gt;&lt;/a&gt;&lt;span style=&quot; font-size:large; font-weight:600;&quot;&gt;H&lt;/span&gt;&lt;span style=&quot; font-size:large; font-weight:600;&quot;&gt;ow to Apply These Terms to Your New Programs&lt;/span&gt; &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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. &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;span style=&quot; font-family:'Courier New,courier';&quot;&gt; &amp;lt;one line to give the program's name and a brief idea of what it does.&amp;gt;&lt;/span&gt;&lt;/p&gt;
&lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;span style=&quot; font-family:'Courier New,courier';&quot;&gt; Copyright (C) &amp;lt;year&amp;gt; &amp;lt;name of author&amp;gt;&lt;/span&gt;&lt;/p&gt;
&lt;p style=&quot;-qt-paragraph-type:empty; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px; font-family:'Courier New,courier';&quot;&gt;&lt;br /&gt;&lt;/p&gt;
&lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;span style=&quot; font-family:'Courier New,courier';&quot;&gt; This program is free software: you can redistribute it and/or modify&lt;/span&gt;&lt;/p&gt;
&lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;span style=&quot; font-family:'Courier New,courier';&quot;&gt; it under the terms of the GNU General Public License as published by&lt;/span&gt;&lt;/p&gt;
&lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;span style=&quot; font-family:'Courier New,courier';&quot;&gt; the Free Software Foundation, either version 3 of the License, or&lt;/span&gt;&lt;/p&gt;
&lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;span style=&quot; font-family:'Courier New,courier';&quot;&gt; (at your option) any later version.&lt;/span&gt;&lt;/p&gt;
&lt;p style=&quot;-qt-paragraph-type:empty; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px; font-family:'Courier New,courier';&quot;&gt;&lt;br /&gt;&lt;/p&gt;
&lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;span style=&quot; font-family:'Courier New,courier';&quot;&gt; This program is distributed in the hope that it will be useful,&lt;/span&gt;&lt;/p&gt;
&lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;span style=&quot; font-family:'Courier New,courier';&quot;&gt; but WITHOUT ANY WARRANTY; without even the implied warranty of&lt;/span&gt;&lt;/p&gt;
&lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;span style=&quot; font-family:'Courier New,courier';&quot;&gt; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the&lt;/span&gt;&lt;/p&gt;
&lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;span style=&quot; font-family:'Courier New,courier';&quot;&gt; GNU General Public License for more details.&lt;/span&gt;&lt;/p&gt;
&lt;p style=&quot;-qt-paragraph-type:empty; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px; font-family:'Courier New,courier';&quot;&gt;&lt;br /&gt;&lt;/p&gt;
&lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;span style=&quot; font-family:'Courier New,courier';&quot;&gt; You should have received a copy of the GNU General Public License&lt;/span&gt;&lt;/p&gt;
&lt;p style=&quot; margin-top:0px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;span style=&quot; font-family:'Courier New,courier';&quot;&gt; along with this program. If not, see &amp;lt;http://www.gnu.org/licenses/&amp;gt;. &lt;/span&gt;&lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;Also add information on how to contact you by electronic and paper mail. &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;If the program does terminal interaction, make it output a short notice like this when it starts in an interactive mode: &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;span style=&quot; font-family:'Courier New,courier';&quot;&gt; &amp;lt;program&amp;gt; Copyright (C) &amp;lt;year&amp;gt; &amp;lt;name of author&amp;gt;&lt;/span&gt;&lt;/p&gt;
&lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;span style=&quot; font-family:'Courier New,courier';&quot;&gt; This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.&lt;/span&gt;&lt;/p&gt;
&lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;span style=&quot; font-family:'Courier New,courier';&quot;&gt; This is free software, and you are welcome to redistribute it&lt;/span&gt;&lt;/p&gt;
&lt;p style=&quot; margin-top:0px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;span style=&quot; font-family:'Courier New,courier';&quot;&gt; under certain conditions; type `show c' for details. &lt;/span&gt;&lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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”. &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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 &amp;lt;&lt;a href=&quot;http://www.gnu.org/licenses/&quot;&gt;&lt;span style=&quot; text-decoration: underline; color:#0000ff;&quot;&gt;http://www.gnu.org/licenses/&lt;/span&gt;&lt;/a&gt;&amp;gt;. &lt;/p&gt;
&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;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 &amp;lt;&lt;a href=&quot;http://www.gnu.org/philosophy/why-not-lgpl.html&quot;&gt;&lt;span style=&quot; text-decoration: underline; color:#0000ff;&quot;&gt;http://www.gnu.org/philosophy/why-not-lgpl.html&lt;/span&gt;&lt;/a&gt;&amp;gt;. &lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
</property>
<property name="textInteractionFlags">
<set>Qt::LinksAccessibleByMouse|Qt::TextSelectableByMouse</set>
</property>
</widget>
</item>
<item>
<widget class="QDialogButtonBox" name="buttonBox">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="standardButtons">
<set>QDialogButtonBox::No|QDialogButtonBox::Yes</set>
</property>
</widget>
</item>
</layout>
</widget>
<resources>
<include location="resources.qrc"/>
</resources>
<connections>
<connection>
<sender>buttonBox</sender>
<signal>accepted()</signal>
<receiver>LicenseDialog</receiver>
<slot>accept()</slot>
<hints>
<hint type="sourcelabel">
<x>248</x>
<y>254</y>
</hint>
<hint type="destinationlabel">
<x>157</x>
<y>274</y>
</hint>
</hints>
</connection>
<connection>
<sender>buttonBox</sender>
<signal>rejected()</signal>
<receiver>LicenseDialog</receiver>
<slot>reject()</slot>
<hints>
<hint type="sourcelabel">
<x>316</x>
<y>260</y>
</hint>
<hint type="destinationlabel">
<x>286</x>
<y>274</y>
</hint>
</hints>
</connection>
</connections>
</ui>

View File

@ -1,12 +0,0 @@
#ifndef mac_doprivileged_h
#define mac_doprivileged_h
#ifdef __APPLE__
// commandAndArgs can contain only single-tic quotes and should redirect its
// stdout and stderr somewhere...
bool macExecutePrivilegedShellCommand(const char *commandAndArgs);
#endif
#endif

View File

@ -1,24 +0,0 @@
#include <string.h>
#include <stdio.h>
#include "mac_doprivileged.h"
#undef slots
#include <Cocoa/Cocoa.h>
bool macExecutePrivilegedShellCommand(const char *commandAndArgs)
{
char tmp[32768];
snprintf(tmp,sizeof(tmp),"do shell script \"%s\" with administrator privileges\n",commandAndArgs);
tmp[32767] = (char)0;
NSString *scriptApple = [[NSString alloc] initWithUTF8String:tmp];
NSAppleScript *as = [[NSAppleScript alloc] initWithSource:scriptApple];
NSDictionary *err = nil;
[as executeAndReturnError:&err];
[as release];
[scriptApple release];
return (err == nil);
}

View File

@ -1,94 +0,0 @@
/*
* ZeroTier One - Global Peer to Peer Ethernet
* Copyright (C) 2012-2013 ZeroTier Networks LLC
*
* 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/>.
*
* --
*
* ZeroTier may be used and distributed under the terms of the GPLv3, which
* are available at: http://www.gnu.org/licenses/gpl-3.0.html
*
* If you would like to embed ZeroTier into a commercial application or
* redistribute it in a modified binary form, please contact ZeroTier Networks
* LLC. Start here: http://www.zerotier.com/
*/
#include "mainwindow.h"
#include "installdialog.h"
#include "licensedialog.h"
#include <QApplication>
#include <QDir>
#include <QString>
#include <QFont>
#ifdef __WINDOWS__
#include <WinSock2.h>
#include <windows.h>
#endif
QSettings *settings = (QSettings *)0;
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
#ifdef __WINDOWS__
{
WSADATA wsaData;
WSAStartup(MAKEWORD(2,2),&wsaData);
}
#endif
{
QFile qss(":css/stylesheet.css");
qss.open(QFile::ReadOnly);
QString style(qss.readAll());
a.setStyleSheet(style);
}
#ifdef __APPLE__
// If service isn't installed, download and install it
if (!QFile::exists("/Library/Application Support/ZeroTier/One/zerotier-one")) {
// InstallDialog is an alternative main window. It will re-launch the app
// when done.
InstallDialog id;
id.show();
return a.exec();
}
#endif
#ifdef __APPLE__
{
// Put QSettings here because this is one of the writable directories allowed
// in Apple's app store sandbox specs. We might end up in app store someday.
QString zt1AppSupport(QDir::homePath() + "/Library/Application Support/ZeroTier/One");
QDir::root().mkpath(zt1AppSupport);
settings = new QSettings(zt1AppSupport + "/ui.ini",QSettings::IniFormat);
}
#else
settings = new QSettings("ZeroTier Networks","ZeroTier One");
#endif
if (!settings->value("acceptedLicenseV1",false).toBool()) {
LicenseDialog ld;
ld.setStyleSheet(a.styleSheet());
ld.exec();
}
MainWindow w;
w.show();
return a.exec();
}

View File

@ -1,9 +0,0 @@
#ifndef MAIN_H
#define MAIN_H
#include <QSettings>
#include <QMainWindow>
extern QSettings *settings;
#endif // MAIN_H

View File

@ -1,406 +0,0 @@
/*
* ZeroTier One - Global Peer to Peer Ethernet
* Copyright (C) 2012-2013 ZeroTier Networks LLC
*
* 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/>.
*
* --
*
* ZeroTier may be used and distributed under the terms of the GPLv3, which
* are available at: http://www.gnu.org/licenses/gpl-3.0.html
*
* If you would like to embed ZeroTier into a commercial application or
* redistribute it in a modified binary form, please contact ZeroTier Networks
* LLC. Start here: http://www.zerotier.com/
*/
#include <string>
#include <map>
#include <set>
#include <vector>
#include <stdexcept>
#include <utility>
#include <QClipboard>
#include <QMutex>
#include <QCoreApplication>
#include <QDir>
#include <QFile>
#include <QMessageBox>
#include <QDebug>
#include <QProcess>
#include <QStringList>
#include <QVBoxLayout>
#include <QScrollBar>
#include <QEventLoop>
#include <QFont>
#include "main.h"
#include "mainwindow.h"
#include "aboutwindow.h"
#include "networkwidget.h"
#include "ui_mainwindow.h"
#include "ui_quickstartdialog.h"
#ifdef __APPLE__
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include "mac_doprivileged.h"
#endif
// Globally visible
ZeroTier::Node::LocalClient *zeroTierClient = (ZeroTier::Node::LocalClient *)0;
// Main window instance for app
QMainWindow *mainWindow = (MainWindow *)0;
// Handles message from ZeroTier One service
static void handleZTMessage(void *arg,unsigned long id,const char *line)
{
static std::map< unsigned long,std::vector<std::string> > ztReplies;
static QMutex ztReplies_m;
ztReplies_m.lock();
if (*line) {
ztReplies[id].push_back(std::string(line));
ztReplies_m.unlock();
} else { // empty lines conclude transmissions
std::map< unsigned long,std::vector<std::string> >::iterator r(ztReplies.find(id));
if (r != ztReplies.end()) {
// The message is packed into an event and sent to the main window where
// the actual parsing code lives.
MainWindow::ZTMessageEvent *event = new MainWindow::ZTMessageEvent(r->second);
ztReplies.erase(r);
ztReplies_m.unlock();
QCoreApplication::postEvent(mainWindow,event); // must post since this may be another thread
} else ztReplies_m.unlock();
}
}
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow),
pollServiceTimerId(-1)
{
mainWindow = this;
ui->setupUi(this);
if (ui->networkListWidget->verticalScrollBar())
ui->networkListWidget->verticalScrollBar()->setSingleStep(8);
#ifdef __APPLE__
QWidgetList widgets = this->findChildren<QWidget*>();
foreach(QWidget *widget, widgets)
widget->setAttribute(Qt::WA_MacShowFocusRect,false);
#endif
#ifdef __WINDOWS__
QWidgetList widgets = this->findChildren<QWidget*>();
foreach(QWidget *widget, widgets) {
QFont font(widget->font());
font.setPointSizeF(font.pointSizeF() * 0.75);
widget->setFont(font);
}
#endif
ui->noNetworksLabel->setVisible(true);
ui->noNetworksLabel->setText("Connecting to Service...");
ui->bottomContainerWidget->setVisible(false);
ui->networkListWidget->setVisible(false);
this->firstTimerTick = true;
this->pollServiceTimerId = this->startTimer(200);
this->cyclesSinceResponseFromService = 0;
}
MainWindow::~MainWindow()
{
delete ui;
delete zeroTierClient;
zeroTierClient = (ZeroTier::Node::LocalClient *)0;
mainWindow = (MainWindow *)0;
}
void MainWindow::timerEvent(QTimerEvent *event) // event can be null since code also calls this directly
{
if (this->isHidden())
return;
if (this->pollServiceTimerId < 0)
return;
if (this->firstTimerTick) {
this->firstTimerTick = false;
this->killTimer(this->pollServiceTimerId);
if (!settings->value("shown_quickStart",false).toBool()) {
on_actionQuick_Start_triggered();
settings->setValue("shown_quickStart",true);
settings->sync();
}
this->pollServiceTimerId = this->startTimer(1500);
}
if (!zeroTierClient) {
std::string authToken;
if (!ZeroTier::Utils::readFile(ZeroTier::Node::LocalClient::authTokenDefaultUserPath().c_str(),authToken)) {
#ifdef __APPLE__
if (QFile::exists("/Library/Application Support/ZeroTier/One/zerotier-one")) {
// Authorize user by copying auth token into local home directory
QMessageBox::information(this,"Authorization Needed","Administrator privileges are required to allow the current user to control ZeroTier One on this computer. (You only have to do this once.)",QMessageBox::Ok,QMessageBox::NoButton);
std::string homePath(QDir::homePath().toStdString());
QString zt1Caches(QDir::homePath() + "/Library/Caches/ZeroTier/One");
QDir::root().mkpath(zt1Caches);
std::string tmpPath((zt1Caches + "/auth.sh").toStdString());
FILE *scr = fopen(tmpPath.c_str(),"w");
if (!scr) {
QMessageBox::critical(this,"Cannot Authorize","Unable to authorize this user to administrate ZeroTier One. (Cannot write to temporary Library/Caches/ZeroTier/One folder.)",QMessageBox::Ok,QMessageBox::NoButton);
QApplication::exit(1);
return;
}
fprintf(scr,"#!/bin/bash\n");
fprintf(scr,"export PATH=\"/bin:/usr/bin:/sbin:/usr/sbin\"\n");
fprintf(scr,"if [ -f '/Library/Application Support/ZeroTier/One/authtoken.secret' ]; then\n");
fprintf(scr," mkdir -p '%s/Library/Application Support/ZeroTier/One'\n",homePath.c_str());
fprintf(scr," chown %d '%s/Library/Application Support/ZeroTier'\n",(int)getuid(),homePath.c_str());
fprintf(scr," chgrp %d '%s/Library/Application Support/ZeroTier'\n",(int)getgid(),homePath.c_str());
fprintf(scr," chmod 0700 '%s/Library/Application Support/ZeroTier'\n",homePath.c_str());
fprintf(scr," chown %d '%s/Library/Application Support/ZeroTier/One'\n",(int)getuid(),homePath.c_str());
fprintf(scr," chgrp %d '%s/Library/Application Support/ZeroTier/One'\n",(int)getgid(),homePath.c_str());
fprintf(scr," chmod 0700 '%s/Library/Application Support/ZeroTier/One'\n",homePath.c_str());
fprintf(scr," cp -f '/Library/Application Support/ZeroTier/One/authtoken.secret' '%s/Library/Application Support/ZeroTier/One/authtoken.secret'\n",homePath.c_str());
fprintf(scr," chown %d '%s/Library/Application Support/ZeroTier/One/authtoken.secret'\n",(int)getuid(),homePath.c_str());
fprintf(scr," chgrp %d '%s/Library/Application Support/ZeroTier/One/authtoken.secret'\n",(int)getgid(),homePath.c_str());
fprintf(scr," chmod 0600 '%s/Library/Application Support/ZeroTier/One/authtoken.secret'\n",homePath.c_str());
fprintf(scr,"fi\n");
fprintf(scr,"exit 0\n");
fclose(scr);
chmod(tmpPath.c_str(),0755);
macExecutePrivilegedShellCommand((std::string("'")+tmpPath+"' >>/dev/null 2>&1").c_str());
unlink(tmpPath.c_str());
}
#endif
if (!ZeroTier::Utils::readFile(ZeroTier::Node::LocalClient::authTokenDefaultUserPath().c_str(),authToken)) {
if (!ZeroTier::Utils::readFile(ZeroTier::Node::LocalClient::authTokenDefaultSystemPath().c_str(),authToken)) {
QMessageBox::critical(this,"Cannot Authorize","Unable to authorize this user to administrate ZeroTier One. (Did you enter your password correctly?)",QMessageBox::Ok,QMessageBox::NoButton);
QApplication::exit(1);
return;
}
}
}
zeroTierClient = new ZeroTier::Node::LocalClient(authToken.c_str(),0,&handleZTMessage,this);
}
if (++this->cyclesSinceResponseFromService >= 3) {
if (this->cyclesSinceResponseFromService == 3)
QMessageBox::warning(this,"Service Not Running","Can't connect to the ZeroTier One service. Is it running?",QMessageBox::Ok);
ui->noNetworksLabel->setVisible(true);
ui->noNetworksLabel->setText("Connecting to Service...");
ui->bottomContainerWidget->setVisible(false);
ui->networkListWidget->setVisible(false);
}
zeroTierClient->send("info");
zeroTierClient->send("listnetworks");
zeroTierClient->send("listpeers");
}
void MainWindow::customEvent(QEvent *event)
{
ZTMessageEvent *m = (ZTMessageEvent *)event; // only one custom event type so far
if (m->ztMessage.size() == 0)
return;
this->cyclesSinceResponseFromService = 0;
std::vector<std::string> hdr(ZeroTier::Node::LocalClient::splitLine(m->ztMessage[0]));
if (hdr.size() < 2)
return;
if (hdr[0] != "200")
return;
if (hdr[1] == "info") {
if (hdr.size() >= 3)
this->myAddress = hdr[2].c_str();
if (hdr.size() >= 4)
this->myStatus = hdr[3].c_str();
if (hdr.size() >= 5)
this->myVersion = hdr[4].c_str();
} else if (hdr[1] == "listnetworks") {
std::map< std::string,std::vector<std::string> > newNetworks;
for(unsigned long i=1;i<m->ztMessage.size();++i) {
std::vector<std::string> l(ZeroTier::Node::LocalClient::splitLine(m->ztMessage[i]));
// 200 listnetworks <nwid> <name> <status> <config age> <type> <dev> <ips>
if ((l.size() == 9)&&(l[2].length() == 16))
newNetworks[l[2]] = l;
}
if (newNetworks != networks) {
networks = newNetworks;
for (bool removed=true;removed;) {
removed = false;
for(int r=0;r<ui->networkListWidget->count();++r) {
NetworkWidget *nw = (NetworkWidget *)ui->networkListWidget->itemWidget(ui->networkListWidget->item(r));
if (!networks.count(nw->networkId())) {
ui->networkListWidget->setVisible(false); // HACK to prevent an occasional crash here, discovered through hours of shotgun debugging... :P
delete ui->networkListWidget->takeItem(r);
removed = true;
break;
}
}
}
ui->networkListWidget->setVisible(true);
std::set<std::string> alreadyDisplayed;
for(int r=0;r<ui->networkListWidget->count();++r) {
NetworkWidget *nw = (NetworkWidget *)ui->networkListWidget->itemWidget(ui->networkListWidget->item(r));
if (networks.count(nw->networkId()) > 0) {
alreadyDisplayed.insert(nw->networkId());
std::vector<std::string> &l = networks[nw->networkId()];
nw->setNetworkName(l[3]);
nw->setStatus(l[4],l[5]);
nw->setNetworkType(l[6]);
nw->setNetworkDeviceName(l[7]);
nw->setIps(l[8]);
}
}
for(std::map< std::string,std::vector<std::string> >::iterator nwdata(networks.begin());nwdata!=networks.end();++nwdata) {
if (alreadyDisplayed.count(nwdata->first) == 0) {
std::vector<std::string> &l = nwdata->second;
NetworkWidget *nw = new NetworkWidget((QWidget *)0,nwdata->first);
nw->setNetworkName(l[3]);
nw->setStatus(l[4],l[5]);
nw->setNetworkType(l[6]);
nw->setNetworkDeviceName(l[7]);
nw->setIps(l[8]);
QListWidgetItem *item = new QListWidgetItem();
item->setSizeHint(nw->sizeHint());
ui->networkListWidget->addItem(item);
ui->networkListWidget->setItemWidget(item,nw);
}
}
}
} else if (hdr[1] == "listpeers") {
this->numPeers = 0;
for(unsigned long i=1;i<m->ztMessage.size();++i) {
std::vector<std::string> l(ZeroTier::Node::LocalClient::splitLine(m->ztMessage[i]));
if ((l.size() >= 5)&&((l[3] != "-")||(l[4] != "-")))
++this->numPeers; // number of direct peers online -- check for active IPv4 and/or IPv6 address
}
}
if (!ui->networkListWidget->count()) {
ui->noNetworksLabel->setText("You Have Not Joined Any Networks");
ui->noNetworksLabel->setVisible(true);
} else ui->noNetworksLabel->setVisible(false);
if (!ui->bottomContainerWidget->isVisible())
ui->bottomContainerWidget->setVisible(true);
if (!ui->networkListWidget->isVisible())
ui->networkListWidget->setVisible(true);
if (this->myAddress.size())
ui->addressButton->setText(this->myAddress);
else ui->addressButton->setText(" ");
QString st(this->myStatus);
st += ", v";
st += this->myVersion;
st += ", ";
st += QString::number(this->numPeers);
st += " direct links to peers";
ui->statusLabel->setText(st);
}
void MainWindow::on_joinNetworkButton_clicked()
{
QString toJoin(ui->networkIdLineEdit->text());
ui->networkIdLineEdit->setText(QString());
if (!zeroTierClient) // sanity check
return;
if (toJoin.size() != 16) {
QMessageBox::information(this,"Invalid Network ID","The network ID you entered was not valid. Enter a 16-digit hexadecimal network ID, like '8056c2e21c000001'.",QMessageBox::Ok,QMessageBox::NoButton);
return;
}
zeroTierClient->send((QString("join ") + toJoin).toStdString());
}
void MainWindow::on_actionAbout_triggered()
{
AboutWindow *about = new AboutWindow(this);
about->show();
}
void MainWindow::on_networkIdLineEdit_textChanged(const QString &text)
{
QString newText;
for(QString::const_iterator i(text.begin());i!=text.end();++i) {
switch(i->toLatin1()) {
case '0': newText.append('0'); break;
case '1': newText.append('1'); break;
case '2': newText.append('2'); break;
case '3': newText.append('3'); break;
case '4': newText.append('4'); break;
case '5': newText.append('5'); break;
case '6': newText.append('6'); break;
case '7': newText.append('7'); break;
case '8': newText.append('8'); break;
case '9': newText.append('9'); break;
case 'a': newText.append('a'); break;
case 'b': newText.append('b'); break;
case 'c': newText.append('c'); break;
case 'd': newText.append('d'); break;
case 'e': newText.append('e'); break;
case 'f': newText.append('f'); break;
case 'A': newText.append('a'); break;
case 'B': newText.append('b'); break;
case 'C': newText.append('c'); break;
case 'D': newText.append('d'); break;
case 'E': newText.append('e'); break;
case 'F': newText.append('f'); break;
default: break;
}
}
if (newText.size() > 16)
newText.truncate(16);
ui->networkIdLineEdit->setText(newText);
}
void MainWindow::on_addressButton_clicked()
{
QApplication::clipboard()->setText(this->myAddress);
}
void MainWindow::on_actionQuick_Start_triggered()
{
Ui::QuickstartDialog qd;
QDialog *qdd = new QDialog(this);
qd.setupUi(qdd);
qdd->setModal(false);
qdd->show();
}

View File

@ -1,100 +0,0 @@
/*
* ZeroTier One - Global Peer to Peer Ethernet
* Copyright (C) 2012-2013 ZeroTier Networks LLC
*
* 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/>.
*
* --
*
* ZeroTier may be used and distributed under the terms of the GPLv3, which
* are available at: http://www.gnu.org/licenses/gpl-3.0.html
*
* If you would like to embed ZeroTier into a commercial application or
* redistribute it in a modified binary form, please contact ZeroTier Networks
* LLC. Start here: http://www.zerotier.com/
*/
#ifndef MAINWINDOW_H
#define MAINWINDOW_H
#include <QMainWindow>
#include <QEvent>
#include <QString>
#include <QShowEvent>
#include <QTimerEvent>
#include <QSettings>
#include <map>
#include <vector>
#include <string>
#include "../node/Constants.hpp"
#include "../node/Node.hpp"
#include "../node/Utils.hpp"
namespace Ui {
class MainWindow;
}
// Globally visible instance of local client for communicating with ZT1
// Can be null if not connected, or will point to current
extern ZeroTier::Node::LocalClient *zeroTierClient;
// Globally visible pointer to main app window
extern QMainWindow *mainWindow;
class MainWindow : public QMainWindow
{
Q_OBJECT
public:
// Event used to pass messages from the Node::LocalClient thread to the
// main window to update network lists and stats.
class ZTMessageEvent : public QEvent
{
public:
ZTMessageEvent(const std::vector<std::string> &m) :
QEvent(QEvent::User),
ztMessage(m) {}
std::vector<std::string> ztMessage;
};
explicit MainWindow(QWidget *parent = 0);
virtual ~MainWindow();
protected:
virtual void timerEvent(QTimerEvent *event);
virtual void customEvent(QEvent *event);
private slots:
void on_joinNetworkButton_clicked();
void on_actionAbout_triggered();
void on_networkIdLineEdit_textChanged(const QString &text);
void on_addressButton_clicked();
void on_actionQuick_Start_triggered();
private:
Ui::MainWindow *ui;
QString myAddress;
QString myStatus;
QString myVersion;
bool firstTimerTick;
int pollServiceTimerId;
unsigned int numPeers;
unsigned int cyclesSinceResponseFromService;
std::map< std::string,std::vector<std::string> > networks;
};
#endif // MAINWINDOW_H

View File

@ -1,306 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>MainWindow</class>
<widget class="QMainWindow" name="MainWindow">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>720</width>
<height>300</height>
</rect>
</property>
<property name="windowTitle">
<string>ZeroTier One</string>
</property>
<property name="windowIcon">
<iconset resource="resources.qrc">
<normaloff>:/img/zt1icon.png</normaloff>:/img/zt1icon.png</iconset>
</property>
<widget class="QWidget" name="centralWidget">
<layout class="QVBoxLayout" name="verticalLayout">
<property name="spacing">
<number>0</number>
</property>
<property name="leftMargin">
<number>0</number>
</property>
<property name="topMargin">
<number>0</number>
</property>
<property name="rightMargin">
<number>0</number>
</property>
<property name="bottomMargin">
<number>0</number>
</property>
<item>
<widget class="QLabel" name="noNetworksLabel">
<property name="font">
<font>
<pointsize>16</pointsize>
</font>
</property>
<property name="frameShape">
<enum>QFrame::NoFrame</enum>
</property>
<property name="text">
<string>You Have Not Joined Any Networks</string>
</property>
<property name="textFormat">
<enum>Qt::PlainText</enum>
</property>
<property name="alignment">
<set>Qt::AlignCenter</set>
</property>
<property name="wordWrap">
<bool>true</bool>
</property>
<property name="margin">
<number>25</number>
</property>
<property name="textInteractionFlags">
<set>Qt::NoTextInteraction</set>
</property>
</widget>
</item>
<item>
<widget class="QListWidget" name="networkListWidget">
<property name="focusPolicy">
<enum>Qt::NoFocus</enum>
</property>
<property name="frameShape">
<enum>QFrame::NoFrame</enum>
</property>
<property name="horizontalScrollBarPolicy">
<enum>Qt::ScrollBarAlwaysOff</enum>
</property>
<property name="autoScroll">
<bool>false</bool>
</property>
<property name="editTriggers">
<set>QAbstractItemView::NoEditTriggers</set>
</property>
<property name="selectionMode">
<enum>QAbstractItemView::NoSelection</enum>
</property>
<property name="verticalScrollMode">
<enum>QAbstractItemView::ScrollPerPixel</enum>
</property>
<property name="spacing">
<number>0</number>
</property>
<property name="uniformItemSizes">
<bool>true</bool>
</property>
</widget>
</item>
<item>
<widget class="QWidget" name="bottomContainerWidget" native="true">
<layout class="QHBoxLayout" name="horizontalLayout">
<property name="spacing">
<number>0</number>
</property>
<property name="leftMargin">
<number>0</number>
</property>
<property name="topMargin">
<number>0</number>
</property>
<property name="rightMargin">
<number>0</number>
</property>
<property name="bottomMargin">
<number>0</number>
</property>
<item>
<widget class="QToolButton" name="addressButton">
<property name="sizePolicy">
<sizepolicy hsizetype="Minimum" vsizetype="Preferred">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="font">
<font>
<family>Courier</family>
<pointsize>12</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="statusTip">
<string>Your 10-digit ZeroTier address; click to copy to clipboard.</string>
</property>
<property name="text">
<string notr="true">----------</string>
</property>
<property name="toolButtonStyle">
<enum>Qt::ToolButtonTextOnly</enum>
</property>
<property name="class" stdset="0">
<string notr="true">clickToCopy</string>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="statusLabel">
<property name="sizePolicy">
<sizepolicy hsizetype="Expanding" vsizetype="Preferred">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="font">
<font>
<pointsize>10</pointsize>
</font>
</property>
<property name="statusTip">
<string>Your network connection status.</string>
</property>
<property name="text">
<string/>
</property>
<property name="textFormat">
<enum>Qt::PlainText</enum>
</property>
</widget>
</item>
<item>
<widget class="QLineEdit" name="networkIdLineEdit">
<property name="sizePolicy">
<sizepolicy hsizetype="Fixed" vsizetype="Fixed">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="font">
<font>
<family>Courier</family>
<pointsize>12</pointsize>
</font>
</property>
<property name="statusTip">
<string>Enter a hexadecimal network ID to join a network.</string>
</property>
<property name="maxLength">
<number>16</number>
</property>
<property name="frame">
<bool>true</bool>
</property>
<property name="placeholderText">
<string>(Network ID)</string>
</property>
</widget>
</item>
<item>
<widget class="QToolButton" name="joinNetworkButton">
<property name="sizePolicy">
<sizepolicy hsizetype="Minimum" vsizetype="Preferred">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="font">
<font>
<family>Courier</family>
<pointsize>16</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="statusTip">
<string>Join this network.</string>
</property>
<property name="text">
<string notr="true">+</string>
</property>
</widget>
</item>
</layout>
</widget>
</item>
</layout>
</widget>
<widget class="QMenuBar" name="menuBar">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>720</width>
<height>22</height>
</rect>
</property>
<property name="font">
<font>
<pointsize>12</pointsize>
</font>
</property>
<property name="layoutDirection">
<enum>Qt::LeftToRight</enum>
</property>
<widget class="QMenu" name="menuHelp">
<property name="title">
<string>Help</string>
</property>
<addaction name="actionAbout"/>
<addaction name="actionQuick_Start"/>
</widget>
<widget class="QMenu" name="menuFile">
<property name="title">
<string>File</string>
</property>
<addaction name="separator"/>
<addaction name="actionExit"/>
</widget>
<addaction name="menuFile"/>
<addaction name="menuHelp"/>
</widget>
<widget class="QStatusBar" name="statusBar">
<property name="font">
<font>
<pointsize>10</pointsize>
</font>
</property>
</widget>
<action name="actionAbout">
<property name="text">
<string>About</string>
</property>
</action>
<action name="actionExit">
<property name="text">
<string>Exit</string>
</property>
</action>
<action name="actionQuick_Start">
<property name="text">
<string>Quick Start</string>
</property>
</action>
</widget>
<layoutdefault spacing="6" margin="11"/>
<resources>
<include location="resources.qrc"/>
</resources>
<connections>
<connection>
<sender>actionExit</sender>
<signal>triggered()</signal>
<receiver>MainWindow</receiver>
<slot>close()</slot>
<hints>
<hint type="sourcelabel">
<x>-1</x>
<y>-1</y>
</hint>
<hint type="destinationlabel">
<x>333</x>
<y>149</y>
</hint>
</hints>
</connection>
</connections>
</ui>

View File

@ -1,179 +0,0 @@
/*
* ZeroTier One - Global Peer to Peer Ethernet
* Copyright (C) 2012-2013 ZeroTier Networks LLC
*
* 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/>.
*
* --
*
* ZeroTier may be used and distributed under the terms of the GPLv3, which
* are available at: http://www.gnu.org/licenses/gpl-3.0.html
*
* If you would like to embed ZeroTier into a commercial application or
* redistribute it in a modified binary form, please contact ZeroTier Networks
* LLC. Start here: http://www.zerotier.com/
*/
#include "networkwidget.h"
#include "mainwindow.h"
#include "ui_networkwidget.h"
#include "onetimedialog.h"
#include "main.h"
#include <QClipboard>
#include <QString>
#include <QStringList>
#include <QCoreApplication>
#include <QProcess>
#include <QList>
#include <QMessageBox>
#include <QFont>
#include "../node/Constants.hpp"
NetworkWidget::NetworkWidget(QWidget *parent,const std::string &nwid) :
QWidget(parent),
ui(new Ui::NetworkWidget),
networkIdStr(nwid),
publicWarningShown(false)
{
ui->setupUi(this);
ui->networkIdButton->setText(QString(nwid.c_str()));
QFontMetrics fm(ui->ipListWidget->font());
int lineHeight = ui->ipListWidget->spacing() + fm.height();
ui->ipListWidget->setMinimumHeight(lineHeight * 4);
ui->ipListWidget->setMaximumHeight(lineHeight * 4);
#ifdef __APPLE__
QWidgetList widgets = this->findChildren<QWidget*>();
foreach(QWidget* widget, widgets)
widget->setAttribute(Qt::WA_MacShowFocusRect,false);
#endif
#ifdef __WINDOWS__
QWidgetList widgets = this->findChildren<QWidget*>();
foreach(QWidget *widget, widgets) {
QFont font(widget->font());
font.setPointSizeF(font.pointSizeF() * 0.75);
widget->setFont(font);
}
#endif
}
NetworkWidget::~NetworkWidget()
{
delete ui;
}
void NetworkWidget::setStatus(const std::string &status,const std::string &age)
{
ui->statusLabel->setText(QString(status.c_str()));
if (status == "OK")
ui->ageLabel->setText(QString("[") + age.c_str() + "s ago]");
else ui->ageLabel->setText(QString());
}
void NetworkWidget::setNetworkName(const std::string &name)
{
if (name == "?") {
ui->nameLabel->setText("... waiting ...");
ui->nameLabel->setEnabled(false);
} else {
ui->nameLabel->setText(QString(name.c_str()));
ui->nameLabel->setEnabled(true);
}
}
void NetworkWidget::setNetworkType(const std::string &type)
{
ui->networkTypeLabel->setText(QString(type.c_str()));
if (type == "?")
ui->networkTypeLabel->setStatusTip("Waiting for configuration...");
else if (type == "public") {
if ((!publicWarningShown)&&(!settings->value("shown_publicWarning",false).toBool())) {
publicWarningShown = true;
OneTimeDialog *d = new OneTimeDialog(mainWindow,"shown_publicWarning","Security Notice","Security Notice:"ZT_EOL_S""ZT_EOL_S"You have joined a public network. Anyone can join these. We recommend making sure that your system's automatic software updates are enabled and turning off any shared network services that you do not want people to access.");
d->setModal(false);
d->show();
}
ui->networkTypeLabel->setStatusTip("This network can be joined by anyone in the world.");
} else if (type == "private")
ui->networkTypeLabel->setStatusTip("This network is private; only authorized peers can join.");
else ui->networkTypeLabel->setStatusTip("Unknown network type.");
}
void NetworkWidget::setNetworkDeviceName(const std::string &dev)
{
ui->deviceLabel->setText(QString(dev.c_str()));
}
void NetworkWidget::setIps(const std::string &commaSeparatedList)
{
QStringList ips(QString(commaSeparatedList.c_str()).split(QChar(','),QString::SkipEmptyParts));
if (commaSeparatedList == "-")
ips.clear();
QStringList tmp;
ips.sort();
for(QStringList::iterator i(ips.begin());i!=ips.end();++i) {
QString ipOnly(*i);
int slashIdx = ipOnly.indexOf('/');
if (slashIdx > 0)
ipOnly.truncate(slashIdx);
tmp.append(ipOnly);
}
ips = tmp;
for(QStringList::iterator i(ips.begin());i!=ips.end();++i) {
if (ui->ipListWidget->findItems(*i,Qt::MatchCaseSensitive).size() == 0)
ui->ipListWidget->addItem(*i);
}
for(int i=0;i<ui->ipListWidget->count();++i) {
QListWidgetItem *item = ui->ipListWidget->item(i);
if (!ips.contains(item->text()))
ui->ipListWidget->removeItemWidget(item);
}
}
const std::string &NetworkWidget::networkId()
{
return networkIdStr;
}
void NetworkWidget::on_leaveNetworkButton_clicked()
{
if (QMessageBox::question(this,"Leave Network?",QString("Are you sure you want to leave network '") + networkIdStr.c_str() + "'?",QMessageBox::No,QMessageBox::Yes) == QMessageBox::Yes) {
this->setEnabled(false);
zeroTierClient->send((QString("leave ") + networkIdStr.c_str()).toStdString());
}
}
void NetworkWidget::on_networkIdButton_clicked()
{
QApplication::clipboard()->setText(ui->networkIdButton->text());
}
void NetworkWidget::on_ipListWidget_itemActivated(QListWidgetItem *item)
{
if (item)
QApplication::clipboard()->setText(item->text());
}
void NetworkWidget::on_ipListWidget_currentItemChanged(QListWidgetItem *current, QListWidgetItem *previous)
{
if (current)
QApplication::clipboard()->setText(current->text());
}

View File

@ -1,68 +0,0 @@
/*
* ZeroTier One - Global Peer to Peer Ethernet
* Copyright (C) 2012-2013 ZeroTier Networks LLC
*
* 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/>.
*
* --
*
* ZeroTier may be used and distributed under the terms of the GPLv3, which
* are available at: http://www.gnu.org/licenses/gpl-3.0.html
*
* If you would like to embed ZeroTier into a commercial application or
* redistribute it in a modified binary form, please contact ZeroTier Networks
* LLC. Start here: http://www.zerotier.com/
*/
#ifndef NETWORK_H
#define NETWORK_H
#include <string>
#include <QWidget>
#include <QListWidgetItem>
namespace Ui {
class NetworkWidget;
}
class NetworkWidget : public QWidget
{
Q_OBJECT
public:
explicit NetworkWidget(QWidget *parent = 0,const std::string &nwid = std::string());
virtual ~NetworkWidget();
void setStatus(const std::string &status,const std::string &age);
void setNetworkName(const std::string &name);
void setNetworkType(const std::string &type);
void setNetworkDeviceName(const std::string &dev);
void setIps(const std::string &commaSeparatedList);
const std::string &networkId();
private slots:
void on_leaveNetworkButton_clicked();
void on_networkIdButton_clicked();
void on_ipListWidget_itemActivated(QListWidgetItem *item);
void on_ipListWidget_currentItemChanged(QListWidgetItem *current, QListWidgetItem *previous);
private:
Ui::NetworkWidget *ui;
std::string networkIdStr;
bool publicWarningShown;
};
#endif // NETWORK_H

View File

@ -1,560 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>NetworkWidget</class>
<widget class="QWidget" name="NetworkWidget">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>580</width>
<height>253</height>
</rect>
</property>
<property name="sizePolicy">
<sizepolicy hsizetype="Expanding" vsizetype="Maximum">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="windowTitle">
<string>Network</string>
</property>
<property name="class" stdset="0">
<string notr="true">networkListItem</string>
</property>
<layout class="QHBoxLayout">
<property name="spacing">
<number>0</number>
</property>
<property name="leftMargin">
<number>2</number>
</property>
<property name="topMargin">
<number>0</number>
</property>
<property name="rightMargin">
<number>2</number>
</property>
<property name="bottomMargin">
<number>0</number>
</property>
<item>
<widget class="QWidget" name="leftWidget" native="true">
<layout class="QVBoxLayout" name="verticalLayout_2">
<property name="spacing">
<number>2</number>
</property>
<property name="leftMargin">
<number>0</number>
</property>
<property name="topMargin">
<number>0</number>
</property>
<property name="rightMargin">
<number>0</number>
</property>
<property name="bottomMargin">
<number>0</number>
</property>
<item>
<widget class="QWidget" name="widget" native="true">
<layout class="QHBoxLayout" name="horizontalLayout">
<property name="leftMargin">
<number>0</number>
</property>
<property name="topMargin">
<number>4</number>
</property>
<property name="rightMargin">
<number>0</number>
</property>
<property name="bottomMargin">
<number>0</number>
</property>
<item>
<widget class="QToolButton" name="networkIdButton">
<property name="font">
<font>
<family>Courier</family>
<pointsize>13</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="statusTip">
<string>Hexadecimal network ID; click to copy to clipboard.</string>
</property>
<property name="text">
<string notr="true">----------------</string>
</property>
<property name="toolButtonStyle">
<enum>Qt::ToolButtonTextOnly</enum>
</property>
<property name="class" stdset="0">
<string notr="true">clickToCopy</string>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="label_2">
<property name="font">
<font>
<pointsize>14</pointsize>
</font>
</property>
<property name="text">
<string>[</string>
</property>
<property name="textFormat">
<enum>Qt::PlainText</enum>
</property>
<property name="textInteractionFlags">
<set>Qt::NoTextInteraction</set>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="nameLabel">
<property name="font">
<font>
<pointsize>13</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="statusTip">
<string>This network's short name.</string>
</property>
<property name="text">
<string>networkname</string>
</property>
<property name="textFormat">
<enum>Qt::PlainText</enum>
</property>
<property name="alignment">
<set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignVCenter</set>
</property>
<property name="textInteractionFlags">
<set>Qt::NoTextInteraction</set>
</property>
<property name="class" stdset="0">
<string notr="true">networkName</string>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="label_3">
<property name="font">
<font>
<pointsize>14</pointsize>
</font>
</property>
<property name="text">
<string>]</string>
</property>
<property name="textFormat">
<enum>Qt::PlainText</enum>
</property>
<property name="textInteractionFlags">
<set>Qt::NoTextInteraction</set>
</property>
</widget>
</item>
<item>
<spacer name="horizontalSpacer_3">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>40</width>
<height>20</height>
</size>
</property>
</spacer>
</item>
</layout>
</widget>
</item>
<item>
<widget class="QWidget" name="networkStatsWidget" native="true">
<property name="sizePolicy">
<sizepolicy hsizetype="Expanding" vsizetype="Expanding">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<layout class="QFormLayout" name="formLayout">
<property name="fieldGrowthPolicy">
<enum>QFormLayout::ExpandingFieldsGrow</enum>
</property>
<property name="rowWrapPolicy">
<enum>QFormLayout::DontWrapRows</enum>
</property>
<property name="labelAlignment">
<set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
</property>
<property name="formAlignment">
<set>Qt::AlignHCenter|Qt::AlignTop</set>
</property>
<property name="horizontalSpacing">
<number>4</number>
</property>
<property name="verticalSpacing">
<number>2</number>
</property>
<property name="leftMargin">
<number>4</number>
</property>
<property name="topMargin">
<number>4</number>
</property>
<property name="rightMargin">
<number>0</number>
</property>
<property name="bottomMargin">
<number>4</number>
</property>
<item row="2" column="0">
<widget class="QLabel" name="label_5">
<property name="font">
<font>
<pointsize>12</pointsize>
</font>
</property>
<property name="text">
<string>Type:</string>
</property>
<property name="textFormat">
<enum>Qt::PlainText</enum>
</property>
</widget>
</item>
<item row="2" column="1">
<widget class="QLabel" name="networkTypeLabel">
<property name="font">
<font>
<pointsize>12</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="statusTip">
<string>What kind of network? Public or private?</string>
</property>
<property name="text">
<string>?</string>
</property>
<property name="textFormat">
<enum>Qt::PlainText</enum>
</property>
</widget>
</item>
<item row="3" column="0">
<widget class="QLabel" name="label">
<property name="font">
<font>
<pointsize>12</pointsize>
</font>
</property>
<property name="text">
<string>Status:</string>
</property>
<property name="textFormat">
<enum>Qt::PlainText</enum>
</property>
</widget>
</item>
<item row="4" column="0">
<widget class="QLabel" name="label_4">
<property name="font">
<font>
<pointsize>12</pointsize>
</font>
</property>
<property name="text">
<string>Device:</string>
</property>
<property name="textFormat">
<enum>Qt::PlainText</enum>
</property>
</widget>
</item>
<item row="3" column="1">
<widget class="QWidget" name="widget" native="true">
<property name="sizePolicy">
<sizepolicy hsizetype="Expanding" vsizetype="Preferred">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<layout class="QHBoxLayout" name="horizontalLayout_3">
<property name="spacing">
<number>12</number>
</property>
<property name="leftMargin">
<number>0</number>
</property>
<property name="topMargin">
<number>0</number>
</property>
<property name="rightMargin">
<number>0</number>
</property>
<property name="bottomMargin">
<number>0</number>
</property>
<item>
<widget class="QLabel" name="statusLabel">
<property name="sizePolicy">
<sizepolicy hsizetype="Preferred" vsizetype="Preferred">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="font">
<font>
<pointsize>12</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="statusTip">
<string>Status of this network.</string>
</property>
<property name="text">
<string>?</string>
</property>
<property name="textFormat">
<enum>Qt::PlainText</enum>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="ageLabel">
<property name="sizePolicy">
<sizepolicy hsizetype="Expanding" vsizetype="Preferred">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="font">
<font>
<pointsize>10</pointsize>
</font>
</property>
<property name="statusTip">
<string>How recently did this network refresh its settings?</string>
</property>
<property name="text">
<string>[0s ago]</string>
</property>
<property name="textFormat">
<enum>Qt::PlainText</enum>
</property>
<property name="textInteractionFlags">
<set>Qt::NoTextInteraction</set>
</property>
</widget>
</item>
<item>
<spacer name="horizontalSpacer_2">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>40</width>
<height>1</height>
</size>
</property>
</spacer>
</item>
</layout>
</widget>
</item>
<item row="4" column="1">
<widget class="QLabel" name="deviceLabel">
<property name="font">
<font>
<pointsize>12</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="statusTip">
<string>The name of the network device on your system.</string>
</property>
<property name="text">
<string>?</string>
</property>
<property name="textFormat">
<enum>Qt::PlainText</enum>
</property>
</widget>
</item>
</layout>
</widget>
</item>
</layout>
</widget>
</item>
<item>
<widget class="QWidget" name="rightWidget" native="true">
<property name="sizePolicy">
<sizepolicy hsizetype="Maximum" vsizetype="Preferred">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<layout class="QVBoxLayout" name="verticalLayout">
<property name="spacing">
<number>0</number>
</property>
<property name="leftMargin">
<number>0</number>
</property>
<property name="topMargin">
<number>0</number>
</property>
<property name="rightMargin">
<number>0</number>
</property>
<property name="bottomMargin">
<number>0</number>
</property>
<item>
<widget class="QLabel" name="label_6">
<property name="sizePolicy">
<sizepolicy hsizetype="Preferred" vsizetype="Fixed">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="font">
<font>
<pointsize>12</pointsize>
<underline>false</underline>
</font>
</property>
<property name="styleSheet">
<string notr="true">padding: 0.1em 0 0.1em 0;</string>
</property>
<property name="text">
<string>IP Addresses</string>
</property>
<property name="textFormat">
<enum>Qt::PlainText</enum>
</property>
</widget>
</item>
<item>
<widget class="QListWidget" name="ipListWidget">
<property name="sizePolicy">
<sizepolicy hsizetype="Expanding" vsizetype="Expanding">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="minimumSize">
<size>
<width>0</width>
<height>0</height>
</size>
</property>
<property name="font">
<font>
<family>Courier</family>
<pointsize>12</pointsize>
</font>
</property>
<property name="statusTip">
<string>IP addresses assigned to this interface; click to copy to clipboard.</string>
</property>
<property name="frameShape">
<enum>QFrame::NoFrame</enum>
</property>
<property name="editTriggers">
<set>QAbstractItemView::NoEditTriggers</set>
</property>
<property name="showDropIndicator" stdset="0">
<bool>false</bool>
</property>
<property name="selectionMode">
<enum>QAbstractItemView::SingleSelection</enum>
</property>
<property name="horizontalScrollMode">
<enum>QAbstractItemView::ScrollPerPixel</enum>
</property>
<property name="sortingEnabled">
<bool>true</bool>
</property>
<property name="class" stdset="0">
<string notr="true">ipAddressList</string>
</property>
</widget>
</item>
<item>
<widget class="QWidget" name="leaveButtonContainerWidget" native="true">
<layout class="QHBoxLayout" name="horizontalLayout_2">
<property name="spacing">
<number>0</number>
</property>
<property name="leftMargin">
<number>0</number>
</property>
<property name="topMargin">
<number>0</number>
</property>
<property name="rightMargin">
<number>0</number>
</property>
<property name="bottomMargin">
<number>0</number>
</property>
<item>
<spacer name="horizontalSpacer">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>40</width>
<height>1</height>
</size>
</property>
</spacer>
</item>
<item>
<widget class="QToolButton" name="leaveNetworkButton">
<property name="sizePolicy">
<sizepolicy hsizetype="Fixed" vsizetype="Fixed">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="statusTip">
<string>Leave this network.</string>
</property>
<property name="text">
<string>Leave Network</string>
</property>
<property name="class" stdset="0">
<string notr="true">leaveNetworkButton</string>
</property>
</widget>
</item>
</layout>
</widget>
</item>
</layout>
</widget>
</item>
</layout>
</widget>
<tabstops>
<tabstop>ipListWidget</tabstop>
</tabstops>
<resources/>
<connections/>
</ui>

View File

@ -1,37 +0,0 @@
#include "onetimedialog.h"
#include "ui_onetimedialog.h"
#include "main.h"
OneTimeDialog::OneTimeDialog(QWidget *parent,const char *propName,const QString &title,const QString &message) :
QDialog(parent),
ui(new Ui::OneTimeDialog)
{
ui->setupUi(this);
ui->label->setText(message);
this->setWindowTitle(title);
_propName = propName;
#ifdef __WINDOWS__
QWidgetList widgets = this->findChildren<QWidget*>();
foreach(QWidget *widget, widgets) {
QFont font(widget->font());
font.setPointSizeF(font.pointSizeF() * 0.75);
widget->setFont(font);
}
#endif
}
OneTimeDialog::~OneTimeDialog()
{
delete ui;
}
void OneTimeDialog::on_pushButton_clicked()
{
if (_propName) {
settings->setValue(_propName,ui->checkBox->isChecked());
settings->sync();
}
this->close();
}

View File

@ -1,26 +0,0 @@
#ifndef ONETIMEDIALOG_H
#define ONETIMEDIALOG_H
#include <QDialog>
namespace Ui {
class OneTimeDialog;
}
class OneTimeDialog : public QDialog
{
Q_OBJECT
public:
explicit OneTimeDialog(QWidget *parent = 0,const char *propName = (const char *)0,const QString &title = QString(),const QString &message = QString());
~OneTimeDialog();
private slots:
void on_pushButton_clicked();
private:
Ui::OneTimeDialog *ui;
const char *_propName;
};
#endif // ONETIMEDIALOG_H

View File

@ -1,99 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>OneTimeDialog</class>
<widget class="QDialog" name="OneTimeDialog">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>496</width>
<height>197</height>
</rect>
</property>
<property name="windowTitle">
<string>Dialog</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout">
<property name="leftMargin">
<number>0</number>
</property>
<property name="topMargin">
<number>0</number>
</property>
<property name="rightMargin">
<number>0</number>
</property>
<property name="bottomMargin">
<number>0</number>
</property>
<item>
<widget class="QLabel" name="label">
<property name="sizePolicy">
<sizepolicy hsizetype="Expanding" vsizetype="Expanding">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="text">
<string/>
</property>
<property name="alignment">
<set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop</set>
</property>
<property name="wordWrap">
<bool>true</bool>
</property>
<property name="margin">
<number>12</number>
</property>
<property name="textInteractionFlags">
<set>Qt::NoTextInteraction</set>
</property>
</widget>
</item>
<item>
<widget class="QWidget" name="widget" native="true">
<layout class="QHBoxLayout" name="horizontalLayout">
<property name="leftMargin">
<number>12</number>
</property>
<property name="topMargin">
<number>0</number>
</property>
<property name="rightMargin">
<number>12</number>
</property>
<property name="bottomMargin">
<number>5</number>
</property>
<item>
<widget class="QCheckBox" name="checkBox">
<property name="sizePolicy">
<sizepolicy hsizetype="Expanding" vsizetype="Fixed">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="text">
<string>Don't Show This Message Again</string>
</property>
<property name="checked">
<bool>true</bool>
</property>
</widget>
</item>
<item>
<widget class="QPushButton" name="pushButton">
<property name="text">
<string>OK</string>
</property>
</widget>
</item>
</layout>
</widget>
</item>
</layout>
</widget>
<resources/>
<connections/>
</ui>

View File

@ -1,170 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>QuickstartDialog</class>
<widget class="QDialog" name="QuickstartDialog">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>800</width>
<height>480</height>
</rect>
</property>
<property name="windowTitle">
<string>Quick Start</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout">
<property name="spacing">
<number>0</number>
</property>
<property name="leftMargin">
<number>0</number>
</property>
<property name="topMargin">
<number>0</number>
</property>
<property name="rightMargin">
<number>0</number>
</property>
<property name="bottomMargin">
<number>0</number>
</property>
<item>
<widget class="QScrollArea" name="scrollArea">
<property name="frameShape">
<enum>QFrame::NoFrame</enum>
</property>
<property name="widgetResizable">
<bool>true</bool>
</property>
<property name="alignment">
<set>Qt::AlignCenter</set>
</property>
<widget class="QWidget" name="scrollAreaWidgetContents">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>785</width>
<height>800</height>
</rect>
</property>
<layout class="QHBoxLayout" name="horizontalLayout_2">
<property name="leftMargin">
<number>0</number>
</property>
<property name="topMargin">
<number>0</number>
</property>
<property name="rightMargin">
<number>0</number>
</property>
<property name="bottomMargin">
<number>0</number>
</property>
<item>
<widget class="QLabel" name="label">
<property name="styleSheet">
<string notr="true">background: #000000;</string>
</property>
<property name="text">
<string/>
</property>
<property name="textFormat">
<enum>Qt::PlainText</enum>
</property>
<property name="pixmap">
<pixmap resource="resources.qrc">:/img/ZT1GUI.png</pixmap>
</property>
<property name="scaledContents">
<bool>false</bool>
</property>
<property name="alignment">
<set>Qt::AlignCenter</set>
</property>
</widget>
</item>
</layout>
</widget>
</widget>
</item>
<item>
<widget class="QWidget" name="widget" native="true">
<layout class="QHBoxLayout" name="horizontalLayout">
<property name="leftMargin">
<number>6</number>
</property>
<property name="topMargin">
<number>6</number>
</property>
<property name="rightMargin">
<number>6</number>
</property>
<property name="bottomMargin">
<number>6</number>
</property>
<item>
<widget class="QLabel" name="label_2">
<property name="font">
<font>
<pointsize>10</pointsize>
</font>
</property>
<property name="text">
<string>Select Help -&gt; Quick Start to see this screen again.</string>
</property>
<property name="textFormat">
<enum>Qt::PlainText</enum>
</property>
<property name="textInteractionFlags">
<set>Qt::NoTextInteraction</set>
</property>
</widget>
</item>
<item>
<spacer name="horizontalSpacer">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>702</width>
<height>20</height>
</size>
</property>
</spacer>
</item>
<item>
<widget class="QPushButton" name="okButton">
<property name="text">
<string>OK</string>
</property>
</widget>
</item>
</layout>
</widget>
</item>
</layout>
</widget>
<resources>
<include location="resources.qrc"/>
</resources>
<connections>
<connection>
<sender>okButton</sender>
<signal>clicked()</signal>
<receiver>QuickstartDialog</receiver>
<slot>accept()</slot>
<hints>
<hint type="sourcelabel">
<x>753</x>
<y>457</y>
</hint>
<hint type="destinationlabel">
<x>399</x>
<y>239</y>
</hint>
</hints>
</connection>
</connections>
</ui>

View File

@ -1,9 +0,0 @@
<RCC>
<qresource prefix="/img">
<file>zt1icon.png</file>
<file>ZT1GUI.png</file>
</qresource>
<qresource prefix="/css">
<file>stylesheet.css</file>
</qresource>
</RCC>

View File

@ -1,106 +0,0 @@
QToolButton {
margin: 0;
padding: 2px;
text-align: center;
background: palette(button);
color: palette(button-text);
border: 1px solid transparent;
}
QToolButton:focus {
border: 1px solid #000000;
}
QToolButton:hover {
background: palette(highlight);
color: palette(highlight-text);
}
QToolButton:pressed {
border: 1px solid #000000;
}
QToolButton.clickToCopy {
padding: 0;
margin: 0;
border: 0;
background: transparent;
color: palette(link);
}
QToolButton.clickToCopy:focus {
text-decoration: underline;
}
QToolButton.clickToCopy:hover {
text-decoration: underline;
}
QToolButton.clickToCopy:pressed {
background: transparent;
}
QToolButton.leaveNetworkButton {
margin: 0 4px 3px 0;
}
QMainWindow {
background: palette(dark);
}
QListWidget {
background: transparent;
padding: 0;
margin: 0;
border: 0;
}
QListWidget::item {
background: palette(base);
margin: 1px 0 1px 0;
}
QListWidget.ipAddressList {
background: palette(button);
margin: 0 4px 4px 0;
}
QListWidget.ipAddressList::item {
background: transparent;
color: palette(link);
border-bottom: 1px solid transparent;
}
QListWidget.ipAddressList::item:selected {
background: transparent;
border-top: 0;
border-left: 0;
border-right: 0;
border-bottom: 1px solid transparent;
}
QListWidget.ipAddressList::item:hover {
border-bottom: 1px solid palette(link);
}
QStatusBar {
background: palette(button);
}
QLabel.networkName {
padding: 0;
margin: 0;
}
#networkIdButton {
padding: 0.2em 0 0 0;
}
#joinNetworkButton {
margin: 1px;
padding: 0;
}
#noNetworksLabel {
background: transparent;
color: #ffffff;
}
#networkListWidget {
background: palette(dark);
margin: 0 0 2px 0;
}
#bottomContainerWidget {
background: palette(base);
}

Binary file not shown.

Binary file not shown.

Before

Width:  |  Height:  |  Size: 361 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 44 KiB

BIN
artwork/ZeroTierIcon.icns Normal file

Binary file not shown.

BIN
artwork/ZeroTierIcon.ico Normal file

Binary file not shown.

After

Width:  |  Height:  |  Size: 361 KiB

BIN
artwork/ZeroTierIcon.png Normal file

Binary file not shown.

After

Width:  |  Height:  |  Size: 26 KiB

37
artwork/logo.html Normal file
View File

@ -0,0 +1,37 @@
<html>
<head>
<style type="text/css">
html,body {
background: #aaaaaa;
margin: 0;
padding: 0;
font-family: "Helvetica";
font-weight: bold;
font-size: 12pt;
height: 100%;
width: 100%;
}
div.icon {
background: #ffb354;
color: #000000;
font-size: 150pt;
border-radius: 2.5rem;
display: inline-block;
width: 1.3em;
height: 1.3em;
padding: 0;
margin: 0;
line-height: 1.4em;
vertical-align: middle;
text-align: center;
}
</style>
</head>
<body>
<br><br><br><br><br><br>
<!-- Yes, our logo is a Unicode character. It sort of just turned out that way. -->
<center>
<div class="icon">&#x23c1;</div>
</center>
</body>
</html>

View File

@ -1,6 +1,6 @@
/*
* ZeroTier One - Global Peer to Peer Ethernet
* Copyright (C) 2012-2013 ZeroTier Networks LLC
* ZeroTier One - Network Virtualization Everywhere
* Copyright (C) 2011-2015 ZeroTier, Inc.
*
* 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

View File

@ -1,6 +1,6 @@
/*
* ZeroTier One - Global Peer to Peer Ethernet
* Copyright (C) 2012-2013 ZeroTier Networks LLC
* ZeroTier One - Network Virtualization Everywhere
* Copyright (C) 2011-2015 ZeroTier, Inc.
*
* 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

4
attic/README.md Normal file
View File

@ -0,0 +1,4 @@
Retired Code and Miscellaneous Junk
======
This directory is for old code that isn't used but we don't want to lose track of, and for anything else random like debug scripts.

View File

@ -1,2 +0,0 @@
This directory is for old code that isn't used but we don't want to lose
track of, and for anything else random like debug scripts.

View File

@ -1,123 +0,0 @@
/*
* ZeroTier One - Global Peer to Peer Ethernet
* Copyright (C) 2012-2013 ZeroTier Networks LLC
*
* 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/>.
*
* --
*
* ZeroTier may be used and distributed under the terms of the GPLv3, which
* are available at: http://www.gnu.org/licenses/gpl-3.0.html
*
* If you would like to embed ZeroTier into a commercial application or
* redistribute it in a modified binary form, please contact ZeroTier Networks
* LLC. Start here: http://www.zerotier.com/
*/
#ifndef _ZT_RANGE_HPP
#define _ZT_RANGE_HPP
namespace ZeroTier {
/**
* A range of numeric values
*
* @tparam T Type, can be any numeric value (int, float, double, etc.)
*/
template<typename T>
class Range
{
public:
/**
* Construct an empty range
*/
Range()
throw() :
start(0),
end(0)
{
}
/**
* @param s Starting value (inclusive)
* @param e Ending value (exclusive)
*/
Range(T s,T e)
throw() :
start(s),
end(e)
{
}
/**
* Construct a range containing from n to n+1 (thus only n for integers)
*
* @param n Number to contain
*/
Range(T n)
throw() :
start(n),
end(n+1)
{
}
/**
* @return end - start
*/
inline T magnitude() const
throw()
{
return (end - start);
}
/**
* @return True if range contains something (magnitude is nonzero)
*/
inline operator bool() const
throw()
{
return (end > start);
}
/**
* @param v Value to test
* @return True if value is between start (inclusive) and end (exclusive)
*/
inline bool operator()(const T &v) const
throw()
{
return ((v >= start)&&(v < end));
}
inline bool operator==(const Range &r) const throw() { return ((start == r.start)&&(end == r.end)); }
inline bool operator!=(const Range &r) const throw() { return (!(*this == r)); }
inline bool operator<(const Range &r) const throw() { return ((start < r.start) ? true : ((start == r.start) ? (end < r.end) : false)); }
inline bool operator>(const Range &r) const throw() { return (r < *this); }
inline bool operator<=(const Range &r) const throw() { return !(r < *this); }
inline bool operator>=(const Range &r) const throw() { return !(*this < r); }
/**
* Start of range (may be modified directly)
*/
T start;
/**
* End of range (may be modified directly)
*/
T end;
};
} // namespace ZeroTier
#endif

32
attic/decrypt Executable file
View File

@ -0,0 +1,32 @@
#!/bin/bash
export PATH=/bin:/usr/bin
if [ ! -e /usr/bin/openssl ]; then
echo $0: requires /usr/bin/openssl, please install openssl tools
exit 1
fi
if [ "$#" -lt 1 ]; then
echo $0: Usage: $0 '<input>' '[output]'
exit 1
fi
if [ ! -r "$1" ]; then
echo $0: $1 does not exist or is not readable.
exit 1
fi
outpath=`echo "$1" | sed 's/[.]aes$//'`
if [ "$#" -ge 2 ]; then
outpath="$2"
fi
if [ -f "$outpath" ]; then
echo $0: $outpath already exists, delete or rename first.
exit 1
fi
openssl aes-256-cbc -d -salt -in "$1" -out "$outpath"
echo $0: wrote "$outpath"

32
attic/encrypt Executable file
View File

@ -0,0 +1,32 @@
#!/bin/bash
export PATH=/bin:/usr/bin
if [ ! -e /usr/bin/openssl ]; then
echo $0: requires /usr/bin/openssl, please install openssl tools
exit 1
fi
if [ "$#" -lt 1 ]; then
echo $0: Usage: $0 '<input>' '[output]'
exit 1
fi
if [ ! -r "$1" ]; then
echo $0: $1 does not exist or is not readable.
exit 1
fi
outpath="$1.aes"
if [ "$#" -ge 2 ]; then
outpath="$2"
fi
if [ -f "$outpath" ]; then
echo $0: $outpath already exists, delete or rename first.
exit 1
fi
openssl aes-256-cbc -salt -in "$1" -out "$outpath"
echo $0: wrote "$outpath"

View File

@ -0,0 +1,764 @@
*****************************************************************************
Anode Protocol Specification Draft
Version 0.8
(c)2009-2010 Adam Ierymenko
*****************************************************************************
Table of Contents
*****************************************************************************
1. Introduction
Anode provides three components that work together to provide a global,
secure, and mobile addressing system for computer networks:
1) An addressing system based on public key cryptography enabling network
devices or applications to assign themselves secure, unique, and globally
reachable network addresses in a flat address space.
2) A system enabling network participants holding global addresses to locate
one another on local or global networks with "zero configuration."
3) A communications protocol for communication between addressed network
participants that requires no special operating system support and no
changes to existing network infrastructure.
Using Anode, both fixed and mobile applications and devices can communicate
directly as if they were all connected to the same VPN. Anode restores the
original vision of the Internet as a "flat" network where anything can talk
to anything, and adds the added benefits of address mobility and strong
protection against address spoofing and other protocol level attacks.
1.1. Design Philosophy
Anode's design philosophy is the classical "KISS" principle: "Keep It Simple
Stupid." Anode's design principles are:
#1: Do not try to solve too many problems at once, and stay in scope.
Anode does not attempt to solve too many problems at once. It attempts to
solve the problems of mobile addressing, address portability, and "flat"
addressing in the presence of NAT or other barriers.
It does not attempt to duplicate the full functionality of SSL, X.509, SSH,
XMPP, an enterprise service bus, a pub/sub architecture, BitTorrent, etc. All
of those protocols and services can be used over Anode if their functionality
is desired.
#2: Avoid state management.
State multiplies the complexity and failure modes of network protocols. State
also tends to get in the way of the achievement of new features implicitly
(see principle #4). Avoid state whenever possible.
#3: Avoid algorithm and dependency bloat.
Anode uses only elliptic curve Diffie-Hellman (EC-DH) and AES-256. No other
cryptographic algorithms or hash functions are presently necessary. This
yields implementations compact enough for embedded devices.
Anode also requires few or no dependencies, depending on whether the two
needed cryptographic algorithms are obtained through a library or included.
No other protocols or libraries are required in an implementation.
#4: Achieve features implicitly.
Use a simple stateless design that allows features to be achieved implicitly
rather than specified explicitly. For example, Anode can do multi-homing and
could be used to build a mesh network, but neither of these features is
explicitly specified.
*****************************************************************************
2. Core Concepts and Algorithms
This section describes addresses, zones, common algorithms, and other core
concepts.
2.1. Zones
A zone is a 32-bit integer encoded into every Anode address. Zones serve to
assist in the location of peers by address on global IP networks. They are
not presently significant for local communications, though they could be
used to partition addresses into groups or link them with configuration
options.
Each zone has a corresponding zone file which can be fetched in a number of
ways (see below). A zone file is a flat text format dictionary of the format
"key=value" separated by carriage returns. Line feeds are ignored, and any
character may be escaped with a backslash (\) character. Blank lines are
ignored.
The following entries must appear in a zone file:
n=<zone name>
d=<zone description>
c=<zone contact, e-mail address of zone administrator>
r=<zone revision, monotonically increasing integer with each edit>
ttl=<seconds before zone file should be re-checked for changes>
Additional fields may appear as well, including fields specific to special
applications or protocols supported within the zone. Some of these are
defined in this document.
Zone file fetching mechanisms are described below. Multiple mechanisms are
specified to enable fallback in the event that one mechanism is not available.
2.1.1. Zone File Retrieval
Zone files are retrieved via HTTP, with the HTTP address being formed in one
of two ways.
The preferred DNS method:
To fetch a zone file via DNS, use the zone ID to generate a host name and URI
of the form:
http://a--XXXXXXXX.net/z
The XXXXXXXX field is the zone ID in hexadecimal.
The fallback IP method:
For fallback in the absence of DNS, the zone ID can be used directly as an
IPv4 or IPv4-mapped-to-IPv6 IP address. A URI is generated of the form:
http://ip_address/z
Support for this method requires that a zone ID be chosen to correspond to a
permanent IPv4 (preferably mappable to IPv6 space as well) IP address.
2.1.2. Zone ID Reservation
By convention, a zone ID is considered reserved when a domain of the form
"a--XXXXXXXX.net" (where XXXXXXXX is the ID in hex) is registered.
It is recommended that this be done even for zone IDs not used for global
address location in order to globally reserve them.
2.2. Addresses
Anode addresses are binary strings containing a 32-bit zone ID, a public key,
and possibly other fields. Only one address type is presently defined:
|---------------------------------------------------------------------------|
| Name | Type ID | Elliptic Curve Parameters | Total Length |
|---------------------------------------------------------------------------|
| ANODE-256-40 | 1 | NIST-P-256 | 40 |
|---------------------------------------------------------------------------|
|---------------------------------------------------------------------------|
| Name | Binary Layout |
|---------------------------------------------------------------------------|
| ANODE-256-40 | <type[1]><zone[4]><unused[2]><public key[33]> |
|---------------------------------------------------------------------------|
The public key is a "compressed" form elliptic curve public key as described
in RFC5480.
The unused section of the address must be zero. These bytes are reserved for
future use.
2.2.1. ASCII Format For Addresses
Addresses are encoded in ASCII using base-32, which provides a quotable and
printable encoding that is of manageable length and is case-insensitive. For
example, an ANODE-256-40 address is 64 characters long in base-32 encoding.
2.3. Relaying
An Anode peer may optionally relay packets to any other reachable peer.
Relaying is accomplished by sending a packet to a peer with the recipient set
to the final recipient. The receiving peer will, if relaying is allowed and if
it knows of or can reach the recipient, forward the packet.
No error is returned if relaying fails, so relay paths are treated as possible
paths for communication until a return is received in the same way as direct
paths.
Relaying can be used by peers to send messages indirectly, locate one
another, and determine network location information to facilitate the
establishment of direct communications.
Peers may refuse to relay or may limit the transmission rate at which packets
can be relayed.
2.3.1. Zone Relays
If a zone's addresses are globally reachable on global IP networks, it must
have one or more zone relays. These must have globally reachable public
static IP addresses.
Zone relays are specified in the zone file in the following format:
zr.<address checksum>=<ip>[,<ip>]:<udp port>:<tcp port>:<anode addresses>
The address checksum is the sum of the bytes in the Anode address modulus
the number of "zr" entries, in hexadecimal. For example, if a zone had four
global relays its zone file could contain the lines:
zr.0=1.2.3.4:4343:4344:klj4j3...
zr.1=2.3.4.5:4343:4344:00194j...
zr.2=3.4.5.6:4343:4344:1j42zz...
zr.3=4.5.6.7:4343:4344:z94j1q...
The relay would be chosen by taking the sum of the bytes in the address
modulo 4. For example, if the bytes of an address sum to 5081 then relay
zr.1 would be used to communicate with that address.
If more than one IP address is listed for a given relay, the peer must choose
at random from among the addresses of the desired type (IPv4 or IPv6).
Each relay must have one Anode address for every address type supported within
the zone. (At present there is only one address type defined.)
Peers should prefer UDP and fall back to TCP only if UDP is not available.
To make itself available, a peer must make itself known to its designated zone
relay. This is accomplished by sending a PING message.
2.4. Key Agreement and Derivation
Key agreement is performed using elliptic curve Diffie-Hellman. This yields
a raw key whose size depends on the elliptic curve parameters in use.
The following algorithm is used to derive a key of any length from a raw
key generated through key agreement:
1) Zero the derived key buffer.
2) Determine the largest of the original raw key or the derived key.
3) Loop from 0 to the largest length determined in step 2, XOR each byte of
the derived key buffer with the corresponding byte of the original key
buffer with each index being modulus the length of the respective buffer.
2.5. Message Authentication
For message authentication, CMAC-AES (with AES-256) is used. This is also
known in some literature as OMAC1-AES. The key is derived from key agreement
between the key pair of the sending peer and the address of the recipient.
2.6. AES-DIGEST
To maintain cryptographic algorithm frugality, a cryptographic hash function
is constructed from the AES-256 cipher. This hash function uses the common
Davis-Meyer construction with Merkle-Damgård length padding.
It is described by the following pseudocode:
byte previous_digest[16]
byte digest[16] = { 0,0,... }
byte block[32] = { 0,0,... }
integer block_counter = 0
; digest message
for each byte b of message
block[block_counter] = b
block_counter = block_counter + 1
if block_counter == 32 then
block_counter = 0
save digest[] in previous_digest[]
encrypt digest[] with aes-256 using block[] as 256-bit aes-256 key
xor digest[] with previous_digest[]
end if
next
; append end marker, do final block
block[block_counter] = 0x80
block_counter = block_counter + 1
zero rest of block[] from block_counter to 15
save digest[] in previous_digest[]
encrypt digest[] with aes-256 using block[] as 256-bit aes-256 key
xor digest[] with previous_digest[]
; Merkle-Damgård length padding
zero first 8 bytes of block[]
fill last 8 bytes of block[] w/64-bit length in big-endian order
save digest[] in previous_digest[]
encrypt digest[] with aes-256 using block[] as 256-bit aes-128 key
xor digest[] with previous_digest[]
; digest[] now contains 128-bit message digest
2.7. Short Address Identifiers (Address IDs)
A short 8-byte version of the Anode address is used in the protocol to reduce
transmission overhead when both sides are already aware of the other's full
address.
The short address identifier is formed by computing the AES-DIGEST of the
full address and then XORing the first 8 bytes of the digest with the last
8 bytes to yield an 8-byte shortened digest.
2.8. DNS Resolution of Anode Addresses
Anode addresses can be saved in DNS TXT records in the following format:
anode:<address in base32 ASCII encoding>
This permits Anode addresses to be resolved from normal DNS host name.
2.9. Packet Transmission Mechanisms
2.9.1. UDP Transmission
The recommended method of sending Anode packets is UDP. Each packet is simply
sent as a UDP packet.
2.9.2. TCP Transmission
To send packets over TCP, each packet is prefixed by its size as a 16-bit
integer.
2.9.3. HTTP Transmission
Anode packets may be submitted in HTTP POST transactions for transport over
networks where HTTP is the only available protocol.
Anode packets are simply prefixed with a 16-byte packet size and concatenated
together just as they are in a TCP stream. One or more packets may be sent
with each HTTP POST transaction for improved performance.
Since this method is intended for use in "hostile" or highly restricted
circumstances, no additional details such as special headers or MIME types
are specified to allow maximum flexibility. Peers should ignore anything
other than the payload.
2.10. Endpoints
An endpoint indicates a place where Anode packets may be sent. The following
endpoint types are specified:
|---------------------------------------------------------------------------|
| Endpoint Type | Description | Address Format |
|---------------------------------------------------------------------------|
| 0x00 | Unspecified | (none) |
| 0x01 | Ethernet | <mac[6]> |
| 0x02 | UDP/IPv4 | <ip[4]><port[2]> |
| 0x03 | TCP/IPv4 | <ip[4]><port[2]> |
| 0x04 | UDP/IPv6 | <ip[16]><port[2]> |
| 0x05 | TCP/IPv6 | <ip[16]><port[2]> |
| 0x06 | HTTP | <null-terminated full URI> |
|---------------------------------------------------------------------------|
Endpoints are encoded by beginning with a single byte indicating the endpoint
type followed by the address information required for the given type.
Note that IP ports bear no relationship to Anode protocol ports.
2.11. Notes
All integers in the protocol are transmitted in network (big endian) byte
order.
*****************************************************************************
3. Common Packet Format
A common header is used for all Anode packets:
|---------------------------------------------------------------------------|
| Field | Length | Description |
|---------------------------------------------------------------------------|
| Hop Count | 1 | 8-bit hop count (not included in MAC) |
| Flags | 1 | 8-bit flags |
| MAC | 8 | 8 byte shortened CMAC-AES of packet |
| Sender Address | ? | Full address or short ID of sender |
| Recipient Address | ? | Full address or short ID of recipient |
| Peer IDs | 1 | Two 4-bit peer IDs: sender, recipient |
| Message Type | 1 | 8-bit message type |
| Message | ? | Message payload |
|---------------------------------------------------------------------------|
3.1. Hop Count
The hop count begins at zero and must be incremented by each peer that relays
the packet to another peer. The hop count must not wrap to zero at 255.
Because the hop count is modified in transit, it is not included in MAC
calculation or authentication.
The hop count is used to prioritize endpoints that are direct over endpoints
that involve relaying, or to prioritize closer routes over more distant
ones.
3.2. Flags and Flag Behavior
|---------------------------------------------------------------------------|
| Flag | Description |
|---------------------------------------------------------------------------|
| 0x01 | Sender address fully specified |
| 0x02 | Recipient address fully specified |
| 0x04 | Authentication error response |
|---------------------------------------------------------------------------|
If flag 0x01 is set, then the sender address will be the full address rather
than a short address identifier. The length of the address can be determined
from the first byte of the address, which always specifies the address type.
Flag 0x02 has the same meaning for the recipient address.
A peer must send fully specified sender addresses until it receives a response
from the recipient. At this point the sender may assume that the recipient
knows its address and use short a short sender address instead. This
assumption should time out, with a recommended timeout of 60 seconds.
There is presently no need to send fully specified recipient addresses, but
the flag is present in case it is needed and must be honored.
Flag 0x04 indicates that this is an error response containing a failed
authentication error. Since authentication failed, this packet may not have
a valid MAC. Packets with this flag must never have any effect other than
to inform of an error. This error, since it is unauthenticated, must never
have any side effects such as terminating a connection.
3.3. MAC
The MAC is calculated as follows:
1) Temporarily set the 64-bit/8-byte MAC field in the packet to the packet's
size as a 64-bit big-endian integer.
2) Calculate the MAC for the entire packet (excluding the first byte) using
the key agreed upon between the sender and the recipient, resulting in a
16 byte full CMAC-AES MAC.
3) Derive the 8 byte packet MAC by XORing the first 8 bytes of the full 16
byte CMAC-AES MAC with the last 8 bytes. Place this into the packet's MAC
field.
3.4. Peer IDs
Peer IDs provide a method for up to 15 different peers to share an address,
each with a unique ID allowing packets to be routed to them individually.
A peer ID of zero indicates "any" or "unspecified." Real peers must have a
nonzero peer ID. In the normal single peer per address case, any peer ID may
be used. If multiple peers are to share an address, some implementation-
dependent method must be used to ensure that each peer has a unique peer ID.
Relaying peers must follow these rules based on the recipient peer ID when
relaying messages:
- IF the peer ID is zero or if the peer ID is not known, the message must
be forwarded to a random endpoint for the given recipient address.
- IF the peer ID is nonzero and matches one or more known endpoints for the
given recipient address and peer ID, the message must only be sent to
a matching endpoint.
A receiving peer should process any message that it receives regardless of
whether its recipient peer ID is correct. The peer ID is primarily for relays.
Peers should typically send messages with a nonzero recipient peer ID when
responding to or involved in a conversation with a specific peer (e.g. a
streaming connection), and send zero recipient peer IDs otherwise.
3.5. Short Address Conflict Disambiguation
In the unlikely event of two Anode addresses with the same short identifier,
the recipient should use MAC validation to disambiguate. The peer ID must not
be relied upon for this purpose.
*****************************************************************************
4. Basic Signaling and Transport Protocol
4.1. Message Types
|---------------------------------------------------------------------------|
| Type | ID | Description |
|---------------------------------------------------------------------------|
| ERROR | 0x00 | Error response |
| PING | 0x01 | Echo request |
| PONG | 0x02 | Echo response |
| EPC_REQ | 0x03 | Endpoint check request |
| EPC | 0x04 | Endpoint check response |
| EPI | 0x05 | Endpoint information |
| NAT_T | 0x06 | NAT traversal message |
| NETID_REQ | 0x07 | Request network address identification and/or test |
| NETID | 0x08 | Response to network address identification request |
| DGRAM | 0x09 | Simple UDP-like datagram |
|---------------------------------------------------------------------------|
4.2. Message Details
4.2.1. ERROR
|---------------------------------------------------------------------------|
| Field | Length | Description |
|---------------------------------------------------------------------------|
| Error Code | 2 | 16-bit error code |
| Error Arguments | ? | Error arguments, depending on error type |
|---------------------------------------------------------------------------|
Error arguments are empty unless otherwise stated below.
Error codes:
|---------------------------------------------------------------------------|
| Error Code | Description |
|---------------------------------------------------------------------------|
| 0x01 | Message not valid |
| 0x02 | Message authentication or decryption failed |
| 0x03 | Relaying and related features not authorized |
| 0x04 | Relay recipient not reachable |
|---------------------------------------------------------------------------|
Generation of errors is optional. A peer may choose to ignore invalid
messages or to throttle the sending of errors.
4.2.2. PING
(Payload unspecified.)
Request echo of payload as PONG message.
4.2.3. PONG
(Payload unspecified.)
Echoed payload of received PING message.
4.2.4. EPC_REQ
|---------------------------------------------------------------------------|
| Field | Length | Description |
|---------------------------------------------------------------------------|
| Request ID | 4 | 32-bit request ID |
|---------------------------------------------------------------------------|
Request echo of request ID in EPC message, used to check and learn endpoints.
To learn a network endpoint for a peer, CHECK_REQ is sent. If CHECK is
returned with a valid request ID, the endpoint is considered valid.
4.2.5. EPC
|---------------------------------------------------------------------------|
| Field | Length | Description |
|---------------------------------------------------------------------------|
| Request ID | 4 | 32-bit request ID echoed back |
|---------------------------------------------------------------------------|
Response to EPC_REQ containing request ID.
4.2.6. EPI
|---------------------------------------------------------------------------|
| Field | Length | Description |
|---------------------------------------------------------------------------|
| Flags | 1 | 8-bit flags |
| Endpoint | ? | Endpoint type and address |
| NAT-T mode | 1 | 8-bit NAT traversal mode |
| NAT-T options | ? | Options related to specified NAT-T mode |
|---------------------------------------------------------------------------|
EPI stands for EndPoint Identification, and is sent to notify another peer of
a network endpoint where the sending peer is reachable.
If the receiving peer is interested in communicating with the sending peer,
the receiving peer must send EPC_REQ to the sending peer at the specified
endpoint to check the validity of that endpoint. The endpoint is learned if a
valid EPC is returned.
If the endpoint in EPI is unspecified, the actual source of the EPI message
is the endpoint. This allows EPI messages to be broadcast on a local LAN
segment to advertise the presence of an address on a local network. EPI
broadcasts on local IP networks must be made to UDP port 8737.
Usually EPI is sent via relays (usually zone relays) to inform a peer of an
endpoint for direct communication.
There are presently no flags, so flags must be zero.
4.2.7. NAT_T
|---------------------------------------------------------------------------|
| Field | Length | Description |
|---------------------------------------------------------------------------|
| NAT-T mode | 1 | 8-bit NAT traversal mode |
| NAT-T options | ? | Options related to specified NAT-T mode |
|---------------------------------------------------------------------------|
NAT_T is used to send messages specific to certain NAT traversal modes.
4.2.8. NETID_REQ
|---------------------------------------------------------------------------|
| Field | Length | Description |
|---------------------------------------------------------------------------|
| Request ID | 4 | 32-bit request ID |
| Endpoint | ? | Endpoint type and address information |
|---------------------------------------------------------------------------|
When a NETID_REQ message is received, the recipient attempts to echo it back
as a NETID message to the specified endpoint address. If the endpoint is
unspecified, the recipient must fill it in with the actual origin of the
NETID_REQ message. This allows a peer to cooperate with another peer (usually
a zone relay) to empirically determine its externally visible network
address information.
A peer may ignore NETID_REQ or respond with an error if it does not allow
relaying.
4.2.9. NETID
|---------------------------------------------------------------------------|
| Field | Length | Description |
|---------------------------------------------------------------------------|
| Request ID | 4 | 32-bit request ID echoed back |
| Endpoint Type | 1 | 8-bit endpoint type |
| Endpoint Address | ? | Endpoint Address (size depends on type) |
|---------------------------------------------------------------------------|
NETID is sent in response to NETID_REQ to the specified endpoint address. It
always contains the endpoint address to which it was sent.
4.2.10. DGRAM
|---------------------------------------------------------------------------|
| Field | Length | Description |
|---------------------------------------------------------------------------|
| Source Port | 2 | 16-bit source port |
| Destination Port | 2 | 16-bit destination port |
| Payload | ? | Datagram packet payload |
|---------------------------------------------------------------------------|
A datagram is a UDP-like message without flow control or delivery assurance.
*****************************************************************************
5. Stream Protocol
The stream protocol is very similar to TCP, though it omits some features
that are not required since they are taken care of by the encapsulating
protocol. SCTP was also an inspiration in the design.
5.1. Message Types
|---------------------------------------------------------------------------|
| Type | ID | Description |
|---------------------------------------------------------------------------|
| S_OPEN | 20 | Initiate a streaming connection (like TCP SYN) |
| S_CLOSE | 21 | Terminate a streaming connection (like TCP RST/FIN) |
| S_DATA | 22 | Data packet |
| S_ACK | 23 | Acknowedge receipt of one or more data packets |
| S_DACK | 24 | Combination of DATA and ACK |
|---------------------------------------------------------------------------|
5.2. Message Details
5.2.1. S_OPEN
|---------------------------------------------------------------------------|
| Field | Length | Description |
|---------------------------------------------------------------------------|
| Sender Link ID | 2 | 16-bit sender link ID |
| Destination Port | 2 | 16-bit destination port |
| Window Size | 2 | 16-bit window size in 1024-byte increments |
| Init. Seq. Number | 4 | 32-bit initial sequence number |
| Flags | 1 | 8-bit flags |
|---------------------------------------------------------------------------|
The OPEN message corresponds to TCP SYN, and initiates a connection. It
specifies the initial window size for the sender and the sender's initial
sequence number, which should be randomly chosen to prevent replay attacks.
If OPEN is successful, the recipient sends its own OPEN to establish the
connetion. If OPEN is unsuccessful, CLOSE is sent with its initial and current
sequence numbers equal and an appropriate reason such as "connection refused."
The sender link ID must be unique for a given recipient.
If flag 01 is set, the sender link ID is actually a source port where the
sender might be listening for connections as well. This exactly duplicates
the behavior of standard TCP. Otherwise, the sender link ID is simply an
arbitrary number that the sender uses to identify the connection with this
recipient and there is no port of origin. Ports of origin are optional for
Anode streaming connections to permit greater scalability.
5.2.2. S_CLOSE
|---------------------------------------------------------------------------|
| Field | Length | Description |
|---------------------------------------------------------------------------|
| Sender Link ID | 2 | 16-bit sender link ID |
| Destination Port | 2 | 16-bit destination port |
| Flags | 1 | 8-bit flags |
| Reason | 1 | 8-bit close reason |
| Init. Seq. Number | 4 | 32-bit initial sequence number |
| Sequence Number | 4 | 32-bit current sequence number |
|---------------------------------------------------------------------------|
The CLOSE message serves a function similar to TCP FIN. The initial sequence
number is the original starting sequence number sent with S_OPEN, while the
current sequence number is the sequence number corresponding to the close
and must be ACKed to complete the close operation. The use of the initial
sequence number helps to serve as a key to prevent replay attacks.
CLOSE is also used to indicate a failed OPEN attempt. In this case the current
sequence number will be equal to the initial sequence number and no ACK will
be expected.
There are currently no flags, so flags must be zero.
The reason field describes the reason for the close:
|---------------------------------------------------------------------------|
| Reason Code | Description |
|---------------------------------------------------------------------------|
| 00 | Application closed connection |
| 01 | Connection refused |
| 02 | Protocol error |
| 03 | Timed out |
|---------------------------------------------------------------------------|
Established connections will usually be closed with reason 00, while reason
01 is usually provided if an OPEN is received but the port is not bound.
5.2.3. S_DATA
|---------------------------------------------------------------------------|
| Field | Length | Description |
|---------------------------------------------------------------------------|
| Sender Link ID | 2 | 16-bit sender link ID |
| Destination Port | 2 | 16-bit destination port |
| Sequence Number | 4 | 32-bit sequence number |
| Payload | ? | Data payload |
|---------------------------------------------------------------------------|
The DATA message carries a packet of data, with the sequence number
determining order. The sequence number is monotonically incremented with
each data packet, and wraps at the maximum value of an unsigned 32-bit
integer.
5.2.4. S_ACK
|---------------------------------------------------------------------------|
| Field | Length | Description |
|---------------------------------------------------------------------------|
| Sender Link ID | 2 | 16-bit sender link ID |
| Destination Port | 2 | 16-bit destination port |
| Window Size | 2 | 16-bit window size in 1024-byte increments |
| Acknowledgements | ? | One or more acknowledgements (see below) |
|---------------------------------------------------------------------------|
Each acknowledgement is a 32-bit integer followed by an 8-bit integer (5 bytes
total). The 32-bit integer is the first sequence number to acknowledge, and
the 8-bit integer is the number of sequential following sequence numbers to
acknowledge. For example "1, 4" would acknowledge sequence numbers 1, 2, 3,
and 4.
5.2.5. S_DACK
|---------------------------------------------------------------------------|
| Field | Length | Description |
|---------------------------------------------------------------------------|
| Sender Link ID | 2 | 16-bit sender link ID |
| Destination Port | 2 | 16-bit destination port |
| Window Size | 2 | 16-bit window size in 1024-byte increments |
| Num. Acks | 1 | 8-bit number of acknowledgements |
| Acknowledgements | ? | One or more acknowledgements |
| Payload | ? | Data payload |
|---------------------------------------------------------------------------|
The DACK message combines ACK and DATA, allowing two peers that are both
transmitting data to efficiently ACK without a separate packet.

View File

@ -1,27 +0,0 @@
#!/usr/bin/ruby
#
# This can be used with the debug build option ZT_TRACE_MULTICAST to trace
# a multicast cascade.
#
# Define ZT_TRACE_MULTICAST to the IP/port where this script will be listening.
# The default port here is 6060, so an example would be to add:
#
# -DZT_TRACE_MULTICAST=\"10.0.0.1/6060\"
#
# ... to DEFS in the Makefile. Then build and run ZeroTier One on a testnet and
# the box defined as the trace endpoint will get spammed with UDP packets
# containing trace information for multicast propagation. This script then dumps
# these trace packets to stdout. Look at the code in PacketDecoder.cpp to see
# what this information entails.
#
require 'socket'
s = UDPSocket.new
s.bind('0.0.0.0',6060)
loop {
m = s.recvfrom(4096)[0].chomp
puts m if m.length > 0
}

View File

@ -0,0 +1,331 @@
/*
* ZeroTier One - Network Virtualization Everywhere
* Copyright (C) 2011-2015 ZeroTier, Inc.
*
* 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/>.
*
* --
*
* ZeroTier may be used and distributed under the terms of the GPLv3, which
* are available at: http://www.gnu.org/licenses/gpl-3.0.html
*
* If you would like to embed ZeroTier into a commercial application or
* redistribute it in a modified binary form, please contact ZeroTier Networks
* LLC. Start here: http://www.zerotier.com/
*/
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/param.h>
#include <sys/sysctl.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <net/route.h>
#include <net/if.h>
#include <net/if_dl.h>
#include <ifaddrs.h>
#include <algorithm>
#include <utility>
#include "../node/Constants.hpp"
#include "BSDRoutingTable.hpp"
// All I wanted was the bloody rounting table. I didn't expect the Spanish inquisition.
#define ZT_BSD_ROUTE_CMD "/sbin/route"
namespace ZeroTier {
BSDRoutingTable::BSDRoutingTable()
{
}
BSDRoutingTable::~BSDRoutingTable()
{
}
std::vector<RoutingTable::Entry> BSDRoutingTable::get(bool includeLinkLocal,bool includeLoopback) const
{
std::vector<RoutingTable::Entry> entries;
int mib[6];
size_t needed;
mib[0] = CTL_NET;
mib[1] = PF_ROUTE;
mib[2] = 0;
mib[3] = 0;
mib[4] = NET_RT_DUMP;
mib[5] = 0;
if (!sysctl(mib,6,NULL,&needed,NULL,0)) {
if (needed <= 0)
return entries;
char *buf = (char *)::malloc(needed);
if (buf) {
if (!sysctl(mib,6,buf,&needed,NULL,0)) {
struct rt_msghdr *rtm;
for(char *next=buf,*end=buf+needed;next<end;) {
rtm = (struct rt_msghdr *)next;
char *saptr = (char *)(rtm + 1);
char *saend = next + rtm->rtm_msglen;
if (((rtm->rtm_flags & RTF_LLINFO) == 0)&&((rtm->rtm_flags & RTF_HOST) == 0)&&((rtm->rtm_flags & RTF_UP) != 0)&&((rtm->rtm_flags & RTF_MULTICAST) == 0)) {
RoutingTable::Entry e;
e.deviceIndex = -9999; // unset
int which = 0;
while (saptr < saend) {
struct sockaddr *sa = (struct sockaddr *)saptr;
unsigned int salen = sa->sa_len;
if (!salen)
break;
// Skip missing fields in rtm_addrs bit field
while ((rtm->rtm_addrs & 1) == 0) {
rtm->rtm_addrs >>= 1;
++which;
if (which > 6)
break;
}
if (which > 6)
break;
rtm->rtm_addrs >>= 1;
switch(which++) {
case 0:
//printf("RTA_DST\n");
if (sa->sa_family == AF_INET6) {
struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sa;
// Nobody expects the Spanish inquisition!
if ((sin6->sin6_addr.s6_addr[0] == 0xfe)&&((sin6->sin6_addr.s6_addr[1] & 0xc0) == 0x80)) {
// Our chief weapon is... in-band signaling!
// Seriously who in the living fuck thought this was a good idea and
// then had the sadistic idea to not document it anywhere? Of course it's
// not like there is any documentation on BSD sysctls anyway.
unsigned int interfaceIndex = ((((unsigned int)sin6->sin6_addr.s6_addr[2]) << 8) & 0xff) | (((unsigned int)sin6->sin6_addr.s6_addr[3]) & 0xff);
sin6->sin6_addr.s6_addr[2] = 0;
sin6->sin6_addr.s6_addr[3] = 0;
if (!sin6->sin6_scope_id)
sin6->sin6_scope_id = interfaceIndex;
}
}
e.destination.set(sa);
break;
case 1:
//printf("RTA_GATEWAY\n");
switch(sa->sa_family) {
case AF_LINK:
e.deviceIndex = (int)((const struct sockaddr_dl *)sa)->sdl_index;
break;
case AF_INET:
case AF_INET6:
e.gateway.set(sa);
break;
}
break;
case 2: {
if (e.destination.isV6()) {
salen = sizeof(struct sockaddr_in6); // Confess!
unsigned int bits = 0;
for(int i=0;i<16;++i) {
unsigned char c = (unsigned char)((const struct sockaddr_in6 *)sa)->sin6_addr.s6_addr[i];
if (c == 0xff)
bits += 8;
else break;
/* must they be multiples of 8? Most of the BSD source I can find says yes..?
else {
while ((c & 0x80) == 0x80) {
++bits;
c <<= 1;
}
break;
}
*/
}
e.destination.setPort(bits);
} else {
salen = sizeof(struct sockaddr_in); // Confess!
e.destination.setPort((unsigned int)Utils::countBits((uint32_t)((const struct sockaddr_in *)sa)->sin_addr.s_addr));
}
//printf("RTA_NETMASK\n");
} break;
/*
case 3:
//printf("RTA_GENMASK\n");
break;
case 4:
//printf("RTA_IFP\n");
break;
case 5:
//printf("RTA_IFA\n");
break;
case 6:
//printf("RTA_AUTHOR\n");
break;
*/
}
saptr += salen;
}
e.metric = (int)rtm->rtm_rmx.rmx_hopcount;
if (e.metric < 0)
e.metric = 0;
if (((includeLinkLocal)||(!e.destination.isLinkLocal()))&&((includeLoopback)||((!e.destination.isLoopback())&&(!e.gateway.isLoopback()))))
entries.push_back(e);
}
next = saend;
}
}
::free(buf);
}
}
for(std::vector<ZeroTier::RoutingTable::Entry>::iterator e1(entries.begin());e1!=entries.end();++e1) {
if ((!e1->device[0])&&(e1->deviceIndex >= 0))
if_indextoname(e1->deviceIndex,e1->device);
}
for(std::vector<ZeroTier::RoutingTable::Entry>::iterator e1(entries.begin());e1!=entries.end();++e1) {
if ((!e1->device[0])&&(e1->gateway)) {
int bestMetric = 9999999;
for(std::vector<ZeroTier::RoutingTable::Entry>::iterator e2(entries.begin());e2!=entries.end();++e2) {
if ((e1->gateway.within(e2->destination))&&(e2->metric <= bestMetric)) {
bestMetric = e2->metric;
Utils::scopy(e1->device,sizeof(e1->device),e2->device);
}
}
}
}
std::sort(entries.begin(),entries.end());
return entries;
}
RoutingTable::Entry BSDRoutingTable::set(const InetAddress &destination,const InetAddress &gateway,const char *device,int metric)
{
if ((!gateway)&&((!device)||(!device[0])))
return RoutingTable::Entry();
std::vector<RoutingTable::Entry> rtab(get(true,true));
for(std::vector<RoutingTable::Entry>::iterator e(rtab.begin());e!=rtab.end();++e) {
if (e->destination == destination) {
if (((!device)||(!device[0]))||(!strcmp(device,e->device))) {
long p = (long)fork();
if (p > 0) {
int exitcode = -1;
::waitpid(p,&exitcode,0);
} else if (p == 0) {
::close(STDOUT_FILENO);
::close(STDERR_FILENO);
::execl(ZT_BSD_ROUTE_CMD,ZT_BSD_ROUTE_CMD,"delete",(destination.isV6() ? "-inet6" : "-inet"),destination.toString().c_str(),(const char *)0);
::_exit(-1);
}
}
}
}
if (metric < 0)
return RoutingTable::Entry();
{
char hcstr[64];
Utils::snprintf(hcstr,sizeof(hcstr),"%d",metric);
long p = (long)fork();
if (p > 0) {
int exitcode = -1;
::waitpid(p,&exitcode,0);
} else if (p == 0) {
::close(STDOUT_FILENO);
::close(STDERR_FILENO);
if (gateway) {
::execl(ZT_BSD_ROUTE_CMD,ZT_BSD_ROUTE_CMD,"add",(destination.isV6() ? "-inet6" : "-inet"),destination.toString().c_str(),gateway.toIpString().c_str(),"-hopcount",hcstr,(const char *)0);
} else if ((device)&&(device[0])) {
::execl(ZT_BSD_ROUTE_CMD,ZT_BSD_ROUTE_CMD,"add",(destination.isV6() ? "-inet6" : "-inet"),destination.toString().c_str(),"-interface",device,"-hopcount",hcstr,(const char *)0);
}
::_exit(-1);
}
}
rtab = get(true,true);
std::vector<RoutingTable::Entry>::iterator bestEntry(rtab.end());
for(std::vector<RoutingTable::Entry>::iterator e(rtab.begin());e!=rtab.end();++e) {
if ((e->destination == destination)&&(e->gateway.ipsEqual(gateway))) {
if ((device)&&(device[0])) {
if (!strcmp(device,e->device)) {
if (metric == e->metric)
bestEntry = e;
}
}
if (bestEntry == rtab.end())
bestEntry = e;
}
}
if (bestEntry != rtab.end())
return *bestEntry;
return RoutingTable::Entry();
}
} // namespace ZeroTier
// Enable and build to test routing table interface
#if 0
using namespace ZeroTier;
int main(int argc,char **argv)
{
BSDRoutingTable rt;
printf("<destination> <gateway> <interface> <metric>\n");
std::vector<RoutingTable::Entry> ents(rt.get());
for(std::vector<RoutingTable::Entry>::iterator e(ents.begin());e!=ents.end();++e)
printf("%s\n",e->toString().c_str());
printf("\n");
printf("adding 1.1.1.0 and 2.2.2.0...\n");
rt.set(InetAddress("1.1.1.0",24),InetAddress("1.2.3.4",0),(const char *)0,1);
rt.set(InetAddress("2.2.2.0",24),InetAddress(),"en0",1);
printf("\n");
printf("<destination> <gateway> <interface> <metric>\n");
ents = rt.get();
for(std::vector<RoutingTable::Entry>::iterator e(ents.begin());e!=ents.end();++e)
printf("%s\n",e->toString().c_str());
printf("\n");
printf("deleting 1.1.1.0 and 2.2.2.0...\n");
rt.set(InetAddress("1.1.1.0",24),InetAddress("1.2.3.4",0),(const char *)0,-1);
rt.set(InetAddress("2.2.2.0",24),InetAddress(),"en0",-1);
printf("\n");
printf("<destination> <gateway> <interface> <metric>\n");
ents = rt.get();
for(std::vector<RoutingTable::Entry>::iterator e(ents.begin());e!=ents.end();++e)
printf("%s\n",e->toString().c_str());
printf("\n");
return 0;
}
#endif

View File

@ -0,0 +1,51 @@
/*
* ZeroTier One - Network Virtualization Everywhere
* Copyright (C) 2011-2015 ZeroTier, Inc.
*
* 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/>.
*
* --
*
* ZeroTier may be used and distributed under the terms of the GPLv3, which
* are available at: http://www.gnu.org/licenses/gpl-3.0.html
*
* If you would like to embed ZeroTier into a commercial application or
* redistribute it in a modified binary form, please contact ZeroTier Networks
* LLC. Start here: http://www.zerotier.com/
*/
#ifndef ZT_BSDROUTINGTABLE_HPP
#define ZT_BSDROUTINGTABLE_HPP
#include "../node/RoutingTable.hpp"
namespace ZeroTier {
/**
* Routing table interface for BSD with sysctl() and BSD /sbin/route
*
* Has currently only been tested on OSX/Darwin.
*/
class BSDRoutingTable : public RoutingTable
{
public:
BSDRoutingTable();
virtual ~BSDRoutingTable();
virtual std::vector<RoutingTable::Entry> get(bool includeLinkLocal = false,bool includeLoopback = false) const;
virtual RoutingTable::Entry set(const InetAddress &destination,const InetAddress &gateway,const char *device,int metric);
};
} // namespace ZeroTier
#endif

View File

@ -0,0 +1,235 @@
/*
* ZeroTier One - Network Virtualization Everywhere
* Copyright (C) 2011-2015 ZeroTier, Inc.
*
* 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/>.
*
* --
*
* ZeroTier may be used and distributed under the terms of the GPLv3, which
* are available at: http://www.gnu.org/licenses/gpl-3.0.html
*
* If you would like to embed ZeroTier into a commercial application or
* redistribute it in a modified binary form, please contact ZeroTier Networks
* LLC. Start here: http://www.zerotier.com/
*/
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <ifaddrs.h>
#include <algorithm>
#include <utility>
#include "../node/Constants.hpp"
#include "../node/Utils.hpp"
#include "LinuxRoutingTable.hpp"
#define ZT_LINUX_IP_COMMAND "/sbin/ip"
namespace ZeroTier {
LinuxRoutingTable::LinuxRoutingTable()
{
}
LinuxRoutingTable::~LinuxRoutingTable()
{
}
std::vector<RoutingTable::Entry> LinuxRoutingTable::get(bool includeLinkLocal,bool includeLoopback) const
{
char buf[131072];
char *stmp,*stmp2;
std::vector<RoutingTable::Entry> entries;
{
int fd = ::open("/proc/net/route",O_RDONLY);
if (fd <= 0)
buf[0] = (char)0;
else {
int n = (int)::read(fd,buf,sizeof(buf) - 1);
::close(fd);
if (n < 0) n = 0;
buf[n] = (char)0;
}
}
int lineno = 0;
for(char *line=Utils::stok(buf,"\r\n",&stmp);(line);line=Utils::stok((char *)0,"\r\n",&stmp)) {
if (lineno == 0) {
++lineno;
continue; // skip header
}
char *iface = (char *)0;
uint32_t destination = 0;
uint32_t gateway = 0;
int metric = 0;
uint32_t mask = 0;
int fno = 0;
for(char *f=Utils::stok(line,"\t \r\n",&stmp2);(f);f=Utils::stok((char *)0,"\t \r\n",&stmp2)) {
switch(fno) {
case 0: iface = f; break;
case 1: destination = (uint32_t)Utils::hexStrToULong(f); break;
case 2: gateway = (uint32_t)Utils::hexStrToULong(f); break;
case 6: metric = (int)Utils::strToInt(f); break;
case 7: mask = (uint32_t)Utils::hexStrToULong(f); break;
}
++fno;
}
if ((iface)&&(destination)) {
RoutingTable::Entry e;
if (destination)
e.destination.set(&destination,4,Utils::countBits(mask));
e.gateway.set(&gateway,4,0);
e.deviceIndex = 0; // not used on Linux
e.metric = metric;
Utils::scopy(e.device,sizeof(e.device),iface);
if ((e.destination)&&((includeLinkLocal)||(!e.destination.isLinkLocal()))&&((includeLoopback)||((!e.destination.isLoopback())&&(!e.gateway.isLoopback())&&(strcmp(iface,"lo")))))
entries.push_back(e);
}
++lineno;
}
{
int fd = ::open("/proc/net/ipv6_route",O_RDONLY);
if (fd <= 0)
buf[0] = (char)0;
else {
int n = (int)::read(fd,buf,sizeof(buf) - 1);
::close(fd);
if (n < 0) n = 0;
buf[n] = (char)0;
}
}
for(char *line=Utils::stok(buf,"\r\n",&stmp);(line);line=Utils::stok((char *)0,"\r\n",&stmp)) {
char *destination = (char *)0;
unsigned int destPrefixLen = 0;
char *gateway = (char *)0; // next hop in ipv6 terminology
int metric = 0;
char *device = (char *)0;
int fno = 0;
for(char *f=Utils::stok(line,"\t \r\n",&stmp2);(f);f=Utils::stok((char *)0,"\t \r\n",&stmp2)) {
switch(fno) {
case 0: destination = f; break;
case 1: destPrefixLen = (unsigned int)Utils::hexStrToULong(f); break;
case 4: gateway = f; break;
case 5: metric = (int)Utils::hexStrToLong(f); break;
case 9: device = f; break;
}
++fno;
}
if ((device)&&(destination)) {
unsigned char tmp[16];
RoutingTable::Entry e;
Utils::unhex(destination,tmp,16);
if ((!Utils::isZero(tmp,16))&&(tmp[0] != 0xff))
e.destination.set(tmp,16,destPrefixLen);
Utils::unhex(gateway,tmp,16);
e.gateway.set(tmp,16,0);
e.deviceIndex = 0; // not used on Linux
e.metric = metric;
Utils::scopy(e.device,sizeof(e.device),device);
if ((e.destination)&&((includeLinkLocal)||(!e.destination.isLinkLocal()))&&((includeLoopback)||((!e.destination.isLoopback())&&(!e.gateway.isLoopback())&&(strcmp(device,"lo")))))
entries.push_back(e);
}
}
std::sort(entries.begin(),entries.end());
return entries;
}
RoutingTable::Entry LinuxRoutingTable::set(const InetAddress &destination,const InetAddress &gateway,const char *device,int metric)
{
char metstr[128];
if ((!gateway)&&((!device)||(!device[0])))
return RoutingTable::Entry();
Utils::snprintf(metstr,sizeof(metstr),"%d",metric);
if (metric < 0) {
long pid = (long)vfork();
if (pid == 0) {
if (gateway) {
if ((device)&&(device[0])) {
::execl(ZT_LINUX_IP_COMMAND,ZT_LINUX_IP_COMMAND,"route","del",destination.toString().c_str(),"via",gateway.toIpString().c_str(),"dev",device,(const char *)0);
} else {
::execl(ZT_LINUX_IP_COMMAND,ZT_LINUX_IP_COMMAND,"route","del",destination.toString().c_str(),"via",gateway.toIpString().c_str(),(const char *)0);
}
} else {
::execl(ZT_LINUX_IP_COMMAND,ZT_LINUX_IP_COMMAND,"route","del",destination.toString().c_str(),"dev",device,(const char *)0);
}
::_exit(-1);
} else if (pid > 0) {
int exitcode = -1;
::waitpid(pid,&exitcode,0);
}
} else {
long pid = (long)vfork();
if (pid == 0) {
if (gateway) {
if ((device)&&(device[0])) {
::execl(ZT_LINUX_IP_COMMAND,ZT_LINUX_IP_COMMAND,"route","replace",destination.toString().c_str(),"metric",metstr,"via",gateway.toIpString().c_str(),"dev",device,(const char *)0);
} else {
::execl(ZT_LINUX_IP_COMMAND,ZT_LINUX_IP_COMMAND,"route","replace",destination.toString().c_str(),"metric",metstr,"via",gateway.toIpString().c_str(),(const char *)0);
}
} else {
::execl(ZT_LINUX_IP_COMMAND,ZT_LINUX_IP_COMMAND,"route","replace",destination.toString().c_str(),"metric",metstr,"dev",device,(const char *)0);
}
::_exit(-1);
} else if (pid > 0) {
int exitcode = -1;
::waitpid(pid,&exitcode,0);
}
}
std::vector<RoutingTable::Entry> rtab(get(true,true));
std::vector<RoutingTable::Entry>::iterator bestEntry(rtab.end());
for(std::vector<RoutingTable::Entry>::iterator e(rtab.begin());e!=rtab.end();++e) {
if ((e->destination == destination)&&(e->gateway.ipsEqual(gateway))) {
if ((device)&&(device[0])) {
if (!strcmp(device,e->device)) {
if (metric == e->metric)
bestEntry = e;
}
}
if (bestEntry == rtab.end())
bestEntry = e;
}
}
if (bestEntry != rtab.end())
return *bestEntry;
return RoutingTable::Entry();
}
} // namespace ZeroTier

View File

@ -0,0 +1,49 @@
/*
* ZeroTier One - Network Virtualization Everywhere
* Copyright (C) 2011-2015 ZeroTier, Inc.
*
* 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/>.
*
* --
*
* ZeroTier may be used and distributed under the terms of the GPLv3, which
* are available at: http://www.gnu.org/licenses/gpl-3.0.html
*
* If you would like to embed ZeroTier into a commercial application or
* redistribute it in a modified binary form, please contact ZeroTier Networks
* LLC. Start here: http://www.zerotier.com/
*/
#ifndef ZT_LINUXROUTINGTABLE_HPP
#define ZT_LINUXROUTINGTABLE_HPP
#include "../node/RoutingTable.hpp"
namespace ZeroTier {
/**
* Routing table interface via /proc/net/route, /proc/net/ipv6_route, and /sbin/route command
*/
class LinuxRoutingTable : public RoutingTable
{
public:
LinuxRoutingTable();
virtual ~LinuxRoutingTable();
virtual std::vector<RoutingTable::Entry> get(bool includeLinkLocal = false,bool includeLoopback = false) const;
virtual RoutingTable::Entry set(const InetAddress &destination,const InetAddress &gateway,const char *device,int metric);
};
} // namespace ZeroTier
#endif

View File

@ -0,0 +1,77 @@
/*
* ZeroTier One - Network Virtualization Everywhere
* Copyright (C) 2011-2015 ZeroTier, Inc.
*
* 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/>.
*
* --
*
* ZeroTier may be used and distributed under the terms of the GPLv3, which
* are available at: http://www.gnu.org/licenses/gpl-3.0.html
*
* If you would like to embed ZeroTier into a commercial application or
* redistribute it in a modified binary form, please contact ZeroTier Networks
* LLC. Start here: http://www.zerotier.com/
*/
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "Constants.hpp"
#include "RoutingTable.hpp"
#include "Utils.hpp"
namespace ZeroTier {
std::string RoutingTable::Entry::toString() const
{
char tmp[1024];
Utils::snprintf(tmp,sizeof(tmp),"%s %s %s %d",destination.toString().c_str(),((gateway) ? gateway.toIpString().c_str() : "<link>"),device,metric);
return std::string(tmp);
}
bool RoutingTable::Entry::operator==(const Entry &re) const
{
return ((destination == re.destination)&&(gateway == re.gateway)&&(strcmp(device,re.device) == 0)&&(metric == re.metric));
}
bool RoutingTable::Entry::operator<(const Entry &re) const
{
if (destination < re.destination)
return true;
else if (destination == re.destination) {
if (gateway < re.gateway)
return true;
else if (gateway == re.gateway) {
int tmp = (int)::strcmp(device,re.device);
if (tmp < 0)
return true;
else if (tmp == 0)
return (metric < re.metric);
}
}
return false;
}
RoutingTable::RoutingTable()
{
}
RoutingTable::~RoutingTable()
{
}
} // namespace ZeroTier

122
attic/rtbl/RoutingTable.hpp Normal file
View File

@ -0,0 +1,122 @@
/*
* ZeroTier One - Network Virtualization Everywhere
* Copyright (C) 2011-2015 ZeroTier, Inc.
*
* 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/>.
*
* --
*
* ZeroTier may be used and distributed under the terms of the GPLv3, which
* are available at: http://www.gnu.org/licenses/gpl-3.0.html
*
* If you would like to embed ZeroTier into a commercial application or
* redistribute it in a modified binary form, please contact ZeroTier Networks
* LLC. Start here: http://www.zerotier.com/
*/
#ifndef ZT_ROUTINGTABLE_HPP
#define ZT_ROUTINGTABLE_HPP
#include <vector>
#include <string>
#include "InetAddress.hpp"
#include "NonCopyable.hpp"
namespace ZeroTier {
/**
* Base class for OS routing table interfaces
*/
class RoutingTable : NonCopyable
{
public:
class Entry
{
public:
Entry() throw() { device[0] = (char)0; }
/**
* Destination IP and netmask bits (CIDR format)
*/
InetAddress destination;
/**
* Gateway or null address if direct link-level route, netmask/port part of InetAddress not used
*/
InetAddress gateway;
/**
* System device index or ID (not included in comparison operators, may not be set on all platforms)
*/
int deviceIndex;
/**
* Metric or hop count -- higher = lower routing priority
*/
int metric;
/**
* System device name
*/
char device[128];
/**
* @return Human-readable representation of this route
*/
std::string toString() const;
/**
* @return True if at least one required field is present (object is not null)
*/
inline operator bool() const { return ((destination)||(gateway)||(device[0])); }
bool operator==(const Entry &re) const;
inline bool operator!=(const Entry &re) const { return (!(*this == re)); }
bool operator<(const Entry &re) const;
inline bool operator>(const Entry &re) const { return (re < *this); }
inline bool operator<=(const Entry &re) const { return (!(re < *this)); }
inline bool operator>=(const Entry &re) const { return (!(*this < re)); }
};
RoutingTable();
virtual ~RoutingTable();
/**
* Get routing table
*
* @param includeLinkLocal If true, include link-local address routes (default: false)
* @param includeLoopback Include loopback (default: false)
* @return Sorted routing table entries
*/
virtual std::vector<RoutingTable::Entry> get(bool includeLinkLocal = false,bool includeLoopback = false) const = 0;
/**
* Add or update a routing table entry
*
* If there is no change, the existing entry is returned. Use a value of -1
* for metric to delete a route.
*
* @param destination Destination IP/netmask
* @param gateway Gateway IP (netmask/port part unused) or NULL/zero for device-level route
* @param device Device name (can be null for gateway routes)
* @param metric Route metric or hop count (higher = lower priority) or negative to delete
* @return Entry or null entry on failure (or delete)
*/
virtual RoutingTable::Entry set(const InetAddress &destination,const InetAddress &gateway,const char *device,int metric) = 0;
};
} // namespace ZeroTier
#endif

View File

@ -1,6 +1,6 @@
/*
* ZeroTier One - Global Peer to Peer Ethernet
* Copyright (C) 2012-2013 ZeroTier Networks LLC
* ZeroTier One - Network Virtualization Everywhere
* Copyright (C) 2011-2015 ZeroTier, Inc.
*
* 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
@ -25,24 +25,26 @@
* LLC. Start here: http://www.zerotier.com/
*/
#include "aboutwindow.h"
#include "ui_aboutwindow.h"
#include "TestRoutingTable.hpp"
#include <QMessageBox>
#include <QFont>
namespace ZeroTier {
#include "../node/Constants.hpp"
#include "../node/Node.hpp"
AboutWindow::AboutWindow(QWidget *parent) :
QDialog(parent),
ui(new Ui::AboutWindow)
TestRoutingTable::TestRoutingTable()
{
ui->setupUi(this);
ui->aboutTextLabel->setText(QString("ZeroTier One\nVersion ")+ZeroTier::Node::versionString()+"\nQt Graphical User Interface\n\n(c)2011-2014 ZeroTier Networks LLC\n\nReleased under the terms of the GNU\nGeneral Public License v3.0, see: http://gplv3.fsf.org for terms.\n\nAuthor(s): Adam Ierymenko");
}
AboutWindow::~AboutWindow()
TestRoutingTable::~TestRoutingTable()
{
delete ui;
}
std::vector<RoutingTable::Entry> TestRoutingTable::get(bool includeLinkLocal,bool includeLoopback) const
{
return std::vector<RoutingTable::Entry>();
}
RoutingTable::Entry TestRoutingTable::set(const InetAddress &destination,const InetAddress &gateway,const char *device,int metric)
{
return RoutingTable::Entry();
}
} // namespace ZeroTier

View File

@ -1,6 +1,6 @@
/*
* ZeroTier One - Global Peer to Peer Ethernet
* Copyright (C) 2012-2013 ZeroTier Networks LLC
* ZeroTier One - Network Virtualization Everywhere
* Copyright (C) 2011-2015 ZeroTier, Inc.
*
* 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
@ -25,35 +25,24 @@
* LLC. Start here: http://www.zerotier.com/
*/
#ifndef ZT_SYSENV_HPP
#define ZT_SYSENV_HPP
#ifndef ZT_TESTROUTINGTABLE_HPP
#define ZT_TESTROUTINGTABLE_HPP
#include <stdint.h>
#include <set>
#include "NonCopyable.hpp"
#include "../node/RoutingTable.hpp"
namespace ZeroTier {
class RuntimeEnvironment;
/**
* Local system environment monitoring utilities
* Dummy routing table -- right now this just does nothing
*/
class SysEnv : NonCopyable
class TestRoutingTable : public RoutingTable
{
public:
SysEnv();
~SysEnv();
TestRoutingTable();
virtual ~TestRoutingTable();
/**
* This computes a CRC-type code from gathered information about your network settings
*
* @param ignoreDevices Ignore these local network devices by OS-specific name (e.g. our taps)
* @return Fingerprint of currently running network environment
*/
uint64_t getNetworkConfigurationFingerprint(const std::set<std::string> &ignoreDevices);
virtual std::vector<RoutingTable::Entry> get(bool includeLinkLocal = false,bool includeLoopback = false) const;
virtual RoutingTable::Entry set(const InetAddress &destination,const InetAddress &gateway,const char *device,int metric);
};
} // namespace ZeroTier

View File

@ -0,0 +1,178 @@
/*
* ZeroTier One - Network Virtualization Everywhere
* Copyright (C) 2011-2015 ZeroTier, Inc.
*
* 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/>.
*
* --
*
* ZeroTier may be used and distributed under the terms of the GPLv3, which
* are available at: http://www.gnu.org/licenses/gpl-3.0.html
*
* If you would like to embed ZeroTier into a commercial application or
* redistribute it in a modified binary form, please contact ZeroTier Networks
* LLC. Start here: http://www.zerotier.com/
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <WinSock2.h>
#include <Windows.h>
#include <netioapi.h>
#include <IPHlpApi.h>
#include <vector>
#include "../node/Constants.hpp"
#include "WindowsRoutingTable.hpp"
namespace ZeroTier {
static void _copyInetAddressToSockaddrInet(const InetAddress &a,SOCKADDR_INET &sinet)
{
memset(&sinet,0,sizeof(sinet));
if (a.isV4()) {
sinet.Ipv4.sin_addr.S_un.S_addr = *((const uint32_t *)a.rawIpData());
sinet.Ipv4.sin_family = AF_INET;
sinet.Ipv4.sin_port = htons(a.port());
} else if (a.isV6()) {
memcpy(sinet.Ipv6.sin6_addr.u.Byte,a.rawIpData(),16);
sinet.Ipv6.sin6_family = AF_INET6;
sinet.Ipv6.sin6_port = htons(a.port());
}
}
WindowsRoutingTable::WindowsRoutingTable()
{
}
WindowsRoutingTable::~WindowsRoutingTable()
{
}
std::vector<RoutingTable::Entry> WindowsRoutingTable::get(bool includeLinkLocal,bool includeLoopback) const
{
std::vector<RoutingTable::Entry> entries;
PMIB_IPFORWARD_TABLE2 rtbl = NULL;
if (GetIpForwardTable2(AF_UNSPEC,&rtbl) != NO_ERROR)
return entries;
if (!rtbl)
return entries;
for(ULONG r=0;r<rtbl->NumEntries;++r) {
RoutingTable::Entry e;
switch(rtbl->Table[r].DestinationPrefix.Prefix.si_family) {
case AF_INET:
e.destination.set(&(rtbl->Table[r].DestinationPrefix.Prefix.Ipv4.sin_addr.S_un.S_addr),4,rtbl->Table[r].DestinationPrefix.PrefixLength);
break;
case AF_INET6:
e.destination.set(rtbl->Table[r].DestinationPrefix.Prefix.Ipv6.sin6_addr.u.Byte,16,rtbl->Table[r].DestinationPrefix.PrefixLength);
break;
}
switch(rtbl->Table[r].NextHop.si_family) {
case AF_INET:
e.gateway.set(&(rtbl->Table[r].NextHop.Ipv4.sin_addr.S_un.S_addr),4,0);
break;
case AF_INET6:
e.gateway.set(rtbl->Table[r].NextHop.Ipv6.sin6_addr.u.Byte,16,0);
break;
}
e.deviceIndex = (int)rtbl->Table[r].InterfaceIndex;
e.metric = (int)rtbl->Table[r].Metric;
ConvertInterfaceLuidToNameA(&(rtbl->Table[r].InterfaceLuid),e.device,sizeof(e.device));
if ((e.destination)&&((includeLinkLocal)||(!e.destination.isLinkLocal()))&&((includeLoopback)||((!e.destination.isLoopback())&&(!e.gateway.isLoopback()))))
entries.push_back(e);
}
FreeMibTable(rtbl);
std::sort(entries.begin(),entries.end());
return entries;
}
RoutingTable::Entry WindowsRoutingTable::set(const InetAddress &destination,const InetAddress &gateway,const char *device,int metric)
{
NET_LUID luid;
luid.Value = 0;
if (ConvertInterfaceNameToLuidA(device,&luid) != NO_ERROR)
return RoutingTable::Entry();
bool needCreate = true;
PMIB_IPFORWARD_TABLE2 rtbl = NULL;
if (GetIpForwardTable2(AF_UNSPEC,&rtbl) != NO_ERROR)
return RoutingTable::Entry();
if (!rtbl)
return RoutingTable::Entry();
for(ULONG r=0;r<rtbl->NumEntries;++r) {
if (rtbl->Table[r].InterfaceLuid.Value == luid.Value) {
InetAddress rdest;
switch(rtbl->Table[r].DestinationPrefix.Prefix.si_family) {
case AF_INET:
rdest.set(&(rtbl->Table[r].DestinationPrefix.Prefix.Ipv4.sin_addr.S_un.S_addr),4,rtbl->Table[r].DestinationPrefix.PrefixLength);
break;
case AF_INET6:
rdest.set(rtbl->Table[r].DestinationPrefix.Prefix.Ipv6.sin6_addr.u.Byte,16,rtbl->Table[r].DestinationPrefix.PrefixLength);
break;
}
if (rdest == destination) {
if (metric >= 0) {
_copyInetAddressToSockaddrInet(gateway,rtbl->Table[r].NextHop);
rtbl->Table[r].Metric = metric;
SetIpForwardEntry2(&(rtbl->Table[r]));
needCreate = false;
} else {
DeleteIpForwardEntry2(&(rtbl->Table[r]));
FreeMibTable(rtbl);
return RoutingTable::Entry();
}
}
}
}
FreeMibTable(rtbl);
if ((metric >= 0)&&(needCreate)) {
MIB_IPFORWARD_ROW2 nr;
InitializeIpForwardEntry(&nr);
nr.InterfaceLuid.Value = luid.Value;
_copyInetAddressToSockaddrInet(destination,nr.DestinationPrefix.Prefix);
nr.DestinationPrefix.PrefixLength = destination.netmaskBits();
_copyInetAddressToSockaddrInet(gateway,nr.NextHop);
nr.Metric = metric;
nr.Protocol = MIB_IPPROTO_NETMGMT;
DWORD result = CreateIpForwardEntry2(&nr);
if (result != NO_ERROR)
return RoutingTable::Entry();
}
std::vector<RoutingTable::Entry> rtab(get(true,true));
std::vector<RoutingTable::Entry>::iterator bestEntry(rtab.end());
for(std::vector<RoutingTable::Entry>::iterator e(rtab.begin());e!=rtab.end();++e) {
if ((e->destination == destination)&&(e->gateway.ipsEqual(gateway))) {
if ((device)&&(device[0])) {
if (!strcmp(device,e->device)) {
if (metric == e->metric)
bestEntry = e;
}
}
if (bestEntry == rtab.end())
bestEntry = e;
}
}
if (bestEntry != rtab.end())
return *bestEntry;
return RoutingTable::Entry();
}
} // namespace ZeroTier

View File

@ -1,6 +1,6 @@
/*
* ZeroTier One - Global Peer to Peer Ethernet
* Copyright (C) 2012-2013 ZeroTier Networks LLC
* ZeroTier One - Network Virtualization Everywhere
* Copyright (C) 2011-2015 ZeroTier, Inc.
*
* 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
@ -25,47 +25,25 @@
* LLC. Start here: http://www.zerotier.com/
*/
#ifndef INSTALLDIALOG_H
#define INSTALLDIALOG_H
#ifndef ZT_WINDOWSROUTINGTABLE_HPP
#define ZT_WINDOWSROUTINGTABLE_HPP
#include <QMainWindow>
#include <QNetworkAccessManager>
#include <QUrl>
#include <QNetworkRequest>
#include <QNetworkReply>
#include "../node/RoutingTable.hpp"
#include <string>
namespace ZeroTier {
#include "../node/Address.hpp"
namespace Ui {
class InstallDialog;
}
class InstallDialog : public QMainWindow
/**
* Interface to Microsoft Windows (Vista or newer) routing table
*/
class WindowsRoutingTable : public RoutingTable
{
Q_OBJECT
public:
explicit InstallDialog(QWidget *parent = 0);
~InstallDialog();
private slots:
void on_networkReply(QNetworkReply *reply);
void on_InstallDialog_rejected();
void on_cancelButton_clicked();
void on_downloadProgress(qint64 bytesReceived,qint64 bytesTotal);
private:
Ui::InstallDialog *ui;
QNetworkAccessManager *nam;
enum {
FETCHING_NFO,
FETCHING_INSTALLER
} phase;
ZeroTier::Address signedBy;
std::string url,signature;
WindowsRoutingTable();
virtual ~WindowsRoutingTable();
virtual std::vector<RoutingTable::Entry> get(bool includeLinkLocal = false,bool includeLoopback = false) const;
virtual RoutingTable::Entry set(const InetAddress &destination,const InetAddress &gateway,const char *device,int metric);
};
#endif // INSTALLDIALOG_H
} // namespace ZeroTier
#endif

View File

@ -1,3 +0,0 @@
This is a do-nothing placebo software update for internal testing. It's a
shell script that just prints a simple message and an .NFO file that signs
it as official.

View File

@ -1,6 +0,0 @@
vMajor=999
vMinor=999
vRevision=999
signedBy=e9bc3707b5
ed25519=ca7b943ace5451f420f1f599822d7013534a7cb7997096141e6a1aa6398c5f260c19dc5eecb297c922950f26dee7f9db787f8dbf85bc422baf3bff94c1131e086a7fc85c26dbb8c1b0a9cae63acc34998d9e1ce553156ea5638f9c99a50f6e2e
url=http://download.zerotier.com/update/update-dummy.sh

View File

@ -1,4 +0,0 @@
#!/bin/bash
echo "Dummy updater -- run with opts: $*"
exit 0

32
controller/README.md Normal file
View File

@ -0,0 +1,32 @@
Network Controller Implementation
======
This folder contains code implementing the node/NetworkController.hpp interface to allow ZeroTier nodes to create and manage virtual networks.
### Building
By default this code is not built or included in the client. To build on Linux, BSD, or Mac add ZT\_ENABLE\_NETCONF\_MASTER=1 to the make command line. You'll need the development headers for Sqlite3 installed. They ship as part of OSX and Xcode. On Linux or BSD you'll probably need to install a package.
### Running
When started, a controller-enabled build of ZeroTier One will automatically create and initialize a *controller.db* in its home folder. This is where all the controller's data and persistent state lives.
Since Sqlite3 supports multiple processes attached to the same database, it is safe to back up a running database with the command line *sqlite3* utility:
sqlite3 /path/to/controller.db .dump
In production ZeroTier runs this frequently and keeps many timestamped copies going back about a week. These are also backed up (encrypted) to Amazon S3 along with the rest of our data.
### Administrating
See service/README.md for documentation on the JSON API presented by this network controller implementation. Also see *nodejs-zt1-client* for a NodeJS JavaScript interface.
### Reliability
Network controllers can go offline without affecting already-configured members of running networks. You just won't be able to change anything and new members will not be able to join.
High-availability can be implemented through fail-over. A simple method involves making a frequent backup of the SQLite database (use the SQLite command line client to do this safely) and the network configuration master's working directory. Then, if the master goes down, another instance of it can rapidly be provisioned elsewhere. Since ZeroTier addresses are mobile, the new instance will quickly (usually no more than 30s) take over for the old one and service requests.
### Limits
A single network configuration master can administrate up to 2^24 (~16m) networks as per the ZeroTier protocol limit. There is no hard limit on the number of clients, though millions or more would impose significant CPU demands on a server. Optimizations could be implemented such as memoization/caching to reduce this.

File diff suppressed because it is too large Load Diff

View File

@ -0,0 +1,133 @@
/*
* ZeroTier One - Network Virtualization Everywhere
* Copyright (C) 2011-2015 ZeroTier, Inc.
*
* 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/>.
*
* --
*
* ZeroTier may be used and distributed under the terms of the GPLv3, which
* are available at: http://www.gnu.org/licenses/gpl-3.0.html
*
* If you would like to embed ZeroTier into a commercial application or
* redistribute it in a modified binary form, please contact ZeroTier Networks
* LLC. Start here: http://www.zerotier.com/
*/
#ifndef ZT_SQLITENETWORKCONTROLLER_HPP
#define ZT_SQLITENETWORKCONTROLLER_HPP
#include <stdint.h>
#include <sqlite3.h>
#include <string>
#include <map>
#include <vector>
#include "../node/Constants.hpp"
#include "../node/NetworkController.hpp"
#include "../node/Mutex.hpp"
namespace ZeroTier {
class SqliteNetworkController : public NetworkController
{
public:
SqliteNetworkController(const char *dbPath);
virtual ~SqliteNetworkController();
virtual NetworkController::ResultCode doNetworkConfigRequest(
const InetAddress &fromAddr,
const Identity &signingId,
const Identity &identity,
uint64_t nwid,
const Dictionary &metaData,
uint64_t haveRevision,
Dictionary &netconf);
unsigned int handleControlPlaneHttpGET(
const std::vector<std::string> &path,
const std::map<std::string,std::string> &urlArgs,
const std::map<std::string,std::string> &headers,
const std::string &body,
std::string &responseBody,
std::string &responseContentType);
unsigned int handleControlPlaneHttpPOST(
const std::vector<std::string> &path,
const std::map<std::string,std::string> &urlArgs,
const std::map<std::string,std::string> &headers,
const std::string &body,
std::string &responseBody,
std::string &responseContentType);
unsigned int handleControlPlaneHttpDELETE(
const std::vector<std::string> &path,
const std::map<std::string,std::string> &urlArgs,
const std::map<std::string,std::string> &headers,
const std::string &body,
std::string &responseBody,
std::string &responseContentType);
private:
unsigned int _doCPGet(
const std::vector<std::string> &path,
const std::map<std::string,std::string> &urlArgs,
const std::map<std::string,std::string> &headers,
const std::string &body,
std::string &responseBody,
std::string &responseContentType);
std::string _dbPath;
sqlite3 *_db;
sqlite3_stmt *_sGetNetworkById;
sqlite3_stmt *_sGetMember;
sqlite3_stmt *_sCreateMember;
sqlite3_stmt *_sGetNodeIdentity;
sqlite3_stmt *_sCreateNode;
sqlite3_stmt *_sUpdateNode;
sqlite3_stmt *_sUpdateNode2;
sqlite3_stmt *_sGetEtherTypesFromRuleTable;
sqlite3_stmt *_sGetMulticastRates;
sqlite3_stmt *_sGetActiveBridges;
sqlite3_stmt *_sGetIpAssignmentsForNode;
sqlite3_stmt *_sGetIpAssignmentPools;
sqlite3_stmt *_sCheckIfIpIsAllocated;
sqlite3_stmt *_sAllocateIp;
sqlite3_stmt *_sDeleteIpAllocations;
sqlite3_stmt *_sGetRelays;
sqlite3_stmt *_sListNetworks;
sqlite3_stmt *_sListNetworkMembers;
sqlite3_stmt *_sGetMember2;
sqlite3_stmt *_sGetIpAssignmentPools2;
sqlite3_stmt *_sListRules;
sqlite3_stmt *_sCreateRule;
sqlite3_stmt *_sCreateNetwork;
sqlite3_stmt *_sGetNetworkRevision;
sqlite3_stmt *_sSetNetworkRevision;
sqlite3_stmt *_sGetIpAssignmentsForNode2;
sqlite3_stmt *_sDeleteRelaysForNetwork;
sqlite3_stmt *_sCreateRelay;
sqlite3_stmt *_sDeleteIpAssignmentPoolsForNetwork;
sqlite3_stmt *_sDeleteRulesForNetwork;
sqlite3_stmt *_sCreateIpAssignmentPool;
sqlite3_stmt *_sDeleteMember;
sqlite3_stmt *_sDeleteNetworkAndRelated;
Mutex _lock;
};
} // namespace ZeroTier
#endif

104
controller/schema.sql Normal file
View File

@ -0,0 +1,104 @@
CREATE TABLE Config (
k varchar(16) PRIMARY KEY NOT NULL,
v varchar(1024) NOT NULL
);
CREATE TABLE IpAssignment (
networkId char(16) NOT NULL,
nodeId char(10) NOT NULL,
ip blob(16) NOT NULL,
ipNetmaskBits integer NOT NULL DEFAULT(0),
ipVersion integer NOT NULL DEFAULT(4)
);
CREATE INDEX IpAssignment_networkId_ip ON IpAssignment (networkId, ip);
CREATE INDEX IpAssignment_networkId_nodeId ON IpAssignment (networkId, nodeId);
CREATE INDEX IpAssignment_networkId ON IpAssignment (networkId);
CREATE TABLE IpAssignmentPool (
networkId char(16) NOT NULL,
ipNetwork blob(16) NOT NULL,
ipNetmaskBits integer NOT NULL,
ipVersion integer NOT NULL DEFAULT(4)
);
CREATE INDEX IpAssignmentPool_networkId ON IpAssignmentPool (networkId);
CREATE TABLE Member (
networkId char(16) NOT NULL,
nodeId char(10) NOT NULL,
authorized integer NOT NULL DEFAULT(0),
activeBridge integer NOT NULL DEFAULT(0)
);
CREATE INDEX Member_networkId ON Member (networkId);
CREATE INDEX Member_networkId_activeBridge ON Member(networkId, activeBridge);
CREATE UNIQUE INDEX Member_networkId_nodeId ON Member (networkId, nodeId);
CREATE TABLE MulticastRate (
networkId char(16) NOT NULL,
mgMac char(12) NOT NULL,
mgAdi integer NOT NULL DEFAULT(0),
preload integer NOT NULL,
maxBalance integer NOT NULL,
accrual integer NOT NULL
);
CREATE INDEX MulticastRate_networkId ON MulticastRate (networkId);
CREATE TABLE Network (
id char(16) PRIMARY KEY NOT NULL,
name varchar(128) NOT NULL,
private integer NOT NULL DEFAULT(1),
enableBroadcast integer NOT NULL DEFAULT(1),
allowPassiveBridging integer NOT NULL DEFAULT(0),
v4AssignMode varchar(8) NOT NULL DEFAULT('none'),
v6AssignMode varchar(8) NOT NULL DEFAULT('none'),
multicastLimit integer NOT NULL DEFAULT(32),
creationTime integer NOT NULL DEFAULT(0),
revision integer NOT NULL DEFAULT(1)
);
CREATE TABLE Relay (
networkId char(16) NOT NULL,
nodeId char(10) NOT NULL,
phyAddress varchar(64) NOT NULL
);
CREATE INDEX Relay_networkId ON Relay (networkId);
CREATE UNIQUE INDEX Relay_networkId_nodeId ON Relay (networkId, nodeId);
CREATE TABLE Node (
id char(10) PRIMARY KEY NOT NULL,
identity varchar(4096) NOT NULL,
lastAt varchar(64),
lastSeen integer NOT NULL DEFAULT(0),
firstSeen integer NOT NULL DEFAULT(0)
);
CREATE TABLE Rule (
networkId char(16) NOT NULL,
ruleId integer NOT NULL,
nodeId char(10),
vlanId integer,
vlanPcp integer,
etherType integer,
macSource char(12),
macDest char(12),
ipSource varchar(64),
ipDest varchar(64),
ipTos integer,
ipProtocol integer,
ipSourcePort integer,
ipDestPort integer,
flags integer,
invFlags integer,
"action" varchar(4096) NOT NULL DEFAULT('accept')
);
CREATE INDEX Rule_networkId ON Rule (networkId);

106
controller/schema.sql.c Normal file
View File

@ -0,0 +1,106 @@
#define ZT_NETCONF_SCHEMA_SQL \
"CREATE TABLE Config (\n"\
" k varchar(16) PRIMARY KEY NOT NULL,\n"\
" v varchar(1024) NOT NULL\n"\
");\n"\
"\n"\
"CREATE TABLE IpAssignment (\n"\
" networkId char(16) NOT NULL,\n"\
" nodeId char(10) NOT NULL,\n"\
" ip blob(16) NOT NULL,\n"\
" ipNetmaskBits integer NOT NULL DEFAULT(0),\n"\
" ipVersion integer NOT NULL DEFAULT(4)\n"\
");\n"\
"\n"\
"CREATE INDEX IpAssignment_networkId_ip ON IpAssignment (networkId, ip);\n"\
"\n"\
"CREATE INDEX IpAssignment_networkId_nodeId ON IpAssignment (networkId, nodeId);\n"\
"\n"\
"CREATE INDEX IpAssignment_networkId ON IpAssignment (networkId);\n"\
"\n"\
"CREATE TABLE IpAssignmentPool (\n"\
" networkId char(16) NOT NULL,\n"\
" ipNetwork blob(16) NOT NULL,\n"\
" ipNetmaskBits integer NOT NULL,\n"\
" ipVersion integer NOT NULL DEFAULT(4)\n"\
");\n"\
"\n"\
"CREATE INDEX IpAssignmentPool_networkId ON IpAssignmentPool (networkId);\n"\
"\n"\
"CREATE TABLE Member (\n"\
" networkId char(16) NOT NULL,\n"\
" nodeId char(10) NOT NULL,\n"\
" authorized integer NOT NULL DEFAULT(0),\n"\
" activeBridge integer NOT NULL DEFAULT(0)\n"\
");\n"\
"\n"\
"CREATE INDEX Member_networkId ON Member (networkId);\n"\
"\n"\
"CREATE INDEX Member_networkId_activeBridge ON Member(networkId, activeBridge);\n"\
"\n"\
"CREATE UNIQUE INDEX Member_networkId_nodeId ON Member (networkId, nodeId);\n"\
"\n"\
"CREATE TABLE MulticastRate (\n"\
" networkId char(16) NOT NULL,\n"\
" mgMac char(12) NOT NULL,\n"\
" mgAdi integer NOT NULL DEFAULT(0),\n"\
" preload integer NOT NULL,\n"\
" maxBalance integer NOT NULL,\n"\
" accrual integer NOT NULL\n"\
");\n"\
"\n"\
"CREATE INDEX MulticastRate_networkId ON MulticastRate (networkId);\n"\
"\n"\
"CREATE TABLE Network (\n"\
" id char(16) PRIMARY KEY NOT NULL,\n"\
" name varchar(128) NOT NULL,\n"\
" private integer NOT NULL DEFAULT(1),\n"\
" enableBroadcast integer NOT NULL DEFAULT(1),\n"\
" allowPassiveBridging integer NOT NULL DEFAULT(0),\n"\
" v4AssignMode varchar(8) NOT NULL DEFAULT('none'),\n"\
" v6AssignMode varchar(8) NOT NULL DEFAULT('none'),\n"\
" multicastLimit integer NOT NULL DEFAULT(32),\n"\
" creationTime integer NOT NULL DEFAULT(0),\n"\
" revision integer NOT NULL DEFAULT(1)\n"\
");\n"\
"\n"\
"CREATE TABLE Relay (\n"\
" networkId char(16) NOT NULL,\n"\
" nodeId char(10) NOT NULL,\n"\
" phyAddress varchar(64) NOT NULL\n"\
");\n"\
"\n"\
"CREATE INDEX Relay_networkId ON Relay (networkId);\n"\
"\n"\
"CREATE UNIQUE INDEX Relay_networkId_nodeId ON Relay (networkId, nodeId);\n"\
"\n"\
"CREATE TABLE Node (\n"\
" id char(10) PRIMARY KEY NOT NULL,\n"\
" identity varchar(4096) NOT NULL,\n"\
" lastAt varchar(64),\n"\
" lastSeen integer NOT NULL DEFAULT(0),\n"\
" firstSeen integer NOT NULL DEFAULT(0)\n"\
");\n"\
"\n"\
"CREATE TABLE Rule (\n"\
" networkId char(16) NOT NULL,\n"\
" ruleId integer NOT NULL,\n"\
" nodeId char(10),\n"\
" vlanId integer,\n"\
" vlanPcp integer,\n"\
" etherType integer,\n"\
" macSource char(12),\n"\
" macDest char(12),\n"\
" ipSource varchar(64),\n"\
" ipDest varchar(64),\n"\
" ipTos integer,\n"\
" ipProtocol integer,\n"\
" ipSourcePort integer,\n"\
" ipDestPort integer,\n"\
" flags integer,\n"\
" invFlags integer,\n"\
" \"action\" varchar(4096) NOT NULL DEFAULT('accept')\n"\
");\n"\
"\n"\
"CREATE INDEX Rule_networkId ON Rule (networkId);\n"\
""

8
controller/schema2c.sh Executable file
View File

@ -0,0 +1,8 @@
#!/bin/bash
# Run this file to package the .sql file into a .c file whenever the SQL changes.
rm -f schema.sql.c
echo '#define ZT_NETCONF_SCHEMA_SQL \' >schema.sql.c
cat schema.sql | sed 's/"/\\"/g' | sed 's/^/"/' | sed 's/$/\\n"\\/' >>schema.sql.c
echo '""' >>schema.sql.c

1
ext/README.md Normal file
View File

@ -0,0 +1 @@
The ext/ folder contains third party code, drivers, installation support files, etc.

View File

@ -1 +0,0 @@
ext/ contains external code, such as libraries, and scripts for building such.

Binary file not shown.

Binary file not shown.

Binary file not shown.

Binary file not shown.

View File

@ -0,0 +1,143 @@
;
; ZeroTier One Virtual Network Port NDIS6 Driver
;
; Based on the OpenVPN tap-windows6 driver version 9.21.1 git
; commit 48f027cfca52b16b5fd23d82e6016ed8a91fc4d3.
; See: https://github.com/OpenVPN/tap-windows6
;
; Modified by ZeroTier, Inc. - https://www.zerotier.com/
;
; (1) Comment out 'tun' functionality and related features such as DHCP
; emulation, since we don't use any of that. Just want straight 'tap'.
; (2) Added custom IOCTL to enumerate L2 multicast memberships.
; (3) Increase maximum number of multicast memberships to 128.
; (4) Set default and max device MTU to 2800.
; (5) Rename/rebrand driver as ZeroTier network port driver.
;
; Original copyright below. Modifications released under GPLv2 as well.
;
; ****************************************************************************
; * Copyright (C) 2002-2014 OpenVPN Technologies, Inc. *
; * This program is free software; you can redistribute it and/or modify *
; * it under the terms of the GNU General Public License version 2 *
; * as published by the Free Software Foundation. *
; ****************************************************************************
;
[Version]
Signature = "$Windows NT$"
CatalogFile = zttap300.cat
ClassGUID = {4d36e972-e325-11ce-bfc1-08002be10318}
Provider = %Provider%
Class = Net
DriverVer=04/25/2015,6.2.9200.20557
[Strings]
DeviceDescription = "ZeroTier One Virtual Port"
Provider = "ZeroTier Networks LLC" ; We're ZeroTier, Inc. now but kernel mode certs are $300+ so fuqdat.
; To build for x86, take NTamd64 off this and off the named section manually, build, then put it back!
[Manufacturer]
%Provider%=zttap300,NTamd64
[zttap300]
%DeviceDescription% = zttap300.ndi, root\zttap300 ; Root enumerated
%DeviceDescription% = zttap300.ndi, zttap300 ; Legacy
[zttap300.NTamd64]
%DeviceDescription% = zttap300.ndi, root\zttap300 ; Root enumerated
%DeviceDescription% = zttap300.ndi, zttap300 ; Legacy
;----------------- Characteristics ------------
; NCF_PHYSICAL = 0x04
; NCF_VIRTUAL = 0x01
; NCF_SOFTWARE_ENUMERATED = 0x02
; NCF_HIDDEN = 0x08
; NCF_NO_SERVICE = 0x10
; NCF_HAS_UI = 0x80
;----------------- Characteristics ------------
[zttap300.ndi]
CopyFiles = zttap300.driver, zttap300.files
AddReg = zttap300.reg
AddReg = zttap300.params.reg
Characteristics = 0x81
*IfType = 0x6 ; IF_TYPE_ETHERNET_CSMACD
*MediaType = 0x0 ; NdisMedium802_3
*PhysicalMediaType = 14 ; NdisPhysicalMedium802_3
[zttap300.ndi.Services]
AddService = zttap300, 2, zttap300.service
[zttap300.reg]
HKR, Ndi, Service, 0, "zttap300"
HKR, Ndi\Interfaces, UpperRange, 0, "ndis5" ; yes, 'ndis5' is correct... yup, Windows.
HKR, Ndi\Interfaces, LowerRange, 0, "ethernet"
HKR, , Manufacturer, 0, "%Provider%"
HKR, , ProductName, 0, "%DeviceDescription%"
[zttap300.params.reg]
HKR, Ndi\params\MTU, ParamDesc, 0, "MTU"
HKR, Ndi\params\MTU, Type, 0, "int"
HKR, Ndi\params\MTU, Default, 0, "2800"
HKR, Ndi\params\MTU, Optional, 0, "0"
HKR, Ndi\params\MTU, Min, 0, "100"
HKR, Ndi\params\MTU, Max, 0, "2800"
HKR, Ndi\params\MTU, Step, 0, "1"
HKR, Ndi\params\MediaStatus, ParamDesc, 0, "Media Status"
HKR, Ndi\params\MediaStatus, Type, 0, "enum"
HKR, Ndi\params\MediaStatus, Default, 0, "0"
HKR, Ndi\params\MediaStatus, Optional, 0, "0"
HKR, Ndi\params\MediaStatus\enum, "0", 0, "Application Controlled"
HKR, Ndi\params\MediaStatus\enum, "1", 0, "Always Connected"
HKR, Ndi\params\MAC, ParamDesc, 0, "MAC Address"
HKR, Ndi\params\MAC, Type, 0, "edit"
HKR, Ndi\params\MAC, Optional, 0, "1"
HKR, Ndi\params\AllowNonAdmin, ParamDesc, 0, "Non-Admin Access"
HKR, Ndi\params\AllowNonAdmin, Type, 0, "enum"
HKR, Ndi\params\AllowNonAdmin, Default, 0, "0"
HKR, Ndi\params\AllowNonAdmin, Optional, 0, "0"
HKR, Ndi\params\AllowNonAdmin\enum, "0", 0, "Not Allowed"
HKR, Ndi\params\AllowNonAdmin\enum, "1", 0, "Allowed"
;---------- Service Type -------------
; SERVICE_KERNEL_DRIVER = 0x01
; SERVICE_WIN32_OWN_PROCESS = 0x10
;---------- Service Type -------------
;---------- Start Mode ---------------
; SERVICE_BOOT_START = 0x0
; SERVICE_SYSTEM_START = 0x1
; SERVICE_AUTO_START = 0x2
; SERVICE_DEMAND_START = 0x3
; SERVICE_DISABLED = 0x4
;---------- Start Mode ---------------
[zttap300.service]
DisplayName = %DeviceDescription%
ServiceType = 1
StartType = 3
ErrorControl = 1
LoadOrderGroup = NDIS
ServiceBinary = %12%\zttap300.sys
;----------------- Copy Flags ------------
; COPYFLG_NOSKIP = 0x02
; COPYFLG_NOVERSIONCHECK = 0x04
;----------------- Copy Flags ------------
[SourceDisksNames]
1 = %DeviceDescription%, zttap300.sys
[SourceDisksFiles]
zttap300.sys = 1
[DestinationDirs]
zttap300.files = 11
zttap300.driver = 12
[zttap300.files]
;
[zttap300.driver]
zttap300.sys,,,6 ; COPYFLG_NOSKIP | COPYFLG_NOVERSIONCHECK

Binary file not shown.

Binary file not shown.

Binary file not shown.

View File

@ -0,0 +1,139 @@
;
; ZeroTier One Virtual Network Port NDIS6 Driver
;
; Based on the OpenVPN tap-windows6 driver version 9.21.1 git
; commit 48f027cfca52b16b5fd23d82e6016ed8a91fc4d3.
; See: https://github.com/OpenVPN/tap-windows6
;
; Modified by ZeroTier, Inc. - https://www.zerotier.com/
;
; (1) Comment out 'tun' functionality and related features such as DHCP
; emulation, since we don't use any of that. Just want straight 'tap'.
; (2) Added custom IOCTL to enumerate L2 multicast memberships.
; (3) Increase maximum number of multicast memberships to 128.
; (4) Set default and max device MTU to 2800.
; (5) Rename/rebrand driver as ZeroTier network port driver.
;
; Original copyright below. Modifications released under GPLv2 as well.
;
; ****************************************************************************
; * Copyright (C) 2002-2014 OpenVPN Technologies, Inc. *
; * This program is free software; you can redistribute it and/or modify *
; * it under the terms of the GNU General Public License version 2 *
; * as published by the Free Software Foundation. *
; ****************************************************************************
;
[Version]
Signature = "$Windows NT$"
CatalogFile = zttap300.cat
ClassGUID = {4d36e972-e325-11ce-bfc1-08002be10318}
Provider = %Provider%
Class = Net
DriverVer=04/25/2015,6.2.9200.20557
[Strings]
DeviceDescription = "ZeroTier One Virtual Port"
Provider = "ZeroTier Networks LLC" ; We're ZeroTier, Inc. now but kernel mode certs are $300+ so fuqdat.
; To build for x86, take NTamd64 off this and off the named section manually, build, then put it back!
[Manufacturer]
%Provider%=zttap300
[zttap300]
%DeviceDescription% = zttap300.ndi, root\zttap300 ; Root enumerated
%DeviceDescription% = zttap300.ndi, zttap300 ; Legacy
;----------------- Characteristics ------------
; NCF_PHYSICAL = 0x04
; NCF_VIRTUAL = 0x01
; NCF_SOFTWARE_ENUMERATED = 0x02
; NCF_HIDDEN = 0x08
; NCF_NO_SERVICE = 0x10
; NCF_HAS_UI = 0x80
;----------------- Characteristics ------------
[zttap300.ndi]
CopyFiles = zttap300.driver, zttap300.files
AddReg = zttap300.reg
AddReg = zttap300.params.reg
Characteristics = 0x81
*IfType = 0x6 ; IF_TYPE_ETHERNET_CSMACD
*MediaType = 0x0 ; NdisMedium802_3
*PhysicalMediaType = 14 ; NdisPhysicalMedium802_3
[zttap300.ndi.Services]
AddService = zttap300, 2, zttap300.service
[zttap300.reg]
HKR, Ndi, Service, 0, "zttap300"
HKR, Ndi\Interfaces, UpperRange, 0, "ndis5" ; yes, 'ndis5' is correct... yup, Windows.
HKR, Ndi\Interfaces, LowerRange, 0, "ethernet"
HKR, , Manufacturer, 0, "%Provider%"
HKR, , ProductName, 0, "%DeviceDescription%"
[zttap300.params.reg]
HKR, Ndi\params\MTU, ParamDesc, 0, "MTU"
HKR, Ndi\params\MTU, Type, 0, "int"
HKR, Ndi\params\MTU, Default, 0, "2800"
HKR, Ndi\params\MTU, Optional, 0, "0"
HKR, Ndi\params\MTU, Min, 0, "100"
HKR, Ndi\params\MTU, Max, 0, "2800"
HKR, Ndi\params\MTU, Step, 0, "1"
HKR, Ndi\params\MediaStatus, ParamDesc, 0, "Media Status"
HKR, Ndi\params\MediaStatus, Type, 0, "enum"
HKR, Ndi\params\MediaStatus, Default, 0, "0"
HKR, Ndi\params\MediaStatus, Optional, 0, "0"
HKR, Ndi\params\MediaStatus\enum, "0", 0, "Application Controlled"
HKR, Ndi\params\MediaStatus\enum, "1", 0, "Always Connected"
HKR, Ndi\params\MAC, ParamDesc, 0, "MAC Address"
HKR, Ndi\params\MAC, Type, 0, "edit"
HKR, Ndi\params\MAC, Optional, 0, "1"
HKR, Ndi\params\AllowNonAdmin, ParamDesc, 0, "Non-Admin Access"
HKR, Ndi\params\AllowNonAdmin, Type, 0, "enum"
HKR, Ndi\params\AllowNonAdmin, Default, 0, "0"
HKR, Ndi\params\AllowNonAdmin, Optional, 0, "0"
HKR, Ndi\params\AllowNonAdmin\enum, "0", 0, "Not Allowed"
HKR, Ndi\params\AllowNonAdmin\enum, "1", 0, "Allowed"
;---------- Service Type -------------
; SERVICE_KERNEL_DRIVER = 0x01
; SERVICE_WIN32_OWN_PROCESS = 0x10
;---------- Service Type -------------
;---------- Start Mode ---------------
; SERVICE_BOOT_START = 0x0
; SERVICE_SYSTEM_START = 0x1
; SERVICE_AUTO_START = 0x2
; SERVICE_DEMAND_START = 0x3
; SERVICE_DISABLED = 0x4
;---------- Start Mode ---------------
[zttap300.service]
DisplayName = %DeviceDescription%
ServiceType = 1
StartType = 3
ErrorControl = 1
LoadOrderGroup = NDIS
ServiceBinary = %12%\zttap300.sys
;----------------- Copy Flags ------------
; COPYFLG_NOSKIP = 0x02
; COPYFLG_NOVERSIONCHECK = 0x04
;----------------- Copy Flags ------------
[SourceDisksNames]
1 = %DeviceDescription%, zttap300.sys
[SourceDisksFiles]
zttap300.sys = 1
[DestinationDirs]
zttap300.files = 11
zttap300.driver = 12
[zttap300.files]
;
[zttap300.driver]
zttap300.sys,,,6 ; COPYFLG_NOSKIP | COPYFLG_NOVERSIONCHECK

Binary file not shown.

Binary file not shown.

63
ext/http-parser/AUTHORS Normal file
View File

@ -0,0 +1,63 @@
# Authors ordered by first contribution.
Ryan Dahl <ry@tinyclouds.org>
Jeremy Hinegardner <jeremy@hinegardner.org>
Sergey Shepelev <temotor@gmail.com>
Joe Damato <ice799@gmail.com>
tomika <tomika_nospam@freemail.hu>
Phoenix Sol <phoenix@burninglabs.com>
Cliff Frey <cliff@meraki.com>
Ewen Cheslack-Postava <ewencp@cs.stanford.edu>
Santiago Gala <sgala@apache.org>
Tim Becker <tim.becker@syngenio.de>
Jeff Terrace <jterrace@gmail.com>
Ben Noordhuis <info@bnoordhuis.nl>
Nathan Rajlich <nathan@tootallnate.net>
Mark Nottingham <mnot@mnot.net>
Aman Gupta <aman@tmm1.net>
Tim Becker <tim.becker@kuriositaet.de>
Sean Cunningham <sean.cunningham@mandiant.com>
Peter Griess <pg@std.in>
Salman Haq <salman.haq@asti-usa.com>
Cliff Frey <clifffrey@gmail.com>
Jon Kolb <jon@b0g.us>
Fouad Mardini <f.mardini@gmail.com>
Paul Querna <pquerna@apache.org>
Felix Geisendörfer <felix@debuggable.com>
koichik <koichik@improvement.jp>
Andre Caron <andre.l.caron@gmail.com>
Ivo Raisr <ivosh@ivosh.net>
James McLaughlin <jamie@lacewing-project.org>
David Gwynne <loki@animata.net>
Thomas LE ROUX <thomas@november-eleven.fr>
Randy Rizun <rrizun@ortivawireless.com>
Andre Louis Caron <andre.louis.caron@usherbrooke.ca>
Simon Zimmermann <simonz05@gmail.com>
Erik Dubbelboer <erik@dubbelboer.com>
Martell Malone <martellmalone@gmail.com>
Bertrand Paquet <bpaquet@octo.com>
BogDan Vatra <bogdan@kde.org>
Peter Faiman <peter@thepicard.org>
Corey Richardson <corey@octayn.net>
Tóth Tamás <tomika_nospam@freemail.hu>
Cam Swords <cam.swords@gmail.com>
Chris Dickinson <christopher.s.dickinson@gmail.com>
Uli Köhler <ukoehler@btronik.de>
Charlie Somerville <charlie@charliesomerville.com>
Patrik Stutz <patrik.stutz@gmail.com>
Fedor Indutny <fedor.indutny@gmail.com>
runner <runner.mei@gmail.com>
Alexis Campailla <alexis@janeasystems.com>
David Wragg <david@wragg.org>
Vinnie Falco <vinnie.falco@gmail.com>
Alex Butum <alexbutum@linux.com>
Rex Feng <rexfeng@gmail.com>
Alex Kocharin <alex@kocharin.ru>
Mark Koopman <markmontymark@yahoo.com>
Helge Heß <me@helgehess.eu>
Alexis La Goutte <alexis.lagoutte@gmail.com>
George Miroshnykov <george.miroshnykov@gmail.com>
Maciej Małecki <me@mmalecki.com>
Marc O'Morain <github.com@marcomorain.com>
Jeff Pinner <jpinner@twitter.com>
Timothy J Fontaine <tjfontaine@gmail.com>
Akagi201 <akagi201@gmail.com>

View File

@ -0,0 +1,23 @@
http_parser.c is based on src/http/ngx_http_parse.c from NGINX copyright
Igor Sysoev.
Additional changes are licensed under the same terms as NGINX and
copyright Joyent, Inc. and other Node contributors. All rights reserved.
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.

File diff suppressed because it is too large Load Diff

View File

@ -0,0 +1,335 @@
/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
*
* 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.
*/
#ifndef http_parser_h
#define http_parser_h
#ifdef __cplusplus
extern "C" {
#endif
/* Also update SONAME in the Makefile whenever you change these. */
#define HTTP_PARSER_VERSION_MAJOR 2
#define HTTP_PARSER_VERSION_MINOR 4
#define HTTP_PARSER_VERSION_PATCH 2
#include <sys/types.h>
#if defined(_WIN32) && !defined(__MINGW32__) && (!defined(_MSC_VER) || _MSC_VER<1600)
#include <BaseTsd.h>
#include <stddef.h>
typedef __int8 int8_t;
typedef unsigned __int8 uint8_t;
typedef __int16 int16_t;
typedef unsigned __int16 uint16_t;
typedef __int32 int32_t;
typedef unsigned __int32 uint32_t;
typedef __int64 int64_t;
typedef unsigned __int64 uint64_t;
#else
#include <stdint.h>
#endif
/* Compile with -DHTTP_PARSER_STRICT=0 to make less checks, but run
* faster
*/
#ifndef HTTP_PARSER_STRICT
# define HTTP_PARSER_STRICT 1
#endif
/* Maximium header size allowed. If the macro is not defined
* before including this header then the default is used. To
* change the maximum header size, define the macro in the build
* environment (e.g. -DHTTP_MAX_HEADER_SIZE=<value>). To remove
* the effective limit on the size of the header, define the macro
* to a very large number (e.g. -DHTTP_MAX_HEADER_SIZE=0x7fffffff)
*/
#ifndef HTTP_MAX_HEADER_SIZE
# define HTTP_MAX_HEADER_SIZE (80*1024)
#endif
typedef struct http_parser http_parser;
typedef struct http_parser_settings http_parser_settings;
/* Callbacks should return non-zero to indicate an error. The parser will
* then halt execution.
*
* The one exception is on_headers_complete. In a HTTP_RESPONSE parser
* returning '1' from on_headers_complete will tell the parser that it
* should not expect a body. This is used when receiving a response to a
* HEAD request which may contain 'Content-Length' or 'Transfer-Encoding:
* chunked' headers that indicate the presence of a body.
*
* http_data_cb does not return data chunks. It will be called arbitrarily
* many times for each string. E.G. you might get 10 callbacks for "on_url"
* each providing just a few characters more data.
*/
typedef int (*http_data_cb) (http_parser*, const char *at, size_t length);
typedef int (*http_cb) (http_parser*);
/* Request Methods */
#define HTTP_METHOD_MAP(XX) \
XX(0, DELETE, DELETE) \
XX(1, GET, GET) \
XX(2, HEAD, HEAD) \
XX(3, POST, POST) \
XX(4, PUT, PUT) \
/* pathological */ \
XX(5, CONNECT, CONNECT) \
XX(6, OPTIONS, OPTIONS) \
XX(7, TRACE, TRACE) \
/* webdav */ \
XX(8, COPY, COPY) \
XX(9, LOCK, LOCK) \
XX(10, MKCOL, MKCOL) \
XX(11, MOVE, MOVE) \
XX(12, PROPFIND, PROPFIND) \
XX(13, PROPPATCH, PROPPATCH) \
XX(14, SEARCH, SEARCH) \
XX(15, UNLOCK, UNLOCK) \
/* subversion */ \
XX(16, REPORT, REPORT) \
XX(17, MKACTIVITY, MKACTIVITY) \
XX(18, CHECKOUT, CHECKOUT) \
XX(19, MERGE, MERGE) \
/* upnp */ \
XX(20, MSEARCH, M-SEARCH) \
XX(21, NOTIFY, NOTIFY) \
XX(22, SUBSCRIBE, SUBSCRIBE) \
XX(23, UNSUBSCRIBE, UNSUBSCRIBE) \
/* RFC-5789 */ \
XX(24, PATCH, PATCH) \
XX(25, PURGE, PURGE) \
/* CalDAV */ \
XX(26, MKCALENDAR, MKCALENDAR) \
enum http_method
{
#define XX(num, name, string) HTTP_##name = num,
HTTP_METHOD_MAP(XX)
#undef XX
};
enum http_parser_type { HTTP_REQUEST, HTTP_RESPONSE, HTTP_BOTH };
/* Flag values for http_parser.flags field */
enum flags
{ F_CHUNKED = 1 << 0
, F_CONNECTION_KEEP_ALIVE = 1 << 1
, F_CONNECTION_CLOSE = 1 << 2
, F_CONNECTION_UPGRADE = 1 << 3
, F_TRAILING = 1 << 4
, F_UPGRADE = 1 << 5
, F_SKIPBODY = 1 << 6
};
/* Map for errno-related constants
*
* The provided argument should be a macro that takes 2 arguments.
*/
#define HTTP_ERRNO_MAP(XX) \
/* No error */ \
XX(OK, "success") \
\
/* Callback-related errors */ \
XX(CB_message_begin, "the on_message_begin callback failed") \
XX(CB_url, "the on_url callback failed") \
XX(CB_header_field, "the on_header_field callback failed") \
XX(CB_header_value, "the on_header_value callback failed") \
XX(CB_headers_complete, "the on_headers_complete callback failed") \
XX(CB_body, "the on_body callback failed") \
XX(CB_message_complete, "the on_message_complete callback failed") \
XX(CB_status, "the on_status callback failed") \
\
/* Parsing-related errors */ \
XX(INVALID_EOF_STATE, "stream ended at an unexpected time") \
XX(HEADER_OVERFLOW, \
"too many header bytes seen; overflow detected") \
XX(CLOSED_CONNECTION, \
"data received after completed connection: close message") \
XX(INVALID_VERSION, "invalid HTTP version") \
XX(INVALID_STATUS, "invalid HTTP status code") \
XX(INVALID_METHOD, "invalid HTTP method") \
XX(INVALID_URL, "invalid URL") \
XX(INVALID_HOST, "invalid host") \
XX(INVALID_PORT, "invalid port") \
XX(INVALID_PATH, "invalid path") \
XX(INVALID_QUERY_STRING, "invalid query string") \
XX(INVALID_FRAGMENT, "invalid fragment") \
XX(LF_EXPECTED, "LF character expected") \
XX(INVALID_HEADER_TOKEN, "invalid character in header") \
XX(INVALID_CONTENT_LENGTH, \
"invalid character in content-length header") \
XX(INVALID_CHUNK_SIZE, \
"invalid character in chunk size header") \
XX(INVALID_CONSTANT, "invalid constant string") \
XX(INVALID_INTERNAL_STATE, "encountered unexpected internal state")\
XX(STRICT, "strict mode assertion failed") \
XX(PAUSED, "parser is paused") \
XX(UNKNOWN, "an unknown error occurred")
/* Define HPE_* values for each errno value above */
#define HTTP_ERRNO_GEN(n, s) HPE_##n,
enum http_errno {
HTTP_ERRNO_MAP(HTTP_ERRNO_GEN)
};
#undef HTTP_ERRNO_GEN
/* Get an http_errno value from an http_parser */
#define HTTP_PARSER_ERRNO(p) ((enum http_errno) (p)->http_errno)
struct http_parser {
/** PRIVATE **/
unsigned int type : 2; /* enum http_parser_type */
unsigned int flags : 7; /* F_* values from 'flags' enum; semi-public */
unsigned int state : 7; /* enum state from http_parser.c */
unsigned int header_state : 8; /* enum header_state from http_parser.c */
unsigned int index : 8; /* index into current matcher */
uint32_t nread; /* # bytes read in various scenarios */
uint64_t content_length; /* # bytes in body (0 if no Content-Length header) */
/** READ-ONLY **/
unsigned short http_major;
unsigned short http_minor;
unsigned int status_code : 16; /* responses only */
unsigned int method : 8; /* requests only */
unsigned int http_errno : 7;
/* 1 = Upgrade header was present and the parser has exited because of that.
* 0 = No upgrade header present.
* Should be checked when http_parser_execute() returns in addition to
* error checking.
*/
unsigned int upgrade : 1;
/** PUBLIC **/
void *data; /* A pointer to get hook to the "connection" or "socket" object */
};
struct http_parser_settings {
http_cb on_message_begin;
http_data_cb on_url;
http_data_cb on_status;
http_data_cb on_header_field;
http_data_cb on_header_value;
http_cb on_headers_complete;
http_data_cb on_body;
http_cb on_message_complete;
};
enum http_parser_url_fields
{ UF_SCHEMA = 0
, UF_HOST = 1
, UF_PORT = 2
, UF_PATH = 3
, UF_QUERY = 4
, UF_FRAGMENT = 5
, UF_USERINFO = 6
, UF_MAX = 7
};
/* Result structure for http_parser_parse_url().
*
* Callers should index into field_data[] with UF_* values iff field_set
* has the relevant (1 << UF_*) bit set. As a courtesy to clients (and
* because we probably have padding left over), we convert any port to
* a uint16_t.
*/
struct http_parser_url {
uint16_t field_set; /* Bitmask of (1 << UF_*) values */
uint16_t port; /* Converted UF_PORT string */
struct {
uint16_t off; /* Offset into buffer in which field starts */
uint16_t len; /* Length of run in buffer */
} field_data[UF_MAX];
};
/* Returns the library version. Bits 16-23 contain the major version number,
* bits 8-15 the minor version number and bits 0-7 the patch level.
* Usage example:
*
* unsigned long version = http_parser_version();
* unsigned major = (version >> 16) & 255;
* unsigned minor = (version >> 8) & 255;
* unsigned patch = version & 255;
* printf("http_parser v%u.%u.%u\n", major, minor, patch);
*/
unsigned long http_parser_version(void);
void http_parser_init(http_parser *parser, enum http_parser_type type);
/* Initialize http_parser_settings members to 0
*/
void http_parser_settings_init(http_parser_settings *settings);
/* Executes the parser. Returns number of parsed bytes. Sets
* `parser->http_errno` on error. */
size_t http_parser_execute(http_parser *parser,
const http_parser_settings *settings,
const char *data,
size_t len);
/* If http_should_keep_alive() in the on_headers_complete or
* on_message_complete callback returns 0, then this should be
* the last message on the connection.
* If you are the server, respond with the "Connection: close" header.
* If you are the client, close the connection.
*/
int http_should_keep_alive(const http_parser *parser);
/* Returns a string version of the HTTP method. */
const char *http_method_str(enum http_method m);
/* Return a string name of the given error */
const char *http_errno_name(enum http_errno err);
/* Return a string description of the given error */
const char *http_errno_description(enum http_errno err);
/* Parse a URL; return nonzero on failure */
int http_parser_parse_url(const char *buf, size_t buflen,
int is_connect,
struct http_parser_url *u);
/* Pause or un-pause the parser; a nonzero value pauses */
void http_parser_pause(http_parser *parser, int paused);
/* Checks if this is the final chunk of the body. */
int http_body_is_final(const http_parser *parser);
#ifdef __cplusplus
}
#endif
#endif

View File

View File

@ -0,0 +1,10 @@
Package: zerotier-one
Architecture: __ARCH__
Maintainer: ZeroTier, Inc. <contact@zerotier.com>
Priority: optional
Version: __VERSION__
Homepage: https://github.com/zerotier/ZeroTierOne
Description: ZeroTier One network virtualization service
ZeroTier One is a fast, secure, and easy to use peer to peer network
virtualization engine. Visit https://www.zerotier.com/ for more
information.

View File

@ -0,0 +1,34 @@
Name: zerotier-one
Summary: ZeroTier One network virtualization service
Version: __VERSION__
Release: 1%{?dist}
License: GPLv3
URL: https://www.zerotier.com/
%description
ZeroTier One creates virtual Ethernet networks that work anywhere and everywhere.
Visit https://www.zerotier.com/ for more information.
%prep
mkdir -p $RPM_BUILD_ROOT/var/lib/zerotier-one/updates.d
cp -f $OLDPWD/__INSTALLER__ $RPM_BUILD_ROOT/var/lib/zerotier-one/updates.d
%pre
mkdir -p /var/lib/zerotier-one/updates.d
%files
/var/lib/zerotier-one/updates.d/__INSTALLER__
%post
chmod 0755 /var/lib/zerotier-one/updates.d/__INSTALLER__
/var/lib/zerotier-one/updates.d/__INSTALLER__
%preun
if [ "$1" -lt 1 ]; then
/var/lib/zerotier-one/uninstall.sh
fi
%clean
cp -f %{_rpmdir}/%{_arch}/%{name}-%{version}-%{release}.%{_arch}.rpm $OLDPWD
rm -f %{_rpmdir}/%{_arch}/%{name}-%{version}-%{release}.%{_arch}.rpm
rm -rf $RPM_BUILD_ROOT

View File

@ -31,16 +31,20 @@ case "$system" in
# Canonicalize $machine for some architectures... we use x86
# and x64 for Intel stuff. ARM and others should be fine if
# we ever ship officially for those.
debian_arch=$machine
case "$machine" in
i386|i486|i586|i686)
machine="x86"
debian_arch="i386"
;;
x86_64|amd64|x64)
machine="x64"
debian_arch="amd64"
;;
armv6l|arm|armhf)
machine="armv6l"
debian_arch="armhf"
;;
*)
echo "Unsupported machine type: $machine"
exit 2
esac
echo "Assembling Linux installer for $machine and version $vmajor.$vminor.$revision"
@ -64,32 +68,55 @@ case "$system" in
rm -f build-installer-tmp.tar.gz
ls -l $targ
;;
if [ -f /usr/bin/dpkg-deb -a "$UID" -eq 0 ]; then
echo
echo Found dpkg-deb and you are root, trying to build Debian package.
Darwin)
echo "Assembling mac installer for x86/x64 (combined) version $vmajor.$vminor.$revision"
rm -rf build-installer-deb
mkdir -p 'build-installer/Applications'
cp -a 'build-ZeroTierUI-release/ZeroTier One.app' 'build-installer/Applications'
mkdir -p 'build-installer/Library/Application Support/ZeroTier/One'
cp -fp 'ext/installfiles/mac/uninstall.sh' 'build-installer/Library/Application Support/ZeroTier/One'
cp -fp 'ext/installfiles/mac/launch.sh' 'build-installer/Library/Application Support/ZeroTier/One'
cp -fp 'zerotier-one' 'build-installer/Library/Application Support/ZeroTier/One'
cp -fRp ext/bin/tap-mac/* 'build-installer/Library/Application Support/ZeroTier/One'
mkdir -p 'build-installer/Library/LaunchDaemons'
cp -fp 'ext/installfiles/mac/com.zerotier.one.plist' 'build-installer/Library/LaunchDaemons'
debbase="build-installer-deb/zerotier-one_${vmajor}.${vminor}.${revision}_$debian_arch"
debfolder="${debbase}/DEBIAN"
mkdir -p $debfolder
targ="ZeroTierOneInstaller-mac-combined-${vmajor}_${vminor}_${revision}"
rm -f build-installer-tmp.tar.bz2
cd build-installer
find . -type f -name .DS_Store -print0 | xargs -0 rm -f
tar -cf - * | bzip2 -9 >../build-installer-tmp.tar.bz2
cd ..
rm -f $targ
cat ext/installfiles/mac/install.tmpl.sh build-installer-tmp.tar.bz2 >$targ
chmod 0755 $targ
rm -f build-installer-tmp.tar.bz2
ls -l $targ
cat 'ext/installfiles/linux/DEBIAN/control.in' | sed "s/__VERSION__/${vmajor}.${vminor}.${revision}/" | sed "s/__ARCH__/${debian_arch}/" >$debfolder/control
cat $debfolder/control
cp -f 'ext/installfiles/linux/DEBIAN/conffiles' "${debfolder}/conffiles"
mkdir -p "${debbase}/var/lib/zerotier-one/updates.d"
cp -f $targ "${debbase}/var/lib/zerotier-one/updates.d"
rm -f "${debfolder}/postinst" "${debfolder}/prerm"
echo '#!/bin/bash' >${debfolder}/postinst
echo "/var/lib/zerotier-one/updates.d/${targ}" >>${debfolder}/postinst
echo "/bin/rm -f /var/lib/zerotier-one/updates.d/*" >>${debfolder}/postinst
chmod a+x ${debfolder}/postinst
echo '#!/bin/bash' >${debfolder}/prerm
echo 'export PATH=/bin:/usr/bin:/usr/local/bin:/sbin:/usr/sbin' >>${debfolder}/prerm
echo 'if [ "$1" != "upgrade" ]; then' >>${debfolder}/prerm
echo ' /var/lib/zerotier-one/uninstall.sh' >>${debfolder}/prerm
echo 'fi' >>${debfolder}/prerm
chmod a+x ${debfolder}/prerm
dpkg-deb --build $debbase
mv -f build-installer-deb/*.deb .
rm -rf build-installer-deb
fi
if [ -f /usr/bin/rpmbuild ]; then
echo
echo Found rpmbuild, trying to build RedHat/CentOS package.
rm -f /tmp/zerotier-one.spec
curr_dir=`pwd`
cat ext/installfiles/linux/RPM/zerotier-one.spec.in | sed "s/__VERSION__/${vmajor}.${vminor}.${revision}/g" | sed "s/__INSTALLER__/${targ}/g" >/tmp/zerotier-one.spec
rpmbuild -ba /tmp/zerotier-one.spec
rm -f /tmp/zerotier-one.spec
fi
;;
@ -99,4 +126,6 @@ case "$system" in
esac
rm -rf build-installer
exit 0

View File

@ -30,7 +30,7 @@ zthome=/var/lib/zerotier-one
# better in a ps listing.
export PATH=/bin:/usr/bin:/sbin:/usr/sbin:$zthome
if [ "$UID" -ne 0 ]; then
if [ "`id -u`" -ne 0 ]; then
echo "Init script must be called as root."
exit 4
fi
@ -47,7 +47,8 @@ fi
running=0
if [ "$pid" -gt 0 ]; then
if [ -n "`ls -l /proc/$pid/exe | grep -F zerotier-one`" ]; then
exepath=`readlink /proc/$pid/exe 2>/dev/null | grep zerotier-one`
if [ -n "$exepath" ]; then
running=1
fi
fi
@ -59,14 +60,23 @@ case "$1" in
exit 0
fi
echo "Starting ZeroTier One..."
nohup zerotier-one >>/dev/null 2>&1 &
disown %1
exit 0
zerotier-one -d
;;
stop)
if [ $running -gt 0 ]; then
echo "Stopping ZeroTier One..."
kill -TERM $pid
sleep 0.25
if [ -f "$zthome/zerotier-one.pid" ]; then
sleep 0.5
fi
if [ -f "$zthome/zerotier-one.pid" ]; then
sleep 1
fi
if [ -f "$zthome/zerotier-one.pid" ]; then
kill -KILL $pid >>/dev/null 2>&1
rm -f "$zthome/zerotier-one.pid"
fi
else
echo "ZeroTier One is not running."
fi
@ -74,11 +84,20 @@ case "$1" in
restart|reload|force-reload|condrestart|try-restart)
echo "Restarting ZeroTier One..."
if [ $running -gt 0 ]; then
kill -TERM $pid
kill -TERM $pid >>/dev/null 2>&1
fi
while [ -f "$zthome/zerotier-one.pid" ]; do sleep 1; done
nohup zerotier-one >>/dev/null 2>&1 &
disown %1
sleep 0.25
if [ -f "$zthome/zerotier-one.pid" ]; then
sleep 0.5
fi
if [ -f "$zthome/zerotier-one.pid" ]; then
sleep 1
fi
if [ -f "$zthome/zerotier-one.pid" ]; then
kill -KILL $pid >>/dev/null 2>&1
rm -f "$zthome/zerotier-one.pid"
fi
zerotier-one -d
;;
status)
if [ $running -gt 0 ]; then

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