wireguard-go/uapi_linux.go

200 lines
3.5 KiB
Go
Raw Normal View History

2019-01-02 00:55:51 +00:00
/* SPDX-License-Identifier: MIT
*
2019-01-02 00:55:51 +00:00
* Copyright (C) 2017-2019 WireGuard LLC. All Rights Reserved.
*/
package main
import (
2017-08-01 10:45:11 +00:00
"errors"
"fmt"
2018-05-24 13:29:16 +00:00
"git.zx2c4.com/wireguard-go/rwcancel"
"golang.org/x/sys/unix"
"net"
"os"
"path"
)
var socketDirectory = "/var/run/wireguard"
const (
2017-11-17 13:36:08 +00:00
ipcErrorIO = -int64(unix.EIO)
ipcErrorProtocol = -int64(unix.EPROTO)
ipcErrorInvalid = -int64(unix.EINVAL)
ipcErrorPortInUse = -int64(unix.EADDRINUSE)
socketName = "%s.sock"
)
type UAPIListener struct {
2018-05-13 22:28:30 +00:00
listener net.Listener // unix socket listener
connNew chan net.Conn
connErr chan error
inotifyFd int
inotifyRWCancel *rwcancel.RWCancel
}
func (l *UAPIListener) Accept() (net.Conn, error) {
for {
select {
case conn := <-l.connNew:
return conn, nil
case err := <-l.connErr:
return nil, err
}
}
}
func (l *UAPIListener) Close() error {
err1 := unix.Close(l.inotifyFd)
2018-05-14 10:46:06 +00:00
err2 := l.inotifyRWCancel.Cancel()
err3 := l.listener.Close()
if err1 != nil {
return err1
}
2018-05-13 22:28:30 +00:00
if err2 != nil {
return err2
}
return err3
}
func (l *UAPIListener) Addr() net.Addr {
2018-05-14 10:46:06 +00:00
return l.listener.Addr()
}
2017-11-17 13:36:08 +00:00
func UAPIListen(name string, file *os.File) (net.Listener, error) {
2017-08-01 10:45:11 +00:00
2017-11-17 13:36:08 +00:00
// wrap file in listener
2017-08-01 10:45:11 +00:00
2017-11-17 13:36:08 +00:00
listener, err := net.FileListener(file)
if err != nil {
return nil, err
}
2018-05-14 10:46:06 +00:00
if unixListener, ok := listener.(*net.UnixListener); ok {
unixListener.SetUnlinkOnClose(true)
}
uapi := &UAPIListener{
listener: listener,
connNew: make(chan net.Conn, 1),
connErr: make(chan error, 1),
}
// watch for deletion of socket
2017-11-17 13:36:08 +00:00
socketPath := path.Join(
socketDirectory,
fmt.Sprintf(socketName, name),
)
uapi.inotifyFd, err = unix.InotifyInit()
if err != nil {
return nil, err
}
_, err = unix.InotifyAddWatch(
uapi.inotifyFd,
socketPath,
unix.IN_ATTRIB|
unix.IN_DELETE|
unix.IN_DELETE_SELF,
)
if err != nil {
return nil, err
}
2018-05-13 22:28:30 +00:00
uapi.inotifyRWCancel, err = rwcancel.NewRWCancel(uapi.inotifyFd)
if err != nil {
unix.Close(uapi.inotifyFd)
return nil, err
}
go func(l *UAPIListener) {
2018-05-13 22:28:30 +00:00
var buff [0]byte
for {
2017-11-17 13:36:08 +00:00
// start with lstat to avoid race condition
if _, err := os.Lstat(socketPath); os.IsNotExist(err) {
l.connErr <- err
return
}
2018-05-13 22:28:30 +00:00
_, err := uapi.inotifyRWCancel.Read(buff[:])
if err != nil {
l.connErr <- err
return
}
}
}(uapi)
// watch for new connections
go func(l *UAPIListener) {
for {
conn, err := l.listener.Accept()
if err != nil {
l.connErr <- err
break
}
l.connNew <- conn
}
}(uapi)
return uapi, nil
}
2017-11-17 13:36:08 +00:00
func UAPIOpen(name string) (*os.File, error) {
// check if path exist
err := os.MkdirAll(socketDirectory, 0755)
2017-11-17 13:36:08 +00:00
if err != nil && !os.IsExist(err) {
return nil, err
}
// open UNIX socket
socketPath := path.Join(
socketDirectory,
fmt.Sprintf(socketName, name),
)
addr, err := net.ResolveUnixAddr("unix", socketPath)
if err != nil {
return nil, err
}
oldUmask := unix.Umask(0077)
2017-11-17 13:36:08 +00:00
listener, err := func() (*net.UnixListener, error) {
// initial connection attempt
listener, err := net.ListenUnix("unix", addr)
if err == nil {
return listener, nil
}
// check if socket already active
_, err = net.Dial("unix", socketPath)
if err == nil {
return nil, errors.New("unix socket in use")
}
// cleanup & attempt again
err = os.Remove(socketPath)
if err != nil {
return nil, err
}
return net.ListenUnix("unix", addr)
}()
unix.Umask(oldUmask)
2017-11-17 13:36:08 +00:00
if err != nil {
return nil, err
}
return listener.File()
}