Source file src/vendor/golang.org/x/net/route/address.go

     1	// Copyright 2016 The Go Authors. All rights reserved.
     2	// Use of this source code is governed by a BSD-style
     3	// license that can be found in the LICENSE file.
     4	
     5	// +build darwin dragonfly freebsd netbsd openbsd
     6	
     7	package route
     8	
     9	import "runtime"
    10	
    11	// An Addr represents an address associated with packet routing.
    12	type Addr interface {
    13		// Family returns an address family.
    14		Family() int
    15	}
    16	
    17	// A LinkAddr represents a link-layer address.
    18	type LinkAddr struct {
    19		Index int    // interface index when attached
    20		Name  string // interface name when attached
    21		Addr  []byte // link-layer address when attached
    22	}
    23	
    24	// Family implements the Family method of Addr interface.
    25	func (a *LinkAddr) Family() int { return sysAF_LINK }
    26	
    27	func (a *LinkAddr) lenAndSpace() (int, int) {
    28		l := 8 + len(a.Name) + len(a.Addr)
    29		return l, roundup(l)
    30	}
    31	
    32	func (a *LinkAddr) marshal(b []byte) (int, error) {
    33		l, ll := a.lenAndSpace()
    34		if len(b) < ll {
    35			return 0, errShortBuffer
    36		}
    37		nlen, alen := len(a.Name), len(a.Addr)
    38		if nlen > 255 || alen > 255 {
    39			return 0, errInvalidAddr
    40		}
    41		b[0] = byte(l)
    42		b[1] = sysAF_LINK
    43		if a.Index > 0 {
    44			nativeEndian.PutUint16(b[2:4], uint16(a.Index))
    45		}
    46		data := b[8:]
    47		if nlen > 0 {
    48			b[5] = byte(nlen)
    49			copy(data[:nlen], a.Addr)
    50			data = data[nlen:]
    51		}
    52		if alen > 0 {
    53			b[6] = byte(alen)
    54			copy(data[:alen], a.Name)
    55			data = data[alen:]
    56		}
    57		return ll, nil
    58	}
    59	
    60	func parseLinkAddr(b []byte) (Addr, error) {
    61		if len(b) < 8 {
    62			return nil, errInvalidAddr
    63		}
    64		_, a, err := parseKernelLinkAddr(sysAF_LINK, b[4:])
    65		if err != nil {
    66			return nil, err
    67		}
    68		a.(*LinkAddr).Index = int(nativeEndian.Uint16(b[2:4]))
    69		return a, nil
    70	}
    71	
    72	// parseKernelLinkAddr parses b as a link-layer address in
    73	// conventional BSD kernel form.
    74	func parseKernelLinkAddr(_ int, b []byte) (int, Addr, error) {
    75		// The encoding looks like the following:
    76		// +----------------------------+
    77		// | Type             (1 octet) |
    78		// +----------------------------+
    79		// | Name length      (1 octet) |
    80		// +----------------------------+
    81		// | Address length   (1 octet) |
    82		// +----------------------------+
    83		// | Selector length  (1 octet) |
    84		// +----------------------------+
    85		// | Data            (variable) |
    86		// +----------------------------+
    87		//
    88		// On some platforms, all-bit-one of length field means "don't
    89		// care".
    90		nlen, alen, slen := int(b[1]), int(b[2]), int(b[3])
    91		if nlen == 0xff {
    92			nlen = 0
    93		}
    94		if alen == 0xff {
    95			alen = 0
    96		}
    97		if slen == 0xff {
    98			slen = 0
    99		}
   100		l := 4 + nlen + alen + slen
   101		if len(b) < l {
   102			return 0, nil, errInvalidAddr
   103		}
   104		data := b[4:]
   105		var name string
   106		var addr []byte
   107		if nlen > 0 {
   108			name = string(data[:nlen])
   109			data = data[nlen:]
   110		}
   111		if alen > 0 {
   112			addr = data[:alen]
   113			data = data[alen:]
   114		}
   115		return l, &LinkAddr{Name: name, Addr: addr}, nil
   116	}
   117	
   118	// An Inet4Addr represents an internet address for IPv4.
   119	type Inet4Addr struct {
   120		IP [4]byte // IP address
   121	}
   122	
   123	// Family implements the Family method of Addr interface.
   124	func (a *Inet4Addr) Family() int { return sysAF_INET }
   125	
   126	func (a *Inet4Addr) lenAndSpace() (int, int) {
   127		return sizeofSockaddrInet, roundup(sizeofSockaddrInet)
   128	}
   129	
   130	func (a *Inet4Addr) marshal(b []byte) (int, error) {
   131		l, ll := a.lenAndSpace()
   132		if len(b) < ll {
   133			return 0, errShortBuffer
   134		}
   135		b[0] = byte(l)
   136		b[1] = sysAF_INET
   137		copy(b[4:8], a.IP[:])
   138		return ll, nil
   139	}
   140	
   141	// An Inet6Addr represents an internet address for IPv6.
   142	type Inet6Addr struct {
   143		IP     [16]byte // IP address
   144		ZoneID int      // zone identifier
   145	}
   146	
   147	// Family implements the Family method of Addr interface.
   148	func (a *Inet6Addr) Family() int { return sysAF_INET6 }
   149	
   150	func (a *Inet6Addr) lenAndSpace() (int, int) {
   151		return sizeofSockaddrInet6, roundup(sizeofSockaddrInet6)
   152	}
   153	
   154	func (a *Inet6Addr) marshal(b []byte) (int, error) {
   155		l, ll := a.lenAndSpace()
   156		if len(b) < ll {
   157			return 0, errShortBuffer
   158		}
   159		b[0] = byte(l)
   160		b[1] = sysAF_INET6
   161		copy(b[8:24], a.IP[:])
   162		if a.ZoneID > 0 {
   163			nativeEndian.PutUint32(b[24:28], uint32(a.ZoneID))
   164		}
   165		return ll, nil
   166	}
   167	
   168	// parseInetAddr parses b as an internet address for IPv4 or IPv6.
   169	func parseInetAddr(af int, b []byte) (Addr, error) {
   170		switch af {
   171		case sysAF_INET:
   172			if len(b) < sizeofSockaddrInet {
   173				return nil, errInvalidAddr
   174			}
   175			a := &Inet4Addr{}
   176			copy(a.IP[:], b[4:8])
   177			return a, nil
   178		case sysAF_INET6:
   179			if len(b) < sizeofSockaddrInet6 {
   180				return nil, errInvalidAddr
   181			}
   182			a := &Inet6Addr{ZoneID: int(nativeEndian.Uint32(b[24:28]))}
   183			copy(a.IP[:], b[8:24])
   184			if a.IP[0] == 0xfe && a.IP[1]&0xc0 == 0x80 || a.IP[0] == 0xff && (a.IP[1]&0x0f == 0x01 || a.IP[1]&0x0f == 0x02) {
   185				// KAME based IPv6 protocol stack usually
   186				// embeds the interface index in the
   187				// interface-local or link-local address as
   188				// the kernel-internal form.
   189				id := int(bigEndian.Uint16(a.IP[2:4]))
   190				if id != 0 {
   191					a.ZoneID = id
   192					a.IP[2], a.IP[3] = 0, 0
   193				}
   194			}
   195			return a, nil
   196		default:
   197			return nil, errInvalidAddr
   198		}
   199	}
   200	
   201	// parseKernelInetAddr parses b as an internet address in conventional
   202	// BSD kernel form.
   203	func parseKernelInetAddr(af int, b []byte) (int, Addr, error) {
   204		// The encoding looks similar to the NLRI encoding.
   205		// +----------------------------+
   206		// | Length           (1 octet) |
   207		// +----------------------------+
   208		// | Address prefix  (variable) |
   209		// +----------------------------+
   210		//
   211		// The differences between the kernel form and the NLRI
   212		// encoding are:
   213		//
   214		// - The length field of the kernel form indicates the prefix
   215		//   length in bytes, not in bits
   216		//
   217		// - In the kernel form, zero value of the length field
   218		//   doesn't mean 0.0.0.0/0 or ::/0
   219		//
   220		// - The kernel form appends leading bytes to the prefix field
   221		//   to make the <length, prefix> tuple to be conformed with
   222		//   the routing message boundary
   223		l := int(b[0])
   224		if runtime.GOOS == "darwin" {
   225			// On Darwn, an address in the kernel form is also
   226			// used as a message filler.
   227			if l == 0 || len(b) > roundup(l) {
   228				l = roundup(l)
   229			}
   230		} else {
   231			l = roundup(l)
   232		}
   233		if len(b) < l {
   234			return 0, nil, errInvalidAddr
   235		}
   236		// Don't reorder case expressions.
   237		// The case expressions for IPv6 must come first.
   238		const (
   239			off4 = 4 // offset of in_addr
   240			off6 = 8 // offset of in6_addr
   241		)
   242		switch {
   243		case b[0] == sizeofSockaddrInet6:
   244			a := &Inet6Addr{}
   245			copy(a.IP[:], b[off6:off6+16])
   246			return int(b[0]), a, nil
   247		case af == sysAF_INET6:
   248			a := &Inet6Addr{}
   249			if l-1 < off6 {
   250				copy(a.IP[:], b[1:l])
   251			} else {
   252				copy(a.IP[:], b[l-off6:l])
   253			}
   254			return int(b[0]), a, nil
   255		case b[0] == sizeofSockaddrInet:
   256			a := &Inet4Addr{}
   257			copy(a.IP[:], b[off4:off4+4])
   258			return int(b[0]), a, nil
   259		default: // an old fashion, AF_UNSPEC or unknown means AF_INET
   260			a := &Inet4Addr{}
   261			if l-1 < off4 {
   262				copy(a.IP[:], b[1:l])
   263			} else {
   264				copy(a.IP[:], b[l-off4:l])
   265			}
   266			return int(b[0]), a, nil
   267		}
   268	}
   269	
   270	// A DefaultAddr represents an address of various operating
   271	// system-specific features.
   272	type DefaultAddr struct {
   273		af  int
   274		Raw []byte // raw format of address
   275	}
   276	
   277	// Family implements the Family method of Addr interface.
   278	func (a *DefaultAddr) Family() int { return a.af }
   279	
   280	func (a *DefaultAddr) lenAndSpace() (int, int) {
   281		l := len(a.Raw)
   282		return l, roundup(l)
   283	}
   284	
   285	func (a *DefaultAddr) marshal(b []byte) (int, error) {
   286		l, ll := a.lenAndSpace()
   287		if len(b) < ll {
   288			return 0, errShortBuffer
   289		}
   290		if l > 255 {
   291			return 0, errInvalidAddr
   292		}
   293		b[1] = byte(l)
   294		copy(b[:l], a.Raw)
   295		return ll, nil
   296	}
   297	
   298	func parseDefaultAddr(b []byte) (Addr, error) {
   299		if len(b) < 2 || len(b) < int(b[0]) {
   300			return nil, errInvalidAddr
   301		}
   302		a := &DefaultAddr{af: int(b[1]), Raw: b[:b[0]]}
   303		return a, nil
   304	}
   305	
   306	func addrsSpace(as []Addr) int {
   307		var l int
   308		for _, a := range as {
   309			switch a := a.(type) {
   310			case *LinkAddr:
   311				_, ll := a.lenAndSpace()
   312				l += ll
   313			case *Inet4Addr:
   314				_, ll := a.lenAndSpace()
   315				l += ll
   316			case *Inet6Addr:
   317				_, ll := a.lenAndSpace()
   318				l += ll
   319			case *DefaultAddr:
   320				_, ll := a.lenAndSpace()
   321				l += ll
   322			}
   323		}
   324		return l
   325	}
   326	
   327	// marshalAddrs marshals as and returns a bitmap indicating which
   328	// address is stored in b.
   329	func marshalAddrs(b []byte, as []Addr) (uint, error) {
   330		var attrs uint
   331		for i, a := range as {
   332			switch a := a.(type) {
   333			case *LinkAddr:
   334				l, err := a.marshal(b)
   335				if err != nil {
   336					return 0, err
   337				}
   338				b = b[l:]
   339				attrs |= 1 << uint(i)
   340			case *Inet4Addr:
   341				l, err := a.marshal(b)
   342				if err != nil {
   343					return 0, err
   344				}
   345				b = b[l:]
   346				attrs |= 1 << uint(i)
   347			case *Inet6Addr:
   348				l, err := a.marshal(b)
   349				if err != nil {
   350					return 0, err
   351				}
   352				b = b[l:]
   353				attrs |= 1 << uint(i)
   354			case *DefaultAddr:
   355				l, err := a.marshal(b)
   356				if err != nil {
   357					return 0, err
   358				}
   359				b = b[l:]
   360				attrs |= 1 << uint(i)
   361			}
   362		}
   363		return attrs, nil
   364	}
   365	
   366	func parseAddrs(attrs uint, fn func(int, []byte) (int, Addr, error), b []byte) ([]Addr, error) {
   367		var as [sysRTAX_MAX]Addr
   368		af := int(sysAF_UNSPEC)
   369		for i := uint(0); i < sysRTAX_MAX && len(b) >= roundup(0); i++ {
   370			if attrs&(1<<i) == 0 {
   371				continue
   372			}
   373			if i <= sysRTAX_BRD {
   374				switch b[1] {
   375				case sysAF_LINK:
   376					a, err := parseLinkAddr(b)
   377					if err != nil {
   378						return nil, err
   379					}
   380					as[i] = a
   381					l := roundup(int(b[0]))
   382					if len(b) < l {
   383						return nil, errMessageTooShort
   384					}
   385					b = b[l:]
   386				case sysAF_INET, sysAF_INET6:
   387					af = int(b[1])
   388					a, err := parseInetAddr(af, b)
   389					if err != nil {
   390						return nil, err
   391					}
   392					as[i] = a
   393					l := roundup(int(b[0]))
   394					if len(b) < l {
   395						return nil, errMessageTooShort
   396					}
   397					b = b[l:]
   398				default:
   399					l, a, err := fn(af, b)
   400					if err != nil {
   401						return nil, err
   402					}
   403					as[i] = a
   404					ll := roundup(l)
   405					if len(b) < ll {
   406						b = b[l:]
   407					} else {
   408						b = b[ll:]
   409					}
   410				}
   411			} else {
   412				a, err := parseDefaultAddr(b)
   413				if err != nil {
   414					return nil, err
   415				}
   416				as[i] = a
   417				l := roundup(int(b[0]))
   418				if len(b) < l {
   419					return nil, errMessageTooShort
   420				}
   421				b = b[l:]
   422			}
   423		}
   424		return as[:], nil
   425	}
   426	

View as plain text