github.com/qinghon/debinterface@v0.0.6/interfaceReader.go (about)

     1  // debian network config parse package
     2  package debinterface
     3  
     4  import (
     5  	"bufio"
     6  	"io"
     7  	"net"
     8  	"os"
     9  	"path/filepath"
    10  	"strconv"
    11  	"strings"
    12  )
    13  
    14  var INTERFACES_FILE = "/etc/network/interfaces"
    15  
    16  type InterfaceReader struct {
    17  	Adapters       []Interface
    18  	Interfaces     []Interfaces
    19  	context        int
    20  	headerComments string
    21  	selection      map[string][]string
    22  	filepath       string
    23  }
    24  
    25  func NewReader(_filepath string) *InterfaceReader {
    26  	var reader = InterfaceReader{}
    27  	reader.context = -1
    28  	if _filepath == "" {
    29  		reader.filepath = INTERFACES_FILE
    30  	} else {
    31  		reader.filepath = _filepath
    32  	}
    33  	reader.selection = make(map[string][]string)
    34  	return &reader
    35  }
    36  func (reader *InterfaceReader) Read() error {
    37  	return reader.ReadLines(reader.filepath)
    38  }
    39  func (reader *InterfaceReader) ReadLines(_filepath string) error {
    40  	fp, err := os.Open(_filepath)
    41  	if err != nil {
    42  		return err
    43  	}
    44  	defer fp.Close()
    45  	var i Interfaces
    46  	i.FilePath = _filepath
    47  	reader.Interfaces = append(reader.Interfaces, i)
    48  	br := bufio.NewReader(fp)
    49  	var header = false
    50  	var lineStr = ""
    51  	var lineByte []byte
    52  	var e error
    53  	for {
    54  		lineByte, _, e = br.ReadLine()
    55  		if e == io.EOF {
    56  			break
    57  		}
    58  		//println(string(lineByte))
    59  		lineStr = string([]rune(string(lineByte)))
    60  		if strings.TrimSpace(lineStr) == "" {
    61  			continue
    62  		}
    63  		if strings.TrimSpace(lineStr)[0:1] == "#" {
    64  			if !header {
    65  				reader.headerComments += lineStr
    66  			}
    67  			continue
    68  		}
    69  		header = false
    70  		// 去掉行尾 "#"
    71  		if strings.Index(lineStr, "#") != -1 {
    72  			lineStr = lineStr[:strings.Index(lineStr, "#")]
    73  		}
    74  		lineStr = strings.TrimSpace(lineStr)
    75  		if lineStr == "" {
    76  			continue
    77  		}
    78  		reader.readAuto(lineStr)
    79  		reader.parseIface(lineStr)
    80  		if err = reader.parseDetails(lineStr); err != nil {
    81  			return err
    82  		}
    83  	}
    84  	reader.parseAuto()
    85  	return nil
    86  }
    87  func (reader *InterfaceReader) ReadFromRD(rd io.Reader) error {
    88  	br := bufio.NewReader(rd)
    89  	var header = false
    90  	var lineStr = ""
    91  	var lineByte []byte
    92  	var e, err error
    93  	for {
    94  		lineByte, _, e = br.ReadLine()
    95  		if e == io.EOF {
    96  			break
    97  		}
    98  		//println(string(lineByte))
    99  		lineStr = string([]rune(string(lineByte)))
   100  		if strings.TrimSpace(lineStr) == "" {
   101  			continue
   102  		}
   103  		if strings.TrimSpace(lineStr)[0:1] == "#" {
   104  			if !header {
   105  				reader.headerComments += lineStr
   106  			}
   107  			continue
   108  		}
   109  		header = false
   110  		// 去掉行尾 "#"
   111  		if strings.Index(lineStr, "#") != -1 {
   112  			lineStr = lineStr[:strings.Index(lineStr, "#")]
   113  		}
   114  		lineStr = strings.TrimSpace(lineStr)
   115  		if lineStr == "" {
   116  			continue
   117  		}
   118  		reader.readAuto(lineStr)
   119  
   120  		reader.parseIface(lineStr)
   121  		if err = reader.parseDetails(lineStr); err != nil {
   122  			return err
   123  		}
   124  	}
   125  	reader.parseAuto()
   126  	return nil
   127  }
   128  func (reader *InterfaceReader) parseIface(line string) {
   129  	sline := strings.Fields(line)
   130  	if sline[0] == "iface" {
   131  		reader.context = reader.context + 1
   132  		var adapter = Interface{}
   133  		adapter.SetName(sline[1])
   134  		adapter.SetAddrFam(sline[2])
   135  		adapter.SetAddrSource(sline[3])
   136  		//adapter.SetFromFile(filepath)
   137  		reader.Adapters = append(reader.Adapters, adapter)
   138  
   139  	}
   140  }
   141  func (reader *InterfaceReader) readAuto(line string) {
   142  	sline := strings.Fields(line)
   143  	switch sline[0] {
   144  	//case "auto":
   145  	//	reader.auto = append(reader.auto, sline[1])
   146  	//case "hotplug":
   147  	//	reader.hotplug = append(reader.hotplug, sline[1])
   148  	case "auto", "hotplug", "allow-hotplug", "no-auto-down", "no-scripts":
   149  		reader.selection[sline[1]] = append(reader.selection[sline[1]], sline[0])
   150  	}
   151  }
   152  
   153  //
   154  func (reader *InterfaceReader) parseAuto() {
   155  	for i, a := range reader.Adapters {
   156  		if len(reader.selection[a.GetName()]) != 0 {
   157  			for _, v := range reader.selection[a.GetName()] {
   158  				reader.Adapters[i].SetSelection(v)
   159  			}
   160  		}
   161  	}
   162  }
   163  func (reader *InterfaceReader) parseDetails(line string) error {
   164  	sline := strings.Fields(line)
   165  	//log.Println(sline,len(sline))
   166  	if len(sline) < 2 {
   167  		return os.ErrInvalid
   168  	}
   169  
   170  	switch sline[0] {
   171  	case "auto", "iface", "allow-hotplug", "no-auto-down", "no-scripts":
   172  		return nil
   173  	case "address":
   174  		if strings.Contains(sline[1], "/") {
   175  			ip, ipnet, err := net.ParseCIDR(sline[1])
   176  			if err == nil {
   177  				reader.Adapters[reader.context].SetAddress(ip)
   178  				reader.Adapters[reader.context].SetNetmask(ipnet.Mask)
   179  			} else {
   180  				//log.Println(err)
   181  				return err
   182  			}
   183  		} else {
   184  			reader.Adapters[reader.context].SetAddress(net.ParseIP(sline[1]))
   185  		}
   186  	case "netmask":
   187  		ip := net.ParseIP(sline[1])
   188  		// todo ipv6 兼容
   189  		ipmask := net.IPv4Mask(ip[len(ip)-4], ip[len(ip)-3], ip[len(ip)-2], ip[len(ip)-1])
   190  		reader.Adapters[reader.context].SetNetmask(ipmask)
   191  	case "gateway":
   192  		reader.Adapters[reader.context].SetGateWay(net.ParseIP(sline[1]))
   193  	case "mtu":
   194  		mtu, err := strconv.Atoi(sline[1])
   195  		if err != nil {
   196  			return err
   197  		}
   198  		reader.Adapters[reader.context].SetMtu(mtu)
   199  	case "scope":
   200  		reader.Adapters[reader.context].SetScope(sline[1])
   201  	case "hwaddress":
   202  		mac, err := net.ParseMAC(sline[1])
   203  		if err == nil {
   204  			reader.Adapters[reader.context].SetHwAddress(mac)
   205  		} else {
   206  			//log.Println(err)
   207  			return err
   208  		}
   209  	case "dns-search":
   210  		reader.Adapters[reader.context].SetDnsSearch(sline[1:])
   211  	case "dns-nameservers":
   212  		var ipList []net.IP
   213  		for _, p := range sline[1:] {
   214  			ipList = append(ipList, net.ParseIP(p))
   215  		}
   216  		reader.Adapters[reader.context].SetDnsNameServer(ipList)
   217  	case "broadcast":
   218  		reader.Adapters[reader.context].SetBroadcast(net.ParseIP(sline[1]))
   219  	case "up", "down", "pre-up", "pre-down", "post-up", "post-down":
   220  		reader.Adapters[reader.context].SetScript(sline[0], strings.Join(sline[1:], " "))
   221  	case "source", "source-directory":
   222  		if sline[0] == "source-directory" {
   223  			//todo source-directory parse
   224  			return nil
   225  		}
   226  		files, err := filepath.Glob(sline[1])
   227  		if err != nil {
   228  			//log.Println(err)
   229  			return err
   230  		}
   231  		for _, f := range files {
   232  			reader.ReadLines(f)
   233  		}
   234  	case "pointopoint":
   235  		reader.Adapters[reader.context].SetPoinToPoint(net.ParseIP(sline[1]))
   236  	case "provider":
   237  		reader.Adapters[reader.context].SetProvider(sline[1])
   238  	case "bridge_ports":
   239  		switch sline[1] {
   240  		case "none":
   241  			reader.Adapters[reader.context].SetBridgePorts(sline[1], "")
   242  		case "regex":
   243  			reader.Adapters[reader.context].SetBridgePorts(sline[1], sline[2])
   244  		default:
   245  			reader.Adapters[reader.context].SetBridgePorts("", sline[1])
   246  		}
   247  	case "bridge_fd":
   248  		fd, err := strconv.Atoi(sline[1])
   249  		if err == nil {
   250  			reader.Adapters[reader.context].SetBridgeFd(fd)
   251  		} else {
   252  			reader.Adapters[reader.context].SetUnknown(line)
   253  		}
   254  	case "bridge_waitport":
   255  		wp, err := strconv.Atoi(sline[1])
   256  		if err == nil {
   257  			reader.Adapters[reader.context].SetBridgeWaitPort(wp)
   258  		} else {
   259  			reader.Adapters[reader.context].SetUnknown(line)
   260  		}
   261  	case "bridge_stp":
   262  		if sline[1] == "off" {
   263  			reader.Adapters[reader.context].SetBridgeStp(false)
   264  		} else if sline[1] == "on" {
   265  			reader.Adapters[reader.context].SetBridgeStp(true)
   266  		}
   267  	default:
   268  		//log.Println("Unknow options",sline)
   269  		if reader.context != -1 {
   270  			reader.Adapters[reader.context].SetUnknown(line)
   271  		}
   272  	}
   273  	return nil
   274  }