Esempio n. 1
0
func (self *LinkHandler) SetLinkState(flag link.Flags) (err os.Error) {
	var qry *netlink.Message
	if hdr, ok := self.cache.Header.(*link.Header); ok {
		// While rtnetlink(7) says changes should always be IFF_QUERY, it has some
		// behaviours that are undocumented - like limiting actions on SETLINK's to
		// specific FLAGs.
		hdr = link.NewHeader(hdr.InterfaceFamily(), hdr.InterfaceType(), hdr.InterfaceIndex(), flag&link.IFF_UP, link.IFF_UP)
		msg := rtnetlink.Message{Header: hdr}
		qry, err = netlink.NewMessage(rtnetlink.RTM_SETLINK, netlink.NLM_F_ACK|netlink.NLM_F_REQUEST, msg, 4)
	} else {
		err = os.NewError("Cant set link flags (invalid cache)")
	}
	if err != nil {
		return
	}
	mch, err := self.h.Query(*qry, 1, 4)
	if err == nil {
		for m := range mch {
			switch m.Header.MessageType() {
			case netlink.NLMSG_ERROR:
				emsg := &netlink.Error{}
				err = emsg.UnmarshalNetlink(m.Body, 4)
				if err == nil && emsg.Code() != 0 {
					err = emsg
				}
			default:
				err = os.NewError("Unexpected netlink message")
				log.Printf("NetlinkError: %v", err)
			}
		}
		close(mch)
	}
	return
}
Esempio n. 2
0
func (self *linkFinder) GetLinkByID(i uint32) (lh *LinkHandler, err os.Error) {
	qry, err := netlink.NewMessage(rtnetlink.RTM_GETLINK, netlink.NLM_F_REQUEST,
		link.NewHeader(rtnetlink.AF_UNSPEC, 0, i, 0, 0), 4)
	if err == nil {
		var mch chan netlink.Message
		mch, err = self.h.Query(*qry, 1, 4)
		if err == nil {
			for ii := range mch {
				switch ii.Header.MessageType() {
				default:
					err = os.NewError("Unknown message type in response to RTM_GETLINK")
				case netlink.NLMSG_ERROR:
					emsg := &netlink.Error{}
					err = emsg.UnmarshalNetlink(ii.Body, 4)
					if err == nil && emsg.Code() != 0 {
						err = emsg
					}
				case rtnetlink.RTM_NEWLINK:
					lhdr := &link.Header{}
					msg := &rtnetlink.Message{Header: lhdr}
					err = msg.UnmarshalNetlink(ii.Body, 4)
					if err == nil {
						lh = &LinkHandler{h: self.h, cache: msg}
					}
				}
			}
			close(mch)
		}
	}
	return
}
Esempio n. 3
0
func main() {
	nlmsg, err := netlink.NewMessage(rtnetlink.RTM_GETADDR, netlink.NLM_F_DUMP|netlink.NLM_F_REQUEST, &addr.Header{}, 4)
	if err != nil {
		log.Exitf("Couldn't construct message: %v", err)
	}
	log.Printf("Dialing: %v", nlmsg)
	nlsock, err := netlink.Dial(netlink.NETLINK_ROUTE)
	if err != nil {
		log.Exitf("Couldn't dial netlink: %v", err)
	}
	h := netlink.NewHandler(nlsock)
	ec := make(chan os.Error)
	go logec(ec)
	go h.Start(ec)
	log.Printf("Sending query: %v", nlmsg)
	c, err := h.Query(*nlmsg, 1, 4)
	log.Printf("Sent query: %v", nlmsg.Header)
	if err != nil {
		log.Exitf("Couldn't write netlink: %v", err)
	}
	for i := range c {
		if i.Header.MessageType() == netlink.NLMSG_DONE {
			break
		}
		switch i.Header.MessageType() {
		case rtnetlink.RTM_NEWADDR:
			hdr := &addr.Header{}
			msg := rtnetlink.NewMessage(hdr, nil)
			err = msg.UnmarshalNetlink(i.Body, 4)
			if err == nil {
				log.Printf("Family: %v; Length: %d; Flags: %v; Scope: %v; IFIndex: %d",
					hdr.AddressFamily(), hdr.PrefixLength(), hdr.Flags(), hdr.Scope(),
					hdr.InterfaceIndex())

				for i := range msg.Attributes {
					log.Printf("Attribute[%d] = %v", i, msg.Attributes[i])
				}
			} else {
				log.Printf("Unmarshal error: %v", err)
			}
		default:
			log.Printf("Unknown type: %v", i)
		}
		if err != nil {
			log.Printf("Handler error: %v", err)
		}
	}
}
Esempio n. 4
0
func main() {
	rtmsg := route.NewHeader(0, 0, 0, 0, 0, 0, 0, 0, 0)
	nlmsg, err := netlink.NewMessage(rtnetlink.RTM_GETROUTE, netlink.NLM_F_DUMP|netlink.NLM_F_REQUEST, rtmsg, 2)
	if err != nil {
		log.Fatalf("Couldn't construct message: %v", err)
	}
	nlsock, err := netlink.Dial(netlink.NETLINK_ROUTE)
	if err != nil {
		log.Fatalf("Couldn't dial netlink: %v", err)
	}
	h := netlink.NewHandler(nlsock)
	ec := make(chan error)
	go h.Start(ec)
	c, err := h.Query(*nlmsg, 1, 4)
	if err != nil {
		log.Fatalf("Couldn't write netlink: %v", err)
	}
	for i := range c {
		if i.Header.MessageType() == netlink.NLMSG_DONE {
			break
		}
		switch i.Header.MessageType() {
		case rtnetlink.RTM_NEWROUTE:
			hdr := &route.Header{}
			msg := rtnetlink.NewMessage(hdr, nil)
			err = msg.UnmarshalNetlink(i.Body, 4)

			if err == nil {
				log.Printf("Route: %v (%d/%d) TOS: %d; (Table: %v; Origin: %v; Scope: %v; Type: %v; Flags: %v",
					hdr.AddressFamily(), hdr.AddressDestLength(), hdr.AddressSourceLength(),
					hdr.TOS(), hdr.RoutingTable(), hdr.RouteOrigin(), hdr.AddressScope(),
					hdr.RouteType(), hdr.Flags())
				for i := range msg.Attributes {
					log.Printf("Attribute[%d]: %v", i, msg.Attributes[i])
				}
			} else {
				log.Printf("Unmarshal error: %v", err)
			}
		default:
			log.Printf("Unknown type: %v", i)
		}
	}
}
Esempio n. 5
0
func main() {
	nlmsg, err := netlink.NewMessage(rtnetlink.RTM_GETLINK, netlink.NLM_F_DUMP|netlink.NLM_F_REQUEST, &link.Header{}, 4)
	if err != nil {
		log.Exitf("Couldn't construct message: %v", err)
	}
	nlsock, err := netlink.Dial(netlink.NETLINK_ROUTE)
	if err != nil {
		log.Exitf("Couldn't dial netlink: %v", err)
	}
	h := netlink.NewHandler(nlsock)
	ec := make(chan os.Error)
	go h.Start(ec)
	c, err := h.Query(*nlmsg, 1, 4)
	if err != nil {
		log.Exitf("Couldn't write netlink: %v", err)
	}
	for i := range c {
		if i.Header.MessageType() == netlink.NLMSG_DONE {
			break
		}
		switch i.Header.MessageType() {
		case rtnetlink.RTM_NEWLINK:
			hdr := &link.Header{}
			msg := rtnetlink.NewMessage(hdr, nil)
			err = msg.UnmarshalNetlink(i.Body, 4)
			if err == nil {
				log.Printf("Link[%d] (Family: %v; Type: %v; Flags: %v; Changes: %v)",
					hdr.InterfaceIndex(),
					hdr.InterfaceFamily(), hdr.InterfaceType(), hdr.Flags(),
					hdr.InterfaceChanges())
				for i := range msg.Attributes {
					log.Printf("Attribute[%d]: %v", i, msg.Attributes[i])
				}
			} else {
				log.Printf("Unmarshal error: %v", err)
			}
		default:
			log.Printf("Unknown type: %v", i)
		}
	}
}
Esempio n. 6
0
func (self *linkFinder) GetLinks() (lhs []*LinkHandler, err os.Error) {
	qry, err := netlink.NewMessage(rtnetlink.RTM_GETLINK, netlink.NLM_F_REQUEST|netlink.NLM_F_ROOT,
		link.NewHeader(rtnetlink.AF_UNSPEC, 0, 0, 0, 0), 4)
	if err != nil {
		return
	}
	var mch chan netlink.Message
	mch, err = self.h.Query(*qry, 1, 4)
	if err == nil {
		for ii := range mch {
			if ii.Header.MessageType() == netlink.NLMSG_DONE {
				break
			}
			switch ii.Header.MessageType() {
			default:
				err = os.NewError("Unknown message type in response to RTM_GETLINK")
			case netlink.NLMSG_ERROR:
				emsg := &netlink.Error{}
				err = emsg.UnmarshalNetlink(ii.Body, 4)
				if err == nil && emsg.Code() != 0 {
					err = emsg
				}
			case rtnetlink.RTM_NEWLINK:
				lhdr := &link.Header{}
				msg := &rtnetlink.Message{Header: lhdr}
				err = msg.UnmarshalNetlink(ii.Body, 4)
				if err == nil {
					lhs = append(lhs, &LinkHandler{h: self.h, cache: msg})
				}
			}
			if err != nil {
				log.Printf("Internal netlink failure: %v", err)
			}
		}
	}
	close(mch)
	return
}