Add peer node sync status in GUI (fixes #46)

.gitattributes

@@ -1,8 +0,0 @@
-# Text files use LF line endings in this repository
-*   text=auto
-
-# Except the dependencies, which we leave alone
-vendor/**   -text=auto
-
-# Diffs on these files are meaningless
-*.svg           -diff

.gitignore

@@ -1,17 +1,3 @@
-/syncthing
-/discosrv
-syncthing.exe
-discosrv.exe
+syncthing
 *.tar.gz
-*.zip
-*.asc
-.jshintrc
-coverage.out
-files/pidx
-bin
-perfstats*.csv
-coverage.xml
-syncthing.sig
-RELEASE
-deb
-lib/auto/gui.files.go
+dist

.mailmap

@@ -1 +0,0 @@
-NICKS

AUTHORS

@@ -1,97 +0,0 @@
-# This is the official list of Syncthing authors for copyright purposes.
-# The format is:
-#
-#    Name Name Name (nickname) <email1@example.com> <email2@example.com>
-#
-# The NICKS list is auto generated from this file.
-
-Aaron Bieber (qbit) <qbit@deftly.net>
-Adam Piggott (simplypeachy) <aD@simplypeachy.co.uk> <simplypeachy@users.noreply.github.com>
-Alessandro G. (alessandro.g89) <alessandro.g89@gmail.com>
-Alexander Graf (alex2108) <register-github@alex-graf.de>
-Alexandre Viau (aviau) <alexandre@alexandreviau.net> <aviau@debian.org>
-Anderson Mesquita (andersonvom) <andersonvom@gmail.com>
-Andrew Dunham (andrew-d) <andrew@du.nham.ca>
-Andrey D (scienmind) <scintertech@cryptolab.net>
-Antony Male (canton7) <antony.male@gmail.com>
-Arthur Axel fREW Schmidt (frioux) <frew@afoolishmanifesto.com> <frioux@gmail.com>
-Audrius Butkevicius (AudriusButkevicius) <audrius.butkevicius@gmail.com>
-Bart De Vries (mogwa1) <devriesb@gmail.com>
-Ben Curthoys (bencurthoys) <ben@bencurthoys.com>
-Ben Schulz (uok) <ueomkail@gmail.com> <uok@users.noreply.github.com>
-Ben Sidhom (bsidhom) <bsidhom@gmail.com>
-Benny Ng (tpng) <benny.tpng@gmail.com>
-Brandon Philips (philips) <brandon@ifup.org>
-Brendan Long (brendanlong) <self@brendanlong.com>
-Brian R. Becker (brbecker) <brbecker@gmail.com>
-Caleb Callaway (cqcallaw) <enlightened.despot@gmail.com>
-Carsten Hagemann (Moter8) <moter8@gmail.com>
-Cathryne Linenweaver (Cathryne) <cathryne.linenweaver@gmail.com> <Cathryne@users.noreply.github.com>
-Chris Howie (cdhowie) <me@chrishowie.com>
-Chris Joel (cdata) <chris@scriptolo.gy>
-Colin Kennedy (moshen) <moshen.colin@gmail.com>
-Daniel Bergmann (brgmnn) <dan.arne.bergmann@gmail.com> <brgmnn@users.noreply.github.com>
-Daniel Harte (norgeous) <daniel@harte.me> <daniel@danielharte.co.uk> <norgeous@users.noreply.github.com>
-Daniel Martí (mvdan) <mvdan@mvdan.cc>
-David Rimmer (dinosore) <dinosore@dbrsoftware.co.uk>
-Denis A. (dva) <denisva@gmail.com>
-Dennis Wilson (snnd) <dw@risu.io>
-Dominik Heidler (asdil12) <dominik@heidler.eu>
-Elias Jarlebring (jarlebring) <jarlebring@gmail.com>
-Emil Hessman (ceh) <emil@hessman.se>
-Erik Meitner (WSGCSysadmin) <e.meitner@willystreet.coop>
-Federico Castagnini (facastagnini) <federico.castagnini@gmail.com>
-Felix Ableitner (Nutomic) <me@nutomic.com>
-Felix Unterpaintner (bigbear2nd) <bigbear2nd@gmail.com>
-Francois-Xavier Gsell (zukoo) <fxgsell@gmail.com>
-Frank Isemann (fti7) <frank@isemann.name>
-Gilli Sigurdsson (gillisig) <gilli@vx.is>
-Jaakko Hannikainen (jgke) <jgke@jgke.fi>
-Jacek Szafarkiewicz (hadogenes) <szafar@linux.pl>
-Jake Peterson (acogdev) <jake@acogdev.com>
-Jakob Borg (calmh) <jakob@nym.se>
-James Patterson (jpjp) <jamespatterson@operamail.com> <jpjp@users.noreply.github.com>
-Jaroslav Malec (dzarda) <dzardacz@gmail.com>
-Jens Diemer (jedie) <github.com@jensdiemer.de> <git@jensdiemer.de>
-Jochen Voss (seehuhn) <voss@seehuhn.de>
-Johan Vromans (sciurius) <jvromans@squirrel.nl>
-Karol Różycki (krozycki) <rozycki.karol@gmail.com>
-Kelong Cong (kc1212) <kc04bc@gmx.com> <kc1212@users.noreply.github.com>
-Ken'ichi Kamada (kamadak) <kamada@nanohz.org>
-Kevin Allen (ironmig) <kma1660@gmail.com>
-Lars K.W. Gohlke (lkwg82) <lkwg82@gmx.de>
-Laurent Etiemble (letiemble) <laurent.etiemble@gmail.com> <laurent.etiemble@monobjc.net>
-Lode Hoste (Zillode) <zillode@zillode.be>
-Lord Landon Agahnim (LordLandon) <lordlandon@gmail.com>
-Majed Abdulaziz (majedev) <majed.alhajry@gmail.com>
-Marc Laporte (marclaporte) <marc@marclaporte.com> <marc@laporte.name>
-Marc Pujol (kilburn) <kilburn@la3.org>
-Marcin Dziadus (marcindziadus) <dziadus.marcin@gmail.com>
-Mateusz Naściszewski (mateon1) <matin1111@wp.pl>
-Matt Burke (burkemw3) <mburke@amplify.com> <burkemw3@gmail.com>
-Max Schulze (kralo) <max.schulze@online.de> <kralo@users.noreply.github.com>
-Michael Jephcote (Rewt0r) <rewt0r@gmx.com> <Rewt0r@users.noreply.github.com>
-Michael Ploujnikov (plouj) <ploujj@gmail.com>
-Michael Tilli (pyfisch) <pyfisch@gmail.com>
-Nate Morrison (nrm21) <natemorrison@gmail.com>
-Pascal Jungblut (pascalj) <github@pascalj.com> <mail@pascal-jungblut.com>
-Peter Hoeg (peterhoeg) <peter@speartail.com>
-Philippe Schommers (filoozoom) <philippe@schommers.be>
-Phill Luby (pluby) <phill.luby@newredo.com>
-Piotr Bejda (piobpl) <piotrb10@gmail.com>
-Ryan Sullivan (KayoticSully) <kayoticsully@gmail.com>
-Scott Klupfel (kluppy) <kluppy@going2blue.com>
-Sergey Mishin (ralder) <ralder@yandex.ru>
-Stefan Kuntz (Stefan-Code) <stefan.github@gmail.com> <Stefan.github@gmail.com>
-Stefan Tatschner (rumpelsepp) <stefan@sevenbyte.org> <rumpelsepp@sevenbyte.org>
-Tim Abell (timabell) <tim@timwise.co.uk>
-Tobias Nygren (tnn2) <tnn@nygren.pp.se>
-Tomas Cerveny (kozec) <kozec@kozec.com>
-Tully Robinson (tojrobinson) <tully@tojr.org>
-Tyler Brazier (tylerbrazier) <tyler@tylerbrazier.com>
-Veeti Paananen (veeti) <veeti.paananen@rojekti.fi>
-Victor Buinsky (buinsky) <vix_booja@tut.by>
-Vil Brekin (Vilbrekin) <vilbrekin@gmail.com>
-William A. Kennington III (wkennington) <william@wkennington.com>
-Wulf Weich (wweich) <wweich@users.noreply.github.com> <wweich@gmx.de>
-Yannic A. (eipiminus1) <eipiminusone+github@gmail.com> <eipiminus1@users.noreply.github.com>

CONDUCT.md

@@ -1,92 +0,0 @@
-## Conduct
-
-* We are committed to providing a friendly, safe and welcoming
-  environment for all, regardless of gender, sexual orientation,
-  disability, ethnicity, religion, or similar personal characteristic.
-
-* On IRC, please avoid using overtly sexual nicknames or other nicknames
-  that might detract from a friendly, safe and welcoming environment for
-  all.
-
-* Please be kind and courteous. There's no need to be mean or rude.
-
-* Respect that people have differences of opinion and that every design
-  or implementation choice carries a trade-off and numerous costs. There
-  is seldom a right answer.
-
-* Please keep unstructured critique to a minimum. If you have solid
-  ideas you want to experiment with, make a fork and see how it works.
-
-* We will exclude you from interaction if you insult, demean or harass
-  anyone. That is not welcome behaviour. We interpret the term
-  "harassment" as including the definition in the <a
-  href="http://citizencodeofconduct.org/">Citizen Code of Conduct</a>;
-  if you have any lack of clarity about what might be included in that
-  concept, please read their definition. In particular, we don't
-  tolerate behavior that excludes people in socially marginalized
-  groups.
-
-* Private harassment is also unacceptable. No matter who you are, if you
-  feel you have been or are being harassed or made uncomfortable by a
-  community member, please contact one of the channel ops or any of the
-  Syncthing core team immediately. Whether you're a regular  contributor
-  or a newcomer, we care about making this community a safe place for
-  you and we've got your back.
-
-* Likewise any spamming, trolling, flaming, baiting or other
-  attention-stealing behaviour is not welcome.
-
-## Moderation
-
-These are the policies for upholding our community's standards of
-conduct in our communication channels, most notably in Syncthing-related
-IRC channels and on the web forum.
-
-1. Remarks that violate the Syncthing standards of conduct, including
-   hateful, hurtful, oppressive, or exclusionary remarks, are not
-   allowed. (Cursing is allowed, but never targeting another user, and
-   never in a hateful manner.)
-
-2. Remarks that moderators find inappropriate, whether listed in the
-   code of conduct or not, are also not allowed.
-
-3. Moderators will first respond to such remarks with a warning.
-
-4. If the warning is unheeded, the user will be "kicked," i.e., kicked
-   out of the communication channel to cool off.
-
-5. If the user comes back and continues to make trouble, they will be
-   banned, i.e., indefinitely excluded.
-
-6. Moderators may choose at their discretion to un-ban the user if it
-   was a first offense and they offer the offended party a genuine
-   apology.
-
-7. If a moderator bans someone and you think it was unjustified, please
-   take it up with that moderator, or with a different moderator, **in
-   private**. Complaints about bans in-channel are not allowed.
-
-8. Moderators are held to a higher standard than other community
-   members. If a moderator creates an inappropriate situation, they
-   should expect less leeway than others.
-
-In the Syncthing community we strive to go the extra step to look out
-for each other. Don't just aim to be technically unimpeachable, try to
-be your best self. In particular, avoid flirting with offensive or
-sensitive issues, particularly if they're off-topic; this all too
-often leads to unnecessary fights, hurt feelings, and damaged trust;
-worse, it can drive people away from the community entirely.
-
-And if someone takes issue with something you said or did, resist the
-urge to be defensive. Just stop doing what it was they complained about
-and apologize. Even if you feel you were misinterpreted or unfairly
-accused, chances are good there was something you could've communicated
-better — remember that it's your responsibility to make your fellow
-community members comfortable. Everyone wants to get along and we are
-all here first and foremost because we want to talk about cool
-technology. You will find that people will be eager to assume good
-intent and forgive as long as you earn their trust.
-
-*Adapted from the [Rust Code of Conduct](https://github.com/rust-lang/rust/wiki/Note-development-policy#conduct)*
-
-*Adapted from the [Node.js Policy on Trolling](http://blog.izs.me/post/30036893703/policy-on-trolling)*

CONTRIBUTING.md

@@ -1,63 +1,22 @@
-## Reporting Bugs
+Please do contribute!
 
-Please file bugs in the [Github Issue
-Tracker](https://github.com/syncthing/syncthing/issues). Include at
-least the following:
+## Building
 
- - What happened
+[See the wiki](https://github.com/calmh/syncthing/wiki/Building)
 
- - What did you expect to happen instead of what *did* happen, if it's
-   not crazy obvious
+## Tests
 
- - What operating system, operating system version and version of
-   Syncthing you are running
+Yes please!
 
- - The same for other connected devices, where relevant
+## Style
 
- - Screenshot if the issue concerns something visible in the GUI
+`go fmt`
 
- - Console log entries, where possible and relevant
+## Documentation
 
-If you're not sure whether something is relevant, erring on the side of
-too much information will never get you yelled at. :)
+[Hack it here](https://github.com/calmh/syncthing/wiki)
 
-## Contributing Translations
+## License
 
-All translations are done via
-[Transifex](https://www.transifex.com/projects/p/syncthing/). If you
-wish to contribute to a translation, just head over there and sign up.
-Before every release, the language resources are updated from the
-latest info on Transifex.
-
-## Contributing Code
-
-Every contribution is welcome. If you want to contribute but are unsure
-where to start, any open issues are fair game! See the [Contribution
-Guidelines](http://docs.syncthing.net/dev/contributing.html) for the full
-story on committing code.
-
-## Contributing Documentation
-
-Updates to the [documentation site](http://docs.syncthing.net/) can be
-made as pull requests on the [documentation
-repository](https://github.com/syncthing/docs).
-
-## Licensing
-
-All contributions are made available under the same license as the already
-existing material being contributed to. For most of the project and unless
-otherwise stated this means MPLv2, but there are exceptions:
-
-- Certain commands (under cmd/...) may have a separate license, indicated by
-  the presence of a LICENSE file in the corresponding directory.
-
-- The documentation (man/...) is licensed under the Creative Commons
-  Attribution 4.0 International License.
-
-- Projects under vendor/... are copyright by and licensed from their
-  respective original authors. Contributions should be made to the original
-  project, not here.
-
-Regardless of the license in effect, you retain the copyright to your
-contribution.
+MIT
 

ISSUE_TEMPLATE.md

@@ -1,28 +0,0 @@
-Do not report security issues in this bug tracker. Instead, contact
-security@syncthing.net directly - see https://syncthing.net/security.html
-for more information.
-
-If your issue is a support request ("How do I get my devices to connect?"
-or similar), please use the support forum at https://forum.syncthing.net/
-where a large number of helpful people hang out. This issue tracker is for
-reporting bugs or feature requests directly to the developers.
-
-If your issue is a bug report, replace this boilerplate with a description
-of the problem, being sure to include at least:
-
- - what happened,
- - what you expected to happen instead, and
- - any steps to reproduce the problem.
-
-Also fill out the version information below and add log output or
-screenshots as appropriate.
-
-If your issue is a feature request, simply replace this template text in
-its entirety.
-
-### Version Information
-
-Syncthing Version: v0.x.y
-OS Version: Windows 7 / Ubuntu 14.04 / ...
-Browser Version: (if applicable, for GUI issues)
-

LICENSE

@@ -1,373 +1,19 @@
-Mozilla Public License Version 2.0
-==================================
-
-1. Definitions
---------------
-
-1.1. "Contributor"
-    means each individual or legal entity that creates, contributes to
-    the creation of, or owns Covered Software.
-
-1.2. "Contributor Version"
-    means the combination of the Contributions of others (if any) used
-    by a Contributor and that particular Contributor's Contribution.
-
-1.3. "Contribution"
-    means Covered Software of a particular Contributor.
-
-1.4. "Covered Software"
-    means Source Code Form to which the initial Contributor has attached
-    the notice in Exhibit A, the Executable Form of such Source Code
-    Form, and Modifications of such Source Code Form, in each case
-    including portions thereof.
-
-1.5. "Incompatible With Secondary Licenses"
-    means
-
-    (a) that the initial Contributor has attached the notice described
-        in Exhibit B to the Covered Software; or
-
-    (b) that the Covered Software was made available under the terms of
-        version 1.1 or earlier of the License, but not also under the
-        terms of a Secondary License.
-
-1.6. "Executable Form"
-    means any form of the work other than Source Code Form.
-
-1.7. "Larger Work"
-    means a work that combines Covered Software with other material, in
-    a separate file or files, that is not Covered Software.
-
-1.8. "License"
-    means this document.
-
-1.9. "Licensable"
-    means having the right to grant, to the maximum extent possible,
-    whether at the time of the initial grant or subsequently, any and
-    all of the rights conveyed by this License.
-
-1.10. "Modifications"
-    means any of the following:
-
-    (a) any file in Source Code Form that results from an addition to,
-        deletion from, or modification of the contents of Covered
-        Software; or
-
-    (b) any new file in Source Code Form that contains any Covered
-        Software.
-
-1.11. "Patent Claims" of a Contributor
-    means any patent claim(s), including without limitation, method,
-    process, and apparatus claims, in any patent Licensable by such
-    Contributor that would be infringed, but for the grant of the
-    License, by the making, using, selling, offering for sale, having
-    made, import, or transfer of either its Contributions or its
-    Contributor Version.
-
-1.12. "Secondary License"
-    means either the GNU General Public License, Version 2.0, the GNU
-    Lesser General Public License, Version 2.1, the GNU Affero General
-    Public License, Version 3.0, or any later versions of those
-    licenses.
-
-1.13. "Source Code Form"
-    means the form of the work preferred for making modifications.
-
-1.14. "You" (or "Your")
-    means an individual or a legal entity exercising rights under this
-    License. For legal entities, "You" includes any entity that
-    controls, is controlled by, or is under common control with You. For
-    purposes of this definition, "control" means (a) the power, direct
-    or indirect, to cause the direction or management of such entity,
-    whether by contract or otherwise, or (b) ownership of more than
-    fifty percent (50%) of the outstanding shares or beneficial
-    ownership of such entity.
-
-2. License Grants and Conditions
---------------------------------
-
-2.1. Grants
-
-Each Contributor hereby grants You a world-wide, royalty-free,
-non-exclusive license:
-
-(a) under intellectual property rights (other than patent or trademark)
-    Licensable by such Contributor to use, reproduce, make available,
-    modify, display, perform, distribute, and otherwise exploit its
-    Contributions, either on an unmodified basis, with Modifications, or
-    as part of a Larger Work; and
-
-(b) under Patent Claims of such Contributor to make, use, sell, offer
-    for sale, have made, import, and otherwise transfer either its
-    Contributions or its Contributor Version.
-
-2.2. Effective Date
-
-The licenses granted in Section 2.1 with respect to any Contribution
-become effective for each Contribution on the date the Contributor first
-distributes such Contribution.
-
-2.3. Limitations on Grant Scope
-
-The licenses granted in this Section 2 are the only rights granted under
-this License. No additional rights or licenses will be implied from the
-distribution or licensing of Covered Software under this License.
-Notwithstanding Section 2.1(b) above, no patent license is granted by a
-Contributor:
-
-(a) for any code that a Contributor has removed from Covered Software;
-    or
-
-(b) for infringements caused by: (i) Your and any other third party's
-    modifications of Covered Software, or (ii) the combination of its
-    Contributions with other software (except as part of its Contributor
-    Version); or
-
-(c) under Patent Claims infringed by Covered Software in the absence of
-    its Contributions.
-
-This License does not grant any rights in the trademarks, service marks,
-or logos of any Contributor (except as may be necessary to comply with
-the notice requirements in Section 3.4).
-
-2.4. Subsequent Licenses
-
-No Contributor makes additional grants as a result of Your choice to
-distribute the Covered Software under a subsequent version of this
-License (see Section 10.2) or under the terms of a Secondary License (if
-permitted under the terms of Section 3.3).
-
-2.5. Representation
-
-Each Contributor represents that the Contributor believes its
-Contributions are its original creation(s) or it has sufficient rights
-to grant the rights to its Contributions conveyed by this License.
-
-2.6. Fair Use
-
-This License is not intended to limit any rights You have under
-applicable copyright doctrines of fair use, fair dealing, or other
-equivalents.
-
-2.7. Conditions
-
-Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted
-in Section 2.1.
-
-3. Responsibilities
--------------------
-
-3.1. Distribution of Source Form
-
-All distribution of Covered Software in Source Code Form, including any
-Modifications that You create or to which You contribute, must be under
-the terms of this License. You must inform recipients that the Source
-Code Form of the Covered Software is governed by the terms of this
-License, and how they can obtain a copy of this License. You may not
-attempt to alter or restrict the recipients' rights in the Source Code
-Form.
-
-3.2. Distribution of Executable Form
-
-If You distribute Covered Software in Executable Form then:
-
-(a) such Covered Software must also be made available in Source Code
-    Form, as described in Section 3.1, and You must inform recipients of
-    the Executable Form how they can obtain a copy of such Source Code
-    Form by reasonable means in a timely manner, at a charge no more
-    than the cost of distribution to the recipient; and
-
-(b) You may distribute such Executable Form under the terms of this
-    License, or sublicense it under different terms, provided that the
-    license for the Executable Form does not attempt to limit or alter
-    the recipients' rights in the Source Code Form under this License.
-
-3.3. Distribution of a Larger Work
-
-You may create and distribute a Larger Work under terms of Your choice,
-provided that You also comply with the requirements of this License for
-the Covered Software. If the Larger Work is a combination of Covered
-Software with a work governed by one or more Secondary Licenses, and the
-Covered Software is not Incompatible With Secondary Licenses, this
-License permits You to additionally distribute such Covered Software
-under the terms of such Secondary License(s), so that the recipient of
-the Larger Work may, at their option, further distribute the Covered
-Software under the terms of either this License or such Secondary
-License(s).
-
-3.4. Notices
-
-You may not remove or alter the substance of any license notices
-(including copyright notices, patent notices, disclaimers of warranty,
-or limitations of liability) contained within the Source Code Form of
-the Covered Software, except that You may alter any license notices to
-the extent required to remedy known factual inaccuracies.
-
-3.5. Application of Additional Terms
-
-You may choose to offer, and to charge a fee for, warranty, support,
-indemnity or liability obligations to one or more recipients of Covered
-Software. However, You may do so only on Your own behalf, and not on
-behalf of any Contributor. You must make it absolutely clear that any
-such warranty, support, indemnity, or liability obligation is offered by
-You alone, and You hereby agree to indemnify every Contributor for any
-liability incurred by such Contributor as a result of warranty, support,
-indemnity or liability terms You offer. You may include additional
-disclaimers of warranty and limitations of liability specific to any
-jurisdiction.
-
-4. Inability to Comply Due to Statute or Regulation
----------------------------------------------------
-
-If it is impossible for You to comply with any of the terms of this
-License with respect to some or all of the Covered Software due to
-statute, judicial order, or regulation then You must: (a) comply with
-the terms of this License to the maximum extent possible; and (b)
-describe the limitations and the code they affect. Such description must
-be placed in a text file included with all distributions of the Covered
-Software under this License. Except to the extent prohibited by statute
-or regulation, such description must be sufficiently detailed for a
-recipient of ordinary skill to be able to understand it.
-
-5. Termination
---------------
-
-5.1. The rights granted under this License will terminate automatically
-if You fail to comply with any of its terms. However, if You become
-compliant, then the rights granted under this License from a particular
-Contributor are reinstated (a) provisionally, unless and until such
-Contributor explicitly and finally terminates Your grants, and (b) on an
-ongoing basis, if such Contributor fails to notify You of the
-non-compliance by some reasonable means prior to 60 days after You have
-come back into compliance. Moreover, Your grants from a particular
-Contributor are reinstated on an ongoing basis if such Contributor
-notifies You of the non-compliance by some reasonable means, this is the
-first time You have received notice of non-compliance with this License
-from such Contributor, and You become compliant prior to 30 days after
-Your receipt of the notice.
-
-5.2. If You initiate litigation against any entity by asserting a patent
-infringement claim (excluding declaratory judgment actions,
-counter-claims, and cross-claims) alleging that a Contributor Version
-directly or indirectly infringes any patent, then the rights granted to
-You by any and all Contributors for the Covered Software under Section
-2.1 of this License shall terminate.
-
-5.3. In the event of termination under Sections 5.1 or 5.2 above, all
-end user license agreements (excluding distributors and resellers) which
-have been validly granted by You or Your distributors under this License
-prior to termination shall survive termination.
-
-************************************************************************
-*                                                                      *
-*  6. Disclaimer of Warranty                                           *
-*  -------------------------                                           *
-*                                                                      *
-*  Covered Software is provided under this License on an "as is"       *
-*  basis, without warranty of any kind, either expressed, implied, or  *
-*  statutory, including, without limitation, warranties that the       *
-*  Covered Software is free of defects, merchantable, fit for a        *
-*  particular purpose or non-infringing. The entire risk as to the     *
-*  quality and performance of the Covered Software is with You.        *
-*  Should any Covered Software prove defective in any respect, You     *
-*  (not any Contributor) assume the cost of any necessary servicing,   *
-*  repair, or correction. This disclaimer of warranty constitutes an   *
-*  essential part of this License. No use of any Covered Software is   *
-*  authorized under this License except under this disclaimer.         *
-*                                                                      *
-************************************************************************
-
-************************************************************************
-*                                                                      *
-*  7. Limitation of Liability                                          *
-*  --------------------------                                          *
-*                                                                      *
-*  Under no circumstances and under no legal theory, whether tort      *
-*  (including negligence), contract, or otherwise, shall any           *
-*  Contributor, or anyone who distributes Covered Software as          *
-*  permitted above, be liable to You for any direct, indirect,         *
-*  special, incidental, or consequential damages of any character      *
-*  including, without limitation, damages for lost profits, loss of    *
-*  goodwill, work stoppage, computer failure or malfunction, or any    *
-*  and all other commercial damages or losses, even if such party      *
-*  shall have been informed of the possibility of such damages. This   *
-*  limitation of liability shall not apply to liability for death or   *
-*  personal injury resulting from such party's negligence to the       *
-*  extent applicable law prohibits such limitation. Some               *
-*  jurisdictions do not allow the exclusion or limitation of           *
-*  incidental or consequential damages, so this exclusion and          *
-*  limitation may not apply to You.                                    *
-*                                                                      *
-************************************************************************
-
-8. Litigation
--------------
-
-Any litigation relating to this License may be brought only in the
-courts of a jurisdiction where the defendant maintains its principal
-place of business and such litigation shall be governed by laws of that
-jurisdiction, without reference to its conflict-of-law provisions.
-Nothing in this Section shall prevent a party's ability to bring
-cross-claims or counter-claims.
-
-9. Miscellaneous
-----------------
-
-This License represents the complete agreement concerning the subject
-matter hereof. If any provision of this License is held to be
-unenforceable, such provision shall be reformed only to the extent
-necessary to make it enforceable. Any law or regulation which provides
-that the language of a contract shall be construed against the drafter
-shall not be used to construe this License against a Contributor.
-
-10. Versions of the License
----------------------------
-
-10.1. New Versions
-
-Mozilla Foundation is the license steward. Except as provided in Section
-10.3, no one other than the license steward has the right to modify or
-publish new versions of this License. Each version will be given a
-distinguishing version number.
-
-10.2. Effect of New Versions
-
-You may distribute the Covered Software under the terms of the version
-of the License under which You originally received the Covered Software,
-or under the terms of any subsequent version published by the license
-steward.
-
-10.3. Modified Versions
-
-If you create software not governed by this License, and you want to
-create a new license for such software, you may create and use a
-modified version of this License if you rename the license and remove
-any references to the name of the license steward (except to note that
-such modified license differs from this License).
-
-10.4. Distributing Source Code Form that is Incompatible With Secondary
-Licenses
-
-If You choose to distribute Source Code Form that is Incompatible With
-Secondary Licenses under the terms of this version of the License, the
-notice described in Exhibit B of this License must be attached.
-
-Exhibit A - Source Code Form License Notice
--------------------------------------------
-
-  This Source Code Form is subject to the terms of the Mozilla Public
-  License, v. 2.0. If a copy of the MPL was not distributed with this
-  file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-If it is not possible or desirable to put the notice in a particular
-file, then You may include the notice in a location (such as a LICENSE
-file in a relevant directory) where a recipient would be likely to look
-for such a notice.
-
-You may add additional accurate notices of copyright ownership.
-
-Exhibit B - "Incompatible With Secondary Licenses" Notice
----------------------------------------------------------
-
-  This Source Code Form is "Incompatible With Secondary Licenses", as
-  defined by the Mozilla Public License, v. 2.0.
+Copyright (C) 2013 Jakob Borg
+
+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.

NICKS

@@ -1,114 +0,0 @@
-# This file maps email addresses used in commits to nicks used the changelog.
-# It is auto generated from the AUTHORS file by script/authors.go.
-
-acogdev <jake@acogdev.com>
-alessandro.g89 <alessandro.g89@gmail.com>
-alex2108 <register-github@alex-graf.de>
-andersonvom <andersonvom@gmail.com>
-andrew-d <andrew@du.nham.ca>
-asdil12 <dominik@heidler.eu>
-AudriusButkevicius <audrius.butkevicius@gmail.com>
-aviau <alexandre@alexandreviau.net>
-aviau <aviau@debian.org>
-bencurthoys <ben@bencurthoys.com>
-bigbear2nd <bigbear2nd@gmail.com>
-brbecker <brbecker@gmail.com>
-brendanlong <self@brendanlong.com>
-brgmnn <dan.arne.bergmann@gmail.com>
-brgmnn <brgmnn@users.noreply.github.com>
-bsidhom <bsidhom@gmail.com>
-buinsky <vix_booja@tut.by>
-burkemw3 <mburke@amplify.com>
-burkemw3 <burkemw3@gmail.com>
-calmh <jakob@nym.se>
-canton7 <antony.male@gmail.com>
-Cathryne <cathryne.linenweaver@gmail.com>
-Cathryne <Cathryne@users.noreply.github.com>
-cdata <chris@scriptolo.gy>
-cdhowie <me@chrishowie.com>
-ceh <emil@hessman.se>
-cqcallaw <enlightened.despot@gmail.com>
-dinosore <dinosore@dbrsoftware.co.uk>
-dva <denisva@gmail.com>
-dzarda <dzardacz@gmail.com>
-eipiminus1 <eipiminusone+github@gmail.com>
-eipiminus1 <eipiminus1@users.noreply.github.com>
-facastagnini <federico.castagnini@gmail.com>
-filoozoom <philippe@schommers.be>
-frioux <frew@afoolishmanifesto.com>
-frioux <frioux@gmail.com>
-fti7 <frank@isemann.name>
-gillisig <gilli@vx.is>
-hadogenes <szafar@linux.pl>
-ironmig <kma1660@gmail.com>
-jarlebring <jarlebring@gmail.com>
-jedie <github.com@jensdiemer.de>
-jedie <git@jensdiemer.de>
-jgke <jgke@jgke.fi>
-jpjp <jamespatterson@operamail.com>
-jpjp <jpjp@users.noreply.github.com>
-kamadak <kamada@nanohz.org>
-KayoticSully <kayoticsully@gmail.com>
-kc1212 <kc04bc@gmx.com>
-kc1212 <kc1212@users.noreply.github.com>
-kilburn <kilburn@la3.org>
-kluppy <kluppy@going2blue.com>
-kozec <kozec@kozec.com>
-kralo <max.schulze@online.de>
-kralo <kralo@users.noreply.github.com>
-krozycki <rozycki.karol@gmail.com>
-letiemble <laurent.etiemble@gmail.com>
-letiemble <laurent.etiemble@monobjc.net>
-lkwg82 <lkwg82@gmx.de>
-LordLandon <lordlandon@gmail.com>
-majedev <majed.alhajry@gmail.com>
-marcindziadus <dziadus.marcin@gmail.com>
-marclaporte <marc@marclaporte.com>
-marclaporte <marc@laporte.name>
-mateon1 <matin1111@wp.pl>
-mogwa1 <devriesb@gmail.com>
-moshen <moshen.colin@gmail.com>
-Moter8 <moter8@gmail.com>
-mvdan <mvdan@mvdan.cc>
-norgeous <daniel@harte.me>
-norgeous <daniel@danielharte.co.uk>
-norgeous <norgeous@users.noreply.github.com>
-nrm21 <natemorrison@gmail.com>
-Nutomic <me@nutomic.com>
-pascalj <github@pascalj.com>
-pascalj <mail@pascal-jungblut.com>
-peterhoeg <peter@speartail.com>
-philips <brandon@ifup.org>
-piobpl <piotrb10@gmail.com>
-plouj <ploujj@gmail.com>
-pluby <phill.luby@newredo.com>
-pyfisch <pyfisch@gmail.com>
-qbit <qbit@deftly.net>
-ralder <ralder@yandex.ru>
-Rewt0r <rewt0r@gmx.com>
-Rewt0r <Rewt0r@users.noreply.github.com>
-rumpelsepp <stefan@sevenbyte.org>
-rumpelsepp <rumpelsepp@sevenbyte.org>
-scienmind <scintertech@cryptolab.net>
-sciurius <jvromans@squirrel.nl>
-seehuhn <voss@seehuhn.de>
-simplypeachy <aD@simplypeachy.co.uk>
-simplypeachy <simplypeachy@users.noreply.github.com>
-snnd <dw@risu.io>
-Stefan-Code <stefan.github@gmail.com>
-Stefan-Code <Stefan.github@gmail.com>
-timabell <tim@timwise.co.uk>
-tnn2 <tnn@nygren.pp.se>
-tojrobinson <tully@tojr.org>
-tpng <benny.tpng@gmail.com>
-tylerbrazier <tyler@tylerbrazier.com>
-uok <ueomkail@gmail.com>
-uok <uok@users.noreply.github.com>
-veeti <veeti.paananen@rojekti.fi>
-Vilbrekin <vilbrekin@gmail.com>
-wkennington <william@wkennington.com>
-WSGCSysadmin <e.meitner@willystreet.coop>
-wweich <wweich@users.noreply.github.com>
-wweich <wweich@gmx.de>
-Zillode <zillode@zillode.be>
-zukoo <fxgsell@gmail.com>

PULL_REQUEST_TEMPLATE.md

@@ -1,32 +0,0 @@
-### Purpose
-
-Describe the purpose of this change. If there is an existing issue that is
-resolved by this pull request, ensure that the commit subject is on the form
-`Some short description (fixes #1234)` where 1234 is the issue number.
-
-### Testing
-
-Describe what testing has been done, and how the reviewer can test the change
-if new tests are not included.
-
-### Screenshots
-
-If this is a GUI change, include screenshots of the change. If not, please
-feel free to just delete this section.
-
-### Documentation
-
-If this is a user visible change (including API and protocol changes), add a link here
-to the corresponding pull request on https://github.com/syncthing/docs or describe
-the documentation changes necessary.
-
-### Authorship
-
-Every author of a code contribution (Go, Javascript, HTML, CSS etc, with the
-possible exception of minor typo corrections and similar) is recorded in the
-AUTHORS and NICKS files and the in-GUI credits. If this is your first
-contribution, a maintainer will add you properly before accepting the
-contribution. You need not do so yourself or worry about the fact that the
-"authors" automated test fails. However, if your name (such as you want it
-presented in the credits) is not visible on your Github profile or in your
-commit messages, please assist by providing it here.

README.md

@@ -1,68 +1,38 @@
-# Syncthing
+syncthing
+=========
 
-[![Latest Build (Official)](https://img.shields.io/jenkins/s/http/build.syncthing.net/syncthing.svg?style=flat-square&label=unix%20build)](http://build.syncthing.net/job/syncthing/lastBuild/)
-[![API Documentation](https://img.shields.io/badge/api-Godoc-blue.svg?style=flat-square)](http://godoc.org/github.com/syncthing/syncthing)
-[![MPLv2 License](https://img.shields.io/badge/license-MPLv2-blue.svg?style=flat-square)](https://www.mozilla.org/MPL/2.0/)
+This is `syncthing`, an open BitTorrent Sync alternative. It is
+currently far from ready for mass consumption, but it is a usable proof
+of concept and tech demo. The following are the project goals:
 
-This is the Syncthing project which pursues the following goals:
-
- 1. Define a protocol for synchronization of a folder between a number of
-    collaborating devices. This protocol should be well defined, unambiguous,
-    easily understood, free to use, efficient, secure and language neutral.
-    This is called the [Block Exchange Protocol][1].
+ 1. Define an open, secure, language neutral protocol usable for
+    efficient synchronization of a file repository between an arbitrary
+    number of nodes. This is the [Block Exchange
+    Protocol](https://github.com/calmh/syncthing/blob/master/protocol/PROTOCOL.md)
+    (BEP).
 
  2. Provide the reference implementation to demonstrate the usability of
-    said protocol. This is the `syncthing` utility. We hope that
-    alternative, compatible implementations of the protocol will arise.
+    said protocol. This is the `syncthing` utility.
 
 The two are evolving together; the protocol is not to be considered
-stable until Syncthing 1.0 is released, at which point it is locked down
+stable until syncthing 1.0 is released, at which point it is locked down
 for incompatible changes.
 
-## Getting Started
+Syncthing does not use the BitTorrent protocol. The reasons for this are
+1) we don't know if BitTorrent Sync does either, so there's nothing to
+be compatible with, 2) BitTorrent includes a lot of functionality for
+making sure large swarms of selfish agents behave and somehow work
+towards a common goal. Here we have a much smaller swarm of cooperative
+agents and a simpler approach will suffice.
 
-Take a look at the [getting started guide][2].
+Documentation
+=============
 
-There are a few examples for keeping Syncthing running in the background
-on your system in [the etc directory][3]. There are also several [GUI
-implementations][11] for Windows, Mac and Linux.
+The syncthing documentation is kept on the
+[GitHub Wiki](https://github.com/calmh/syncthing/wiki).
 
-## Getting in Touch
+License
+=======
 
-The first and best point of contact is the [Forum][8]. There is also an IRC
-channel, `#syncthing` on [freenode][4] (with a [web client][9]), for talking
-directly to developers and users. If you've found something that is clearly a
-bug, feel free to report it in the [GitHub issue tracker][10].
+MIT
 
-## Building
-
-Building Syncthing from source is easy, and there's a [guide][5]
-that describes it for both Unix and Windows systems.
-
-## Signed Releases
-
-As of v0.10.15 and onwards release binaries are GPG signed with the key
-D26E6ED000654A3E, available from https://syncthing.net/security.html and
-most key servers.
-
-There is also a built in automatic upgrade mechanism (disabled in some
-distribution channels) which uses a compiled in ECDSA signature. Mac OS
-X binaries are also properly code signed.
-
-## Documentation
-
-Please see the [Syncthing documentation site][6].
-
-All code is licensed under the [MPLv2 License][7].
-
-[1]: http://docs.syncthing.net/specs/bep-v1.html
-[2]: http://docs.syncthing.net/intro/getting-started.html
-[3]: https://github.com/syncthing/syncthing/blob/master/etc
-[4]: http://www.freenode.net/irc_servers.shtml
-[5]: http://docs.syncthing.net/dev/building.html
-[6]: http://docs.syncthing.net/
-[7]: https://github.com/syncthing/syncthing/blob/master/LICENSE
-[8]: https://forum.syncthing.net/
-[9]: https://kiwiirc.com/client/irc.freenode.net/#syncthing
-[10]: https://github.com/syncthing/syncthing/issues
-[11]: http://docs.syncthing.net/users/contrib.html#gui-wrappers

blocks.go

@@ -0,0 +1,74 @@
+package main
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"io"
+)
+
+type Block struct {
+	Offset int64
+	Size   uint32
+	Hash   []byte
+}
+
+// Blocks returns the blockwise hash of the reader.
+func Blocks(r io.Reader, blocksize int) ([]Block, error) {
+	var blocks []Block
+	var offset int64
+	for {
+		lr := &io.LimitedReader{r, int64(blocksize)}
+		hf := sha256.New()
+		n, err := io.Copy(hf, lr)
+		if err != nil {
+			return nil, err
+		}
+
+		if n == 0 {
+			break
+		}
+
+		b := Block{
+			Offset: offset,
+			Size:   uint32(n),
+			Hash:   hf.Sum(nil),
+		}
+		blocks = append(blocks, b)
+		offset += int64(n)
+	}
+
+	if len(blocks) == 0 {
+		// Empty file
+		blocks = append(blocks, Block{
+			Offset: 0,
+			Size:   0,
+			Hash:   []uint8{0xe3, 0xb0, 0xc4, 0x42, 0x98, 0xfc, 0x1c, 0x14, 0x9a, 0xfb, 0xf4, 0xc8, 0x99, 0x6f, 0xb9, 0x24, 0x27, 0xae, 0x41, 0xe4, 0x64, 0x9b, 0x93, 0x4c, 0xa4, 0x95, 0x99, 0x1b, 0x78, 0x52, 0xb8, 0x55},
+		})
+	}
+
+	return blocks, nil
+}
+
+// BlockDiff returns lists of common and missing (to transform src into tgt)
+// blocks. Both block lists must have been created with the same block size.
+func BlockDiff(src, tgt []Block) (have, need []Block) {
+	if len(tgt) == 0 && len(src) != 0 {
+		return nil, nil
+	}
+
+	if len(tgt) != 0 && len(src) == 0 {
+		// Copy the entire file
+		return nil, tgt
+	}
+
+	for i := range tgt {
+		if i >= len(src) || bytes.Compare(tgt[i].Hash, src[i].Hash) != 0 {
+			// Copy differing block
+			need = append(need, tgt[i])
+		} else {
+			have = append(have, tgt[i])
+		}
+	}
+
+	return have, need
+}

blocks_test.go

@@ -1,17 +1,9 @@
-// Copyright (C) 2014 The Syncthing Authors.
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this file,
-// You can obtain one at http://mozilla.org/MPL/2.0/.
-
-package scanner
+package main
 
 import (
 	"bytes"
 	"fmt"
 	"testing"
-
-	"github.com/syncthing/syncthing/lib/protocol"
 )
 
 var blocksTestData = []struct {
@@ -51,7 +43,7 @@ var blocksTestData = []struct {
 func TestBlocks(t *testing.T) {
 	for _, test := range blocksTestData {
 		buf := bytes.NewBuffer(test.data)
-		blocks, err := Blocks(buf, test.blocksize, 0, nil)
+		blocks, err := Blocks(buf, test.blocksize)
 
 		if err != nil {
 			t.Fatal(err)
@@ -87,26 +79,26 @@ var diffTestData = []struct {
 	a string
 	b string
 	s int
-	d []protocol.BlockInfo
+	d []Block
 }{
-	{"contents", "contents", 1024, []protocol.BlockInfo{}},
-	{"", "", 1024, []protocol.BlockInfo{}},
-	{"contents", "contents", 3, []protocol.BlockInfo{}},
-	{"contents", "cantents", 3, []protocol.BlockInfo{{0, 3, nil}}},
-	{"contents", "contants", 3, []protocol.BlockInfo{{3, 3, nil}}},
-	{"contents", "cantants", 3, []protocol.BlockInfo{{0, 3, nil}, {3, 3, nil}}},
-	{"contents", "", 3, []protocol.BlockInfo{{0, 0, nil}}},
-	{"", "contents", 3, []protocol.BlockInfo{{0, 3, nil}, {3, 3, nil}, {6, 2, nil}}},
-	{"con", "contents", 3, []protocol.BlockInfo{{3, 3, nil}, {6, 2, nil}}},
+	{"contents", "contents", 1024, []Block{}},
+	{"", "", 1024, []Block{}},
+	{"contents", "contents", 3, []Block{}},
+	{"contents", "cantents", 3, []Block{{0, 3, nil}}},
+	{"contents", "contants", 3, []Block{{3, 3, nil}}},
+	{"contents", "cantants", 3, []Block{{0, 3, nil}, {3, 3, nil}}},
+	{"contents", "", 3, []Block{{0, 0, nil}}},
+	{"", "contents", 3, []Block{{0, 3, nil}, {3, 3, nil}, {6, 2, nil}}},
+	{"con", "contents", 3, []Block{{3, 3, nil}, {6, 2, nil}}},
 	{"contents", "con", 3, nil},
-	{"contents", "cont", 3, []protocol.BlockInfo{{3, 1, nil}}},
-	{"cont", "contents", 3, []protocol.BlockInfo{{3, 3, nil}, {6, 2, nil}}},
+	{"contents", "cont", 3, []Block{{3, 1, nil}}},
+	{"cont", "contents", 3, []Block{{3, 3, nil}, {6, 2, nil}}},
 }
 
 func TestDiff(t *testing.T) {
 	for i, test := range diffTestData {
-		a, _ := Blocks(bytes.NewBufferString(test.a), test.s, 0, nil)
-		b, _ := Blocks(bytes.NewBufferString(test.b), test.s, 0, nil)
+		a, _ := Blocks(bytes.NewBufferString(test.a), test.s)
+		b, _ := Blocks(bytes.NewBufferString(test.b), test.s)
 		_, d := BlockDiff(a, b)
 		if len(d) != len(test.d) {
 			t.Fatalf("Incorrect length for diff %d; %d != %d", i, len(d), len(test.d))

buffers/buffers.go

@@ -0,0 +1,45 @@
+package buffers
+
+const (
+	largeMin = 1024
+)
+
+var (
+	smallBuffers = make(chan []byte, 32)
+	largeBuffers = make(chan []byte, 32)
+)
+
+func Get(size int) []byte {
+	var ch = largeBuffers
+	if size < largeMin {
+		ch = smallBuffers
+	}
+
+	var buf []byte
+	select {
+	case buf = <-ch:
+	default:
+	}
+
+	if len(buf) < size {
+		return make([]byte, size)
+	}
+	return buf[:size]
+}
+
+func Put(buf []byte) {
+	buf = buf[:cap(buf)]
+	if len(buf) == 0 {
+		return
+	}
+
+	var ch = largeBuffers
+	if len(buf) < largeMin {
+		ch = smallBuffers
+	}
+
+	select {
+	case ch <- buf:
+	default:
+	}
+}

build.sh

@@ -1,186 +1,51 @@
-#!/usr/bin/env bash
-set -euo pipefail
-IFS=$'\n\t'
+#!/bin/bash
 
-STTRACE=${STTRACE:-}
+export COPYFILE_DISABLE=true
 
-script() {
-	name="$1"
-	shift
-	go run "script/$name.go" "$@"
-}
+version=$(git describe --always)
+buildDir=dist
 
-build() {
-	go run build.go "$@"
-}
+if [[ $fast != yes ]] ; then
+	go get -d
+	go test ./...
+fi
 
-case "${1:-default}" in
-	default)
-		build
-		;;
+if [[ -z $1 ]] ; then
+	go build -ldflags "-X main.Version $version"
+elif [[ $1 == "embed" ]] ; then
+	embedder auto gui > auto/gui.files.go \
+	&& go build -ldflags "-X main.Version $version"
+elif [[ $1 == "tar" ]] ; then
+	go build -ldflags "-X main.Version $version" \
+	&& mkdir syncthing-dist \
+	&& cp syncthing README.md LICENSE syncthing-dist \
+	&& tar zcvf syncthing-dist.tar.gz syncthing-dist \
+	&& rm -rf syncthing-dist
+elif [[ $1 == "all" ]] ; then
+	rm -rf "$buildDir"
+	mkdir -p "$buildDir" || exit 1
 
-	clean)
-		build "$@"
-		;;
-
-	tar)
-		build "$@"
-		;;
-
-	assets)
-		build "$@"
-		;;
-
-	xdr)
-		build "$@"
-		;;
-
-	translate)
-		build "$@"
-		;;
-
-	deb)
-		build "$@"
-		;;
-
-	setup)
-		build "$@"
-		;;
-
-	test)
-		ulimit -t 600 &>/dev/null || true
-		ulimit -d 512000 &>/dev/null || true
-		ulimit -m 512000 &>/dev/null || true
-		LOGGER_DISCARD=1 build test
-		;;
-
-	bench)
-		LOGGER_DISCARD=1 build bench | script benchfilter
-		;;
-
-	prerelease)
-		go run script/authors.go
-		build transifex
-		git add -A gui/default/assets/ lib/auto/
-		pushd man ; ./refresh.sh ; popd
-		git add -A man
-		;;
-
-	noupgrade)
-		build -no-upgrade tar
-		;;
-
-	all)
-		platforms=(
-			darwin-amd64 dragonfly-amd64 freebsd-amd64 linux-amd64 netbsd-amd64 openbsd-amd64 solaris-amd64 windows-amd64
-			freebsd-386 linux-386 netbsd-386 openbsd-386 windows-386
-			linux-arm linux-arm64 linux-ppc64 linux-ppc64le
-		)
-
-		for plat in "${platforms[@]}"; do
-			echo Building "$plat"
-
-			goos="${plat%-*}"
-			goarch="${plat#*-}"
-			dist="tar"
-
-			if [[ $goos == "windows" ]]; then
-				dist="zip"
-			fi
-
-			build -goos "$goos" -goarch "$goarch" "$dist"
-			echo
-		done
-		;;
-
-	test-cov)
-		ulimit -t 600 &>/dev/null || true
-		ulimit -d 512000 &>/dev/null || true
-		ulimit -m 512000 &>/dev/null || true
-
-		echo "mode: set" > coverage.out
-		fail=0
-
-		# For every package in the repo
-		for dir in $(go list ./lib/... ./cmd/...) ; do
-			# run the tests
-			GOPATH="$(pwd)/Godeps/_workspace:$GOPATH" go test -race -coverprofile=profile.out $dir
-			if [ -f profile.out ] ; then
-				# and if there was test output, append it to coverage.out
-				grep -v "mode: " profile.out >> coverage.out
-				rm profile.out
-			fi
-		done
-
-		gocov convert coverage.out | gocov-xml > coverage.xml
-
-		# This is usually run from within Jenkins. If it is, we need to
-		# tweak the paths in coverage.xml so cobertura finds the
-		# source.
-		if [[ "${WORKSPACE:-default}" != "default" ]] ; then
-			sed "s#$WORKSPACE##g" < coverage.xml > coverage.xml.new && mv coverage.xml.new coverage.xml
-		fi
-		;;
-
-	test-xunit)
-		ulimit -t 600 &>/dev/null || true
-		ulimit -d 512000 &>/dev/null || true
-		ulimit -m 512000 &>/dev/null || true
-
-		(GOPATH="$(pwd)/Godeps/_workspace:$GOPATH" go test -v -race ./lib/... ./cmd/... || true) > tests.out
-		go2xunit -output tests.xml -fail < tests.out
-		;;
-
-	docker-all)
-		img=${DOCKERIMG:-syncthing/build:latest}
-		docker run --rm -h syncthing-builder -u $(id -u) -t \
-			-v $(pwd):/go/src/github.com/syncthing/syncthing \
-			-w /go/src/github.com/syncthing/syncthing \
-			-e "STTRACE=$STTRACE" \
-			"$img" \
-			sh -c './build.sh clean \
-				&& ./build.sh test-cov \
-				&& ./build.sh bench \
-				&& ./build.sh all'
-		;;
-
-	docker-test)
-		img=${DOCKERIMG:-syncthing/build:latest}
-		docker run --rm -h syncthing-builder -u $(id -u) -t \
-			-v $(pwd):/go/src/github.com/syncthing/syncthing \
-			-w /go/src/github.com/syncthing/syncthing \
-			-e "STTRACE=$STTRACE" \
-			"$img" \
-			sh -euxc './build.sh clean \
-				&& go run build.go -race \
-				&& export GOPATH=$(pwd)/Godeps/_workspace:$GOPATH \
-				&& cd test \
-				&& go test -tags integration -v -timeout 90m -short \
-				&& git clean -fxd .'
-		;;
-
-	docker-lint)
-		img=${DOCKERIMG:-syncthing/build:latest}
-		docker run --rm -h syncthing-builder -u $(id -u) -t \
-			-v $(pwd):/go/src/github.com/syncthing/syncthing \
-			-w /go/src/github.com/syncthing/syncthing \
-			-e "STTRACE=$STTRACE" \
-			"$img" \
-			sh -euxc 'go run build.go lint'
-		;;
-
-
-	docker-vet)
-		img=${DOCKERIMG:-syncthing/build:latest}
-		docker run --rm -h syncthing-builder -u $(id -u) -t \
-			-v $(pwd):/go/src/github.com/syncthing/syncthing \
-			-w /go/src/github.com/syncthing/syncthing \
-			-e "STTRACE=$STTRACE" \
-			"$img" \
-			sh -euxc 'go run build.go vet'
-		;;
-
-	*)
-		echo "Unknown build command $1"
-		;;
-esac
+	export GOARM=7
+	for os in darwin-amd64 linux-386 linux-amd64 linux-arm freebsd-386 freebsd-amd64 windows-386 windows-amd64 ; do
+		echo "$os"
+		export name="syncthing-$os"
+		export GOOS=${os%-*}
+		export GOARCH=${os#*-}
+		go build -ldflags "-X main.Version $version"
+		mkdir -p "$name"
+		cp README.md LICENSE "$name"
+		case $GOOS in
+			windows)
+				cp syncthing.exe "$buildDir/$name.exe"
+				mv syncthing.exe "$name"
+				zip -qr "$buildDir/$name.zip" "$name"
+				;;
+			*)
+				cp syncthing "$buildDir/$name"
+				mv syncthing "$name"
+				tar zcf "$buildDir/$name.tar.gz" "$name"
+				;;
+		esac
+		rm -r  "$name"
+	done
+fi

cmd/.gitignore

@@ -1 +0,0 @@
-!syncthing

cmd/discosrv/LICENSE

@@ -1,19 +0,0 @@
-Copyright (C) 2014-2015 The Discosrv Authors
-
-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.

cmd/discosrv/README.md

@@ -1,40 +0,0 @@
-discosrv
-========
-
-[![Latest Build](http://img.shields.io/jenkins/s/http/build.syncthing.net/discosrv.svg?style=flat-square)](http://build.syncthing.net/job/discosrv/lastBuild/)
-
-This is the global discovery server for the `syncthing` project.
-
-To get it, run `go get github.com/syncthing/discosrv` or download the
-[latest build](http://build.syncthing.net/job/discosrv/lastSuccessfulBuild/artifact/)
-from the build server.
-
-Usage
------
-
-The discovery server supports `ql` and `postgres` backends.
-Specify the backend via `-db-backend` and the database DSN via `-db-dsn`.
-
-By default it will use in-memory `ql` backend. If you wish to persist the
-information on disk between restarts in `ql`, specify a file DSN:
-
-```bash
-$ discosrv -db-dsn="file:///var/run/discosrv.db"
-```
-
-For `postgres`, you will need to create a database and a user with permissions
-to create tables in it, then start the discosrv as follows:
-
-```bash
-$ export DISCOSRV_DB_DSN="postgres://user:password@localhost/databasename"
-$ discosrv -db-backend="postgres"
-```
-
-You can pass the DSN as command line option, but the value what you pass in will
-be visible in most process managers, potentially exposing the database password
-to other users.
-
-In all cases, the appropriate tables and indexes will be created at first
-startup. If it doesn't exit with an error, you're fine.
-
-See `discosrv -help` for other options.

cmd/discosrv/clean.go

@@ -1,75 +0,0 @@
-// Copyright (C) 2014-2015 Jakob Borg and Contributors (see the CONTRIBUTORS file).
-
-package main
-
-import (
-	"database/sql"
-	"log"
-	"time"
-)
-
-type cleansrv struct {
-	intv time.Duration
-	db   *sql.DB
-	prep map[string]*sql.Stmt
-}
-
-func (s *cleansrv) Serve() {
-	for {
-		time.Sleep(next(s.intv))
-
-		err := s.cleanOldEntries()
-		if err != nil {
-			log.Println("Clean:", err)
-		}
-	}
-}
-
-func (s *cleansrv) Stop() {
-	panic("stop unimplemented")
-}
-
-func (s *cleansrv) cleanOldEntries() (err error) {
-	var tx *sql.Tx
-	tx, err = s.db.Begin()
-	if err != nil {
-		return err
-	}
-
-	defer func() {
-		if err == nil {
-			err = tx.Commit()
-		} else {
-			tx.Rollback()
-		}
-	}()
-
-	res, err := tx.Stmt(s.prep["cleanAddress"]).Exec()
-	if err != nil {
-		return err
-	}
-	if rows, _ := res.RowsAffected(); rows > 0 {
-		log.Printf("Clean: %d old addresses", rows)
-	}
-
-	res, err = tx.Stmt(s.prep["cleanDevice"]).Exec()
-	if err != nil {
-		return err
-	}
-	if rows, _ := res.RowsAffected(); rows > 0 {
-		log.Printf("Clean: %d old devices", rows)
-	}
-
-	var devs, addrs int
-	row := tx.Stmt(s.prep["countDevice"]).QueryRow()
-	if err = row.Scan(&devs); err != nil {
-		return err
-	}
-	row = tx.Stmt(s.prep["countAddress"]).QueryRow()
-	if err = row.Scan(&addrs); err != nil {
-		return err
-	}
-
-	log.Printf("Database: %d devices, %d addresses", devs, addrs)
-	return nil
-}

cmd/discosrv/db.go

@@ -1,32 +0,0 @@
-// Copyright (C) 2014-2015 Jakob Borg and Contributors (see the CONTRIBUTORS file).
-
-package main
-
-import (
-	"database/sql"
-	"fmt"
-)
-
-type setupFunc func(db *sql.DB) error
-type compileFunc func(db *sql.DB) (map[string]*sql.Stmt, error)
-
-var (
-	setupFuncs   = make(map[string]setupFunc)
-	compileFuncs = make(map[string]compileFunc)
-)
-
-func register(name string, setup setupFunc, compile compileFunc) {
-	setupFuncs[name] = setup
-	compileFuncs[name] = compile
-}
-
-func setup(backend string, db *sql.DB) (map[string]*sql.Stmt, error) {
-	setup, ok := setupFuncs[backend]
-	if !ok {
-		return nil, fmt.Errorf("Unsupported backend")
-	}
-	if err := setup(db); err != nil {
-		return nil, err
-	}
-	return compileFuncs[backend](db)
-}

cmd/discosrv/main.go

@@ -1,141 +0,0 @@
-// Copyright (C) 2014-2015 Jakob Borg and Contributors (see the CONTRIBUTORS file).
-
-package main
-
-import (
-	"crypto/tls"
-	"database/sql"
-	"flag"
-	"fmt"
-	"log"
-	"os"
-	"runtime"
-	"strconv"
-	"time"
-
-	"github.com/syncthing/syncthing/lib/protocol"
-	"github.com/thejerf/suture"
-)
-
-const (
-	minNegCache  = 60        // seconds
-	maxNegCache  = 3600      // seconds
-	maxDeviceAge = 7 * 86400 // one week, in seconds
-)
-
-var (
-	Version    string
-	BuildStamp string
-	BuildUser  string
-	BuildHost  string
-
-	BuildDate   time.Time
-	LongVersion string
-)
-
-func init() {
-	stamp, _ := strconv.Atoi(BuildStamp)
-	BuildDate = time.Unix(int64(stamp), 0)
-
-	date := BuildDate.UTC().Format("2006-01-02 15:04:05 MST")
-	LongVersion = fmt.Sprintf(`discosrv %s (%s %s-%s) %s@%s %s`, Version, runtime.Version(), runtime.GOOS, runtime.GOARCH, BuildUser, BuildHost, date)
-}
-
-var (
-	lruSize     = 10240
-	limitAvg    = 5
-	limitBurst  = 20
-	globalStats stats
-	statsFile   string
-	backend     = "ql"
-	dsn         = getEnvDefault("DISCOSRV_DB_DSN", "memory://discosrv")
-	certFile    = "cert.pem"
-	keyFile     = "key.pem"
-	debug       = false
-	useHTTP     = false
-)
-
-func main() {
-	const (
-		cleanIntv = 1 * time.Hour
-		statsIntv = 5 * time.Minute
-	)
-
-	var listen string
-
-	log.SetOutput(os.Stdout)
-	log.SetFlags(0)
-
-	flag.StringVar(&listen, "listen", ":8443", "Listen address")
-	flag.IntVar(&lruSize, "limit-cache", lruSize, "Limiter cache entries")
-	flag.IntVar(&limitAvg, "limit-avg", limitAvg, "Allowed average package rate, per 10 s")
-	flag.IntVar(&limitBurst, "limit-burst", limitBurst, "Allowed burst size, packets")
-	flag.StringVar(&statsFile, "stats-file", statsFile, "File to write periodic operation stats to")
-	flag.StringVar(&backend, "db-backend", backend, "Database backend to use")
-	flag.StringVar(&dsn, "db-dsn", dsn, "Database DSN")
-	flag.StringVar(&certFile, "cert", certFile, "Certificate file")
-	flag.StringVar(&keyFile, "key", keyFile, "Key file")
-	flag.BoolVar(&debug, "debug", debug, "Debug")
-	flag.BoolVar(&useHTTP, "http", useHTTP, "Listen on HTTP (behind an HTTPS proxy)")
-	flag.Parse()
-
-	log.Println(LongVersion)
-
-	var cert tls.Certificate
-	var err error
-	if !useHTTP {
-		cert, err = tls.LoadX509KeyPair(certFile, keyFile)
-		if err != nil {
-			log.Fatalln("Failed to load X509 key pair:", err)
-		}
-
-		devID := protocol.NewDeviceID(cert.Certificate[0])
-		log.Println("Server device ID is", devID)
-	}
-
-	db, err := sql.Open(backend, dsn)
-	if err != nil {
-		log.Fatalln("sql.Open:", err)
-	}
-	prep, err := setup(backend, db)
-	if err != nil {
-		log.Fatalln("Setup:", err)
-	}
-
-	main := suture.NewSimple("main")
-
-	main.Add(&querysrv{
-		addr: listen,
-		cert: cert,
-		db:   db,
-		prep: prep,
-	})
-
-	main.Add(&cleansrv{
-		intv: cleanIntv,
-		db:   db,
-		prep: prep,
-	})
-
-	main.Add(&statssrv{
-		intv: statsIntv,
-		file: statsFile,
-		db:   db,
-	})
-
-	globalStats.Reset()
-	main.Serve()
-}
-
-func getEnvDefault(key, def string) string {
-	if val := os.Getenv(key); val != "" {
-		return val
-	}
-	return def
-}
-
-func next(intv time.Duration) time.Duration {
-	t0 := time.Now()
-	t1 := t0.Add(intv).Truncate(intv)
-	return t1.Sub(t0)
-}

cmd/discosrv/psql.go

@@ -1,97 +0,0 @@
-// Copyright (C) 2014-2015 Jakob Borg and Contributors (see the CONTRIBUTORS file).
-
-package main
-
-import (
-	"database/sql"
-	"fmt"
-
-	_ "github.com/lib/pq"
-)
-
-func init() {
-	register("postgres", postgresSetup, postgresCompile)
-}
-
-func postgresSetup(db *sql.DB) error {
-	var err error
-
-	db.SetMaxIdleConns(4)
-	db.SetMaxOpenConns(8)
-
-	_, err = db.Exec(`CREATE TABLE IF NOT EXISTS Devices (
-		DeviceID CHAR(63) NOT NULL PRIMARY KEY,
-		Seen TIMESTAMP NOT NULL
-	)`)
-	if err != nil {
-		return err
-	}
-
-	row := db.QueryRow(`SELECT 'DevicesDeviceIDIndex'::regclass`)
-	if err := row.Scan(nil); err != nil {
-		_, err = db.Exec(`CREATE INDEX DevicesDeviceIDIndex ON Devices (DeviceID)`)
-	}
-	if err != nil {
-		return err
-	}
-
-	row = db.QueryRow(`SELECT 'DevicesSeenIndex'::regclass`)
-	if err := row.Scan(nil); err != nil {
-		_, err = db.Exec(`CREATE INDEX DevicesSeenIndex ON Devices (Seen)`)
-	}
-	if err != nil {
-		return err
-	}
-
-	_, err = db.Exec(`CREATE TABLE IF NOT EXISTS Addresses (
-		DeviceID CHAR(63) NOT NULL,
-		Seen TIMESTAMP NOT NULL,
-		Address VARCHAR(256) NOT NULL
-	)`)
-	if err != nil {
-		return err
-	}
-
-	row = db.QueryRow(`SELECT 'AddressesDeviceIDSeenIndex'::regclass`)
-	if err := row.Scan(nil); err != nil {
-		_, err = db.Exec(`CREATE INDEX AddressesDeviceIDSeenIndex ON Addresses (DeviceID, Seen)`)
-	}
-	if err != nil {
-		return err
-	}
-
-	row = db.QueryRow(`SELECT 'AddressesDeviceIDAddressIndex'::regclass`)
-	if err := row.Scan(nil); err != nil {
-		_, err = db.Exec(`CREATE INDEX AddressesDeviceIDAddressIndex ON Addresses (DeviceID, Address)`)
-	}
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func postgresCompile(db *sql.DB) (map[string]*sql.Stmt, error) {
-	stmts := map[string]string{
-		"cleanAddress":  "DELETE FROM Addresses WHERE Seen < now() - '2 hour'::INTERVAL",
-		"cleanDevice":   fmt.Sprintf("DELETE FROM Devices WHERE Seen < now() - '%d hour'::INTERVAL", maxDeviceAge/3600),
-		"countAddress":  "SELECT count(*) FROM Addresses",
-		"countDevice":   "SELECT count(*) FROM Devices",
-		"insertAddress": "INSERT INTO Addresses (DeviceID, Seen, Address) VALUES ($1, now(), $2)",
-		"insertDevice":  "INSERT INTO Devices (DeviceID, Seen) VALUES ($1, now())",
-		"selectAddress": "SELECT Address FROM Addresses WHERE DeviceID=$1 AND Seen > now() - '1 hour'::INTERVAL ORDER BY random() LIMIT 16",
-		"selectDevice":  "SELECT Seen FROM Devices WHERE DeviceID=$1",
-		"updateAddress": "UPDATE Addresses SET Seen=now() WHERE DeviceID=$1 AND Address=$2",
-		"updateDevice":  "UPDATE Devices SET Seen=now() WHERE DeviceID=$1",
-	}
-
-	res := make(map[string]*sql.Stmt, len(stmts))
-	for key, stmt := range stmts {
-		prep, err := db.Prepare(stmt)
-		if err != nil {
-			return nil, err
-		}
-		res[key] = prep
-	}
-	return res, nil
-}

cmd/discosrv/ql.go

@@ -1,81 +0,0 @@
-// Copyright (C) 2015 Audrius Butkevicius and Contributors (see the CONTRIBUTORS file).
-
-package main
-
-import (
-	"database/sql"
-	"fmt"
-	"log"
-
-	"github.com/cznic/ql"
-)
-
-func init() {
-	ql.RegisterDriver()
-	register("ql", qlSetup, qlCompile)
-}
-
-func qlSetup(db *sql.DB) (err error) {
-	tx, err := db.Begin()
-	if err != nil {
-		return
-	}
-
-	defer func() {
-		if err == nil {
-			err = tx.Commit()
-		} else {
-			tx.Rollback()
-		}
-	}()
-
-	_, err = tx.Exec(`CREATE TABLE IF NOT EXISTS Devices (
-		DeviceID STRING NOT NULL,
-		Seen TIME NOT NULL
-	)`)
-	if err != nil {
-		return
-	}
-
-	if _, err = tx.Exec(`CREATE INDEX IF NOT EXISTS DevicesDeviceIDIndex ON Devices (DeviceID)`); err != nil {
-		return
-	}
-
-	_, err = tx.Exec(`CREATE TABLE IF NOT EXISTS Addresses (
-		DeviceID STRING NOT NULL,
-		Seen TIME NOT NULL,
-		Address STRING NOT NULL,
-	)`)
-	if err != nil {
-		return
-	}
-
-	_, err = tx.Exec(`CREATE INDEX IF NOT EXISTS AddressesDeviceIDAddressIndex ON Addresses (DeviceID, Address)`)
-	return
-}
-
-func qlCompile(db *sql.DB) (map[string]*sql.Stmt, error) {
-	stmts := map[string]string{
-		"cleanAddress":  `DELETE FROM Addresses WHERE Seen < now() - duration("2h")`,
-		"cleanDevice":   fmt.Sprintf(`DELETE FROM Devices WHERE Seen < now() - duration("%dh")`, maxDeviceAge/3600),
-		"countAddress":  "SELECT count(*) FROM Addresses",
-		"countDevice":   "SELECT count(*) FROM Devices",
-		"insertAddress": "INSERT INTO Addresses (DeviceID, Seen, Address) VALUES ($1, now(), $2)",
-		"insertDevice":  "INSERT INTO Devices (DeviceID, Seen) VALUES ($1, now())",
-		"selectAddress": `SELECT Address from Addresses WHERE DeviceID==$1 AND Seen > now() - duration("1h") LIMIT 16`,
-		"selectDevice":  "SELECT Seen FROM Devices WHERE DeviceID==$1",
-		"updateAddress": "UPDATE Addresses Seen=now() WHERE DeviceID==$1 AND Address==$2",
-		"updateDevice":  "UPDATE Devices Seen=now() WHERE DeviceID==$1",
-	}
-
-	res := make(map[string]*sql.Stmt, len(stmts))
-	for key, stmt := range stmts {
-		prep, err := db.Prepare(stmt)
-		if err != nil {
-			log.Println("Failed to compile", stmt)
-			return nil, err
-		}
-		res[key] = prep
-	}
-	return res, nil
-}

cmd/discosrv/querysrv.go

@@ -1,478 +0,0 @@
-// Copyright (C) 2014-2015 Jakob Borg and Contributors (see the CONTRIBUTORS file).
-
-package main
-
-import (
-	"bytes"
-	"crypto/tls"
-	"database/sql"
-	"encoding/json"
-	"encoding/pem"
-	"fmt"
-	"log"
-	"math/rand"
-	"net"
-	"net/http"
-	"net/url"
-	"strconv"
-	"sync"
-	"time"
-
-	"github.com/golang/groupcache/lru"
-	"github.com/juju/ratelimit"
-	"github.com/syncthing/syncthing/lib/protocol"
-	"golang.org/x/net/context"
-)
-
-type querysrv struct {
-	addr     string
-	db       *sql.DB
-	prep     map[string]*sql.Stmt
-	limiter  *safeCache
-	cert     tls.Certificate
-	listener net.Listener
-}
-
-type announcement struct {
-	Seen      time.Time `json:"seen"`
-	Addresses []string  `json:"addresses"`
-}
-
-type safeCache struct {
-	*lru.Cache
-	mut sync.Mutex
-}
-
-func (s *safeCache) Get(key string) (val interface{}, ok bool) {
-	s.mut.Lock()
-	val, ok = s.Cache.Get(key)
-	s.mut.Unlock()
-	return
-}
-
-func (s *safeCache) Add(key string, val interface{}) {
-	s.mut.Lock()
-	s.Cache.Add(key, val)
-	s.mut.Unlock()
-}
-
-type requestID int64
-
-func (i requestID) String() string {
-	return fmt.Sprintf("%016x", int64(i))
-}
-
-func negCacheFor(lastSeen time.Time) int {
-	since := time.Since(lastSeen).Seconds()
-	if since >= maxDeviceAge {
-		return maxNegCache
-	}
-	if since < 0 {
-		// That's weird
-		return minNegCache
-	}
-
-	// Return a value linearly scaled from minNegCache (at zero seconds ago)
-	// to maxNegCache (at maxDeviceAge seconds ago).
-	r := since / maxDeviceAge
-	return int(minNegCache + r*(maxNegCache-minNegCache))
-}
-
-func (s *querysrv) Serve() {
-	s.limiter = &safeCache{
-		Cache: lru.New(lruSize),
-	}
-
-	if useHTTP {
-		listener, err := net.Listen("tcp", s.addr)
-		if err != nil {
-			log.Println("Listen:", err)
-			return
-		}
-		s.listener = listener
-	} else {
-		tlsCfg := &tls.Config{
-			Certificates:           []tls.Certificate{s.cert},
-			ClientAuth:             tls.RequestClientCert,
-			SessionTicketsDisabled: true,
-			MinVersion:             tls.VersionTLS12,
-			CipherSuites: []uint16{
-				tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
-				tls.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
-				tls.TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA,
-				tls.TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA,
-				tls.TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA,
-				tls.TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA,
-			},
-		}
-
-		tlsListener, err := tls.Listen("tcp", s.addr, tlsCfg)
-		if err != nil {
-			log.Println("Listen:", err)
-			return
-		}
-		s.listener = tlsListener
-	}
-
-	http.HandleFunc("/v2/", s.handler)
-	http.HandleFunc("/ping", handlePing)
-
-	srv := &http.Server{
-		ReadTimeout:    5 * time.Second,
-		WriteTimeout:   5 * time.Second,
-		MaxHeaderBytes: 1 << 10,
-	}
-
-	if err := srv.Serve(s.listener); err != nil {
-		log.Println("Serve:", err)
-	}
-}
-
-var topCtx = context.Background()
-
-func (s *querysrv) handler(w http.ResponseWriter, req *http.Request) {
-	reqID := requestID(rand.Int63())
-	ctx := context.WithValue(topCtx, "id", reqID)
-
-	if debug {
-		log.Println(reqID, req.Method, req.URL)
-	}
-
-	t0 := time.Now()
-	defer func() {
-		diff := time.Since(t0)
-		var comment string
-		if diff > time.Second {
-			comment = "(very slow request)"
-		} else if diff > 100*time.Millisecond {
-			comment = "(slow request)"
-		}
-		if comment != "" || debug {
-			log.Println(reqID, req.Method, req.URL, "completed in", diff, comment)
-		}
-	}()
-
-	var remoteIP net.IP
-	if useHTTP {
-		remoteIP = net.ParseIP(req.Header.Get("X-Forwarded-For"))
-	} else {
-		addr, err := net.ResolveTCPAddr("tcp", req.RemoteAddr)
-		if err != nil {
-			log.Println("remoteAddr:", err)
-			http.Error(w, "Internal Server Error", http.StatusInternalServerError)
-			return
-		}
-		remoteIP = addr.IP
-	}
-
-	if s.limit(remoteIP) {
-		if debug {
-			log.Println(remoteIP, "is limited")
-		}
-		w.Header().Set("Retry-After", "60")
-		http.Error(w, "Too Many Requests", 429)
-		return
-	}
-
-	switch req.Method {
-	case "GET":
-		s.handleGET(ctx, w, req)
-	case "POST":
-		s.handlePOST(ctx, remoteIP, w, req)
-	default:
-		globalStats.Error()
-		http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed)
-	}
-}
-
-func (s *querysrv) handleGET(ctx context.Context, w http.ResponseWriter, req *http.Request) {
-	reqID := ctx.Value("id").(requestID)
-
-	deviceID, err := protocol.DeviceIDFromString(req.URL.Query().Get("device"))
-	if err != nil {
-		if debug {
-			log.Println(reqID, "bad device param")
-		}
-		globalStats.Error()
-		http.Error(w, "Bad Request", http.StatusBadRequest)
-		return
-	}
-
-	var ann announcement
-
-	ann.Seen, err = s.getDeviceSeen(deviceID)
-	negCache := strconv.Itoa(negCacheFor(ann.Seen))
-	w.Header().Set("Retry-After", negCache)
-	w.Header().Set("Cache-Control", "public, max-age="+negCache)
-
-	if err != nil {
-		// The device is not in the database.
-		globalStats.Query()
-		http.Error(w, "Not Found", http.StatusNotFound)
-		return
-	}
-
-	t0 := time.Now()
-	ann.Addresses, err = s.getAddresses(ctx, deviceID)
-	if err != nil {
-		log.Println(reqID, "getAddresses:", err)
-		globalStats.Error()
-		http.Error(w, "Internal Server Error", http.StatusInternalServerError)
-		return
-	}
-	if debug {
-		log.Println(reqID, "getAddresses in", time.Since(t0))
-	}
-
-	globalStats.Query()
-
-	if len(ann.Addresses) == 0 {
-		http.Error(w, "Not Found", http.StatusNotFound)
-		return
-	}
-
-	globalStats.Answer()
-
-	w.Header().Set("Content-Type", "application/json")
-	json.NewEncoder(w).Encode(ann)
-}
-
-func (s *querysrv) handlePOST(ctx context.Context, remoteIP net.IP, w http.ResponseWriter, req *http.Request) {
-	reqID := ctx.Value("id").(requestID)
-
-	rawCert := certificateBytes(req)
-	if rawCert == nil {
-		if debug {
-			log.Println(reqID, "no certificates")
-		}
-		globalStats.Error()
-		http.Error(w, "Forbidden", http.StatusForbidden)
-		return
-	}
-
-	var ann announcement
-	if err := json.NewDecoder(req.Body).Decode(&ann); err != nil {
-		if debug {
-			log.Println(reqID, "decode:", err)
-		}
-		globalStats.Error()
-		http.Error(w, "Bad Request", http.StatusBadRequest)
-		return
-	}
-
-	deviceID := protocol.NewDeviceID(rawCert)
-
-	// handleAnnounce returns *two* errors. The first indicates a problem with
-	// something the client posted to us. We should return a 400 Bad Request
-	// and not worry about it. The second indicates that the request was fine,
-	// but something internal messed up. We should log it and respond with a
-	// more apologetic 500 Internal Server Error.
-	userErr, internalErr := s.handleAnnounce(ctx, remoteIP, deviceID, ann.Addresses)
-	if userErr != nil {
-		if debug {
-			log.Println(reqID, "handleAnnounce:", userErr)
-		}
-		globalStats.Error()
-		http.Error(w, "Bad Request", http.StatusBadRequest)
-		return
-	}
-	if internalErr != nil {
-		log.Println(reqID, "handleAnnounce:", internalErr)
-		globalStats.Error()
-		http.Error(w, "Internal Server Error", http.StatusInternalServerError)
-		return
-	}
-
-	globalStats.Announce()
-
-	// TODO: Slowly increase this for stable clients
-	w.Header().Set("Reannounce-After", "1800")
-
-	// We could return the lookup result here, but it's kind of unnecessarily
-	// expensive to go query the database again so we let the client decide to
-	// do a lookup if they really care.
-	w.WriteHeader(http.StatusNoContent)
-}
-
-func (s *querysrv) Stop() {
-	s.listener.Close()
-}
-
-func (s *querysrv) handleAnnounce(ctx context.Context, remote net.IP, deviceID protocol.DeviceID, addresses []string) (userErr, internalErr error) {
-	reqID := ctx.Value("id").(requestID)
-
-	tx, err := s.db.Begin()
-	if err != nil {
-		internalErr = err
-		return
-	}
-
-	defer func() {
-		// Since we return from a bunch of different places, we handle
-		// rollback in the defer.
-		if internalErr != nil || userErr != nil {
-			tx.Rollback()
-		}
-	}()
-
-	for _, annAddr := range addresses {
-		uri, err := url.Parse(annAddr)
-		if err != nil {
-			userErr = err
-			return
-		}
-
-		host, port, err := net.SplitHostPort(uri.Host)
-		if err != nil {
-			userErr = err
-			return
-		}
-
-		ip := net.ParseIP(host)
-		if host == "" || ip.IsUnspecified() {
-			host = remote.String()
-		}
-
-		uri.Host = net.JoinHostPort(host, port)
-
-		if err := s.updateAddress(ctx, tx, deviceID, uri.String()); err != nil {
-			internalErr = err
-			return
-		}
-	}
-
-	if err := s.updateDevice(ctx, tx, deviceID); err != nil {
-		internalErr = err
-		return
-	}
-
-	t0 := time.Now()
-	internalErr = tx.Commit()
-	if debug {
-		log.Println(reqID, "commit in", time.Since(t0))
-	}
-	return
-}
-
-func (s *querysrv) limit(remote net.IP) bool {
-	key := remote.String()
-
-	bkt, ok := s.limiter.Get(key)
-	if ok {
-		bkt := bkt.(*ratelimit.Bucket)
-		if bkt.TakeAvailable(1) != 1 {
-			// Rate limit exceeded; ignore packet
-			return true
-		}
-	} else {
-		// One packet per ten seconds average rate, burst ten packets
-		s.limiter.Add(key, ratelimit.NewBucket(10*time.Second/time.Duration(limitAvg), int64(limitBurst)))
-	}
-
-	return false
-}
-
-func (s *querysrv) updateDevice(ctx context.Context, tx *sql.Tx, device protocol.DeviceID) error {
-	reqID := ctx.Value("id").(requestID)
-	t0 := time.Now()
-	res, err := tx.Stmt(s.prep["updateDevice"]).Exec(device.String())
-	if err != nil {
-		return err
-	}
-	if debug {
-		log.Println(reqID, "updateDevice in", time.Since(t0))
-	}
-
-	if rows, _ := res.RowsAffected(); rows == 0 {
-		t0 = time.Now()
-		_, err := tx.Stmt(s.prep["insertDevice"]).Exec(device.String())
-		if err != nil {
-			return err
-		}
-		if debug {
-			log.Println(reqID, "insertDevice in", time.Since(t0))
-		}
-	}
-
-	return nil
-}
-
-func (s *querysrv) updateAddress(ctx context.Context, tx *sql.Tx, device protocol.DeviceID, uri string) error {
-	res, err := tx.Stmt(s.prep["updateAddress"]).Exec(device.String(), uri)
-	if err != nil {
-		return err
-	}
-
-	if rows, _ := res.RowsAffected(); rows == 0 {
-		_, err := tx.Stmt(s.prep["insertAddress"]).Exec(device.String(), uri)
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-func (s *querysrv) getAddresses(ctx context.Context, device protocol.DeviceID) ([]string, error) {
-	rows, err := s.prep["selectAddress"].Query(device.String())
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-
-	var res []string
-	for rows.Next() {
-		var addr string
-
-		err := rows.Scan(&addr)
-		if err != nil {
-			log.Println("Scan:", err)
-			continue
-		}
-		res = append(res, addr)
-	}
-
-	return res, nil
-}
-
-func (s *querysrv) getDeviceSeen(device protocol.DeviceID) (time.Time, error) {
-	row := s.prep["selectDevice"].QueryRow(device.String())
-	var seen time.Time
-	if err := row.Scan(&seen); err != nil {
-		return time.Time{}, err
-	}
-	return seen, nil
-}
-
-func handlePing(w http.ResponseWriter, r *http.Request) {
-	w.WriteHeader(204)
-}
-
-func certificateBytes(req *http.Request) []byte {
-	if req.TLS != nil && len(req.TLS.PeerCertificates) > 0 {
-		return req.TLS.PeerCertificates[0].Raw
-	}
-
-	if hdr := req.Header.Get("X-SSL-Cert"); hdr != "" {
-		bs := []byte(hdr)
-		// The certificate is in PEM format but with spaces for newlines. We
-		// need to reinstate the newlines for the PEM decoder. But we need to
-		// leave the spaces in the BEGIN and END lines - the first and last
-		// space - alone.
-		firstSpace := bytes.Index(bs, []byte(" "))
-		lastSpace := bytes.LastIndex(bs, []byte(" "))
-		for i := firstSpace + 1; i < lastSpace; i++ {
-			if bs[i] == ' ' {
-				bs[i] = '\n'
-			}
-		}
-		block, _ := pem.Decode(bs)
-		if block == nil {
-			// Decoding failed
-			return nil
-		}
-		return block.Bytes
-	}
-
-	return nil
-}

cmd/discosrv/stats.go

@@ -1,141 +0,0 @@
-// Copyright (C) 2014-2015 Jakob Borg and Contributors (see the CONTRIBUTORS file).
-
-package main
-
-import (
-	"bytes"
-	"database/sql"
-	"fmt"
-	"io/ioutil"
-	"log"
-	"os"
-	"sync/atomic"
-	"time"
-)
-
-type stats struct {
-	// Incremented atomically
-	announces int64
-	queries   int64
-	answers   int64
-	errors    int64
-}
-
-func (s *stats) Announce() {
-	atomic.AddInt64(&s.announces, 1)
-}
-
-func (s *stats) Query() {
-	atomic.AddInt64(&s.queries, 1)
-}
-
-func (s *stats) Answer() {
-	atomic.AddInt64(&s.answers, 1)
-}
-
-func (s *stats) Error() {
-	atomic.AddInt64(&s.errors, 1)
-}
-
-// Reset returns a copy of the current stats and resets the counters to
-// zero.
-func (s *stats) Reset() stats {
-	// Create a copy of the stats using atomic reads
-	copy := stats{
-		announces: atomic.LoadInt64(&s.announces),
-		queries:   atomic.LoadInt64(&s.queries),
-		answers:   atomic.LoadInt64(&s.answers),
-		errors:    atomic.LoadInt64(&s.errors),
-	}
-
-	// Reset the stats by subtracting the values that we copied
-	atomic.AddInt64(&s.announces, -copy.announces)
-	atomic.AddInt64(&s.queries, -copy.queries)
-	atomic.AddInt64(&s.answers, -copy.answers)
-	atomic.AddInt64(&s.errors, -copy.errors)
-
-	return copy
-}
-
-type statssrv struct {
-	intv time.Duration
-	file string
-	db   *sql.DB
-}
-
-func (s *statssrv) Serve() {
-	lastReset := time.Now()
-	for {
-		time.Sleep(next(s.intv))
-
-		stats := globalStats.Reset()
-		d := time.Since(lastReset).Seconds()
-		lastReset = time.Now()
-
-		log.Printf("Stats: %.02f announces/s, %.02f queries/s, %.02f answers/s, %.02f errors/s",
-			float64(stats.announces)/d, float64(stats.queries)/d, float64(stats.answers)/d, float64(stats.errors)/d)
-
-		if s.file != "" {
-			s.writeToFile(stats, d)
-		}
-	}
-}
-
-func (s *statssrv) Stop() {
-	panic("stop unimplemented")
-}
-
-func (s *statssrv) writeToFile(stats stats, secs float64) {
-	newLine := []byte("\n")
-
-	var addrs int
-	row := s.db.QueryRow("SELECT COUNT(*) FROM Addresses")
-	if err := row.Scan(&addrs); err != nil {
-		log.Println("stats query:", err)
-		return
-	}
-
-	fd, err := os.OpenFile(s.file, os.O_RDWR|os.O_CREATE, 0666)
-	if err != nil {
-		log.Println("stats file:", err)
-		return
-	}
-	defer func() {
-		err = fd.Close()
-		if err != nil {
-			log.Println("stats file:", err)
-		}
-	}()
-
-	bs, err := ioutil.ReadAll(fd)
-	if err != nil {
-		log.Println("stats file:", err)
-		return
-	}
-	lines := bytes.Split(bytes.TrimSpace(bs), newLine)
-	if len(lines) > 12 {
-		lines = lines[len(lines)-12:]
-	}
-
-	latest := fmt.Sprintf("%v: %6d addresses, %8.02f announces/s, %8.02f queries/s, %8.02f answers/s, %8.02f errors/s\n",
-		time.Now().UTC().Format(time.RFC3339), addrs,
-		float64(stats.announces)/secs, float64(stats.queries)/secs, float64(stats.answers)/secs, float64(stats.errors)/secs)
-	lines = append(lines, []byte(latest))
-
-	_, err = fd.Seek(0, 0)
-	if err != nil {
-		log.Println("stats file:", err)
-		return
-	}
-	err = fd.Truncate(0)
-	if err != nil {
-		log.Println("stats file:", err)
-		return
-	}
-
-	_, err = fd.Write(bytes.Join(lines, newLine))
-	if err != nil {
-		log.Println("stats file:", err)
-		return
-	}
-}

cmd/relaysrv/LICENSE

@@ -1,22 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2015 The Syncthing Project
-
-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.
-

cmd/relaysrv/README.md

@@ -1,141 +0,0 @@
-relaysrv
-========
-
-[![Latest Build](http://img.shields.io/jenkins/s/http/build.syncthing.net/relaysrv.svg?style=flat-square)](http://build.syncthing.net/job/relaysrv/lastBuild/)
-
-This is the relay server for the `syncthing` project.
-
-To get it, run `go get github.com/syncthing/relaysrv` or download the
-[latest build](http://build.syncthing.net/job/relaysrv/lastSuccessfulBuild/artifact/)
-from the build server.
-
-:exclamation:Warnings:exclamation: - Read or regret
------
-
-By default, all relay servers will join the default public relay pool, which means that the relay server will be availble for public use, and **will consume your bandwidth** helping others to connect.
-
-If you wish to disable this behaviour, please specify `-pools=""` argument.
-
-Please note that `relaysrv` is only usable by `syncthing` **version v0.12 and onwards**.
-
-To run `relaysrv` you need to have port 22067 available to the internet, which means you might need to allow it through your firewall if you **have a public IP, or setup a port-forwarding** (22067 to 22067) if you are behind a router.
-
-Furthermore, **by default relaysrv will also expose a /status HTTP endpoint on port 22070**, which is used by the pool servers to peek at metrics of the relaysrv, such as what are the current transfer rates, how many clients are connected, etc, etc. If you wish this information to be available, similarlly you might want to allow it through your firewall, or port-forward it (22070 to 22070) on your NAT device.
-
-This is **not mandatory** for the relaysrv to function, and is used only to gather metrics and present them in the overview page of the pool server, displaying stats about the specific relay.
-
-At the point of writing the endpoint output looks as follows:
-
-```
-{
-    "bytesProxied": 0,
-    "goArch": "amd64",
-    "goMaxProcs": 1,
-    "goNumRoutine": 13,
-    "goOS": "linux",
-    "goVersion": "go1.6",
-    "kbps10s1m5m15m30m60m": [
-        0,
-        0,
-        0,
-        0,
-        0,
-        0
-    ],
-    "numActiveSessions": 0,
-    "numConnections": 0,
-    "numPendingSessionKeys": 2,
-    "numProxies": 0,
-    "options": {
-        "global-rate": 0,
-        "message-timeout": 60,
-        "network-timeout": 120,
-        "per-session-rate": 0,
-        "ping-interval": 60,
-        "pools": [
-            "https://relays.syncthing.net/endpoint"
-        ],
-        "provided-by": ""
-    },
-    "startTime": "2016-03-06T12:53:07.090847749-05:00",
-    "uptimeSeconds": 17
-}
-```
-
-If you wish to disable the /status endpoint, provide `-status-srv=""` as one of the arguments when starting the relaysrv.
-
-Running for public use
-----
-Make sure you have a public IP with port 22067 open, or make sure you have port-forwarding (22067 to 22067) if you are behind a router.
-
-Run the `relaysrv` with no arguments (or `-debug` if you want more output), and that should be enough for the server to join the public relay pool.
-You should see a message saying:
-```
-2015/09/21 22:45:46 pool.go:60: Joined https://relays.syncthing.net/endpoint rejoining in 48m0s
-```
-
-See `relaysrv -help` for other options, such as rate limits, timeout intervals, etc.
-
-Running for private use
------
-
-Once you've started the `relaysrv`, it will generate a key pair and print an URI:
-```bash
-relay://:22067/?id=EZQOIDM-6DDD4ZI-DJ65NSM-4OQWRAT-EIKSMJO-OZ552BO-WQZEGYY-STS5RQM&pingInterval=1m0s&networkTimeout=2m0s&sessionLimitBps=0&globalLimitBps=0&statusAddr=:22070
-```
-
-This URI contains partial address of the relay server, as well as it's options which in the future may be taken into account when choosing the best suitable relay out of multiple available.
-
-Because `-listen` option was not used, the `relaysrv` does not know it's external IP, therefore you should replace the host part of the URI with your public IP address on which the `relaysrv` will be available:
-
-```bash
-relay://123.123.123.123:22067/?id=EZQOIDM-6DDD4ZI-DJ65NSM-4OQWRAT-EIKSMJO-OZ552BO-WQZEGYY-STS5RQM&pingInterval=1m0s&networkTimeout=2m0s&sessionLimitBps=0&globalLimitBps=0&statusAddr=:22070
-```
-
-If you do not care about certificate pinning (improved security) or do not care about passing verbose settings to the clients, you can shorten the URL to just the host part:
-
-```bash
-relay://123.123.123.123:22067
-```
-
-This URI can then be used in `syncthing` as one of the relay servers.
-
-See `relaysrv -help` for other options, such as rate limits, timeout intervals, etc.
-
-Other items available in this repo
-----
-##### testutil
-A test utility which can be used to test connectivity of a relay server.
-You need to generate two x509 key pairs (key.pem and cert.pem), one for the client, another one for the server, in separate directories.
-Afterwards, start the client:
-```bash
-./testutil -relay="relay://uri.of.relay" -keys=certs/client/ -join
-```
-
-This prints out the client ID:
-```
-2015/09/21 23:00:52 main.go:42: ID: BG2C5ZA-W7XPFDO-LH222Z6-65F3HJX-ADFTGRT-3SBFIGM-KV26O2Q-E5RMRQ2
-```
-
-In the other terminal run the following:
-
-```bash
- ./testutil -relay="relay://uri.of.relay" -keys=certs/server/ -connect=BG2C5ZA-W7XPFDO-LH222Z6-65F3HJX-ADFTGRT-3SBFIGM-KV26O2Q-E5RMRQ2
-```
-
-Which should then give you an interactive prompt, where you can type things in one terminal, and they get relayed to the other terminal.
-
-Relay related libraries used by this repo
-----
-##### Relay protocol definition.
-
-[Available here](https://github.com/syncthing/syncthing/tree/master/lib/relay/protocol)
-
-
-##### Relay client
-
-Only used by the testutil.
-
-[Available here](https://github.com/syncthing/syncthing/tree/master/lib/relay/client)
-
-

cmd/relaysrv/etc/linux-systemd/syncthing-relaysrv.service

@@ -1,17 +0,0 @@
-[Unit]
-Description=Syncthing relay server
-After=network.target
-
-[Service]
-User=syncthing-relaysrv
-Group=syncthing-relaysrv
-ExecStart=/usr/bin/relaysrv
-WorkingDirectory=/var/lib/syncthing-relaysrv
-
-PrivateTmp=true
-ProtectSystem=full
-ProtectHome=true
-NoNewPrivileges=true
-
-[Install]
-WantedBy=multi-user.target

cmd/relaysrv/listener.go

@@ -1,345 +0,0 @@
-// Copyright (C) 2015 Audrius Butkevicius and Contributors.
-
-package main
-
-import (
-	"crypto/tls"
-	"encoding/hex"
-	"log"
-	"net"
-	"sync"
-	"sync/atomic"
-	"time"
-
-	syncthingprotocol "github.com/syncthing/syncthing/lib/protocol"
-	"github.com/syncthing/syncthing/lib/tlsutil"
-
-	"github.com/syncthing/syncthing/lib/relay/protocol"
-)
-
-var (
-	outboxesMut    = sync.RWMutex{}
-	outboxes       = make(map[syncthingprotocol.DeviceID]chan interface{})
-	numConnections int64
-)
-
-func listener(addr string, config *tls.Config) {
-	tcpListener, err := net.Listen("tcp", addr)
-	if err != nil {
-		log.Fatalln(err)
-	}
-
-	listener := tlsutil.DowngradingListener{
-		Listener: tcpListener,
-	}
-
-	for {
-		conn, isTLS, err := listener.AcceptNoWrapTLS()
-		if err != nil {
-			if debug {
-				log.Println("Listener failed to accept connection from", conn.RemoteAddr(), ". Possibly a TCP Ping.")
-			}
-			continue
-		}
-
-		setTCPOptions(conn)
-
-		if debug {
-			log.Println("Listener accepted connection from", conn.RemoteAddr(), "tls", isTLS)
-		}
-
-		if isTLS {
-			go protocolConnectionHandler(conn, config)
-		} else {
-			go sessionConnectionHandler(conn)
-		}
-
-	}
-}
-
-func protocolConnectionHandler(tcpConn net.Conn, config *tls.Config) {
-	conn := tls.Server(tcpConn, config)
-	err := conn.Handshake()
-	if err != nil {
-		if debug {
-			log.Println("Protocol connection TLS handshake:", conn.RemoteAddr(), err)
-		}
-		conn.Close()
-		return
-	}
-
-	state := conn.ConnectionState()
-	if (!state.NegotiatedProtocolIsMutual || state.NegotiatedProtocol != protocol.ProtocolName) && debug {
-		log.Println("Protocol negotiation error")
-	}
-
-	certs := state.PeerCertificates
-	if len(certs) != 1 {
-		if debug {
-			log.Println("Certificate list error")
-		}
-		conn.Close()
-		return
-	}
-
-	id := syncthingprotocol.NewDeviceID(certs[0].Raw)
-
-	messages := make(chan interface{})
-	errors := make(chan error, 1)
-	outbox := make(chan interface{})
-
-	// Read messages from the connection and send them on the messages
-	// channel. When there is an error, send it on the error channel and
-	// return. Applies also when the connection gets closed, so the pattern
-	// below is to close the connection on error, then wait for the error
-	// signal from messageReader to exit.
-	go messageReader(conn, messages, errors)
-
-	pingTicker := time.NewTicker(pingInterval)
-	timeoutTicker := time.NewTimer(networkTimeout)
-	joined := false
-
-	for {
-		select {
-		case message := <-messages:
-			timeoutTicker.Reset(networkTimeout)
-			if debug {
-				log.Printf("Message %T from %s", message, id)
-			}
-
-			switch msg := message.(type) {
-			case protocol.JoinRelayRequest:
-				if atomic.LoadInt32(&overLimit) > 0 {
-					protocol.WriteMessage(conn, protocol.RelayFull{})
-					if debug {
-						log.Println("Refusing join request from", id, "due to being over limits")
-					}
-					conn.Close()
-					limitCheckTimer.Reset(time.Second)
-					continue
-				}
-
-				outboxesMut.RLock()
-				_, ok := outboxes[id]
-				outboxesMut.RUnlock()
-				if ok {
-					protocol.WriteMessage(conn, protocol.ResponseAlreadyConnected)
-					if debug {
-						log.Println("Already have a peer with the same ID", id, conn.RemoteAddr())
-					}
-					conn.Close()
-					continue
-				}
-
-				outboxesMut.Lock()
-				outboxes[id] = outbox
-				outboxesMut.Unlock()
-				joined = true
-
-				protocol.WriteMessage(conn, protocol.ResponseSuccess)
-
-			case protocol.ConnectRequest:
-				requestedPeer := syncthingprotocol.DeviceIDFromBytes(msg.ID)
-				outboxesMut.RLock()
-				peerOutbox, ok := outboxes[requestedPeer]
-				outboxesMut.RUnlock()
-				if !ok {
-					if debug {
-						log.Println(id, "is looking for", requestedPeer, "which does not exist")
-					}
-					protocol.WriteMessage(conn, protocol.ResponseNotFound)
-					conn.Close()
-					continue
-				}
-				// requestedPeer is the server, id is the client
-				ses := newSession(requestedPeer, id, sessionLimiter, globalLimiter)
-
-				go ses.Serve()
-
-				clientInvitation := ses.GetClientInvitationMessage()
-				serverInvitation := ses.GetServerInvitationMessage()
-
-				if err := protocol.WriteMessage(conn, clientInvitation); err != nil {
-					if debug {
-						log.Printf("Error sending invitation from %s to client: %s", id, err)
-					}
-					conn.Close()
-					continue
-				}
-
-				peerOutbox <- serverInvitation
-
-				if debug {
-					log.Println("Sent invitation from", id, "to", requestedPeer)
-				}
-				conn.Close()
-
-			case protocol.Ping:
-				if err := protocol.WriteMessage(conn, protocol.Pong{}); err != nil {
-					if debug {
-						log.Println("Error writing pong:", err)
-					}
-					conn.Close()
-					continue
-				}
-
-			case protocol.Pong:
-				// Nothing
-
-			default:
-				if debug {
-					log.Printf("Unknown message %s: %T", id, message)
-				}
-				protocol.WriteMessage(conn, protocol.ResponseUnexpectedMessage)
-				conn.Close()
-			}
-
-		case err := <-errors:
-			if debug {
-				log.Printf("Closing connection %s: %s", id, err)
-			}
-			close(outbox)
-
-			// Potentially closing a second time.
-			conn.Close()
-
-			if joined {
-				// Only delete the outbox if the client is joined, as it might be
-				// a lookup request coming from the same client.
-				outboxesMut.Lock()
-				delete(outboxes, id)
-				outboxesMut.Unlock()
-				// Also, kill all sessions related to this node, as it probably
-				// went offline. This is for the other end to realize the client
-				// is no longer there faster. This also helps resolve
-				// 'already connected' errors when one of the sides is
-				// restarting, and connecting to the other peer before the other
-				// peer even realised that the node has gone away.
-				dropSessions(id)
-			}
-			return
-
-		case <-pingTicker.C:
-			if !joined {
-				if debug {
-					log.Println(id, "didn't join within", pingInterval)
-				}
-				conn.Close()
-				continue
-			}
-
-			if err := protocol.WriteMessage(conn, protocol.Ping{}); err != nil {
-				if debug {
-					log.Println(id, err)
-				}
-				conn.Close()
-			}
-
-			if atomic.LoadInt32(&overLimit) > 0 && !hasSessions(id) {
-				if debug {
-					log.Println("Dropping", id, "as it has no sessions and we are over our limits")
-				}
-				protocol.WriteMessage(conn, protocol.RelayFull{})
-				conn.Close()
-
-				limitCheckTimer.Reset(time.Second)
-			}
-
-		case <-timeoutTicker.C:
-			// We should receive a error from the reader loop, which will cause
-			// us to quit this loop.
-			if debug {
-				log.Printf("%s timed out", id)
-			}
-			conn.Close()
-
-		case msg := <-outbox:
-			if msg == nil {
-				conn.Close()
-				return
-			}
-			if debug {
-				log.Printf("Sending message %T to %s", msg, id)
-			}
-			if err := protocol.WriteMessage(conn, msg); err != nil {
-				if debug {
-					log.Println(id, err)
-				}
-				conn.Close()
-			}
-		}
-	}
-}
-
-func sessionConnectionHandler(conn net.Conn) {
-	if err := conn.SetDeadline(time.Now().Add(messageTimeout)); err != nil {
-		if debug {
-			log.Println("Weird error setting deadline:", err, "on", conn.RemoteAddr())
-		}
-		return
-	}
-
-	message, err := protocol.ReadMessage(conn)
-	if err != nil {
-		return
-	}
-
-	switch msg := message.(type) {
-	case protocol.JoinSessionRequest:
-		ses := findSession(string(msg.Key))
-		if debug {
-			log.Println(conn.RemoteAddr(), "session lookup", ses, hex.EncodeToString(msg.Key)[:5])
-		}
-
-		if ses == nil {
-			protocol.WriteMessage(conn, protocol.ResponseNotFound)
-			conn.Close()
-			return
-		}
-
-		if !ses.AddConnection(conn) {
-			if debug {
-				log.Println("Failed to add", conn.RemoteAddr(), "to session", ses)
-			}
-			protocol.WriteMessage(conn, protocol.ResponseAlreadyConnected)
-			conn.Close()
-			return
-		}
-
-		if err := protocol.WriteMessage(conn, protocol.ResponseSuccess); err != nil {
-			if debug {
-				log.Println("Failed to send session join response to ", conn.RemoteAddr(), "for", ses)
-			}
-			return
-		}
-
-		if err := conn.SetDeadline(time.Time{}); err != nil {
-			if debug {
-				log.Println("Weird error setting deadline:", err, "on", conn.RemoteAddr())
-			}
-			conn.Close()
-			return
-		}
-
-	default:
-		if debug {
-			log.Println("Unexpected message from", conn.RemoteAddr(), message)
-		}
-		protocol.WriteMessage(conn, protocol.ResponseUnexpectedMessage)
-		conn.Close()
-	}
-}
-
-func messageReader(conn net.Conn, messages chan<- interface{}, errors chan<- error) {
-	atomic.AddInt64(&numConnections, 1)
-	defer atomic.AddInt64(&numConnections, -1)
-
-	for {
-		msg, err := protocol.ReadMessage(conn)
-		if err != nil {
-			errors <- err
-			return
-		}
-		messages <- msg
-	}
-}

cmd/relaysrv/main.go

@@ -1,224 +0,0 @@
-// Copyright (C) 2015 Audrius Butkevicius and Contributors.
-
-package main
-
-import (
-	"crypto/tls"
-	"flag"
-	"fmt"
-	"log"
-	"net"
-	"net/url"
-	"os"
-	"os/signal"
-	"path/filepath"
-	"runtime"
-	"strconv"
-	"strings"
-	"sync/atomic"
-	"syscall"
-	"time"
-
-	"github.com/juju/ratelimit"
-	"github.com/syncthing/syncthing/lib/osutil"
-	"github.com/syncthing/syncthing/lib/relay/protocol"
-	"github.com/syncthing/syncthing/lib/tlsutil"
-
-	syncthingprotocol "github.com/syncthing/syncthing/lib/protocol"
-)
-
-var (
-	Version    string
-	BuildStamp string
-	BuildUser  string
-	BuildHost  string
-
-	BuildDate   time.Time
-	LongVersion string
-)
-
-func init() {
-	stamp, _ := strconv.Atoi(BuildStamp)
-	BuildDate = time.Unix(int64(stamp), 0)
-
-	date := BuildDate.UTC().Format("2006-01-02 15:04:05 MST")
-	LongVersion = fmt.Sprintf(`relaysrv %s (%s %s-%s) %s@%s %s`, Version, runtime.Version(), runtime.GOOS, runtime.GOARCH, BuildUser, BuildHost, date)
-}
-
-var (
-	listen string
-	debug  bool
-
-	sessionAddress []byte
-	sessionPort    uint16
-
-	networkTimeout = 2 * time.Minute
-	pingInterval   = time.Minute
-	messageTimeout = time.Minute
-
-	limitCheckTimer *time.Timer
-
-	sessionLimitBps int
-	globalLimitBps  int
-	overLimit       int32
-	descriptorLimit int64
-	sessionLimiter  *ratelimit.Bucket
-	globalLimiter   *ratelimit.Bucket
-
-	statusAddr       string
-	poolAddrs        string
-	pools            []string
-	providedBy       string
-	defaultPoolAddrs = "https://relays.syncthing.net/endpoint"
-)
-
-func main() {
-	log.SetFlags(log.Lshortfile | log.LstdFlags)
-
-	var dir, extAddress string
-
-	flag.StringVar(&listen, "listen", ":22067", "Protocol listen address")
-	flag.StringVar(&dir, "keys", ".", "Directory where cert.pem and key.pem is stored")
-	flag.DurationVar(&networkTimeout, "network-timeout", networkTimeout, "Timeout for network operations between the client and the relay.\n\tIf no data is received between the client and the relay in this period of time, the connection is terminated.\n\tFurthermore, if no data is sent between either clients being relayed within this period of time, the session is also terminated.")
-	flag.DurationVar(&pingInterval, "ping-interval", pingInterval, "How often pings are sent")
-	flag.DurationVar(&messageTimeout, "message-timeout", messageTimeout, "Maximum amount of time we wait for relevant messages to arrive")
-	flag.IntVar(&sessionLimitBps, "per-session-rate", sessionLimitBps, "Per session rate limit, in bytes/s")
-	flag.IntVar(&globalLimitBps, "global-rate", globalLimitBps, "Global rate limit, in bytes/s")
-	flag.BoolVar(&debug, "debug", debug, "Enable debug output")
-	flag.StringVar(&statusAddr, "status-srv", ":22070", "Listen address for status service (blank to disable)")
-	flag.StringVar(&poolAddrs, "pools", defaultPoolAddrs, "Comma separated list of relay pool addresses to join")
-	flag.StringVar(&providedBy, "provided-by", "", "An optional description about who provides the relay")
-	flag.StringVar(&extAddress, "ext-address", "", "An optional address to advertising as being available on.\n\tAllows listening on an unprivileged port with port forwarding from e.g. 443, and be connected to on port 443.")
-
-	flag.Parse()
-
-	if extAddress == "" {
-		extAddress = listen
-	}
-
-	addr, err := net.ResolveTCPAddr("tcp", extAddress)
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	log.Println(LongVersion)
-
-	maxDescriptors, err := osutil.MaximizeOpenFileLimit()
-	if maxDescriptors > 0 {
-		// Assume that 20% of FD's are leaked/unaccounted for.
-		descriptorLimit = int64(maxDescriptors*80) / 100
-		log.Println("Connection limit", descriptorLimit)
-
-		go monitorLimits()
-	} else if err != nil && runtime.GOOS != "windows" {
-		log.Println("Assuming no connection limit, due to error retrievign rlimits:", err)
-	}
-
-	sessionAddress = addr.IP[:]
-	sessionPort = uint16(addr.Port)
-
-	certFile, keyFile := filepath.Join(dir, "cert.pem"), filepath.Join(dir, "key.pem")
-	cert, err := tls.LoadX509KeyPair(certFile, keyFile)
-	if err != nil {
-		log.Println("Failed to load keypair. Generating one, this might take a while...")
-		cert, err = tlsutil.NewCertificate(certFile, keyFile, "relaysrv", 3072)
-		if err != nil {
-			log.Fatalln("Failed to generate X509 key pair:", err)
-		}
-	}
-
-	tlsCfg := &tls.Config{
-		Certificates:           []tls.Certificate{cert},
-		NextProtos:             []string{protocol.ProtocolName},
-		ClientAuth:             tls.RequestClientCert,
-		SessionTicketsDisabled: true,
-		InsecureSkipVerify:     true,
-		MinVersion:             tls.VersionTLS12,
-		CipherSuites: []uint16{
-			tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
-			tls.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
-			tls.TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA,
-			tls.TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA,
-			tls.TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA,
-			tls.TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA,
-		},
-	}
-
-	id := syncthingprotocol.NewDeviceID(cert.Certificate[0])
-	if debug {
-		log.Println("ID:", id)
-	}
-
-	if sessionLimitBps > 0 {
-		sessionLimiter = ratelimit.NewBucketWithRate(float64(sessionLimitBps), int64(2*sessionLimitBps))
-	}
-	if globalLimitBps > 0 {
-		globalLimiter = ratelimit.NewBucketWithRate(float64(globalLimitBps), int64(2*globalLimitBps))
-	}
-
-	if statusAddr != "" {
-		go statusService(statusAddr)
-	}
-
-	uri, err := url.Parse(fmt.Sprintf("relay://%s/?id=%s&pingInterval=%s&networkTimeout=%s&sessionLimitBps=%d&globalLimitBps=%d&statusAddr=%s&providedBy=%s", extAddress, id, pingInterval, networkTimeout, sessionLimitBps, globalLimitBps, statusAddr, providedBy))
-	if err != nil {
-		log.Fatalln("Failed to construct URI", err)
-	}
-
-	log.Println("URI:", uri.String())
-
-	if poolAddrs == defaultPoolAddrs {
-		log.Println("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
-		log.Println("!!  Joining default relay pools, this relay will be available for public use. !!")
-		log.Println(`!!      Use the -pools="" command line option to make the relay private.      !!`)
-		log.Println("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
-	}
-
-	pools = strings.Split(poolAddrs, ",")
-	for _, pool := range pools {
-		pool = strings.TrimSpace(pool)
-		if len(pool) > 0 {
-			go poolHandler(pool, uri)
-		}
-	}
-
-	go listener(listen, tlsCfg)
-
-	sigs := make(chan os.Signal, 1)
-	signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
-	<-sigs
-
-	// Gracefully close all connections, hoping that clients will be faster
-	// to realize that the relay is now gone.
-
-	sessionMut.RLock()
-	for _, session := range activeSessions {
-		session.CloseConns()
-	}
-
-	for _, session := range pendingSessions {
-		session.CloseConns()
-	}
-	sessionMut.RUnlock()
-
-	outboxesMut.RLock()
-	for _, outbox := range outboxes {
-		close(outbox)
-	}
-	outboxesMut.RUnlock()
-
-	time.Sleep(500 * time.Millisecond)
-}
-
-func monitorLimits() {
-	limitCheckTimer = time.NewTimer(time.Minute)
-	for _ = range limitCheckTimer.C {
-		if atomic.LoadInt64(&numConnections)+atomic.LoadInt64(&numProxies) > descriptorLimit {
-			atomic.StoreInt32(&overLimit, 1)
-			log.Println("Gone past our connection limits. Starting to refuse new/drop idle connections.")
-		} else if atomic.CompareAndSwapInt32(&overLimit, 1, 0) {
-			log.Println("Dropped below our connection limits. Accepting new connections.")
-		}
-		limitCheckTimer.Reset(time.Minute)
-	}
-}

cmd/relaysrv/pool.go

@@ -1,63 +0,0 @@
-// Copyright (C) 2015 Audrius Butkevicius and Contributors.
-
-package main
-
-import (
-	"bytes"
-	"encoding/json"
-	"io/ioutil"
-	"log"
-	"net/http"
-	"net/url"
-	"time"
-)
-
-func poolHandler(pool string, uri *url.URL) {
-	if debug {
-		log.Println("Joining", pool)
-	}
-	for {
-		var b bytes.Buffer
-		json.NewEncoder(&b).Encode(struct {
-			URL string `json:"url"`
-		}{
-			uri.String(),
-		})
-
-		resp, err := http.Post(pool, "application/json", &b)
-		if err != nil {
-			log.Println("Error joining pool", pool, err)
-		} else if resp.StatusCode == 500 {
-			bs, err := ioutil.ReadAll(resp.Body)
-			if err != nil {
-				log.Println("Failed to join", pool, "due to an internal server error. Could not read response:", err)
-			} else {
-				log.Println("Failed to join", pool, "due to an internal server error:", string(bs))
-			}
-			resp.Body.Close()
-		} else if resp.StatusCode == 429 {
-			log.Println(pool, "under load, will retry in a minute")
-			time.Sleep(time.Minute)
-			continue
-		} else if resp.StatusCode == 403 {
-			log.Println(pool, "failed to join due to IP address not matching external address. Aborting")
-			return
-		} else if resp.StatusCode == 200 {
-			var x struct {
-				EvictionIn time.Duration `json:"evictionIn"`
-			}
-			err := json.NewDecoder(resp.Body).Decode(&x)
-			if err == nil {
-				rejoin := x.EvictionIn - (x.EvictionIn / 5)
-				log.Println("Joined", pool, "rejoining in", rejoin)
-				time.Sleep(rejoin)
-				continue
-			} else {
-				log.Println("Failed to deserialize response", err)
-			}
-		} else {
-			log.Println(pool, "unknown response type from server", resp.StatusCode)
-		}
-		time.Sleep(time.Hour)
-	}
-}

cmd/relaysrv/session.go

@@ -1,326 +0,0 @@
-// Copyright (C) 2015 Audrius Butkevicius and Contributors.
-
-package main
-
-import (
-	"crypto/rand"
-	"encoding/hex"
-	"fmt"
-	"log"
-	"net"
-	"sync"
-	"sync/atomic"
-	"time"
-
-	"github.com/juju/ratelimit"
-	"github.com/syncthing/syncthing/lib/relay/protocol"
-
-	syncthingprotocol "github.com/syncthing/syncthing/lib/protocol"
-)
-
-var (
-	sessionMut      = sync.RWMutex{}
-	activeSessions  = make([]*session, 0)
-	pendingSessions = make(map[string]*session, 0)
-	numProxies      int64
-	bytesProxied    int64
-)
-
-func newSession(serverid, clientid syncthingprotocol.DeviceID, sessionRateLimit, globalRateLimit *ratelimit.Bucket) *session {
-	serverkey := make([]byte, 32)
-	_, err := rand.Read(serverkey)
-	if err != nil {
-		return nil
-	}
-
-	clientkey := make([]byte, 32)
-	_, err = rand.Read(clientkey)
-	if err != nil {
-		return nil
-	}
-
-	ses := &session{
-		serverkey: serverkey,
-		serverid:  serverid,
-		clientkey: clientkey,
-		clientid:  clientid,
-		rateLimit: makeRateLimitFunc(sessionRateLimit, globalRateLimit),
-		connsChan: make(chan net.Conn),
-		conns:     make([]net.Conn, 0, 2),
-	}
-
-	if debug {
-		log.Println("New session", ses)
-	}
-
-	sessionMut.Lock()
-	pendingSessions[string(ses.serverkey)] = ses
-	pendingSessions[string(ses.clientkey)] = ses
-	sessionMut.Unlock()
-
-	return ses
-}
-
-func findSession(key string) *session {
-	sessionMut.Lock()
-	defer sessionMut.Unlock()
-	ses, ok := pendingSessions[key]
-	if !ok {
-		return nil
-
-	}
-	delete(pendingSessions, key)
-	return ses
-}
-
-func dropSessions(id syncthingprotocol.DeviceID) {
-	sessionMut.RLock()
-	for _, session := range activeSessions {
-		if session.HasParticipant(id) {
-			if debug {
-				log.Println("Dropping session", session, "involving", id)
-			}
-			session.CloseConns()
-		}
-	}
-	sessionMut.RUnlock()
-}
-
-func hasSessions(id syncthingprotocol.DeviceID) bool {
-	sessionMut.RLock()
-	has := false
-	for _, session := range activeSessions {
-		if session.HasParticipant(id) {
-			has = true
-			break
-		}
-	}
-	sessionMut.RUnlock()
-	return has
-}
-
-type session struct {
-	mut sync.Mutex
-
-	serverkey []byte
-	serverid  syncthingprotocol.DeviceID
-
-	clientkey []byte
-	clientid  syncthingprotocol.DeviceID
-
-	rateLimit func(bytes int64)
-
-	connsChan chan net.Conn
-	conns     []net.Conn
-}
-
-func (s *session) AddConnection(conn net.Conn) bool {
-	if debug {
-		log.Println("New connection for", s, "from", conn.RemoteAddr())
-	}
-
-	select {
-	case s.connsChan <- conn:
-		return true
-	default:
-	}
-	return false
-}
-
-func (s *session) Serve() {
-	timedout := time.After(messageTimeout)
-
-	if debug {
-		log.Println("Session", s, "serving")
-	}
-
-	for {
-		select {
-		case conn := <-s.connsChan:
-			s.mut.Lock()
-			s.conns = append(s.conns, conn)
-			s.mut.Unlock()
-			// We're the only ones mutating s.conns, hence we are free to read it.
-			if len(s.conns) < 2 {
-				continue
-			}
-
-			close(s.connsChan)
-
-			if debug {
-				log.Println("Session", s, "starting between", s.conns[0].RemoteAddr(), "and", s.conns[1].RemoteAddr())
-			}
-
-			wg := sync.WaitGroup{}
-			wg.Add(2)
-
-			var err0 error
-			go func() {
-				err0 = s.proxy(s.conns[0], s.conns[1])
-				wg.Done()
-			}()
-
-			var err1 error
-			go func() {
-				err1 = s.proxy(s.conns[1], s.conns[0])
-				wg.Done()
-			}()
-
-			sessionMut.Lock()
-			activeSessions = append(activeSessions, s)
-			sessionMut.Unlock()
-
-			wg.Wait()
-
-			if debug {
-				log.Println("Session", s, "ended, outcomes:", err0, "and", err1)
-			}
-			goto done
-
-		case <-timedout:
-			if debug {
-				log.Println("Session", s, "timed out")
-			}
-			goto done
-		}
-	}
-done:
-	// We can end up here in 3 cases:
-	// 1. Timeout joining, in which case there are potentially entries in pendingSessions
-	// 2. General session end/timeout, in which case there are entries in activeSessions
-	// 3. Protocol handler calls dropSession as one of it's clients disconnects.
-
-	sessionMut.Lock()
-	delete(pendingSessions, string(s.serverkey))
-	delete(pendingSessions, string(s.clientkey))
-
-	for i, session := range activeSessions {
-		if session == s {
-			l := len(activeSessions) - 1
-			activeSessions[i] = activeSessions[l]
-			activeSessions[l] = nil
-			activeSessions = activeSessions[:l]
-		}
-	}
-	sessionMut.Unlock()
-
-	// If we are here because of case 2 or 3, we are potentially closing some or
-	// all connections a second time.
-	s.CloseConns()
-
-	if debug {
-		log.Println("Session", s, "stopping")
-	}
-}
-
-func (s *session) GetClientInvitationMessage() protocol.SessionInvitation {
-	return protocol.SessionInvitation{
-		From:         s.serverid[:],
-		Key:          []byte(s.clientkey),
-		Address:      sessionAddress,
-		Port:         sessionPort,
-		ServerSocket: false,
-	}
-}
-
-func (s *session) GetServerInvitationMessage() protocol.SessionInvitation {
-	return protocol.SessionInvitation{
-		From:         s.clientid[:],
-		Key:          []byte(s.serverkey),
-		Address:      sessionAddress,
-		Port:         sessionPort,
-		ServerSocket: true,
-	}
-}
-
-func (s *session) HasParticipant(id syncthingprotocol.DeviceID) bool {
-	return s.clientid == id || s.serverid == id
-}
-
-func (s *session) CloseConns() {
-	s.mut.Lock()
-	for _, conn := range s.conns {
-		conn.Close()
-	}
-	s.mut.Unlock()
-}
-
-func (s *session) proxy(c1, c2 net.Conn) error {
-	if debug {
-		log.Println("Proxy", c1.RemoteAddr(), "->", c2.RemoteAddr())
-	}
-
-	atomic.AddInt64(&numProxies, 1)
-	defer atomic.AddInt64(&numProxies, -1)
-
-	buf := make([]byte, 65536)
-	for {
-		c1.SetReadDeadline(time.Now().Add(networkTimeout))
-		n, err := c1.Read(buf)
-		if err != nil {
-			return err
-		}
-
-		atomic.AddInt64(&bytesProxied, int64(n))
-
-		if debug {
-			log.Printf("%d bytes from %s to %s", n, c1.RemoteAddr(), c2.RemoteAddr())
-		}
-
-		if s.rateLimit != nil {
-			s.rateLimit(int64(n))
-		}
-
-		c2.SetWriteDeadline(time.Now().Add(networkTimeout))
-		_, err = c2.Write(buf[:n])
-		if err != nil {
-			return err
-		}
-	}
-}
-
-func (s *session) String() string {
-	return fmt.Sprintf("<%s/%s>", hex.EncodeToString(s.clientkey)[:5], hex.EncodeToString(s.serverkey)[:5])
-}
-
-func makeRateLimitFunc(sessionRateLimit, globalRateLimit *ratelimit.Bucket) func(int64) {
-	// This may be a case of super duper premature optimization... We build an
-	// optimized function to do the rate limiting here based on what we need
-	// to do and then use it in the loop.
-
-	if sessionRateLimit == nil && globalRateLimit == nil {
-		// No limiting needed. We could equally well return a func(int64){} and
-		// not do a nil check were we use it, but I think the nil check there
-		// makes it clear that there will be no limiting if none is
-		// configured...
-		return nil
-	}
-
-	if sessionRateLimit == nil {
-		// We only have a global limiter
-		return func(bytes int64) {
-			globalRateLimit.Wait(bytes)
-		}
-	}
-
-	if globalRateLimit == nil {
-		// We only have a session limiter
-		return func(bytes int64) {
-			sessionRateLimit.Wait(bytes)
-		}
-	}
-
-	// We have both. Queue the bytes on both the global and session specific
-	// rate limiters. Wait for both in parallell, so that the actual send
-	// happens when both conditions are satisfied. In practice this just means
-	// wait the longer of the two times.
-	return func(bytes int64) {
-		t0 := sessionRateLimit.Take(bytes)
-		t1 := globalRateLimit.Take(bytes)
-		if t0 > t1 {
-			time.Sleep(t0)
-		} else {
-			time.Sleep(t1)
-		}
-	}
-}

cmd/relaysrv/status.go

@@ -1,111 +0,0 @@
-// Copyright (C) 2015 Audrius Butkevicius and Contributors.
-
-package main
-
-import (
-	"encoding/json"
-	"log"
-	"net/http"
-	"runtime"
-	"sync/atomic"
-	"time"
-)
-
-var rc *rateCalculator
-
-func statusService(addr string) {
-	rc = newRateCalculator(360, 10*time.Second, &bytesProxied)
-
-	http.HandleFunc("/status", getStatus)
-	if err := http.ListenAndServe(addr, nil); err != nil {
-		log.Fatal(err)
-	}
-}
-
-func getStatus(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Access-Control-Allow-Origin", "*")
-	status := make(map[string]interface{})
-
-	sessionMut.Lock()
-	// This can potentially be double the number of pending sessions, as each session has two keys, one for each side.
-	status["startTime"] = rc.startTime
-	status["uptimeSeconds"] = time.Since(rc.startTime) / time.Second
-	status["numPendingSessionKeys"] = len(pendingSessions)
-	status["numActiveSessions"] = len(activeSessions)
-	sessionMut.Unlock()
-	status["numConnections"] = atomic.LoadInt64(&numConnections)
-	status["numProxies"] = atomic.LoadInt64(&numProxies)
-	status["bytesProxied"] = atomic.LoadInt64(&bytesProxied)
-	status["goVersion"] = runtime.Version()
-	status["goOS"] = runtime.GOOS
-	status["goArch"] = runtime.GOARCH
-	status["goMaxProcs"] = runtime.GOMAXPROCS(-1)
-	status["goNumRoutine"] = runtime.NumGoroutine()
-	status["kbps10s1m5m15m30m60m"] = []int64{
-		rc.rate(10/10) * 8 / 1000,
-		rc.rate(60/10) * 8 / 1000,
-		rc.rate(5*60/10) * 8 / 1000,
-		rc.rate(15*60/10) * 8 / 1000,
-		rc.rate(30*60/10) * 8 / 1000,
-		rc.rate(60*60/10) * 8 / 1000,
-	}
-	status["options"] = map[string]interface{}{
-		"network-timeout":  networkTimeout / time.Second,
-		"ping-interval":    pingInterval / time.Second,
-		"message-timeout":  messageTimeout / time.Second,
-		"per-session-rate": sessionLimitBps,
-		"global-rate":      globalLimitBps,
-		"pools":            pools,
-		"provided-by":      providedBy,
-	}
-
-	bs, err := json.MarshalIndent(status, "", "    ")
-	if err != nil {
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-		return
-	}
-
-	w.Header().Set("Content-Type", "application/json")
-	w.Write(bs)
-}
-
-type rateCalculator struct {
-	rates     []int64
-	prev      int64
-	counter   *int64
-	startTime time.Time
-}
-
-func newRateCalculator(keepIntervals int, interval time.Duration, counter *int64) *rateCalculator {
-	r := &rateCalculator{
-		rates:     make([]int64, keepIntervals),
-		counter:   counter,
-		startTime: time.Now(),
-	}
-
-	go r.updateRates(interval)
-
-	return r
-}
-
-func (r *rateCalculator) updateRates(interval time.Duration) {
-	for {
-		now := time.Now()
-		next := now.Truncate(interval).Add(interval)
-		time.Sleep(next.Sub(now))
-
-		cur := atomic.LoadInt64(r.counter)
-		rate := int64(float64(cur-r.prev) / interval.Seconds())
-		copy(r.rates[1:], r.rates)
-		r.rates[0] = rate
-		r.prev = cur
-	}
-}
-
-func (r *rateCalculator) rate(periods int) int64 {
-	var tot int64
-	for i := 0; i < periods; i++ {
-		tot += r.rates[i]
-	}
-	return tot / int64(periods)
-}

cmd/relaysrv/testutil/main.go

@@ -1,152 +0,0 @@
-// Copyright (C) 2015 Audrius Butkevicius and Contributors (see the CONTRIBUTORS file).
-
-package main
-
-import (
-	"bufio"
-	"crypto/tls"
-	"flag"
-	"log"
-	"net"
-	"net/url"
-	"os"
-	"path/filepath"
-	"time"
-
-	syncthingprotocol "github.com/syncthing/syncthing/lib/protocol"
-	"github.com/syncthing/syncthing/lib/relay/client"
-	"github.com/syncthing/syncthing/lib/relay/protocol"
-)
-
-func main() {
-	log.SetOutput(os.Stdout)
-	log.SetFlags(log.LstdFlags | log.Lshortfile)
-
-	var connect, relay, dir string
-	var join, test bool
-
-	flag.StringVar(&connect, "connect", "", "Device ID to which to connect to")
-	flag.BoolVar(&join, "join", false, "Join relay")
-	flag.BoolVar(&test, "test", false, "Generic relay test")
-	flag.StringVar(&relay, "relay", "relay://127.0.0.1:22067", "Relay address")
-	flag.StringVar(&dir, "keys", ".", "Directory where cert.pem and key.pem is stored")
-
-	flag.Parse()
-
-	certFile, keyFile := filepath.Join(dir, "cert.pem"), filepath.Join(dir, "key.pem")
-	cert, err := tls.LoadX509KeyPair(certFile, keyFile)
-	if err != nil {
-		log.Fatalln("Failed to load X509 key pair:", err)
-	}
-
-	id := syncthingprotocol.NewDeviceID(cert.Certificate[0])
-	log.Println("ID:", id)
-
-	uri, err := url.Parse(relay)
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	stdin := make(chan string)
-
-	go stdinReader(stdin)
-
-	if join {
-		log.Println("Creating client")
-		relay, err := client.NewClient(uri, []tls.Certificate{cert}, nil, 10*time.Second)
-		if err != nil {
-			log.Fatal(err)
-		}
-		log.Println("Created client")
-
-		go relay.Serve()
-
-		recv := make(chan protocol.SessionInvitation)
-
-		go func() {
-			log.Println("Starting invitation receiver")
-			for invite := range relay.Invitations() {
-				select {
-				case recv <- invite:
-					log.Println("Received invitation", invite)
-				default:
-					log.Println("Discarding invitation", invite)
-				}
-			}
-		}()
-
-		for {
-			conn, err := client.JoinSession(<-recv)
-			if err != nil {
-				log.Fatalln("Failed to join", err)
-			}
-			log.Println("Joined", conn.RemoteAddr(), conn.LocalAddr())
-			connectToStdio(stdin, conn)
-			log.Println("Finished", conn.RemoteAddr(), conn.LocalAddr())
-		}
-	} else if connect != "" {
-		id, err := syncthingprotocol.DeviceIDFromString(connect)
-		if err != nil {
-			log.Fatal(err)
-		}
-
-		invite, err := client.GetInvitationFromRelay(uri, id, []tls.Certificate{cert}, 10*time.Second)
-		if err != nil {
-			log.Fatal(err)
-		}
-
-		log.Println("Received invitation", invite)
-		conn, err := client.JoinSession(invite)
-		if err != nil {
-			log.Fatalln("Failed to join", err)
-		}
-		log.Println("Joined", conn.RemoteAddr(), conn.LocalAddr())
-		connectToStdio(stdin, conn)
-		log.Println("Finished", conn.RemoteAddr(), conn.LocalAddr())
-	} else if test {
-		if client.TestRelay(uri, []tls.Certificate{cert}, time.Second, 2*time.Second, 4) {
-			log.Println("OK")
-		} else {
-			log.Println("FAIL")
-		}
-	} else {
-		log.Fatal("Requires either join or connect")
-	}
-}
-
-func stdinReader(c chan<- string) {
-	scanner := bufio.NewScanner(os.Stdin)
-	for scanner.Scan() {
-		c <- scanner.Text()
-		c <- "\n"
-	}
-}
-
-func connectToStdio(stdin <-chan string, conn net.Conn) {
-	go func() {
-
-	}()
-
-	buf := make([]byte, 1024)
-	for {
-		conn.SetReadDeadline(time.Now().Add(time.Millisecond))
-		n, err := conn.Read(buf[0:])
-		if err != nil {
-			nerr, ok := err.(net.Error)
-			if !ok || !nerr.Timeout() {
-				log.Println(err)
-				return
-			}
-		}
-		os.Stdout.Write(buf[:n])
-
-		select {
-		case msg := <-stdin:
-			_, err := conn.Write([]byte(msg))
-			if err != nil {
-				return
-			}
-		default:
-		}
-	}
-}

cmd/relaysrv/utils.go

@@ -1,28 +0,0 @@
-// Copyright (C) 2015 Audrius Butkevicius and Contributors.
-
-package main
-
-import (
-	"errors"
-	"net"
-)
-
-func setTCPOptions(conn net.Conn) error {
-	tcpConn, ok := conn.(*net.TCPConn)
-	if !ok {
-		return errors.New("Not a TCP connection")
-	}
-	if err := tcpConn.SetLinger(0); err != nil {
-		return err
-	}
-	if err := tcpConn.SetNoDelay(true); err != nil {
-		return err
-	}
-	if err := tcpConn.SetKeepAlivePeriod(networkTimeout); err != nil {
-		return err
-	}
-	if err := tcpConn.SetKeepAlive(true); err != nil {
-		return err
-	}
-	return nil
-}

cmd/stbench/main.go

@@ -1,143 +0,0 @@
-// Copyright (C) 2016 The Syncthing Authors.
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this file,
-// You can obtain one at http://mozilla.org/MPL/2.0/.
-
-// This doesn't build on Windows due to the Rusage stuff.
-
-// +build !windows
-
-package main
-
-import (
-	"flag"
-	"fmt"
-	"log"
-	"runtime"
-	"syscall"
-	"time"
-
-	"github.com/syncthing/syncthing/lib/rc"
-)
-
-var homeDir = "h1"
-var syncthingBin = "./bin/syncthing"
-var test = "scan"
-
-func main() {
-	flag.StringVar(&homeDir, "home", homeDir, "Home directory location")
-	flag.StringVar(&syncthingBin, "bin", syncthingBin, "Binary location")
-	flag.StringVar(&test, "test", test, "Test to run")
-	flag.Parse()
-
-	switch test {
-	case "scan":
-		// scan measures the resource usage required to perform the initial
-		// scan, without cleaning away the database first.
-		testScan()
-	}
-}
-
-// testScan starts a process and reports on the resource usage required to
-// perform the initial scan.
-func testScan() {
-	log.Println("Starting...")
-	p := rc.NewProcess("127.0.0.1:8081")
-	if err := p.Start(syncthingBin, "-home", homeDir, "-no-browser"); err != nil {
-		log.Println(err)
-		return
-	}
-	defer p.Stop()
-
-	wallTime := awaitScanComplete(p)
-
-	report(p, wallTime)
-}
-
-// awaitScanComplete waits for a folder to transition idle->scanning and
-// then scanning->idle and returns the time taken for the scan.
-func awaitScanComplete(p *rc.Process) time.Duration {
-	log.Println("Awaiting scan completion...")
-	var t0, t1 time.Time
-	lastEvent := 0
-loop:
-	for {
-		evs, err := p.Events(lastEvent)
-		if err != nil {
-			continue
-		}
-
-		for _, ev := range evs {
-			if ev.Type == "StateChanged" {
-				data := ev.Data.(map[string]interface{})
-				log.Println(ev)
-
-				if data["to"].(string) == "scanning" {
-					t0 = ev.Time
-					continue
-				}
-
-				if !t0.IsZero() && data["to"].(string) == "idle" {
-					t1 = ev.Time
-					break loop
-				}
-			}
-			lastEvent = ev.ID
-		}
-
-		time.Sleep(250 * time.Millisecond)
-	}
-
-	return t1.Sub(t0)
-}
-
-// report stops the given process and reports on it's resource usage in two
-// ways: human readable to stderr, and CSV to stdout.
-func report(p *rc.Process, wallTime time.Duration) {
-	sv, err := p.SystemVersion()
-	if err != nil {
-		log.Println(err)
-		return
-	}
-
-	ss, err := p.SystemStatus()
-	if err != nil {
-		log.Println(err)
-		return
-	}
-
-	proc, err := p.Stop()
-	if err != nil {
-		return
-	}
-
-	rusage, ok := proc.SysUsage().(*syscall.Rusage)
-	if !ok {
-		return
-	}
-
-	log.Println("Version:", sv.Version)
-	log.Println("Alloc:", ss.Alloc/1024, "KiB")
-	log.Println("Sys:", ss.Sys/1024, "KiB")
-	log.Println("Goroutines:", ss.Goroutines)
-	log.Println("Wall time:", wallTime)
-	log.Println("Utime:", time.Duration(rusage.Utime.Nano()))
-	log.Println("Stime:", time.Duration(rusage.Stime.Nano()))
-	if runtime.GOOS == "darwin" {
-		// Darwin reports in bytes, Linux seems to report in KiB even
-		// though the manpage says otherwise.
-		rusage.Maxrss /= 1024
-	}
-	log.Println("MaxRSS:", rusage.Maxrss, "KiB")
-
-	fmt.Printf("%s,%d,%d,%d,%.02f,%.02f,%.02f,%d\n",
-		sv.Version,
-		ss.Alloc/1024,
-		ss.Sys/1024,
-		ss.Goroutines,
-		wallTime.Seconds(),
-		time.Duration(rusage.Utime.Nano()).Seconds(),
-		time.Duration(rusage.Stime.Nano()).Seconds(),
-		rusage.Maxrss)
-}

cmd/stcompdirs/main.go

@@ -1,168 +0,0 @@
-// Copyright (C) 2014 The Syncthing Authors.
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this file,
-// You can obtain one at http://mozilla.org/MPL/2.0/.
-
-package main
-
-import (
-	"crypto/md5"
-	"errors"
-	"flag"
-	"fmt"
-	"io"
-	"log"
-	"os"
-	"path/filepath"
-
-	"github.com/syncthing/syncthing/lib/symlinks"
-)
-
-func main() {
-	flag.Parse()
-	log.Println(compareDirectories(flag.Args()...))
-}
-
-// Compare a number of directories. Returns nil if the contents are identical,
-// otherwise an error describing the first found difference.
-func compareDirectories(dirs ...string) error {
-	chans := make([]chan fileInfo, len(dirs))
-	for i := range chans {
-		chans[i] = make(chan fileInfo)
-	}
-	errcs := make([]chan error, len(dirs))
-	abort := make(chan struct{})
-
-	for i := range dirs {
-		errcs[i] = startWalker(dirs[i], chans[i], abort)
-	}
-
-	res := make([]fileInfo, len(dirs))
-	for {
-		numDone := 0
-		for i := range chans {
-			fi, ok := <-chans[i]
-			if !ok {
-				err, hasError := <-errcs[i]
-				if hasError {
-					close(abort)
-					return err
-				}
-				numDone++
-			}
-			res[i] = fi
-		}
-
-		for i := 1; i < len(res); i++ {
-			if res[i] != res[0] {
-				close(abort)
-				if res[i].name < res[0].name {
-					return fmt.Errorf("%s missing %v (present in %s)", dirs[0], res[i], dirs[i])
-				} else if res[i].name > res[0].name {
-					return fmt.Errorf("%s missing %v (present in %s)", dirs[i], res[0], dirs[0])
-				}
-				return fmt.Errorf("Mismatch; %v (%s) != %v (%s)", res[i], dirs[i], res[0], dirs[0])
-			}
-		}
-
-		if numDone == len(dirs) {
-			return nil
-		}
-	}
-}
-
-type fileInfo struct {
-	name string
-	mode os.FileMode
-	mod  int64
-	hash [16]byte
-}
-
-func (f fileInfo) String() string {
-	return fmt.Sprintf("%s %04o %d %x", f.name, f.mode, f.mod, f.hash)
-}
-
-func startWalker(dir string, res chan<- fileInfo, abort <-chan struct{}) chan error {
-	walker := func(path string, info os.FileInfo, err error) error {
-		if err != nil {
-			return err
-		}
-
-		rn, _ := filepath.Rel(dir, path)
-		if rn == "." || rn == ".stfolder" {
-			return nil
-		}
-		if rn == ".stversions" {
-			return filepath.SkipDir
-		}
-
-		var f fileInfo
-		if info.Mode()&os.ModeSymlink != 0 {
-			f = fileInfo{
-				name: rn,
-				mode: os.ModeSymlink,
-			}
-
-			tgt, _, err := symlinks.Read(path)
-			if err != nil {
-				return err
-			}
-			h := md5.New()
-			h.Write([]byte(tgt))
-			hash := h.Sum(nil)
-
-			copy(f.hash[:], hash)
-		} else if info.IsDir() {
-			f = fileInfo{
-				name: rn,
-				mode: info.Mode(),
-				// hash and modtime zero for directories
-			}
-		} else {
-			f = fileInfo{
-				name: rn,
-				mode: info.Mode(),
-				mod:  info.ModTime().Unix(),
-			}
-			sum, err := md5file(path)
-			if err != nil {
-				return err
-			}
-			f.hash = sum
-		}
-
-		select {
-		case res <- f:
-			return nil
-		case <-abort:
-			return errors.New("abort")
-		}
-	}
-
-	errc := make(chan error)
-	go func() {
-		err := filepath.Walk(dir, walker)
-		close(res)
-		if err != nil {
-			errc <- err
-		}
-		close(errc)
-	}()
-	return errc
-}
-
-func md5file(fname string) (hash [16]byte, err error) {
-	f, err := os.Open(fname)
-	if err != nil {
-		return
-	}
-	defer f.Close()
-
-	h := md5.New()
-	io.Copy(h, f)
-	hb := h.Sum(nil)
-	copy(hash[:], hb)
-
-	return
-}

cmd/stdisco/main.go

@@ -1,126 +0,0 @@
-// Copyright (C) 2016 The Syncthing Authors.
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this file,
-// You can obtain one at http://mozilla.org/MPL/2.0/.
-
-package main
-
-import (
-	"bytes"
-	"crypto/rand"
-	"flag"
-	"log"
-	"strings"
-	"time"
-
-	"github.com/syncthing/syncthing/lib/beacon"
-	"github.com/syncthing/syncthing/lib/discover"
-	"github.com/syncthing/syncthing/lib/protocol"
-)
-
-var (
-	all  = false // print all packets, not just first from each device/source
-	fake = false // send fake packets to lure out other devices faster
-	mc   = "[ff12::8384]:21027"
-	bc   = 21027
-)
-
-var (
-	// Static prefix that we use when generating fake device IDs, so that we
-	// can recognize them ourselves. Also makes the device ID start with
-	// "STPROBE-" which is humanly recognizable.
-	randomPrefix = []byte{148, 223, 23, 4, 148}
-
-	// Our random, fake, device ID that we use when sending announcements.
-	myID = randomDeviceID()
-)
-
-func main() {
-	flag.BoolVar(&all, "all", all, "Print all received announcements (not only first)")
-	flag.BoolVar(&fake, "fake", fake, "Send fake announcements")
-	flag.StringVar(&mc, "mc", mc, "IPv6 multicast address")
-	flag.IntVar(&bc, "bc", bc, "IPv4 broadcast port number")
-	flag.Parse()
-
-	if fake {
-		log.Println("My ID:", protocol.DeviceIDFromBytes(myID))
-	}
-
-	runbeacon(beacon.NewMulticast(mc), fake)
-	runbeacon(beacon.NewBroadcast(bc), fake)
-
-	select {}
-}
-
-func runbeacon(bc beacon.Interface, fake bool) {
-	go bc.Serve()
-	go recv(bc)
-	if fake {
-		go send(bc)
-	}
-}
-
-// receives and prints discovery announcements
-func recv(bc beacon.Interface) {
-	seen := make(map[string]bool)
-	for {
-		data, src := bc.Recv()
-		var ann discover.Announce
-		ann.UnmarshalXDR(data)
-
-		if bytes.Equal(ann.This.ID, myID) {
-			// This is one of our own fake packets, don't print it.
-			continue
-		}
-
-		// Print announcement details for the first packet from a given
-		// device ID and source address, or if -all was given.
-		key := string(ann.This.ID) + src.String()
-		if all || !seen[key] {
-			log.Printf("Announcement from %v\n", src)
-			log.Printf(" %v at %s\n", protocol.DeviceIDFromBytes(ann.This.ID), strings.Join(addrStrs(ann.This), ", "))
-
-			for _, dev := range ann.Extra {
-				log.Printf(" %v at %s\n", protocol.DeviceIDFromBytes(dev.ID), strings.Join(addrStrs(dev), ", "))
-			}
-			seen[key] = true
-		}
-	}
-}
-
-// sends fake discovery announcements once every second
-func send(bc beacon.Interface) {
-	ann := discover.Announce{
-		Magic: discover.AnnouncementMagic,
-		This: discover.Device{
-			ID: myID,
-			Addresses: []discover.Address{
-				{URL: "tcp://fake.example.com:12345"},
-			},
-		},
-	}
-	bs, _ := ann.MarshalXDR()
-
-	for {
-		bc.Send(bs)
-		time.Sleep(time.Second)
-	}
-}
-
-// returns the list of address URLs
-func addrStrs(dev discover.Device) []string {
-	ss := make([]string, len(dev.Addresses))
-	for i, addr := range dev.Addresses {
-		ss[i] = addr.URL
-	}
-	return ss
-}
-
-// returns a random but recognizable device ID
-func randomDeviceID() []byte {
-	var id [32]byte
-	copy(id[:], randomPrefix)
-	rand.Read(id[len(randomPrefix):])
-	return id[:]
-}

cmd/stevents/main.go

@@ -1,63 +0,0 @@
-// Copyright (C) 2014 The Syncthing Authors.
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this file,
-// You can obtain one at http://mozilla.org/MPL/2.0/.
-
-package main
-
-import (
-	"encoding/json"
-	"flag"
-	"fmt"
-	"log"
-	"net/http"
-	"os"
-	"time"
-)
-
-type event struct {
-	ID   int                    `json:"id"`
-	Type string                 `json:"type"`
-	Time time.Time              `json:"time"`
-	Data map[string]interface{} `json:"data"`
-}
-
-func main() {
-	log.SetOutput(os.Stdout)
-	log.SetFlags(0)
-
-	target := flag.String("target", "localhost:8384", "Target Syncthing instance")
-	apikey := flag.String("apikey", "", "Syncthing API key")
-	flag.Parse()
-
-	if *apikey == "" {
-		log.Fatal("Must give -apikey argument")
-	}
-
-	since := 0
-	for {
-		req, err := http.NewRequest("GET", fmt.Sprintf("http://%s/rest/events?since=%d", *target, since), nil)
-		if err != nil {
-			log.Fatal(err)
-		}
-		req.Header.Set("X-API-Key", *apikey)
-		res, err := http.DefaultClient.Do(req)
-		if err != nil {
-			log.Fatal(err)
-		}
-
-		var events []event
-		err = json.NewDecoder(res.Body).Decode(&events)
-		if err != nil {
-			log.Fatal(err)
-		}
-		res.Body.Close()
-
-		for _, event := range events {
-			bs, _ := json.MarshalIndent(event, "", "    ")
-			log.Printf("%s", bs)
-			since = event.ID
-		}
-	}
-}

cmd/stfileinfo/main.go

@@ -1,80 +0,0 @@
-// Copyright (C) 2014 The Syncthing Authors.
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this file,
-// You can obtain one at http://mozilla.org/MPL/2.0/.
-
-package main
-
-import (
-	"flag"
-	"log"
-	"os"
-	"path/filepath"
-
-	"github.com/syncthing/syncthing/lib/protocol"
-	"github.com/syncthing/syncthing/lib/scanner"
-)
-
-func main() {
-	log.SetFlags(0)
-	log.SetOutput(os.Stdout)
-
-	standardBlocks := flag.Bool("s", false, "Use standard block size")
-	flag.Parse()
-
-	path := flag.Arg(0)
-	if path == "" {
-		log.Fatal("Need one argument: path to check")
-	}
-
-	log.Println("File:")
-	log.Println(" ", filepath.Clean(path))
-	log.Println()
-
-	fi, err := os.Lstat(path)
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	log.Println("Lstat:")
-	log.Printf("  Size: %d bytes", fi.Size())
-	log.Printf("  Mode: 0%o", fi.Mode())
-	log.Printf("  Time: %v (%d)", fi.ModTime(), fi.ModTime().Unix())
-	log.Println()
-
-	if !fi.Mode().IsDir() && !fi.Mode().IsRegular() {
-		fi, err = os.Stat(path)
-		if err != nil {
-			log.Fatal(err)
-		}
-
-		log.Println("Stat:")
-		log.Printf("  Size: %d bytes", fi.Size())
-		log.Printf("  Mode: 0%o", fi.Mode())
-		log.Printf("  Time: %v (%d)", fi.ModTime(), fi.ModTime().Unix())
-		log.Println()
-	}
-
-	if fi.Mode().IsRegular() {
-		log.Println("Blocks:")
-
-		fd, err := os.Open(path)
-		if err != nil {
-			log.Fatal(err)
-		}
-
-		blockSize := int(fi.Size())
-		if *standardBlocks || blockSize < protocol.BlockSize {
-			blockSize = protocol.BlockSize
-		}
-		bs, err := scanner.Blocks(fd, blockSize, fi.Size(), nil)
-		if err != nil {
-			log.Fatal(err)
-		}
-
-		for _, b := range bs {
-			log.Println(" ", b)
-		}
-	}
-}

cmd/stfinddevice/main.go

@@ -1,107 +0,0 @@
-// Copyright (C) 2014 The Syncthing Authors.
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this file,
-// You can obtain one at http://mozilla.org/MPL/2.0/.
-
-package main
-
-import (
-	"crypto/tls"
-	"errors"
-	"flag"
-	"fmt"
-	"net/url"
-	"os"
-	"time"
-
-	"github.com/syncthing/syncthing/lib/config"
-	"github.com/syncthing/syncthing/lib/discover"
-	"github.com/syncthing/syncthing/lib/protocol"
-)
-
-var timeout = 5 * time.Second
-
-func main() {
-	var server string
-
-	flag.StringVar(&server, "server", "", "Announce server (blank for default set)")
-	flag.DurationVar(&timeout, "timeout", timeout, "Query timeout")
-	flag.Usage = usage
-	flag.Parse()
-
-	if flag.NArg() != 1 {
-		flag.Usage()
-		os.Exit(64)
-	}
-
-	id, err := protocol.DeviceIDFromString(flag.Args()[0])
-	if err != nil {
-		fmt.Println(err)
-		os.Exit(1)
-	}
-
-	if server != "" {
-		checkServers(id, server)
-	} else {
-		checkServers(id, config.DefaultDiscoveryServers...)
-	}
-}
-
-type checkResult struct {
-	server    string
-	addresses []string
-	error
-}
-
-func checkServers(deviceID protocol.DeviceID, servers ...string) {
-	t0 := time.Now()
-	resc := make(chan checkResult)
-	for _, srv := range servers {
-		srv := srv
-		go func() {
-			res := checkServer(deviceID, srv)
-			res.server = srv
-			resc <- res
-		}()
-	}
-
-	for _ = range servers {
-		res := <-resc
-
-		u, _ := url.Parse(res.server)
-		fmt.Printf("%s (%v):\n", u.Host, time.Since(t0))
-
-		if res.error != nil {
-			fmt.Println("  " + res.error.Error())
-		}
-		for _, addr := range res.addresses {
-			fmt.Println("  address:", addr)
-		}
-	}
-}
-
-func checkServer(deviceID protocol.DeviceID, server string) checkResult {
-	disco, err := discover.NewGlobal(server, tls.Certificate{}, nil)
-	if err != nil {
-		return checkResult{error: err}
-	}
-
-	res := make(chan checkResult, 1)
-
-	time.AfterFunc(timeout, func() {
-		res <- checkResult{error: errors.New("timeout")}
-	})
-
-	go func() {
-		addresses, err := disco.Lookup(deviceID)
-		res <- checkResult{addresses: addresses, error: err}
-	}()
-
-	return <-res
-}
-
-func usage() {
-	fmt.Printf("Usage:\n\t%s [options] <device ID>\n\nOptions:\n", os.Args[0])
-	flag.PrintDefaults()
-}

cmd/stgenfiles/main.go

@@ -1,124 +0,0 @@
-// Copyright (C) 2016 The Syncthing Authors.
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this file,
-// You can obtain one at http://mozilla.org/MPL/2.0/.
-
-package main
-
-import (
-	"flag"
-	"fmt"
-	"io"
-	"log"
-	"math/rand"
-	"os"
-	"path/filepath"
-	"time"
-)
-
-func main() {
-	dir := flag.String("dir", "~/files", "Directory to generate into")
-	files := flag.Int("files", 1000, "Number of files to create")
-	maxExp := flag.Int("maxexp", 20, "Max size exponent")
-	src := flag.String("src", "/dev/urandom", "Source of file data")
-	flag.Parse()
-	if err := generateFiles(*dir, *files, *maxExp, *src); err != nil {
-		log.Println(err)
-	}
-}
-
-func generateFiles(dir string, files, maxexp int, srcname string) error {
-	fd, err := os.Open(srcname)
-	if err != nil {
-		return err
-	}
-
-	for i := 0; i < files; i++ {
-		n := randomName()
-
-		if rand.Float64() < 0.05 {
-			// Some files and directories are dotfiles
-			n = "." + n
-		}
-
-		p0 := filepath.Join(dir, string(n[0]), n[0:2])
-		err = os.MkdirAll(p0, 0755)
-		if err != nil {
-			log.Fatal(err)
-		}
-
-		p1 := filepath.Join(p0, n)
-
-		s := int64(1 << uint(rand.Intn(maxexp)))
-		a := int64(128 * 1024)
-		if a > s {
-			a = s
-		}
-		s += rand.Int63n(a)
-
-		if err := generateOneFile(fd, p1, s); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-func generateOneFile(fd io.ReadSeeker, p1 string, s int64) error {
-	src := io.LimitReader(&inifiteReader{fd}, int64(s))
-	dst, err := os.Create(p1)
-	if err != nil {
-		return err
-	}
-
-	_, err = io.Copy(dst, src)
-	if err != nil {
-		return err
-	}
-
-	err = dst.Close()
-	if err != nil {
-		return err
-	}
-
-	_ = os.Chmod(p1, os.FileMode(rand.Intn(0777)|0400))
-
-	t := time.Now().Add(-time.Duration(rand.Intn(30*86400)) * time.Second)
-	err = os.Chtimes(p1, t, t)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func randomName() string {
-	var b [16]byte
-	readRand(b[:])
-	return fmt.Sprintf("%x", b[:])
-}
-
-func readRand(bs []byte) (int, error) {
-	var r uint32
-	for i := range bs {
-		if i%4 == 0 {
-			r = uint32(rand.Int63())
-		}
-		bs[i] = byte(r >> uint((i%4)*8))
-	}
-	return len(bs), nil
-}
-
-type inifiteReader struct {
-	rd io.ReadSeeker
-}
-
-func (i *inifiteReader) Read(bs []byte) (int, error) {
-	n, err := i.rd.Read(bs)
-	if err == io.EOF {
-		err = nil
-		i.rd.Seek(0, 0)
-	}
-	return n, err
-}

cmd/stindex/dump.go

@@ -1,65 +0,0 @@
-// Copyright (C) 2015 The Syncthing Authors.
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this file,
-// You can obtain one at http://mozilla.org/MPL/2.0/.
-
-package main
-
-import (
-	"encoding/binary"
-	"fmt"
-	"log"
-
-	"github.com/syncthing/syncthing/lib/db"
-	"github.com/syncthing/syncthing/lib/protocol"
-	"github.com/syndtr/goleveldb/leveldb"
-)
-
-func dump(ldb *leveldb.DB) {
-	it := ldb.NewIterator(nil, nil)
-	var dev protocol.DeviceID
-	for it.Next() {
-		key := it.Key()
-		switch key[0] {
-		case db.KeyTypeDevice:
-			folder := nulString(key[1 : 1+64])
-			devBytes := key[1+64 : 1+64+32]
-			name := nulString(key[1+64+32:])
-			copy(dev[:], devBytes)
-			fmt.Printf("[device] F:%q N:%q D:%v\n", folder, name, dev)
-
-			var f protocol.FileInfo
-			err := f.UnmarshalXDR(it.Value())
-			if err != nil {
-				log.Fatal(err)
-			}
-			fmt.Printf("  N:%q\n  F:%#o\n  M:%d\n  V:%v\n  S:%d\n  B:%d\n", f.Name, f.Flags, f.Modified, f.Version, f.Size(), len(f.Blocks))
-
-		case db.KeyTypeGlobal:
-			folder := nulString(key[1 : 1+64])
-			name := nulString(key[1+64:])
-			var flv db.VersionList
-			flv.UnmarshalXDR(it.Value())
-			fmt.Printf("[global] F:%q N:%q V: %s\n", folder, name, flv)
-
-		case db.KeyTypeBlock:
-			folder := nulString(key[1 : 1+64])
-			hash := key[1+64 : 1+64+32]
-			name := nulString(key[1+64+32:])
-			fmt.Printf("[block] F:%q H:%x N:%q I:%d\n", folder, hash, name, binary.BigEndian.Uint32(it.Value()))
-
-		case db.KeyTypeDeviceStatistic:
-			fmt.Printf("[dstat]\n  %x\n  %x\n", it.Key(), it.Value())
-
-		case db.KeyTypeFolderStatistic:
-			fmt.Printf("[fstat]\n  %x\n  %x\n", it.Key(), it.Value())
-
-		case db.KeyTypeVirtualMtime:
-			fmt.Printf("[mtime]\n  %x\n  %x\n", it.Key(), it.Value())
-
-		default:
-			fmt.Printf("[???]\n  %x\n  %x\n", it.Key(), it.Value())
-		}
-	}
-}

cmd/stindex/dumpsize.go

@@ -1,89 +0,0 @@
-// Copyright (C) 2015 The Syncthing Authors.
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this file,
-// You can obtain one at http://mozilla.org/MPL/2.0/.
-
-package main
-
-import (
-	"container/heap"
-	"fmt"
-
-	"github.com/syncthing/syncthing/lib/db"
-	"github.com/syncthing/syncthing/lib/protocol"
-	"github.com/syndtr/goleveldb/leveldb"
-)
-
-type SizedElement struct {
-	key  string
-	size int
-}
-
-type ElementHeap []SizedElement
-
-func (h ElementHeap) Len() int           { return len(h) }
-func (h ElementHeap) Less(i, j int) bool { return h[i].size > h[j].size }
-func (h ElementHeap) Swap(i, j int)      { h[i], h[j] = h[j], h[i] }
-
-func (h *ElementHeap) Push(x interface{}) {
-	*h = append(*h, x.(SizedElement))
-}
-
-func (h *ElementHeap) Pop() interface{} {
-	old := *h
-	n := len(old)
-	x := old[n-1]
-	*h = old[0 : n-1]
-	return x
-}
-
-func dumpsize(ldb *leveldb.DB) {
-	h := &ElementHeap{}
-	heap.Init(h)
-
-	it := ldb.NewIterator(nil, nil)
-	var dev protocol.DeviceID
-	var ele SizedElement
-	for it.Next() {
-		key := it.Key()
-		switch key[0] {
-		case db.KeyTypeDevice:
-			folder := nulString(key[1 : 1+64])
-			devBytes := key[1+64 : 1+64+32]
-			name := nulString(key[1+64+32:])
-			copy(dev[:], devBytes)
-			ele.key = fmt.Sprintf("DEVICE:%s:%s:%s", dev, folder, name)
-
-		case db.KeyTypeGlobal:
-			folder := nulString(key[1 : 1+64])
-			name := nulString(key[1+64:])
-			ele.key = fmt.Sprintf("GLOBAL:%s:%s", folder, name)
-
-		case db.KeyTypeBlock:
-			folder := nulString(key[1 : 1+64])
-			hash := key[1+64 : 1+64+32]
-			name := nulString(key[1+64+32:])
-			ele.key = fmt.Sprintf("BLOCK:%s:%x:%s", folder, hash, name)
-
-		case db.KeyTypeDeviceStatistic:
-			ele.key = fmt.Sprintf("DEVICESTATS:%s", key[1:])
-
-		case db.KeyTypeFolderStatistic:
-			ele.key = fmt.Sprintf("FOLDERSTATS:%s", key[1:])
-
-		case db.KeyTypeVirtualMtime:
-			ele.key = fmt.Sprintf("MTIME:%s", key[1:])
-
-		default:
-			ele.key = fmt.Sprintf("UNKNOWN:%x", key)
-		}
-		ele.size = len(it.Value())
-		heap.Push(h, ele)
-	}
-
-	for h.Len() > 0 {
-		ele = heap.Pop(h).(SizedElement)
-		fmt.Println(ele.key, ele.size)
-	}
-}

cmd/stindex/main.go

@@ -1,52 +0,0 @@
-// Copyright (C) 2014 The Syncthing Authors.
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this file,
-// You can obtain one at http://mozilla.org/MPL/2.0/.
-
-package main
-
-import (
-	"flag"
-	"fmt"
-	"log"
-	"os"
-	"path/filepath"
-
-	"github.com/syndtr/goleveldb/leveldb"
-	"github.com/syndtr/goleveldb/leveldb/opt"
-)
-
-func main() {
-	var mode string
-	log.SetFlags(0)
-	log.SetOutput(os.Stdout)
-
-	flag.StringVar(&mode, "mode", "dump", "Mode of operation: dump, dumpsize")
-
-	flag.Parse()
-
-	path := flag.Arg(0)
-	if path == "" {
-		path = filepath.Join(defaultConfigDir(), "index-v0.11.0.db")
-	}
-
-	fmt.Println("Path:", path)
-
-	ldb, err := leveldb.OpenFile(path, &opt.Options{
-		ErrorIfMissing:         true,
-		Strict:                 opt.StrictAll,
-		OpenFilesCacheCapacity: 100,
-	})
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	if mode == "dump" {
-		dump(ldb)
-	} else if mode == "dumpsize" {
-		dumpsize(ldb)
-	} else {
-		fmt.Println("Unknown mode")
-	}
-}

cmd/stindex/util.go

@@ -1,52 +0,0 @@
-// Copyright (C) 2015 The Syncthing Authors.
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this file,
-// You can obtain one at http://mozilla.org/MPL/2.0/.
-
-package main
-
-import (
-	"log"
-	"os"
-	"path/filepath"
-	"runtime"
-
-	"github.com/syncthing/syncthing/lib/osutil"
-)
-
-func nulString(bs []byte) string {
-	for i := range bs {
-		if bs[i] == 0 {
-			return string(bs[:i])
-		}
-	}
-	return string(bs)
-}
-
-func defaultConfigDir() string {
-	switch runtime.GOOS {
-	case "windows":
-		if p := os.Getenv("LocalAppData"); p != "" {
-			return filepath.Join(p, "Syncthing")
-		}
-		return filepath.Join(os.Getenv("AppData"), "Syncthing")
-
-	case "darwin":
-		dir, err := osutil.ExpandTilde("~/Library/Application Support/Syncthing")
-		if err != nil {
-			log.Fatal(err)
-		}
-		return dir
-
-	default:
-		if xdgCfg := os.Getenv("XDG_CONFIG_HOME"); xdgCfg != "" {
-			return filepath.Join(xdgCfg, "syncthing")
-		}
-		dir, err := osutil.ExpandTilde("~/.config/syncthing")
-		if err != nil {
-			log.Fatal(err)
-		}
-		return dir
-	}
-}

cmd/stsigtool/main.go

@@ -1,122 +0,0 @@
-// Copyright (C) 2015 The Syncthing Authors.
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this file,
-// You can obtain one at http://mozilla.org/MPL/2.0/.
-
-package main
-
-import (
-	"flag"
-	"io"
-	"io/ioutil"
-	"log"
-	"os"
-
-	"github.com/syncthing/syncthing/lib/signature"
-	"github.com/syncthing/syncthing/lib/upgrade"
-)
-
-func main() {
-	log.SetFlags(0)
-	log.SetOutput(os.Stdout)
-
-	flag.Parse()
-
-	if flag.NArg() < 1 {
-		log.Println(`Usage:
-	stsigtool <command>
-
-Where command is one of:
-
-	gen
-		- generate a new key pair
-
-	sign <privkeyfile> [datafile]
-		- sign a file
-
-	verify <signaturefile> <datafile>
-		- verify a signature, using the built in public key
-
-	verify <signaturefile> <datafile> <pubkeyfile>
-		- verify a signature, using the specified public key file
-`)
-	}
-
-	switch flag.Arg(0) {
-	case "gen":
-		gen()
-	case "sign":
-		sign(flag.Arg(1), flag.Arg(2))
-	case "verify":
-		if flag.NArg() == 4 {
-			verifyWithFile(flag.Arg(1), flag.Arg(2), flag.Arg(3))
-		} else {
-			verifyWithKey(flag.Arg(1), flag.Arg(2), upgrade.SigningKey)
-		}
-	}
-}
-
-func gen() {
-	priv, pub, err := signature.GenerateKeys()
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	os.Stdout.Write(priv)
-	os.Stdout.Write(pub)
-}
-
-func sign(keyname, dataname string) {
-	privkey, err := ioutil.ReadFile(keyname)
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	var input io.Reader
-	if dataname == "-" || dataname == "" {
-		input = os.Stdin
-	} else {
-		fd, err := os.Open(dataname)
-		if err != nil {
-			log.Fatal(err)
-		}
-		defer fd.Close()
-		input = fd
-	}
-
-	sig, err := signature.Sign(privkey, input)
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	os.Stdout.Write(sig)
-}
-
-func verifyWithFile(signame, dataname, keyname string) {
-	pubkey, err := ioutil.ReadFile(keyname)
-	if err != nil {
-		log.Fatal(err)
-	}
-	verifyWithKey(signame, dataname, pubkey)
-}
-
-func verifyWithKey(signame, dataname string, pubkey []byte) {
-	sig, err := ioutil.ReadFile(signame)
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	fd, err := os.Open(dataname)
-	if err != nil {
-		log.Fatal(err)
-	}
-	defer fd.Close()
-
-	err = signature.Verify(pubkey, sig, fd)
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	log.Println("correct signature")
-}

cmd/stvanity/main.go

@@ -1,212 +0,0 @@
-// Copyright (C) 2016 The Syncthing Authors.
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this file,
-// You can obtain one at http://mozilla.org/MPL/2.0/.
-
-package main
-
-import (
-	"crypto/ecdsa"
-	"crypto/elliptic"
-	"crypto/rand"
-	"crypto/rsa"
-	"crypto/x509"
-	"crypto/x509/pkix"
-	"encoding/pem"
-	"flag"
-	"fmt"
-	"math/big"
-	mr "math/rand"
-	"os"
-	"runtime"
-	"strings"
-	"sync"
-	"sync/atomic"
-	"time"
-
-	"github.com/syncthing/syncthing/lib/protocol"
-)
-
-type result struct {
-	id       protocol.DeviceID
-	priv     *ecdsa.PrivateKey
-	derBytes []byte
-}
-
-func main() {
-	flag.Parse()
-	prefix := strings.ToUpper(strings.Replace(flag.Arg(0), "-", "", -1))
-	if len(prefix) > 7 {
-		prefix = prefix[:7] + "-" + prefix[7:]
-	}
-
-	found := make(chan result)
-	stop := make(chan struct{})
-	var count int64
-
-	// Print periodic progress reports.
-	go printProgress(prefix, &count)
-
-	// Run one certificate generator per CPU core.
-	var wg sync.WaitGroup
-	for i := 0; i < runtime.GOMAXPROCS(-1); i++ {
-		wg.Add(1)
-		go func() {
-			generatePrefixed(prefix, &count, found, stop)
-			wg.Done()
-		}()
-	}
-
-	// Save the result, when one has been found.
-	res := <-found
-	close(stop)
-	wg.Wait()
-
-	fmt.Println("Found", res.id)
-	saveCert(res.priv, res.derBytes)
-	fmt.Println("Saved to cert.pem, key.pem")
-}
-
-// Try certificates until one is found that has the prefix at the start of
-// the resulting device ID. Increments count atomically, sends the result to
-// found, returns when stop is closed.
-func generatePrefixed(prefix string, count *int64, found chan<- result, stop <-chan struct{}) {
-	notBefore := time.Now()
-	notAfter := time.Date(2049, 12, 31, 23, 59, 59, 0, time.UTC)
-
-	template := x509.Certificate{
-		SerialNumber: new(big.Int).SetInt64(mr.Int63()),
-		Subject: pkix.Name{
-			CommonName: "syncthing",
-		},
-		NotBefore: notBefore,
-		NotAfter:  notAfter,
-
-		KeyUsage:              x509.KeyUsageKeyEncipherment | x509.KeyUsageDigitalSignature,
-		ExtKeyUsage:           []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth, x509.ExtKeyUsageClientAuth},
-		BasicConstraintsValid: true,
-	}
-
-	priv, err := ecdsa.GenerateKey(elliptic.P384(), rand.Reader)
-	if err != nil {
-		fmt.Println(err)
-		os.Exit(1)
-	}
-
-	for {
-		select {
-		case <-stop:
-			return
-		default:
-		}
-
-		derBytes, err := x509.CreateCertificate(rand.Reader, &template, &template, &priv.PublicKey, priv)
-		if err != nil {
-			fmt.Println(err)
-			os.Exit(1)
-		}
-
-		id := protocol.NewDeviceID(derBytes)
-		atomic.AddInt64(count, 1)
-
-		if strings.HasPrefix(id.String(), prefix) {
-			select {
-			case found <- result{id, priv, derBytes}:
-			case <-stop:
-			}
-			return
-		}
-	}
-}
-
-func printProgress(prefix string, count *int64) {
-	started := time.Now()
-	wantBits := 5 * len(prefix)
-	if wantBits > 63 {
-		fmt.Printf("Want %d bits for prefix %q, refusing to boil the ocean.\n", wantBits, prefix)
-		os.Exit(1)
-	}
-	expectedIterations := float64(int(1) << uint(wantBits))
-	fmt.Printf("Want %d bits for prefix %q, about %.2g certs to test (statistically speaking)\n", wantBits, prefix, expectedIterations)
-
-	for _ = range time.NewTicker(15 * time.Second).C {
-		tried := atomic.LoadInt64(count)
-		elapsed := time.Since(started)
-		rate := float64(tried) / elapsed.Seconds()
-		expected := timeStr(expectedIterations / rate)
-		fmt.Printf("Trying %.0f certs/s, tested %d so far in %v, expect ~%s total time to complete\n", rate, tried, elapsed/time.Second*time.Second, expected)
-	}
-}
-
-func saveCert(priv interface{}, derBytes []byte) {
-	certOut, err := os.Create("cert.pem")
-	if err != nil {
-		fmt.Println(err)
-		os.Exit(1)
-	}
-	err = pem.Encode(certOut, &pem.Block{Type: "CERTIFICATE", Bytes: derBytes})
-	if err != nil {
-		fmt.Println(err)
-		os.Exit(1)
-	}
-	err = certOut.Close()
-	if err != nil {
-		fmt.Println(err)
-		os.Exit(1)
-	}
-
-	keyOut, err := os.OpenFile("key.pem", os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600)
-	if err != nil {
-		fmt.Println(err)
-		os.Exit(1)
-	}
-
-	block, err := pemBlockForKey(priv)
-	if err != nil {
-		fmt.Println(err)
-		os.Exit(1)
-	}
-
-	err = pem.Encode(keyOut, block)
-	if err != nil {
-		fmt.Println(err)
-		os.Exit(1)
-	}
-	err = keyOut.Close()
-	if err != nil {
-		fmt.Println(err)
-		os.Exit(1)
-	}
-}
-
-func pemBlockForKey(priv interface{}) (*pem.Block, error) {
-	switch k := priv.(type) {
-	case *rsa.PrivateKey:
-		return &pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(k)}, nil
-	case *ecdsa.PrivateKey:
-		b, err := x509.MarshalECPrivateKey(k)
-		if err != nil {
-			return nil, err
-		}
-		return &pem.Block{Type: "EC PRIVATE KEY", Bytes: b}, nil
-	default:
-		return nil, fmt.Errorf("unknown key type")
-	}
-}
-
-func timeStr(seconds float64) string {
-	if seconds < 60 {
-		return fmt.Sprintf("%.0fs", seconds)
-	}
-	if seconds < 3600 {
-		return fmt.Sprintf("%.0fm", seconds/60)
-	}
-	if seconds < 86400 {
-		return fmt.Sprintf("%.0fh", seconds/3600)
-	}
-	if seconds < 86400*365 {
-		return fmt.Sprintf("%.0f days", seconds/3600)
-	}
-	return fmt.Sprintf("%.0f years", seconds/86400/365)
-}

cmd/stwatchfile/main.go

@@ -1,98 +0,0 @@
-// Copyright (C) 2015 The Syncthing Authors.
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this file,
-// You can obtain one at http://mozilla.org/MPL/2.0/.
-
-package main
-
-import (
-	"bytes"
-	"crypto/md5"
-	"flag"
-	"fmt"
-	"io"
-	"os"
-	"time"
-)
-
-func getmd5(filePath string) ([]byte, error) {
-	var result []byte
-	file, err := os.Open(filePath)
-	if err != nil {
-		return result, err
-	}
-	defer file.Close()
-
-	hash := md5.New()
-	if _, err := io.Copy(hash, file); err != nil {
-		return result, err
-	}
-
-	return hash.Sum(result), nil
-}
-
-func main() {
-	period := flag.Duration("period", 200*time.Millisecond, "Sleep period between checks")
-	flag.Parse()
-
-	file := flag.Arg(0)
-
-	if file == "" {
-		fmt.Println("Expects a path as an argument")
-		return
-	}
-
-	exists := true
-	size := int64(0)
-	mtime := time.Time{}
-	hash := []byte{}
-
-	for {
-		time.Sleep(*period)
-
-		newExists := true
-		fi, err := os.Stat(file)
-		if err != nil && os.IsNotExist(err) {
-			newExists = false
-		} else if err != nil {
-			fmt.Println("stat:", err)
-			return
-		}
-
-		if newExists != exists {
-			exists = newExists
-			if !newExists {
-				fmt.Println(file, "does not exist")
-			} else {
-				fmt.Println(file, "appeared")
-			}
-		}
-
-		if !exists {
-			size = 0
-			mtime = time.Time{}
-			hash = []byte{}
-			continue
-		}
-
-		if fi.IsDir() {
-			fmt.Println(file, "is directory")
-			return
-		}
-		newSize := fi.Size()
-		newMtime := fi.ModTime()
-
-		newHash, err := getmd5(file)
-		if err != nil {
-			fmt.Println("getmd5:", err)
-		}
-
-		if newSize != size || newMtime != mtime || !bytes.Equal(newHash, hash) {
-			fmt.Println(file, "Size:", newSize, "Mtime:", newMtime, "Hash:", fmt.Sprintf("%x", newHash))
-			hash = newHash
-			size = newSize
-			mtime = newMtime
-		}
-	}
-}

cmd/syncthing/.gitignore

@@ -1 +0,0 @@
-*.idx.gz

cmd/syncthing/auditservice.go

@@ -1,69 +0,0 @@
-// Copyright (C) 2015 The Syncthing Authors.
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this file,
-// You can obtain one at http://mozilla.org/MPL/2.0/.
-
-package main
-
-import (
-	"encoding/json"
-	"io"
-
-	"github.com/syncthing/syncthing/lib/events"
-)
-
-// The auditService subscribes to events and writes these in JSON format, one
-// event per line, to the specified writer.
-type auditService struct {
-	w       io.Writer     // audit destination
-	stop    chan struct{} // signals time to stop
-	started chan struct{} // signals startup complete
-	stopped chan struct{} // signals stop complete
-}
-
-func newAuditService(w io.Writer) *auditService {
-	return &auditService{
-		w:       w,
-		stop:    make(chan struct{}),
-		started: make(chan struct{}),
-		stopped: make(chan struct{}),
-	}
-}
-
-// Serve runs the audit service.
-func (s *auditService) Serve() {
-	defer close(s.stopped)
-	sub := events.Default.Subscribe(events.AllEvents)
-	defer events.Default.Unsubscribe(sub)
-	enc := json.NewEncoder(s.w)
-
-	// We're ready to start processing events.
-	close(s.started)
-
-	for {
-		select {
-		case ev := <-sub.C():
-			enc.Encode(ev)
-		case <-s.stop:
-			return
-		}
-	}
-}
-
-// Stop stops the audit service.
-func (s *auditService) Stop() {
-	close(s.stop)
-}
-
-// WaitForStart returns once the audit service is ready to receive events, or
-// immediately if it's already running.
-func (s *auditService) WaitForStart() {
-	<-s.started
-}
-
-// WaitForStop returns once the audit service has stopped.
-// (Needed by the tests.)
-func (s *auditService) WaitForStop() {
-	<-s.stopped
-}

cmd/syncthing/auditservice_test.go

@@ -1,54 +0,0 @@
-// Copyright (C) 2015 The Syncthing Authors.
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this file,
-// You can obtain one at http://mozilla.org/MPL/2.0/.
-
-package main
-
-import (
-	"bytes"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/syncthing/syncthing/lib/events"
-)
-
-func TestAuditService(t *testing.T) {
-	buf := new(bytes.Buffer)
-	service := newAuditService(buf)
-
-	// Event sent before start, will not be logged
-	events.Default.Log(events.Ping, "the first event")
-
-	go service.Serve()
-	service.WaitForStart()
-
-	// Event that should end up in the audit log
-	events.Default.Log(events.Ping, "the second event")
-
-	// We need to give the events time to arrive, since the channels are buffered etc.
-	time.Sleep(10 * time.Millisecond)
-
-	service.Stop()
-	service.WaitForStop()
-
-	// This event should not be logged, since we have stopped.
-	events.Default.Log(events.Ping, "the third event")
-
-	result := string(buf.Bytes())
-	t.Log(result)
-
-	if strings.Contains(result, "first event") {
-		t.Error("Unexpected first event")
-	}
-
-	if !strings.Contains(result, "second event") {
-		t.Error("Missing second event")
-	}
-
-	if strings.Contains(result, "third event") {
-		t.Error("Missing third event")
-	}
-}

cmd/syncthing/blockprof.go

@@ -1,50 +0,0 @@
-// Copyright (C) 2014 The Syncthing Authors.
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this file,
-// You can obtain one at http://mozilla.org/MPL/2.0/.
-
-package main
-
-import (
-	"fmt"
-	"os"
-	"runtime"
-	"runtime/pprof"
-	"syscall"
-	"time"
-)
-
-func init() {
-	if innerProcess && os.Getenv("STBLOCKPROFILE") != "" {
-		profiler := pprof.Lookup("block")
-		if profiler == nil {
-			panic("Couldn't find block profiler")
-		}
-		l.Debugln("Starting block profiling")
-		go saveBlockingProfiles(profiler)
-	}
-}
-
-func saveBlockingProfiles(profiler *pprof.Profile) {
-	runtime.SetBlockProfileRate(1)
-
-	t0 := time.Now()
-	for t := range time.NewTicker(20 * time.Second).C {
-		startms := int(t.Sub(t0).Seconds() * 1000)
-
-		fd, err := os.Create(fmt.Sprintf("block-%05d-%07d.pprof", syscall.Getpid(), startms))
-		if err != nil {
-			panic(err)
-		}
-		err = profiler.WriteTo(fd, 0)
-		if err != nil {
-			panic(err)
-		}
-		err = fd.Close()
-		if err != nil {
-			panic(err)
-		}
-
-	}
-}

cmd/syncthing/debug.go

@@ -1,28 +0,0 @@
-// Copyright (C) 2014 The Syncthing Authors.
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this file,
-// You can obtain one at http://mozilla.org/MPL/2.0/.
-
-package main
-
-import (
-	"os"
-	"strings"
-
-	"github.com/syncthing/syncthing/lib/logger"
-)
-
-var (
-	l     = logger.DefaultLogger.NewFacility("main", "Main package")
-	httpl = logger.DefaultLogger.NewFacility("http", "REST API")
-)
-
-func shouldDebugHTTP() bool {
-	return l.ShouldDebug("http")
-}
-
-func init() {
-	l.SetDebug("main", strings.Contains(os.Getenv("STTRACE"), "main") || os.Getenv("STTRACE") == "all")
-	l.SetDebug("http", strings.Contains(os.Getenv("STTRACE"), "http") || os.Getenv("STTRACE") == "all")
-}

cmd/syncthing/gui_auth.go

@@ -1,141 +0,0 @@
-// Copyright (C) 2014 The Syncthing Authors.
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this file,
-// You can obtain one at http://mozilla.org/MPL/2.0/.
-
-package main
-
-import (
-	"bytes"
-	"encoding/base64"
-	"net/http"
-	"strings"
-	"time"
-
-	"github.com/syncthing/syncthing/lib/config"
-	"github.com/syncthing/syncthing/lib/events"
-	"github.com/syncthing/syncthing/lib/rand"
-	"github.com/syncthing/syncthing/lib/sync"
-	"golang.org/x/crypto/bcrypt"
-)
-
-var (
-	sessions    = make(map[string]bool)
-	sessionsMut = sync.NewMutex()
-)
-
-func emitLoginAttempt(success bool, username string) {
-	events.Default.Log(events.LoginAttempt, map[string]interface{}{
-		"success":  success,
-		"username": username,
-	})
-}
-
-func basicAuthAndSessionMiddleware(cookieName string, cfg config.GUIConfiguration, next http.Handler) http.Handler {
-	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if cfg.IsValidAPIKey(r.Header.Get("X-API-Key")) {
-			next.ServeHTTP(w, r)
-			return
-		}
-
-		cookie, err := r.Cookie(cookieName)
-		if err == nil && cookie != nil {
-			sessionsMut.Lock()
-			_, ok := sessions[cookie.Value]
-			sessionsMut.Unlock()
-			if ok {
-				next.ServeHTTP(w, r)
-				return
-			}
-		}
-
-		httpl.Debugln("Sessionless HTTP request with authentication; this is expensive.")
-
-		error := func() {
-			time.Sleep(time.Duration(rand.Intn(100)+100) * time.Millisecond)
-			w.Header().Set("WWW-Authenticate", "Basic realm=\"Authorization Required\"")
-			http.Error(w, "Not Authorized", http.StatusUnauthorized)
-		}
-
-		hdr := r.Header.Get("Authorization")
-		if !strings.HasPrefix(hdr, "Basic ") {
-			error()
-			return
-		}
-
-		hdr = hdr[6:]
-		bs, err := base64.StdEncoding.DecodeString(hdr)
-		if err != nil {
-			error()
-			return
-		}
-
-		fields := bytes.SplitN(bs, []byte(":"), 2)
-		if len(fields) != 2 {
-			error()
-			return
-		}
-
-		// Check if the username is correct, assuming it was sent as UTF-8
-		username := string(fields[0])
-		if username == cfg.User {
-			goto usernameOK
-		}
-
-		// ... check it again, converting it from assumed ISO-8859-1 to UTF-8
-		username = string(iso88591ToUTF8(fields[0]))
-		if username == cfg.User {
-			goto usernameOK
-		}
-
-		// Neither of the possible interpretations match the configured username
-		emitLoginAttempt(false, username)
-		error()
-		return
-
-	usernameOK:
-		// Check password as given (assumes UTF-8 encoding)
-		password := fields[1]
-		if err := bcrypt.CompareHashAndPassword([]byte(cfg.Password), password); err == nil {
-			goto passwordOK
-		}
-
-		// ... check it again, converting it from assumed ISO-8859-1 to UTF-8
-		password = iso88591ToUTF8(password)
-		if err := bcrypt.CompareHashAndPassword([]byte(cfg.Password), password); err == nil {
-			goto passwordOK
-		}
-
-		// Neither of the attempts to verify the password checked out
-		emitLoginAttempt(false, username)
-		error()
-		return
-
-	passwordOK:
-		sessionid := rand.String(32)
-		sessionsMut.Lock()
-		sessions[sessionid] = true
-		sessionsMut.Unlock()
-		http.SetCookie(w, &http.Cookie{
-			Name:   cookieName,
-			Value:  sessionid,
-			MaxAge: 0,
-		})
-
-		emitLoginAttempt(true, username)
-		next.ServeHTTP(w, r)
-	})
-}
-
-// Convert an ISO-8859-1 encoded byte string to UTF-8. Works by the
-// principle that ISO-8859-1 bytes are equivalent to unicode code points,
-// that a rune slice is a list of code points, and that stringifying a slice
-// of runes generates UTF-8 in Go.
-func iso88591ToUTF8(s []byte) []byte {
-	runes := make([]rune, len(s))
-	for i := range s {
-		runes[i] = rune(s[i])
-	}
-	return []byte(string(runes))
-}

cmd/syncthing/gui_csrf.go

@@ -1,132 +0,0 @@
-// Copyright (C) 2014 The Syncthing Authors.
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this file,
-// You can obtain one at http://mozilla.org/MPL/2.0/.
-
-package main
-
-import (
-	"bufio"
-	"fmt"
-	"net/http"
-	"os"
-	"strings"
-
-	"github.com/syncthing/syncthing/lib/config"
-	"github.com/syncthing/syncthing/lib/osutil"
-	"github.com/syncthing/syncthing/lib/rand"
-	"github.com/syncthing/syncthing/lib/sync"
-)
-
-// csrfTokens is a list of valid tokens. It is sorted so that the most
-// recently used token is first in the list. New tokens are added to the front
-// of the list (as it is the most recently used at that time). The list is
-// pruned to a maximum of maxCsrfTokens, throwing away the least recently used
-// tokens.
-var csrfTokens []string
-var csrfMut = sync.NewMutex()
-
-const maxCsrfTokens = 25
-
-// Check for CSRF token on /rest/ URLs. If a correct one is not given, reject
-// the request with 403. For / and /index.html, set a new CSRF cookie if none
-// is currently set.
-func csrfMiddleware(unique string, prefix string, cfg config.GUIConfiguration, next http.Handler) http.Handler {
-	loadCsrfTokens()
-	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		// Allow requests carrying a valid API key
-		if cfg.IsValidAPIKey(r.Header.Get("X-API-Key")) {
-			next.ServeHTTP(w, r)
-			return
-		}
-
-		// Allow requests for anything not under the protected path prefix,
-		// and set a CSRF cookie if there isn't already a valid one.
-		if !strings.HasPrefix(r.URL.Path, prefix) {
-			cookie, err := r.Cookie("CSRF-Token-" + unique)
-			if err != nil || !validCsrfToken(cookie.Value) {
-				httpl.Debugln("new CSRF cookie in response to request for", r.URL)
-				cookie = &http.Cookie{
-					Name:  "CSRF-Token-" + unique,
-					Value: newCsrfToken(),
-				}
-				http.SetCookie(w, cookie)
-			}
-			next.ServeHTTP(w, r)
-			return
-		}
-
-		// Verify the CSRF token
-		token := r.Header.Get("X-CSRF-Token-" + unique)
-		if !validCsrfToken(token) {
-			http.Error(w, "CSRF Error", 403)
-			return
-		}
-
-		next.ServeHTTP(w, r)
-	})
-}
-
-func validCsrfToken(token string) bool {
-	csrfMut.Lock()
-	defer csrfMut.Unlock()
-	for i, t := range csrfTokens {
-		if t == token {
-			if i > 0 {
-				// Move this token to the head of the list. Copy the tokens at
-				// the front one step to the right and then replace the token
-				// at the head.
-				copy(csrfTokens[1:], csrfTokens[:i+1])
-				csrfTokens[0] = token
-			}
-			return true
-		}
-	}
-	return false
-}
-
-func newCsrfToken() string {
-	token := rand.String(32)
-
-	csrfMut.Lock()
-	csrfTokens = append([]string{token}, csrfTokens...)
-	if len(csrfTokens) > maxCsrfTokens {
-		csrfTokens = csrfTokens[:maxCsrfTokens]
-	}
-	defer csrfMut.Unlock()
-
-	saveCsrfTokens()
-
-	return token
-}
-
-func saveCsrfTokens() {
-	// We're ignoring errors in here. It's not super critical and there's
-	// nothing relevant we can do about them anyway...
-
-	name := locations[locCsrfTokens]
-	f, err := osutil.CreateAtomic(name, 0600)
-	if err != nil {
-		return
-	}
-
-	for _, t := range csrfTokens {
-		fmt.Fprintln(f, t)
-	}
-
-	f.Close()
-}
-
-func loadCsrfTokens() {
-	f, err := os.Open(locations[locCsrfTokens])
-	if err != nil {
-		return
-	}
-	defer f.Close()
-
-	s := bufio.NewScanner(f)
-	for s.Scan() {
-		csrfTokens = append(csrfTokens, s.Text())
-	}
-}

cmd/syncthing/gui_solaris.go

@@ -1,98 +0,0 @@
-// Copyright (C) 2014 The Syncthing Authors.
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this file,
-// You can obtain one at http://mozilla.org/MPL/2.0/.
-
-//+build solaris
-
-package main
-
-import (
-	"encoding/binary"
-	"fmt"
-	"os"
-	"time"
-)
-
-type id_t int32
-type ulong_t uint32
-
-type timestruc_t struct {
-	Tv_sec  int64
-	Tv_nsec int64
-}
-
-func (tv timestruc_t) Nano() int64 {
-	return tv.Tv_sec*1e9 + tv.Tv_nsec
-}
-
-type prusage_t struct {
-	Pr_lwpid    id_t        /* lwp id.  0: process or defunct */
-	Pr_count    int32       /* number of contributing lwps */
-	Pr_tstamp   timestruc_t /* real time stamp, time of read() */
-	Pr_create   timestruc_t /* process/lwp creation time stamp */
-	Pr_term     timestruc_t /* process/lwp termination time stamp */
-	Pr_rtime    timestruc_t /* total lwp real (elapsed) time */
-	Pr_utime    timestruc_t /* user level CPU time */
-	Pr_stime    timestruc_t /* system call CPU time */
-	Pr_ttime    timestruc_t /* other system trap CPU time */
-	Pr_tftime   timestruc_t /* text page fault sleep time */
-	Pr_dftime   timestruc_t /* data page fault sleep time */
-	Pr_kftime   timestruc_t /* kernel page fault sleep time */
-	Pr_ltime    timestruc_t /* user lock wait sleep time */
-	Pr_slptime  timestruc_t /* all other sleep time */
-	Pr_wtime    timestruc_t /* wait-cpu (latency) time */
-	Pr_stoptime timestruc_t /* stopped time */
-	Pr_minf     ulong_t     /* minor page faults */
-	Pr_majf     ulong_t     /* major page faults */
-	Pr_nswap    ulong_t     /* swaps */
-	Pr_inblk    ulong_t     /* input blocks */
-	Pr_oublk    ulong_t     /* output blocks */
-	Pr_msnd     ulong_t     /* messages sent */
-	Pr_mrcv     ulong_t     /* messages received */
-	Pr_sigs     ulong_t     /* signals received */
-	Pr_vctx     ulong_t     /* voluntary context switches */
-	Pr_ictx     ulong_t     /* involuntary context switches */
-	Pr_sysc     ulong_t     /* system calls */
-	Pr_ioch     ulong_t     /* chars read and written */
-
-}
-
-func solarisPrusage(pid int, rusage *prusage_t) error {
-	fd, err := os.Open(fmt.Sprintf("/proc/%d/usage", pid))
-	if err != nil {
-		return err
-	}
-	err = binary.Read(fd, binary.LittleEndian, rusage)
-	fd.Close()
-	return err
-}
-
-func init() {
-	go trackCPUUsage()
-}
-
-func trackCPUUsage() {
-	var prevUsage int64
-	var prevTime = time.Now().UnixNano()
-	var rusage prusage_t
-	var pid = os.Getpid()
-	for _ = range time.NewTicker(time.Second).C {
-		err := solarisPrusage(pid, &rusage)
-		if err != nil {
-			l.Warnln("getting prusage:", err)
-			continue
-		}
-		curTime := time.Now().UnixNano()
-		timeDiff := curTime - prevTime
-		curUsage := rusage.Pr_utime.Nano() + rusage.Pr_stime.Nano()
-		usageDiff := curUsage - prevUsage
-		cpuUsageLock.Lock()
-		copy(cpuUsagePercent[1:], cpuUsagePercent[0:])
-		cpuUsagePercent[0] = 100 * float64(usageDiff) / float64(timeDiff)
-		cpuUsageLock.Unlock()
-		prevTime = curTime
-		prevUsage = curUsage
-	}
-}

