path: root/tun/tun_windows.go

/* SPDX-License-Identifier: MIT
 *
 * Copyright (C) 2018-2019 WireGuard LLC. All Rights Reserved.
 */

package tun

import (
	"errors"
	"fmt"
	"os"
	"unsafe"

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

const (
	TUN_MAX_PACKET_SIZE      = 1600
	TUN_MAX_PACKET_EXCHANGE  = 256 // Number of packets that can be exchanged at a time
	TUN_EXCHANGE_BUFFER_SIZE = 410632
)

const (
	TUN_SIGNAL_DATA_AVAIL = 0
	TUN_SIGNAL_CLOSE      = 1

	TUN_SIGNAL_MAX = 2
)

type TunPacket struct {
	size uint32
	data [TUN_MAX_PACKET_SIZE]byte
}

type TunRWQueue struct {
	numPackets uint32
	packets    [TUN_MAX_PACKET_EXCHANGE]TunPacket
	left       uint32
}

type nativeTun struct {
	ifname       string
	tunName      string
	signalName   *uint16
	tunFile      *os.File
	wrBuff       TunRWQueue
	rdBuff       TunRWQueue
	signals      [TUN_SIGNAL_MAX]windows.Handle
	rdNextPacket uint32
	events       chan TUNEvent
	errors       chan error
}

func CreateTUN(ifname string) (TUNDevice, error) {
	signalNameUTF16, err := windows.UTF16PtrFromString(fmt.Sprintf("Global\\WINTUN_EVENT_%s", ifname))
	if err != nil {
		return nil, err
	}

	// Create instance.
	tun := &nativeTun{
		ifname:     ifname,
		tunName:    fmt.Sprintf("\\\\.\\Global\\WINTUN_DEVICE_%s", ifname),
		signalName: signalNameUTF16,
		events:     make(chan TUNEvent, 10),
		errors:     make(chan error, 1),
	}

	// Create close event.
	tun.signals[TUN_SIGNAL_CLOSE], err = windows.CreateEvent(nil, 1 /*TRUE*/, 0 /*FALSE*/, nil)
	if err != nil {
		return nil, err
	}

	return tun, nil
}

func (tun *nativeTun) openTUN() error {
	for {
		// Open interface data pipe.
		// Data pipe must be opened first, as the interface data available event is created when somebody actually connects to the data pipe.
		file, err := os.OpenFile(tun.tunName, os.O_RDWR|os.O_SYNC, 0600)
		if err != nil {
			// After examining possible error conditions, many arose that were only temporary: windows.ERROR_FILE_NOT_FOUND, "read <filename> closed", etc.
			// To simplify, we will enter a retry-loop on _any_ error until session is closed by user.
			switch evt, e := windows.WaitForSingleObject(tun.signals[TUN_SIGNAL_CLOSE], 1000); evt {
			case windows.WAIT_OBJECT_0, windows.WAIT_ABANDONED:
				return errors.New("TUN closed")
			case windows.WAIT_TIMEOUT:
				continue
			default:
				return errors.New("Unexpected result from WaitForSingleObject: " + e.Error())
			}
		}

		// Open interface data available event.
		event, err := windows.OpenEvent(windows.SYNCHRONIZE, false, tun.signalName)
		if err != nil {
			file.Close()
			return errors.New("Opening interface data ready event failed: " + err.Error())
		}

		tun.tunFile = file
		tun.signals[TUN_SIGNAL_DATA_AVAIL] = event

		return nil
	}
}

func (tun *nativeTun) closeTUN() (err error) {
	if tun.signals[TUN_SIGNAL_DATA_AVAIL] != 0 {
		// Close interface data ready event.
		e := windows.CloseHandle(tun.signals[TUN_SIGNAL_DATA_AVAIL])
		if err != nil {
			err = e
		}

		tun.signals[TUN_SIGNAL_DATA_AVAIL] = 0
	}

	if tun.tunFile != nil {
		// Close interface data pipe.
		e := tun.tunFile.Close()
		if err != nil {
			err = e
		}

		tun.tunFile = nil
	}

	return
}

func (tun *nativeTun) Name() (string, error) {
	return tun.ifname, nil
}

func (tun *nativeTun) File() *os.File {
	return nil
}

func (tun *nativeTun) Events() chan TUNEvent {
	return tun.events
}

func (tun *nativeTun) Close() error {
	windows.SetEvent(tun.signals[TUN_SIGNAL_CLOSE])
	err := windows.CloseHandle(tun.signals[TUN_SIGNAL_CLOSE])

	e := tun.closeTUN()
	if err == nil {
		err = e
	}

	if tun.events != nil {
		close(tun.events)
	}

	return err
}

func (tun *nativeTun) MTU() (int, error) {
	return 1500, nil
}

func (tun *nativeTun) Read(buff []byte, offset int) (int, error) {
	select {
	case err := <-tun.errors:
		return 0, err

	default:
		for {
			if tun.rdNextPacket < tun.rdBuff.numPackets {
				// Get packet from the queue.
				tunPacket := &tun.rdBuff.packets[tun.rdNextPacket]
				tun.rdNextPacket++

				if TUN_MAX_PACKET_SIZE < tunPacket.size {
					// Invalid packet size.
					continue
				}

				// Copy data.
				copy(buff[offset:], tunPacket.data[:tunPacket.size])
				return int(tunPacket.size), nil
			}

			if tun.signals[TUN_SIGNAL_DATA_AVAIL] == 0 {
				// Data pipe and interface data available event are not open (yet).
				err := tun.openTUN()
				if err != nil {
					return 0, err
				}
			}

			if tun.rdBuff.numPackets < TUN_MAX_PACKET_EXCHANGE || tun.rdBuff.left == 0 {
				// Buffer was not full. Wait for the interface data or user close.
				r, err := windows.WaitForMultipleObjects(tun.signals[:], false, windows.INFINITE)
				if err != nil {
					return 0, errors.New("Waiting for data failed: " + err.Error())
				}
				switch r {
				case windows.WAIT_OBJECT_0 + TUN_SIGNAL_DATA_AVAIL:
					// Data is available.
				case windows.WAIT_ABANDONED + TUN_SIGNAL_DATA_AVAIL:
					// TUN stopped. Reopen it.
					tun.closeTUN()
					continue
				case windows.WAIT_OBJECT_0 + TUN_SIGNAL_CLOSE, windows.WAIT_ABANDONED + TUN_SIGNAL_CLOSE:
					return 0, errors.New("TUN closed")
				case windows.WAIT_TIMEOUT:
					// Congratulations, we reached infinity. Let's do it again! :)
					continue
				default:
					return 0, errors.New("unexpected result from WaitForMultipleObjects")
				}
			}

			// Fill queue.
			data := (*[TUN_EXCHANGE_BUFFER_SIZE]byte)(unsafe.Pointer(&tun.rdBuff))
			n, err := tun.tunFile.Read(data[:])
			tun.rdNextPacket = 0
			if n != TUN_EXCHANGE_BUFFER_SIZE || err != nil {
				// TUN interface stopped, returned incomplete data, etc.
				// Retry.
				tun.rdBuff.numPackets = 0
				tun.closeTUN()
				continue
			}
		}
	}
}

func (tun *nativeTun) flush() error {
	// Flush write buffer.
	data := (*[TUN_EXCHANGE_BUFFER_SIZE]byte)(unsafe.Pointer(&tun.wrBuff))
	n, err := tun.tunFile.Write(data[:])
	tun.wrBuff.numPackets = 0
	if err != nil {
		return err
	}
	if n != TUN_EXCHANGE_BUFFER_SIZE {
		return fmt.Errorf("%d byte(s) written, %d byte(s) expected", n, TUN_EXCHANGE_BUFFER_SIZE)
	}

	return nil
}

func (tun *nativeTun) putTunPacket(buff []byte) error {
	size := len(buff)
	if size == 0 {
		return errors.New("Empty packet")
	}
	if size > TUN_MAX_PACKET_SIZE {
		return errors.New("Packet too big")
	}

	if tun.wrBuff.numPackets >= TUN_MAX_PACKET_EXCHANGE {
		// Queue is full -> flush first.
		err := tun.flush()
		if err != nil {
			return err
		}
	}

	// Push packet to the buffer.
	tunPacket := &tun.wrBuff.packets[tun.wrBuff.numPackets]
	tunPacket.size = uint32(size)
	copy(tunPacket.data[:size], buff)

	tun.wrBuff.numPackets++

	return nil
}

func (tun *nativeTun) Write(buff []byte, offset int) (int, error) {

	err := tun.putTunPacket(buff[offset:])
	if err != nil {
		return 0, err
	}

	// Flush write buffer.
	return len(buff) - offset, tun.flush()
}