@@ -3,7 +3,7 @@

 # LIBNETWORK_COMMIT is used to build the docker-userland-proxy binary. When

 # updating the binary version, consider updating github.com/docker/libnetwork

 # in vendor.conf accordingly

-: "${LIBNETWORK_COMMIT:=bf2bd42abc0a3734f12b5ec724e571434e42c669}"

+: "${LIBNETWORK_COMMIT:=beab24292cb13d13670985fc860215f9e296bd47}"

 install_proxy() {

 	case "$1" in

@@ -38,7 +38,7 @@ github.com/gofrs/flock                              392e7fae8f1b0bdbd67dad7237d2

 # libnetwork

 # When updating, also update LIBNETWORK_COMMIT in hack/dockerfile/install/proxy.installer accordingly

-github.com/docker/libnetwork                        bf2bd42abc0a3734f12b5ec724e571434e42c669

+github.com/docker/libnetwork                        beab24292cb13d13670985fc860215f9e296bd47

 github.com/docker/go-events                         9461782956ad83b30282bf90e31fa6a70c255ba9

 github.com/armon/go-radix                           e39d623f12e8e41c7b5529e9a9dd67a1e2261f80

 github.com/armon/go-metrics                         eb0af217e5e9747e41dd5303755356b62d28e3ec

@@ -50,8 +50,9 @@ github.com/hashicorp/go-sockaddr                    c7188e74f6acae5a989bdc959aa7

 github.com/hashicorp/go-multierror                  886a7fbe3eb1c874d46f623bfa70af45f425b3d1 # v1.0.0

 github.com/hashicorp/serf                           598c54895cc5a7b1a24a398d635e8c0ea0959870

 github.com/docker/libkv                             458977154600b9f23984d9f4b82e79570b5ae12b

-github.com/vishvananda/netns                        7109fa855b0ff1ebef7fbd2f6aa613e8db7cfbc0

-github.com/vishvananda/netlink                      a2ad57a690f3caf3015351d2d6e1c0b95c349752

+github.com/vishvananda/netns                        0a2b9b5464df8343199164a0321edf3313202f7e

+github.com/vishvananda/netlink                      f049be6f391489d3f374498fe0c8df8449258372 # v1.1.0

+github.com/moby/ipvs                                8f137da6850a975020f4f739c589d293dd3a9d7b # v1.0.0

 # When updating, consider updating TOMLV_COMMIT in hack/dockerfile/install/tomlv.installer accordingly

 github.com/BurntSushi/toml                          3012a1dbe2e4bd1391d42b32f0577cb7bbc7f005 # v0.3.1

@@ -793,7 +793,7 @@ func (n *network) watchMiss(nlSock *nl.NetlinkSocket, nsPath string) {

 		return

 	}

 	for {

-		msgs, err := nlSock.Receive()

+		msgs, _, err := nlSock.Receive()

 		if err != nil {

 			n.Lock()

 			nlFd := nlSock.GetFd()

deleted file mode 100644

@@ -1,178 +0,0 @@

-// +build linux

-

-package ipvs

-

-const (

-	genlCtrlID = 0x10

-)

-

-// GENL control commands

-const (

-	genlCtrlCmdUnspec uint8 = iota

-	genlCtrlCmdNewFamily

-	genlCtrlCmdDelFamily

-	genlCtrlCmdGetFamily

-)

-

-// GENL family attributes

-const (

-	genlCtrlAttrUnspec int = iota

-	genlCtrlAttrFamilyID

-	genlCtrlAttrFamilyName

-)

-

-// IPVS genl commands

-const (

-	ipvsCmdUnspec uint8 = iota

-	ipvsCmdNewService

-	ipvsCmdSetService

-	ipvsCmdDelService

-	ipvsCmdGetService

-	ipvsCmdNewDest

-	ipvsCmdSetDest

-	ipvsCmdDelDest

-	ipvsCmdGetDest

-	ipvsCmdNewDaemon

-	ipvsCmdDelDaemon

-	ipvsCmdGetDaemon

-	ipvsCmdSetConfig

-	ipvsCmdGetConfig

-	ipvsCmdSetInfo

-	ipvsCmdGetInfo

-	ipvsCmdZero

-	ipvsCmdFlush

-)

-

-// Attributes used in the first level of commands

-const (

-	ipvsCmdAttrUnspec int = iota

-	ipvsCmdAttrService

-	ipvsCmdAttrDest

-	ipvsCmdAttrDaemon

-	ipvsCmdAttrTimeoutTCP

-	ipvsCmdAttrTimeoutTCPFin

-	ipvsCmdAttrTimeoutUDP

-)

-

-// Attributes used to describe a service. Used inside nested attribute

-// ipvsCmdAttrService

-const (

-	ipvsSvcAttrUnspec int = iota

-	ipvsSvcAttrAddressFamily

-	ipvsSvcAttrProtocol

-	ipvsSvcAttrAddress

-	ipvsSvcAttrPort

-	ipvsSvcAttrFWMark

-	ipvsSvcAttrSchedName

-	ipvsSvcAttrFlags

-	ipvsSvcAttrTimeout

-	ipvsSvcAttrNetmask

-	ipvsSvcAttrStats

-	ipvsSvcAttrPEName

-)

-

-// Attributes used to describe a destination (real server). Used

-// inside nested attribute ipvsCmdAttrDest.

-const (

-	ipvsDestAttrUnspec int = iota

-	ipvsDestAttrAddress

-	ipvsDestAttrPort

-	ipvsDestAttrForwardingMethod

-	ipvsDestAttrWeight

-	ipvsDestAttrUpperThreshold

-	ipvsDestAttrLowerThreshold

-	ipvsDestAttrActiveConnections

-	ipvsDestAttrInactiveConnections

-	ipvsDestAttrPersistentConnections

-	ipvsDestAttrStats

-	ipvsDestAttrAddressFamily

-)

-

-// IPVS Svc Statistics constancs

-

-const (

-	ipvsSvcStatsUnspec int = iota

-	ipvsSvcStatsConns

-	ipvsSvcStatsPktsIn

-	ipvsSvcStatsPktsOut

-	ipvsSvcStatsBytesIn

-	ipvsSvcStatsBytesOut

-	ipvsSvcStatsCPS

-	ipvsSvcStatsPPSIn

-	ipvsSvcStatsPPSOut

-	ipvsSvcStatsBPSIn

-	ipvsSvcStatsBPSOut

-)

-

-// Destination forwarding methods

-const (

-	// ConnectionFlagFwdmask indicates the mask in the connection

-	// flags which is used by forwarding method bits.

-	ConnectionFlagFwdMask = 0x0007

-

-	// ConnectionFlagMasq is used for masquerade forwarding method.

-	ConnectionFlagMasq = 0x0000

-

-	// ConnectionFlagLocalNode is used for local node forwarding

-	// method.

-	ConnectionFlagLocalNode = 0x0001

-

-	// ConnectionFlagTunnel is used for tunnel mode forwarding

-	// method.

-	ConnectionFlagTunnel = 0x0002

-

-	// ConnectionFlagDirectRoute is used for direct routing

-	// forwarding method.

-	ConnectionFlagDirectRoute = 0x0003

-)

-

-const (

-	// RoundRobin distributes jobs equally amongst the available

-	// real servers.

-	RoundRobin = "rr"

-

-	// LeastConnection assigns more jobs to real servers with

-	// fewer active jobs.

-	LeastConnection = "lc"

-

-	// DestinationHashing assigns jobs to servers through looking

-	// up a statically assigned hash table by their destination IP

-	// addresses.

-	DestinationHashing = "dh"

-

-	// SourceHashing assigns jobs to servers through looking up

-	// a statically assigned hash table by their source IP

-	// addresses.

-	SourceHashing = "sh"

-

-	// WeightedRoundRobin assigns jobs to real servers proportionally

-	// to there real servers' weight. Servers with higher weights

-	// receive new jobs first and get more jobs than servers

-	// with lower weights. Servers with equal weights get

-	// an equal distribution of new jobs

-	WeightedRoundRobin = "wrr"

-

-	// WeightedLeastConnection assigns more jobs to servers

-	// with fewer jobs and relative to the real servers' weight

-	WeightedLeastConnection = "wlc"

-)

-

-const (

-	// ConnFwdMask is a mask for the fwd methods

-	ConnFwdMask = 0x0007

-

-	// ConnFwdMasq denotes forwarding via masquerading/NAT

-	ConnFwdMasq = 0x0000

-

-	// ConnFwdLocalNode denotes forwarding to a local node

-	ConnFwdLocalNode = 0x0001

-

-	// ConnFwdTunnel denotes forwarding via a tunnel

-	ConnFwdTunnel = 0x0002

-

-	// ConnFwdDirectRoute denotes forwarding via direct routing

-	ConnFwdDirectRoute = 0x0003

-

-	// ConnFwdBypass denotes forwarding while bypassing the cache

-	ConnFwdBypass = 0x0004

-)

deleted file mode 100644

@@ -1,206 +0,0 @@

-// +build linux

-

-package ipvs

-

-import (

-	"fmt"

-	"net"

-	"time"

-

-	"github.com/vishvananda/netlink/nl"

-	"github.com/vishvananda/netns"

-	"golang.org/x/sys/unix"

-)

-

-const (

-	netlinkRecvSocketsTimeout = 3 * time.Second

-	netlinkSendSocketTimeout  = 30 * time.Second

-)

-

-// Service defines an IPVS service in its entirety.

-type Service struct {

-	// Virtual service address.

-	Address  net.IP

-	Protocol uint16

-	Port     uint16

-	FWMark   uint32 // Firewall mark of the service.

-

-	// Virtual service options.

-	SchedName     string

-	Flags         uint32

-	Timeout       uint32

-	Netmask       uint32

-	AddressFamily uint16

-	PEName        string

-	Stats         SvcStats

-}

-

-// SvcStats defines an IPVS service statistics

-type SvcStats struct {

-	Connections uint32

-	PacketsIn   uint32

-	PacketsOut  uint32

-	BytesIn     uint64

-	BytesOut    uint64

-	CPS         uint32

-	BPSOut      uint32

-	PPSIn       uint32

-	PPSOut      uint32

-	BPSIn       uint32

-}

-

-// Destination defines an IPVS destination (real server) in its

-// entirety.

-type Destination struct {

-	Address             net.IP

-	Port                uint16

-	Weight              int

-	ConnectionFlags     uint32

-	AddressFamily       uint16

-	UpperThreshold      uint32

-	LowerThreshold      uint32

-	ActiveConnections   int

-	InactiveConnections int

-	Stats               DstStats

-}

-

-// DstStats defines IPVS destination (real server) statistics

-type DstStats SvcStats

-

-// Config defines IPVS timeout configuration

-type Config struct {

-	TimeoutTCP    time.Duration

-	TimeoutTCPFin time.Duration

-	TimeoutUDP    time.Duration

-}

-

-// Handle provides a namespace specific ipvs handle to program ipvs

-// rules.

-type Handle struct {

-	seq  uint32

-	sock *nl.NetlinkSocket

-}

-

-// New provides a new ipvs handle in the namespace pointed to by the

-// passed path. It will return a valid handle or an error in case an

-// error occurred while creating the handle.

-func New(path string) (*Handle, error) {

-	setup()

-

-	n := netns.None()

-	if path != "" {

-		var err error

-		n, err = netns.GetFromPath(path)

-		if err != nil {

-			return nil, err

-		}

-	}

-	defer n.Close()

-

-	sock, err := nl.GetNetlinkSocketAt(n, netns.None(), unix.NETLINK_GENERIC)

-	if err != nil {

-		return nil, err

-	}

-	// Add operation timeout to avoid deadlocks

-	tv := unix.NsecToTimeval(netlinkSendSocketTimeout.Nanoseconds())

-	if err := sock.SetSendTimeout(&tv); err != nil {

-		return nil, err

-	}

-	tv = unix.NsecToTimeval(netlinkRecvSocketsTimeout.Nanoseconds())

-	if err := sock.SetReceiveTimeout(&tv); err != nil {

-		return nil, err

-	}

-

-	return &Handle{sock: sock}, nil

-}

-

-// Close closes the ipvs handle. The handle is invalid after Close

-// returns.

-func (i *Handle) Close() {

-	if i.sock != nil {

-		i.sock.Close()

-	}

-}

-

-// NewService creates a new ipvs service in the passed handle.

-func (i *Handle) NewService(s *Service) error {

-	return i.doCmd(s, nil, ipvsCmdNewService)

-}

-

-// IsServicePresent queries for the ipvs service in the passed handle.

-func (i *Handle) IsServicePresent(s *Service) bool {

-	return nil == i.doCmd(s, nil, ipvsCmdGetService)

-}

-

-// UpdateService updates an already existing service in the passed

-// handle.

-func (i *Handle) UpdateService(s *Service) error {

-	return i.doCmd(s, nil, ipvsCmdSetService)

-}

-

-// DelService deletes an already existing service in the passed

-// handle.

-func (i *Handle) DelService(s *Service) error {

-	return i.doCmd(s, nil, ipvsCmdDelService)

-}

-

-// Flush deletes all existing services in the passed

-// handle.

-func (i *Handle) Flush() error {

-	_, err := i.doCmdWithoutAttr(ipvsCmdFlush)

-	return err

-}

-

-// NewDestination creates a new real server in the passed ipvs

-// service which should already be existing in the passed handle.

-func (i *Handle) NewDestination(s *Service, d *Destination) error {

-	return i.doCmd(s, d, ipvsCmdNewDest)

-}

-

-// UpdateDestination updates an already existing real server in the

-// passed ipvs service in the passed handle.

-func (i *Handle) UpdateDestination(s *Service, d *Destination) error {

-	return i.doCmd(s, d, ipvsCmdSetDest)

-}

-

-// DelDestination deletes an already existing real server in the

-// passed ipvs service in the passed handle.

-func (i *Handle) DelDestination(s *Service, d *Destination) error {

-	return i.doCmd(s, d, ipvsCmdDelDest)

-}

-

-// GetServices returns an array of services configured on the Node

-func (i *Handle) GetServices() ([]*Service, error) {

-	return i.doGetServicesCmd(nil)

-}

-

-// GetDestinations returns an array of Destinations configured for this Service

-func (i *Handle) GetDestinations(s *Service) ([]*Destination, error) {

-	return i.doGetDestinationsCmd(s, nil)

-}

-

-// GetService gets details of a specific IPVS services, useful in updating statisics etc.,

-func (i *Handle) GetService(s *Service) (*Service, error) {

-

-	res, err := i.doGetServicesCmd(s)

-	if err != nil {

-		return nil, err

-	}

-

-	// We are looking for exactly one service otherwise error out

-	if len(res) != 1 {

-		return nil, fmt.Errorf("Expected only one service obtained=%d", len(res))

-	}

-

-	return res[0], nil

-}

-

-// GetConfig returns the current timeout configuration

-func (i *Handle) GetConfig() (*Config, error) {

-	return i.doGetConfigCmd()

-}

-

-// SetConfig set the current timeout configuration. 0: no change

-func (i *Handle) SetConfig(c *Config) error {

-	return i.doSetConfigCmd(c)

-}

deleted file mode 100644

@@ -1,636 +0,0 @@

-// +build linux

-

-package ipvs

-

-import (

-	"bytes"

-	"encoding/binary"

-	"fmt"

-	"net"

-	"os/exec"

-	"strings"

-	"sync"

-	"sync/atomic"

-	"syscall"

-	"time"

-	"unsafe"

-

-	"github.com/sirupsen/logrus"

-	"github.com/vishvananda/netlink/nl"

-	"github.com/vishvananda/netns"

-)

-

-// For Quick Reference IPVS related netlink message is described at the end of this file.

-var (

-	native     = nl.NativeEndian()

-	ipvsFamily int

-	ipvsOnce   sync.Once

-)

-

-type genlMsgHdr struct {

-	cmd      uint8

-	version  uint8

-	reserved uint16

-}

-

-type ipvsFlags struct {

-	flags uint32

-	mask  uint32

-}

-

-func deserializeGenlMsg(b []byte) (hdr *genlMsgHdr) {

-	return (*genlMsgHdr)(unsafe.Pointer(&b[0:unsafe.Sizeof(*hdr)][0]))

-}

-

-func (hdr *genlMsgHdr) Serialize() []byte {

-	return (*(*[unsafe.Sizeof(*hdr)]byte)(unsafe.Pointer(hdr)))[:]

-}

-

-func (hdr *genlMsgHdr) Len() int {

-	return int(unsafe.Sizeof(*hdr))

-}

-

-func (f *ipvsFlags) Serialize() []byte {

-	return (*(*[unsafe.Sizeof(*f)]byte)(unsafe.Pointer(f)))[:]

-}

-

-func (f *ipvsFlags) Len() int {

-	return int(unsafe.Sizeof(*f))

-}

-

-func setup() {

-	ipvsOnce.Do(func() {

-		var err error

-		if out, err := exec.Command("modprobe", "-va", "ip_vs").CombinedOutput(); err != nil {

-			logrus.Warnf("Running modprobe ip_vs failed with message: `%s`, error: %v", strings.TrimSpace(string(out)), err)

-		}

-

-		ipvsFamily, err = getIPVSFamily()

-		if err != nil {

-			logrus.Error("Could not get ipvs family information from the kernel. It is possible that ipvs is not enabled in your kernel. Native loadbalancing will not work until this is fixed.")

-		}

-	})

-}

-

-func fillService(s *Service) nl.NetlinkRequestData {

-	cmdAttr := nl.NewRtAttr(ipvsCmdAttrService, nil)

-	nl.NewRtAttrChild(cmdAttr, ipvsSvcAttrAddressFamily, nl.Uint16Attr(s.AddressFamily))

-	if s.FWMark != 0 {

-		nl.NewRtAttrChild(cmdAttr, ipvsSvcAttrFWMark, nl.Uint32Attr(s.FWMark))

-	} else {

-		nl.NewRtAttrChild(cmdAttr, ipvsSvcAttrProtocol, nl.Uint16Attr(s.Protocol))

-		nl.NewRtAttrChild(cmdAttr, ipvsSvcAttrAddress, rawIPData(s.Address))

-

-		// Port needs to be in network byte order.

-		portBuf := new(bytes.Buffer)

-		binary.Write(portBuf, binary.BigEndian, s.Port)

-		nl.NewRtAttrChild(cmdAttr, ipvsSvcAttrPort, portBuf.Bytes())

-	}

-

-	nl.NewRtAttrChild(cmdAttr, ipvsSvcAttrSchedName, nl.ZeroTerminated(s.SchedName))

-	if s.PEName != "" {

-		nl.NewRtAttrChild(cmdAttr, ipvsSvcAttrPEName, nl.ZeroTerminated(s.PEName))

-	}

-	f := &ipvsFlags{

-		flags: s.Flags,

-		mask:  0xFFFFFFFF,

-	}

-	nl.NewRtAttrChild(cmdAttr, ipvsSvcAttrFlags, f.Serialize())

-	nl.NewRtAttrChild(cmdAttr, ipvsSvcAttrTimeout, nl.Uint32Attr(s.Timeout))

-	nl.NewRtAttrChild(cmdAttr, ipvsSvcAttrNetmask, nl.Uint32Attr(s.Netmask))

-	return cmdAttr

-}

-

-func fillDestination(d *Destination) nl.NetlinkRequestData {

-	cmdAttr := nl.NewRtAttr(ipvsCmdAttrDest, nil)

-

-	nl.NewRtAttrChild(cmdAttr, ipvsDestAttrAddress, rawIPData(d.Address))

-	// Port needs to be in network byte order.

-	portBuf := new(bytes.Buffer)

-	binary.Write(portBuf, binary.BigEndian, d.Port)

-	nl.NewRtAttrChild(cmdAttr, ipvsDestAttrPort, portBuf.Bytes())

-

-	nl.NewRtAttrChild(cmdAttr, ipvsDestAttrForwardingMethod, nl.Uint32Attr(d.ConnectionFlags&ConnectionFlagFwdMask))

-	nl.NewRtAttrChild(cmdAttr, ipvsDestAttrWeight, nl.Uint32Attr(uint32(d.Weight)))

-	nl.NewRtAttrChild(cmdAttr, ipvsDestAttrUpperThreshold, nl.Uint32Attr(d.UpperThreshold))

-	nl.NewRtAttrChild(cmdAttr, ipvsDestAttrLowerThreshold, nl.Uint32Attr(d.LowerThreshold))

-

-	return cmdAttr

-}

-

-func (i *Handle) doCmdwithResponse(s *Service, d *Destination, cmd uint8) ([][]byte, error) {

-	req := newIPVSRequest(cmd)

-	req.Seq = atomic.AddUint32(&i.seq, 1)

-

-	if s == nil {

-		req.Flags |= syscall.NLM_F_DUMP                    //Flag to dump all messages

-		req.AddData(nl.NewRtAttr(ipvsCmdAttrService, nil)) //Add a dummy attribute

-	} else {

-		req.AddData(fillService(s))

-	}

-

-	if d == nil {

-		if cmd == ipvsCmdGetDest {

-			req.Flags |= syscall.NLM_F_DUMP

-		}

-

-	} else {

-		req.AddData(fillDestination(d))

-	}

-

-	res, err := execute(i.sock, req, 0)

-	if err != nil {

-		return [][]byte{}, err

-	}

-

-	return res, nil

-}

-

-func (i *Handle) doCmd(s *Service, d *Destination, cmd uint8) error {

-	_, err := i.doCmdwithResponse(s, d, cmd)

-

-	return err

-}

-

-func getIPVSFamily() (int, error) {

-	sock, err := nl.GetNetlinkSocketAt(netns.None(), netns.None(), syscall.NETLINK_GENERIC)

-	if err != nil {

-		return 0, err

-	}

-	defer sock.Close()

-

-	req := newGenlRequest(genlCtrlID, genlCtrlCmdGetFamily)

-	req.AddData(nl.NewRtAttr(genlCtrlAttrFamilyName, nl.ZeroTerminated("IPVS")))

-

-	msgs, err := execute(sock, req, 0)

-	if err != nil {

-		return 0, err

-	}

-

-	for _, m := range msgs {

-		hdr := deserializeGenlMsg(m)

-		attrs, err := nl.ParseRouteAttr(m[hdr.Len():])

-		if err != nil {

-			return 0, err

-		}

-

-		for _, attr := range attrs {

-			switch int(attr.Attr.Type) {

-			case genlCtrlAttrFamilyID:

-				return int(native.Uint16(attr.Value[0:2])), nil

-			}

-		}

-	}

-

-	return 0, fmt.Errorf("no family id in the netlink response")

-}

-

-func rawIPData(ip net.IP) []byte {

-	family := nl.GetIPFamily(ip)

-	if family == nl.FAMILY_V4 {

-		return ip.To4()

-	}

-	return ip

-}

-

-func newIPVSRequest(cmd uint8) *nl.NetlinkRequest {

-	return newGenlRequest(ipvsFamily, cmd)

-}

-

-func newGenlRequest(familyID int, cmd uint8) *nl.NetlinkRequest {

-	req := nl.NewNetlinkRequest(familyID, syscall.NLM_F_ACK)

-	req.AddData(&genlMsgHdr{cmd: cmd, version: 1})

-	return req

-}

-

-func execute(s *nl.NetlinkSocket, req *nl.NetlinkRequest, resType uint16) ([][]byte, error) {

-	if err := s.Send(req); err != nil {

-		return nil, err

-	}

-

-	pid, err := s.GetPid()

-	if err != nil {

-		return nil, err

-	}

-

-	var res [][]byte

-

-done:

-	for {

-		msgs, err := s.Receive()

-		if err != nil {

-			if s.GetFd() == -1 {

-				return nil, fmt.Errorf("Socket got closed on receive")

-			}

-			if err == syscall.EAGAIN {

-				// timeout fired

-				continue

-			}

-			return nil, err

-		}

-		for _, m := range msgs {

-			if m.Header.Seq != req.Seq {

-				continue

-			}

-			if m.Header.Pid != pid {

-				return nil, fmt.Errorf("Wrong pid %d, expected %d", m.Header.Pid, pid)

-			}

-			if m.Header.Type == syscall.NLMSG_DONE {

-				break done

-			}

-			if m.Header.Type == syscall.NLMSG_ERROR {

-				error := int32(native.Uint32(m.Data[0:4]))

-				if error == 0 {

-					break done

-				}

-				return nil, syscall.Errno(-error)

-			}

-			if resType != 0 && m.Header.Type != resType {

-				continue

-			}

-			res = append(res, m.Data)

-			if m.Header.Flags&syscall.NLM_F_MULTI == 0 {

-				break done

-			}

-		}

-	}

-	return res, nil

-}

-

-func parseIP(ip []byte, family uint16) (net.IP, error) {

-

-	var resIP net.IP

-

-	switch family {

-	case syscall.AF_INET:

-		resIP = (net.IP)(ip[:4])

-	case syscall.AF_INET6:

-		resIP = (net.IP)(ip[:16])

-	default:

-		return nil, fmt.Errorf("parseIP Error ip=%v", ip)

-

-	}

-	return resIP, nil

-}

-

-// parseStats

-func assembleStats(msg []byte) (SvcStats, error) {

-

-	var s SvcStats

-

-	attrs, err := nl.ParseRouteAttr(msg)

-	if err != nil {

-		return s, err

-	}

-

-	for _, attr := range attrs {

-		attrType := int(attr.Attr.Type)

-		switch attrType {

-		case ipvsSvcStatsConns:

-			s.Connections = native.Uint32(attr.Value)

-		case ipvsSvcStatsPktsIn:

-			s.PacketsIn = native.Uint32(attr.Value)

-		case ipvsSvcStatsPktsOut:

-			s.PacketsOut = native.Uint32(attr.Value)

-		case ipvsSvcStatsBytesIn:

-			s.BytesIn = native.Uint64(attr.Value)

-		case ipvsSvcStatsBytesOut:

-			s.BytesOut = native.Uint64(attr.Value)

-		case ipvsSvcStatsCPS:

-			s.CPS = native.Uint32(attr.Value)

-		case ipvsSvcStatsPPSIn:

-			s.PPSIn = native.Uint32(attr.Value)

-		case ipvsSvcStatsPPSOut:

-			s.PPSOut = native.Uint32(attr.Value)

-		case ipvsSvcStatsBPSIn:

-			s.BPSIn = native.Uint32(attr.Value)

-		case ipvsSvcStatsBPSOut:

-			s.BPSOut = native.Uint32(attr.Value)

-		}

-	}

-	return s, nil

-}

-

-// assembleService assembles a services back from a hain of netlink attributes

-func assembleService(attrs []syscall.NetlinkRouteAttr) (*Service, error) {

-

-	var s Service

-	var addressBytes []byte

-

-	for _, attr := range attrs {

-

-		attrType := int(attr.Attr.Type)

-

-		switch attrType {

-

-		case ipvsSvcAttrAddressFamily:

-			s.AddressFamily = native.Uint16(attr.Value)

-		case ipvsSvcAttrProtocol:

-			s.Protocol = native.Uint16(attr.Value)

-		case ipvsSvcAttrAddress:

-			addressBytes = attr.Value

-		case ipvsSvcAttrPort:

-			s.Port = binary.BigEndian.Uint16(attr.Value)

-		case ipvsSvcAttrFWMark:

-			s.FWMark = native.Uint32(attr.Value)

-		case ipvsSvcAttrSchedName:

-			s.SchedName = nl.BytesToString(attr.Value)

-		case ipvsSvcAttrFlags:

-			s.Flags = native.Uint32(attr.Value)

-		case ipvsSvcAttrTimeout:

-			s.Timeout = native.Uint32(attr.Value)

-		case ipvsSvcAttrNetmask:

-			s.Netmask = native.Uint32(attr.Value)

-		case ipvsSvcAttrStats:

-			stats, err := assembleStats(attr.Value)

-			if err != nil {

-				return nil, err

-			}

-			s.Stats = stats

-		}

-

-	}

-

-	// parse Address after parse AddressFamily incase of parseIP error

-	if addressBytes != nil {

-		ip, err := parseIP(addressBytes, s.AddressFamily)

-		if err != nil {

-			return nil, err

-		}

-		s.Address = ip

-	}

-

-	return &s, nil

-}

-

-// parseService given a ipvs netlink response this function will respond with a valid service entry, an error otherwise

-func (i *Handle) parseService(msg []byte) (*Service, error) {

-

-	var s *Service

-

-	//Remove General header for this message and parse the NetLink message

-	hdr := deserializeGenlMsg(msg)

-	NetLinkAttrs, err := nl.ParseRouteAttr(msg[hdr.Len():])

-	if err != nil {

-		return nil, err

-	}

-	if len(NetLinkAttrs) == 0 {

-		return nil, fmt.Errorf("error no valid netlink message found while parsing service record")

-	}

-

-	//Now Parse and get IPVS related attributes messages packed in this message.

-	ipvsAttrs, err := nl.ParseRouteAttr(NetLinkAttrs[0].Value)

-	if err != nil {

-		return nil, err

-	}

-

-	//Assemble all the IPVS related attribute messages and create a service record

-	s, err = assembleService(ipvsAttrs)

-	if err != nil {

-		return nil, err

-	}

-

-	return s, nil

-}

-

-// doGetServicesCmd a wrapper which could be used commonly for both GetServices() and GetService(*Service)

-func (i *Handle) doGetServicesCmd(svc *Service) ([]*Service, error) {

-	var res []*Service

-

-	msgs, err := i.doCmdwithResponse(svc, nil, ipvsCmdGetService)

-	if err != nil {

-		return nil, err

-	}

-

-	for _, msg := range msgs {

-		srv, err := i.parseService(msg)

-		if err != nil {

-			return nil, err

-		}

-		res = append(res, srv)

-	}

-

-	return res, nil

-}

-

-// doCmdWithoutAttr a simple wrapper of netlink socket execute command

-func (i *Handle) doCmdWithoutAttr(cmd uint8) ([][]byte, error) {

-	req := newIPVSRequest(cmd)

-	req.Seq = atomic.AddUint32(&i.seq, 1)

-	return execute(i.sock, req, 0)

-}