mleku/indra
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

adding a registry of flags.

Browse Source
This commit is contained in:
greg stone
2023-02-23 10:24:28 +00:00
parent 5610b7a11d
commit bfbe702148
7 changed files with 94 additions and 148 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
cmd/indra/seed.go
View File

@@ -38,7 +38,7 @@ func init() {
viper.BindPFlag("seed", seedCmd.PersistentFlags().Lookup("seed"))
viper.BindPFlag("connect", seedCmd.PersistentFlags().Lookup("connect"))
rpc.Configure(seedCmd)
rpc.InitFlags(seedCmd)
rootCmd.AddCommand(seedCmd)
}

55
pkg/rpc/cmd.go
View File

@@ -1,39 +1,9 @@
package rpc
import (
"github.com/spf13/cobra"
"github.com/spf13/viper"
)
var (
flag_tun_enable = "rpc-tun-enable"
flag_tun_key = "rpc-tun-key"
flag_tun_port = "rpc-tun-port"
flag_tun_whitlist_peer = "rpc-tun-whitelist-peer"
)
var (
rpc_tun_enable bool
rpc_tun_key string
rpc_tun_port uint16
rpc_tun_whitelist_peer []string
)
func Configure(cmd *cobra.Command) {
defineUnixSocket(cmd)
cmd.PersistentFlags().BoolVarP(&rpc_tun_enable, flag_tun_enable, "", false, "enables the rpc server tunnel")
cmd.PersistentFlags().Uint16VarP(&rpc_tun_port, flag_tun_port, "", 0, "binds the udp server to port (random if not selected)")
cmd.PersistentFlags().StringVarP(&rpc_tun_key, flag_tun_key, "", "", "the base58 encoded pre-shared key for accessing the rpc")
cmd.PersistentFlags().StringSliceVarP(&rpc_tun_whitelist_peer, flag_tun_whitlist_peer, "", []string{}, "adds a peer id to the whitelist for access")
viper.BindPFlag(flag_tun_enable, cmd.PersistentFlags().Lookup(flag_tun_enable))
viper.BindPFlag(flag_tun_port, cmd.PersistentFlags().Lookup(flag_tun_port))
viper.BindPFlag(flag_tun_key, cmd.PersistentFlags().Lookup(flag_tun_key))
viper.BindPFlag(flag_tun_whitlist_peer, cmd.PersistentFlags().Lookup(flag_tun_whitlist_peer))
}
func ConfigureWithViper() (err error) {
log.I.Ln("configuring the rpc server")
@@ -42,14 +12,25 @@ func ConfigureWithViper() (err error) {
configureTunnel()
log.I.Ln("rpc listeners:")
log.I.F("- [/ip4/0.0.0.0/udp/%d", config.listenPort)
log.I.F("/ip4/0.0.0.0/udp/%d", config.listenPort)
log.I.F("/ip6/:::/udp/%d", config.listenPort)
log.I.F("- [/ip4/0.0.0.0/udp/%d", devicePort)
log.I.F("/ip4/0.0.0.0/udp/%d", devicePort)
log.I.F("/ip6/:::/udp/%d", devicePort)
log.I.F("/unix" + unixPath + "]")
return
}
func configureUnixSocket() {
if viper.GetString(unixPathFlag) == "" {
return
}
log.I.Ln("enabling unix listener:", viper.GetString(unixPath))
isUnixSockEnabled = true
}
func configureTunnel() {
if !viper.GetBool("rpc-tun-enable") {
@@ -65,10 +46,6 @@ func configureTunnel() {
enableTunnel()
}
var (
tunKey *RPCPrivateKey
)
func configureTunnelKey() {
if viper.GetString("rpc-tun-key") == "" {
@@ -81,7 +58,7 @@ func configureTunnelKey() {
}
log.I.Ln("rpc public key:")
log.I.Ln("-", config.key.PubKey().Encode())
log.I.Ln("-", tunKey.PubKey().Encode())
}
func configureTunnelPort() {
@@ -101,6 +78,6 @@ func configurePeerWhitelist() {
pubKey.Decode(peer)
config.peerWhitelist = append(config.peerWhitelist, pubKey)
tunWhitelist = append(tunWhitelist, pubKey)
}
}

65
pkg/rpc/config.go
View File

@@ -1,65 +0,0 @@
package rpc
import (
"github.com/multiformats/go-multiaddr"
"math/rand"
"time"
)
var (
config = rpcConfig{
key: &nullRPCPrivateKey,
listenPort: NullPort,
peerWhitelist: []RPCPublicKey{},
ipWhitelist: []multiaddr.Multiaddr{},
}
)
type rpcConfig struct {
key *RPCPrivateKey
listenPort uint16
peerWhitelist []RPCPublicKey
ipWhitelist []multiaddr.Multiaddr
unixPath string
}
func (c *rpcConfig) newKey() {
var err error
if c.key, err = NewPrivateKey(); check(err) {
panic(err)
}
}
func (c *rpcConfig) setKey(key string) {
c.key.Decode(key)
}
func (c *rpcConfig) isNullKey() bool {
return c.key.IsZero()
}
func (c *rpcConfig) setPort(port uint16) {
c.listenPort = port
}
func (c *rpcConfig) isNullPort() bool {
return c.listenPort == NullPort
}
func (c *rpcConfig) setRandomPort() uint16 {
rand.Seed(time.Now().Unix())
c.listenPort = uint16(rand.Intn(45534) + 10000)
return c.listenPort
}
func (c *rpcConfig) setUnixPath(path string) {
c.unixPath = path
}
func (conf *rpcConfig) isEnabled() bool {
return !conf.key.IsZero()
}

57
pkg/rpc/flags.go Normal file
View File

@@ -0,0 +1,57 @@
package rpc
import (
"github.com/spf13/cobra"
"github.com/spf13/viper"
)
var (
unixPathFlag = "rpc-unix-listen"
tunEnableFlag = "rpc-tun-enable"
tunKeyFlag = "rpc-tun-key"
tunPortFlag = "rpc-tun-port"
tunPeersFlag = "rpc-tun-peer"
)
var (
tunKeyRaw string
tunPeersRaw = []string{}
)
func InitFlags(cmd *cobra.Command) {
cmd.PersistentFlags().StringVarP(&unixPath, unixPathFlag, "",
unixPath,
"binds to a unix socket with path",
)
viper.BindPFlag(unixPathFlag, cmd.PersistentFlags().Lookup(unixPathFlag))
cmd.PersistentFlags().BoolVarP(&isTunnelEnabled, tunEnableFlag, "",
isTunnelEnabled,
"enables the rpc server tunnel",
)
viper.BindPFlag(tunEnableFlag, cmd.PersistentFlags().Lookup(tunEnableFlag))
cmd.PersistentFlags().StringVarP(&tunKeyRaw, tunKeyFlag, "",
"",
"the base58 encoded pre-shared key for accessing the rpc",
)
viper.BindPFlag(tunKeyFlag, cmd.PersistentFlags().Lookup(tunKeyFlag))
cmd.PersistentFlags().IntVarP(&devicePort, tunPortFlag, "",
devicePort,
"binds the udp server to port (random if not selected)",
)
viper.BindPFlag(tunPortFlag, cmd.PersistentFlags().Lookup(tunPortFlag))
cmd.PersistentFlags().StringSliceVarP(&tunPeersRaw, tunPeersFlag, "",
tunPeersRaw,
"adds a peer id to the whitelist for access",
)
viper.BindPFlag(tunPeersFlag, cmd.PersistentFlags().Lookup(tunPeersFlag))
}

6
pkg/rpc/server.go
View File

@@ -34,7 +34,11 @@ func Start(ctx context.Context) {
var err error
if err = startUnixSocket(); check(err) {
if err = startUnixSocket(server); check(err) {
startupErrors <- err
}
if err = startTunnel(server); check(err) {
startupErrors <- err
}

41
pkg/rpc/socket_unix.go
View File

@@ -1,50 +1,17 @@
package rpc
import (
"github.com/spf13/cobra"
"github.com/spf13/viper"
"google.golang.org/grpc"
"net"
)
var (
isUnixSockEnabled bool = false
unixSock net.Listener
unixPath = "/tmp/indra.sock"
)
var (
unixPathFlag = "rpc-unix-listen"
unixPathUsage = "binds to a unix socket with path"
unixPath = "/tmp/indra.sock"
)
func defineUnixSocket(cmd *cobra.Command) {
cmd.PersistentFlags().StringVarP(
&unixPath,
unixPathFlag,
"",
unixPath,
unixPathUsage,
)
viper.BindPFlag(
unixPathFlag,
cmd.PersistentFlags().Lookup(unixPathFlag),
)
}
func configureUnixSocket() {
if viper.GetString(unixPathFlag) == "" {
return
}
log.I.Ln("enabling unix listener:", viper.GetString(unixPath))
isUnixSockEnabled = true
}
func startUnixSocket() (err error) {
func startUnixSocket(srv *grpc.Server) (err error) {
if !isUnixSockEnabled {
return
@@ -54,7 +21,7 @@ func startUnixSocket() (err error) {
return
}
go server.Serve(unixSock)
go srv.Serve(unixSock)
return
}

16
pkg/rpc/tunnel.go
View File

@@ -5,6 +5,7 @@ import (
"golang.zx2c4.com/wireguard/device"
"golang.zx2c4.com/wireguard/tun"
"golang.zx2c4.com/wireguard/tun/netstack"
"google.golang.org/grpc"
"net"
"net/netip"
"strconv"
@@ -30,11 +31,16 @@ var (
tcpSock net.Listener
)
var (
tunKey *RPCPrivateKey
tunWhitelist []RPCPublicKey
)
func enableTunnel() {
isTunnelEnabled = true
}
func startTunnel() (err error) {
func startTunnel(srv *grpc.Server) (err error) {
if !isTunnelEnabled {
return
@@ -47,10 +53,10 @@ func startTunnel() (err error) {
dev = device.NewDevice(tunnel, conn.NewDefaultBind(), device.NewLogger(device.LogLevelError, "server "))
dev.SetPrivateKey(config.key.AsDeviceKey())
dev.IpcSet("listen_port=" + strconv.Itoa(int(config.listenPort)))
dev.SetPrivateKey(tunKey.AsDeviceKey())
dev.IpcSet("listen_port=" + strconv.Itoa(int(devicePort)))
for _, peer_whitelist := range config.peerWhitelist {
for _, peer_whitelist := range tunWhitelist {
deviceConf := "" +
"public_key=" + peer_whitelist.HexString() + "\n" +
@@ -72,7 +78,7 @@ func startTunnel() (err error) {
return
}
go server.Serve(tcpSock)
go srv.Serve(tcpSock)
return
}