Example #1
0
func dhcpSetup(cfg *Config) chan error {
	cfg.db.InitDHCP()
	exit := make(chan error, 1)
	go func() {
		d := &DHCPService{
			ip:            cfg.DHCPIP(),
			leaseDuration: cfg.DHCPLeaseDuration(),
			db:            cfg.db,
			subnet:        cfg.Subnet(),
			guestPool:     cfg.DHCPSubnet(),
			domain:        cfg.Domain(),
			defaultOptions: dhcp4.Options{
				dhcp4.OptionSubnetMask:       net.IP(cfg.Subnet().Mask),
				dhcp4.OptionRouter:           cfg.Gateway(),
				dhcp4.OptionDomainNameServer: cfg.DHCPIP(),
			},
		}
		dhcpTFTP := cfg.DHCPTFTP()
		if dhcpTFTP != "" {
			d.defaultOptions[dhcp4.OptionTFTPServerName] = []byte(dhcpTFTP)
		}
		exit <- dhcp4.ListenAndServeIf(cfg.DHCPNIC(), d)
	}()
	return exit
}
Example #2
0
File: dhcpd.go Project: erikh/dhcpd
func main() {
	if len(os.Args) != 2 {
		panic("not enough args")
	}

	intf, err := net.InterfaceByName(os.Args[1])
	if err != nil {
		panic(err)
	}

	addrs, err := intf.Addrs()
	if err != nil {
		panic(err)
	}

	if len(addrs) == 0 {
		panic("no addresses on interface")
	}

	myIP, _, _ := net.ParseCIDR(addrs[0].String())

	dhcpHandler := &DHCPHandler{
		myIP:           myIP,
		leases:         make(map[string]net.IP),
		allocator:      net.IPNet{IP: net.IPv4(172, 16, 55, 0), Mask: net.CIDRMask(24, 32)},
		allocatorMutex: new(sync.Mutex),
	}

	handler := &HTTPHandler{dhcpHandler}

	go dhcp.ListenAndServeIf(os.Args[1], dhcpHandler)
	http.ListenAndServe(":8080", handler)
}
Example #3
0
// StartDHCP ListenAndServe for dhcp on port 67, binds on interface=ifName if it's
// not empty
func StartDHCP(ifName string, serverIP net.IP, datasource datasource.DataSource) error {
	handler := &Handler{
		ifName:      ifName,
		serverIP:    serverIP,
		datasource:  datasource,
		bootMessage: fmt.Sprintf("Blacksmith (%s)", datasource.SelfInfo().Version),
	}

	log.WithFields(log.Fields{
		"where":  "dhcp.StartDHCP",
		"action": "announce",
	}).Infof("Listening on %s:67 (interface: %s)", serverIP.String(), ifName)

	var err error
	if ifName != "" {
		err = dhcp4.ListenAndServeIf(ifName, handler)
	} else {
		err = dhcp4.ListenAndServe(handler)
	}

	// https://groups.google.com/forum/#!topic/coreos-user/Qbn3OdVtrZU
	if len(datasource.ClusterName()) > 50 { // 63 - 12(mac) - 1(.)
		log.WithField("where", "dhcp.StartDHCP").Warn(
			"Warning: ClusterName is too long. It may break the behaviour of the DHCP clients")
	}

	rand.Seed(time.Now().UTC().UnixNano())

	return err
}
Example #4
0
func RunDhcpHandler(dhcpInfo *DataTracker, intf net.Interface, myIp string) {
	log.Println("Starting on interface: ", intf.Name, " with server ip: ", myIp)

	serverIP, _, _ := net.ParseCIDR(myIp)
	serverIP = serverIP.To4()
	handler := &DHCPHandler{
		ip:   serverIP,
		intf: intf,
		info: dhcpInfo,
	}
	log.Fatal(dhcp.ListenAndServeIf(intf.Name, handler))
}
Example #5
0
func dhcpServer(c *Config, l *Store) {
	handler := &DHCPHandler{
		ip:            c.BaseIP,
		config:        c,
		leaseDuration: 24 * time.Hour,
		leaseRange:    50,
		leases:        l,
		options: dhcp.Options{
			dhcp.OptionSubnetMask:       []byte(c.Subnet.To4()),
			dhcp.OptionBootFileName:     []byte("undionly.kpxe"),
			dhcp.OptionRouter:           []byte(c.Gateway.To4()),
			dhcp.OptionDomainNameServer: []byte(c.DNSServer.To4()),
		},
	}
	logger.Error("%v", dhcp.ListenAndServeIf(c.Interf, handler))
}
Example #6
0
func ServeDHCP(settings *DHCPSetting, leasePool *LeasePool) error {
	handler, err := newDHCPHandler(settings, leasePool)
	if err != nil {
		logging.Debug("DHCP", "Error in connecting etcd - %s", err.Error())
		return err
	}
	logging.Log("DHCP", "Listening on :67 - with server IP %s", settings.ServerIP.String())
	if settings.IFName != "" {
		err = dhcp4.ListenAndServeIf(settings.IFName, handler)
	} else {
		err = dhcp4.ListenAndServe(handler)
	}
	if err != nil {
		logging.Debug("DHCP", "Error in server - %s", err.Error())
	}
	return err
}
Example #7
0
func ServeDHCP(settings *DHCPSetting, datasource datasource.DataSource) error {
	handler, err := newDHCPHandler(settings, datasource)
	if err != nil {
		logging.Debug("DHCP", "Error in connecting etcd - %s", err.Error())
		return err
	}
	logging.Log("DHCP", "Listening on %s:67 (interface: %s)",
		settings.ServerIP.String(), settings.IFName)
	if settings.IFName != "" {
		err = dhcp4.ListenAndServeIf(settings.IFName, handler)
	} else {
		err = dhcp4.ListenAndServe(handler)
	}
	if err != nil {
		logging.Debug("DHCP", "Error in server - %s", err.Error())
	}

	rand.Seed(time.Now().UTC().UnixNano())

	return err
}