From df53b9f0d410acb46c1c31d0c51409bfa964b8a2 Mon Sep 17 00:00:00 2001 From: David Scott Date: Mon, 20 Jun 2022 16:27:21 +0100 Subject: [PATCH] Add support for AF_UNIX SOCK_DGRAM Unfortunately these aren't supported by libuv directly, so we need to implement our own separate system. It doesn't need to be particularly scalable as the expected use-case is to send and receive ethernet frames. The server will listen on a Unix domain socket and receive connected SOCK_DGRAM sockets which will have ethernet frames on them. Signed-off-by: David Scott --- go/cmd/vmnet-example/main.go | 41 ++ go/pkg/vmnet/datagram.go | 50 ++ go/pkg/vmnet/dhcp.go | 114 ++++ go/pkg/vmnet/ethernet.go | 66 ++ go/pkg/vmnet/framing.go | 54 ++ go/pkg/vmnet/ipv4.go | 68 ++ go/pkg/vmnet/pcap.go | 83 +++ go/pkg/vmnet/protocol.go | 154 +++++ go/pkg/vmnet/sendreceiver.go | 9 + go/pkg/vmnet/socketpair.go | 34 + go/pkg/vmnet/udpv4.go | 65 ++ go/pkg/vmnet/vif.go | 166 +++++ go/pkg/vmnet/vmnet.go | 658 +++----------------- src/bin/bind.ml | 3 +- src/bin/main.ml | 40 +- src/fs9p/dune | 2 +- src/hostnet/constants.ml | 8 +- src/hostnet/dune | 2 +- src/hostnet/host.ml | 2 + src/hostnet/host_unix_dgram.ml | 400 ++++++++++++ src/hostnet/host_unix_dgram.mli | 8 + src/hostnet/hostnet_dhcp.ml | 1 + src/hostnet/hostnet_icmp.ml | 2 +- src/hostnet/sig.ml | 34 + src/hostnet/stubs_utils.c | 32 + src/hostnet/utils.ml | 9 + src/hostnet/utils.mli | 6 + src/hostnet/vmnet_dgram.ml | 415 ++++++++++++ src/hostnet/vmnet_dgram.mli | 52 ++ src/hostnet/vmnet_proto.ml | 183 ++++++ src/hostnet/vmnet_proto.mli | 45 ++ src/hostnet/{vmnet.ml => vmnet_stream.ml} | 185 +----- src/hostnet/{vmnet.mli => vmnet_stream.mli} | 25 - src/hostnet_test/slirp_stack.ml | 2 +- 34 files changed, 2237 insertions(+), 781 deletions(-) create mode 100644 go/cmd/vmnet-example/main.go create mode 100644 go/pkg/vmnet/datagram.go create mode 100644 go/pkg/vmnet/dhcp.go create mode 100644 go/pkg/vmnet/ethernet.go create mode 100644 go/pkg/vmnet/framing.go create mode 100644 go/pkg/vmnet/ipv4.go create mode 100644 go/pkg/vmnet/pcap.go create mode 100644 go/pkg/vmnet/protocol.go create mode 100644 go/pkg/vmnet/sendreceiver.go create mode 100644 go/pkg/vmnet/socketpair.go create mode 100644 go/pkg/vmnet/udpv4.go create mode 100644 go/pkg/vmnet/vif.go create mode 100644 src/hostnet/host_unix_dgram.ml create mode 100644 src/hostnet/host_unix_dgram.mli create mode 100644 src/hostnet/vmnet_dgram.ml create mode 100644 src/hostnet/vmnet_dgram.mli create mode 100644 src/hostnet/vmnet_proto.ml create mode 100644 src/hostnet/vmnet_proto.mli rename src/hostnet/{vmnet.ml => vmnet_stream.ml} (73%) rename src/hostnet/{vmnet.mli => vmnet_stream.mli} (77%) diff --git a/go/cmd/vmnet-example/main.go b/go/cmd/vmnet-example/main.go new file mode 100644 index 000000000..e339dbb70 --- /dev/null +++ b/go/cmd/vmnet-example/main.go @@ -0,0 +1,41 @@ +package main + +import ( + "context" + "flag" + "fmt" + "log" + "os" + + "github.com/google/uuid" + "github.com/moby/vpnkit/go/pkg/vmnet" +) + +var path string + +func main() { + flag.StringVar(&path, "path", "", "path to vmnet socket") + flag.Parse() + if path == "" { + fmt.Fprintf(os.Stderr, "Please supply a --path argument\n") + } + vm, err := vmnet.Connect(context.Background(), vmnet.Config{ + Path: path, + }) + if err != nil { + log.Fatal(err) + } + defer vm.Close() + log.Println("connected to vmnet service") + u, err := uuid.NewRandom() + if err != nil { + log.Fatal(err) + } + vif, err := vm.ConnectVif(u) + if err != nil { + log.Fatal(err) + } + defer vif.Close() + log.Printf("VIF has IP %s", vif.IP) + log.Printf("SOCK_DGRAM fd: %d", vif.Ethernet.Fd) +} diff --git a/go/pkg/vmnet/datagram.go b/go/pkg/vmnet/datagram.go new file mode 100644 index 000000000..c1307b051 --- /dev/null +++ b/go/pkg/vmnet/datagram.go @@ -0,0 +1,50 @@ +package vmnet + +/* +// FIXME: Needed because we call C.send. Perhaps we could use syscall instead? +#include +#include + +*/ +import "C" + +import ( + "syscall" + + "github.com/pkg/errors" +) + +// Datagram sends and receives ethernet frames via send/recv over a SOCK_DGRAM fd. +type Datagram struct { + Fd int // Underlying SOCK_DGRAM file descriptor. + pcap *PcapWriter +} + +func (e Datagram) Recv(buf []byte) (int, error) { + num, _, err := syscall.Recvfrom(e.Fd, buf, 0) + if e.pcap != nil { + if err := e.pcap.Write(buf[0:num]); err != nil { + return 0, errors.Wrap(err, "writing to pcap") + } + } + return num, err +} + +func (e Datagram) Send(packet []byte) (int, error) { + if e.pcap != nil { + if err := e.pcap.Write(packet); err != nil { + return 0, errors.Wrap(err, "writing to pcap") + } + } + result, err := C.send(C.int(e.Fd), C.CBytes(packet), C.size_t(len(packet)), 0) + if result == -1 { + return 0, err + } + return len(packet), nil +} + +func (e Datagram) Close() error { + return syscall.Close(e.Fd) +} + +var _ sendReceiver = Datagram{} diff --git a/go/pkg/vmnet/dhcp.go b/go/pkg/vmnet/dhcp.go new file mode 100644 index 000000000..62a40aa83 --- /dev/null +++ b/go/pkg/vmnet/dhcp.go @@ -0,0 +1,114 @@ +package vmnet + +import ( + "net" + "time" +) + +// dhcp queries the IP by DHCP +func dhcpRequest(packet sendReceiver, clientMAC net.HardwareAddr) (net.IP, error) { + broadcastMAC := []byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff} + broadcastIP := []byte{0xff, 0xff, 0xff, 0xff} + unknownIP := []byte{0, 0, 0, 0} + + dhcpRequest := NewDhcpRequest(clientMAC).Bytes() + ipv4 := NewIpv4(broadcastIP, unknownIP) + + udpv4 := NewUdpv4(ipv4, 68, 67, dhcpRequest) + ipv4.setData(udpv4.Bytes()) + + ethernet := NewEthernetFrame(broadcastMAC, clientMAC, 0x800) + ethernet.setData(ipv4.Bytes()) + finished := false + go func() { + for !finished { + if _, err := packet.Send(ethernet.Bytes()); err != nil { + panic(err) + } + time.Sleep(time.Second) + } + }() + + buf := make([]byte, 1500) + for { + n, err := packet.Recv(buf) + if err != nil { + return nil, err + } + response := buf[0:n] + ethernet, err = ParseEthernetFrame(response) + if err != nil { + continue + } + for i, x := range ethernet.Dst { + if i > len(clientMAC) || clientMAC[i] != x { + // intended for someone else + continue + } + } + ipv4, err = ParseIpv4(ethernet.Data) + if err != nil { + // probably not an IPv4 packet + continue + } + udpv4, err = ParseUdpv4(ipv4.Data) + if err != nil { + // probably not a UDPv4 packet + continue + } + if udpv4.Src != 67 || udpv4.Dst != 68 { + // not a DHCP response + continue + } + if len(udpv4.Data) < 243 { + // truncated + continue + } + if udpv4.Data[240] != 53 || udpv4.Data[241] != 1 || udpv4.Data[242] != 2 { + // not a DHCP offer + continue + } + var ip net.IP + ip = udpv4.Data[16:20] + finished = true // will terminate sending goroutine + return ip, nil + } +} + +// DhcpRequest is a simple DHCP request +type DhcpRequest struct { + MAC net.HardwareAddr +} + +// NewDhcpRequest constructs a DHCP request +func NewDhcpRequest(MAC net.HardwareAddr) *DhcpRequest { + if len(MAC) != 6 { + panic("MAC address must be 6 bytes") + } + return &DhcpRequest{MAC} +} + +// Bytes returns the marshalled DHCP request +func (d *DhcpRequest) Bytes() []byte { + bs := []byte{ + 0x01, // OP + 0x01, // HTYPE + 0x06, // HLEN + 0x00, // HOPS + 0x01, 0x00, 0x00, 0x00, // XID + 0x00, 0x00, // SECS + 0x80, 0x00, // FLAGS + 0x00, 0x00, 0x00, 0x00, // CIADDR + 0x00, 0x00, 0x00, 0x00, // YIADDR + 0x00, 0x00, 0x00, 0x00, // SIADDR + 0x00, 0x00, 0x00, 0x00, // GIADDR + d.MAC[0], d.MAC[1], d.MAC[2], d.MAC[3], d.MAC[4], d.MAC[5], + } + bs = append(bs, make([]byte, 202)...) + bs = append(bs, []byte{ + 0x63, 0x82, 0x53, 0x63, // Magic cookie + 0x35, 0x01, 0x01, // DHCP discover + 0xff, // Endmark + }...) + return bs +} diff --git a/go/pkg/vmnet/ethernet.go b/go/pkg/vmnet/ethernet.go new file mode 100644 index 000000000..cd82c8503 --- /dev/null +++ b/go/pkg/vmnet/ethernet.go @@ -0,0 +1,66 @@ +package vmnet + +import ( + "bytes" + "encoding/binary" + "io" + "net" + + "github.com/pkg/errors" +) + +// EthernetFrame is an ethernet frame +type EthernetFrame struct { + Dst net.HardwareAddr + Src net.HardwareAddr + Type uint16 + Data []byte +} + +// NewEthernetFrame constructs an Ethernet frame +func NewEthernetFrame(Dst, Src net.HardwareAddr, Type uint16) *EthernetFrame { + Data := make([]byte, 0) + return &EthernetFrame{Dst, Src, Type, Data} +} + +func (e *EthernetFrame) setData(data []byte) { + e.Data = data +} + +// Write marshals an Ethernet frame +func (e *EthernetFrame) Write(w io.Writer) error { + if err := binary.Write(w, binary.BigEndian, e.Dst); err != nil { + return err + } + if err := binary.Write(w, binary.BigEndian, e.Src); err != nil { + return err + } + if err := binary.Write(w, binary.BigEndian, e.Type); err != nil { + return err + } + if err := binary.Write(w, binary.BigEndian, e.Data); err != nil { + return err + } + return nil +} + +// ParseEthernetFrame parses the ethernet frame +func ParseEthernetFrame(frame []byte) (*EthernetFrame, error) { + if len(frame) < (6 + 6 + 2) { + return nil, errors.New("Ethernet frame is too small") + } + Dst := frame[0:6] + Src := frame[6:12] + Type := uint16(frame[12])<<8 + uint16(frame[13]) + Data := frame[14:] + return &EthernetFrame{Dst, Src, Type, Data}, nil +} + +// Bytes returns the marshalled ethernet frame +func (e *EthernetFrame) Bytes() []byte { + buf := bytes.NewBufferString("") + if err := e.Write(buf); err != nil { + panic(err) + } + return buf.Bytes() +} diff --git a/go/pkg/vmnet/framing.go b/go/pkg/vmnet/framing.go new file mode 100644 index 000000000..49a62aaae --- /dev/null +++ b/go/pkg/vmnet/framing.go @@ -0,0 +1,54 @@ +package vmnet + +import ( + "encoding/binary" + "io" +) + +// Messages sent to vpnkit can either be +// - fixed-size, no length prefix +// - variable-length, with a length prefix + +// fixedSizeSendReceiver sends and receives fixed-size control messages with no length prefix. +type fixedSizeSendReceiver struct { + rw io.ReadWriter +} + +var _ sendReceiver = fixedSizeSendReceiver{} + +func (f fixedSizeSendReceiver) Recv(buf []byte) (int, error) { + return io.ReadFull(f.rw, buf) +} + +func (f fixedSizeSendReceiver) Send(buf []byte) (int, error) { + return f.rw.Write(buf) +} + +// lengthPrefixer sends and receives variable-length control messages with a length prefix. +type lengthPrefixer struct { + rw io.ReadWriter +} + +var _ sendReceiver = lengthPrefixer{} + +func (e lengthPrefixer) Recv(buf []byte) (int, error) { + var len uint16 + if err := binary.Read(e.rw, binary.LittleEndian, &len); err != nil { + return 0, err + } + if err := binary.Read(e.rw, binary.LittleEndian, &buf); err != nil { + return 0, err + } + return int(len), nil +} + +func (e lengthPrefixer) Send(packet []byte) (int, error) { + len := uint16(len(packet)) + if err := binary.Write(e.rw, binary.LittleEndian, len); err != nil { + return 0, err + } + if err := binary.Write(e.rw, binary.LittleEndian, packet); err != nil { + return 0, err + } + return int(len), nil +} diff --git a/go/pkg/vmnet/ipv4.go b/go/pkg/vmnet/ipv4.go new file mode 100644 index 000000000..2acb1a627 --- /dev/null +++ b/go/pkg/vmnet/ipv4.go @@ -0,0 +1,68 @@ +package vmnet + +import ( + "net" + + "github.com/pkg/errors" +) + +// Ipv4 is an IPv4 frame +type Ipv4 struct { + Dst net.IP + Src net.IP + Data []byte + Checksum uint16 +} + +// NewIpv4 constructs a new empty IPv4 packet +func NewIpv4(Dst, Src net.IP) *Ipv4 { + Checksum := uint16(0) + Data := make([]byte, 0) + return &Ipv4{Dst, Src, Data, Checksum} +} + +// ParseIpv4 parses an IP packet +func ParseIpv4(packet []byte) (*Ipv4, error) { + if len(packet) < 20 { + return nil, errors.New("IPv4 packet too small") + } + ihl := int((packet[0] & 0xf) * 4) // in octets + if len(packet) < ihl { + return nil, errors.New("IPv4 packet too small") + } + Dst := packet[12:16] + Src := packet[16:20] + Data := packet[ihl:] + Checksum := uint16(0) // assume offload + return &Ipv4{Dst, Src, Data, Checksum}, nil +} + +func (i *Ipv4) setData(data []byte) { + i.Data = data + i.Checksum = uint16(0) // as if we were using offload +} + +// HeaderBytes returns the marshalled form of the IPv4 header +func (i *Ipv4) HeaderBytes() []byte { + len := len(i.Data) + 20 + length := [2]byte{byte(len >> 8), byte(len & 0xff)} + checksum := [2]byte{byte(i.Checksum >> 8), byte(i.Checksum & 0xff)} + return []byte{ + 0x45, // version + IHL + 0x00, // DSCP + ECN + length[0], length[1], // total length + 0x7f, 0x61, // Identification + 0x00, 0x00, // Flags + Fragment offset + 0x40, // TTL + 0x11, // Protocol + checksum[0], checksum[1], + 0x00, 0x00, 0x00, 0x00, // source + 0xff, 0xff, 0xff, 0xff, // destination + } +} + +// Bytes returns the marshalled IPv4 packet +func (i *Ipv4) Bytes() []byte { + header := i.HeaderBytes() + return append(header, i.Data...) +} diff --git a/go/pkg/vmnet/pcap.go b/go/pkg/vmnet/pcap.go new file mode 100644 index 000000000..682ff4ce6 --- /dev/null +++ b/go/pkg/vmnet/pcap.go @@ -0,0 +1,83 @@ +package vmnet + +import ( + "encoding/binary" + "io" + "sync" + "time" +) + +// PcapWriter writes pcap-formatted packet streams. The results can be analysed with tcpdump/wireshark. +type PcapWriter struct { + w io.Writer + snaplen uint32 + m sync.Mutex +} + +// NewPcapWriter creates a PcapWriter and writes the initial header +func NewPcapWriter(w io.Writer) (*PcapWriter, error) { + magic := uint32(0xa1b2c3d4) + major := uint16(2) + minor := uint16(4) + thiszone := uint32(0) // GMT to local correction + sigfigs := uint32(0) // accuracy of local timestamps + snaplen := uint32(1500) // max length of captured packets, in octets + network := uint32(1) // ethernet + if err := binary.Write(w, binary.LittleEndian, magic); err != nil { + return nil, err + } + if err := binary.Write(w, binary.LittleEndian, major); err != nil { + return nil, err + } + if err := binary.Write(w, binary.LittleEndian, minor); err != nil { + return nil, err + } + if err := binary.Write(w, binary.LittleEndian, thiszone); err != nil { + return nil, err + } + if err := binary.Write(w, binary.LittleEndian, sigfigs); err != nil { + return nil, err + } + if err := binary.Write(w, binary.LittleEndian, snaplen); err != nil { + return nil, err + } + if err := binary.Write(w, binary.LittleEndian, network); err != nil { + return nil, err + } + return &PcapWriter{ + w: w, + snaplen: snaplen, + }, nil +} + +// Write appends a packet with a pcap-format header +func (p *PcapWriter) Write(packet []byte) error { + p.m.Lock() + defer p.m.Unlock() + stamp := time.Now() + s := uint32(stamp.Second()) + us := uint32(stamp.Nanosecond() / 1000) + actualLen := uint32(len(packet)) + if err := binary.Write(p.w, binary.LittleEndian, s); err != nil { + return err + } + if err := binary.Write(p.w, binary.LittleEndian, us); err != nil { + return err + } + toWrite := packet[:] + if actualLen > p.snaplen { + toWrite = toWrite[0:p.snaplen] + } + caplen := uint32(len(toWrite)) + if err := binary.Write(p.w, binary.LittleEndian, caplen); err != nil { + return err + } + if err := binary.Write(p.w, binary.LittleEndian, actualLen); err != nil { + return err + } + + if err := binary.Write(p.w, binary.LittleEndian, toWrite); err != nil { + return err + } + return nil +} diff --git a/go/pkg/vmnet/protocol.go b/go/pkg/vmnet/protocol.go new file mode 100644 index 000000000..6827c1b34 --- /dev/null +++ b/go/pkg/vmnet/protocol.go @@ -0,0 +1,154 @@ +package vmnet + +import ( + "bytes" + "encoding/binary" + "fmt" + "log" + "net" + + "github.com/google/uuid" + "github.com/pkg/errors" +) + +// vpnkit internal protocol requests and responses + +func negotiate(sr sendReceiver) (*InitMessage, error) { + m := defaultInitMessage() + if err := m.Send(sr); err != nil { + return nil, err + } + return readInitMessage(sr) +} + +// InitMessage is used for the initial version exchange +type InitMessage struct { + magic [5]byte + version uint32 + commit [40]byte +} + +const sizeof_InitMessage = 5 + 4 + 40 + +// String returns a human-readable string. +func (m *InitMessage) String() string { + return fmt.Sprintf("magic=%v version=%d commit=%v", m.magic, m.version, m.commit) +} + +// defaultInitMessage is the init message we will send to vpnkit +func defaultInitMessage() *InitMessage { + magic := [5]byte{'V', 'M', 'N', '3', 'T'} + version := uint32(22) + var commit [40]byte + copy(commit[:], []byte("0123456789012345678901234567890123456789")) + return &InitMessage{magic, version, commit} +} + +// Write marshals an init message to a connection +func (m *InitMessage) Send(sr sendReceiver) error { + var buf bytes.Buffer + if err := binary.Write(&buf, binary.LittleEndian, m.magic); err != nil { + return err + } + if err := binary.Write(&buf, binary.LittleEndian, m.version); err != nil { + return err + } + if err := binary.Write(&buf, binary.LittleEndian, m.commit); err != nil { + return err + } + _, err := sr.Send(buf.Bytes()) + return err +} + +// readInitMessage unmarshals an init message from a connection +func readInitMessage(sr sendReceiver) (*InitMessage, error) { + m := defaultInitMessage() + bs := make([]byte, sizeof_InitMessage) + n, err := sr.Recv(bs) + if err != nil { + return nil, err + } + br := bytes.NewReader(bs[0:n]) + if err := binary.Read(br, binary.LittleEndian, &m.magic); err != nil { + return nil, err + } + if err := binary.Read(br, binary.LittleEndian, &m.version); err != nil { + return nil, err + } + log.Printf("version = %d", m.version) + if err := binary.Read(br, binary.LittleEndian, &m.commit); err != nil { + return nil, err + } + return m, nil +} + +// EthernetRequest requests the creation of a network connection with a given +// uuid and optional IP +type EthernetRequest struct { + uuid uuid.UUID + ip net.IP +} + +// NewEthernetRequest requests an Ethernet connection +func NewEthernetRequest(uuid uuid.UUID, ip net.IP) *EthernetRequest { + return &EthernetRequest{uuid, ip} +} + +// Write marshals an EthernetRequest message +func (m *EthernetRequest) Send(sr sendReceiver) error { + var buf bytes.Buffer + ty := uint8(1) + if m.ip != nil { + ty = uint8(8) + } + if err := binary.Write(&buf, binary.LittleEndian, ty); err != nil { + return err + } + u, err := m.uuid.MarshalText() + if err != nil { + return err + } + if err := binary.Write(&buf, binary.LittleEndian, u); err != nil { + return err + } + ip := uint32(0) + if m.ip != nil { + ip = binary.BigEndian.Uint32(m.ip.To4()) + } + // The protocol uses little endian, not network endian + if err := binary.Write(&buf, binary.LittleEndian, ip); err != nil { + return err + } + _, err = sr.Send(buf.Bytes()) + return err +} + +const max_ethernetResponse = 1500 + +func readEthernetResponse(sr sendReceiver) error { + bs := make([]byte, max_ethernetResponse) + n, err := sr.Recv(bs) + if err != nil { + return err + } + br := bytes.NewReader(bs[0:n]) + var responseType uint8 + if err := binary.Read(br, binary.LittleEndian, &responseType); err != nil { + return err + } + switch responseType { + case 1: + return nil + default: + var len uint8 + if err := binary.Read(br, binary.LittleEndian, &len); err != nil { + return err + } + message := make([]byte, len) + if err := binary.Read(br, binary.LittleEndian, &message); err != nil { + return err + } + + return errors.New(string(message)) + } +} diff --git a/go/pkg/vmnet/sendreceiver.go b/go/pkg/vmnet/sendreceiver.go new file mode 100644 index 000000000..233a5589e --- /dev/null +++ b/go/pkg/vmnet/sendreceiver.go @@ -0,0 +1,9 @@ +package vmnet + +// sendReceiver sends and receives whole messages atomically. +// This has the same shape as io.ReadWriter's Read and Write, but we use different functions +// to prevent confusion. +type sendReceiver interface { + Send(packet []byte) (int, error) + Recv(buffer []byte) (int, error) +} diff --git a/go/pkg/vmnet/socketpair.go b/go/pkg/vmnet/socketpair.go new file mode 100644 index 000000000..292c510f2 --- /dev/null +++ b/go/pkg/vmnet/socketpair.go @@ -0,0 +1,34 @@ +package vmnet + +import ( + "syscall" + + "github.com/pkg/errors" +) + +func socketpair() ([2]int, error) { + invalid := [2]int{-1, -1} + fds, err := syscall.Socketpair(syscall.AF_LOCAL, syscall.SOCK_DGRAM, 0) + if err != nil { + return invalid, errors.Wrap(err, "creating SOCK_DGRAM socketpair for ethernet") + } + defer func() { + if err == nil { + return + } + for _, fd := range fds { + _ = syscall.Close(fd) + } + }() + + for _, fd := range fds { + maxLength := 1048576 + if err = syscall.SetsockoptInt(fd, syscall.SOL_SOCKET, syscall.SO_RCVBUF, maxLength); err != nil { + return invalid, errors.Wrap(err, "setting SO_RCVBUF") + } + if err = syscall.SetsockoptInt(fd, syscall.SOL_SOCKET, syscall.SO_SNDBUF, maxLength); err != nil { + return invalid, errors.Wrap(err, "setting SO_SNDBUF") + } + } + return fds, nil +} diff --git a/go/pkg/vmnet/udpv4.go b/go/pkg/vmnet/udpv4.go new file mode 100644 index 000000000..e63270371 --- /dev/null +++ b/go/pkg/vmnet/udpv4.go @@ -0,0 +1,65 @@ +package vmnet + +import ( + "bytes" + "encoding/binary" + "io" + + "github.com/pkg/errors" +) + +// Udpv4 is a Udpv4 frame +type Udpv4 struct { + Src uint16 + Dst uint16 + Data []byte + Checksum uint16 +} + +// NewUdpv4 constructs a Udpv4 frame +func NewUdpv4(ipv4 *Ipv4, Dst, Src uint16, Data []byte) *Udpv4 { + Checksum := uint16(0) + return &Udpv4{Dst, Src, Data, Checksum} +} + +// ParseUdpv4 parses a Udpv4 packet +func ParseUdpv4(packet []byte) (*Udpv4, error) { + if len(packet) < 8 { + return nil, errors.New("UDPv4 is too short") + } + Src := uint16(packet[0])<<8 + uint16(packet[1]) + Dst := uint16(packet[2])<<8 + uint16(packet[3]) + Checksum := uint16(packet[6])<<8 + uint16(packet[7]) + Data := packet[8:] + return &Udpv4{Src, Dst, Data, Checksum}, nil +} + +// Write marshalls a Udpv4 frame +func (u *Udpv4) Write(w io.Writer) error { + if err := binary.Write(w, binary.BigEndian, u.Src); err != nil { + return err + } + if err := binary.Write(w, binary.BigEndian, u.Dst); err != nil { + return err + } + length := uint16(8 + len(u.Data)) + if err := binary.Write(w, binary.BigEndian, length); err != nil { + return err + } + if err := binary.Write(w, binary.BigEndian, u.Checksum); err != nil { + return err + } + if err := binary.Write(w, binary.BigEndian, u.Data); err != nil { + return err + } + return nil +} + +// Bytes returns the marshalled Udpv4 frame +func (u *Udpv4) Bytes() []byte { + buf := bytes.NewBufferString("") + if err := u.Write(buf); err != nil { + panic(err) + } + return buf.Bytes() +} diff --git a/go/pkg/vmnet/vif.go b/go/pkg/vmnet/vif.go new file mode 100644 index 000000000..ae6d0397f --- /dev/null +++ b/go/pkg/vmnet/vif.go @@ -0,0 +1,166 @@ +package vmnet + +import ( + "bytes" + "encoding/binary" + "net" + "os" + "syscall" + "time" + + "github.com/google/uuid" + "github.com/moby/vpnkit/go/pkg/vpnkit/log" + "github.com/pkg/errors" +) + +// Vif represents an Ethernet device as a file descriptor. +// Clients should call Fd() and use send/recv to send ethernet frames. +type Vif struct { + MTU uint16 + MaxPacketSize uint16 + ClientMAC net.HardwareAddr + IP net.IP + Ethernet Datagram // Ethernet allows clients to Read() and Write() raw ethernet frames. + fds []int +} + +func (v *Vif) Close() error { + for _, fd := range v.fds { + _ = syscall.Close(fd) + } + return nil +} + +// ensure we have a SOCK_DGRAM fd, by starting a proxy if necessary. +func (v *Vif) start(ethernet sendReceiver) error { + if e, ok := ethernet.(Datagram); ok { + // no proxy is required because we already have a datagram socket + v.Ethernet = e + return nil + } + // create a socketpair and feed one end into the sendReceiver + fds, err := socketpair() + if err != nil { + return err + } + // remember the fds for Close() + v.fds = fds[:] + // client data will be written in this end + v.Ethernet = Datagram{ + Fd: fds[0], + } + // and then proxied to the underlying sendReceiver + proxy := Datagram{ + Fd: fds[1], + } + // proxy until the fds are closed + go v.proxy(proxy, ethernet) + go v.proxy(ethernet, proxy) + return nil +} + +func (v *Vif) proxy(from, to sendReceiver) { + buf := make([]byte, v.MaxPacketSize) + for { + n, err := from.Recv(buf) + if err != nil { + log.Errorf("from.Read: %v", err) + return + } + packet := buf[0:n] + for { + _, err := to.Send(packet) + if err == nil { + break + } + log.Errorf("to.write retrying packet of length %d: %v", len(packet), err) + time.Sleep(10 * time.Millisecond) + } + } +} + +type connectConfig struct { + control sendReceiver // vpnkit protocol message read/writer + ethernet sendReceiver // ethenet frame read/write + uuid uuid.UUID // vpnkit interface UUID + IP net.IP // optional requested IP address + pcap string // optional .pcap file +} + +func connectVif(config connectConfig) (*Vif, error) { + e := NewEthernetRequest(config.uuid, config.IP) + if err := e.Send(config.control); err != nil { + return nil, err + } + vif, err := readVif(config.control) + if err != nil { + return nil, err + } + if err := vif.start(config.ethernet); err != nil { + return nil, err + } + config.pcap = "out.pcap" + if config.pcap != "" { + w, err := os.Create(config.pcap) + if err != nil { + return nil, errors.Wrapf(err, "creating %s", config.pcap) + } + p, err := NewPcapWriter(w) + if err != nil { + return nil, errors.Wrapf(err, "creating pcap in %s", config.pcap) + } + vif.Ethernet.pcap = p + } + vif.IP = config.IP + if vif.IP == nil { + IP, err := dhcpRequest(vif.Ethernet, vif.ClientMAC) + if err != nil { + return nil, err + } + vif.IP = IP + } + return vif, err +} + +func readVif(fixedSize sendReceiver) (*Vif, error) { + // https://github.com/moby/vpnkit/blob/6039eac025e0740e530f2ff11f57d6d990d1c4a1/src/hostnet/vmnet.ml#L160 + buf := make([]byte, 1+1+256) + n, err := fixedSize.Recv(buf) + if err != nil { + return nil, errors.Wrap(err, "reading VIF metadata") + } + br := bytes.NewReader(buf[0:n]) + + var responseType uint8 + if err := binary.Read(br, binary.LittleEndian, &responseType); err != nil { + return nil, errors.Wrap(err, "reading response type") + } + if responseType != 1 { + var len uint8 + if err := binary.Read(br, binary.LittleEndian, &len); err != nil { + return nil, errors.Wrap(err, "reading error length") + } + message := make([]byte, len) + if err := binary.Read(br, binary.LittleEndian, &message); err != nil { + return nil, errors.Wrap(err, "reading error message") + } + return nil, errors.New(string(message)) + } + + var MTU, MaxPacketSize uint16 + if err := binary.Read(br, binary.LittleEndian, &MTU); err != nil { + return nil, err + } + if err := binary.Read(br, binary.LittleEndian, &MaxPacketSize); err != nil { + return nil, err + } + var mac [6]byte + if err := binary.Read(br, binary.LittleEndian, &mac); err != nil { + return nil, err + } + return &Vif{ + MTU: MTU, + MaxPacketSize: MaxPacketSize, + ClientMAC: mac[:], + }, nil +} diff --git a/go/pkg/vmnet/vmnet.go b/go/pkg/vmnet/vmnet.go index 5ce5e5175..a5dbfaed9 100644 --- a/go/pkg/vmnet/vmnet.go +++ b/go/pkg/vmnet/vmnet.go @@ -1,617 +1,151 @@ package vmnet import ( - "bytes" "context" - "encoding/binary" - "errors" "fmt" "io" + "io/ioutil" "net" - "time" + "syscall" "github.com/google/uuid" + "github.com/pkg/errors" ) // Vmnet describes a "vmnet protocol" connection which allows ethernet frames to be // sent to and received by vpnkit. type Vmnet struct { - conn net.Conn + closer io.Closer + control sendReceiver // fixed-size control messages used by vpnkit itself + ethernet sendReceiver // variable-length ethernet frames remoteVersion *InitMessage + pcap string } -// New constructs an instance of Vmnet. +// New connection to vpnkit's ethernet socket. +// This function is deprecated, use Connect instead. func New(ctx context.Context, path string) (*Vmnet, error) { - d := &net.Dialer{} - conn, err := d.DialContext(ctx, "unix", path) - if err != nil { - return nil, err - } - var remoteVersion *InitMessage - vmnet := &Vmnet{conn, remoteVersion} - err = vmnet.negotiate() - if err != nil { - return nil, err - } - return vmnet, err -} - -// Close closes the connection. -func (v *Vmnet) Close() error { - return v.conn.Close() + // use the old stream socket by default + return connectStream(ctx, path) } -// InitMessage is used for the initial version exchange -type InitMessage struct { - magic [5]byte - version uint32 - commit [40]byte -} +const ( + fdSendMagic = "VMNET" + fdSendSuccess = "OK" +) -// String returns a human-readable string. -func (m *InitMessage) String() string { - return fmt.Sprintf("magic=%v version=%d commit=%v", m.magic, m.version, m.commit) +// Config for Connect. +type Config struct { + Path string // Path to the vpnkit ethernet socket. + PCAP string // PCAP file to capture packets. } -// defaultInitMessage is the init message we will send to vpnkit -func defaultInitMessage() *InitMessage { - magic := [5]byte{'V', 'M', 'N', '3', 'T'} - version := uint32(22) - var commit [40]byte - copy(commit[:], []byte("0123456789012345678901234567890123456789")) - return &InitMessage{magic, version, commit} -} +// Connect connects to vpnkit using the new SOCK_DGRAM protocol. +func Connect(ctx context.Context, config Config) (*Vmnet, error) { + // Create a socketpair + fds, err := socketpair() + if err != nil { + return nil, errors.Wrap(err, "creating SOCK_DGRAM socketpair for ethernet") + } + defer func() { + for _, fd := range fds { + if fd == -1 { + continue + } + _ = syscall.Close(fd) + } + }() -// Write marshals an init message to a connection -func (m *InitMessage) Write(c net.Conn) error { - if err := binary.Write(c, binary.LittleEndian, m.magic); err != nil { - return err + // Dial over SOCK_STREAM, passing fd and magic + c, err := net.DialUnix("unix", nil, &net.UnixAddr{Name: config.Path, Net: "unix"}) + if err != nil { + return nil, errors.Wrap(err, "dialing "+config.Path) } - if err := binary.Write(c, binary.LittleEndian, m.version); err != nil { - return err + defer c.Close() + if err := sendFileDescriptor(c, []byte(fdSendMagic), fds[0]); err != nil { + return nil, errors.Wrap(err, "sending file descriptor") } - if err := binary.Write(c, binary.LittleEndian, m.commit); err != nil { - return err + // Receive success + response, err := ioutil.ReadAll(c) + if err != nil { + return nil, errors.Wrap(err, "reading response from file descriptor send") } - return nil -} - -// readInitMessage unmarshals an init message from a connection -func (v *Vmnet) readInitMessage() (*InitMessage, error) { - m := defaultInitMessage() - if err := binary.Read(v.conn, binary.LittleEndian, &m.magic); err != nil { - return nil, err + if string(response) != fdSendSuccess { + return nil, fmt.Errorf("sending file descriptor: %s", string(response)) } - if err := binary.Read(v.conn, binary.LittleEndian, &m.version); err != nil { - return nil, err + // We can now negotiate over the socketpair + datagram := Datagram{ + Fd: fds[1], } - if err := binary.Read(v.conn, binary.LittleEndian, &m.commit); err != nil { + remoteVersion, err := negotiate(datagram) + if err != nil { return nil, err } - return m, nil -} - -func (v *Vmnet) negotiate() error { - m := defaultInitMessage() - if err := m.Write(v.conn); err != nil { - return err - } - remoteVersion, err := v.readInitMessage() - if err != nil { - return err + vmnet := &Vmnet{ + closer: datagram, + control: datagram, + ethernet: datagram, + remoteVersion: remoteVersion, + pcap: config.PCAP, } - v.remoteVersion = remoteVersion - return nil -} - -// Ethernet requests the creation of a network connection with a given -// uuid and optional IP -type Ethernet struct { - uuid uuid.UUID - ip net.IP + fds[1] = -1 // don't close our end of the socketpair in the defer + return vmnet, nil } -// NewEthernet creates an Ethernet frame -func NewEthernet(uuid uuid.UUID, ip net.IP) *Ethernet { - return &Ethernet{uuid, ip} -} +func sendFileDescriptor(c *net.UnixConn, msg []byte, fd int) error { + rights := syscall.UnixRights(fd) -// Write marshals an Ethernet message -func (m *Ethernet) Write(c net.Conn) error { - ty := uint8(1) - if m.ip != nil { - ty = uint8(8) - } - if err := binary.Write(c, binary.LittleEndian, ty); err != nil { - return err - } - u, err := m.uuid.MarshalText() + unixConnFile, err := c.File() if err != nil { - return err - } - if err := binary.Write(c, binary.LittleEndian, u); err != nil { - return err - } - ip := uint32(0) - if m.ip != nil { - ip = binary.BigEndian.Uint32(m.ip.To4()) + return errors.Wrap(err, "can't access connection file") } - // The protocol uses little endian, not network endian - if err := binary.Write(c, binary.LittleEndian, ip); err != nil { - return err - } - return nil -} + defer unixConnFile.Close() -// Vif represents an Ethernet device -type Vif struct { - MTU uint16 - MaxPacketSize uint16 - ClientMAC net.HardwareAddr - IP net.IP - conn net.Conn + unixConnFd := int(unixConnFile.Fd()) + return syscall.Sendmsg(unixConnFd, msg, rights, nil, 0) } -func (v *Vmnet) readVif() (*Vif, error) { - var MTU, MaxPacketSize uint16 - - if err := binary.Read(v.conn, binary.LittleEndian, &MTU); err != nil { - return nil, err - } - if err := binary.Read(v.conn, binary.LittleEndian, &MaxPacketSize); err != nil { +// connectStream uses the old SOCK_STREAM protocol. +func connectStream(ctx context.Context, path string) (*Vmnet, error) { + d := &net.Dialer{} + c, err := d.DialContext(ctx, "unix", path) + if err != nil { return nil, err } - var mac [6]byte - if err := binary.Read(v.conn, binary.LittleEndian, &mac); err != nil { + f := fixedSizeSendReceiver{c} + remoteVersion, err := negotiate(f) + if err != nil { return nil, err } - padding := make([]byte, 1+256-6-2-2) - if err := binary.Read(v.conn, binary.LittleEndian, &padding); err != nil { - return nil, err + vmnet := &Vmnet{ + closer: c, + control: f, + ethernet: lengthPrefixer{c}, // need to add artificial message boundaries + remoteVersion: remoteVersion, } - ClientMAC := mac[:] - conn := v.conn - var IP net.IP - return &Vif{MTU, MaxPacketSize, ClientMAC, IP, conn}, nil + return vmnet, err +} + +func (v *Vmnet) Close() error { + return v.closer.Close() } // ConnectVif returns a connected network interface with the given uuid. func (v *Vmnet) ConnectVif(uuid uuid.UUID) (*Vif, error) { - e := NewEthernet(uuid, nil) - if err := e.Write(v.conn); err != nil { - return nil, err - } - var responseType uint8 - if err := binary.Read(v.conn, binary.LittleEndian, &responseType); err != nil { - return nil, err - } - switch responseType { - case 1: - vif, err := v.readVif() - if err != nil { - return nil, err - } - IP, err := vif.dhcp() - if err != nil { - return nil, err - } - vif.IP = IP - return vif, err - default: - var len uint8 - if err := binary.Read(v.conn, binary.LittleEndian, &len); err != nil { - return nil, err - } - message := make([]byte, len) - if err := binary.Read(v.conn, binary.LittleEndian, &message); err != nil { - return nil, err - } - return nil, errors.New(string(message)) - } + return connectVif(connectConfig{ + control: v.control, + ethernet: v.ethernet, + uuid: uuid, + }) } // ConnectVifIP returns a connected network interface with the given uuid // and IP. If the IP is already in use then return an error. func (v *Vmnet) ConnectVifIP(uuid uuid.UUID, IP net.IP) (*Vif, error) { - e := NewEthernet(uuid, IP) - if err := e.Write(v.conn); err != nil { - return nil, err - } - var responseType uint8 - if err := binary.Read(v.conn, binary.LittleEndian, &responseType); err != nil { - return nil, err - } - switch responseType { - case 1: - vif, err := v.readVif() - if err != nil { - return nil, err - } - vif.IP = IP - return vif, err - default: - var len uint8 - if err := binary.Read(v.conn, binary.LittleEndian, &len); err != nil { - return nil, err - } - message := make([]byte, len) - if err := binary.Read(v.conn, binary.LittleEndian, &message); err != nil { - return nil, err - } - return nil, errors.New(string(message)) - } -} - -// Write writes a packet to a Vif -func (v *Vif) Write(packet []byte) error { - len := uint16(len(packet)) - if err := binary.Write(v.conn, binary.LittleEndian, len); err != nil { - return err - } - if err := binary.Write(v.conn, binary.LittleEndian, packet); err != nil { - return err - } - return nil -} - -// Read reads the next packet from a Vif -func (v *Vif) Read() ([]byte, error) { - var len uint16 - if err := binary.Read(v.conn, binary.LittleEndian, &len); err != nil { - return nil, err - } - packet := make([]byte, len) - if err := binary.Read(v.conn, binary.LittleEndian, &packet); err != nil { - return nil, err - } - return packet, nil -} - -// PcapWriter writes pcap-formatted packet streams -type PcapWriter struct { - w io.Writer - snaplen uint32 -} - -// NewPcapWriter creates a PcapWriter and writes the initial header -func NewPcapWriter(w io.Writer) (*PcapWriter, error) { - magic := uint32(0xa1b2c3d4) - major := uint16(2) - minor := uint16(4) - thiszone := uint32(0) // GMT to local correction - sigfigs := uint32(0) // accuracy of local timestamps - snaplen := uint32(1500) // max length of captured packets, in octets - network := uint32(1) // ethernet - if err := binary.Write(w, binary.LittleEndian, magic); err != nil { - return nil, err - } - if err := binary.Write(w, binary.LittleEndian, major); err != nil { - return nil, err - } - if err := binary.Write(w, binary.LittleEndian, minor); err != nil { - return nil, err - } - if err := binary.Write(w, binary.LittleEndian, thiszone); err != nil { - return nil, err - } - if err := binary.Write(w, binary.LittleEndian, sigfigs); err != nil { - return nil, err - } - if err := binary.Write(w, binary.LittleEndian, snaplen); err != nil { - return nil, err - } - if err := binary.Write(w, binary.LittleEndian, network); err != nil { - return nil, err - } - return &PcapWriter{w, snaplen}, nil -} - -// Write appends a packet with a pcap-format header -func (p *PcapWriter) Write(packet []byte) error { - stamp := time.Now() - s := uint32(stamp.Second()) - us := uint32(stamp.Nanosecond() / 1000) - actualLen := uint32(len(packet)) - if err := binary.Write(p.w, binary.LittleEndian, s); err != nil { - return err - } - if err := binary.Write(p.w, binary.LittleEndian, us); err != nil { - return err - } - toWrite := packet[:] - if actualLen > p.snaplen { - toWrite = toWrite[0:p.snaplen] - } - caplen := uint32(len(toWrite)) - if err := binary.Write(p.w, binary.LittleEndian, caplen); err != nil { - return err - } - if err := binary.Write(p.w, binary.LittleEndian, actualLen); err != nil { - return err - } - - if err := binary.Write(p.w, binary.LittleEndian, toWrite); err != nil { - return err - } - return nil -} - -// EthernetFrame is an ethernet frame -type EthernetFrame struct { - Dst net.HardwareAddr - Src net.HardwareAddr - Type uint16 - Data []byte -} - -// NewEthernetFrame constructs an Ethernet frame -func NewEthernetFrame(Dst, Src net.HardwareAddr, Type uint16) *EthernetFrame { - Data := make([]byte, 0) - return &EthernetFrame{Dst, Src, Type, Data} -} - -func (e *EthernetFrame) setData(data []byte) { - e.Data = data -} - -// Write marshals an Ethernet frame -func (e *EthernetFrame) Write(w io.Writer) error { - if err := binary.Write(w, binary.BigEndian, e.Dst); err != nil { - return err - } - if err := binary.Write(w, binary.BigEndian, e.Src); err != nil { - return err - } - if err := binary.Write(w, binary.BigEndian, e.Type); err != nil { - return err - } - if err := binary.Write(w, binary.BigEndian, e.Data); err != nil { - return err - } - return nil -} - -// ParseEthernetFrame parses the ethernet frame -func ParseEthernetFrame(frame []byte) (*EthernetFrame, error) { - if len(frame) < (6 + 6 + 2) { - return nil, errors.New("Ethernet frame is too small") - } - Dst := frame[0:6] - Src := frame[6:12] - Type := uint16(frame[12])<<8 + uint16(frame[13]) - Data := frame[14:] - return &EthernetFrame{Dst, Src, Type, Data}, nil -} - -// Bytes returns the marshalled ethernet frame -func (e *EthernetFrame) Bytes() []byte { - buf := bytes.NewBufferString("") - if err := e.Write(buf); err != nil { - panic(err) - } - return buf.Bytes() -} - -// Ipv4 is an IPv4 frame -type Ipv4 struct { - Dst net.IP - Src net.IP - Data []byte - Checksum uint16 -} - -// NewIpv4 constructs a new empty IPv4 packet -func NewIpv4(Dst, Src net.IP) *Ipv4 { - Checksum := uint16(0) - Data := make([]byte, 0) - return &Ipv4{Dst, Src, Data, Checksum} -} - -// ParseIpv4 parses an IP packet -func ParseIpv4(packet []byte) (*Ipv4, error) { - if len(packet) < 20 { - return nil, errors.New("IPv4 packet too small") - } - ihl := int((packet[0] & 0xf) * 4) // in octets - if len(packet) < ihl { - return nil, errors.New("IPv4 packet too small") - } - Dst := packet[12:16] - Src := packet[16:20] - Data := packet[ihl:] - Checksum := uint16(0) // assume offload - return &Ipv4{Dst, Src, Data, Checksum}, nil -} - -func (i *Ipv4) setData(data []byte) { - i.Data = data - i.Checksum = uint16(0) // as if we were using offload -} - -// HeaderBytes returns the marshalled form of the IPv4 header -func (i *Ipv4) HeaderBytes() []byte { - len := len(i.Data) + 20 - length := [2]byte{byte(len >> 8), byte(len & 0xff)} - checksum := [2]byte{byte(i.Checksum >> 8), byte(i.Checksum & 0xff)} - return []byte{ - 0x45, // version + IHL - 0x00, // DSCP + ECN - length[0], length[1], // total length - 0x7f, 0x61, // Identification - 0x00, 0x00, // Flags + Fragment offset - 0x40, // TTL - 0x11, // Protocol - checksum[0], checksum[1], - 0x00, 0x00, 0x00, 0x00, // source - 0xff, 0xff, 0xff, 0xff, // destination - } -} - -// Bytes returns the marshalled IPv4 packet -func (i *Ipv4) Bytes() []byte { - header := i.HeaderBytes() - return append(header, i.Data...) -} - -// Udpv4 is a Udpv4 frame -type Udpv4 struct { - Src uint16 - Dst uint16 - Data []byte - Checksum uint16 -} - -// NewUdpv4 constructs a Udpv4 frame -func NewUdpv4(ipv4 *Ipv4, Dst, Src uint16, Data []byte) *Udpv4 { - Checksum := uint16(0) - return &Udpv4{Dst, Src, Data, Checksum} -} - -// ParseUdpv4 parses a Udpv4 packet -func ParseUdpv4(packet []byte) (*Udpv4, error) { - if len(packet) < 8 { - return nil, errors.New("UDPv4 is too short") - } - Src := uint16(packet[0])<<8 + uint16(packet[1]) - Dst := uint16(packet[2])<<8 + uint16(packet[3]) - Checksum := uint16(packet[6])<<8 + uint16(packet[7]) - Data := packet[8:] - return &Udpv4{Src, Dst, Data, Checksum}, nil -} - -// Write marshalls a Udpv4 frame -func (u *Udpv4) Write(w io.Writer) error { - if err := binary.Write(w, binary.BigEndian, u.Src); err != nil { - return err - } - if err := binary.Write(w, binary.BigEndian, u.Dst); err != nil { - return err - } - length := uint16(8 + len(u.Data)) - if err := binary.Write(w, binary.BigEndian, length); err != nil { - return err - } - if err := binary.Write(w, binary.BigEndian, u.Checksum); err != nil { - return err - } - if err := binary.Write(w, binary.BigEndian, u.Data); err != nil { - return err - } - return nil -} - -// Bytes returns the marshalled Udpv4 frame -func (u *Udpv4) Bytes() []byte { - buf := bytes.NewBufferString("") - if err := u.Write(buf); err != nil { - panic(err) - } - return buf.Bytes() -} - -// DhcpRequest is a simple DHCP request -type DhcpRequest struct { - MAC net.HardwareAddr -} - -// NewDhcpRequest constructs a DHCP request -func NewDhcpRequest(MAC net.HardwareAddr) *DhcpRequest { - if len(MAC) != 6 { - panic("MAC address must be 6 bytes") - } - return &DhcpRequest{MAC} -} - -// Bytes returns the marshalled DHCP request -func (d *DhcpRequest) Bytes() []byte { - bs := []byte{ - 0x01, // OP - 0x01, // HTYPE - 0x06, // HLEN - 0x00, // HOPS - 0x01, 0x00, 0x00, 0x00, // XID - 0x00, 0x00, // SECS - 0x80, 0x00, // FLAGS - 0x00, 0x00, 0x00, 0x00, // CIADDR - 0x00, 0x00, 0x00, 0x00, // YIADDR - 0x00, 0x00, 0x00, 0x00, // SIADDR - 0x00, 0x00, 0x00, 0x00, // GIADDR - d.MAC[0], d.MAC[1], d.MAC[2], d.MAC[3], d.MAC[4], d.MAC[5], - } - bs = append(bs, make([]byte, 202)...) - bs = append(bs, []byte{ - 0x63, 0x82, 0x53, 0x63, // Magic cookie - 0x35, 0x01, 0x01, // DHCP discover - 0xff, // Endmark - }...) - return bs -} - -// dhcp queries the IP by DHCP -func (v *Vif) dhcp() (net.IP, error) { - broadcastMAC := []byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff} - broadcastIP := []byte{0xff, 0xff, 0xff, 0xff} - unknownIP := []byte{0, 0, 0, 0} - - dhcpRequest := NewDhcpRequest(v.ClientMAC).Bytes() - ipv4 := NewIpv4(broadcastIP, unknownIP) - - udpv4 := NewUdpv4(ipv4, 68, 67, dhcpRequest) - ipv4.setData(udpv4.Bytes()) - - ethernet := NewEthernetFrame(broadcastMAC, v.ClientMAC, 0x800) - ethernet.setData(ipv4.Bytes()) - finished := false - go func() { - for !finished { - if err := v.Write(ethernet.Bytes()); err != nil { - panic(err) - } - time.Sleep(time.Second) - } - }() - - for { - response, err := v.Read() - if err != nil { - return nil, err - } - ethernet, err = ParseEthernetFrame(response) - if err != nil { - continue - } - for i, x := range ethernet.Dst { - if i > len(v.ClientMAC) || v.ClientMAC[i] != x { - // intended for someone else - continue - } - } - ipv4, err = ParseIpv4(ethernet.Data) - if err != nil { - // probably not an IPv4 packet - continue - } - udpv4, err = ParseUdpv4(ipv4.Data) - if err != nil { - // probably not a UDPv4 packet - continue - } - if udpv4.Src != 67 || udpv4.Dst != 68 { - // not a DHCP response - continue - } - if len(udpv4.Data) < 243 { - // truncated - continue - } - if udpv4.Data[240] != 53 || udpv4.Data[241] != 1 || udpv4.Data[242] != 2 { - // not a DHCP offer - continue - } - var ip net.IP - ip = udpv4.Data[16:20] - finished = true // will terminate sending goroutine - return ip, nil - } - + return connectVif(connectConfig{ + control: v.control, + ethernet: v.ethernet, + uuid: uuid, + IP: IP, + }) } diff --git a/src/bin/bind.ml b/src/bin/bind.ml index ba0a43dcc..8cba115be 100644 --- a/src/bin/bind.ml +++ b/src/bin/bind.ml @@ -6,7 +6,7 @@ let src = module Log = (val Logs.src_log src : Logs.LOG) open Lwt.Infix -open Vmnet +open Vmnet_proto let is_windows = Sys.os_type = "Win32" @@ -97,6 +97,7 @@ module Make(Socket: Sig.SOCKETS) = struct module Datagram = struct type address = Socket.Datagram.address + module Unix = Socket.Datagram.Unix module Udp = struct include Socket.Datagram.Udp diff --git a/src/bin/main.ml b/src/bin/main.ml index 379f73375..221d3383a 100644 --- a/src/bin/main.ml +++ b/src/bin/main.ml @@ -398,7 +398,7 @@ let hvsock_addr_of_uri ~default_serviceid uri = match Uri.scheme uri with | Some ("hyperv-connect"|"hyperv-listen") -> let module Slirp_stack = - Slirp.Make(Vmnet.Make(HV))(Dns_policy) + Slirp.Make(Vmnet_stream.Make(HV))(Dns_policy) (Mclock)(Mirage_random_stdlib)(Vnet) in let sockaddr = @@ -429,9 +429,38 @@ let hvsock_addr_of_uri ~default_serviceid uri = if Uri.scheme uri = Some "hyperv-connect" then hvsock_connect_forever socket_url sockaddr callback else hvsock_listen sockaddr callback + | Some "dgram" -> + let module Slirp_stack = + Slirp.Make(Vmnet_dgram.Make(Host_unix_dgram))(Dns_policy) + (Mclock)(Mirage_random_stdlib)(Vnet) + in + let path = Uri.path uri in + (try Unix.unlink path with Unix.Unix_error(Unix.ENOENT, _, _) -> ()); + begin Host_unix_dgram.bind path + >>= fun server -> + Slirp_stack.create_static vnet_switch configuration + >>= fun stack_config -> + Host_unix_dgram.listen server (fun conn -> + Slirp_stack.connect stack_config conn >>= fun stack -> + Log.info (fun f -> f "TCP/IP stack connected"); + List.iter (fun url -> + start_introspection url (Slirp_stack.filesystem stack); + ) introspection_urls; + List.iter (fun url -> + start_server "diagnostics" url @@ Slirp_stack.diagnostics stack + ) diagnostics_urls; + List.iter (fun url -> + start_server "pcap" url @@ Slirp_stack.pcap stack + ) pcap_urls; + Slirp_stack.after_disconnect stack >|= fun () -> + Log.info (fun f -> f "TCP/IP stack disconnected") + ); + let wait_forever, _ = Lwt.task () in + wait_forever + end | Some "fd" | None -> let module Slirp_stack = - Slirp.Make(Vmnet.Make(Host.Sockets.Stream.Unix))(Dns_policy) + Slirp.Make(Vmnet_stream.Make(Host.Sockets.Stream.Unix))(Dns_policy) (Mclock)(Mirage_random_stdlib)(Vnet) in begin match http_intercept_api_path with @@ -466,7 +495,7 @@ let hvsock_addr_of_uri ~default_serviceid uri = end | _ -> let module Slirp_stack = - Slirp.Make(Vmnet.Make(HV_generic))(Dns_policy) + Slirp.Make(Vmnet_stream.Make(HV_generic))(Dns_policy) (Mclock)(Mirage_random_stdlib)(Vnet) in Slirp_stack.create_static vnet_switch configuration @@ -508,7 +537,10 @@ let hvsock_addr_of_uri ~default_serviceid uri = Logging.setup level; Log.info (fun f -> f "Starting"); - + let mtu = if mtu > Constants.max_mtu then begin + Log.warn (fun f -> f "capping MTU at the maximum value %d" Constants.max_mtu); + Constants.max_mtu + end else mtu in let host_names = List.map Dns.Name.of_string @@ Astring.String.cuts ~sep:"," host_names in let gateway_names = List.map Dns.Name.of_string @@ Astring.String.cuts ~sep:"," gateway_names in let vm_names = List.map Dns.Name.of_string @@ Astring.String.cuts ~sep:"," vm_names in diff --git a/src/fs9p/dune b/src/fs9p/dune index d4a4da848..1c70daef4 100644 --- a/src/fs9p/dune +++ b/src/fs9p/dune @@ -1,4 +1,4 @@ (library (name fs9p) (wrapped false) - (libraries protocol-9p mirage-flow)) + (libraries protocol-9p mirage-flow result)) diff --git a/src/hostnet/constants.ml b/src/hostnet/constants.ml index 01d4036f2..b484e0240 100644 --- a/src/hostnet/constants.ml +++ b/src/hostnet/constants.ml @@ -1,2 +1,8 @@ +let max_ip_datagram_length = 65535 + (* IP datagram (65535) - IP header(20) - UDP header(8) *) -let max_udp_length = 65507 +let max_udp_length = max_ip_datagram_length - 20 - 8 + +let max_mtu = 16424 + +let mib = 1024 * 1024 diff --git a/src/hostnet/dune b/src/hostnet/dune index 222bbbd6e..c961b96da 100644 --- a/src/hostnet/dune +++ b/src/hostnet/dune @@ -8,6 +8,6 @@ luv_unix lwt.unix threads astring fs9p dns_forward tar mirage-vnetif uuidm cohttp-lwt mirage-channel ezjsonm duration mirage-time mirage-clock - mirage-random tcpip.checksum forwarder cstructs sha) + mirage-random tcpip.checksum forwarder cstructs sha fd-send-recv) (foreign_stubs (language c) (names stubs_utils)) (wrapped false)) diff --git a/src/hostnet/host.ml b/src/hostnet/host.ml index 4a15c63bf..e171894f6 100644 --- a/src/hostnet/host.ml +++ b/src/hostnet/host.ml @@ -52,6 +52,8 @@ end module Sockets = struct module Datagram = struct + module Unix = Host_unix_dgram + type address = Ipaddr.t * int let string_of_address = string_of_address diff --git a/src/hostnet/host_unix_dgram.ml b/src/hostnet/host_unix_dgram.ml new file mode 100644 index 000000000..bc55b1ee9 --- /dev/null +++ b/src/hostnet/host_unix_dgram.ml @@ -0,0 +1,400 @@ +let src = + let src = Logs.Src.create "Datagram" ~doc:"Host SOCK_DGRAM implementation" in + Logs.Src.set_level src (Some Logs.Info); + src + +module Log = (val Logs.src_log src : Logs.LOG) + +type flow = { + (* SOCK_DGRAM socket. Ethernet frames are sent and received using send(2) and recv(2) *) + fd : Unix.file_descr; + (* A transmit queue. Packets are transmitted asynchronously by a background thread. *) + send_q : Cstruct.t Queue.t; + mutable send_done : bool; + mutable send_len : int; + send_waiters : unit Lwt.u Queue.t; + send_m : Mutex.t; + send_c : Condition.t; + (* A receive queue. Packets are received asynchronously by a background thread. *) + recv_q : Cstruct.t Queue.t; + (* Amount of data currently queued *) + mutable recv_len : int; + recv_m : Mutex.t; + (* Signalled when there is space in the queue *) + recv_c : Condition.t; + (* If the receive queue is empty then an Lwt thread can block itself here and will be woken up + by the next packet arrival. If there is no waiting Lwt thread then packets are queued. *) + mutable recv_u : Cstruct.t Lwt.u option; + mtu : int; +} + +let max_buffer = Constants.mib + +exception Done + +let send_thread t = + try + while true do + Mutex.lock t.send_m; + while Queue.is_empty t.send_q && not t.send_done do + Condition.wait t.send_c t.send_m + done; + if t.send_done then raise Done; + let to_send = Queue.copy t.send_q in + Queue.clear t.send_q; + t.send_len <- 0; + let to_wake = Queue.copy t.send_waiters in + Queue.clear t.send_waiters; + Luv_lwt.in_lwt_async (fun () -> + (* Wake up all blocked calls to send *) + Queue.iter (fun u -> Lwt.wakeup_later u ()) to_wake); + Mutex.unlock t.send_m; + Queue.iter + (fun packet -> + try + let n = Utils.cstruct_send t.fd packet in + Log.debug (fun f -> f "send %d" n); + let len = Cstruct.length packet in + if n <> len then + Log.warn (fun f -> + f "Utils.cstruct_send packet length %d but sent only %d" len n); + t.send_len <- t.send_len - len + with Unix.Unix_error (Unix.ENOBUFS, _, _) -> + (* If we're out of buffer space we have to drop the packet *) + Log.warn (fun f -> f "ENOBUFS: dropping packet")) + to_send + done + with + | Unix.Unix_error (Unix.EBADF, _, _) -> + Log.info (fun f -> + f "send: EBADFD: connection has been closed, stopping thread") + | Done -> Log.info (fun f -> f "send: fd has been closed, stopping thread") + | Unix.Unix_error (Unix.ECONNREFUSED, _, _) -> + Log.info (fun f -> f "send: ECONNREFUSED: stopping thread") + +let receive_thread t = + try + (* Many packets are small ACKs so cache an allocated buffer *) + let allocation_size = Constants.mib in + let recv_buffer = ref (Cstruct.create allocation_size) in + while true do + if Cstruct.length !recv_buffer < t.mtu then + recv_buffer := Cstruct.create allocation_size; + let n = Utils.cstruct_recv t.fd !recv_buffer in + let packet = Cstruct.sub !recv_buffer 0 n in + recv_buffer := Cstruct.shift !recv_buffer n; + Log.debug (fun f -> f "recv %d" n); + Mutex.lock t.recv_m; + let handled = ref false in + while not !handled do + match t.recv_u with + | None -> + (* No-one is waiting so consider queueing the packet *) + if n + t.recv_len > max_buffer then Condition.wait t.recv_c t.recv_m + (* Note we need to check t.recv_u again *) + else ( + Queue.push packet t.recv_q; + t.recv_len <- t.recv_len + n; + handled := true) + | Some waiter -> + (* A caller is blocked in recv already *) + Luv_lwt.in_lwt_async (fun () -> Lwt.wakeup_later waiter packet); + t.recv_u <- None; + handled := true + done; + (* Is someone already waiting *) + Mutex.unlock t.recv_m + done + with + | Unix.Unix_error (Unix.EBADF, _, _) -> + Log.info (fun f -> + f "recv: EBADFD: connection has been closed, stopping thread") + | Unix.Unix_error (Unix.ECONNREFUSED, _, _) -> + Log.info (fun f -> f "recv: ECONNREFUSED: stopping thread") + +let of_bound_fd ?(mtu = 65536) fd = + Log.info (fun f -> f "SOCK_DGRAM interface using MTU %d" mtu); + let t = + { + fd; + send_q = Queue.create (); + send_done = false; + send_len = 0; + send_waiters = Queue.create (); + send_m = Mutex.create (); + send_c = Condition.create (); + recv_q = Queue.create (); + recv_len = 0; + recv_m = Mutex.create (); + recv_c = Condition.create (); + recv_u = None; + mtu; + } + in + let (_ : Thread.t) = Thread.create (fun () -> send_thread t) () in + let (_ : Thread.t) = Thread.create (fun () -> receive_thread t) () in + Lwt.return t + +let send flow buf = + let len = Cstruct.length buf in + let rec loop () = + Mutex.lock flow.send_m; + if flow.send_len + len > max_buffer then ( + (* Too much data is queued. We will wait and this will add backpressure *) + let t, u = Lwt.wait () in + Queue.push u flow.send_waiters; + Mutex.unlock flow.send_m; + let open Lwt.Infix in + t >>= fun () -> loop ()) + else ( + Queue.push buf flow.send_q; + flow.send_len <- flow.send_len + len; + Condition.signal flow.send_c; + Mutex.unlock flow.send_m; + Lwt.return_unit) + in + loop () + +let recv flow = + Mutex.lock flow.recv_m; + if not (Queue.is_empty flow.recv_q) then ( + (* A packet is already queued *) + let packet = Queue.pop flow.recv_q in + flow.recv_len <- flow.recv_len - Cstruct.length packet; + Condition.signal flow.recv_c; + Mutex.unlock flow.recv_m; + Lwt.return packet) + else ( + (* The TCP stack should only call recv serially, otherwise packets will be permuted *) + assert (flow.recv_u = None); + let t, u = Lwt.wait () in + flow.recv_u <- Some u; + Condition.signal flow.recv_c; + Mutex.unlock flow.recv_m; + (* Wait for a packet to arrive *) + t) + +let close flow = + Mutex.lock flow.send_m; + flow.send_done <- true; + Condition.signal flow.send_c; + Mutex.unlock flow.send_m; + Unix.close flow.fd + +let%test_unit "socketpair" = + if Sys.os_type <> "Win32" then + let a, b = Unix.socketpair Unix.PF_UNIX Unix.SOCK_DGRAM 0 in + Lwt_main.run + (let open Lwt.Infix in + of_bound_fd a >>= fun a_flow -> + of_bound_fd b >>= fun b_flow -> + let rec loop () = + Lwt.catch + (fun () -> + send a_flow (Cstruct.of_string "hello") >>= fun () -> + Lwt.return true) + (function + | Unix.Unix_error (Unix.ENOTCONN, _, _) -> Lwt.return false + | e -> Lwt.fail e) + >>= function + | false -> Lwt.return_unit + | true -> Lwt_unix.sleep 1. >>= fun () -> loop () + in + let _ = loop () in + recv b_flow >>= fun buf -> + let n = Cstruct.length buf in + if n <> 5 then failwith (Printf.sprintf "recv returned %d, expected 5" n); + let received = Cstruct.(to_string (sub buf 0 n)) in + if received <> "hello" then + failwith + (Printf.sprintf "recv returned '%s', expected 'hello'" received); + Printf.fprintf stderr "closing\n"; + close a_flow; + close b_flow; + Lwt.return_unit) + +type error = [ `Closed | `Msg of string ] + +let pp_error ppf = function + | `Closed -> Fmt.string ppf "Closed" + | `Msg m -> Fmt.string ppf m + +type write_error = error + +let pp_write_error = pp_error + +open Lwt.Infix + +let read t = + recv t >>= fun buf -> + let n = Cstruct.length buf in + if n = 0 then Lwt.return @@ Ok `Eof else Lwt.return @@ Ok (`Data buf) + +let read_into _t _buf = + Lwt.return (Error (`Msg "read_into not implemented for SOCK_DGRAM")) + +let write t buf = send t buf >>= fun () -> Lwt.return @@ Ok () + +let writev t bufs = + let buf = Cstruct.concat bufs in + write t buf + +let close t = + close t; + Lwt.return_unit + +(* A server listens on a Unix domain socket for connections and then receives SOCK_DGRAM + file descriptors. In case someone connects and doesn't know the protocol we have a text + error message describing what the socket is really for. *) +type server = { fd : Unix.file_descr } +type address = string + +let magic = "VMNET" + +let error_message = + "This socket receives SOCK_DGRAM file descriptors for sending and receiving \ + ethernet frames.\n\ + It cannot be used directly.\n" + +let success_message = "OK" + +(* For low-frequency tasks like binding a listening socket, we fork a pthread for one request. *) +let run_in_pthread f = + let t, u = Lwt.task () in + let (_ : Thread.t) = + Thread.create + (fun () -> + try + let result = f () in + Luv_lwt.in_lwt_async (fun () -> Lwt.wakeup_later u result) + with e -> Luv_lwt.in_lwt_async (fun () -> Lwt.wakeup_exn u e)) + () + in + t + +let finally f g = + try + let result = f () in + g (); + result + with e -> + g (); + raise e + +let connect address = + let open Lwt.Infix in + run_in_pthread (fun () -> + try + let s = Unix.socket Unix.PF_UNIX Unix.SOCK_STREAM 0 in + finally + (fun () -> + Unix.connect s (Unix.ADDR_UNIX address); + let a, b = Unix.socketpair Unix.PF_UNIX Unix.SOCK_DGRAM 0 in + (* We will send a and keep b. *) + finally + (fun () -> + try + let (_ : int) = + Fd_send_recv.send_fd s (Bytes.of_string magic) 0 + (String.length magic) [] a + in + let buf = Bytes.create (String.length error_message) in + let n = Unix.read s buf 0 (Bytes.length buf) in + let response = Bytes.sub buf 0 n |> Bytes.to_string in + if response <> success_message then + failwith ("Host_unix_dgram.connect: " ^ response); + Ok b + with e -> + Unix.close b; + raise e) + (fun () -> Unix.close a)) + (fun () -> Unix.close s) + with e -> Error e) + >>= function + | Ok fd -> of_bound_fd fd + | Error e -> Lwt.fail e + +let bind ?description:_ address = + let open Lwt.Infix in + run_in_pthread (fun () -> + try + let s = Unix.socket Unix.PF_UNIX Unix.SOCK_STREAM 0 in + try + Unix.bind s (Unix.ADDR_UNIX address); + Unix.listen s 5; + Ok s + with e -> + Unix.close s; + Error e + with e -> Error e) + >>= function + | Ok fd -> Lwt.return { fd } + | Error e -> Lwt.fail e + +let listen server cb = + let (_ : Thread.t) = + Thread.create + (fun () -> + while true do + let fd, _ = Unix.accept server.fd in + let reply message = + let m = Bytes.of_string message in + let (_ : int) = Unix.write fd m 0 (Bytes.length m) in + () + in + finally + (fun () -> + let result = Bytes.make 8 '\000' in + let n, _, received_fd = + try Fd_send_recv.recv_fd fd result 0 (Bytes.length result) [] + with e -> + (* No passed fd probably means the caller doesn't realise what this socket is for. *) + reply error_message; + raise e + in + let actual_magic = Bytes.sub result 0 n |> Bytes.to_string in + let ok = actual_magic = magic in + let () = + try reply @@ if ok then success_message else error_message + with e -> + Unix.close received_fd; + raise e + in + if ok then + Luv_lwt.in_lwt_async (fun () -> + Lwt.async (fun () -> + of_bound_fd received_fd >>= fun flow -> cb flow))) + (fun () -> Unix.close fd) + done) + () + in + () + +let shutdown server = run_in_pthread (fun () -> Unix.close server.fd) + +let%test_unit "host_unix_dgram" = + if Sys.os_type <> "Win32" then + Lwt_main.run + (let address = "/tmp/host_unix_dgram.sock" in + (try Unix.unlink address with Unix.Unix_error (Unix.ENOENT, _, _) -> ()); + bind address >>= fun server -> + listen server (fun flow -> + recv flow >>= fun buf -> + let n = Cstruct.length buf in + send flow (Cstruct.sub buf 0 n)); + connect address >>= fun flow -> + let message = "hello" in + let buf = Cstruct.create (String.length message) in + Cstruct.blit_from_string message 0 buf 0 (String.length message); + send flow buf >>= fun () -> + recv flow >>= fun buf -> + let n = Cstruct.length buf in + if n <> String.length message then + failwith + (Printf.sprintf "n (%d) <> String.length message (%d)" n + (String.length message)); + let response = Cstruct.to_string buf in + if message <> response then + failwith + (Printf.sprintf "message (%s) <> response (%s)" message response); + close flow) diff --git a/src/hostnet/host_unix_dgram.mli b/src/hostnet/host_unix_dgram.mli new file mode 100644 index 000000000..d4f655816 --- /dev/null +++ b/src/hostnet/host_unix_dgram.mli @@ -0,0 +1,8 @@ +(** A simple thread-per-socket AF_UNIX SOCK_DRAM send/recv implementation to work around + the lack of support in libuv. + + This will be used for a single ethernet socket at a time, so scalability isn't required. + *) + +include Sig.UNIX_DGRAM +include Sig.CONN with type flow := flow diff --git a/src/hostnet/hostnet_dhcp.ml b/src/hostnet/hostnet_dhcp.ml index e373736bc..d4eb4cff6 100644 --- a/src/hostnet/hostnet_dhcp.ml +++ b/src/hostnet/hostnet_dhcp.ml @@ -71,6 +71,7 @@ module Make (Clock: Mirage_clock.MCLOCK) (Netif: Mirage_net.S) = struct Dhcp_wire.Ntp_servers [ c.Configuration.gateway_ip ]; Dhcp_wire.Broadcast_addr (Ipaddr.V4.Prefix.broadcast prefix); Dhcp_wire.Subnet_mask (Ipaddr.V4.Prefix.netmask prefix); + Dhcp_wire.Interface_mtu c.Configuration.mtu; ] in (* domain_search and get_domain_name may produce an empty string, which is * invalid, so only add the option if there is content *) diff --git a/src/hostnet/hostnet_icmp.ml b/src/hostnet/hostnet_icmp.ml index 0791a9ec4..dd4cd885e 100644 --- a/src/hostnet/hostnet_icmp.ml +++ b/src/hostnet/hostnet_icmp.ml @@ -113,7 +113,7 @@ module Make Lwt.return { server; server_fd; phys_to_flow; virt_to_flow; ids_in_use; next_id; send_reply } let start_receiver t = - let buf = Cstruct.create 4096 in + let buf = Cstruct.create Constants.max_ip_datagram_length in let try_to_send ~src ~dst ~payload = match t.send_reply with diff --git a/src/hostnet/sig.ml b/src/hostnet/sig.ml index d3002ce06..2a14ab082 100644 --- a/src/hostnet/sig.ml +++ b/src/hostnet/sig.ml @@ -64,6 +64,39 @@ module type FLOW_CLIENT_SERVER = sig and type flow := flow end +module type UNIX_DGRAM = sig + type flow + + val of_bound_fd: ?mtu:int -> Unix.file_descr -> flow Lwt.t + (** Create a flow from a file descriptor bound to a Unix domain socket + by some other process and passed to us. *) + + val send: flow -> Cstruct.t -> unit Lwt.t + + val recv: flow -> Cstruct.t Lwt.t + + val close: flow -> unit Lwt.t + + type address = string + (** Path of a listening Unix domain socket *) + + val connect: address -> flow Lwt.t + (** Connect a SOCK_DRAM socket via fd-passing to a listening socket. *) + + type server + (** A Unix domain socket which can receive datagram sockets *) + + val bind: ?description:string -> address -> server Lwt.t + (** Bind a server to an address *) + + val listen: server -> (flow -> unit Lwt.t) -> unit + (** Accept connections forever, calling the callback with a connection. + Connections are closed automatically when the callback finishes. *) + + val shutdown: server -> unit Lwt.t + (** Stop accepting connections on the given server *) +end + module type SOCKETS = sig (* An OS-based BSD sockets implementation *) @@ -81,6 +114,7 @@ module type SOCKETS = sig val sendto: server -> address -> ?ttl:int -> Cstruct.t -> unit Lwt.t end + module Unix: UNIX_DGRAM end module Stream: sig module Tcp: sig diff --git a/src/hostnet/stubs_utils.c b/src/hostnet/stubs_utils.c index b944a21af..ac9883039 100644 --- a/src/hostnet/stubs_utils.c +++ b/src/hostnet/stubs_utils.c @@ -4,6 +4,8 @@ #include #include #include +#include +#include #include @@ -62,3 +64,33 @@ CAMLprim value stub_setSocketTTL(value s, value ttl){ } CAMLreturn(Val_unit); } + +CAMLprim value stub_cstruct_send(value val_fd, value val_buf, value val_ofs, value val_len) { + CAMLparam4(val_fd, val_buf, val_ofs, val_len); +#ifdef WIN32 + caml_failwith("stub_cstruct_send not implemented on Win32"); +#endif + int fd = Int_val(val_fd); + const char *buf = (char*)Caml_ba_data_val(val_buf) + Long_val(val_ofs); + size_t len = (size_t) Long_val(val_len); + caml_release_runtime_system(); + ssize_t n = send(fd, buf, len, 0); + caml_acquire_runtime_system(); + if (n < 0) unix_error(errno, "send", Nothing); + CAMLreturn(Val_int(n)); +} + +CAMLprim value stub_cstruct_recv(value val_fd, value val_buf, value val_ofs, value val_len) { + CAMLparam4(val_fd, val_buf, val_ofs, val_len); +#ifdef WIN32 + caml_failwith("stub_cstruct_recv not implemented on Win32"); +#endif + int fd = Int_val(val_fd); + void *buf = (void*)Caml_ba_data_val(val_buf) + Long_val(val_ofs); + size_t len = (size_t) Long_val(val_len); + caml_release_runtime_system(); + ssize_t n = recv(fd, buf, len, 0); + caml_acquire_runtime_system(); + if (n < 0) unix_error(errno, "recv", Nothing); + CAMLreturn(Val_int(n)); +} \ No newline at end of file diff --git a/src/hostnet/utils.ml b/src/hostnet/utils.ml index dd0ee911a..6c7c78310 100644 --- a/src/hostnet/utils.ml +++ b/src/hostnet/utils.ml @@ -5,3 +5,12 @@ let somaxconn = ref (get_SOMAXCONN ()) external rtlGenRandom: int -> bytes option = "stub_RtlGenRandom" external setSocketTTL: Unix.file_descr -> int -> unit = "stub_setSocketTTL" + +type buffer = (char, Bigarray.int8_unsigned_elt, Bigarray.c_layout) Bigarray.Array1.t + +external stub_cstruct_send: Unix.file_descr -> buffer -> int -> int -> int = "stub_cstruct_send" +let cstruct_send fd c = stub_cstruct_send fd c.Cstruct.buffer c.Cstruct.off c.Cstruct.len + +external stub_cstruct_recv: Unix.file_descr -> buffer -> int -> int -> int = "stub_cstruct_recv" +let cstruct_recv fd c = stub_cstruct_recv fd c.Cstruct.buffer c.Cstruct.off c.Cstruct.len + diff --git a/src/hostnet/utils.mli b/src/hostnet/utils.mli index a22d24f55..4d6b0e730 100644 --- a/src/hostnet/utils.mli +++ b/src/hostnet/utils.mli @@ -7,3 +7,9 @@ val rtlGenRandom: int -> bytes option val setSocketTTL: Unix.file_descr -> int -> unit (** [setSocketTTL s ttl] sets the TTL on the socket [s] to [ttl] *) + +val cstruct_send: Unix.file_descr -> Cstruct.t -> int +(** [cstruct_send fd c] can be used to send a datagram *) + +val cstruct_recv: Unix.file_descr -> Cstruct.t -> int +(** [cstruct_recv fd c] can be used to receive a datagram *) \ No newline at end of file diff --git a/src/hostnet/vmnet_dgram.ml b/src/hostnet/vmnet_dgram.ml new file mode 100644 index 000000000..4dc8f2b40 --- /dev/null +++ b/src/hostnet/vmnet_dgram.ml @@ -0,0 +1,415 @@ +open Lwt.Infix + +let src = + let src = Logs.Src.create "vmnet_dgram" ~doc:"vmnet_dgram" in + Logs.Src.set_level src (Some Logs.Info); + src + +module Log = (val Logs.src_log src : Logs.LOG) +open Vmnet_proto + +module Make (C : Sig.UNIX_DGRAM) = struct + type error = Mirage_net.Net.error + + let pp_error ppf = function + | #Mirage_net.Net.error as e -> Mirage_net.Net.pp_error ppf e + + let failf fmt = Fmt.kstr (fun e -> Lwt_result.fail (`Msg e)) fmt + + type t = { + mutable fd : C.flow option; + stats : Mirage_net.stats; + client_uuid : Uuidm.t; + client_macaddr : Macaddr.t; + server_macaddr : Macaddr.t; + mtu : int; + write_m : Lwt_mutex.t; + mutable pcap : Unix.file_descr option; + mutable pcap_size_limit : int64 option; + pcap_m : Lwt_mutex.t; + mutable listeners : (Cstruct.t -> unit Lwt.t) list; + mutable listening : bool; + after_disconnect : unit Lwt.t; + after_disconnect_u : unit Lwt.u; + (* NB: The Mirage DHCP client calls `listen` and then later the + Tcp_direct_direct will do the same. This behaviour seems to be + undefined, but common implementations adopt a last-caller-wins + semantic. This is the last caller wins callback *) + mutable callback : Cstruct.t -> unit Lwt.t; + log_prefix : string; + } + + let get_client_uuid t = t.client_uuid + let get_client_macaddr t = t.client_macaddr + let with_msg x f = match x with Ok x -> f x | Error _ as e -> Lwt.return e + let server_log_prefix = "Vmnet_dgram.Server" + let client_log_prefix = "Vmnet_dgram.Client" + + let read_exactly len flow = + C.recv flow >>= fun buf -> + if len <> Cstruct.length buf then + Lwt.fail_with + (Printf.sprintf "recv: expected length is %d but only received %d" len + (Cstruct.length buf)) + else Lwt.return buf + + let server_negotiate ~fd ~connect_client_fn ~mtu = + let assign_uuid_ip uuid ip = + connect_client_fn uuid ip >>= fun mac -> + match mac with + | Error (`Msg msg) -> + let buf = Cstruct.create Response.sizeof in + let (_ : Cstruct.t) = Response.marshal (Disconnect msg) buf in + Log.err (fun f -> + f "%s.negotiate: disconnecting client, reason: %s" + server_log_prefix msg); + C.send fd buf >>= fun () -> + failf "%s.negotiate: disconnecting client, reason: %s " + server_log_prefix msg + | Ok client_macaddr -> + let vif = Vif.create client_macaddr mtu () in + let buf = Cstruct.create Response.sizeof in + let (_ : Cstruct.t) = Response.marshal (Vif vif) buf in + Log.info (fun f -> + f "%s.negotiate: sending %s" server_log_prefix (Vif.to_string vif)); + C.send fd buf >>= fun () -> Lwt_result.return (uuid, client_macaddr) + in + read_exactly Init.sizeof fd >>= fun buf -> + let init, _ = Init.unmarshal buf in + Log.info (fun f -> + f "%s.negotiate: received %s" server_log_prefix (Init.to_string init)); + match init.version with + | 22l -> ( + let (_ : Cstruct.t) = Init.marshal Init.default buf in + C.send fd buf >>= fun () -> + read_exactly Command.sizeof fd >>= fun buf -> + with_msg (Command.unmarshal buf) @@ fun (command, _) -> + Log.info (fun f -> + f "%s.negotiate: received %s" server_log_prefix + (Command.to_string command)); + match command with + | Command.Bind_ipv4 _ -> + let buf = Cstruct.create Response.sizeof in + let (_ : Cstruct.t) = + Response.marshal (Disconnect "Unsupported command Bind_ipv4") buf + in + C.send fd buf >>= fun () -> + failf "%s.negotiate: unsupported command Bind_ipv4" + server_log_prefix + | Command.Ethernet uuid -> assign_uuid_ip uuid None + | Command.Preferred_ipv4 (uuid, ip) -> assign_uuid_ip uuid (Some ip)) + | x -> + let (_ : Cstruct.t) = Init.marshal Init.default buf in + (* write our version before disconnecting *) + C.send fd buf >>= fun () -> + Log.err (fun f -> + f + "%s: Client requested protocol version %s, server only supports \ + version %s" + server_log_prefix (Int32.to_string x) + (Int32.to_string Init.default.version)); + Lwt_result.fail (`Msg "Client requested unsupported protocol version") + + let client_negotiate ~uuid ?preferred_ip ~fd () = + let buf = Cstruct.create Init.sizeof in + let (_ : Cstruct.t) = Init.marshal Init.default buf in + C.send fd buf >>= fun () -> + read_exactly Init.sizeof fd >>= fun buf -> + let init, _ = Init.unmarshal buf in + Log.info (fun f -> + f "%s.negotiate: received %s" client_log_prefix (Init.to_string init)); + match init.version with + | 22l -> ( + let buf = Cstruct.create Command.sizeof in + let (_ : Cstruct.t) = + match preferred_ip with + | None -> Command.marshal (Command.Ethernet uuid) buf + | Some ip -> Command.marshal (Command.Preferred_ipv4 (uuid, ip)) buf + in + C.send fd buf >>= fun () -> + read_exactly Response.sizeof fd >>= fun buf -> + let open Lwt_result.Infix in + Lwt.return (Response.unmarshal buf) >>= fun (response, _) -> + match response with + | Vif vif -> + Log.debug (fun f -> + f "%s.negotiate: vif %s" client_log_prefix (Vif.to_string vif)); + Lwt_result.return vif + | Disconnect reason -> + let msg = "Server disconnected with reason: " ^ reason in + Log.err (fun f -> f "%s.negotiate: %s" client_log_prefix msg); + Lwt_result.fail (`Msg msg)) + | x -> + Log.err (fun f -> + f "%s: Server requires protocol version %s, we have %s" + client_log_prefix (Int32.to_string x) + (Int32.to_string Init.default.version)); + Lwt_result.fail + (`Msg "Server does not support our version of the protocol") + + (* Use blocking I/O here so we can avoid Using Lwt_unix or Uwt. Ideally we + would use a FLOW handle referencing a file/stream. *) + let really_write fd str = + let rec loop ofs = + if ofs = Bytes.length str then () + else + let n = Unix.write fd str ofs (Bytes.length str - ofs) in + loop (ofs + n) + in + loop 0 + + let start_capture t ?size_limit filename = + Lwt_mutex.with_lock t.pcap_m (fun () -> + (match t.pcap with Some fd -> Unix.close fd | None -> ()); + let fd = + Unix.openfile filename + [ Unix.O_WRONLY; Unix.O_TRUNC; Unix.O_CREAT ] + 0o0644 + in + let buf = Cstruct.create Pcap.LE.sizeof_pcap_header in + let open Pcap.LE in + set_pcap_header_magic_number buf Pcap.magic_number; + set_pcap_header_version_major buf Pcap.major_version; + set_pcap_header_version_minor buf Pcap.minor_version; + set_pcap_header_thiszone buf 0l; + set_pcap_header_sigfigs buf 4l; + set_pcap_header_snaplen buf 1500l; + set_pcap_header_network buf + (Pcap.Network.to_int32 Pcap.Network.Ethernet); + really_write fd (Cstruct.to_string buf |> Bytes.of_string); + t.pcap <- Some fd; + t.pcap_size_limit <- size_limit; + Lwt.return ()) + + let stop_capture_already_locked t = + match t.pcap with + | None -> () + | Some fd -> + Unix.close fd; + t.pcap <- None; + t.pcap_size_limit <- None + + let stop_capture t = + Lwt_mutex.with_lock t.pcap_m (fun () -> + stop_capture_already_locked t; + Lwt.return_unit) + + let make ~client_macaddr ~server_macaddr ~mtu ~client_uuid ~log_prefix fd = + let fd = Some fd in + let stats = Mirage_net.Stats.create () in + let write_m = Lwt_mutex.create () in + let pcap = None in + let pcap_size_limit = None in + let pcap_m = Lwt_mutex.create () in + let listeners = [] in + let listening = false in + let after_disconnect, after_disconnect_u = Lwt.task () in + let callback _ = Lwt.return_unit in + { + fd; + stats; + client_macaddr; + client_uuid; + server_macaddr; + mtu; + write_m; + pcap; + pcap_size_limit; + pcap_m; + listeners; + listening; + after_disconnect; + after_disconnect_u; + callback; + log_prefix; + } + + type fd = C.flow + + let of_fd ~connect_client_fn ~server_macaddr ~mtu fd = + let open Lwt_result.Infix in + server_negotiate ~fd ~connect_client_fn ~mtu + >>= fun (client_uuid, client_macaddr) -> + let t = + make ~client_macaddr ~server_macaddr ~mtu ~client_uuid + ~log_prefix:server_log_prefix fd + in + Lwt_result.return t + + let client_of_fd ~uuid ?preferred_ip ~server_macaddr flow = + let open Lwt_result.Infix in + client_negotiate ~uuid ?preferred_ip ~fd:flow () >>= fun vif -> + let t = + make ~client_macaddr:server_macaddr ~server_macaddr:vif.Vif.client_macaddr + ~mtu:vif.Vif.mtu ~client_uuid:uuid ~log_prefix:client_log_prefix flow + in + Lwt_result.return t + + let disconnect t = + match t.fd with + | None -> Lwt.return () + | Some _fd -> + Log.info (fun f -> f "%s.disconnect" t.log_prefix); + t.fd <- None; + Log.debug (fun f -> f "%s.disconnect flushing channel" t.log_prefix); + Lwt.wakeup_later t.after_disconnect_u (); + Lwt.return_unit + + let after_disconnect t = t.after_disconnect + + let capture t bufs = + match t.pcap with + | None -> Lwt.return () + | Some pcap -> + Lwt_mutex.with_lock t.pcap_m (fun () -> + let len = List.(fold_left ( + ) 0 (map Cstruct.length bufs)) in + let time = Unix.gettimeofday () in + let secs = Int32.of_float time in + let usecs = Int32.of_float (1e6 *. (time -. floor time)) in + let buf = Cstruct.create Pcap.sizeof_pcap_packet in + let open Pcap.LE in + set_pcap_packet_ts_sec buf secs; + set_pcap_packet_ts_usec buf usecs; + set_pcap_packet_incl_len buf @@ Int32.of_int len; + set_pcap_packet_orig_len buf @@ Int32.of_int len; + really_write pcap (Cstruct.to_string buf |> Bytes.of_string); + List.iter + (fun buf -> + really_write pcap (Cstruct.to_string buf |> Bytes.of_string)) + bufs; + match t.pcap_size_limit with + | None -> Lwt.return () (* no limit *) + | Some limit -> + let limit = Int64.(sub limit (of_int len)) in + t.pcap_size_limit <- Some limit; + if limit < 0L then stop_capture_already_locked t; + Lwt.return_unit) + + let with_fd t f = match t.fd with None -> Lwt.return false | Some fd -> f fd + + let listen_nocancel t new_callback = + Log.info (fun f -> + f "%s.listen: rebinding the primary listen callback" t.log_prefix); + t.callback <- new_callback; + + let last_error_log = ref 0. in + let rec loop () = + ( with_fd t @@ fun fd -> + C.recv fd >>= fun buf -> + capture t [ buf ] >>= fun () -> + Log.debug (fun f -> + let b = Buffer.create 128 in + Cstruct.hexdump_to_buffer b buf; + f "received%s" (Buffer.contents b)); + let callback buf = + Lwt.catch + (fun () -> t.callback buf) + (function + | e -> + let now = Unix.gettimeofday () in + if now -. !last_error_log > 30. then ( + Log.err (fun f -> + f "%s.listen callback caught %a" t.log_prefix Fmt.exn e); + last_error_log := now); + Lwt.return_unit) + in + Lwt.async (fun () -> callback buf); + List.iter + (fun callback -> Lwt.async (fun () -> callback buf)) + t.listeners; + Lwt.return true ) + >>= function + | true -> loop () + | false -> Lwt.return () + in + (if not t.listening then ( + t.listening <- true; + Log.info (fun f -> f "%s.listen: starting event loop" t.log_prefix); + loop ()) + else ( + (* Block forever without running a second loop() *) + Log.info (fun f -> f "%s.listen: blocking until disconnect" t.log_prefix); + t.after_disconnect >>= fun () -> + Log.info (fun f -> f "%s.listen: disconnected" t.log_prefix); + Lwt.return_unit)) + >>= fun () -> + Log.info (fun f -> f "%s.listen returning Ok()" t.log_prefix); + Lwt.return (Ok ()) + + let listen t ~header_size:_ new_callback = + let task, u = Lwt.task () in + (* There is a clash over the Netif.listen callbacks between the DHCP client (which + wants ethernet frames) and the rest of the TCP/IP stack. It seems to work + usually by accident: first the DHCP client calls `listen`, performs a transaction + and then the main stack calls `listen` and this overrides the DHCP client listen. + Unfortunately the DHCP client calls `cancel` after 4s which can ripple through + and cancel the ethernet `read`. We work around that by ignoring `cancel`. *) + Lwt.on_cancel task (fun () -> + Log.warn (fun f -> + f "%s.listen: ignoring Lwt.cancel (called from the DHCP client)" + t.log_prefix)); + let _ = + listen_nocancel t new_callback >>= fun x -> + Lwt.wakeup_later u x; + Lwt.return_unit + in + task + + let write t ~size fill = + Lwt_mutex.with_lock t.write_m (fun () -> + let allocated = Cstruct.create (size + t.mtu) in + let len = fill allocated in + let buf = Cstruct.sub allocated 0 len in + capture t [ buf ] >>= fun () -> + if len > t.mtu + ethernet_header_length then ( + Log.err (fun f -> + f "%s Dropping over-large ethernet frame, length = %d, mtu = %d" + t.log_prefix len t.mtu); + Lwt.return (Ok ())) + else + match t.fd with + | None -> Lwt.return (Error `Disconnected) + | Some fd -> + Log.debug (fun f -> + let b = Buffer.create 128 in + Cstruct.hexdump_to_buffer b buf; + f "sending%s" (Buffer.contents b)); + C.send fd buf >>= fun () -> Lwt.return (Ok ())) + + let add_listener t callback = t.listeners <- callback :: t.listeners + let mac t = t.server_macaddr + let mtu t = t.mtu + let get_stats_counters t = t.stats + let reset_stats_counters t = Mirage_net.Stats.reset t.stats +end + +let%test_unit "negotiate" = + if Sys.os_type <> "Win32" then + let module V = Make (Host_unix_dgram) in + Lwt_main.run + (let address = "/tmp/vmnet_dgram.sock" in + (try Unix.unlink address with Unix.Unix_error (Unix.ENOENT, _, _) -> ()); + let expected_uuid = Uuidm.v `V4 in + let expected_mtu = 1500 in + let expected_mac = Macaddr.of_string_exn "C0:FF:EE:C0:FF:EE" in + Host_unix_dgram.bind address >>= fun server -> + Host_unix_dgram.listen server (fun flow -> + let connect_client_fn _uuid _ip = Lwt.return (Ok expected_mac) in + V.server_negotiate ~fd:flow ~connect_client_fn ~mtu:expected_mtu + >>= function + | Error (`Msg m) -> failwith m + | Ok (_uuid, _mac) -> Lwt.return_unit); + Host_unix_dgram.connect address >>= fun flow -> + V.client_negotiate ~uuid:expected_uuid ~fd:flow () >>= function + | Error (`Msg m) -> failwith m + | Ok vif -> + if vif.mtu <> expected_mtu then + failwith + (Printf.sprintf "vif.mtu (%d) <> expected_mtu (%d)" vif.mtu + expected_mtu); + if Macaddr.compare vif.client_macaddr expected_mac <> 0 then + failwith + (Printf.sprintf "vif.client_macaddr (%s) <> expected_mac (%s)" + (Macaddr.to_string vif.client_macaddr) + (Macaddr.to_string expected_mac)); + Lwt.return_unit) diff --git a/src/hostnet/vmnet_dgram.mli b/src/hostnet/vmnet_dgram.mli new file mode 100644 index 000000000..217fcbea3 --- /dev/null +++ b/src/hostnet/vmnet_dgram.mli @@ -0,0 +1,52 @@ +module Make (C : Sig.UNIX_DGRAM) : sig + (** Accept connections and talk to clients via the vmnetd protocol, exposing + the packets as a Mirage NETWORK interface *) + + type fd = C.flow + + include Mirage_net.S + + val after_disconnect : t -> unit Lwt.t + (** [after_disconnect connection] resolves after [connection] has + disconnected. *) + + val add_listener : t -> (Cstruct.t -> unit Lwt.t) -> unit + + val of_fd : + connect_client_fn: + (Uuidm.t -> + Ipaddr.V4.t option -> + (Macaddr.t, [ `Msg of string ]) result Lwt.t) -> + server_macaddr:Macaddr.t -> + mtu:int -> + C.flow -> + (t, [ `Msg of string ]) result Lwt.t + (** [of_fd ~connect_client_fn ~server_macaddr ~mtu fd] + negotiates with the client over [fd]. The server uses + [connect_client_fn] to create a source address for the + client's ethernet frames based on a uuid supplied by the + client and an optional preferred IP address. The server uses + [server_macaddr] as the source address of all its ethernet frames and + sets the MTU to [mtu]. *) + + val client_of_fd : + uuid:Uuidm.t -> + ?preferred_ip:Ipaddr.V4.t -> + server_macaddr:Macaddr.t -> + C.flow -> + (t, [ `Msg of string ]) result Lwt.t + + val start_capture : t -> ?size_limit:int64 -> string -> unit Lwt.t + (** [start_capture t ?size_limit filename] closes any existing pcap + capture file and starts capturing to [filename]. If + [?size_limit] is provided then the file will be automatically + closed after the given number of bytes are written -- this is to + avoid forgetting to close the file and filling up your storage + with capture data. *) + + val stop_capture : t -> unit Lwt.t + (** [stop_capture t] stops any in-progress capture and closes the file. *) + + val get_client_uuid : t -> Uuidm.t + val get_client_macaddr : t -> Macaddr.t +end diff --git a/src/hostnet/vmnet_proto.ml b/src/hostnet/vmnet_proto.ml new file mode 100644 index 000000000..001c7c9a1 --- /dev/null +++ b/src/hostnet/vmnet_proto.ml @@ -0,0 +1,183 @@ +let src = + let src = Logs.Src.create "vmnet_proto" ~doc:"vmnet_proto" in + Logs.Src.set_level src (Some Logs.Info); + src + +module Log = (val Logs.src_log src : Logs.LOG) + +let ethernet_header_length = 14 (* no VLAN *) + +module Init = struct + type t = { magic : string; version : int32; commit : string } + + let to_string t = + Fmt.str "{ magic = %s; version = %ld; commit = %s }" t.magic t.version + t.commit + + let sizeof = 5 + 4 + 40 + + let default = + { + magic = "VMN3T"; + version = 22l; + commit = "0123456789012345678901234567890123456789"; + } + + let marshal t rest = + Cstruct.blit_from_string t.magic 0 rest 0 5; + Cstruct.LE.set_uint32 rest 5 t.version; + Cstruct.blit_from_string t.commit 0 rest 9 40; + Cstruct.shift rest sizeof + + let unmarshal rest = + let magic = Cstruct.(to_string @@ sub rest 0 5) in + let version = Cstruct.LE.get_uint32 rest 5 in + let commit = Cstruct.(to_string @@ sub rest 9 40) in + let rest = Cstruct.shift rest sizeof in + ({ magic; version; commit }, rest) +end + +module Command = struct + type t = + | Ethernet of Uuidm.t (* 36 bytes *) + | Preferred_ipv4 of Uuidm.t (* 36 bytes *) * Ipaddr.V4.t + | Bind_ipv4 of Ipaddr.V4.t * int * bool + + let to_string = function + | Ethernet x -> Fmt.str "Ethernet %a" Uuidm.pp x + | Preferred_ipv4 (uuid, ip) -> + Fmt.str "Preferred_ipv4 %a %a" Uuidm.pp uuid Ipaddr.V4.pp ip + | Bind_ipv4 (ip, port, tcp) -> + Fmt.str "Bind_ipv4 %a %d %b" Ipaddr.V4.pp ip port tcp + + let sizeof = 1 + 36 + 4 + + let marshal t rest = + match t with + | Ethernet uuid -> + Cstruct.set_uint8 rest 0 1; + let rest = Cstruct.shift rest 1 in + let uuid_str = Uuidm.to_string uuid in + Cstruct.blit_from_string uuid_str 0 rest 0 (String.length uuid_str); + Cstruct.shift rest (String.length uuid_str) + | Preferred_ipv4 (uuid, ip) -> + Cstruct.set_uint8 rest 0 8; + let rest = Cstruct.shift rest 1 in + let uuid_str = Uuidm.to_string uuid in + Cstruct.blit_from_string uuid_str 0 rest 0 (String.length uuid_str); + let rest = Cstruct.shift rest (String.length uuid_str) in + Cstruct.LE.set_uint32 rest 0 (Ipaddr.V4.to_int32 ip); + Cstruct.shift rest 4 + | Bind_ipv4 (ip, port, stream) -> + Cstruct.set_uint8 rest 0 6; + let rest = Cstruct.shift rest 1 in + Cstruct.LE.set_uint32 rest 0 (Ipaddr.V4.to_int32 ip); + let rest = Cstruct.shift rest 4 in + Cstruct.LE.set_uint16 rest 0 port; + let rest = Cstruct.shift rest 2 in + Cstruct.set_uint8 rest 0 (if stream then 0 else 1); + Cstruct.shift rest 1 + + let unmarshal rest = + let process_uuid uuid_str = + if String.compare (String.make 36 '\000') uuid_str = 0 then ( + let random_uuid = Uuidm.v `V4 in + Log.info (fun f -> + f "Generated UUID on behalf of client: %a" Uuidm.pp random_uuid); + (* generate random uuid on behalf of client if client sent + array of \0 *) + Some random_uuid) + else Uuidm.of_string uuid_str + in + match Cstruct.get_uint8 rest 0 with + | 1 -> ( + (* ethernet *) + let uuid_str = Cstruct.(to_string (sub rest 1 36)) in + let rest = Cstruct.shift rest 37 in + match process_uuid uuid_str with + | Some uuid -> Ok (Ethernet uuid, rest) + | None -> Error (`Msg (Printf.sprintf "Invalid UUID: %s" uuid_str))) + | 8 -> ( + (* preferred_ipv4 *) + let uuid_str = Cstruct.(to_string (sub rest 1 36)) in + let rest = Cstruct.shift rest 37 in + let ip = Ipaddr.V4.of_int32 (Cstruct.LE.get_uint32 rest 0) in + let rest = Cstruct.shift rest 4 in + match process_uuid uuid_str with + | Some uuid -> Ok (Preferred_ipv4 (uuid, ip), rest) + | None -> Error (`Msg (Printf.sprintf "Invalid UUID: %s" uuid_str))) + | n -> Error (`Msg (Printf.sprintf "Unknown command: %d" n)) +end + +module Vif = struct + type t = { mtu : int; max_packet_size : int; client_macaddr : Macaddr.t } + + let to_string t = + Fmt.str "{ mtu = %d; max_packet_size = %d; client_macaddr = %s }" t.mtu + t.max_packet_size + (Macaddr.to_string t.client_macaddr) + + let create client_macaddr mtu () = + let max_packet_size = mtu + 50 in + { mtu; max_packet_size; client_macaddr } + + let sizeof = 2 + 2 + 6 + + let marshal t rest = + Cstruct.LE.set_uint16 rest 0 t.mtu; + Cstruct.LE.set_uint16 rest 2 t.max_packet_size; + Cstruct.blit_from_string (Macaddr.to_octets t.client_macaddr) 0 rest 4 6; + Cstruct.shift rest sizeof + + let unmarshal rest = + let mtu = Cstruct.LE.get_uint16 rest 0 in + let max_packet_size = Cstruct.LE.get_uint16 rest 2 in + let mac = Cstruct.(to_string @@ sub rest 4 6) in + try + let client_macaddr = Macaddr.of_octets_exn mac in + Ok ({ mtu; max_packet_size; client_macaddr }, Cstruct.shift rest sizeof) + with _ -> Error (`Msg (Printf.sprintf "Failed to parse MAC: [%s]" mac)) +end + +module Response = struct + type t = + | Vif of Vif.t + (* 10 bytes *) + | Disconnect of string + (* disconnect reason *) + + let sizeof = 1 + 1 + 256 (* leave room for error message and length *) + + let marshal t rest = + match t with + | Vif vif -> + Cstruct.set_uint8 rest 0 1; + let rest = Cstruct.shift rest 1 in + Vif.marshal vif rest + | Disconnect reason -> + Cstruct.set_uint8 rest 0 2; + let rest = Cstruct.shift rest 1 in + Cstruct.set_uint8 rest 0 (String.length reason); + let rest = Cstruct.shift rest 1 in + Cstruct.blit_from_string reason 0 rest 0 (String.length reason); + Cstruct.shift rest (String.length reason) + + let unmarshal rest = + match Cstruct.get_uint8 rest 0 with + | 1 -> ( + (* vif *) + let rest = Cstruct.shift rest 1 in + let vif = Vif.unmarshal rest in + match vif with + | Ok (vif, rest) -> Ok (Vif vif, rest) + | Error msg -> Error msg) + | 2 -> + (* disconnect *) + let rest = Cstruct.shift rest 1 in + let str_len = Cstruct.get_uint8 rest 0 in + let rest = Cstruct.shift rest 1 in + let reason_str = Cstruct.(to_string (sub rest 0 str_len)) in + let rest = Cstruct.shift rest str_len in + Ok (Disconnect reason_str, rest) + | n -> Error (`Msg (Printf.sprintf "Unknown response: %d" n)) +end diff --git a/src/hostnet/vmnet_proto.mli b/src/hostnet/vmnet_proto.mli new file mode 100644 index 000000000..95d680517 --- /dev/null +++ b/src/hostnet/vmnet_proto.mli @@ -0,0 +1,45 @@ +val ethernet_header_length : int + +module Init : sig + type t = { magic : string; version : int32; commit : string } + + val to_string : t -> string + val sizeof : int + val default : t + val marshal : t -> Cstruct.t -> Cstruct.t + val unmarshal : Cstruct.t -> t * Cstruct.t +end + +module Command : sig + type t = + | Ethernet of Uuidm.t (* 36 bytes *) + | Preferred_ipv4 of Uuidm.t (* 36 bytes *) * Ipaddr.V4.t + | Bind_ipv4 of Ipaddr.V4.t * int * bool + + val to_string : t -> string + val sizeof : int + val marshal : t -> Cstruct.t -> Cstruct.t + val unmarshal : Cstruct.t -> (t * Cstruct.t, [ `Msg of string ]) result +end + +module Vif : sig + type t = { mtu : int; max_packet_size : int; client_macaddr : Macaddr.t } + + val create : Macaddr.t -> int -> unit -> t + val to_string : t -> string + val sizeof : int + val marshal : t -> Cstruct.t -> Cstruct.t + val unmarshal : Cstruct.t -> (t * Cstruct.t, [> `Msg of string ]) result +end + +module Response : sig + type t = + | Vif of Vif.t + (* 10 bytes *) + | Disconnect of string + (* disconnect reason *) + + val sizeof : int + val marshal : t -> Cstruct.t -> Cstruct.t + val unmarshal : Cstruct.t -> (t * Cstruct.t, [> `Msg of string ]) result +end diff --git a/src/hostnet/vmnet.ml b/src/hostnet/vmnet_stream.ml similarity index 73% rename from src/hostnet/vmnet.ml rename to src/hostnet/vmnet_stream.ml index 39d02bd8f..d1065550d 100644 --- a/src/hostnet/vmnet.ml +++ b/src/hostnet/vmnet_stream.ml @@ -7,190 +7,7 @@ let src = module Log = (val Logs.src_log src : Logs.LOG) -let ethernet_header_length = 14 (* no VLAN *) - -module Init = struct - - type t = { - magic: string; - version: int32; - commit: string; - } - - let to_string t = - Fmt.str "{ magic = %s; version = %ld; commit = %s }" - t.magic t.version t.commit - - let sizeof = 5 + 4 + 40 - - let default = { - magic = "VMN3T"; - version = 22l; - commit = "0123456789012345678901234567890123456789"; - } - - let marshal t rest = - Cstruct.blit_from_string t.magic 0 rest 0 5; - Cstruct.LE.set_uint32 rest 5 t.version; - Cstruct.blit_from_string t.commit 0 rest 9 40; - Cstruct.shift rest sizeof - - let unmarshal rest = - let magic = Cstruct.(to_string @@ sub rest 0 5) in - let version = Cstruct.LE.get_uint32 rest 5 in - let commit = Cstruct.(to_string @@ sub rest 9 40) in - let rest = Cstruct.shift rest sizeof in - { magic; version; commit }, rest -end - -module Command = struct - - type t = - | Ethernet of Uuidm.t (* 36 bytes *) - | Preferred_ipv4 of Uuidm.t (* 36 bytes *) * Ipaddr.V4.t - | Bind_ipv4 of Ipaddr.V4.t * int * bool - - let to_string = function - | Ethernet x -> Fmt.str "Ethernet %a" Uuidm.pp x - | Preferred_ipv4 (uuid, ip) -> - Fmt.str "Preferred_ipv4 %a %a" Uuidm.pp uuid Ipaddr.V4.pp ip - | Bind_ipv4 (ip, port, tcp) -> - Fmt.str "Bind_ipv4 %a %d %b" Ipaddr.V4.pp ip port tcp - - let sizeof = 1 + 36 + 4 - - let marshal t rest = match t with - | Ethernet uuid -> - Cstruct.set_uint8 rest 0 1; - let rest = Cstruct.shift rest 1 in - let uuid_str = Uuidm.to_string uuid in - Cstruct.blit_from_string uuid_str 0 rest 0 (String.length uuid_str); - Cstruct.shift rest (String.length uuid_str) - | Preferred_ipv4 (uuid, ip) -> - Cstruct.set_uint8 rest 0 8; - let rest = Cstruct.shift rest 1 in - let uuid_str = Uuidm.to_string uuid in - Cstruct.blit_from_string uuid_str 0 rest 0 (String.length uuid_str); - let rest = Cstruct.shift rest (String.length uuid_str) in - Cstruct.LE.set_uint32 rest 0 (Ipaddr.V4.to_int32 ip); - Cstruct.shift rest 4 - | Bind_ipv4 (ip, port, stream) -> - Cstruct.set_uint8 rest 0 6; - let rest = Cstruct.shift rest 1 in - Cstruct.LE.set_uint32 rest 0 (Ipaddr.V4.to_int32 ip); - let rest = Cstruct.shift rest 4 in - Cstruct.LE.set_uint16 rest 0 port; - let rest = Cstruct.shift rest 2 in - Cstruct.set_uint8 rest 0 (if stream then 0 else 1); - Cstruct.shift rest 1 - - let unmarshal rest = - let process_uuid uuid_str = - if (String.compare (String.make 36 '\000') uuid_str) = 0 then - begin - let random_uuid = (Uuidm.v `V4) in - Log.info (fun f -> - f "Generated UUID on behalf of client: %a" Uuidm.pp random_uuid); - (* generate random uuid on behalf of client if client sent - array of \0 *) - Some random_uuid - end else - Uuidm.of_string uuid_str - in - match Cstruct.get_uint8 rest 0 with - | 1 -> (* ethernet *) - let uuid_str = Cstruct.(to_string (sub rest 1 36)) in - let rest = Cstruct.shift rest 37 in - (match process_uuid uuid_str with - | Some uuid -> Ok (Ethernet uuid, rest) - | None -> Error (`Msg (Printf.sprintf "Invalid UUID: %s" uuid_str))) - | 8 -> (* preferred_ipv4 *) - let uuid_str = Cstruct.(to_string (sub rest 1 36)) in - let rest = Cstruct.shift rest 37 in - let ip = Ipaddr.V4.of_int32 (Cstruct.LE.get_uint32 rest 0) in - let rest = Cstruct.shift rest 4 in - (match process_uuid uuid_str with - | Some uuid -> Ok (Preferred_ipv4 (uuid, ip), rest) - | None -> Error (`Msg (Printf.sprintf "Invalid UUID: %s" uuid_str))) - | n -> Error (`Msg (Printf.sprintf "Unknown command: %d" n)) - -end - -module Vif = struct - - type t = { - mtu: int; - max_packet_size: int; - client_macaddr: Macaddr.t; - } - - let to_string t = - Fmt.str "{ mtu = %d; max_packet_size = %d; client_macaddr = %s }" - t.mtu t.max_packet_size (Macaddr.to_string t.client_macaddr) - - let create client_macaddr mtu () = - let max_packet_size = mtu + 50 in - { mtu; max_packet_size; client_macaddr } - - let sizeof = 2 + 2 + 6 - - let marshal t rest = - Cstruct.LE.set_uint16 rest 0 t.mtu; - Cstruct.LE.set_uint16 rest 2 t.max_packet_size; - Cstruct.blit_from_string (Macaddr.to_octets t.client_macaddr) 0 rest 4 6; - Cstruct.shift rest sizeof - - let unmarshal rest = - let mtu = Cstruct.LE.get_uint16 rest 0 in - let max_packet_size = Cstruct.LE.get_uint16 rest 2 in - let mac = Cstruct.(to_string @@ sub rest 4 6) in - try - let client_macaddr = Macaddr.of_octets_exn mac in - Ok ({ mtu; max_packet_size; client_macaddr }, Cstruct.shift rest sizeof) - with _ -> - Error (`Msg (Printf.sprintf "Failed to parse MAC: [%s]" mac)) - -end - -module Response = struct - type t = - | Vif of Vif.t (* 10 bytes *) - | Disconnect of string (* disconnect reason *) - - let sizeof = 1+1+256 (* leave room for error message and length *) - - let marshal t rest = match t with - | Vif vif -> - Cstruct.set_uint8 rest 0 1; - let rest = Cstruct.shift rest 1 in - Vif.marshal vif rest - | Disconnect reason -> - Cstruct.set_uint8 rest 0 2; - let rest = Cstruct.shift rest 1 in - Cstruct.set_uint8 rest 0 (String.length reason); - let rest = Cstruct.shift rest 1 in - Cstruct.blit_from_string reason 0 rest 0 (String.length reason); - Cstruct.shift rest (String.length reason) - - let unmarshal rest = - match Cstruct.get_uint8 rest 0 with - | 1 -> (* vif *) - let rest = Cstruct.shift rest 1 in - let vif = Vif.unmarshal rest in - (match vif with - | Ok (vif, rest) -> Ok (Vif vif, rest) - | Error msg -> Error (msg)) - | 2 -> (* disconnect *) - let rest = Cstruct.shift rest 1 in - let str_len = Cstruct.get_uint8 rest 0 in - let rest = Cstruct.shift rest 1 in - let reason_str = Cstruct.(to_string (sub rest 0 str_len)) in - let rest = Cstruct.shift rest str_len in - Ok (Disconnect reason_str, rest) - | n -> Error (`Msg (Printf.sprintf "Unknown response: %d" n)) - -end - +open Vmnet_proto module Packet = struct let sizeof = 2 diff --git a/src/hostnet/vmnet.mli b/src/hostnet/vmnet_stream.mli similarity index 77% rename from src/hostnet/vmnet.mli rename to src/hostnet/vmnet_stream.mli index 2a49ec440..080766341 100644 --- a/src/hostnet/vmnet.mli +++ b/src/hostnet/vmnet_stream.mli @@ -44,28 +44,3 @@ module Make(C: Sig.CONN): sig end -module Init : sig - type t - - val to_string: t -> string - val sizeof: int - val default: t - - val marshal: t -> Cstruct.t -> Cstruct.t - val unmarshal: Cstruct.t -> t * Cstruct.t -end - -module Command : sig - - type t = - | Ethernet of Uuidm.t (* 36 bytes *) - | Preferred_ipv4 of Uuidm.t (* 36 bytes *) * Ipaddr.V4.t - | Bind_ipv4 of Ipaddr.V4.t * int * bool - - val to_string: t -> string - val sizeof: int - - val marshal: t -> Cstruct.t -> Cstruct.t - val unmarshal: Cstruct.t -> (t * Cstruct.t, [ `Msg of string ]) result -end - diff --git a/src/hostnet_test/slirp_stack.ml b/src/hostnet_test/slirp_stack.ml index 8ad6ca087..4334d7172 100644 --- a/src/hostnet_test/slirp_stack.ml +++ b/src/hostnet_test/slirp_stack.ml @@ -64,7 +64,7 @@ module Dns_policy = struct end -module VMNET = Vmnet.Make(Host.Sockets.Stream.Tcp) +module VMNET = Vmnet_stream.Make(Host.Sockets.Stream.Tcp) module Vnet = Basic_backend.Make module Slirp_stack = Slirp.Make(VMNET)(Dns_policy)(Mclock)(Mirage_random_stdlib)(Vnet)