Update vendoring (#722)

* Update vendor github.com/beevik/ntp@v0.2.0

* Update vendor github.com/mdlayher/netlink/...

* Update vendor github.com/mdlayher/wifi/...

Adds vendor github.com/mdlayher/genetlink

* Update vendor github.com/prometheus/common/...

* Update vendor github.com/prometheus/procfs/...

* Update vendor golang.org/x/sys/unix

* Update vendor golang.org/x/sys/windows

vendor/github.com/beevik/ntp/LICENSE

@@ -1,4 +1,4 @@
-Copyright 2015 Brett Vickers. All rights reserved.
+Copyright 2015-2017 Brett Vickers. All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions

vendor/github.com/beevik/ntp/README.md

@@ -1,25 +1,71 @@
-[![Build Status](https://travis-ci.org/beevik/ntp.svg?branch=master)](https://travis-ci.org/beevik/ntp)
-[![GoDoc](https://godoc.org/github.com/beevik/ntp?status.svg)](https://godoc.org/github.com/beevik/ntp)
-
-ntp
-===
-
-The ntp package is an implementation of a Simple NTP (SNTP) client based on
-[RFC5905](https://tools.ietf.org/html/rfc5905). It allows you to connect to
-a remote NTP server and request the current time.
-
-If all you care about is the current time according to a known remote NTP
-server, simply use the `Time` function:
-```go
-time, err := ntp.Time("0.beevik-ntp.pool.ntp.org")
-```
-
-If you want the time as well as additional metadata about the time, use the
-`Query` function instead:
-```go
-response, err := ntp.Query("0.beevik-ntp.pool.ntp.org")
-```
-
-To use the NTP pool in your application, please request your own
-[vendor zone](http://www.pool.ntp.org/en/vendors.html).  Avoid using 
-the `[number].pool.ntp.org` zone names in your applications.
+[![Build Status](https://travis-ci.org/beevik/ntp.svg?branch=master)](https://travis-ci.org/beevik/ntp)
+[![GoDoc](https://godoc.org/github.com/beevik/ntp?status.svg)](https://godoc.org/github.com/beevik/ntp)
+
+ntp
+===
+
+The ntp package is an implementation of a Simple NTP (SNTP) client based on
+[RFC5905](https://tools.ietf.org/html/rfc5905). It allows you to connect to
+a remote NTP server and request information about the current time.
+
+
+## Querying the current time
+
+If all you care about is the current time according to a remote NTP server,
+simply use the `Time` function:
+```go
+time, err := ntp.Time("0.beevik-ntp.pool.ntp.org")
+```
+
+
+## Querying time metadata
+
+To obtain the current time as well as some additional metadata about the time,
+use the `Query` function:
+```go
+response, err := ntp.Query("0.beevik-ntp.pool.ntp.org")
+time := time.Now().Add(response.ClockOffset)
+```
+
+Alternatively, use the `QueryWithOptions` function if you want to change the
+default behavior used by the `Query` function:
+```go
+options := ntp.QueryOptions{ Timeout: 30*time.Second, TTL: 5 }
+response, err := ntp.QueryWithOptions("0.beevik-ntp.pool.ntp.org", options)
+time := time.Now().Add(response.ClockOffset)
+```
+
+The `Response` structure returned by `Query` includes the following
+information:
+* `Time`: The time the server transmitted its response, according to its own clock.
+* `ClockOffset`: The estimated offset of the local system clock relative to the server's clock. For a more accurate time reading, you may add this offset to any subsequent system clock reading.
+* `RTT`: An estimate of the round-trip-time delay between the client and the server.
+* `Precision`: The precision of the server's clock reading.
+* `Stratum`: The server's stratum, which indicates the number of hops from the server to the reference clock. A stratum 1 server is directly attached to the reference clock. If the stratum is zero, the server has responded with the "kiss of death".
+* `ReferenceID`: A unique identifier for the consulted reference clock.
+* `ReferenceTime`: The time at which the server last updated its local clock setting.
+* `RootDelay`: The server's aggregate round-trip-time delay to the stratum 1 server.
+* `RootDispersion`: The server's estimated maximum measurement error relative to the reference clock.
+* `RootDistance`: An estimate of the root synchronization distance between the client and the stratum 1 server.
+* `Leap`: The leap second indicator, indicating whether a second should be added to or removed from the current month's last minute.
+* `MinError`: A lower bound on the clock error between the client and the server.
+* `KissCode`: A 4-character string describing the reason for a "kiss of death" response (stratum=0).
+* `Poll`: The maximum polling interval between successive messages to the server.
+
+The `Response` structure's `Validate` method performs additional sanity checks
+to determine whether the response is suitable for time synchronization
+purposes.
+```go
+err := response.Validate()
+if err == nil {
+    // response data is suitable for synchronization purposes
+}
+```
+
+## Using the NTP pool
+
+The NTP pool is a shared resource used by people all over the world.
+To prevent it from becoming overloaded, please avoid querying the standard
+`pool.ntp.org` zone names in your applications.  Instead, consider requesting
+your own [vendor zone](http://www.pool.ntp.org/en/vendors.html) or [joining
+the pool](http://www.pool.ntp.org/join.html).

vendor/github.com/beevik/ntp/RELEASE_NOTES.md

@@ -1,3 +1,13 @@
+Release v0.2.0
+==============
+
+There are no breaking changes or further deprecations in this release.
+
+**Changes**
+
+* Added `KissCode` to the `Response` structure.
+
+
 Release v0.1.1
 ==============
 

vendor/github.com/beevik/ntp/ntp.go

@@ -14,6 +14,7 @@ import (
 	"crypto/rand"
 	"encoding/binary"
 	"errors"
+	"fmt"
 	"net"
 	"time"
 
@@ -223,6 +224,11 @@ type Response struct {
 	// minimum error may be useful.
 	MinError time.Duration
 
+	// KissCode is a 4-character string describing the reason for a
+	// "kiss of death" response (stratum = 0). For a list of standard kiss
+	// codes, see https://tools.ietf.org/html/rfc5905#section-7.4.
+	KissCode string
+
 	// Poll is the maximum interval between successive NTP polling messages.
 	// It is not relevant for simple NTP clients like this one.
 	Poll time.Duration
@@ -233,7 +239,7 @@ type Response struct {
 func (r *Response) Validate() error {
 	// Handle invalid stratum values.
 	if r.Stratum == 0 {
-		return errors.New("kiss of death received")
+		return fmt.Errorf("kiss of death received: %s", r.KissCode)
 	}
 	if r.Stratum >= maxStratum {
 		return errors.New("invalid stratum in response")
@@ -379,16 +385,16 @@ func getTime(host string, opt QueryOptions) (*msg, ntpTime, error) {
 	// To ensure privacy and prevent spoofing, try to use a random 64-bit
 	// value for the TransmitTime. If crypto/rand couldn't generate a
 	// random value, fall back to using the system clock. Keep track of
-	// when the messsage was actually sent.
-	r := make([]byte, 8)
-	_, err = rand.Read(r)
-	var sendTime time.Time
+	// when the messsage was actually transmitted.
+	bits := make([]byte, 8)
+	_, err = rand.Read(bits)
+	var xmitTime time.Time
 	if err == nil {
-		xmitMsg.TransmitTime = ntpTime(binary.BigEndian.Uint64(r))
-		sendTime = time.Now()
+		xmitMsg.TransmitTime = ntpTime(binary.BigEndian.Uint64(bits))
+		xmitTime = time.Now()
 	} else {
-		sendTime = time.Now()
-		xmitMsg.TransmitTime = toNtpTime(sendTime)
+		xmitTime = time.Now()
+		xmitMsg.TransmitTime = toNtpTime(xmitTime)
 	}
 
 	// Transmit the query.
@@ -404,15 +410,16 @@ func getTime(host string, opt QueryOptions) (*msg, ntpTime, error) {
 	}
 
 	// Keep track of the time the response was received.
-	delta := time.Since(sendTime)
+	delta := time.Since(xmitTime)
 	if delta < 0 {
-		// The system clock may have been set backwards since the packet was
-		// transmitted. In go 1.9 and later, time.Since ensures that a
-		// monotonic clock is used, and delta can never be less than zero.
-		// In versions before 1.9, we have to check.
+		// The local system may have had its clock adjusted since it
+		// sent the query. In go 1.9 and later, time.Since ensures
+		// that a monotonic clock is used, so delta can never be less
+		// than zero. In versions before 1.9, a monotonic clock is
+		// not used, so we have to check.
 		return nil, 0, errors.New("client clock ticked backwards")
 	}
-	recvTime := toNtpTime(sendTime.Add(delta))
+	recvTime := toNtpTime(xmitTime.Add(delta))
 
 	// Check for invalid fields.
 	if recvMsg.getMode() != server {
@@ -428,9 +435,9 @@ func getTime(host string, opt QueryOptions) (*msg, ntpTime, error) {
 		return nil, 0, errors.New("server clock ticked backwards")
 	}
 
-	// Correct the received message's origin time using the actual send
-	// time.
-	recvMsg.OriginTime = toNtpTime(sendTime)
+	// Correct the received message's origin time using the actual
+	// transmit time.
+	recvMsg.OriginTime = toNtpTime(xmitTime)
 
 	return recvMsg, recvTime, nil
 }
@@ -456,6 +463,12 @@ func parseTime(m *msg, recvTime ntpTime) *Response {
 	// Calculate values depending on other calculated values
 	r.RootDistance = rootDistance(r.RTT, r.RootDelay, r.RootDispersion)
 
+	// If a kiss of death was received, interpret the reference ID as
+	// a kiss code.
+	if r.Stratum == 0 {
+		r.KissCode = kissCode(r.ReferenceID)
+	}
+
 	return r
 }
 
@@ -533,3 +546,20 @@ func toInterval(t int8) time.Duration {
 		return time.Second
 	}
 }
+
+func kissCode(id uint32) string {
+	isPrintable := func(ch byte) bool { return ch >= 32 && ch <= 126 }
+
+	b := []byte{
+		byte(id >> 24),
+		byte(id >> 16),
+		byte(id >> 8),
+		byte(id),
+	}
+	for _, ch := range b {
+		if !isPrintable(ch) {
+			return ""
+		}
+	}
+	return string(b)
+}