cmd/syncthing/gui_statics.go

@@ -1,176 +0,0 @@
-// Copyright (C) 2014 The Syncthing Authors.
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this file,
-// You can obtain one at http://mozilla.org/MPL/2.0/.
-
-package main
-
-import (
-	"bytes"
-	"compress/gzip"
-	"fmt"
-	"io/ioutil"
-	"mime"
-	"net/http"
-	"os"
-	"path/filepath"
-	"strings"
-
-	"github.com/syncthing/syncthing/lib/auto"
-	"github.com/syncthing/syncthing/lib/config"
-	"github.com/syncthing/syncthing/lib/sync"
-)
-
-type staticsServer struct {
-	assetDir        string
-	assets          map[string][]byte
-	availableThemes []string
-
-	mut   sync.RWMutex
-	theme string
-}
-
-func newStaticsServer(theme, assetDir string) *staticsServer {
-	s := &staticsServer{
-		assetDir: assetDir,
-		assets:   auto.Assets(),
-		mut:      sync.NewRWMutex(),
-		theme:    theme,
-	}
-
-	seen := make(map[string]struct{})
-	// Load themes from compiled in assets.
-	for file := range auto.Assets() {
-		theme := strings.Split(file, "/")[0]
-		if _, ok := seen[theme]; !ok {
-			seen[theme] = struct{}{}
-			s.availableThemes = append(s.availableThemes, theme)
-		}
-	}
-	if assetDir != "" {
-		// Load any extra themes from the asset override dir.
-		for _, dir := range dirNames(assetDir) {
-			if _, ok := seen[dir]; !ok {
-				seen[dir] = struct{}{}
-				s.availableThemes = append(s.availableThemes, dir)
-			}
-		}
-	}
-
-	return s
-}
-
-func (s *staticsServer) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	switch r.URL.Path {
-	case "/themes.json":
-		s.serveThemes(w, r)
-	default:
-		s.serveAsset(w, r)
-	}
-}
-
-func (s *staticsServer) serveAsset(w http.ResponseWriter, r *http.Request) {
-	file := r.URL.Path
-
-	if file[0] == '/' {
-		file = file[1:]
-	}
-
-	if len(file) == 0 {
-		file = "index.html"
-	}
-
-	s.mut.RLock()
-	theme := s.theme
-	s.mut.RUnlock()
-
-	// Check for an override for the current theme.
-	if s.assetDir != "" {
-		p := filepath.Join(s.assetDir, theme, filepath.FromSlash(file))
-		if _, err := os.Stat(p); err == nil {
-			http.ServeFile(w, r, p)
-			return
-		}
-	}
-
-	// Check for a compiled in asset for the current theme.
-	bs, ok := s.assets[theme+"/"+file]
-	if !ok {
-		// Check for an overridden default asset.
-		if s.assetDir != "" {
-			p := filepath.Join(s.assetDir, config.DefaultTheme, filepath.FromSlash(file))
-			if _, err := os.Stat(p); err == nil {
-				http.ServeFile(w, r, p)
-				return
-			}
-		}
-
-		// Check for a compiled in default asset.
-		bs, ok = s.assets[config.DefaultTheme+"/"+file]
-		if !ok {
-			http.NotFound(w, r)
-			return
-		}
-	}
-
-	mtype := s.mimeTypeForFile(file)
-	if len(mtype) != 0 {
-		w.Header().Set("Content-Type", mtype)
-	}
-	if strings.Contains(r.Header.Get("Accept-Encoding"), "gzip") {
-		w.Header().Set("Content-Encoding", "gzip")
-	} else {
-		// ungzip if browser not send gzip accepted header
-		var gr *gzip.Reader
-		gr, _ = gzip.NewReader(bytes.NewReader(bs))
-		bs, _ = ioutil.ReadAll(gr)
-		gr.Close()
-	}
-	w.Header().Set("Content-Length", fmt.Sprintf("%d", len(bs)))
-
-	w.Write(bs)
-}
-
-func (s *staticsServer) serveThemes(w http.ResponseWriter, r *http.Request) {
-	sendJSON(w, map[string][]string{
-		"themes": s.availableThemes,
-	})
-}
-
-func (s *staticsServer) mimeTypeForFile(file string) string {
-	// We use a built in table of the common types since the system
-	// TypeByExtension might be unreliable. But if we don't know, we delegate
-	// to the system.
-	ext := filepath.Ext(file)
-	switch ext {
-	case ".htm", ".html":
-		return "text/html"
-	case ".css":
-		return "text/css"
-	case ".js":
-		return "application/javascript"
-	case ".json":
-		return "application/json"
-	case ".png":
-		return "image/png"
-	case ".ttf":
-		return "application/x-font-ttf"
-	case ".woff":
-		return "application/x-font-woff"
-	case ".svg":
-		return "image/svg+xml"
-	default:
-		return mime.TypeByExtension(ext)
-	}
-}
-
-func (s *staticsServer) setTheme(theme string) {
-	s.mut.Lock()
-	s.theme = theme
-	s.mut.Unlock()
-}
-
-func (s *staticsServer) String() string {
-	return fmt.Sprintf("staticsServer@%p", s)
-}

