First set of code review patches

Merge branch 'master' of git.zx2c4.com:wireguard-go

Create /var/run/wireguard if non-existent

Makefile: cleanup a bit and add cloc

Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>

Remove stale unix socket

Close UAPI socket before exit

Verify source address

Fixed shadowing bug

Merge branch 'master' of git.zx2c4.com:wireguard-go

Improved timer code

Close UDP connection when listen port changes

Merge branch 'darwin'

Fixed UAPI deadlock

Moved remaining platform dependent UAPI code

Reviewed and added OSX patch

The patch was provided by:
Naveen Nathan <naveen@lastninja.net>

The following modifications to the patch was made:

- Added copyright notice
- Fixed file descriptor leak in .MTU() method
- Migrated to the new(er) golang.org/x/sys/unix package
- Removed non-functioning Daemonize method

Added last_handshake_time fields to UAPI

Fixed file descriptor leak on linux

Fixed deadlock in index.go

Added padding

Added plaintext padding and fixed default interface MTU

Conforming to the cross-platform UX

The implementation now terminates when the unix socket is deleted.
Currently we are unable to use fsnotify (on linux),
since it does not notify on the deletion of open files.

The implementation can now daemonize (on linux)
or be kept in the foreground by providing the necessary flag.

Improved throughput

- Improved performance by adding the message buffers to a sync.Pool.
- Fixed issue with computing "next" key-pair upon
  receiving a response message.

Endpoint discovery from handshake initiation

Terminate on interface deletion

Program now terminates when the interface is removed
Increases the number of os threads (relevant for Go <1.5, not tested)
More consistent commenting
Improved logging (additional peer information)

Restructured MAC/cookie calculation

Added copy-right headers accidentally removed

Fixed MTU method for linux TUN interface

Updated the TUN interface
Added the "MTU" method for the linux implementation of the TUN interface

Added ratelimiting of handshake messages

Fixed incomming initiation bug

Added replay protection

Improved timer state machine

Added source verification

Fixed cookie reply processing bug

Fixed broken test

Initial working full exchange

The implementation is now capable of connecting to another
wireguard instance, complete a handshake and exchange transport
messages.

Fixed transport header problem

Handshake negotiation functioning

Removed exponential backoff

Completed initial version of outbound flow

Completed get/set configuration

For debugging of "outbound flow"
Mostly, a few things still missing

Work on UAPI

Cross-platform API (get operation)
Handshake initiation creation process
Outbound packet flow
Fixes from code-review

Implemented MAC1/2 calculation

Begin implementation of outbound work queue

Begin work on outbound packet flow

Completed noise handshake

Restructuring of noise impl.

Fixed missing type

Beginning work noise handshake

Beginning work on TUN interface

And outbound routing

I am not entirely convinced the use of net.IP is a good idea,
since the internal representation of net.IP is a byte slice
and all constructor functions in "net" return 16 byte slices
(padded for IPv4), while the use in this project uses 4 byte slices.
Which may be confusing.

Trie random test

Test trie against naive implementation of prefix routing.

Added random test for trie

Inital implementation of trie

Merge branch 'master' of git.zx2c4.com:wireguard-go

Beginning work on UAPI and routing table

README: rust -> go

Initial scaffolding