yggdrasil-go/cmd/yggdrasil/main.go

338 lines
10 KiB
Go
Raw Normal View History

2017-12-29 07:16:20 +03:00
package main
import (
"bytes"
"encoding/hex"
"encoding/json"
"flag"
"fmt"
"io/ioutil"
"os"
"os/signal"
"strings"
"syscall"
2017-12-29 07:16:20 +03:00
"golang.org/x/text/encoding/unicode"
2018-06-15 11:20:41 +03:00
"github.com/gologme/log"
2019-06-29 02:32:23 +03:00
gsyslog "github.com/hashicorp/go-syslog"
"github.com/hjson/hjson-go"
"github.com/kardianos/minwinsvc"
"github.com/mitchellh/mapstructure"
2017-12-29 07:16:20 +03:00
"github.com/yggdrasil-network/yggdrasil-go/src/admin"
2018-12-08 04:56:04 +03:00
"github.com/yggdrasil-network/yggdrasil-go/src/config"
"github.com/yggdrasil-network/yggdrasil-go/src/crypto"
"github.com/yggdrasil-network/yggdrasil-go/src/multicast"
"github.com/yggdrasil-network/yggdrasil-go/src/tuntap"
2018-12-08 04:56:04 +03:00
"github.com/yggdrasil-network/yggdrasil-go/src/yggdrasil"
)
2017-12-29 07:16:20 +03:00
type node struct {
core yggdrasil.Core
state *config.NodeState
2019-03-28 22:09:19 +03:00
tuntap tuntap.TunAdapter
multicast multicast.Multicast
admin admin.AdminSocket
2017-12-29 07:16:20 +03:00
}
func readConfig(useconf *bool, useconffile *string, normaliseconf *bool) *config.NodeConfig {
// Use a configuration file. If -useconf, the configuration will be read
// from stdin. If -useconffile, the configuration will be read from the
// filesystem.
2019-01-14 17:01:38 +03:00
var conf []byte
var err error
if *useconffile != "" {
// Read the file from the filesystem
2019-01-14 17:01:38 +03:00
conf, err = ioutil.ReadFile(*useconffile)
} else {
// Read the file from stdin.
2019-01-14 17:01:38 +03:00
conf, err = ioutil.ReadAll(os.Stdin)
}
if err != nil {
panic(err)
}
// If there's a byte order mark - which Windows 10 is now incredibly fond of
// throwing everywhere when it's converting things into UTF-16 for the hell
// of it - remove it and decode back down into UTF-8. This is necessary
// because hjson doesn't know what to do with UTF-16 and will panic
2019-01-14 17:01:38 +03:00
if bytes.Compare(conf[0:2], []byte{0xFF, 0xFE}) == 0 ||
bytes.Compare(conf[0:2], []byte{0xFE, 0xFF}) == 0 {
utf := unicode.UTF16(unicode.BigEndian, unicode.UseBOM)
decoder := utf.NewDecoder()
2019-01-14 17:01:38 +03:00
conf, err = decoder.Bytes(conf)
if err != nil {
panic(err)
}
}
// Generate a new configuration - this gives us a set of sane defaults -
// then parse the configuration we loaded above on top of it. The effect
// of this is that any configuration item that is missing from the provided
// configuration will use a sane default.
cfg := config.GenerateConfig()
var dat map[string]interface{}
2019-01-14 17:01:38 +03:00
if err := hjson.Unmarshal(conf, &dat); err != nil {
panic(err)
}
confJson, err := json.Marshal(dat)
if err != nil {
panic(err)
}
json.Unmarshal(confJson, &cfg)
// Overlay our newly mapped configuration onto the autoconf node config that
// we generated above.
if err = mapstructure.Decode(dat, &cfg); err != nil {
panic(err)
}
return cfg
}
2018-05-28 00:13:37 +03:00
// Generates a new configuration and returns it in HJSON format. This is used
// with -genconf.
func doGenconf(isjson bool) string {
cfg := config.GenerateConfig()
var bs []byte
var err error
if isjson {
bs, err = json.MarshalIndent(cfg, "", " ")
} else {
bs, err = hjson.Marshal(cfg)
}
2018-01-05 01:37:51 +03:00
if err != nil {
panic(err)
}
return string(bs)
2017-12-29 07:16:20 +03:00
}
2018-05-28 00:13:37 +03:00
// The main function is responsible for configuring and starting Yggdrasil.
2017-12-29 07:16:20 +03:00
func main() {
2018-05-28 00:13:37 +03:00
// Configure the command line parameters.
genconf := flag.Bool("genconf", false, "print a new config to stdout")
useconf := flag.Bool("useconf", false, "read HJSON/JSON config from stdin")
useconffile := flag.String("useconffile", "", "read HJSON/JSON config from specified file path")
2018-05-28 00:13:37 +03:00
normaliseconf := flag.Bool("normaliseconf", false, "use in combination with either -useconf or -useconffile, outputs your configuration normalised")
confjson := flag.Bool("json", false, "print configuration from -genconf or -normaliseconf as JSON instead of HJSON")
2018-05-28 00:13:37 +03:00
autoconf := flag.Bool("autoconf", false, "automatic mode (dynamic IP, peer with IPv6 neighbors)")
version := flag.Bool("version", false, "prints the version of this build")
logging := flag.String("logging", "info,warn,error", "comma-separated list of logging levels to enable")
logto := flag.String("logto", "stdout", "file path to log to, \"syslog\" or \"stdout\"")
2018-01-05 01:37:51 +03:00
flag.Parse()
2018-05-28 00:13:37 +03:00
var cfg *config.NodeConfig
var err error
2018-01-05 01:37:51 +03:00
switch {
case *version:
2019-03-29 21:24:57 +03:00
fmt.Println("Build name:", yggdrasil.BuildName())
fmt.Println("Build version:", yggdrasil.BuildVersion())
os.Exit(0)
2018-01-05 01:37:51 +03:00
case *autoconf:
2018-05-28 00:13:37 +03:00
// Use an autoconf-generated config, this will give us random keys and
// port numbers, and will use an automatically selected TUN/TAP interface.
cfg = config.GenerateConfig()
2018-05-27 20:31:35 +03:00
case *useconffile != "" || *useconf:
// Read the configuration from either stdin or from the filesystem
cfg = readConfig(useconf, useconffile, normaliseconf)
2018-05-28 00:13:37 +03:00
// If the -normaliseconf option was specified then remarshal the above
// configuration and print it back to stdout. This lets the user update
// their configuration file with newly mapped names (like above) or to
// convert from plain JSON to commented HJSON.
if *normaliseconf {
var bs []byte
if *confjson {
bs, err = json.MarshalIndent(cfg, "", " ")
} else {
bs, err = hjson.Marshal(cfg)
}
if err != nil {
panic(err)
}
fmt.Println(string(bs))
return
}
2018-01-05 01:37:51 +03:00
case *genconf:
2018-05-28 00:13:37 +03:00
// Generate a new configuration and print it to stdout.
fmt.Println(doGenconf(*confjson))
2018-01-05 01:37:51 +03:00
default:
2018-05-28 00:13:37 +03:00
// No flags were provided, therefore print the list of flags to stdout.
2018-01-05 01:37:51 +03:00
flag.PrintDefaults()
}
2018-05-28 00:13:37 +03:00
// Have we got a working configuration? If we don't then it probably means
// that neither -autoconf, -useconf or -useconffile were set above. Stop
// if we don't.
2018-01-05 01:37:51 +03:00
if cfg == nil {
return
}
2018-05-28 00:13:37 +03:00
// Create a new logger that logs output to stdout.
var logger *log.Logger
switch *logto {
case "stdout":
logger = log.New(os.Stdout, "", log.Flags())
case "syslog":
2019-06-29 02:32:23 +03:00
if syslogger, err := gsyslog.NewLogger(gsyslog.LOG_NOTICE, "DAEMON", yggdrasil.BuildName()); err == nil {
logger = log.New(syslogger, "", log.Flags())
}
default:
if logfd, err := os.OpenFile(*logto, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644); err == nil {
logger = log.New(logfd, "", log.Flags())
}
}
if logger == nil {
logger = log.New(os.Stdout, "", log.Flags())
logger.Warnln("Logging defaulting to stdout")
}
//logger.EnableLevel("error")
//logger.EnableLevel("warn")
//logger.EnableLevel("info")
if levels := strings.Split(*logging, ","); len(levels) > 0 {
for _, level := range levels {
l := strings.TrimSpace(level)
switch l {
case "error", "warn", "info", "trace", "debug":
logger.EnableLevel(l)
default:
continue
}
}
}
2018-05-28 00:13:37 +03:00
// Setup the Yggdrasil node itself. The node{} type includes a Core, so we
// don't need to create this manually.
2018-01-05 01:37:51 +03:00
n := node{}
// Now start Yggdrasil - this starts the DHT, router, switch and other core
// components needed for Yggdrasil to operate
n.state, err = n.core.Start(cfg, logger)
2019-03-28 22:09:19 +03:00
if err != nil {
logger.Errorln("An error occurred during startup")
2018-05-28 00:13:37 +03:00
panic(err)
}
// Register the session firewall gatekeeper function
n.core.SetSessionGatekeeper(n.sessionFirewall)
// Start the admin socket
n.admin.Init(&n.core, n.state, logger, nil)
if err := n.admin.Start(); err != nil {
logger.Errorln("An error occurred starting admin socket:", err)
}
// Start the multicast interface
n.multicast.Init(&n.core, n.state, logger, nil)
if err := n.multicast.Start(); err != nil {
logger.Errorln("An error occurred starting multicast:", err)
}
n.multicast.SetupAdminHandlers(&n.admin)
// Start the TUN/TAP interface
if listener, err := n.core.ConnListen(); err == nil {
if dialer, err := n.core.ConnDialer(); err == nil {
n.tuntap.Init(n.state, logger, listener, dialer)
if err := n.tuntap.Start(); err != nil {
logger.Errorln("An error occurred starting TUN/TAP:", err)
}
n.tuntap.SetupAdminHandlers(&n.admin)
} else {
logger.Errorln("Unable to get Dialer:", err)
}
} else {
logger.Errorln("Unable to get Listener:", err)
}
2018-05-28 00:13:37 +03:00
// Make some nice output that tells us what our IPv6 address and subnet are.
// This is just logged to stdout for the user.
2019-03-29 21:24:57 +03:00
address := n.core.Address()
subnet := n.core.Subnet()
logger.Infof("Your IPv6 address is %s", address.String())
logger.Infof("Your IPv6 subnet is %s", subnet.String())
2018-05-28 00:13:37 +03:00
// Catch interrupts from the operating system to exit gracefully.
2018-01-05 01:37:51 +03:00
c := make(chan os.Signal, 1)
r := make(chan os.Signal, 1)
signal.Notify(c, os.Interrupt, syscall.SIGTERM)
signal.Notify(r, os.Interrupt, syscall.SIGHUP)
// Capture the service being stopped on Windows.
2019-07-06 14:17:40 +03:00
minwinsvc.SetOnExit(n.shutdown)
defer n.shutdown()
2018-05-28 00:13:37 +03:00
// Wait for the terminate/interrupt signal. Once a signal is received, the
// deferred Stop function above will run which will shut down TUN/TAP.
for {
select {
case _ = <-c:
goto exit
case _ = <-r:
if *useconffile != "" {
cfg = readConfig(useconf, useconffile, normaliseconf)
n.core.UpdateConfig(cfg)
2019-05-18 00:29:52 +03:00
n.tuntap.UpdateConfig(cfg)
n.multicast.UpdateConfig(cfg)
} else {
logger.Errorln("Reloading config at runtime is only possible with -useconffile")
}
}
}
exit:
2019-07-06 14:17:40 +03:00
}
func (n *node) shutdown() {
n.core.Stop()
n.admin.Stop()
n.multicast.Stop()
n.tuntap.Stop()
os.Exit(0)
2017-12-29 07:16:20 +03:00
}
func (n *node) sessionFirewall(pubkey *crypto.BoxPubKey, initiator bool) bool {
n.state.Mutex.RLock()
defer n.state.Mutex.RUnlock()
// Allow by default if the session firewall is disabled
if !n.state.Current.SessionFirewall.Enable {
return true
}
// Prepare for checking whitelist/blacklist
var box crypto.BoxPubKey
// Reject blacklisted nodes
for _, b := range n.state.Current.SessionFirewall.BlacklistEncryptionPublicKeys {
key, err := hex.DecodeString(b)
if err == nil {
copy(box[:crypto.BoxPubKeyLen], key)
if box == *pubkey {
return false
}
}
}
// Allow whitelisted nodes
for _, b := range n.state.Current.SessionFirewall.WhitelistEncryptionPublicKeys {
key, err := hex.DecodeString(b)
if err == nil {
copy(box[:crypto.BoxPubKeyLen], key)
if box == *pubkey {
return true
}
}
}
// Allow outbound sessions if appropriate
if n.state.Current.SessionFirewall.AlwaysAllowOutbound {
if initiator {
return true
}
}
// Look and see if the pubkey is that of a direct peer
var isDirectPeer bool
for _, peer := range n.core.GetPeers() {
if peer.PublicKey == *pubkey {
isDirectPeer = true
break
}
}
// Allow direct peers if appropriate
if n.state.Current.SessionFirewall.AllowFromDirect && isDirectPeer {
return true
}
// Allow remote nodes if appropriate
if n.state.Current.SessionFirewall.AllowFromRemote && !isDirectPeer {
return true
}
// Finally, default-deny if not matching any of the above rules
return false
}