add all files from Hong
This commit is contained in:
zhangsz
241
server/handle.go
Normal file
241
server/handle.go
Normal file
@@ -0,0 +1,241 @@
|
||||
// Copyright 2018-present the CoreDHCP Authors. All rights reserved
|
||||
// This source code is licensed under the MIT license found in the
|
||||
// LICENSE file in the root directory of this source tree.
|
||||
|
||||
package server
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"net"
|
||||
"sync"
|
||||
|
||||
"golang.org/x/net/ipv4"
|
||||
"golang.org/x/net/ipv6"
|
||||
|
||||
"github.com/insomniacslk/dhcp/dhcpv4"
|
||||
"github.com/insomniacslk/dhcp/dhcpv6"
|
||||
)
|
||||
|
||||
// HandleMsg6 runs for every received DHCPv6 packet. It will run every
|
||||
// registered handler in sequence, and reply with the resulting response.
|
||||
// It will not reply if the resulting response is `nil`.
|
||||
func (l *listener6) HandleMsg6(buf []byte, oob *ipv6.ControlMessage, peer *net.UDPAddr) {
|
||||
d, err := dhcpv6.FromBytes(buf)
|
||||
bufpool.Put(&buf)
|
||||
if err != nil {
|
||||
log.Printf("Error parsing DHCPv6 request: %v", err)
|
||||
return
|
||||
}
|
||||
|
||||
// decapsulate the relay message
|
||||
msg, err := d.GetInnerMessage()
|
||||
if err != nil {
|
||||
log.Warningf("DHCPv6: cannot get inner message: %v", err)
|
||||
return
|
||||
}
|
||||
|
||||
// Create a suitable basic response packet
|
||||
var resp dhcpv6.DHCPv6
|
||||
switch msg.Type() {
|
||||
case dhcpv6.MessageTypeSolicit:
|
||||
if msg.GetOneOption(dhcpv6.OptionRapidCommit) != nil {
|
||||
resp, err = dhcpv6.NewReplyFromMessage(msg)
|
||||
} else {
|
||||
resp, err = dhcpv6.NewAdvertiseFromSolicit(msg)
|
||||
}
|
||||
case dhcpv6.MessageTypeRequest, dhcpv6.MessageTypeConfirm, dhcpv6.MessageTypeRenew,
|
||||
dhcpv6.MessageTypeRebind, dhcpv6.MessageTypeRelease, dhcpv6.MessageTypeInformationRequest:
|
||||
resp, err = dhcpv6.NewReplyFromMessage(msg)
|
||||
default:
|
||||
err = fmt.Errorf("MainHandler6: message type %d not supported", msg.Type())
|
||||
}
|
||||
if err != nil {
|
||||
log.Printf("MainHandler6: NewReplyFromDHCPv6Message failed: %v", err)
|
||||
return
|
||||
}
|
||||
|
||||
var stop bool
|
||||
for _, handler := range l.handlers {
|
||||
resp, stop = handler(d, resp)
|
||||
if stop {
|
||||
break
|
||||
}
|
||||
}
|
||||
if resp == nil {
|
||||
log.Print("MainHandler6: dropping request because response is nil")
|
||||
return
|
||||
}
|
||||
|
||||
// if the request was relayed, re-encapsulate the response
|
||||
if d.IsRelay() {
|
||||
if rmsg, ok := resp.(*dhcpv6.Message); !ok {
|
||||
log.Warningf("DHCPv6: response is a relayed message, not reencapsulating")
|
||||
} else {
|
||||
tmp, err := dhcpv6.NewRelayReplFromRelayForw(d.(*dhcpv6.RelayMessage), rmsg)
|
||||
if err != nil {
|
||||
log.Warningf("DHCPv6: cannot create relay-repl from relay-forw: %v", err)
|
||||
return
|
||||
}
|
||||
resp = tmp
|
||||
}
|
||||
}
|
||||
|
||||
var woob *ipv6.ControlMessage
|
||||
if peer.IP.IsLinkLocalUnicast() {
|
||||
// LL need to be directed to the correct interface. Globally reachable
|
||||
// addresses should use the default route, in case of asymetric routing.
|
||||
switch {
|
||||
case l.Interface.Index != 0:
|
||||
woob = &ipv6.ControlMessage{IfIndex: l.Interface.Index}
|
||||
case oob != nil && oob.IfIndex != 0:
|
||||
woob = &ipv6.ControlMessage{IfIndex: oob.IfIndex}
|
||||
default:
|
||||
log.Errorf("HandleMsg6: Did not receive interface information")
|
||||
}
|
||||
}
|
||||
if _, err := l.WriteTo(resp.ToBytes(), woob, peer); err != nil {
|
||||
log.Printf("MainHandler6: conn.Write to %v failed: %v", peer, err)
|
||||
}
|
||||
}
|
||||
|
||||
func (l *listener4) HandleMsg4(buf []byte, oob *ipv4.ControlMessage, _peer net.Addr) {
|
||||
var (
|
||||
resp, tmp *dhcpv4.DHCPv4
|
||||
err error
|
||||
stop bool
|
||||
)
|
||||
|
||||
req, err := dhcpv4.FromBytes(buf)
|
||||
bufpool.Put(&buf)
|
||||
if err != nil {
|
||||
log.Printf("Error parsing DHCPv4 request: %v", err)
|
||||
return
|
||||
}
|
||||
|
||||
if req.OpCode != dhcpv4.OpcodeBootRequest {
|
||||
log.Printf("MainHandler4: unsupported opcode %d. Only BootRequest (%d) is supported", req.OpCode, dhcpv4.OpcodeBootRequest)
|
||||
return
|
||||
}
|
||||
tmp, err = dhcpv4.NewReplyFromRequest(req)
|
||||
if err != nil {
|
||||
log.Printf("MainHandler4: failed to build reply: %v", err)
|
||||
return
|
||||
}
|
||||
switch mt := req.MessageType(); mt {
|
||||
case dhcpv4.MessageTypeDiscover:
|
||||
tmp.UpdateOption(dhcpv4.OptMessageType(dhcpv4.MessageTypeOffer))
|
||||
case dhcpv4.MessageTypeRequest:
|
||||
tmp.UpdateOption(dhcpv4.OptMessageType(dhcpv4.MessageTypeAck))
|
||||
default:
|
||||
log.Printf("plugins/server: Unhandled message type: %v", mt)
|
||||
return
|
||||
}
|
||||
|
||||
resp = tmp
|
||||
for _, handler := range l.handlers {
|
||||
resp, stop = handler(req, resp)
|
||||
if stop {
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
if resp != nil {
|
||||
useEthernet := false
|
||||
var peer *net.UDPAddr
|
||||
if !req.GatewayIPAddr.IsUnspecified() {
|
||||
// TODO: make RFC8357 compliant
|
||||
peer = &net.UDPAddr{IP: req.GatewayIPAddr, Port: dhcpv4.ServerPort}
|
||||
} else if resp.MessageType() == dhcpv4.MessageTypeNak {
|
||||
peer = &net.UDPAddr{IP: net.IPv4bcast, Port: dhcpv4.ClientPort}
|
||||
} else if !req.ClientIPAddr.IsUnspecified() {
|
||||
peer = &net.UDPAddr{IP: req.ClientIPAddr, Port: dhcpv4.ClientPort}
|
||||
} else if req.IsBroadcast() {
|
||||
peer = &net.UDPAddr{IP: net.IPv4bcast, Port: dhcpv4.ClientPort}
|
||||
} else {
|
||||
//sends a layer2 frame so that we can define the destination MAC address
|
||||
peer = &net.UDPAddr{IP: resp.YourIPAddr, Port: dhcpv4.ClientPort}
|
||||
useEthernet = true
|
||||
}
|
||||
|
||||
var woob *ipv4.ControlMessage
|
||||
if peer.IP.Equal(net.IPv4bcast) || peer.IP.IsLinkLocalUnicast() || useEthernet {
|
||||
// Direct broadcasts, link-local and layer2 unicasts to the interface the request was
|
||||
// received on. Other packets should use the normal routing table in
|
||||
// case of asymetric routing
|
||||
switch {
|
||||
case l.Interface.Index != 0:
|
||||
woob = &ipv4.ControlMessage{IfIndex: l.Interface.Index}
|
||||
case oob != nil && oob.IfIndex != 0:
|
||||
woob = &ipv4.ControlMessage{IfIndex: oob.IfIndex}
|
||||
default:
|
||||
log.Errorf("HandleMsg4: Did not receive interface information")
|
||||
}
|
||||
}
|
||||
|
||||
if useEthernet {
|
||||
intf, err := net.InterfaceByIndex(woob.IfIndex)
|
||||
if err != nil {
|
||||
log.Errorf("MainHandler4: Can not get Interface for index %d %v", woob.IfIndex, err)
|
||||
return
|
||||
}
|
||||
err = sendEthernet(*intf, resp)
|
||||
if err != nil {
|
||||
log.Errorf("MainHandler4: Cannot send Ethernet packet: %v", err)
|
||||
}
|
||||
} else {
|
||||
if _, err := l.WriteTo(resp.ToBytes(), woob, peer); err != nil {
|
||||
log.Errorf("MainHandler4: conn.Write to %v failed: %v", peer, err)
|
||||
}
|
||||
}
|
||||
} else {
|
||||
log.Print("MainHandler4: dropping request because response is nil")
|
||||
}
|
||||
}
|
||||
|
||||
// XXX: performance-wise, Pool may or may not be good (see https://github.com/golang/go/issues/23199)
|
||||
// Interface is good for what we want. Maybe "just" trust the GC and we'll be fine ?
|
||||
var bufpool = sync.Pool{New: func() interface{} { r := make([]byte, MaxDatagram); return &r }}
|
||||
|
||||
// MaxDatagram is the maximum length of message that can be received.
|
||||
const MaxDatagram = 1 << 16
|
||||
|
||||
// XXX: investigate using RecvMsgs to batch messages and reduce syscalls
|
||||
|
||||
// Serve6 handles datagrams received on conn and passes them to the pluginchain
|
||||
func (l *listener6) Serve() error {
|
||||
log.Printf("Listen %s", l.LocalAddr())
|
||||
for {
|
||||
b := *bufpool.Get().(*[]byte)
|
||||
b = b[:MaxDatagram] //Reslice to max capacity in case the buffer in pool was resliced smaller
|
||||
|
||||
n, oob, peer, err := l.ReadFrom(b)
|
||||
if errors.Is(err, net.ErrClosed) {
|
||||
// Server is quitting
|
||||
return nil
|
||||
} else if err != nil {
|
||||
log.Printf("Error reading from connection: %v", err)
|
||||
return err
|
||||
}
|
||||
go l.HandleMsg6(b[:n], oob, peer.(*net.UDPAddr))
|
||||
}
|
||||
}
|
||||
|
||||
// Serve6 handles datagrams received on conn and passes them to the pluginchain
|
||||
func (l *listener4) Serve() error {
|
||||
log.Printf("Listen %s", l.LocalAddr())
|
||||
for {
|
||||
b := *bufpool.Get().(*[]byte)
|
||||
b = b[:MaxDatagram] //Reslice to max capacity in case the buffer in pool was resliced smaller
|
||||
|
||||
n, oob, peer, err := l.ReadFrom(b)
|
||||
if errors.Is(err, net.ErrClosed) {
|
||||
// Server is quitting
|
||||
return nil
|
||||
} else if err != nil {
|
||||
log.Printf("Error reading from connection: %v", err)
|
||||
return err
|
||||
}
|
||||
go l.HandleMsg4(b[:n], oob, peer.(*net.UDPAddr))
|
||||
}
|
||||
}
|
||||
96
server/sendEthernet.go
Normal file
96
server/sendEthernet.go
Normal file
@@ -0,0 +1,96 @@
|
||||
// Copyright 2018-present the CoreDHCP Authors. All rights reserved
|
||||
// This source code is licensed under the MIT license found in the
|
||||
// LICENSE file in the root directory of this source tree.
|
||||
|
||||
// +build linux
|
||||
|
||||
package server
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"net"
|
||||
"syscall"
|
||||
|
||||
"github.com/google/gopacket"
|
||||
"github.com/google/gopacket/layers"
|
||||
"github.com/insomniacslk/dhcp/dhcpv4"
|
||||
)
|
||||
|
||||
//this function sends an unicast to the hardware address defined in resp.ClientHWAddr,
|
||||
//the layer3 destination address is still the broadcast address;
|
||||
//iface: the interface where the DHCP message should be sent;
|
||||
//resp: DHCPv4 struct, which should be sent;
|
||||
func sendEthernet(iface net.Interface, resp *dhcpv4.DHCPv4) error {
|
||||
|
||||
eth := layers.Ethernet{
|
||||
EthernetType: layers.EthernetTypeIPv4,
|
||||
SrcMAC: iface.HardwareAddr,
|
||||
DstMAC: resp.ClientHWAddr,
|
||||
}
|
||||
ip := layers.IPv4{
|
||||
Version: 4,
|
||||
TTL: 64,
|
||||
SrcIP: resp.ServerIPAddr,
|
||||
DstIP: resp.YourIPAddr,
|
||||
Protocol: layers.IPProtocolUDP,
|
||||
Flags: layers.IPv4DontFragment,
|
||||
}
|
||||
udp := layers.UDP{
|
||||
SrcPort: dhcpv4.ServerPort,
|
||||
DstPort: dhcpv4.ClientPort,
|
||||
}
|
||||
|
||||
err := udp.SetNetworkLayerForChecksum(&ip)
|
||||
if err != nil {
|
||||
return fmt.Errorf("Send Ethernet: Couldn't set network layer: %v", err)
|
||||
}
|
||||
|
||||
buf := gopacket.NewSerializeBuffer()
|
||||
opts := gopacket.SerializeOptions{
|
||||
ComputeChecksums: true,
|
||||
FixLengths: true,
|
||||
}
|
||||
|
||||
// Decode a packet
|
||||
packet := gopacket.NewPacket(resp.ToBytes(), layers.LayerTypeDHCPv4, gopacket.NoCopy)
|
||||
dhcpLayer := packet.Layer(layers.LayerTypeDHCPv4)
|
||||
dhcp, ok := dhcpLayer.(gopacket.SerializableLayer)
|
||||
if !ok {
|
||||
return fmt.Errorf("Layer %s is not serializable", dhcpLayer.LayerType().String())
|
||||
}
|
||||
err = gopacket.SerializeLayers(buf, opts, ð, &ip, &udp, dhcp)
|
||||
if err != nil {
|
||||
return fmt.Errorf("Cannot serialize layer: %v", err)
|
||||
}
|
||||
data := buf.Bytes()
|
||||
|
||||
fd, err := syscall.Socket(syscall.AF_PACKET, syscall.SOCK_RAW, 0)
|
||||
if err != nil {
|
||||
return fmt.Errorf("Send Ethernet: Cannot open socket: %v", err)
|
||||
}
|
||||
defer func() {
|
||||
err = syscall.Close(fd)
|
||||
if err != nil {
|
||||
log.Errorf("Send Ethernet: Cannot close socket: %v", err)
|
||||
}
|
||||
}()
|
||||
|
||||
err = syscall.SetsockoptInt(fd, syscall.SOL_SOCKET, syscall.SO_REUSEADDR, 1)
|
||||
if err != nil {
|
||||
log.Errorf("Send Ethernet: Cannot set option for socket: %v", err)
|
||||
}
|
||||
|
||||
var hwAddr [8]byte
|
||||
copy(hwAddr[0:6], resp.ClientHWAddr[0:6])
|
||||
ethAddr := syscall.SockaddrLinklayer{
|
||||
Protocol: 0,
|
||||
Ifindex: iface.Index,
|
||||
Halen: 6,
|
||||
Addr: hwAddr, //not used
|
||||
}
|
||||
err = syscall.Sendto(fd, data, 0, ðAddr)
|
||||
if err != nil {
|
||||
return fmt.Errorf("Cannot send frame via socket: %v", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
185
server/serve.go
Normal file
185
server/serve.go
Normal file
@@ -0,0 +1,185 @@
|
||||
// Copyright 2018-present the CoreDHCP Authors. All rights reserved
|
||||
// This source code is licensed under the MIT license found in the
|
||||
// LICENSE file in the root directory of this source tree.
|
||||
|
||||
package server
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"net"
|
||||
|
||||
"golang.org/x/net/ipv4"
|
||||
"golang.org/x/net/ipv6"
|
||||
|
||||
"github.com/coredhcp/coredhcp/config"
|
||||
"github.com/coredhcp/coredhcp/handler"
|
||||
"github.com/coredhcp/coredhcp/logger"
|
||||
"github.com/coredhcp/coredhcp/plugins"
|
||||
"github.com/insomniacslk/dhcp/dhcpv4/server4"
|
||||
"github.com/insomniacslk/dhcp/dhcpv6/server6"
|
||||
)
|
||||
|
||||
var log = logger.GetLogger("server")
|
||||
|
||||
type listener6 struct {
|
||||
*ipv6.PacketConn
|
||||
net.Interface
|
||||
handlers []handler.Handler6
|
||||
}
|
||||
|
||||
type listener4 struct {
|
||||
*ipv4.PacketConn
|
||||
net.Interface
|
||||
handlers []handler.Handler4
|
||||
}
|
||||
|
||||
type listener interface {
|
||||
io.Closer
|
||||
}
|
||||
|
||||
// Servers contains state for a running server (with possibly multiple interfaces/listeners)
|
||||
type Servers struct {
|
||||
listeners []listener
|
||||
errors chan error
|
||||
}
|
||||
|
||||
func listen4(a *net.UDPAddr) (*listener4, error) {
|
||||
var err error
|
||||
l4 := listener4{}
|
||||
udpConn, err := server4.NewIPv4UDPConn(a.Zone, a)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
l4.PacketConn = ipv4.NewPacketConn(udpConn)
|
||||
var ifi *net.Interface
|
||||
if a.Zone != "" {
|
||||
ifi, err = net.InterfaceByName(a.Zone)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("DHCPv4: Listen could not find interface %s: %v", a.Zone, err)
|
||||
}
|
||||
l4.Interface = *ifi
|
||||
} else {
|
||||
|
||||
// When not bound to an interface, we need the information in each
|
||||
// packet to know which interface it came on
|
||||
err = l4.SetControlMessage(ipv4.FlagInterface, true)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
|
||||
if a.IP.IsMulticast() {
|
||||
err = l4.JoinGroup(ifi, a)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
return &l4, nil
|
||||
}
|
||||
|
||||
func listen6(a *net.UDPAddr) (*listener6, error) {
|
||||
l6 := listener6{}
|
||||
udpconn, err := server6.NewIPv6UDPConn(a.Zone, a)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
l6.PacketConn = ipv6.NewPacketConn(udpconn)
|
||||
var ifi *net.Interface
|
||||
if a.Zone != "" {
|
||||
ifi, err = net.InterfaceByName(a.Zone)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("DHCPv4: Listen could not find interface %s: %v", a.Zone, err)
|
||||
}
|
||||
l6.Interface = *ifi
|
||||
} else {
|
||||
// When not bound to an interface, we need the information in each
|
||||
// packet to know which interface it came on
|
||||
err = l6.SetControlMessage(ipv6.FlagInterface, true)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
|
||||
if a.IP.IsMulticast() {
|
||||
err = l6.JoinGroup(ifi, a)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
return &l6, nil
|
||||
}
|
||||
|
||||
// Start will start the server asynchronously. See `Wait` to wait until
|
||||
// the execution ends.
|
||||
func Start(config *config.Config) (*Servers, error) {
|
||||
handlers4, handlers6, err := plugins.LoadPlugins(config)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
srv := Servers{
|
||||
errors: make(chan error),
|
||||
}
|
||||
|
||||
// listen
|
||||
if config.Server6 != nil {
|
||||
log.Println("Starting DHCPv6 server")
|
||||
for _, addr := range config.Server6.Addresses {
|
||||
var l6 *listener6
|
||||
l6, err = listen6(&addr)
|
||||
if err != nil {
|
||||
goto cleanup
|
||||
}
|
||||
l6.handlers = handlers6
|
||||
srv.listeners = append(srv.listeners, l6)
|
||||
go func() {
|
||||
srv.errors <- l6.Serve()
|
||||
}()
|
||||
}
|
||||
}
|
||||
|
||||
if config.Server4 != nil {
|
||||
log.Println("Starting DHCPv4 server")
|
||||
for _, addr := range config.Server4.Addresses {
|
||||
var l4 *listener4
|
||||
l4, err = listen4(&addr)
|
||||
if err != nil {
|
||||
goto cleanup
|
||||
}
|
||||
l4.handlers = handlers4
|
||||
srv.listeners = append(srv.listeners, l4)
|
||||
go func() {
|
||||
srv.errors <- l4.Serve()
|
||||
}()
|
||||
}
|
||||
}
|
||||
|
||||
return &srv, nil
|
||||
|
||||
cleanup:
|
||||
srv.Close()
|
||||
return nil, err
|
||||
}
|
||||
|
||||
// Wait waits until the end of the execution of the server.
|
||||
func (s *Servers) Wait() error {
|
||||
log.Debug("Waiting")
|
||||
errs := make([]error, 1, len(s.listeners))
|
||||
errs[0] = <-s.errors
|
||||
s.Close()
|
||||
// Wait for the other listeners to close
|
||||
for i := 1; i < len(s.listeners); i++ {
|
||||
errs = append(errs, <-s.errors)
|
||||
}
|
||||
return errors.Join(errs...)
|
||||
}
|
||||
|
||||
// Close closes all listening connections
|
||||
func (s *Servers) Close() {
|
||||
for _, srv := range s.listeners {
|
||||
if srv != nil {
|
||||
srv.Close()
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user