_insomniak_dhcp_golang.md

test

bindtodevice_darwin.go

// +build darwin solaris

package interfaces

import (
	"fmt"
	"net"

	"golang.org/x/sys/unix"
)

var IsIPV6 = false

func BindToInterface(fd int, ifname string) error {
	iface, err := net.InterfaceByName(ifname)
	if err != nil {
		return err
	}

	if !IsIPV6 {
		if err := unix.SetsockoptInt(fd, unix.IPPROTO_IP, unix.IP_RECVIF, iface.Index); err != nil {
			return fmt.Errorf("ipv4: Could not bind to an interface (receive path): %w", err)
		}

		if err := unix.SetsockoptInt(fd, unix.IPPROTO_IP, unix.IP_BOUND_IF, iface.Index); err != nil {
			return fmt.Errorf("ipv4: Could not bind to an interface (send path): %w", err)
		}
		return nil
	} else {
		if err := unix.SetsockoptInt(fd, unix.IPPROTO_IPV6, unix.IP_RECVIF, iface.Index); err != nil {
			return fmt.Errorf("ipv6: Could not bind to an interface (receive path): %w", err)
		}

		if err := unix.SetsockoptInt(fd, unix.IPPROTO_IPV6, unix.IPV6_BOUND_IF, iface.Index); err != nil {
			return fmt.Errorf("ipv6: Could not bind to an interface (send path): %w", err)
		}
		return err
	}
}

server.go

package main

import (
	"log"
	"net"

	"github.com/insomniacslk/dhcp/interfaces"

	"github.com/insomniacslk/dhcp/dhcpv4"
	"github.com/insomniacslk/dhcp/dhcpv4/server4"
	"github.com/insomniacslk/dhcp/dhcpv6"
	"github.com/insomniacslk/dhcp/dhcpv6/server6"
)

const _interface = "en8"

func handler4(conn net.PacketConn, peer net.Addr, m *dhcpv4.DHCPv4) {
	log.Println("CONNECTION: ", peer.String(), m.MessageType().String())

	// clientIP, clientNet, _ := net.ParseCIDR("10.233.0.10/24")
	// gatewayIP := net.ParseIP("10.233.0.1")

	// reply, err := dhcpv4.NewReplyFromRequest(m)
	// if err != nil {
	// 	log.Println(err)
	// 	return
	// }

	// switch m.MessageType() {
	// case dhcpv4.MessageTypeDiscover:
	// 	reply.UpdateOption(dhcpv4.OptMessageType(dhcpv4.MessageTypeOffer))
	// case dhcpv4.MessageTypeRequest:
	// 	reply.UpdateOption(dhcpv4.OptMessageType(dhcpv4.MessageTypeAck))
	// }

	// reply.YourIPAddr = clientIP
	// reply.ServerIPAddr = gatewayIP

	// reply.UpdateOption(dhcpv4.OptServerIdentifier(gatewayIP))
	// reply.UpdateOption(dhcpv4.OptRouter(gatewayIP))
	// reply.UpdateOption(dhcpv4.OptSubnetMask(clientNet.Mask))

	// _, err = conn.WriteTo(reply.ToBytes(), peer)
	// log.Println(peer.String(), reply.Summary())
	// fmt.Println(err)
}

func handler6(conn net.PacketConn, peer net.Addr, m dhcpv6.DHCPv6) {
	log.Println("CONNECTION: ", peer.String(), m.Type().String())
}

func main() {
	interfaces.IsIPV6 = false

	if interfaces.IsIPV6 {
		laddr := &net.UDPAddr{
			IP:   net.ParseIP("::0"),
			Port: dhcpv6.DefaultServerPort,
		}
		server, err := server6.NewServer(_interface, laddr, handler6)
		if err != nil {
			log.Fatal(err)
		}

		log.Println("Serving IPV6")
		server.Serve()
	} else {
		laddr := &net.UDPAddr{
			IP:   net.ParseIP("0.0.0.0"),
			Port: dhcpv4.ServerPort,
		}
		server, err := server4.NewServer(_interface, laddr, handler4)
		if err != nil {
			log.Fatal(err)
		}

		log.Println("Serving IPV4")
		server.Serve()
	}
}