cmd/syncthing/gui_test.go

@@ -1,615 +0,0 @@
-// Copyright (C) 2016 The Syncthing Authors.
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this file,
-// You can obtain one at http://mozilla.org/MPL/2.0/.
-
-package main
-
-import (
-	"bytes"
-	"compress/gzip"
-	"encoding/json"
-	"fmt"
-	"io/ioutil"
-	"net"
-	"net/http"
-	"net/http/httptest"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/d4l3k/messagediff"
-	"github.com/syncthing/syncthing/lib/config"
-	"github.com/syncthing/syncthing/lib/protocol"
-	"github.com/syncthing/syncthing/lib/sync"
-	"github.com/thejerf/suture"
-)
-
-func TestCSRFToken(t *testing.T) {
-	t1 := newCsrfToken()
-	t2 := newCsrfToken()
-
-	t3 := newCsrfToken()
-	if !validCsrfToken(t3) {
-		t.Fatal("t3 should be valid")
-	}
-
-	for i := 0; i < 250; i++ {
-		if i%5 == 0 {
-			// t1 and t2 should remain valid by virtue of us checking them now
-			// and then.
-			if !validCsrfToken(t1) {
-				t.Fatal("t1 should be valid at iteration", i)
-			}
-			if !validCsrfToken(t2) {
-				t.Fatal("t2 should be valid at iteration", i)
-			}
-		}
-
-		// The newly generated token is always valid
-		t4 := newCsrfToken()
-		if !validCsrfToken(t4) {
-			t.Fatal("t4 should be valid at iteration", i)
-		}
-	}
-
-	if validCsrfToken(t3) {
-		t.Fatal("t3 should have expired by now")
-	}
-}
-
-func TestStopAfterBrokenConfig(t *testing.T) {
-	cfg := config.Configuration{
-		GUI: config.GUIConfiguration{
-			RawAddress: "127.0.0.1:0",
-			RawUseTLS:  false,
-		},
-	}
-	w := config.Wrap("/dev/null", cfg)
-
-	srv := newAPIService(protocol.LocalDeviceID, w, "../../test/h1/https-cert.pem", "../../test/h1/https-key.pem", "", nil, nil, nil, nil, nil, nil)
-	srv.started = make(chan string)
-
-	sup := suture.NewSimple("test")
-	sup.Add(srv)
-	sup.ServeBackground()
-
-	<-srv.started
-
-	// Service is now running, listening on a random port on localhost. Now we
-	// request a config change to a completely invalid listen address. The
-	// commit will fail and the service will be in a broken state.
-
-	newCfg := config.Configuration{
-		GUI: config.GUIConfiguration{
-			RawAddress: "totally not a valid address",
-			RawUseTLS:  false,
-		},
-	}
-	if err := srv.VerifyConfiguration(cfg, newCfg); err == nil {
-		t.Fatal("Verify config should have failed")
-	}
-
-	// Nonetheless, it should be fine to Stop() it without panic.
-
-	sup.Stop()
-}
-
-func TestAssetsDir(t *testing.T) {
-	// For any given request to $FILE, we should return the first found of
-	//  - assetsdir/$THEME/$FILE
-	//  - compiled in asset $THEME/$FILE
-	//  - assetsdir/default/$FILE
-	//  - compiled in asset default/$FILE
-
-	// The asset map contains compressed assets, so create a couple of gzip compressed assets here.
-	buf := new(bytes.Buffer)
-	gw := gzip.NewWriter(buf)
-	gw.Write([]byte("default"))
-	gw.Close()
-	def := buf.Bytes()
-
-	buf = new(bytes.Buffer)
-	gw = gzip.NewWriter(buf)
-	gw.Write([]byte("foo"))
-	gw.Close()
-	foo := buf.Bytes()
-
-	e := &staticsServer{
-		theme:    "foo",
-		mut:      sync.NewRWMutex(),
-		assetDir: "testdata",
-		assets: map[string][]byte{
-			"foo/a":     foo, // overridden in foo/a
-			"foo/b":     foo,
-			"default/a": def, // overridden in default/a (but foo/a takes precedence)
-			"default/b": def, // overridden in default/b (but foo/b takes precedence)
-			"default/c": def,
-		},
-	}
-
-	s := httptest.NewServer(e)
-	defer s.Close()
-
-	// assetsdir/foo/a exists, overrides compiled in
-	expectURLToContain(t, s.URL+"/a", "overridden-foo")
-
-	// foo/b is compiled in, default/b is overridden, return compiled in
-	expectURLToContain(t, s.URL+"/b", "foo")
-
-	// only exists as compiled in default/c so use that
-	expectURLToContain(t, s.URL+"/c", "default")
-
-	// only exists as overridden default/d so use that
-	expectURLToContain(t, s.URL+"/d", "overridden-default")
-}
-
-func expectURLToContain(t *testing.T, url, exp string) {
-	res, err := http.Get(url)
-	if err != nil {
-		t.Error(err)
-		return
-	}
-
-	if res.StatusCode != 200 {
-		t.Errorf("Got %s instead of 200 OK", res.Status)
-		return
-	}
-
-	data, err := ioutil.ReadAll(res.Body)
-	res.Body.Close()
-	if err != nil {
-		t.Error(err)
-		return
-	}
-
-	if string(data) != exp {
-		t.Errorf("Got %q instead of %q on %q", data, exp, url)
-		return
-	}
-}
-
-func TestDirNames(t *testing.T) {
-	names := dirNames("testdata")
-	expected := []string{"default", "foo", "testfolder"}
-	if diff, equal := messagediff.PrettyDiff(expected, names); !equal {
-		t.Errorf("Unexpected dirNames return: %#v\n%s", names, diff)
-	}
-}
-
-type httpTestCase struct {
-	URL     string        // URL to check
-	Code    int           // Expected result code
-	Type    string        // Expected content type
-	Prefix  string        // Expected result prefix
-	Timeout time.Duration // Defaults to a second
-}
-
-func TestAPIServiceRequests(t *testing.T) {
-	const testAPIKey = "foobarbaz"
-	cfg := new(mockedConfig)
-	cfg.gui.APIKey = testAPIKey
-	baseURL, err := startHTTP(cfg)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	cases := []httpTestCase{
-		// /rest/db
-		{
-			URL:    "/rest/db/completion?device=" + protocol.LocalDeviceID.String() + "&folder=default",
-			Code:   200,
-			Type:   "application/json",
-			Prefix: "{",
-		},
-		{
-			URL:  "/rest/db/file?folder=default&file=something",
-			Code: 404,
-		},
-		{
-			URL:    "/rest/db/ignores?folder=default",
-			Code:   200,
-			Type:   "application/json",
-			Prefix: "{",
-		},
-		{
-			URL:    "/rest/db/need?folder=default",
-			Code:   200,
-			Type:   "application/json",
-			Prefix: "{",
-		},
-		{
-			URL:    "/rest/db/status?folder=default",
-			Code:   200,
-			Type:   "application/json",
-			Prefix: "{",
-		},
-		{
-			URL:    "/rest/db/browse?folder=default",
-			Code:   200,
-			Type:   "application/json",
-			Prefix: "null",
-		},
-
-		// /rest/stats
-		{
-			URL:    "/rest/stats/device",
-			Code:   200,
-			Type:   "application/json",
-			Prefix: "null",
-		},
-		{
-			URL:    "/rest/stats/folder",
-			Code:   200,
-			Type:   "application/json",
-			Prefix: "null",
-		},
-
-		// /rest/svc
-		{
-			URL:    "/rest/svc/deviceid?id=" + protocol.LocalDeviceID.String(),
-			Code:   200,
-			Type:   "application/json",
-			Prefix: "{",
-		},
-		{
-			URL:    "/rest/svc/lang",
-			Code:   200,
-			Type:   "application/json",
-			Prefix: "[",
-		},
-		{
-			URL:     "/rest/svc/report",
-			Code:    200,
-			Type:    "application/json",
-			Prefix:  "{",
-			Timeout: 5 * time.Second,
-		},
-
-		// /rest/system
-		{
-			URL:    "/rest/system/browse?current=~",
-			Code:   200,
-			Type:   "application/json",
-			Prefix: "[",
-		},
-		{
-			URL:    "/rest/system/config",
-			Code:   200,
-			Type:   "application/json",
-			Prefix: "{",
-		},
-		{
-			URL:    "/rest/system/config/insync",
-			Code:   200,
-			Type:   "application/json",
-			Prefix: "{",
-		},
-		{
-			URL:    "/rest/system/connections",
-			Code:   200,
-			Type:   "application/json",
-			Prefix: "null",
-		},
-		{
-			URL:    "/rest/system/discovery",
-			Code:   200,
-			Type:   "application/json",
-			Prefix: "{",
-		},
-		{
-			URL:    "/rest/system/error?since=0",
-			Code:   200,
-			Type:   "application/json",
-			Prefix: "{",
-		},
-		{
-			URL:    "/rest/system/ping",
-			Code:   200,
-			Type:   "application/json",
-			Prefix: "{",
-		},
-		{
-			URL:    "/rest/system/status",
-			Code:   200,
-			Type:   "application/json",
-			Prefix: "{",
-		},
-		{
-			URL:    "/rest/system/version",
-			Code:   200,
-			Type:   "application/json",
-			Prefix: "{",
-		},
-		{
-			URL:    "/rest/system/debug",
-			Code:   200,
-			Type:   "application/json",
-			Prefix: "{",
-		},
-		{
-			URL:    "/rest/system/log?since=0",
-			Code:   200,
-			Type:   "application/json",
-			Prefix: "{",
-		},
-		{
-			URL:    "/rest/system/log.txt?since=0",
-			Code:   200,
-			Type:   "text/plain",
-			Prefix: "",
-		},
-	}
-
-	for _, tc := range cases {
-		t.Log("Testing", tc.URL, "...")
-		testHTTPRequest(t, baseURL, tc, testAPIKey)
-	}
-}
-
-// testHTTPRequest tries the given test case, comparing the result code,
-// content type, and result prefix.
-func testHTTPRequest(t *testing.T, baseURL string, tc httpTestCase, apikey string) {
-	timeout := time.Second
-	if tc.Timeout > 0 {
-		timeout = tc.Timeout
-	}
-	cli := &http.Client{
-		Timeout: timeout,
-	}
-
-	req, err := http.NewRequest("GET", baseURL+tc.URL, nil)
-	if err != nil {
-		t.Errorf("Unexpected error requesting %s: %v", tc.URL, err)
-		return
-	}
-	req.Header.Set("X-API-Key", apikey)
-
-	resp, err := cli.Do(req)
-	if err != nil {
-		t.Errorf("Unexpected error requesting %s: %v", tc.URL, err)
-		return
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode != tc.Code {
-		t.Errorf("Get on %s should have returned status code %d, not %s", tc.URL, tc.Code, resp.Status)
-		return
-	}
-
-	ct := resp.Header.Get("Content-Type")
-	if !strings.HasPrefix(ct, tc.Type) {
-		t.Errorf("The content type on %s should be %q, not %q", tc.URL, tc.Type, ct)
-		return
-	}
-
-	data, err := ioutil.ReadAll(resp.Body)
-	if err != nil {
-		t.Errorf("Unexpected error reading %s: %v", tc.URL, err)
-		return
-	}
-
-	if !bytes.HasPrefix(data, []byte(tc.Prefix)) {
-		t.Errorf("Returned data from %s does not have prefix %q: %s", tc.URL, tc.Prefix, data)
-		return
-	}
-}
-
-func TestHTTPLogin(t *testing.T) {
-	cfg := new(mockedConfig)
-	cfg.gui.User = "üser"
-	cfg.gui.Password = "$2a$10$IdIZTxTg/dCNuNEGlmLynOjqg4B1FvDKuIV5e0BB3pnWVHNb8.GSq" // bcrypt of "räksmörgås" in UTF-8
-	baseURL, err := startHTTP(cfg)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	// Verify rejection when not using authorization
-
-	req, _ := http.NewRequest("GET", baseURL, nil)
-	resp, err := http.DefaultClient.Do(req)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if resp.StatusCode != http.StatusUnauthorized {
-		t.Errorf("Unexpected non-401 return code %d for unauthed request", resp.StatusCode)
-	}
-
-	// Verify that incorrect password is rejected
-
-	req.SetBasicAuth("üser", "rksmrgs")
-	resp, err = http.DefaultClient.Do(req)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if resp.StatusCode != http.StatusUnauthorized {
-		t.Errorf("Unexpected non-401 return code %d for incorrect password", resp.StatusCode)
-	}
-
-	// Verify that incorrect username is rejected
-
-	req.SetBasicAuth("user", "räksmörgås") // string literals in Go source code are in UTF-8
-	resp, err = http.DefaultClient.Do(req)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if resp.StatusCode != http.StatusUnauthorized {
-		t.Errorf("Unexpected non-401 return code %d for incorrect username", resp.StatusCode)
-	}
-
-	// Verify that UTF-8 auth works
-
-	req.SetBasicAuth("üser", "räksmörgås") // string literals in Go source code are in UTF-8
-	resp, err = http.DefaultClient.Do(req)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if resp.StatusCode != http.StatusOK {
-		t.Errorf("Unexpected non-200 return code %d for authed request (UTF-8)", resp.StatusCode)
-	}
-
-	// Verify that ISO-8859-1 auth
-
-	req.SetBasicAuth("\xfcser", "r\xe4ksm\xf6rg\xe5s") // escaped ISO-8859-1
-	resp, err = http.DefaultClient.Do(req)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if resp.StatusCode != http.StatusOK {
-		t.Errorf("Unexpected non-200 return code %d for authed request (ISO-8859-1)", resp.StatusCode)
-	}
-
-}
-
-func startHTTP(cfg *mockedConfig) (string, error) {
-	model := new(mockedModel)
-	httpsCertFile := "../../test/h1/https-cert.pem"
-	httpsKeyFile := "../../test/h1/https-key.pem"
-	assetDir := "../../gui"
-	eventSub := new(mockedEventSub)
-	discoverer := new(mockedCachingMux)
-	connections := new(mockedConnections)
-	errorLog := new(mockedLoggerRecorder)
-	systemLog := new(mockedLoggerRecorder)
-	addrChan := make(chan string)
-
-	// Instantiate the API service
-	svc := newAPIService(protocol.LocalDeviceID, cfg, httpsCertFile, httpsKeyFile, assetDir, model,
-		eventSub, discoverer, connections, errorLog, systemLog)
-	svc.started = addrChan
-
-	// Actually start the API service
-	supervisor := suture.NewSimple("API test")
-	supervisor.Add(svc)
-	supervisor.ServeBackground()
-
-	// Make sure the API service is listening, and get the URL to use.
-	addr := <-addrChan
-	tcpAddr, err := net.ResolveTCPAddr("tcp", addr)
-	if err != nil {
-		return "", fmt.Errorf("Weird address from API service: %v", err)
-	}
-	baseURL := fmt.Sprintf("http://127.0.0.1:%d", tcpAddr.Port)
-
-	return baseURL, nil
-}
-
-func TestCSRFRequired(t *testing.T) {
-	const testAPIKey = "foobarbaz"
-	cfg := new(mockedConfig)
-	cfg.gui.APIKey = testAPIKey
-	baseURL, err := startHTTP(cfg)
-
-	cli := &http.Client{
-		Timeout: time.Second,
-	}
-
-	// Getting the base URL (i.e. "/") should succeed.
-
-	resp, err := cli.Get(baseURL)
-	if err != nil {
-		t.Fatal("Unexpected error from getting base URL:", err)
-	}
-	resp.Body.Close()
-	if resp.StatusCode != http.StatusOK {
-		t.Fatal("Getting base URL should succeed, not", resp.Status)
-	}
-
-	// Find the returned CSRF token for future use
-
-	var csrfTokenName, csrfTokenValue string
-	for _, cookie := range resp.Cookies() {
-		if strings.HasPrefix(cookie.Name, "CSRF-Token") {
-			csrfTokenName = cookie.Name
-			csrfTokenValue = cookie.Value
-			break
-		}
-	}
-
-	// Calling on /rest without a token should fail
-
-	resp, err = cli.Get(baseURL + "/rest/system/config")
-	if err != nil {
-		t.Fatal("Unexpected error from getting /rest/system/config:", err)
-	}
-	resp.Body.Close()
-	if resp.StatusCode != http.StatusForbidden {
-		t.Fatal("Getting /rest/system/config without CSRF token should fail, not", resp.Status)
-	}
-
-	// Calling on /rest with a token should succeed
-
-	req, _ := http.NewRequest("GET", baseURL+"/rest/system/config", nil)
-	req.Header.Set("X-"+csrfTokenName, csrfTokenValue)
-	resp, err = cli.Do(req)
-	if err != nil {
-		t.Fatal("Unexpected error from getting /rest/system/config:", err)
-	}
-	resp.Body.Close()
-	if resp.StatusCode != http.StatusOK {
-		t.Fatal("Getting /rest/system/config with CSRF token should succeed, not", resp.Status)
-	}
-
-	// Calling on /rest with the API key should succeed
-
-	req, _ = http.NewRequest("GET", baseURL+"/rest/system/config", nil)
-	req.Header.Set("X-API-Key", testAPIKey)
-	resp, err = cli.Do(req)
-	if err != nil {
-		t.Fatal("Unexpected error from getting /rest/system/config:", err)
-	}
-	resp.Body.Close()
-	if resp.StatusCode != http.StatusOK {
-		t.Fatal("Getting /rest/system/config with API key should succeed, not", resp.Status)
-	}
-}
-
-func TestRandomString(t *testing.T) {
-	const testAPIKey = "foobarbaz"
-	cfg := new(mockedConfig)
-	cfg.gui.APIKey = testAPIKey
-	baseURL, err := startHTTP(cfg)
-	if err != nil {
-		t.Fatal(err)
-	}
-	cli := &http.Client{
-		Timeout: time.Second,
-	}
-
-	// The default should be to return a 32 character random string
-
-	for _, url := range []string{"/rest/svc/random/string", "/rest/svc/random/string?length=-1", "/rest/svc/random/string?length=yo"} {
-		req, _ := http.NewRequest("GET", baseURL+url, nil)
-		req.Header.Set("X-API-Key", testAPIKey)
-		resp, err := cli.Do(req)
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		var res map[string]string
-		if err := json.NewDecoder(resp.Body).Decode(&res); err != nil {
-			t.Fatal(err)
-		}
-		if len(res["random"]) != 32 {
-			t.Errorf("Expected 32 random characters, got %q of length %d", res["random"], len(res["random"]))
-		}
-	}
-
-	// We can ask for a different length if we like
-
-	req, _ := http.NewRequest("GET", baseURL+"/rest/svc/random/string?length=27", nil)
-	req.Header.Set("X-API-Key", testAPIKey)
-	resp, err := cli.Do(req)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	var res map[string]string
-	if err := json.NewDecoder(resp.Body).Decode(&res); err != nil {
-		t.Fatal(err)
-	}
-	if len(res["random"]) != 27 {
-		t.Errorf("Expected 27 random characters, got %q of length %d", res["random"], len(res["random"]))
-	}
-}

cmd/syncthing/gui_windows.go

@@ -1,58 +0,0 @@
-// Copyright (C) 2014 The Syncthing Authors.
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this file,
-// You can obtain one at http://mozilla.org/MPL/2.0/.
-
-//+build windows
-
-package main
-
-import (
-	"syscall"
-	"time"
-)
-
-func init() {
-	go trackCPUUsage()
-}
-
-func trackCPUUsage() {
-	handle, err := syscall.GetCurrentProcess()
-	if err != nil {
-		l.Warnln("Cannot track CPU usage:", err)
-		return
-	}
-
-	var ctime, etime, ktime, utime syscall.Filetime
-	err = syscall.GetProcessTimes(handle, &ctime, &etime, &ktime, &utime)
-	if err != nil {
-		l.Warnln("Cannot track CPU usage:", err)
-		return
-	}
-
-	prevTime := ctime.Nanoseconds()
-	prevUsage := ktime.Nanoseconds() + utime.Nanoseconds() // Always overflows
-
-	for _ = range time.NewTicker(time.Second).C {
-		err := syscall.GetProcessTimes(handle, &ctime, &etime, &ktime, &utime)
-		if err != nil {
-			continue
-		}
-
-		curTime := time.Now().UnixNano()
-		timeDiff := curTime - prevTime
-		// This is sometimes 0, no clue why.
-		if timeDiff == 0 {
-			continue
-		}
-		curUsage := ktime.Nanoseconds() + utime.Nanoseconds()
-		usageDiff := curUsage - prevUsage
-		cpuUsageLock.Lock()
-		copy(cpuUsagePercent[1:], cpuUsagePercent[0:])
-		cpuUsagePercent[0] = 100 * float64(usageDiff) / float64(timeDiff)
-		cpuUsageLock.Unlock()
-		prevTime = curTime
-		prevUsage = curUsage
-	}
-}

cmd/syncthing/heapprof.go

@@ -1,63 +0,0 @@
-// Copyright (C) 2014 The Syncthing Authors.
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this file,
-// You can obtain one at http://mozilla.org/MPL/2.0/.
-
-package main
-
-import (
-	"fmt"
-	"os"
-	"runtime"
-	"runtime/pprof"
-	"strconv"
-	"syscall"
-	"time"
-)
-
-func init() {
-	if innerProcess && os.Getenv("STHEAPPROFILE") != "" {
-		rate := 1
-		if i, err := strconv.Atoi(os.Getenv("STHEAPPROFILE")); err == nil {
-			rate = i
-		}
-		l.Debugln("Starting heap profiling")
-		go saveHeapProfiles(rate)
-	}
-}
-
-func saveHeapProfiles(rate int) {
-	runtime.MemProfileRate = rate
-	var memstats, prevMemstats runtime.MemStats
-
-	name := fmt.Sprintf("heap-%05d.pprof", syscall.Getpid())
-	for {
-		runtime.ReadMemStats(&memstats)
-
-		if memstats.HeapInuse > prevMemstats.HeapInuse {
-			fd, err := os.Create(name + ".tmp")
-			if err != nil {
-				panic(err)
-			}
-			err = pprof.WriteHeapProfile(fd)
-			if err != nil {
-				panic(err)
-			}
-			err = fd.Close()
-			if err != nil {
-				panic(err)
-			}
-
-			_ = os.Remove(name) // Error deliberately ignored
-			err = os.Rename(name+".tmp", name)
-			if err != nil {
-				panic(err)
-			}
-
-			prevMemstats = memstats
-		}
-
-		time.Sleep(250 * time.Millisecond)
-	}
-}

cmd/syncthing/locations.go

@@ -1,125 +0,0 @@
-// Copyright (C) 2015 The Syncthing Authors.
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this file,
-// You can obtain one at http://mozilla.org/MPL/2.0/.
-
-package main
-
-import (
-	"os"
-	"path/filepath"
-	"runtime"
-	"strings"
-	"time"
-
-	"github.com/syncthing/syncthing/lib/osutil"
-)
-
-type locationEnum string
-
-// Use strings as keys to make printout and serialization of the locations map
-// more meaningful.
-const (
-	locConfigFile    locationEnum = "config"
-	locCertFile                   = "certFile"
-	locKeyFile                    = "keyFile"
-	locHTTPSCertFile              = "httpsCertFile"
-	locHTTPSKeyFile               = "httpsKeyFile"
-	locDatabase                   = "database"
-	locLogFile                    = "logFile"
-	locCsrfTokens                 = "csrfTokens"
-	locPanicLog                   = "panicLog"
-	locAuditLog                   = "auditLog"
-	locGUIAssets                  = "GUIAssets"
-	locDefFolder                  = "defFolder"
-)
-
-// Platform dependent directories
-var baseDirs = map[string]string{
-	"config": defaultConfigDir(), // Overridden by -home flag
-	"home":   homeDir(),          // User's home directory, *not* -home flag
-}
-
-// Use the variables from baseDirs here
-var locations = map[locationEnum]string{
-	locConfigFile:    "${config}/config.xml",
-	locCertFile:      "${config}/cert.pem",
-	locKeyFile:       "${config}/key.pem",
-	locHTTPSCertFile: "${config}/https-cert.pem",
-	locHTTPSKeyFile:  "${config}/https-key.pem",
-	locDatabase:      "${config}/index-v0.13.0.db",
-	locLogFile:       "${config}/syncthing.log", // -logfile on Windows
-	locCsrfTokens:    "${config}/csrftokens.txt",
-	locPanicLog:      "${config}/panic-${timestamp}.log",
-	locAuditLog:      "${config}/audit-${timestamp}.log",
-	locGUIAssets:     "${config}/gui",
-	locDefFolder:     "${home}/Sync",
-}
-
-// expandLocations replaces the variables in the location map with actual
-// directory locations.
-func expandLocations() error {
-	for key, dir := range locations {
-		for varName, value := range baseDirs {
-			dir = strings.Replace(dir, "${"+varName+"}", value, -1)
-		}
-		var err error
-		dir, err = osutil.ExpandTilde(dir)
-		if err != nil {
-			return err
-		}
-		locations[key] = dir
-	}
-	return nil
-}
-
-// defaultConfigDir returns the default configuration directory, as figured
-// out by various the environment variables present on each platform, or dies
-// trying.
-func defaultConfigDir() string {
-	switch runtime.GOOS {
-	case "windows":
-		if p := os.Getenv("LocalAppData"); p != "" {
-			return filepath.Join(p, "Syncthing")
-		}
-		return filepath.Join(os.Getenv("AppData"), "Syncthing")
-
-	case "darwin":
-		dir, err := osutil.ExpandTilde("~/Library/Application Support/Syncthing")
-		if err != nil {
-			l.Fatalln(err)
-		}
-		return dir
-
-	default:
-		if xdgCfg := os.Getenv("XDG_CONFIG_HOME"); xdgCfg != "" {
-			return filepath.Join(xdgCfg, "syncthing")
-		}
-		dir, err := osutil.ExpandTilde("~/.config/syncthing")
-		if err != nil {
-			l.Fatalln(err)
-		}
-		return dir
-	}
-}
-
-// homeDir returns the user's home directory, or dies trying.
-func homeDir() string {
-	home, err := osutil.ExpandTilde("~")
-	if err != nil {
-		l.Fatalln(err)
-	}
-	return home
-}
-
-func timestampedLoc(key locationEnum) string {
-	// We take the roundtrip via "${timestamp}" instead of passing the path
-	// directly through time.Format() to avoid issues when the path we are
-	// expanding contains numbers; otherwise for example
-	// /home/user2006/.../panic-20060102-150405.log would get both instances of
-	// 2006 replaced by 2015...
-	tpl := locations[key]
-	now := time.Now().Format("20060102-150405")
-	return strings.Replace(tpl, "${timestamp}", now, -1)
-}

cmd/syncthing/main_test.go

@@ -1,203 +0,0 @@
-// Copyright (C) 2014 The Syncthing Authors.
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this file,
-// You can obtain one at http://mozilla.org/MPL/2.0/.
-
-package main
-
-import (
-	"os"
-	"testing"
-
-	"github.com/syncthing/syncthing/lib/config"
-	"github.com/syncthing/syncthing/lib/db"
-	"github.com/syncthing/syncthing/lib/model"
-	"github.com/syncthing/syncthing/lib/protocol"
-)
-
-func TestFolderErrors(t *testing.T) {
-	// This test intentionally avoids starting the folders. If they are
-	// started, they will perform an initial scan, which will create missing
-	// folder markers and race with the stuff we do in the test.
-
-	fcfg := config.FolderConfiguration{
-		ID:      "folder",
-		RawPath: "testdata/testfolder",
-	}
-	cfg := config.Wrap("/tmp/test", config.Configuration{
-		Folders: []config.FolderConfiguration{fcfg},
-	})
-
-	for _, file := range []string{".stfolder", "testfolder/.stfolder", "testfolder"} {
-		if err := os.Remove("testdata/" + file); err != nil && !os.IsNotExist(err) {
-			t.Fatal(err)
-		}
-	}
-
-	ldb := db.OpenMemory()
-
-	// Case 1 - new folder, directory and marker created
-
-	m := model.NewModel(cfg, protocol.LocalDeviceID, "device", "syncthing", "dev", ldb, nil)
-	m.AddFolder(fcfg)
-
-	if err := m.CheckFolderHealth("folder"); err != nil {
-		t.Error("Unexpected error", cfg.Folders()["folder"].Invalid)
-	}
-
-	s, err := os.Stat("testdata/testfolder")
-	if err != nil || !s.IsDir() {
-		t.Error(err)
-	}
-
-	_, err = os.Stat("testdata/testfolder/.stfolder")
-	if err != nil {
-		t.Error(err)
-	}
-
-	if err := os.Remove("testdata/testfolder/.stfolder"); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.Remove("testdata/testfolder/"); err != nil {
-		t.Fatal(err)
-	}
-
-	// Case 2 - new folder, marker created
-
-	fcfg.RawPath = "testdata/"
-	cfg = config.Wrap("/tmp/test", config.Configuration{
-		Folders: []config.FolderConfiguration{fcfg},
-	})
-
-	m = model.NewModel(cfg, protocol.LocalDeviceID, "device", "syncthing", "dev", ldb, nil)
-	m.AddFolder(fcfg)
-
-	if err := m.CheckFolderHealth("folder"); err != nil {
-		t.Error("Unexpected error", cfg.Folders()["folder"].Invalid)
-	}
-
-	_, err = os.Stat("testdata/.stfolder")
-	if err != nil {
-		t.Error(err)
-	}
-
-	if err := os.Remove("testdata/.stfolder"); err != nil {
-		t.Fatal(err)
-	}
-
-	// Case 3 - Folder marker missing
-
-	set := db.NewFileSet("folder", ldb)
-	set.Update(protocol.LocalDeviceID, []protocol.FileInfo{
-		{Name: "dummyfile"},
-	})
-
-	m = model.NewModel(cfg, protocol.LocalDeviceID, "device", "syncthing", "dev", ldb, nil)
-	m.AddFolder(fcfg)
-
-	if err := m.CheckFolderHealth("folder"); err == nil || err.Error() != "folder marker missing" {
-		t.Error("Incorrect error: Folder marker missing !=", m.CheckFolderHealth("folder"))
-	}
-
-	// Case 3.1 - recover after folder marker missing
-
-	if err = fcfg.CreateMarker(); err != nil {
-		t.Error(err)
-	}
-
-	if err := m.CheckFolderHealth("folder"); err != nil {
-		t.Error("Unexpected error", cfg.Folders()["folder"].Invalid)
-	}
-
-	// Case 4 - Folder path missing
-
-	if err := os.Remove("testdata/testfolder/.stfolder"); err != nil && !os.IsNotExist(err) {
-		t.Fatal(err)
-	}
-	if err := os.Remove("testdata/testfolder"); err != nil && !os.IsNotExist(err) {
-		t.Fatal(err)
-	}
-
-	fcfg.RawPath = "testdata/testfolder"
-	cfg = config.Wrap("testdata/subfolder", config.Configuration{
-		Folders: []config.FolderConfiguration{fcfg},
-	})
-
-	m = model.NewModel(cfg, protocol.LocalDeviceID, "device", "syncthing", "dev", ldb, nil)
-	m.AddFolder(fcfg)
-
-	if err := m.CheckFolderHealth("folder"); err == nil || err.Error() != "folder path missing" {
-		t.Error("Incorrect error: Folder path missing !=", m.CheckFolderHealth("folder"))
-	}
-
-	// Case 4.1 - recover after folder path missing
-
-	if err := os.Mkdir("testdata/testfolder", 0700); err != nil {
-		t.Fatal(err)
-	}
-
-	if err := m.CheckFolderHealth("folder"); err == nil || err.Error() != "folder marker missing" {
-		t.Error("Incorrect error: Folder marker missing !=", m.CheckFolderHealth("folder"))
-	}
-
-	// Case 4.2 - recover after missing marker
-
-	if err = fcfg.CreateMarker(); err != nil {
-		t.Error(err)
-	}
-
-	if err := m.CheckFolderHealth("folder"); err != nil {
-		t.Error("Unexpected error", cfg.Folders()["folder"].Invalid)
-	}
-}
-
-func TestShortIDCheck(t *testing.T) {
-	cfg := config.Wrap("/tmp/test", config.Configuration{
-		Devices: []config.DeviceConfiguration{
-			{DeviceID: protocol.DeviceID{8, 16, 24, 32, 40, 48, 56, 0, 0}},
-			{DeviceID: protocol.DeviceID{8, 16, 24, 32, 40, 48, 56, 1, 1}}, // first 56 bits same, differ in the first 64 bits
-		},
-	})
-
-	if err := checkShortIDs(cfg); err != nil {
-		t.Error("Unexpected error:", err)
-	}
-
-	cfg = config.Wrap("/tmp/test", config.Configuration{
-		Devices: []config.DeviceConfiguration{
-			{DeviceID: protocol.DeviceID{8, 16, 24, 32, 40, 48, 56, 64, 0}},
-			{DeviceID: protocol.DeviceID{8, 16, 24, 32, 40, 48, 56, 64, 1}}, // first 64 bits same
-		},
-	})
-
-	if err := checkShortIDs(cfg); err == nil {
-		t.Error("Should have gotten an error")
-	}
-}
-
-func TestAllowedVersions(t *testing.T) {
-	testcases := []struct {
-		ver     string
-		allowed bool
-	}{
-		{"v0.13.0", true},
-		{"v0.12.11+22-gabcdef0", true},
-		{"v0.13.0-beta0", true},
-		{"v0.13.0-beta47", true},
-		{"v0.13.0-beta47+1-gabcdef0", true},
-		{"v0.13.0-beta.0", true},
-		{"v0.13.0-beta.47", true},
-		{"v0.13.0-beta.0+1-gabcdef0", true},
-		{"v0.13.0-beta.47+1-gabcdef0", true},
-		{"v0.13.0-some-weird-but-allowed-tag", true},
-		{"v0.13.0-allowed.to.do.this", true},
-		{"v0.13.0+not.allowed.to.do.this", false},
-	}
-
-	for i, c := range testcases {
-		if allowed := allowedVersionExp.MatchString(c.ver); allowed != c.allowed {
-			t.Errorf("%d: incorrect result %v != %v for %q", i, allowed, c.allowed, c.ver)
-		}
-	}
-}

cmd/syncthing/memsize_darwin.go

@@ -1,31 +0,0 @@
-// Copyright (C) 2014 The Syncthing Authors.
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this file,
-// You can obtain one at http://mozilla.org/MPL/2.0/.
-
-package main
-
-import (
-	"errors"
-	"os/exec"
-	"strconv"
-	"strings"
-)
-
-func memorySize() (int64, error) {
-	cmd := exec.Command("sysctl", "hw.memsize")
-	out, err := cmd.Output()
-	if err != nil {
-		return 0, err
-	}
-	fs := strings.Fields(string(out))
-	if len(fs) != 2 {
-		return 0, errors.New("sysctl parse error")
-	}
-	bytes, err := strconv.ParseInt(fs[1], 10, 64)
-	if err != nil {
-		return 0, err
-	}
-	return bytes, nil
-}

cmd/syncthing/memsize_linux.go

@@ -1,39 +0,0 @@
-// Copyright (C) 2014 The Syncthing Authors.
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this file,
-// You can obtain one at http://mozilla.org/MPL/2.0/.
-
-package main
-
-import (
-	"bufio"
-	"errors"
-	"os"
-	"strconv"
-	"strings"
-)
-
-func memorySize() (int64, error) {
-	f, err := os.Open("/proc/meminfo")
-	if err != nil {
-		return 0, err
-	}
-
-	s := bufio.NewScanner(f)
-	if !s.Scan() {
-		return 0, errors.New("/proc/meminfo parse error 1")
-	}
-
-	l := s.Text()
-	fs := strings.Fields(l)
-	if len(fs) != 3 || fs[2] != "kB" {
-		return 0, errors.New("/proc/meminfo parse error 2")
-	}
-
-	kb, err := strconv.ParseInt(fs[1], 10, 64)
-	if err != nil {
-		return 0, err
-	}
-	return kb * 1024, nil
-}

cmd/syncthing/memsize_netbsd.go

@@ -1,31 +0,0 @@
-// Copyright (C) 2014 The Syncthing Authors.
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this file,
-// You can obtain one at http://mozilla.org/MPL/2.0/.
-
-package main
-
-import (
-	"errors"
-	"os/exec"
-	"strconv"
-	"strings"
-)
-
-func memorySize() (int64, error) {
-	cmd := exec.Command("/sbin/sysctl", "hw.physmem64")
-	out, err := cmd.Output()
-	if err != nil {
-		return 0, err
-	}
-	fs := strings.Fields(string(out))
-	if len(fs) != 3 {
-		return 0, errors.New("sysctl parse error")
-	}
-	bytes, err := strconv.ParseInt(fs[2], 10, 64)
-	if err != nil {
-		return 0, err
-	}
-	return bytes, nil
-}

cmd/syncthing/memsize_solaris.go

@@ -1,28 +0,0 @@
-// Copyright (C) 2014 The Syncthing Authors.
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this file,
-// You can obtain one at http://mozilla.org/MPL/2.0/.
-
-// +build solaris
-
-package main
-
-import (
-	"os/exec"
-	"strconv"
-)
-
-func memorySize() (int64, error) {
-	cmd := exec.Command("prtconf", "-m")
-	out, err := cmd.CombinedOutput()
-	if err != nil {
-		return 0, err
-	}
-
-	mb, err := strconv.ParseInt(string(out), 10, 64)
-	if err != nil {
-		return 0, err
-	}
-	return mb * 1024 * 1024, nil
-}

cmd/syncthing/memsize_unimpl.go

@@ -1,15 +0,0 @@
-// Copyright (C) 2014 The Syncthing Authors.
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this file,
-// You can obtain one at http://mozilla.org/MPL/2.0/.
-
-// +build freebsd openbsd dragonfly
-
-package main
-
-import "errors"
-
-func memorySize() (int64, error) {
-	return 0, errors.New("not implemented")
-}

cmd/syncthing/memsize_windows.go

@@ -1,31 +0,0 @@
-// Copyright (C) 2014 The Syncthing Authors.
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this file,
-// You can obtain one at http://mozilla.org/MPL/2.0/.
-
-package main
-
-import (
-	"encoding/binary"
-	"syscall"
-	"unsafe"
-)
-
-var (
-	kernel32, _             = syscall.LoadLibrary("kernel32.dll")
-	globalMemoryStatusEx, _ = syscall.GetProcAddress(kernel32, "GlobalMemoryStatusEx")
-)
-
-func memorySize() (int64, error) {
-	var memoryStatusEx [64]byte
-	binary.LittleEndian.PutUint32(memoryStatusEx[:], 64)
-	p := uintptr(unsafe.Pointer(&memoryStatusEx[0]))
-
-	ret, _, callErr := syscall.Syscall(uintptr(globalMemoryStatusEx), 1, p, 0, 0)
-	if ret == 0 {
-		return 0, callErr
-	}
-
-	return int64(binary.LittleEndian.Uint64(memoryStatusEx[8:])), nil
-}

cmd/syncthing/mocked_config_test.go

@@ -1,50 +0,0 @@
-// Copyright (C) 2016 The Syncthing Authors.
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this file,
-// You can obtain one at http://mozilla.org/MPL/2.0/.
-
-package main
-
-import (
-	"github.com/syncthing/syncthing/lib/config"
-	"github.com/syncthing/syncthing/lib/protocol"
-)
-
-type mockedConfig struct {
-	gui config.GUIConfiguration
-}
-
-func (c *mockedConfig) GUI() config.GUIConfiguration {
-	return c.gui
-}
-
-func (c *mockedConfig) ListenAddresses() []string {
-	return nil
-}
-
-func (c *mockedConfig) Raw() config.Configuration {
-	return config.Configuration{}
-}
-
-func (c *mockedConfig) Options() config.OptionsConfiguration {
-	return config.OptionsConfiguration{}
-}
-
-func (c *mockedConfig) Replace(cfg config.Configuration) config.CommitResponse {
-	return config.CommitResponse{}
-}
-
-func (c *mockedConfig) Subscribe(cm config.Committer) {}
-
-func (c *mockedConfig) Folders() map[string]config.FolderConfiguration {
-	return nil
-}
-
-func (c *mockedConfig) Devices() map[protocol.DeviceID]config.DeviceConfiguration {
-	return nil
-}
-
-func (c *mockedConfig) Save() error {
-	return nil
-}

cmd/syncthing/mocked_connections_test.go

@@ -1,13 +0,0 @@
-// Copyright (C) 2016 The Syncthing Authors.
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this file,
-// You can obtain one at http://mozilla.org/MPL/2.0/.
-
-package main
-
-type mockedConnections struct{}
-
-func (m *mockedConnections) Status() map[string]interface{} {
-	return nil
-}

cmd/syncthing/mocked_discovery_test.go

@@ -1,52 +0,0 @@
-// Copyright (C) 2016 The Syncthing Authors.
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this file,
-// You can obtain one at http://mozilla.org/MPL/2.0/.
-
-package main
-
-import (
-	"time"
-
-	"github.com/syncthing/syncthing/lib/discover"
-	"github.com/syncthing/syncthing/lib/protocol"
-)
-
-type mockedCachingMux struct{}
-
-// from suture.Service
-
-func (m *mockedCachingMux) Serve() {
-	select {}
-}
-
-func (m *mockedCachingMux) Stop() {
-}
-
-// from events.Finder
-
-func (m *mockedCachingMux) Lookup(deviceID protocol.DeviceID) (direct []string, err error) {
-	return nil, nil
-}
-
-func (m *mockedCachingMux) Error() error {
-	return nil
-}
-
-func (m *mockedCachingMux) String() string {
-	return "mockedCachingMux"
-}
-
-func (m *mockedCachingMux) Cache() map[protocol.DeviceID]discover.CacheEntry {
-	return nil
-}
-
-// from events.CachingMux
-
-func (m *mockedCachingMux) Add(finder discover.Finder, cacheTime, negCacheTime time.Duration, priority int) {
-}
-
-func (m *mockedCachingMux) ChildErrors() map[string]error {
-	return nil
-}

cmd/syncthing/mocked_events_test.go

@@ -1,15 +0,0 @@
-// Copyright (C) 2016 The Syncthing Authors.
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this file,
-// You can obtain one at http://mozilla.org/MPL/2.0/.
-
-package main
-
-import "github.com/syncthing/syncthing/lib/events"
-
-type mockedEventSub struct{}
-
-func (s *mockedEventSub) Since(id int, into []events.Event) []events.Event {
-	select {}
-}

cmd/syncthing/mocked_logger_test.go

@@ -1,26 +0,0 @@
-// Copyright (C) 2016 The Syncthing Authors.
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this file,
-// You can obtain one at http://mozilla.org/MPL/2.0/.
-
-package main
-
-import (
-	"time"
-
-	"github.com/syncthing/syncthing/lib/logger"
-)
-
-type mockedLoggerRecorder struct{}
-
-func (r *mockedLoggerRecorder) Since(t time.Time) []logger.Line {
-	return []logger.Line{
-		{
-			When:    time.Now(),
-			Message: "Test message",
-		},
-	}
-}
-
-func (r *mockedLoggerRecorder) Clear() {}

cmd/syncthing/mocked_model_test.go

@@ -1,116 +0,0 @@
-// Copyright (C) 2016 The Syncthing Authors.
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this file,
-// You can obtain one at http://mozilla.org/MPL/2.0/.
-
-package main
-
-import (
-	"time"
-
-	"github.com/syncthing/syncthing/lib/db"
-	"github.com/syncthing/syncthing/lib/model"
-	"github.com/syncthing/syncthing/lib/protocol"
-	"github.com/syncthing/syncthing/lib/stats"
-)
-
-type mockedModel struct{}
-
-func (m *mockedModel) GlobalDirectoryTree(folder, prefix string, levels int, dirsonly bool) map[string]interface{} {
-	return nil
-}
-
-func (m *mockedModel) Completion(device protocol.DeviceID, folder string) float64 {
-	return 0
-}
-
-func (m *mockedModel) Override(folder string) {}
-
-func (m *mockedModel) NeedFolderFiles(folder string, page, perpage int) ([]db.FileInfoTruncated, []db.FileInfoTruncated, []db.FileInfoTruncated, int) {
-	return nil, nil, nil, 0
-}
-
-func (m *mockedModel) NeedSize(folder string) (nfiles int, bytes int64) {
-	return 0, 0
-}
-
-func (m *mockedModel) ConnectionStats() map[string]interface{} {
-	return nil
-}
-
-func (m *mockedModel) DeviceStatistics() map[string]stats.DeviceStatistics {
-	return nil
-}
-
-func (m *mockedModel) FolderStatistics() map[string]stats.FolderStatistics {
-	return nil
-}
-
-func (m *mockedModel) CurrentFolderFile(folder string, file string) (protocol.FileInfo, bool) {
-	return protocol.FileInfo{}, false
-}
-
-func (m *mockedModel) CurrentGlobalFile(folder string, file string) (protocol.FileInfo, bool) {
-	return protocol.FileInfo{}, false
-}
-
-func (m *mockedModel) ResetFolder(folder string) {
-}
-
-func (m *mockedModel) Availability(folder, file string, version protocol.Vector, block protocol.BlockInfo) []model.Availability {
-	return nil
-}
-
-func (m *mockedModel) GetIgnores(folder string) ([]string, []string, error) {
-	return nil, nil, nil
-}
-
-func (m *mockedModel) SetIgnores(folder string, content []string) error {
-	return nil
-}
-
-func (m *mockedModel) PauseDevice(device protocol.DeviceID) {
-}
-
-func (m *mockedModel) ResumeDevice(device protocol.DeviceID) {}
-
-func (m *mockedModel) DelayScan(folder string, next time.Duration) {}
-
-func (m *mockedModel) ScanFolder(folder string) error {
-	return nil
-}
-
-func (m *mockedModel) ScanFolders() map[string]error {
-	return nil
-}
-
-func (m *mockedModel) ScanFolderSubs(folder string, subs []string) error {
-	return nil
-}
-
-func (m *mockedModel) BringToFront(folder, file string) {}
-
-func (m *mockedModel) ConnectedTo(deviceID protocol.DeviceID) bool {
-	return false
-}
-
-func (m *mockedModel) GlobalSize(folder string) (nfiles, deleted int, bytes int64) {
-	return 0, 0, 0
-}
-
-func (m *mockedModel) LocalSize(folder string) (nfiles, deleted int, bytes int64) {
-	return 0, 0, 0
-}
-
-func (m *mockedModel) CurrentLocalVersion(folder string) (int64, bool) {
-	return 0, false
-}
-
-func (m *mockedModel) RemoteLocalVersion(folder string) (int64, bool) {
-	return 0, false
-}
-
-func (m *mockedModel) State(folder string) (string, time.Time, error) {
-	return "", time.Time{}, nil
-}

cmd/syncthing/monitor.go

@@ -1,380 +0,0 @@
-// Copyright (C) 2014 The Syncthing Authors.
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this file,
-// You can obtain one at http://mozilla.org/MPL/2.0/.
-
-package main
-
-import (
-	"bufio"
-	"io"
-	"os"
-	"os/exec"
-	"os/signal"
-	"runtime"
-	"strings"
-	"syscall"
-	"time"
-
-	"github.com/syncthing/syncthing/lib/osutil"
-	"github.com/syncthing/syncthing/lib/sync"
-)
-
-var (
-	stdoutFirstLines []string // The first 10 lines of stdout
-	stdoutLastLines  []string // The last 50 lines of stdout
-	stdoutMut        = sync.NewMutex()
-)
-
-const (
-	countRestarts         = 4
-	loopThreshold         = 60 * time.Second
-	logFileAutoCloseDelay = 5 * time.Second
-	logFileMaxOpenTime    = time.Minute
-)
-
-func monitorMain(runtimeOptions RuntimeOptions) {
-	os.Setenv("STNORESTART", "yes")
-	os.Setenv("STMONITORED", "yes")
-	l.SetPrefix("[monitor] ")
-
-	var dst io.Writer = os.Stdout
-
-	logFile := runtimeOptions.logFile
-	if logFile != "-" {
-		var fileDst io.Writer = newAutoclosedFile(logFile, logFileAutoCloseDelay, logFileMaxOpenTime)
-
-		if runtime.GOOS == "windows" {
-			// Translate line breaks to Windows standard
-			fileDst = osutil.ReplacingWriter{
-				Writer: fileDst,
-				From:   '\n',
-				To:     []byte{'\r', '\n'},
-			}
-		}
-
-		// Log to both stdout and file.
-		dst = io.MultiWriter(dst, fileDst)
-
-		l.Infof(`Log output saved to file "%s"`, logFile)
-	}
-
-	args := os.Args
-	var restarts [countRestarts]time.Time
-
-	stopSign := make(chan os.Signal, 1)
-	sigTerm := syscall.Signal(15)
-	signal.Notify(stopSign, os.Interrupt, sigTerm)
-	restartSign := make(chan os.Signal, 1)
-	sigHup := syscall.Signal(1)
-	signal.Notify(restartSign, sigHup)
-
-	for {
-		if t := time.Since(restarts[0]); t < loopThreshold {
-			l.Warnf("%d restarts in %v; not retrying further", countRestarts, t)
-			os.Exit(exitError)
-		}
-
-		copy(restarts[0:], restarts[1:])
-		restarts[len(restarts)-1] = time.Now()
-
-		cmd := exec.Command(args[0], args[1:]...)
-
-		stderr, err := cmd.StderrPipe()
-		if err != nil {
-			l.Fatalln("stderr:", err)
-		}
-
-		stdout, err := cmd.StdoutPipe()
-		if err != nil {
-			l.Fatalln("stdout:", err)
-		}
-
-		l.Infoln("Starting syncthing")
-		err = cmd.Start()
-		if err != nil {
-			l.Fatalln(err)
-		}
-
-		// Let the next child process know that this is not the first time
-		// it's starting up.
-		os.Setenv("STRESTART", "yes")
-
-		stdoutMut.Lock()
-		stdoutFirstLines = make([]string, 0, 10)
-		stdoutLastLines = make([]string, 0, 50)
-		stdoutMut.Unlock()
-
-		wg := sync.NewWaitGroup()
-
-		wg.Add(1)
-		go func() {
-			copyStderr(stderr, dst)
-			wg.Done()
-		}()
-
-		wg.Add(1)
-		go func() {
-			copyStdout(stdout, dst)
-			wg.Done()
-		}()
-
-		exit := make(chan error)
-
-		go func() {
-			wg.Wait()
-			exit <- cmd.Wait()
-		}()
-
-		select {
-		case s := <-stopSign:
-			l.Infof("Signal %d received; exiting", s)
-			cmd.Process.Kill()
-			<-exit
-			return
-
-		case s := <-restartSign:
-			l.Infof("Signal %d received; restarting", s)
-			cmd.Process.Signal(sigHup)
-			err = <-exit
-
-		case err = <-exit:
-			if err == nil {
-				// Successful exit indicates an intentional shutdown
-				return
-			} else if exiterr, ok := err.(*exec.ExitError); ok {
-				if status, ok := exiterr.Sys().(syscall.WaitStatus); ok {
-					switch status.ExitStatus() {
-					case exitUpgrading:
-						// Restart the monitor process to release the .old
-						// binary as part of the upgrade process.
-						l.Infoln("Restarting monitor...")
-						os.Setenv("STNORESTART", "")
-						if err = restartMonitor(args); err != nil {
-							l.Warnln("Restart:", err)
-						}
-						return
-					}
-				}
-			}
-		}
-
-		l.Infoln("Syncthing exited:", err)
-		time.Sleep(1 * time.Second)
-	}
-}
-
-func copyStderr(stderr io.Reader, dst io.Writer) {
-	br := bufio.NewReader(stderr)
-
-	var panicFd *os.File
-	for {
-		line, err := br.ReadString('\n')
-		if err != nil {
-			return
-		}
-
-		if panicFd == nil {
-			dst.Write([]byte(line))
-
-			if strings.HasPrefix(line, "panic:") || strings.HasPrefix(line, "fatal error:") {
-				panicFd, err = os.Create(timestampedLoc(locPanicLog))
-				if err != nil {
-					l.Warnln("Create panic log:", err)
-					continue
-				}
-
-				l.Warnf("Panic detected, writing to \"%s\"", panicFd.Name())
-				l.Warnln("Please check for existing issues with similar panic message at https://github.com/syncthing/syncthing/issues/")
-				l.Warnln("If no issue with similar panic message exists, please create a new issue with the panic log attached")
-
-				stdoutMut.Lock()
-				for _, line := range stdoutFirstLines {
-					panicFd.WriteString(line)
-				}
-				panicFd.WriteString("...\n")
-				for _, line := range stdoutLastLines {
-					panicFd.WriteString(line)
-				}
-				stdoutMut.Unlock()
-			}
-
-			panicFd.WriteString("Panic at " + time.Now().Format(time.RFC3339) + "\n")
-		}
-
-		if panicFd != nil {
-			panicFd.WriteString(line)
-		}
-	}
-}
-
-func copyStdout(stdout io.Reader, dst io.Writer) {
-	br := bufio.NewReader(stdout)
-	for {
-		line, err := br.ReadString('\n')
-		if err != nil {
-			return
-		}
-
-		stdoutMut.Lock()
-		if len(stdoutFirstLines) < cap(stdoutFirstLines) {
-			stdoutFirstLines = append(stdoutFirstLines, line)
-		} else {
-			if l := len(stdoutLastLines); l == cap(stdoutLastLines) {
-				stdoutLastLines = stdoutLastLines[:l-1]
-			}
-			stdoutLastLines = append(stdoutLastLines, line)
-		}
-		stdoutMut.Unlock()
-
-		dst.Write([]byte(line))
-	}
-}
-
-func restartMonitor(args []string) error {
-	if runtime.GOOS != "windows" {
-		// syscall.Exec is the cleanest way to restart on Unixes as it
-		// replaces the current process with the new one, keeping the pid and
-		// controlling terminal and so on
-		return restartMonitorUnix(args)
-	}
-
-	// but it isn't supported on Windows, so there we start a normal
-	// exec.Command and return.
-	return restartMonitorWindows(args)
-}
-
-func restartMonitorUnix(args []string) error {
-	if !strings.ContainsRune(args[0], os.PathSeparator) {
-		// The path to the binary doesn't contain a slash, so it should be
-		// found in $PATH.
-		binary, err := exec.LookPath(args[0])
-		if err != nil {
-			return err
-		}
-		args[0] = binary
-	}
-
-	return syscall.Exec(args[0], args, os.Environ())
-}
-
-func restartMonitorWindows(args []string) error {
-	cmd := exec.Command(args[0], args[1:]...)
-	// Retain the standard streams
-	cmd.Stderr = os.Stderr
-	cmd.Stdout = os.Stdout
-	cmd.Stdin = os.Stdin
-	return cmd.Start()
-}
-
-// An autoclosedFile is an io.WriteCloser that opens itself for appending on
-// Write() and closes itself after an interval of no writes (closeDelay) or
-// when the file has been open for too long (maxOpenTime). A call to Write()
-// will return any error that happens on the resulting Open() call too. Errors
-// on automatic Close() calls are silently swallowed...
-type autoclosedFile struct {
-	name        string        // path to write to
-	closeDelay  time.Duration // close after this long inactivity
-	maxOpenTime time.Duration // or this long after opening
-
-	fd         io.WriteCloser // underlying WriteCloser
-	opened     time.Time      // timestamp when the file was last opened
-	closed     chan struct{}  // closed on Close(), stops the closerLoop
-	closeTimer *time.Timer    // fires closeDelay after a write
-
-	mut sync.Mutex
-}
-
-func newAutoclosedFile(name string, closeDelay, maxOpenTime time.Duration) *autoclosedFile {
-	f := &autoclosedFile{
-		name:        name,
-		closeDelay:  closeDelay,
-		maxOpenTime: maxOpenTime,
-		mut:         sync.NewMutex(),
-		closed:      make(chan struct{}),
-		closeTimer:  time.NewTimer(time.Minute),
-	}
-	go f.closerLoop()
-	return f
-}
-
-func (f *autoclosedFile) Write(bs []byte) (int, error) {
-	f.mut.Lock()
-	defer f.mut.Unlock()
-
-	// Make sure the file is open for appending
-	if err := f.ensureOpen(); err != nil {
-		return 0, err
-	}
-
-	// If we haven't run into the maxOpenTime, postpone close for another
-	// closeDelay
-	if time.Since(f.opened) < f.maxOpenTime {
-		f.closeTimer.Reset(f.closeDelay)
-	}
-
-	return f.fd.Write(bs)
-}
-
-func (f *autoclosedFile) Close() error {
-	f.mut.Lock()
-	defer f.mut.Unlock()
-
-	// Stop the timer and closerLoop() routine
-	f.closeTimer.Stop()
-	close(f.closed)
-
-	// Close the file, if it's open
-	if f.fd != nil {
-		return f.fd.Close()
-	}
-
-	return nil
-}
-
-// Must be called with f.mut held!
-func (f *autoclosedFile) ensureOpen() error {
-	if f.fd != nil {
-		// File is already open
-		return nil
-	}
-
-	// We open the file for write only, and create it if it doesn't exist.
-	flags := os.O_WRONLY | os.O_CREATE
-	if f.opened.IsZero() {
-		// This is the first time we are opening the file. We should truncate
-		// it to better emulate an os.Create() call.
-		flags |= os.O_TRUNC
-	} else {
-		// The file was already opened once, so we should append to it.
-		flags |= os.O_APPEND
-	}
-
-	fd, err := os.OpenFile(f.name, flags, 0644)
-	if err != nil {
-		return err
-	}
-
-	f.fd = fd
-	f.opened = time.Now()
-	return nil
-}
-
-func (f *autoclosedFile) closerLoop() {
-	for {
-		select {
-		case <-f.closeTimer.C:
-			// Close the file when the timer expires.
-			f.mut.Lock()
-			if f.fd != nil {
-				f.fd.Close() // errors, schmerrors
-				f.fd = nil
-			}
-			f.mut.Unlock()
-
-		case <-f.closed:
-			return
-		}
-	}
-}