libgo/go/net/interface_plan9.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 package net
   6
   7 import (
   8         "errors"
   9         "os"
  10 )
  11
  12 // If the ifindex is zero, interfaceTable returns mappings of all
  13 // network interfaces. Otherwise it returns a mapping of a specific
  14 // interface.
  15 func interfaceTable(ifindex int) ([]Interface, error) {
  16         if ifindex == 0 {
  17                 n, err := interfaceCount()
  18                 if err != nil {
  19                         return nil, err
  20                 }
  21                 ifcs := make([]Interface, n)
  22                 for i := range ifcs {
  23                         ifc, err := readInterface(i)
  24                         if err != nil {
  25                                 return nil, err
  26                         }
  27                         ifcs[i] = *ifc
  28                 }
  29                 return ifcs, nil
  30         }
  31
  32         ifc, err := readInterface(ifindex - 1)
  33         if err != nil {
  34                 return nil, err
  35         }
  36         return []Interface{*ifc}, nil
  37 }
  38
  39 func readInterface(i int) (*Interface, error) {
  40         ifc := &Interface{
  41                 Index: i + 1,                        // Offset the index by one to suit the contract
  42                 Name:  netdir + "/ipifc/" + itoa(i), // Name is the full path to the interface path in plan9
  43         }
  44
  45         ifcstat := ifc.Name + "/status"
  46         ifcstatf, err := open(ifcstat)
  47         if err != nil {
  48                 return nil, err
  49         }
  50         defer ifcstatf.close()
  51
  52         line, ok := ifcstatf.readLine()
  53         if !ok {
  54                 return nil, errors.New("invalid interface status file: " + ifcstat)
  55         }
  56
  57         fields := getFields(line)
  58         if len(fields) < 4 {
  59                 return nil, errors.New("invalid interface status file: " + ifcstat)
  60         }
  61
  62         device := fields[1]
  63         mtustr := fields[3]
  64
  65         mtu, _, ok := dtoi(mtustr)
  66         if !ok {
  67                 return nil, errors.New("invalid status file of interface: " + ifcstat)
  68         }
  69         ifc.MTU = mtu
  70
  71         // Not a loopback device
  72         if device != "/dev/null" {
  73                 deviceaddrf, err := open(device + "/addr")
  74                 if err != nil {
  75                         return nil, err
  76                 }
  77                 defer deviceaddrf.close()
  78
  79                 line, ok = deviceaddrf.readLine()
  80                 if !ok {
  81                         return nil, errors.New("invalid address file for interface: " + device + "/addr")
  82                 }
  83
  84                 if len(line) > 0 && len(line)%2 == 0 {
  85                         ifc.HardwareAddr = make([]byte, len(line)/2)
  86                         var ok bool
  87                         for i := range ifc.HardwareAddr {
  88                                 j := (i + 1) * 2
  89                                 ifc.HardwareAddr[i], ok = xtoi2(line[i*2:j], 0)
  90                                 if !ok {
  91                                         ifc.HardwareAddr = ifc.HardwareAddr[:i]
  92                                         break
  93                                 }
  94                         }
  95                 }
  96
  97                 ifc.Flags = FlagUp | FlagBroadcast | FlagMulticast
  98         } else {
  99                 ifc.Flags = FlagUp | FlagMulticast | FlagLoopback
 100         }
 101
 102         return ifc, nil
 103 }
 104
 105 func interfaceCount() (int, error) {
 106         d, err := os.Open(netdir + "/ipifc")
 107         if err != nil {
 108                 return -1, err
 109         }
 110         defer d.Close()
 111
 112         names, err := d.Readdirnames(0)
 113         if err != nil {
 114                 return -1, err
 115         }
 116
 117         // Assumes that numbered files in ipifc are strictly
 118         // the incrementing numbered directories for the
 119         // interfaces
 120         c := 0
 121         for _, name := range names {
 122                 if _, _, ok := dtoi(name); !ok {
 123                         continue
 124                 }
 125                 c++
 126         }
 127
 128         return c, nil
 129 }
 130
 131 // If the ifi is nil, interfaceAddrTable returns addresses for all
 132 // network interfaces. Otherwise it returns addresses for a specific
 133 // interface.
 134 func interfaceAddrTable(ifi *Interface) ([]Addr, error) {
 135         var ifcs []Interface
 136         if ifi == nil {
 137                 var err error
 138                 ifcs, err = interfaceTable(0)
 139                 if err != nil {
 140                         return nil, err
 141                 }
 142         } else {
 143                 ifcs = []Interface{*ifi}
 144         }
 145
 146         addrs := make([]Addr, len(ifcs))
 147         for i, ifc := range ifcs {
 148                 status := ifc.Name + "/status"
 149                 statusf, err := open(status)
 150                 if err != nil {
 151                         return nil, err
 152                 }
 153                 defer statusf.close()
 154
 155                 // Read but ignore first line as it only contains the table header.
 156                 // See https://9p.io/magic/man2html/3/ip
 157                 if _, ok := statusf.readLine(); !ok {
 158                         return nil, errors.New("cannot read header line for interface: " + status)
 159                 }
 160                 line, ok := statusf.readLine()
 161                 if !ok {
 162                         return nil, errors.New("cannot read IP address for interface: " + status)
 163                 }
 164
 165                 // This assumes only a single address for the interface.
 166                 fields := getFields(line)
 167                 if len(fields) < 1 {
 168                         return nil, errors.New("cannot parse IP address for interface: " + status)
 169                 }
 170                 addr := fields[0]
 171                 ip := ParseIP(addr)
 172                 if ip == nil {
 173                         return nil, errors.New("cannot parse IP address for interface: " + status)
 174                 }
 175
 176                 // The mask is represented as CIDR relative to the IPv6 address.
 177                 // Plan 9 internal representation is always IPv6.
 178                 maskfld := fields[1]
 179                 maskfld = maskfld[1:]
 180                 pfxlen, _, ok := dtoi(maskfld)
 181                 if !ok {
 182                         return nil, errors.New("cannot parse network mask for interface: " + status)
 183                 }
 184                 var mask IPMask
 185                 if ip.To4() != nil { // IPv4 or IPv6 IPv4-mapped address
 186                         mask = CIDRMask(pfxlen-8*len(v4InV6Prefix), 8*IPv4len)
 187                 }
 188                 if ip.To16() != nil && ip.To4() == nil { // IPv6 address
 189                         mask = CIDRMask(pfxlen, 8*IPv6len)
 190                 }
 191
 192                 addrs[i] = &IPNet{IP: ip, Mask: mask}
 193         }
 194
 195         return addrs, nil
 196 }
 197
 198 // interfaceMulticastAddrTable returns addresses for a specific
 199 // interface.
 200 func interfaceMulticastAddrTable(ifi *Interface) ([]Addr, error) {
 201         return nil, nil
 202 }