From 42f28ab8e374137fe3f5d25424489d879d4724f8 Mon Sep 17 00:00:00 2001
From: Christopher Speller <crspeller@gmail.com>
Date: Wed, 21 Jun 2017 19:06:17 -0700
Subject: Updating server dependancies (#6712)

---
 vendor/golang.org/x/net/ipv6/control_unix.go | 118 +++------------------------
 1 file changed, 10 insertions(+), 108 deletions(-)

(limited to 'vendor/golang.org/x/net/ipv6/control_unix.go')

diff --git a/vendor/golang.org/x/net/ipv6/control_unix.go b/vendor/golang.org/x/net/ipv6/control_unix.go
index 7bd421053..66515060a 100644
--- a/vendor/golang.org/x/net/ipv6/control_unix.go
+++ b/vendor/golang.org/x/net/ipv6/control_unix.go
@@ -6,18 +6,13 @@
 
 package ipv6
 
-import (
-	"os"
-	"syscall"
+import "golang.org/x/net/internal/socket"
 
-	"golang.org/x/net/internal/iana"
-)
-
-func setControlMessage(s uintptr, opt *rawOpt, cf ControlFlags, on bool) error {
+func setControlMessage(c *socket.Conn, opt *rawOpt, cf ControlFlags, on bool) error {
 	opt.Lock()
 	defer opt.Unlock()
-	if cf&FlagTrafficClass != 0 && sockOpts[ssoReceiveTrafficClass].name > 0 {
-		if err := setInt(s, &sockOpts[ssoReceiveTrafficClass], boolint(on)); err != nil {
+	if so, ok := sockOpts[ssoReceiveTrafficClass]; ok && cf&FlagTrafficClass != 0 {
+		if err := so.SetInt(c, boolint(on)); err != nil {
 			return err
 		}
 		if on {
@@ -26,8 +21,8 @@ func setControlMessage(s uintptr, opt *rawOpt, cf ControlFlags, on bool) error {
 			opt.clear(FlagTrafficClass)
 		}
 	}
-	if cf&FlagHopLimit != 0 && sockOpts[ssoReceiveHopLimit].name > 0 {
-		if err := setInt(s, &sockOpts[ssoReceiveHopLimit], boolint(on)); err != nil {
+	if so, ok := sockOpts[ssoReceiveHopLimit]; ok && cf&FlagHopLimit != 0 {
+		if err := so.SetInt(c, boolint(on)); err != nil {
 			return err
 		}
 		if on {
@@ -36,8 +31,8 @@ func setControlMessage(s uintptr, opt *rawOpt, cf ControlFlags, on bool) error {
 			opt.clear(FlagHopLimit)
 		}
 	}
-	if cf&flagPacketInfo != 0 && sockOpts[ssoReceivePacketInfo].name > 0 {
-		if err := setInt(s, &sockOpts[ssoReceivePacketInfo], boolint(on)); err != nil {
+	if so, ok := sockOpts[ssoReceivePacketInfo]; ok && cf&flagPacketInfo != 0 {
+		if err := so.SetInt(c, boolint(on)); err != nil {
 			return err
 		}
 		if on {
@@ -46,8 +41,8 @@ func setControlMessage(s uintptr, opt *rawOpt, cf ControlFlags, on bool) error {
 			opt.clear(cf & flagPacketInfo)
 		}
 	}
-	if cf&FlagPathMTU != 0 && sockOpts[ssoReceivePathMTU].name > 0 {
-		if err := setInt(s, &sockOpts[ssoReceivePathMTU], boolint(on)); err != nil {
+	if so, ok := sockOpts[ssoReceivePathMTU]; ok && cf&FlagPathMTU != 0 {
+		if err := so.SetInt(c, boolint(on)); err != nil {
 			return err
 		}
 		if on {
@@ -58,96 +53,3 @@ func setControlMessage(s uintptr, opt *rawOpt, cf ControlFlags, on bool) error {
 	}
 	return nil
 }
-
-func newControlMessage(opt *rawOpt) (oob []byte) {
-	opt.RLock()
-	var l int
-	if opt.isset(FlagTrafficClass) && ctlOpts[ctlTrafficClass].name > 0 {
-		l += syscall.CmsgSpace(ctlOpts[ctlTrafficClass].length)
-	}
-	if opt.isset(FlagHopLimit) && ctlOpts[ctlHopLimit].name > 0 {
-		l += syscall.CmsgSpace(ctlOpts[ctlHopLimit].length)
-	}
-	if opt.isset(flagPacketInfo) && ctlOpts[ctlPacketInfo].name > 0 {
-		l += syscall.CmsgSpace(ctlOpts[ctlPacketInfo].length)
-	}
-	if opt.isset(FlagPathMTU) && ctlOpts[ctlPathMTU].name > 0 {
-		l += syscall.CmsgSpace(ctlOpts[ctlPathMTU].length)
-	}
-	if l > 0 {
-		oob = make([]byte, l)
-	}
-	opt.RUnlock()
-	return
-}
-
-func parseControlMessage(b []byte) (*ControlMessage, error) {
-	if len(b) == 0 {
-		return nil, nil
-	}
-	cmsgs, err := syscall.ParseSocketControlMessage(b)
-	if err != nil {
-		return nil, os.NewSyscallError("parse socket control message", err)
-	}
-	cm := &ControlMessage{}
-	for _, m := range cmsgs {
-		if m.Header.Level != iana.ProtocolIPv6 {
-			continue
-		}
-		switch int(m.Header.Type) {
-		case ctlOpts[ctlTrafficClass].name:
-			ctlOpts[ctlTrafficClass].parse(cm, m.Data[:])
-		case ctlOpts[ctlHopLimit].name:
-			ctlOpts[ctlHopLimit].parse(cm, m.Data[:])
-		case ctlOpts[ctlPacketInfo].name:
-			ctlOpts[ctlPacketInfo].parse(cm, m.Data[:])
-		case ctlOpts[ctlPathMTU].name:
-			ctlOpts[ctlPathMTU].parse(cm, m.Data[:])
-		}
-	}
-	return cm, nil
-}
-
-func marshalControlMessage(cm *ControlMessage) (oob []byte) {
-	if cm == nil {
-		return
-	}
-	var l int
-	tclass := false
-	if ctlOpts[ctlTrafficClass].name > 0 && cm.TrafficClass > 0 {
-		tclass = true
-		l += syscall.CmsgSpace(ctlOpts[ctlTrafficClass].length)
-	}
-	hoplimit := false
-	if ctlOpts[ctlHopLimit].name > 0 && cm.HopLimit > 0 {
-		hoplimit = true
-		l += syscall.CmsgSpace(ctlOpts[ctlHopLimit].length)
-	}
-	pktinfo := false
-	if ctlOpts[ctlPacketInfo].name > 0 && (cm.Src.To16() != nil && cm.Src.To4() == nil || cm.IfIndex > 0) {
-		pktinfo = true
-		l += syscall.CmsgSpace(ctlOpts[ctlPacketInfo].length)
-	}
-	nexthop := false
-	if ctlOpts[ctlNextHop].name > 0 && cm.NextHop.To16() != nil && cm.NextHop.To4() == nil {
-		nexthop = true
-		l += syscall.CmsgSpace(ctlOpts[ctlNextHop].length)
-	}
-	if l > 0 {
-		oob = make([]byte, l)
-		b := oob
-		if tclass {
-			b = ctlOpts[ctlTrafficClass].marshal(b, cm)
-		}
-		if hoplimit {
-			b = ctlOpts[ctlHopLimit].marshal(b, cm)
-		}
-		if pktinfo {
-			b = ctlOpts[ctlPacketInfo].marshal(b, cm)
-		}
-		if nexthop {
-			b = ctlOpts[ctlNextHop].marshal(b, cm)
-		}
-	}
-	return
-}
-- 
cgit v1.2.3-1-g7c22