diff --git a/cmd/wicectl/main.go b/cmd/wicectl/main.go index 1c96f6b4..455f4db1 100644 --- a/cmd/wicectl/main.go +++ b/cmd/wicectl/main.go @@ -1,51 +1,43 @@ package main import ( - "flag" - "os" + "fmt" + "github.com/spf13/cobra" "go.uber.org/zap" "riasc.eu/wice/internal" "riasc.eu/wice/pkg/socket" ) -var sockPath = flag.String("socket", "/var/run/wice.go", "Unix control and monitoring socket") +var client *socket.Client = nil +var logger *zap.Logger + +func pre(cmd *cobra.Command, args []string) error { + var err error + + internal.SetupRand() + + logger = internal.SetupLogging() + + if client, err = socket.Connect(sockPath); err != nil { + return fmt.Errorf("failed to connect to control socket: %w", err) + } + + return nil +} + +func post(cmd *cobra.Command, args []string) error { + if err := client.Close(); err != nil { + return err + } + + if err := logger.Sync(); err != nil { + return err + } + + return nil +} func main() { - internal.SetupRand() - signals := internal.SetupSignals() - logger := internal.SetupLogging() - defer logger.Sync() - - flag.Parse() - - subCommand := flag.Arg(0) - - switch subCommand { - case "monitor": - monitor(signals) - - default: - logger.Fatal("Unknown subcommand", zap.String("command", subCommand)) - } -} - -func monitor(signals chan os.Signal) { - logger := zap.L().Named("events") - - sock, err := socket.Connect(*sockPath) - if err != nil { - logger.Fatal("Failed to connect to control socket", zap.Error(err)) - } - - for { - select { - case sig := <-signals: - logger.Info("Received signal", zap.Any("signal", sig)) - os.Exit(0) - - case evt := <-sock.Events: - evt.Log(logger, "Event") - } - } + rootCmd.Execute() } diff --git a/cmd/wicectl/monitor.go b/cmd/wicectl/monitor.go new file mode 100644 index 00000000..2daeedc7 --- /dev/null +++ b/cmd/wicectl/monitor.go @@ -0,0 +1,35 @@ +package main + +import ( + "github.com/spf13/cobra" + "go.uber.org/zap" + "riasc.eu/wice/internal" +) + +var monitorCmd = &cobra.Command{ + Use: "monitor", + Short: "Monitor the WICE daemon for events", + RunE: monitor, + PersistentPreRunE: pre, + PersistentPostRunE: post, +} + +func monitor(cmd *cobra.Command, args []string) error { + signals := internal.SetupSignals() + + logger := zap.L().Named("events") + +out: + for { + select { + case sig := <-signals: + logger.Info("Received signal", zap.Any("signal", sig)) + break out + + case evt := <-client.Events: + evt.Log(logger, "Event") + } + } + + return nil +} diff --git a/cmd/wicectl/root.go b/cmd/wicectl/root.go new file mode 100644 index 00000000..c01d452c --- /dev/null +++ b/cmd/wicectl/root.go @@ -0,0 +1,66 @@ +package main + +import ( + "os" + + "github.com/spf13/cobra" + "github.com/spf13/viper" + "go.uber.org/zap" + "riasc.eu/wice/internal" + "riasc.eu/wice/internal/cli" +) + +var ( + // Used for flags. + cfgFile string + sockPath string + + rootCmd = &cobra.Command{ + Use: "wicectl", + Short: "A client tool to control the WICE daemon", + } +) + +func init() { + cobra.OnInitialize( + internal.SetupRand, + setupLogging, + setupConfig, + ) + + pf := rootCmd.PersistentFlags() + + pf.StringVar(&sockPath, "socket", "/var/run/wice.sock", "Unix control and monitoring socket") + pf.StringVar(&cfgFile, "config", "", "Path to config file (default $HOME/.wice.yaml)") + + viper.BindPFlag("socket", pf.Lookup("socket")) + + rootCmd.AddCommand(shutdownCmd) + rootCmd.AddCommand(monitorCmd) + rootCmd.AddCommand(syncCmd) + rootCmd.AddCommand(cli.NewDocsCommand(rootCmd)) +} + +func setupLogging() { + logger = internal.SetupLogging() +} + +func setupConfig() { + if cfgFile != "" { + // Use config file from the flag. + viper.SetConfigFile(cfgFile) + } else { + home, err := os.UserHomeDir() + cobra.CheckErr(err) + + viper.AddConfigPath(home) + viper.SetConfigType("yaml") + viper.SetConfigName(".wice.yaml") + } + + viper.AutomaticEnv() + + if err := viper.ReadInConfig(); err == nil { + logger.Debug("Using config file", zap.String("file", viper.ConfigFileUsed())) + } +} diff --git a/cmd/wicectl/shutdown.go b/cmd/wicectl/shutdown.go new file mode 100644 index 00000000..ef47eb2d --- /dev/null +++ b/cmd/wicectl/shutdown.go @@ -0,0 +1,28 @@ +package main + +import ( + "context" + "fmt" + + "github.com/spf13/cobra" + "riasc.eu/wice/pkg/pb" +) + +var shutdownCmd = &cobra.Command{ + Use: "shutdown", + Short: "Shutdown the WICE daemon", + RunE: shutdown, + PersistentPreRunE: pre, + PersistentPostRunE: post, +} + +func shutdown(cmd *cobra.Command, args []string) error { + rerr, err := client.Shutdown(context.Background(), &pb.ShutdownParams{}) + if err != nil { + return fmt.Errorf("failed RPC request: %w", err) + } else if !rerr.Ok() { + return fmt.Errorf("received RPC error: %w", rerr) + } + + return nil +} diff --git a/cmd/wicectl/sync.go b/cmd/wicectl/sync.go new file mode 100644 index 00000000..a406d460 --- /dev/null +++ b/cmd/wicectl/sync.go @@ -0,0 +1,54 @@ +package main + +import ( + "context" + "fmt" + + "github.com/spf13/cobra" + "riasc.eu/wice/pkg/pb" +) + +var ( + syncCmd = &cobra.Command{ + Use: "sync", + PersistentPreRunE: pre, + PersistentPostRunE: post, + } + + syncConfigCmd = &cobra.Command{ + Use: "config", + RunE: syncConfig, + } + + syncInterfacesCmd = &cobra.Command{ + Use: "interfaces", + RunE: syncInterfaces, + } +) + +func init() { + syncCmd.AddCommand(syncConfigCmd) + syncCmd.AddCommand(syncInterfacesCmd) +} + +func syncConfig(cmd *cobra.Command, args []string) error { + rerr, err := client.SyncConfig(context.Background(), &pb.SyncConfigParams{}) + if err != nil { + return fmt.Errorf("failed RPC request: %w", err) + } else if !rerr.Ok() { + return fmt.Errorf("received RPC error: %w", rerr) + } + + return nil +} + +func syncInterfaces(cmd *cobra.Command, args []string) error { + rerr, err := client.SyncInterfaces(context.Background(), &pb.SyncInterfaceParams{}) + if err != nil { + return fmt.Errorf("failed RPC request: %w", err) + } else if !rerr.Ok() { + return fmt.Errorf("received RPC error: %w", rerr) + } + + return nil +} diff --git a/internal/cli/docs.go b/internal/cli/docs.go new file mode 100644 index 00000000..d24102e8 --- /dev/null +++ b/internal/cli/docs.go @@ -0,0 +1,87 @@ +package cli + +import ( + "fmt" + "log" + "os" + "path/filepath" + + "github.com/spf13/cobra" + "github.com/spf13/cobra/doc" +) + +type runEfunc func(cmd *cobra.Command, args []string) error + +var ( + outputDir string = "./" +) + +func NewDocsCommand(rootCmd *cobra.Command) *cobra.Command { + cmd := &cobra.Command{ + Use: "docs", + Short: "Generate documentation for the wice commands", + // Hidden: true, + RunE: func(cmd *cobra.Command, args []string) error { + if err := docsMarkdown(rootCmd); err != nil { + return err + } + if err := docsManpage(rootCmd); err != nil { + return err + } + + return nil + }, + } + + cmd.AddCommand(&cobra.Command{ + Use: "markdown", + Short: "Generate markdown docs", + RunE: func(cmd *cobra.Command, args []string) error { + return docsMarkdown(rootCmd) + }, + }) + + cmd.AddCommand(&cobra.Command{ + Use: "man", + Short: "Generate manpages", + RunE: func(cmd *cobra.Command, args []string) error { + return docsManpage(rootCmd) + }, + }) + + pf := cmd.PersistentFlags() + pf.StringVar(&outputDir, "output-dir", "./docs", "Output directory of generated documenation") + + return cmd +} + +func docsMarkdown(rootCmd *cobra.Command) error { + dir := filepath.Join(outputDir, "md") + if err := os.MkdirAll(dir, 0755); err != nil { + return fmt.Errorf("failed to create directory: %w", err) + } + + if err := doc.GenMarkdownTree(rootCmd, dir); err != nil { + log.Fatal(err) + } + + return nil +} + +func docsManpage(rootCmd *cobra.Command) error { + dir := filepath.Join(outputDir, "man") + if err := os.MkdirAll(dir, 0755); err != nil { + return fmt.Errorf("failed to create directory: %w", err) + } + + header := &doc.GenManHeader{ + Title: "MINE", + Section: "3", + } + + if err := doc.GenManTree(rootCmd, header, dir); err != nil { + log.Fatal(err) + } + + return nil +} diff --git a/internal/config/config.go b/internal/config/config.go new file mode 100644 index 00000000..6bb44bae --- /dev/null +++ b/internal/config/config.go @@ -0,0 +1,308 @@ +package config + +import ( + "flag" + "fmt" + "io" + "net/url" + "os" + "path/filepath" + "regexp" + "strconv" + "time" + + "go.uber.org/zap" + "riasc.eu/wice/pkg/proxy" + "riasc.eu/wice/pkg/signaling" + + "github.com/pion/ice/v2" + "github.com/spf13/pflag" + "github.com/spf13/viper" +) + +// Copied from pion/ice/agent_config.go +const ( + // defaultCheckInterval is the interval at which the agent performs candidate checks in the connecting phase + defaultCheckInterval = 200 * time.Millisecond + + // keepaliveInterval used to keep candidates alive + defaultKeepaliveInterval = 2 * time.Second + + // defaultDisconnectedTimeout is the default time till an Agent transitions disconnected + defaultDisconnectedTimeout = 5 * time.Second + + // defaultFailedTimeout is the default time till an Agent transitions to failed after disconnected + defaultFailedTimeout = 25 * time.Second + + // max binding request before considering a pair failed + defaultMaxBindingRequests = 7 +) + +var ( + defaultICEUrls = []*ice.URL{ + { + Scheme: ice.SchemeTypeSTUN, + Host: "stun.l.google.com", + Port: 19302, + Username: "", + Password: "", + Proto: ice.ProtoTypeUDP, + }, + } + + defaultBackendURLs = []*url.URL{ + { + Scheme: "p2p", + }, + } +) + +type Config struct { + File string + LogLevel logLevel + + Socket string + SocketWait bool + + Backends backendURLList + User bool + ProxyType proxyType + ConfigSync bool + ConfigPath string + WatchInterval time.Duration + RestartInterval time.Duration + + Interfaces []string + + InterfaceFilter regex + InterfaceFilterICE regex + + // for ice.AgentConfig + iceURLs iceURLList + + iceNat1to1IPs arrayFlags + + iceInsecureSkipVerify bool + + iceCandidateTypes candidateTypeList + iceNetworkTypes networkTypeList + + iceDisconnectedTimeout time.Duration + iceFailedTimeout time.Duration + iceKeepaliveInterval time.Duration + iceCheckInterval time.Duration + + iceUsername string + icePassword string + + icePortMin uint16 + icePortMax uint16 + + iceMdns bool + iceLite bool + + iceMaxBindingRequests uint16 + + viper *viper.Viper + logger *zap.Logger +} + +func ShowUsage() { + fmt.Fprintf(os.Stderr, "usage: %s [OPTIONS] [IFACES ...]\n", os.Args[0]) + fmt.Println() + fmt.Println(" IFACES is a list of Wireguard interfaces") + fmt.Println(" (defaults to all available Wireguard interfaces)") + fmt.Println("") + fmt.Println(("Available OPTIONS are:")) + flag.PrintDefaults() + fmt.Println() + fmt.Println(" (**) These options can be specified multiple times") + fmt.Println() + fmt.Println("Available backends types are:") + for name, plugin := range signaling.Backends { + fmt.Printf(" %-7s %s\n", name, plugin.Description) + } +} + +func NewConfig(flags *pflag.FlagSet) *Config { + matchAll, _ := regexp.Compile(".*") + + // Default arguments + cfg := &Config{ + Backends: backendURLList{}, + iceCandidateTypes: candidateTypeList{}, + InterfaceFilterICE: regex{matchAll}, + iceNat1to1IPs: arrayFlags{}, + iceNetworkTypes: networkTypeList{}, + iceURLs: iceURLList{}, + InterfaceFilter: regex{matchAll}, + Interfaces: []string{}, + LogLevel: logLevel{zap.NewAtomicLevel()}, + ProxyType: proxyType{proxy.TypeAuto}, + + viper: viper.New(), + logger: zap.L().Named("config"), + } + + flags.StringVarP(&cfg.File, "config", "c", "", "Path of configuration file") + flags.VarP(&cfg.LogLevel, "log-level", "d", "log level (one of \"panic\", \"fatal\", \"error\", \"warn\", \"info\", \"debug\", \"trace\")") + flags.VarP(&cfg.Backends, "backend", "b", "backend types / URLs") + flags.VarP(&cfg.ProxyType, "proxy", "p", "proxy type to use") + flags.VarP(&cfg.InterfaceFilter, "interface-filter", "f", "regex for filtering Wireguard interfaces (e.g. \"wg-.*\")") + flags.DurationVarP(&cfg.WatchInterval, "watch-interval", "i", time.Second, "interval at which we are polling the kernel for updates on the Wireguard interfaces") + + flags.BoolVarP(&cfg.User, "wg-user", "u", false, "start userspace Wireguard daemon") + flags.BoolVarP(&cfg.ConfigSync, "wg-config-sync", "s", false, "sync Wireguard interface with configuration file (see \"wg synconf\"") + flags.StringVarP(&cfg.ConfigPath, "wg-config-path", "w", "/etc/wireguard", "base path to search for Wireguard configuration files") + + // ice.AgentConfig fields + flags.VarP(&cfg.iceURLs, "url", "a", "STUN and/or TURN server address (**)") + flags.Var(&cfg.iceCandidateTypes, "ice-candidate-type", "usable candidate types (**, one of \"host\", \"srflx\", \"prflx\", \"relay\")") + flags.Var(&cfg.iceNetworkTypes, "ice-network-type", "usable network types (**, select from \"udp4\", \"udp6\", \"tcp4\", \"tcp6\")") + flags.Var(&cfg.iceNat1to1IPs, "ice-nat-1to1-ip", "list of IP addresses which will be added as local server reflexive candidates (**)") + + flags.Uint16Var(&cfg.icePortMin, "ice-port-min", 0, "minimum port for allocation policy (range: 0-65535)") + flags.Uint16Var(&cfg.icePortMax, "ice-port-max", 0, "maximum port for allocation policy (range: 0-65535)") + flags.BoolVarP(&cfg.iceLite, "ice-lite", "l", false, "lite agents do not perform connectivity check and only provide host candidates") + flags.BoolVarP(&cfg.iceMdns, "ice-mdns", "m", false, "enable local Multicast DNS discovery") + flags.Uint16Var(&cfg.iceMaxBindingRequests, "ice-max-binding-requests", defaultMaxBindingRequests, "maximum number of binding request before considering a pair failed") + flags.BoolVarP(&cfg.iceInsecureSkipVerify, "ice-insecure-skip-verify", "k", false, "skip verification of TLS certificates for secure STUN/TURN servers") + flags.Var(&cfg.InterfaceFilterICE, "ice-interface-filter", "regex for filtering local interfaces for ICE candidate gathering (e.g. \"eth[0-9]+\")") + flags.DurationVar(&cfg.iceDisconnectedTimeout, "ice-disconnected-timout", defaultDisconnectedTimeout, "time till an Agent transitions disconnected") + flags.DurationVar(&cfg.iceFailedTimeout, "ice-failed-timeout", defaultFailedTimeout, "time until an Agent transitions to failed after disconnected") + flags.DurationVar(&cfg.iceKeepaliveInterval, "ice-keepalive-interval", defaultKeepaliveInterval, "interval netween STUN keepalives") + flags.DurationVar(&cfg.iceCheckInterval, "ice-check-interval", defaultCheckInterval, "interval at which the agent performs candidate checks in the connecting phase") + flags.DurationVar(&cfg.RestartInterval, "ice-restart-interval", defaultDisconnectedTimeout, "time to wait before ICE restart") + flags.StringVarP(&cfg.iceUsername, "ice-user", "U", "", "username for STUN/TURN credentials") + flags.StringVarP(&cfg.icePassword, "ice-pass", "P", "", "password for STUN/TURN credentials") + // iceMaxBindingRequestTimeout := flag.Duration("ice-max-binding-request-timeout", maxBindingRequestTimeout, "wait time before binding requests can be deleted") + + flags.StringVar(&cfg.Socket, "socket", "/var/run/wice.sock", "Unix control and monitoring socket") + flags.BoolVar(&cfg.SocketWait, "socket-wait", false, "wait until first client connected to control socket before continuing start") + + cfg.viper.BindPFlags(flags) + + return cfg +} + +func (c *Config) Setup() { + // Find best proxy method + if c.ProxyType.ProxyType == proxy.TypeAuto { + c.ProxyType.ProxyType = proxy.AutoProxy() + } + + // Add default backend + if len(c.Backends) == 0 { + c.Backends = defaultBackendURLs + } + + if c.File != "" { + // Use config file from the flag. + viper.SetConfigFile(c.File) + } else { + home, err := os.UserHomeDir() + if err != nil { + c.logger.Warn("Failed to determine home directory", zap.Error(err)) + } else { + viper.AddConfigPath(filepath.Join(home, ".config", "wice")) + } + + viper.AddConfigPath("/etc/wice") + + viper.SetConfigType("ini") + viper.SetConfigName("wicerc") + } + + c.viper.AutomaticEnv() + + if err := viper.ReadInConfig(); err == nil { + c.logger.Debug("Using config file", zap.String("file", viper.ConfigFileUsed())) + } +} + +func (a *Config) AgentConfig() (*ice.AgentConfig, error) { + cfg := &ice.AgentConfig{ + InsecureSkipVerify: a.iceInsecureSkipVerify, + NetworkTypes: a.iceNetworkTypes, + CandidateTypes: a.iceCandidateTypes, + Urls: a.iceURLs, + } + + // Add default STUN/TURN servers + if len(cfg.Urls) == 0 { + cfg.Urls = defaultICEUrls + } else { + // Set ICE credentials + for _, u := range cfg.Urls { + if a.iceUsername != "" { + u.Username = a.iceUsername + } + + if a.icePassword != "" { + u.Password = a.icePassword + } + } + } + + if a.iceMaxBindingRequests > 0 { + cfg.MaxBindingRequests = &a.iceMaxBindingRequests + } + + if a.iceMdns { + cfg.MulticastDNSMode = ice.MulticastDNSModeQueryAndGather + } + + if a.iceDisconnectedTimeout > 0 { + cfg.DisconnectedTimeout = &a.iceDisconnectedTimeout + } + + if a.iceFailedTimeout > 0 { + cfg.FailedTimeout = &a.iceFailedTimeout + } + + if a.iceKeepaliveInterval > 0 { + cfg.KeepaliveInterval = &a.iceKeepaliveInterval + } + + if a.iceCheckInterval > 0 { + cfg.CheckInterval = &a.iceCheckInterval + } + + if len(a.iceNat1to1IPs) > 0 { + cfg.NAT1To1IPCandidateType = ice.CandidateTypeServerReflexive + cfg.NAT1To1IPs = a.iceNat1to1IPs + } + + // Default network types + if len(a.iceNetworkTypes) == 0 { + cfg.NetworkTypes = append(cfg.NetworkTypes, + ice.NetworkTypeUDP4, + ice.NetworkTypeUDP6, + ) + } + + return cfg, nil +} + +func (c *Config) Dump(wr io.Writer) { + cfg, _ := c.AgentConfig() + + fmt.Fprintln(wr, "Options:") + fmt.Fprintln(wr, " URLs:") + for _, u := range cfg.Urls { + fmt.Fprintf(wr, " %s\n", u.String()) + } + + fmt.Fprintln(wr, " Interfaces:") + for _, d := range c.Interfaces { + fmt.Fprintf(wr, " %s\n", d) + } + + fmt.Fprintf(wr, " User: %s\n", strconv.FormatBool(c.User)) + fmt.Fprintf(wr, " ProxyType: %s\n", c.ProxyType.String()) + + fmt.Fprintf(wr, " Signalling Backends:\n") + for _, b := range c.Backends { + fmt.Fprintf(wr, " %s\n", b) + } +} diff --git a/pkg/args/args_test.go b/internal/config/config_test.go similarity index 73% rename from pkg/args/args_test.go rename to internal/config/config_test.go index eb87f426..b74ddfd5 100644 --- a/pkg/args/args_test.go +++ b/internal/config/config_test.go @@ -1,14 +1,14 @@ -package args_test +package config_test import ( "testing" "github.com/pion/ice/v2" - "riasc.eu/wice/pkg/args" + "riasc.eu/wice/internal/config" ) func TestParseArgsUser(t *testing.T) { - config, err := args.Parse("prog", []string{"-user"}) + config, err := config.Parse("prog", []string{"-user"}) if err != nil { t.Errorf("err got %v, want nil", err) } @@ -19,7 +19,7 @@ func TestParseArgsUser(t *testing.T) { } func TestParseArgsBackend(t *testing.T) { - config, err := args.Parse("prog", []string{"-backend", "k8s"}) + config, err := config.Parse("prog", []string{"-backend", "k8s"}) if err != nil { t.Errorf("err got %v, want nil", err) } @@ -30,7 +30,7 @@ func TestParseArgsBackend(t *testing.T) { } func TestParseArgsUrls(t *testing.T) { - config, err := args.Parse("prog", []string{"-url", "stun:stun.riasc.eu", "-url", "turn:turn.riasc.eu"}) + config, err := config.Parse("prog", []string{"-url", "stun:stun.riasc.eu", "-url", "turn:turn.riasc.eu"}) if err != nil { t.Errorf("err got %v, want nil", err) } @@ -57,7 +57,7 @@ func TestParseArgsUrls(t *testing.T) { } func TestParseArgsCandidateTypes(t *testing.T) { - config, err := args.Parse("prog", []string{"-ice-candidate-type", "host", "-ice-candidate-type", "relay"}) + config, err := config.Parse("prog", []string{"-ice-candidate-type", "host", "-ice-candidate-type", "relay"}) if err != nil { t.Errorf("err got %v, want nil", err) } @@ -76,7 +76,7 @@ func TestParseArgsCandidateTypes(t *testing.T) { } func TestParseArgsInterfaceFilter(t *testing.T) { - config, err := args.Parse("prog", []string{"-interface-filter", "eth\\d+"}) + config, err := config.Parse("prog", []string{"-interface-filter", "eth\\d+"}) if err != nil { t.Errorf("err got %v, want nil", err) } @@ -91,14 +91,14 @@ func TestParseArgsInterfaceFilter(t *testing.T) { } func TestParseArgsInterfaceFilterFail(t *testing.T) { - _, err := args.Parse("prog", []string{"-interface-filter", "eth("}) + _, err := config.Parse("prog", []string{"-interface-filter", "eth("}) if err == nil { t.Fail() } } func TestParseArgsDefault(t *testing.T) { - config, err := args.Parse("prog", []string{}) + config, err := config.Parse("prog", []string{}) if err != nil { t.Fail() } diff --git a/internal/config/ice.go b/internal/config/ice.go new file mode 100644 index 00000000..6f7366d5 --- /dev/null +++ b/internal/config/ice.go @@ -0,0 +1,37 @@ +package config + +import ( + "fmt" + + "github.com/pion/ice/v2" +) + +func candidateTypeFromString(t string) (ice.CandidateType, error) { + switch t { + case "host": + return ice.CandidateTypeHost, nil + case "srflx": + return ice.CandidateTypeServerReflexive, nil + case "prflx": + return ice.CandidateTypePeerReflexive, nil + case "relay": + return ice.CandidateTypeRelay, nil + default: + return ice.CandidateTypeUnspecified, fmt.Errorf("unknown candidate type: %s", t) + } +} + +func networkTypeFromString(t string) (ice.NetworkType, error) { + switch t { + case "udp4": + return ice.NetworkTypeUDP4, nil + case "udp6": + return ice.NetworkTypeUDP6, nil + case "tcp4": + return ice.NetworkTypeTCP4, nil + case "tcp6": + return ice.NetworkTypeTCP6, nil + default: + return ice.NetworkTypeTCP4, fmt.Errorf("unknown network type: %s", t) + } +} diff --git a/internal/config/types.go b/internal/config/types.go new file mode 100644 index 00000000..c47e19cf --- /dev/null +++ b/internal/config/types.go @@ -0,0 +1,180 @@ +package config + +import ( + "fmt" + "net/url" + "regexp" + "strings" + + "github.com/pion/ice/v2" + "go.uber.org/zap" + "riasc.eu/wice/pkg/proxy" +) + +type backendURLList []*url.URL + +func (i *backendURLList) Type() string { + return "stringSlice" +} + +func (i *backendURLList) String() string { + s := []string{} + for _, u := range *i { + s = append(s, u.String()) + } + + return strings.Join(s, ",") +} + +func (i *backendURLList) Set(value string) error { + + // Allow the user to specify just the backend type as a valid url. + // E.g. "p2p" instead of "p2p:" + if !strings.Contains(value, ":") { + value += ":" + } + + uri, err := url.Parse(value) + if err != nil { + return fmt.Errorf("invalid backend URI: %w", err) + } + + *i = append(*i, uri) + + return nil +} + +type arrayFlags []string + +func (i *arrayFlags) String() string { + return strings.Join(*i, ",") +} + +func (i *arrayFlags) Set(value string) error { + *i = append(*i, value) + return nil +} + +func (i *arrayFlags) Type() string { + return "stringSlice" +} + +type iceURLList []*ice.URL + +func (ul *iceURLList) Type() string { + return "stringSlice" +} + +func (ul *iceURLList) Set(value string) error { + u, err := ice.ParseURL(value) + if err != nil { + return err + } + + *ul = append(*ul, u) + + return nil +} + +func (ul *iceURLList) String() string { + l := []string{} + + for _, u := range *ul { + l = append(l, u.String()) + } + + return strings.Join(l, ",") +} + +type candidateTypeList []ice.CandidateType + +func (cl *candidateTypeList) Type() string { + return "stringSlice" +} + +func (cl *candidateTypeList) Set(value string) error { + ct, err := candidateTypeFromString(value) + if err != nil { + return err + } + + *cl = append(*cl, ct) + + return nil +} + +func (cl *candidateTypeList) String() string { + l := []string{} + + for _, c := range *cl { + l = append(l, c.String()) + } + + return strings.Join(l, ",") +} + +type networkTypeList []ice.NetworkType + +func (nl *networkTypeList) Type() string { + return "stringSlice" +} + +func (nl *networkTypeList) Set(value string) error { + ct, err := networkTypeFromString(value) + if err != nil { + return err + } + + *nl = append(*nl, ct) + + return nil +} + +func (nl *networkTypeList) String() string { + l := []string{} + + for _, c := range *nl { + l = append(l, c.String()) + } + + return strings.Join(l, ",") +} + +type proxyType struct{ proxy.ProxyType } + +func (pt *proxyType) Type() string { + return "string" +} + +func (pt *proxyType) Set(value string) error { + var err error + pt.ProxyType, err = proxy.ProxyTypeFromString(value) + return err +} + +type logLevel struct{ zap.AtomicLevel } + +func (ll *logLevel) Type() string { + return "string" +} + +func (ll *logLevel) Set(value string) error { + return ll.UnmarshalText([]byte(value)) +} + +type regex struct{ *regexp.Regexp } + +func (re *regex) Type() string { + return "string" +} + +func (re *regex) Set(value string) error { + r, err := regexp.Compile(value) + if err != nil { + return fmt.Errorf("failed to compile regex: %w", err) + } + + re.Regexp = r + + return nil +} diff --git a/pkg/args/args.go b/pkg/args/args.go deleted file mode 100644 index ba05e60d..00000000 --- a/pkg/args/args.go +++ /dev/null @@ -1,373 +0,0 @@ -package args - -import ( - "flag" - "fmt" - "io" - "net/url" - "os" - "regexp" - "strconv" - "strings" - "time" - - "go.uber.org/zap" - "go.uber.org/zap/zapcore" - pice "riasc.eu/wice/internal/ice" - "riasc.eu/wice/pkg/proxy" - "riasc.eu/wice/pkg/signaling" - - "github.com/pion/ice/v2" -) - -// Copied from pion/ice/agent_config.go -const ( - // defaultCheckInterval is the interval at which the agent performs candidate checks in the connecting phase - defaultCheckInterval = 200 * time.Millisecond - - // keepaliveInterval used to keep candidates alive - defaultKeepaliveInterval = 2 * time.Second - - // defaultDisconnectedTimeout is the default time till an Agent transitions disconnected - defaultDisconnectedTimeout = 5 * time.Second - - // defaultFailedTimeout is the default time till an Agent transitions to failed after disconnected - defaultFailedTimeout = 25 * time.Second - - // max binding request before considering a pair failed - defaultMaxBindingRequests = 7 -) - -var ( - defaultICEUrls = []*ice.URL{ - { - Scheme: ice.SchemeTypeSTUN, - Host: "stun.l.google.com", - Port: 19302, - Username: "", - Password: "", - Proto: ice.ProtoTypeUDP, - }, - } -) - -type backendURLList []*url.URL - -func (i *backendURLList) String() string { - s := []string{} - for _, u := range *i { - s = append(s, u.String()) - } - - return strings.Join(s, ",") -} - -func (i *backendURLList) Set(value string) error { - - // Allow the user to specify just the backend type as a valid url. - // E.g. "p2p" instead of "p2p:" - if !strings.Contains(value, ":") { - value += ":" - } - - uri, err := url.Parse(value) - if err != nil { - return fmt.Errorf("invalid backend URI: %w", err) - } - - *i = append(*i, uri) - - return nil -} - -type iceURLList []*ice.URL - -func (i *iceURLList) String() string { - s := []string{} - for _, u := range *i { - s = append(s, u.String()) - } - - return strings.Join(s, ",") -} - -func (i *iceURLList) Set(value string) error { - iceUrl, err := ice.ParseURL(value) - if err != nil { - return fmt.Errorf("failed to parse ICE url %s: %w", value, err) - } - - *i = append(*i, iceUrl) - - return nil -} - -type arrayFlags []string - -func (i *arrayFlags) String() string { - return strings.Join(*i, ",") -} - -func (i *arrayFlags) Set(value string) error { - *i = append(*i, value) - return nil -} - -type Args struct { - Backends []*url.URL - User bool - ProxyType proxy.Type - ConfigSync bool - ConfigPath string - WatchInterval time.Duration - RestartInterval time.Duration - - InterfaceRegex *regexp.Regexp - IceInterfaceRegex *regexp.Regexp - AgentConfig ice.AgentConfig - - Socket string - SocketWait bool - - Interfaces []string -} - -func showUsage() { - fmt.Fprintf(os.Stderr, "usage: %s [OPTIONS] [IFACES ...]\n", os.Args[0]) - fmt.Println() - fmt.Println(" IFACES is a list of Wireguard interfaces") - fmt.Println(" (defaults to all available Wireguard interfaces)") - fmt.Println("") - fmt.Println(("Available OPTIONS are:")) - flag.PrintDefaults() - fmt.Println() - fmt.Println(" (**) These options can be specified multiple times") - fmt.Println() - fmt.Println("Available backends types are:") - for name, plugin := range signaling.Backends { - fmt.Printf(" %-7s %s\n", name, plugin.Description) - } -} - -func (a *Args) DumpConfig(wr io.Writer) { - fmt.Fprintln(wr, "Options:") - fmt.Fprintln(wr, " URLs:") - for _, u := range a.AgentConfig.Urls { - fmt.Fprintf(wr, " %s\n", u.String()) - } - - fmt.Fprintln(wr, " Interfaces:") - for _, d := range a.Interfaces { - fmt.Fprintf(wr, " %s\n", d) - } - - fmt.Fprintf(wr, " User: %s\n", strconv.FormatBool(a.User)) - fmt.Fprintf(wr, " ProxyType: %s\n", a.ProxyType.String()) - - fmt.Fprintf(wr, " Signalling Backends:\n") - for _, b := range a.Backends { - fmt.Fprintf(wr, " %s\n", b) - } -} - -func candidateTypeFromString(t string) (ice.CandidateType, error) { - switch t { - case "host": - return ice.CandidateTypeHost, nil - case "srflx": - return ice.CandidateTypeServerReflexive, nil - case "prflx": - return ice.CandidateTypePeerReflexive, nil - case "relay": - return ice.CandidateTypeRelay, nil - default: - return ice.CandidateTypeUnspecified, fmt.Errorf("unknown candidate type: %s", t) - } -} - -func networkTypeFromString(t string) (ice.NetworkType, error) { - switch t { - case "udp4": - return ice.NetworkTypeUDP4, nil - case "udp6": - return ice.NetworkTypeUDP6, nil - case "tcp4": - return ice.NetworkTypeTCP4, nil - case "tcp6": - return ice.NetworkTypeTCP6, nil - default: - return ice.NetworkTypeTCP4, fmt.Errorf("unknown network type: %s", t) - } -} - -func Parse(progname string, argv []string) (*Args, error) { - var err error - var iceURLs, iceCandidateTypes, iceNetworkTypes, iceNat1to1IPs arrayFlags - var backendURLs backendURLList - var logLevel zapcore.Level - - flags := flag.NewFlagSet(progname, flag.ContinueOnError) - - flags.Usage = showUsage - - flags.Var(&logLevel, "log-level", "log level (one of \"panic\", \"fatal\", \"error\", \"warn\", \"info\", \"debug\", \"trace\")") - flags.Var(&backendURLs, "backend", "backend type / URL") - user := flags.Bool("user", false, "start userspace Wireguard daemon") - proxyType := flags.String("proxy", "auto", "proxy type to use") - interfaceFilter := flags.String("interface-filter", ".*", "regex for filtering Wireguard interfaces (e.g. \"wg-.*\")") - configSync := flags.Bool("config-sync", false, "sync Wireguard interface with configuration file (see \"wg synconf\"") - configPath := flags.String("config-path", "/etc/wireguard", "base path to search for Wireguard configuration files") - watchInterval := flags.Duration("watch-interval", time.Second, "interval at which we are polling the kernel for updates on the Wireguard interfaces") - - // ice.AgentConfig fields - flags.Var(&iceURLs, "url", "STUN and/or TURN server address (**)") - flags.Var(&iceCandidateTypes, "ice-candidate-type", "usable candidate types (**, one of \"host\", \"srflx\", \"prflx\", \"relay\")") - flags.Var(&iceNetworkTypes, "ice-network-type", "usable network types (**, select from \"udp4\", \"udp6\", \"tcp4\", \"tcp6\")") - flags.Var(&iceNat1to1IPs, "ice-nat-1to1-ip", "list of IP addresses which will be added as local server reflexive candidates (**)") - - icePortMin := flags.Uint("ice-port-min", 0, "minimum port for allocation policy (range: 0-65535)") - icePortMax := flags.Uint("ice-port-max", 0, "maximum port for allocation policy (range: 0-65535)") - iceLite := flags.Bool("ice-lite", false, "lite agents do not perform connectivity check and only provide host candidates") - iceMdns := flags.Bool("ice-mdns", false, "enable local Multicast DNS discovery") - iceMaxBindingRequests := flags.Int("ice-max-binding-requests", defaultMaxBindingRequests, "maximum number of binding request before considering a pair failed") - iceInsecureSkipVerify := flags.Bool("ice-insecure-skip-verify", false, "skip verification of TLS certificates for secure STUN/TURN servers") - iceInterfaceFilter := flags.String("ice-interface-filter", ".*", "regex for filtering local interfaces for ICE candidate gathering (e.g. \"eth[0-9]+\")") - iceDisconnectedTimeout := flags.Duration("ice-disconnected-timout", defaultDisconnectedTimeout, "time till an Agent transitions disconnected") - iceFailedTimeout := flags.Duration("ice-failed-timeout", defaultFailedTimeout, "time until an Agent transitions to failed after disconnected") - iceKeepaliveInterval := flags.Duration("ice-keepalive-interval", defaultKeepaliveInterval, "interval netween STUN keepalives") - iceCheckInterval := flags.Duration("ice-check-interval", defaultCheckInterval, "interval at which the agent performs candidate checks in the connecting phase") - iceRestartInterval := flags.Duration("ice-restart-interval", defaultDisconnectedTimeout, "time to wait before ICE restart") - iceUsername := flags.String("ice-user", "", "username for STUN/TURN credentials") - icePassword := flags.String("ice-pass", "", "password for STUN/TURN credentials") - // iceMaxBindingRequestTimeout := flag.Duration("ice-max-binding-request-timeout", maxBindingRequestTimeout, "wait time before binding requests can be deleted") - - socket := flags.String("socket", "/var/run/wice.sock", "Unix control and monitoring socket") - socketWait := flags.Bool("socket-wait", false, "wait until first client connected to control socket before continuing start") - - if err := flags.Parse(argv); err != nil { - return nil, fmt.Errorf("failed to parse args: %w", err) - } - - logger := zap.L().Named("args") - - logger.Info("Setting debug level", zap.Any("level", logLevel)) - // logger.SetLevel(logLevel.Level) - - args := &Args{ - User: *user, - Backends: backendURLs, - ProxyType: proxy.ProxyTypeFromString(*proxyType), - // Discover: *discover, - ConfigSync: *configSync, - ConfigPath: *configPath, - WatchInterval: *watchInterval, - RestartInterval: *iceRestartInterval, - Socket: *socket, - SocketWait: *socketWait, - Interfaces: flag.Args(), - AgentConfig: ice.AgentConfig{ - PortMin: uint16(*icePortMin), - PortMax: uint16(*icePortMax), - Lite: *iceLite, - InsecureSkipVerify: *iceInsecureSkipVerify, - Urls: []*ice.URL{}, - }, - } - - // Find best proxy method - if args.ProxyType == proxy.TypeAuto { - args.ProxyType = proxy.AutoProxy() - } - - // Check proxy type - if args.ProxyType == proxy.TypeInvalid { - return nil, fmt.Errorf("invalid proxy type: %s", *proxyType) - } - - // Compile interface regex - args.InterfaceRegex, err = regexp.Compile(*interfaceFilter) - if err != nil { - return nil, fmt.Errorf("invalid interface filter: %w", err) - } - - if *iceMaxBindingRequests >= 0 { - maxBindingReqs := uint16(*iceMaxBindingRequests) - args.AgentConfig.MaxBindingRequests = &maxBindingReqs - } - if *iceMdns { - args.AgentConfig.MulticastDNSMode = ice.MulticastDNSModeQueryAndGather - } - if *iceDisconnectedTimeout > 0 { - args.AgentConfig.DisconnectedTimeout = iceDisconnectedTimeout - } - if *iceFailedTimeout > 0 { - args.AgentConfig.FailedTimeout = iceFailedTimeout - } - if *iceKeepaliveInterval > 0 { - args.AgentConfig.KeepaliveInterval = iceKeepaliveInterval - } - if *iceCheckInterval > 0 { - args.AgentConfig.CheckInterval = iceCheckInterval - } - if len(iceNat1to1IPs) > 0 { - args.AgentConfig.NAT1To1IPCandidateType = ice.CandidateTypeServerReflexive - args.AgentConfig.NAT1To1IPs = iceNat1to1IPs - } - - args.IceInterfaceRegex, err = regexp.Compile(*iceInterfaceFilter) - if err != nil { - return nil, fmt.Errorf("failed to compile interface regex: %w", err) - } - - // Parse candidate types - for _, c := range iceCandidateTypes { - candType, err := candidateTypeFromString(c) - if err != nil { - return nil, err - } - args.AgentConfig.CandidateTypes = append(args.AgentConfig.CandidateTypes, candType) - } - - // Parse network types - if len(iceNetworkTypes) == 0 { - args.AgentConfig.NetworkTypes = []ice.NetworkType{ - ice.NetworkTypeUDP4, - ice.NetworkTypeUDP6, - } - } else { - for _, n := range iceNetworkTypes { - netType, err := networkTypeFromString(n) - if err != nil { - return nil, err - } - args.AgentConfig.NetworkTypes = append(args.AgentConfig.NetworkTypes, netType) - } - } - - // Add default backend - if len(args.Backends) == 0 { - args.Backends = append(args.Backends, &url.URL{ - Scheme: "p2p", - }) - } - - // Add default STUN/TURN servers - if len(args.AgentConfig.Urls) == 0 { - args.AgentConfig.Urls = defaultICEUrls - } else { - // Set ICE credentials - for _, u := range args.AgentConfig.Urls { - if *iceUsername != "" { - u.Username = *iceUsername - } - - if *icePassword != "" { - u.Password = *icePassword - } - } - } - - args.AgentConfig.LoggerFactory = &pice.LoggerFactory{} - - return args, nil -} diff --git a/pkg/pb/candidate.go b/pkg/pb/candidate.go new file mode 100644 index 00000000..318f4f56 --- /dev/null +++ b/pkg/pb/candidate.go @@ -0,0 +1,98 @@ +package pb + +import ( + "fmt" + "strings" + + "github.com/pion/ice/v2" +) + +func NewCandidate(ic ice.Candidate) *Candidate { + c := &Candidate{ + Type: Candidate_Type(ic.Type()), + Foundation: ic.Foundation(), + Component: int32(ic.Component()), + NetworkType: Candidate_NetworkType(ic.NetworkType()), + Priority: int32(ic.Priority()), + Address: ic.Address(), + Port: int32(ic.Port()), + TcpType: Candidate_TCPType(ic.TCPType()), + } + + if r := c.RelatedAddress; r != nil { + c.RelatedAddress = &RelatedAddress{ + Address: r.Address, + Port: r.Port, + } + } + + return c +} + +func (c *Candidate) ICECandidate() (ice.Candidate, error) { + var err error + + var relAddr = "" + var relPort = 0 + if c.RelatedAddress != nil { + relAddr = c.RelatedAddress.Address + relPort = int(c.RelatedAddress.Port) + } + + var ic ice.Candidate + switch c.Type { + case Candidate_TYPE_HOST: + ic, err = ice.NewCandidateHost(&ice.CandidateHostConfig{ + CandidateID: "", + Network: strings.ToLower(c.NetworkType.String()), + Address: c.Address, + Port: int(c.Port), + Component: uint16(c.Component), + Priority: uint32(c.Priority), + Foundation: c.Foundation, + TCPType: ice.TCPType(c.TcpType), + }) + case Candidate_TYPE_SERVER_REFLEXIVE: + ic, err = ice.NewCandidateServerReflexive(&ice.CandidateServerReflexiveConfig{ + CandidateID: "", + Network: strings.ToLower(c.NetworkType.String()), + Address: c.Address, + Port: int(c.Port), + Component: uint16(c.Component), + Priority: uint32(c.Priority), + Foundation: c.Foundation, + RelAddr: relAddr, + RelPort: relPort, + }) + case Candidate_TYPE_PEER_REFLEXIVE: + ic, err = ice.NewCandidatePeerReflexive(&ice.CandidatePeerReflexiveConfig{ + CandidateID: "", + Network: strings.ToLower(c.NetworkType.String()), + Address: c.Address, + Port: int(c.Port), + Component: uint16(c.Component), + Priority: uint32(c.Priority), + Foundation: c.Foundation, + RelAddr: relAddr, + RelPort: relPort, + }) + + case Candidate_TYPE_RELAY: + ic, err = ice.NewCandidateRelay(&ice.CandidateRelayConfig{ + CandidateID: "", + Network: strings.ToLower(c.NetworkType.String()), + Address: c.Address, + Port: int(c.Port), + Component: uint16(c.Component), + Priority: uint32(c.Priority), + Foundation: c.Foundation, + RelAddr: relAddr, + RelPort: relPort, + }) + + default: + err = fmt.Errorf("unknown candidate type: %s", c.Type) + } + + return ic, err +} diff --git a/pkg/pb/candidate.pb.go b/pkg/pb/candidate.pb.go new file mode 100644 index 00000000..b1a816fb --- /dev/null +++ b/pkg/pb/candidate.pb.go @@ -0,0 +1,483 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.27.1 +// protoc v3.14.0 +// source: candidate.proto + +package pb + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +type Candidate_Type int32 + +const ( + Candidate_TYPE_UNSPECIFIED Candidate_Type = 0 + Candidate_TYPE_HOST Candidate_Type = 1 + Candidate_TYPE_SERVER_REFLEXIVE Candidate_Type = 2 + Candidate_TYPE_PEER_REFLEXIVE Candidate_Type = 3 + Candidate_TYPE_RELAY Candidate_Type = 4 +) + +// Enum value maps for Candidate_Type. +var ( + Candidate_Type_name = map[int32]string{ + 0: "TYPE_UNSPECIFIED", + 1: "TYPE_HOST", + 2: "TYPE_SERVER_REFLEXIVE", + 3: "TYPE_PEER_REFLEXIVE", + 4: "TYPE_RELAY", + } + Candidate_Type_value = map[string]int32{ + "TYPE_UNSPECIFIED": 0, + "TYPE_HOST": 1, + "TYPE_SERVER_REFLEXIVE": 2, + "TYPE_PEER_REFLEXIVE": 3, + "TYPE_RELAY": 4, + } +) + +func (x Candidate_Type) Enum() *Candidate_Type { + p := new(Candidate_Type) + *p = x + return p +} + +func (x Candidate_Type) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (Candidate_Type) Descriptor() protoreflect.EnumDescriptor { + return file_candidate_proto_enumTypes[0].Descriptor() +} + +func (Candidate_Type) Type() protoreflect.EnumType { + return &file_candidate_proto_enumTypes[0] +} + +func (x Candidate_Type) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use Candidate_Type.Descriptor instead. +func (Candidate_Type) EnumDescriptor() ([]byte, []int) { + return file_candidate_proto_rawDescGZIP(), []int{1, 0} +} + +type Candidate_NetworkType int32 + +const ( + Candidate_UDP4 Candidate_NetworkType = 0 + Candidate_UDP6 Candidate_NetworkType = 1 + Candidate_TCP4 Candidate_NetworkType = 2 + Candidate_TCP6 Candidate_NetworkType = 3 +) + +// Enum value maps for Candidate_NetworkType. +var ( + Candidate_NetworkType_name = map[int32]string{ + 0: "UDP4", + 1: "UDP6", + 2: "TCP4", + 3: "TCP6", + } + Candidate_NetworkType_value = map[string]int32{ + "UDP4": 0, + "UDP6": 1, + "TCP4": 2, + "TCP6": 3, + } +) + +func (x Candidate_NetworkType) Enum() *Candidate_NetworkType { + p := new(Candidate_NetworkType) + *p = x + return p +} + +func (x Candidate_NetworkType) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (Candidate_NetworkType) Descriptor() protoreflect.EnumDescriptor { + return file_candidate_proto_enumTypes[1].Descriptor() +} + +func (Candidate_NetworkType) Type() protoreflect.EnumType { + return &file_candidate_proto_enumTypes[1] +} + +func (x Candidate_NetworkType) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use Candidate_NetworkType.Descriptor instead. +func (Candidate_NetworkType) EnumDescriptor() ([]byte, []int) { + return file_candidate_proto_rawDescGZIP(), []int{1, 1} +} + +type Candidate_TCPType int32 + +const ( + Candidate_TCP_TYPE_UNSPECIFIED Candidate_TCPType = 0 + Candidate_TCP_TYPE_ACTIVE Candidate_TCPType = 1 + Candidate_TCP_TYPE_PASSIVE Candidate_TCPType = 2 + Candidate_TCP_TYPE_SIMULTANEOUS_OPEN Candidate_TCPType = 3 +) + +// Enum value maps for Candidate_TCPType. +var ( + Candidate_TCPType_name = map[int32]string{ + 0: "TCP_TYPE_UNSPECIFIED", + 1: "TCP_TYPE_ACTIVE", + 2: "TCP_TYPE_PASSIVE", + 3: "TCP_TYPE_SIMULTANEOUS_OPEN", + } + Candidate_TCPType_value = map[string]int32{ + "TCP_TYPE_UNSPECIFIED": 0, + "TCP_TYPE_ACTIVE": 1, + "TCP_TYPE_PASSIVE": 2, + "TCP_TYPE_SIMULTANEOUS_OPEN": 3, + } +) + +func (x Candidate_TCPType) Enum() *Candidate_TCPType { + p := new(Candidate_TCPType) + *p = x + return p +} + +func (x Candidate_TCPType) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (Candidate_TCPType) Descriptor() protoreflect.EnumDescriptor { + return file_candidate_proto_enumTypes[2].Descriptor() +} + +func (Candidate_TCPType) Type() protoreflect.EnumType { + return &file_candidate_proto_enumTypes[2] +} + +func (x Candidate_TCPType) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use Candidate_TCPType.Descriptor instead. +func (Candidate_TCPType) EnumDescriptor() ([]byte, []int) { + return file_candidate_proto_rawDescGZIP(), []int{1, 2} +} + +type RelatedAddress struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` + Port int32 `protobuf:"varint,2,opt,name=port,proto3" json:"port,omitempty"` +} + +func (x *RelatedAddress) Reset() { + *x = RelatedAddress{} + if protoimpl.UnsafeEnabled { + mi := &file_candidate_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *RelatedAddress) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RelatedAddress) ProtoMessage() {} + +func (x *RelatedAddress) ProtoReflect() protoreflect.Message { + mi := &file_candidate_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RelatedAddress.ProtoReflect.Descriptor instead. +func (*RelatedAddress) Descriptor() ([]byte, []int) { + return file_candidate_proto_rawDescGZIP(), []int{0} +} + +func (x *RelatedAddress) GetAddress() string { + if x != nil { + return x.Address + } + return "" +} + +func (x *RelatedAddress) GetPort() int32 { + if x != nil { + return x.Port + } + return 0 +} + +type Candidate struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Type Candidate_Type `protobuf:"varint,1,opt,name=type,proto3,enum=Candidate_Type" json:"type,omitempty"` + Foundation string `protobuf:"bytes,2,opt,name=foundation,proto3" json:"foundation,omitempty"` + Component int32 `protobuf:"varint,3,opt,name=component,proto3" json:"component,omitempty"` + NetworkType Candidate_NetworkType `protobuf:"varint,4,opt,name=network_type,json=networkType,proto3,enum=Candidate_NetworkType" json:"network_type,omitempty"` + Priority int32 `protobuf:"varint,5,opt,name=priority,proto3" json:"priority,omitempty"` + Address string `protobuf:"bytes,6,opt,name=address,proto3" json:"address,omitempty"` + Port int32 `protobuf:"varint,7,opt,name=port,proto3" json:"port,omitempty"` + TcpType Candidate_TCPType `protobuf:"varint,8,opt,name=tcp_type,json=tcpType,proto3,enum=Candidate_TCPType" json:"tcp_type,omitempty"` + RelatedAddress *RelatedAddress `protobuf:"bytes,9,opt,name=related_address,json=relatedAddress,proto3" json:"related_address,omitempty"` +} + +func (x *Candidate) Reset() { + *x = Candidate{} + if protoimpl.UnsafeEnabled { + mi := &file_candidate_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Candidate) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Candidate) ProtoMessage() {} + +func (x *Candidate) ProtoReflect() protoreflect.Message { + mi := &file_candidate_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Candidate.ProtoReflect.Descriptor instead. +func (*Candidate) Descriptor() ([]byte, []int) { + return file_candidate_proto_rawDescGZIP(), []int{1} +} + +func (x *Candidate) GetType() Candidate_Type { + if x != nil { + return x.Type + } + return Candidate_TYPE_UNSPECIFIED +} + +func (x *Candidate) GetFoundation() string { + if x != nil { + return x.Foundation + } + return "" +} + +func (x *Candidate) GetComponent() int32 { + if x != nil { + return x.Component + } + return 0 +} + +func (x *Candidate) GetNetworkType() Candidate_NetworkType { + if x != nil { + return x.NetworkType + } + return Candidate_UDP4 +} + +func (x *Candidate) GetPriority() int32 { + if x != nil { + return x.Priority + } + return 0 +} + +func (x *Candidate) GetAddress() string { + if x != nil { + return x.Address + } + return "" +} + +func (x *Candidate) GetPort() int32 { + if x != nil { + return x.Port + } + return 0 +} + +func (x *Candidate) GetTcpType() Candidate_TCPType { + if x != nil { + return x.TcpType + } + return Candidate_TCP_TYPE_UNSPECIFIED +} + +func (x *Candidate) GetRelatedAddress() *RelatedAddress { + if x != nil { + return x.RelatedAddress + } + return nil +} + +var File_candidate_proto protoreflect.FileDescriptor + +var file_candidate_proto_rawDesc = []byte{ + 0x0a, 0x0f, 0x63, 0x61, 0x6e, 0x64, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x22, 0x3e, 0x0a, 0x0e, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x65, 0x64, 0x41, 0x64, 0x64, 0x72, + 0x65, 0x73, 0x73, 0x12, 0x18, 0x0a, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x12, 0x0a, + 0x04, 0x70, 0x6f, 0x72, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x04, 0x70, 0x6f, 0x72, + 0x74, 0x22, 0xf4, 0x04, 0x0a, 0x09, 0x43, 0x61, 0x6e, 0x64, 0x69, 0x64, 0x61, 0x74, 0x65, 0x12, + 0x23, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x0f, 0x2e, + 0x43, 0x61, 0x6e, 0x64, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, + 0x74, 0x79, 0x70, 0x65, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x6f, 0x75, 0x6e, 0x64, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x6f, 0x75, 0x6e, 0x64, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1c, 0x0a, 0x09, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, + 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, + 0x6e, 0x74, 0x12, 0x39, 0x0a, 0x0c, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x5f, 0x74, 0x79, + 0x70, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x16, 0x2e, 0x43, 0x61, 0x6e, 0x64, 0x69, + 0x64, 0x61, 0x74, 0x65, 0x2e, 0x4e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x54, 0x79, 0x70, 0x65, + 0x52, 0x0b, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x54, 0x79, 0x70, 0x65, 0x12, 0x1a, 0x0a, + 0x08, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, + 0x08, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x12, 0x18, 0x0a, 0x07, 0x61, 0x64, 0x64, + 0x72, 0x65, 0x73, 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x61, 0x64, 0x64, 0x72, + 0x65, 0x73, 0x73, 0x12, 0x12, 0x0a, 0x04, 0x70, 0x6f, 0x72, 0x74, 0x18, 0x07, 0x20, 0x01, 0x28, + 0x05, 0x52, 0x04, 0x70, 0x6f, 0x72, 0x74, 0x12, 0x2d, 0x0a, 0x08, 0x74, 0x63, 0x70, 0x5f, 0x74, + 0x79, 0x70, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x12, 0x2e, 0x43, 0x61, 0x6e, 0x64, + 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x54, 0x43, 0x50, 0x54, 0x79, 0x70, 0x65, 0x52, 0x07, 0x74, + 0x63, 0x70, 0x54, 0x79, 0x70, 0x65, 0x12, 0x38, 0x0a, 0x0f, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x65, + 0x64, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x0f, 0x2e, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x65, 0x64, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, + 0x52, 0x0e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x65, 0x64, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, + 0x22, 0x6f, 0x0a, 0x04, 0x54, 0x79, 0x70, 0x65, 0x12, 0x14, 0x0a, 0x10, 0x54, 0x59, 0x50, 0x45, + 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x0d, + 0x0a, 0x09, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x48, 0x4f, 0x53, 0x54, 0x10, 0x01, 0x12, 0x19, 0x0a, + 0x15, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x53, 0x45, 0x52, 0x56, 0x45, 0x52, 0x5f, 0x52, 0x45, 0x46, + 0x4c, 0x45, 0x58, 0x49, 0x56, 0x45, 0x10, 0x02, 0x12, 0x17, 0x0a, 0x13, 0x54, 0x59, 0x50, 0x45, + 0x5f, 0x50, 0x45, 0x45, 0x52, 0x5f, 0x52, 0x45, 0x46, 0x4c, 0x45, 0x58, 0x49, 0x56, 0x45, 0x10, + 0x03, 0x12, 0x0e, 0x0a, 0x0a, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x52, 0x45, 0x4c, 0x41, 0x59, 0x10, + 0x04, 0x22, 0x35, 0x0a, 0x0b, 0x4e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x54, 0x79, 0x70, 0x65, + 0x12, 0x08, 0x0a, 0x04, 0x55, 0x44, 0x50, 0x34, 0x10, 0x00, 0x12, 0x08, 0x0a, 0x04, 0x55, 0x44, + 0x50, 0x36, 0x10, 0x01, 0x12, 0x08, 0x0a, 0x04, 0x54, 0x43, 0x50, 0x34, 0x10, 0x02, 0x12, 0x08, + 0x0a, 0x04, 0x54, 0x43, 0x50, 0x36, 0x10, 0x03, 0x22, 0x6e, 0x0a, 0x07, 0x54, 0x43, 0x50, 0x54, + 0x79, 0x70, 0x65, 0x12, 0x18, 0x0a, 0x14, 0x54, 0x43, 0x50, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, + 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x13, 0x0a, + 0x0f, 0x54, 0x43, 0x50, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x41, 0x43, 0x54, 0x49, 0x56, 0x45, + 0x10, 0x01, 0x12, 0x14, 0x0a, 0x10, 0x54, 0x43, 0x50, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x50, + 0x41, 0x53, 0x53, 0x49, 0x56, 0x45, 0x10, 0x02, 0x12, 0x1e, 0x0a, 0x1a, 0x54, 0x43, 0x50, 0x5f, + 0x54, 0x59, 0x50, 0x45, 0x5f, 0x53, 0x49, 0x4d, 0x55, 0x4c, 0x54, 0x41, 0x4e, 0x45, 0x4f, 0x55, + 0x53, 0x5f, 0x4f, 0x50, 0x45, 0x4e, 0x10, 0x03, 0x42, 0x16, 0x5a, 0x14, 0x72, 0x69, 0x61, 0x73, + 0x63, 0x2e, 0x65, 0x75, 0x2f, 0x77, 0x69, 0x63, 0x65, 0x2f, 0x70, 0x6b, 0x67, 0x2f, 0x70, 0x62, + 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_candidate_proto_rawDescOnce sync.Once + file_candidate_proto_rawDescData = file_candidate_proto_rawDesc +) + +func file_candidate_proto_rawDescGZIP() []byte { + file_candidate_proto_rawDescOnce.Do(func() { + file_candidate_proto_rawDescData = protoimpl.X.CompressGZIP(file_candidate_proto_rawDescData) + }) + return file_candidate_proto_rawDescData +} + +var file_candidate_proto_enumTypes = make([]protoimpl.EnumInfo, 3) +var file_candidate_proto_msgTypes = make([]protoimpl.MessageInfo, 2) +var file_candidate_proto_goTypes = []interface{}{ + (Candidate_Type)(0), // 0: Candidate.Type + (Candidate_NetworkType)(0), // 1: Candidate.NetworkType + (Candidate_TCPType)(0), // 2: Candidate.TCPType + (*RelatedAddress)(nil), // 3: RelatedAddress + (*Candidate)(nil), // 4: Candidate +} +var file_candidate_proto_depIdxs = []int32{ + 0, // 0: Candidate.type:type_name -> Candidate.Type + 1, // 1: Candidate.network_type:type_name -> Candidate.NetworkType + 2, // 2: Candidate.tcp_type:type_name -> Candidate.TCPType + 3, // 3: Candidate.related_address:type_name -> RelatedAddress + 4, // [4:4] is the sub-list for method output_type + 4, // [4:4] is the sub-list for method input_type + 4, // [4:4] is the sub-list for extension type_name + 4, // [4:4] is the sub-list for extension extendee + 0, // [0:4] is the sub-list for field type_name +} + +func init() { file_candidate_proto_init() } +func file_candidate_proto_init() { + if File_candidate_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_candidate_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*RelatedAddress); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_candidate_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Candidate); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_candidate_proto_rawDesc, + NumEnums: 3, + NumMessages: 2, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_candidate_proto_goTypes, + DependencyIndexes: file_candidate_proto_depIdxs, + EnumInfos: file_candidate_proto_enumTypes, + MessageInfos: file_candidate_proto_msgTypes, + }.Build() + File_candidate_proto = out.File + file_candidate_proto_rawDesc = nil + file_candidate_proto_goTypes = nil + file_candidate_proto_depIdxs = nil +} diff --git a/pkg/pb/candidate.proto b/pkg/pb/candidate.proto new file mode 100644 index 00000000..69354385 --- /dev/null +++ b/pkg/pb/candidate.proto @@ -0,0 +1,42 @@ +syntax = "proto3"; + +option go_package = "riasc.eu/wice/pkg/pb"; + +message RelatedAddress { + string address = 1; + int32 port = 2; +} + +message Candidate { + enum Type { + TYPE_UNSPECIFIED = 0; + TYPE_HOST = 1; + TYPE_SERVER_REFLEXIVE = 2; + TYPE_PEER_REFLEXIVE = 3; + TYPE_RELAY = 4; + } + + enum NetworkType { + UDP4 = 0; + UDP6 = 1; + TCP4 = 2; + TCP6 = 3; + } + + enum TCPType { + TCP_TYPE_UNSPECIFIED = 0; + TCP_TYPE_ACTIVE = 1; + TCP_TYPE_PASSIVE = 2; + TCP_TYPE_SIMULTANEOUS_OPEN = 3; + } + + Type type = 1; + string foundation = 2; + int32 component = 3; + NetworkType network_type = 4; + int32 priority = 5; + string address = 6; + int32 port = 7; + TCPType tcp_type = 8; + RelatedAddress related_address = 9; +} \ No newline at end of file diff --git a/pkg/pb/common.go b/pkg/pb/common.go index 2be5c5c6..4ebaba1a 100644 --- a/pkg/pb/common.go +++ b/pkg/pb/common.go @@ -1,14 +1,28 @@ package pb -import "time" +import ( + "time" +) -var Ok = Error{ - Ok: true, +var Success = &Error{ + Code: Error_SUCCESS, +} + +func (e *Error) Error() string { + return e.Message +} + +func (e *Error) Ok() bool { + return e.Code == Error_SUCCESS } func TimeNow() *Timestamp { + return Time(time.Now()) +} + +func Time(s time.Time) *Timestamp { t := &Timestamp{} - t.Set(time.Now()) + t.Set(s) return t } diff --git a/pkg/pb/common.pb.go b/pkg/pb/common.pb.go index 3c45a800..efd7720b 100644 --- a/pkg/pb/common.pb.go +++ b/pkg/pb/common.pb.go @@ -20,59 +20,125 @@ const ( _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) ) -type Interface_Type int32 +// from pion/ice/ice.go +type ConnectionState int32 const ( - Interface_UNKNOWN Interface_Type = 0 - Interface_LINUX_KERNEL Interface_Type = 1 - Interface_OPENBSD_KERNEL Interface_Type = 2 - Interface_WINDOWS_KERNEL Interface_Type = 3 - Interface_USERSPACE Interface_Type = 4 + ConnectionState_NEW ConnectionState = 0 // ConnectionStateNew ICE agent is gathering addresses + ConnectionState_CHECKING ConnectionState = 1 // ConnectionStateChecking ICE agent has been given local and remote candidates, and is attempting to find a match + ConnectionState_CONNECTED ConnectionState = 2 // ConnectionStateConnected ICE agent has a pairing, but is still checking other pairs + ConnectionState_COMPLETED ConnectionState = 3 // ConnectionStateCompleted ICE agent has finished + ConnectionState_FAILED ConnectionState = 4 // ConnectionStateFailed ICE agent never could successfully connect + ConnectionState_DISCONNECTED ConnectionState = 5 // ConnectionStateDisconnected ICE agent connected successfully, but has entered a failed state + ConnectionState_CLOSED ConnectionState = 6 // ConnectionStateClosed ICE agent has finished and is no longer handling requests ) -// Enum value maps for Interface_Type. +// Enum value maps for ConnectionState. var ( - Interface_Type_name = map[int32]string{ - 0: "UNKNOWN", - 1: "LINUX_KERNEL", - 2: "OPENBSD_KERNEL", - 3: "WINDOWS_KERNEL", - 4: "USERSPACE", + ConnectionState_name = map[int32]string{ + 0: "NEW", + 1: "CHECKING", + 2: "CONNECTED", + 3: "COMPLETED", + 4: "FAILED", + 5: "DISCONNECTED", + 6: "CLOSED", } - Interface_Type_value = map[string]int32{ - "UNKNOWN": 0, - "LINUX_KERNEL": 1, - "OPENBSD_KERNEL": 2, - "WINDOWS_KERNEL": 3, - "USERSPACE": 4, + ConnectionState_value = map[string]int32{ + "NEW": 0, + "CHECKING": 1, + "CONNECTED": 2, + "COMPLETED": 3, + "FAILED": 4, + "DISCONNECTED": 5, + "CLOSED": 6, } ) -func (x Interface_Type) Enum() *Interface_Type { - p := new(Interface_Type) +func (x ConnectionState) Enum() *ConnectionState { + p := new(ConnectionState) *p = x return p } -func (x Interface_Type) String() string { +func (x ConnectionState) String() string { return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) } -func (Interface_Type) Descriptor() protoreflect.EnumDescriptor { +func (ConnectionState) Descriptor() protoreflect.EnumDescriptor { return file_common_proto_enumTypes[0].Descriptor() } -func (Interface_Type) Type() protoreflect.EnumType { +func (ConnectionState) Type() protoreflect.EnumType { return &file_common_proto_enumTypes[0] } -func (x Interface_Type) Number() protoreflect.EnumNumber { +func (x ConnectionState) Number() protoreflect.EnumNumber { return protoreflect.EnumNumber(x) } -// Deprecated: Use Interface_Type.Descriptor instead. -func (Interface_Type) EnumDescriptor() ([]byte, []int) { - return file_common_proto_rawDescGZIP(), []int{4, 0} +// Deprecated: Use ConnectionState.Descriptor instead. +func (ConnectionState) EnumDescriptor() ([]byte, []int) { + return file_common_proto_rawDescGZIP(), []int{0} +} + +// https://pubs.opengroup.org/onlinepubs/009696899/functions/xsh_chap02_03.html +type Error_Code int32 + +const ( + Error_SUCCESS Error_Code = 0 + Error_EPERM Error_Code = 1 + Error_ENOENT Error_Code = 2 + Error_EEXIST Error_Code = 17 + Error_EALREADY Error_Code = 18 + Error_ENOTSUP Error_Code = 10 +) + +// Enum value maps for Error_Code. +var ( + Error_Code_name = map[int32]string{ + 0: "SUCCESS", + 1: "EPERM", + 2: "ENOENT", + 17: "EEXIST", + 18: "EALREADY", + 10: "ENOTSUP", + } + Error_Code_value = map[string]int32{ + "SUCCESS": 0, + "EPERM": 1, + "ENOENT": 2, + "EEXIST": 17, + "EALREADY": 18, + "ENOTSUP": 10, + } +) + +func (x Error_Code) Enum() *Error_Code { + p := new(Error_Code) + *p = x + return p +} + +func (x Error_Code) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (Error_Code) Descriptor() protoreflect.EnumDescriptor { + return file_common_proto_enumTypes[1].Descriptor() +} + +func (Error_Code) Type() protoreflect.EnumType { + return &file_common_proto_enumTypes[1] +} + +func (x Error_Code) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use Error_Code.Descriptor instead. +func (Error_Code) EnumDescriptor() ([]byte, []int) { + return file_common_proto_rawDescGZIP(), []int{2, 0} } type Void struct { @@ -168,66 +234,19 @@ func (x *Timestamp) GetNanos() int32 { return 0 } -type Status struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - Interfaces []*Interface `protobuf:"bytes,1,rep,name=interfaces,proto3" json:"interfaces,omitempty"` -} - -func (x *Status) Reset() { - *x = Status{} - if protoimpl.UnsafeEnabled { - mi := &file_common_proto_msgTypes[2] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *Status) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*Status) ProtoMessage() {} - -func (x *Status) ProtoReflect() protoreflect.Message { - mi := &file_common_proto_msgTypes[2] - if protoimpl.UnsafeEnabled && x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use Status.ProtoReflect.Descriptor instead. -func (*Status) Descriptor() ([]byte, []int) { - return file_common_proto_rawDescGZIP(), []int{2} -} - -func (x *Status) GetInterfaces() []*Interface { - if x != nil { - return x.Interfaces - } - return nil -} - type Error struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - Ok bool `protobuf:"varint,1,opt,name=ok,proto3" json:"ok,omitempty"` - Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"` + Code Error_Code `protobuf:"varint,1,opt,name=code,proto3,enum=Error_Code" json:"code,omitempty"` + Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"` } func (x *Error) Reset() { *x = Error{} if protoimpl.UnsafeEnabled { - mi := &file_common_proto_msgTypes[3] + mi := &file_common_proto_msgTypes[2] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -240,7 +259,7 @@ func (x *Error) String() string { func (*Error) ProtoMessage() {} func (x *Error) ProtoReflect() protoreflect.Message { - mi := &file_common_proto_msgTypes[3] + mi := &file_common_proto_msgTypes[2] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -253,221 +272,23 @@ func (x *Error) ProtoReflect() protoreflect.Message { // Deprecated: Use Error.ProtoReflect.Descriptor instead. func (*Error) Descriptor() ([]byte, []int) { - return file_common_proto_rawDescGZIP(), []int{3} + return file_common_proto_rawDescGZIP(), []int{2} } -func (x *Error) GetOk() bool { +func (x *Error) GetCode() Error_Code { if x != nil { - return x.Ok + return x.Code } - return false + return Error_SUCCESS } -func (x *Error) GetError() string { +func (x *Error) GetMessage() string { if x != nil { - return x.Error + return x.Message } return "" } -type Interface struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` - Type Interface_Type `protobuf:"varint,2,opt,name=type,proto3,enum=Interface_Type" json:"type,omitempty"` - PrivateKey []byte `protobuf:"bytes,3,opt,name=private_key,json=privateKey,proto3" json:"private_key,omitempty"` - PublicKey []byte `protobuf:"bytes,4,opt,name=public_key,json=publicKey,proto3" json:"public_key,omitempty"` - ListenPort uint32 `protobuf:"varint,5,opt,name=listen_port,json=listenPort,proto3" json:"listen_port,omitempty"` - FirewallMark uint32 `protobuf:"varint,6,opt,name=firewall_mark,json=firewallMark,proto3" json:"firewall_mark,omitempty"` - Peers []*Peer `protobuf:"bytes,7,rep,name=peers,proto3" json:"peers,omitempty"` -} - -func (x *Interface) Reset() { - *x = Interface{} - if protoimpl.UnsafeEnabled { - mi := &file_common_proto_msgTypes[4] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *Interface) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*Interface) ProtoMessage() {} - -func (x *Interface) ProtoReflect() protoreflect.Message { - mi := &file_common_proto_msgTypes[4] - if protoimpl.UnsafeEnabled && x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use Interface.ProtoReflect.Descriptor instead. -func (*Interface) Descriptor() ([]byte, []int) { - return file_common_proto_rawDescGZIP(), []int{4} -} - -func (x *Interface) GetName() string { - if x != nil { - return x.Name - } - return "" -} - -func (x *Interface) GetType() Interface_Type { - if x != nil { - return x.Type - } - return Interface_UNKNOWN -} - -func (x *Interface) GetPrivateKey() []byte { - if x != nil { - return x.PrivateKey - } - return nil -} - -func (x *Interface) GetPublicKey() []byte { - if x != nil { - return x.PublicKey - } - return nil -} - -func (x *Interface) GetListenPort() uint32 { - if x != nil { - return x.ListenPort - } - return 0 -} - -func (x *Interface) GetFirewallMark() uint32 { - if x != nil { - return x.FirewallMark - } - return 0 -} - -func (x *Interface) GetPeers() []*Peer { - if x != nil { - return x.Peers - } - return nil -} - -type Peer struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - PublicKey []byte `protobuf:"bytes,1,opt,name=public_key,json=publicKey,proto3" json:"public_key,omitempty"` - Endpoint []string `protobuf:"bytes,2,rep,name=Endpoint,proto3" json:"Endpoint,omitempty"` - PersistentKeepaliveInterval uint32 `protobuf:"varint,3,opt,name=persistent_keepalive_interval,json=persistentKeepaliveInterval,proto3" json:"persistent_keepalive_interval,omitempty"` - LastHandshake *Timestamp `protobuf:"bytes,4,opt,name=last_handshake,json=lastHandshake,proto3" json:"last_handshake,omitempty"` - TransmitBytes int64 `protobuf:"varint,5,opt,name=transmit_bytes,json=transmitBytes,proto3" json:"transmit_bytes,omitempty"` - ReceiveBytes int64 `protobuf:"varint,6,opt,name=receive_bytes,json=receiveBytes,proto3" json:"receive_bytes,omitempty"` - AllowedIps []string `protobuf:"bytes,7,rep,name=allowed_ips,json=allowedIps,proto3" json:"allowed_ips,omitempty"` - ProtocolVersion uint32 `protobuf:"varint,8,opt,name=protocol_version,json=protocolVersion,proto3" json:"protocol_version,omitempty"` -} - -func (x *Peer) Reset() { - *x = Peer{} - if protoimpl.UnsafeEnabled { - mi := &file_common_proto_msgTypes[5] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *Peer) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*Peer) ProtoMessage() {} - -func (x *Peer) ProtoReflect() protoreflect.Message { - mi := &file_common_proto_msgTypes[5] - if protoimpl.UnsafeEnabled && x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use Peer.ProtoReflect.Descriptor instead. -func (*Peer) Descriptor() ([]byte, []int) { - return file_common_proto_rawDescGZIP(), []int{5} -} - -func (x *Peer) GetPublicKey() []byte { - if x != nil { - return x.PublicKey - } - return nil -} - -func (x *Peer) GetEndpoint() []string { - if x != nil { - return x.Endpoint - } - return nil -} - -func (x *Peer) GetPersistentKeepaliveInterval() uint32 { - if x != nil { - return x.PersistentKeepaliveInterval - } - return 0 -} - -func (x *Peer) GetLastHandshake() *Timestamp { - if x != nil { - return x.LastHandshake - } - return nil -} - -func (x *Peer) GetTransmitBytes() int64 { - if x != nil { - return x.TransmitBytes - } - return 0 -} - -func (x *Peer) GetReceiveBytes() int64 { - if x != nil { - return x.ReceiveBytes - } - return 0 -} - -func (x *Peer) GetAllowedIps() []string { - if x != nil { - return x.AllowedIps - } - return nil -} - -func (x *Peer) GetProtocolVersion() uint32 { - if x != nil { - return x.ProtocolVersion - } - return 0 -} - var File_common_proto protoreflect.FileDescriptor var file_common_proto_rawDesc = []byte{ @@ -476,57 +297,25 @@ var file_common_proto_rawDesc = []byte{ 0x61, 0x6d, 0x70, 0x12, 0x18, 0x0a, 0x07, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x6e, 0x61, 0x6e, 0x6f, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x6e, 0x61, - 0x6e, 0x6f, 0x73, 0x22, 0x34, 0x0a, 0x06, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x2a, 0x0a, - 0x0a, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, - 0x0b, 0x32, 0x0a, 0x2e, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x52, 0x0a, 0x69, - 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x73, 0x22, 0x2d, 0x0a, 0x05, 0x45, 0x72, 0x72, - 0x6f, 0x72, 0x12, 0x0e, 0x0a, 0x02, 0x6f, 0x6b, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x02, - 0x6f, 0x6b, 0x12, 0x14, 0x0a, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x22, 0xc5, 0x02, 0x0a, 0x09, 0x49, 0x6e, 0x74, - 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x23, 0x0a, 0x04, 0x74, 0x79, - 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x0f, 0x2e, 0x49, 0x6e, 0x74, 0x65, 0x72, - 0x66, 0x61, 0x63, 0x65, 0x2e, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, - 0x1f, 0x0a, 0x0b, 0x70, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x03, - 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x70, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x4b, 0x65, 0x79, - 0x12, 0x1d, 0x0a, 0x0a, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x04, - 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x12, - 0x1f, 0x0a, 0x0b, 0x6c, 0x69, 0x73, 0x74, 0x65, 0x6e, 0x5f, 0x70, 0x6f, 0x72, 0x74, 0x18, 0x05, - 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0a, 0x6c, 0x69, 0x73, 0x74, 0x65, 0x6e, 0x50, 0x6f, 0x72, 0x74, - 0x12, 0x23, 0x0a, 0x0d, 0x66, 0x69, 0x72, 0x65, 0x77, 0x61, 0x6c, 0x6c, 0x5f, 0x6d, 0x61, 0x72, - 0x6b, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0c, 0x66, 0x69, 0x72, 0x65, 0x77, 0x61, 0x6c, - 0x6c, 0x4d, 0x61, 0x72, 0x6b, 0x12, 0x1b, 0x0a, 0x05, 0x70, 0x65, 0x65, 0x72, 0x73, 0x18, 0x07, - 0x20, 0x03, 0x28, 0x0b, 0x32, 0x05, 0x2e, 0x50, 0x65, 0x65, 0x72, 0x52, 0x05, 0x70, 0x65, 0x65, - 0x72, 0x73, 0x22, 0x5c, 0x0a, 0x04, 0x54, 0x79, 0x70, 0x65, 0x12, 0x0b, 0x0a, 0x07, 0x55, 0x4e, - 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12, 0x10, 0x0a, 0x0c, 0x4c, 0x49, 0x4e, 0x55, 0x58, - 0x5f, 0x4b, 0x45, 0x52, 0x4e, 0x45, 0x4c, 0x10, 0x01, 0x12, 0x12, 0x0a, 0x0e, 0x4f, 0x50, 0x45, - 0x4e, 0x42, 0x53, 0x44, 0x5f, 0x4b, 0x45, 0x52, 0x4e, 0x45, 0x4c, 0x10, 0x02, 0x12, 0x12, 0x0a, - 0x0e, 0x57, 0x49, 0x4e, 0x44, 0x4f, 0x57, 0x53, 0x5f, 0x4b, 0x45, 0x52, 0x4e, 0x45, 0x4c, 0x10, - 0x03, 0x12, 0x0d, 0x0a, 0x09, 0x55, 0x53, 0x45, 0x52, 0x53, 0x50, 0x41, 0x43, 0x45, 0x10, 0x04, - 0x22, 0xd0, 0x02, 0x0a, 0x04, 0x50, 0x65, 0x65, 0x72, 0x12, 0x1d, 0x0a, 0x0a, 0x70, 0x75, 0x62, - 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x70, - 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x12, 0x1a, 0x0a, 0x08, 0x45, 0x6e, 0x64, 0x70, - 0x6f, 0x69, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x45, 0x6e, 0x64, 0x70, - 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x42, 0x0a, 0x1d, 0x70, 0x65, 0x72, 0x73, 0x69, 0x73, 0x74, 0x65, - 0x6e, 0x74, 0x5f, 0x6b, 0x65, 0x65, 0x70, 0x61, 0x6c, 0x69, 0x76, 0x65, 0x5f, 0x69, 0x6e, 0x74, - 0x65, 0x72, 0x76, 0x61, 0x6c, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x1b, 0x70, 0x65, 0x72, - 0x73, 0x69, 0x73, 0x74, 0x65, 0x6e, 0x74, 0x4b, 0x65, 0x65, 0x70, 0x61, 0x6c, 0x69, 0x76, 0x65, - 0x49, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x12, 0x31, 0x0a, 0x0e, 0x6c, 0x61, 0x73, 0x74, - 0x5f, 0x68, 0x61, 0x6e, 0x64, 0x73, 0x68, 0x61, 0x6b, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, - 0x32, 0x0a, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x0d, 0x6c, 0x61, - 0x73, 0x74, 0x48, 0x61, 0x6e, 0x64, 0x73, 0x68, 0x61, 0x6b, 0x65, 0x12, 0x25, 0x0a, 0x0e, 0x74, - 0x72, 0x61, 0x6e, 0x73, 0x6d, 0x69, 0x74, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x05, 0x20, - 0x01, 0x28, 0x03, 0x52, 0x0d, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x6d, 0x69, 0x74, 0x42, 0x79, 0x74, - 0x65, 0x73, 0x12, 0x23, 0x0a, 0x0d, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x5f, 0x62, 0x79, - 0x74, 0x65, 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x72, 0x65, 0x63, 0x65, 0x69, - 0x76, 0x65, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x1f, 0x0a, 0x0b, 0x61, 0x6c, 0x6c, 0x6f, 0x77, - 0x65, 0x64, 0x5f, 0x69, 0x70, 0x73, 0x18, 0x07, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x61, 0x6c, - 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x49, 0x70, 0x73, 0x12, 0x29, 0x0a, 0x10, 0x70, 0x72, 0x6f, 0x74, - 0x6f, 0x63, 0x6f, 0x6c, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x08, 0x20, 0x01, - 0x28, 0x0d, 0x52, 0x0f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x56, 0x65, 0x72, 0x73, - 0x69, 0x6f, 0x6e, 0x42, 0x16, 0x5a, 0x14, 0x72, 0x69, 0x61, 0x73, 0x63, 0x2e, 0x65, 0x75, 0x2f, - 0x77, 0x69, 0x63, 0x65, 0x2f, 0x70, 0x6b, 0x67, 0x2f, 0x70, 0x62, 0x62, 0x06, 0x70, 0x72, 0x6f, - 0x74, 0x6f, 0x33, + 0x6e, 0x6f, 0x73, 0x22, 0x95, 0x01, 0x0a, 0x05, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x12, 0x1f, 0x0a, + 0x04, 0x63, 0x6f, 0x64, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x0b, 0x2e, 0x45, 0x72, + 0x72, 0x6f, 0x72, 0x2e, 0x43, 0x6f, 0x64, 0x65, 0x52, 0x04, 0x63, 0x6f, 0x64, 0x65, 0x12, 0x18, + 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x51, 0x0a, 0x04, 0x43, 0x6f, 0x64, 0x65, + 0x12, 0x0b, 0x0a, 0x07, 0x53, 0x55, 0x43, 0x43, 0x45, 0x53, 0x53, 0x10, 0x00, 0x12, 0x09, 0x0a, + 0x05, 0x45, 0x50, 0x45, 0x52, 0x4d, 0x10, 0x01, 0x12, 0x0a, 0x0a, 0x06, 0x45, 0x4e, 0x4f, 0x45, + 0x4e, 0x54, 0x10, 0x02, 0x12, 0x0a, 0x0a, 0x06, 0x45, 0x45, 0x58, 0x49, 0x53, 0x54, 0x10, 0x11, + 0x12, 0x0c, 0x0a, 0x08, 0x45, 0x41, 0x4c, 0x52, 0x45, 0x41, 0x44, 0x59, 0x10, 0x12, 0x12, 0x0b, + 0x0a, 0x07, 0x45, 0x4e, 0x4f, 0x54, 0x53, 0x55, 0x50, 0x10, 0x0a, 0x2a, 0x70, 0x0a, 0x0f, 0x43, + 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x07, + 0x0a, 0x03, 0x4e, 0x45, 0x57, 0x10, 0x00, 0x12, 0x0c, 0x0a, 0x08, 0x43, 0x48, 0x45, 0x43, 0x4b, + 0x49, 0x4e, 0x47, 0x10, 0x01, 0x12, 0x0d, 0x0a, 0x09, 0x43, 0x4f, 0x4e, 0x4e, 0x45, 0x43, 0x54, + 0x45, 0x44, 0x10, 0x02, 0x12, 0x0d, 0x0a, 0x09, 0x43, 0x4f, 0x4d, 0x50, 0x4c, 0x45, 0x54, 0x45, + 0x44, 0x10, 0x03, 0x12, 0x0a, 0x0a, 0x06, 0x46, 0x41, 0x49, 0x4c, 0x45, 0x44, 0x10, 0x04, 0x12, + 0x10, 0x0a, 0x0c, 0x44, 0x49, 0x53, 0x43, 0x4f, 0x4e, 0x4e, 0x45, 0x43, 0x54, 0x45, 0x44, 0x10, + 0x05, 0x12, 0x0a, 0x0a, 0x06, 0x43, 0x4c, 0x4f, 0x53, 0x45, 0x44, 0x10, 0x06, 0x42, 0x16, 0x5a, + 0x14, 0x72, 0x69, 0x61, 0x73, 0x63, 0x2e, 0x65, 0x75, 0x2f, 0x77, 0x69, 0x63, 0x65, 0x2f, 0x70, + 0x6b, 0x67, 0x2f, 0x70, 0x62, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, } var ( @@ -541,27 +330,22 @@ func file_common_proto_rawDescGZIP() []byte { return file_common_proto_rawDescData } -var file_common_proto_enumTypes = make([]protoimpl.EnumInfo, 1) -var file_common_proto_msgTypes = make([]protoimpl.MessageInfo, 6) +var file_common_proto_enumTypes = make([]protoimpl.EnumInfo, 2) +var file_common_proto_msgTypes = make([]protoimpl.MessageInfo, 3) var file_common_proto_goTypes = []interface{}{ - (Interface_Type)(0), // 0: Interface.Type - (*Void)(nil), // 1: Void - (*Timestamp)(nil), // 2: Timestamp - (*Status)(nil), // 3: Status - (*Error)(nil), // 4: Error - (*Interface)(nil), // 5: Interface - (*Peer)(nil), // 6: Peer + (ConnectionState)(0), // 0: ConnectionState + (Error_Code)(0), // 1: Error.Code + (*Void)(nil), // 2: Void + (*Timestamp)(nil), // 3: Timestamp + (*Error)(nil), // 4: Error } var file_common_proto_depIdxs = []int32{ - 5, // 0: Status.interfaces:type_name -> Interface - 0, // 1: Interface.type:type_name -> Interface.Type - 6, // 2: Interface.peers:type_name -> Peer - 2, // 3: Peer.last_handshake:type_name -> Timestamp - 4, // [4:4] is the sub-list for method output_type - 4, // [4:4] is the sub-list for method input_type - 4, // [4:4] is the sub-list for extension type_name - 4, // [4:4] is the sub-list for extension extendee - 0, // [0:4] is the sub-list for field type_name + 1, // 0: Error.code:type_name -> Error.Code + 1, // [1:1] is the sub-list for method output_type + 1, // [1:1] is the sub-list for method input_type + 1, // [1:1] is the sub-list for extension type_name + 1, // [1:1] is the sub-list for extension extendee + 0, // [0:1] is the sub-list for field type_name } func init() { file_common_proto_init() } @@ -595,18 +379,6 @@ func file_common_proto_init() { } } file_common_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*Status); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_common_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*Error); i { case 0: return &v.state @@ -618,38 +390,14 @@ func file_common_proto_init() { return nil } } - file_common_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*Interface); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_common_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*Peer); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } } type x struct{} out := protoimpl.TypeBuilder{ File: protoimpl.DescBuilder{ GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: file_common_proto_rawDesc, - NumEnums: 1, - NumMessages: 6, + NumEnums: 2, + NumMessages: 3, NumExtensions: 0, NumServices: 0, }, diff --git a/pkg/pb/common.proto b/pkg/pb/common.proto index 3a6e23ec..7fda2b25 100644 --- a/pkg/pb/common.proto +++ b/pkg/pb/common.proto @@ -4,51 +4,33 @@ option go_package = "riasc.eu/wice/pkg/pb"; message Void {} -message Timestamp { - int64 seconds = 1; - int32 nanos = 2; +// from pion/ice/ice.go +enum ConnectionState { + NEW = 0; // ConnectionStateNew ICE agent is gathering addresses + CHECKING = 1; // ConnectionStateChecking ICE agent has been given local and remote candidates, and is attempting to find a match + CONNECTED = 2; // ConnectionStateConnected ICE agent has a pairing, but is still checking other pairs + COMPLETED = 3; // ConnectionStateCompleted ICE agent has finished + FAILED = 4; // ConnectionStateFailed ICE agent never could successfully connect + DISCONNECTED = 5; // ConnectionStateDisconnected ICE agent connected successfully, but has entered a failed state + CLOSED = 6; // ConnectionStateClosed ICE agent has finished and is no longer handling requests } -message Status { - repeated Interface interfaces = 1; +message Timestamp { + int64 seconds = 1; + int32 nanos = 2; } message Error { - bool ok = 1; - string error = 2; + // https://pubs.opengroup.org/onlinepubs/009696899/functions/xsh_chap02_03.html + enum Code { + SUCCESS = 0; + EPERM = 1; + ENOENT = 2; + EEXIST = 17; + EALREADY = 18; + ENOTSUP = 10; + } + + Code code = 1; + string message = 2; } - -message Interface { - enum Type { - UNKNOWN = 0; - LINUX_KERNEL = 1; - OPENBSD_KERNEL = 2; - WINDOWS_KERNEL = 3; - USERSPACE = 4; - } - - string name = 1; - Type type = 2; - - bytes private_key = 3; - bytes public_key = 4; - - uint32 listen_port = 5; - - uint32 firewall_mark = 6; - - repeated Peer peers = 7; -} - -message Peer { - bytes public_key = 1; - - repeated string Endpoint = 2; - - uint32 persistent_keepalive_interval = 3; - Timestamp last_handshake = 4; - int64 transmit_bytes = 5; - int64 receive_bytes = 6; - repeated string allowed_ips = 7; - uint32 protocol_version = 8; -} \ No newline at end of file diff --git a/pkg/pb/event.go b/pkg/pb/event.go index 137c7010..6b8fa49e 100644 --- a/pkg/pb/event.go +++ b/pkg/pb/event.go @@ -8,6 +8,7 @@ func (e *Event) Log(l *zap.Logger, msg string, fields ...zap.Field) { fields = append(fields, zap.String("type", e.Type), zap.String("state", e.State), + zap.Any("event", e.Event), ) if e.Time != nil { diff --git a/pkg/pb/event.pb.go b/pkg/pb/event.pb.go index 3be55b01..abb7148b 100644 --- a/pkg/pb/event.pb.go +++ b/pkg/pb/event.pb.go @@ -186,7 +186,8 @@ type PeerEvent struct { sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - Peer *Peer `protobuf:"bytes,1,opt,name=peer,proto3" json:"peer,omitempty"` + Peer *Peer `protobuf:"bytes,1,opt,name=peer,proto3" json:"peer,omitempty"` + Modified []string `protobuf:"bytes,2,rep,name=modified,proto3" json:"modified,omitempty"` } func (x *PeerEvent) Reset() { @@ -228,6 +229,13 @@ func (x *PeerEvent) GetPeer() *Peer { return nil } +func (x *PeerEvent) GetModified() []string { + if x != nil { + return x.Modified + } + return nil +} + type InterfaceEvent struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache @@ -342,37 +350,40 @@ var File_event_proto protoreflect.FileDescriptor var file_event_proto_rawDesc = []byte{ 0x0a, 0x0b, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x0c, 0x63, - 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xce, 0x01, 0x0a, 0x05, - 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x1e, 0x0a, 0x04, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x0b, 0x32, 0x0a, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, - 0x04, 0x74, 0x69, 0x6d, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x74, 0x61, - 0x74, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x12, - 0x20, 0x0a, 0x04, 0x70, 0x65, 0x65, 0x72, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0a, 0x2e, - 0x50, 0x65, 0x65, 0x72, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x48, 0x00, 0x52, 0x04, 0x70, 0x65, 0x65, - 0x72, 0x12, 0x25, 0x0a, 0x04, 0x69, 0x6e, 0x74, 0x66, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32, - 0x0f, 0x2e, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74, - 0x48, 0x00, 0x52, 0x04, 0x69, 0x6e, 0x74, 0x66, 0x12, 0x29, 0x0a, 0x07, 0x62, 0x61, 0x63, 0x6b, - 0x65, 0x6e, 0x64, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0d, 0x2e, 0x42, 0x61, 0x63, 0x6b, - 0x65, 0x6e, 0x64, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x48, 0x00, 0x52, 0x07, 0x62, 0x61, 0x63, 0x6b, - 0x65, 0x6e, 0x64, 0x42, 0x07, 0x0a, 0x05, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x22, 0x26, 0x0a, 0x09, - 0x50, 0x65, 0x65, 0x72, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x19, 0x0a, 0x04, 0x70, 0x65, 0x65, - 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x05, 0x2e, 0x50, 0x65, 0x65, 0x72, 0x52, 0x04, - 0x70, 0x65, 0x65, 0x72, 0x22, 0x3a, 0x0a, 0x0e, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, - 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x28, 0x0a, 0x09, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x66, - 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0a, 0x2e, 0x49, 0x6e, 0x74, 0x65, - 0x72, 0x66, 0x61, 0x63, 0x65, 0x52, 0x09, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, - 0x22, 0x84, 0x01, 0x0a, 0x0c, 0x42, 0x61, 0x63, 0x6b, 0x65, 0x6e, 0x64, 0x45, 0x76, 0x65, 0x6e, - 0x74, 0x12, 0x26, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, - 0x12, 0x2e, 0x42, 0x61, 0x63, 0x6b, 0x65, 0x6e, 0x64, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x2e, 0x54, - 0x79, 0x70, 0x65, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, - 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x29, 0x0a, 0x10, 0x6c, 0x69, 0x73, - 0x74, 0x65, 0x6e, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x18, 0x03, 0x20, - 0x03, 0x28, 0x09, 0x52, 0x0f, 0x6c, 0x69, 0x73, 0x74, 0x65, 0x6e, 0x41, 0x64, 0x64, 0x72, 0x65, - 0x73, 0x73, 0x65, 0x73, 0x22, 0x11, 0x0a, 0x04, 0x54, 0x79, 0x70, 0x65, 0x12, 0x09, 0x0a, 0x05, - 0x52, 0x45, 0x41, 0x44, 0x59, 0x10, 0x00, 0x42, 0x16, 0x5a, 0x14, 0x72, 0x69, 0x61, 0x73, 0x63, - 0x2e, 0x65, 0x75, 0x2f, 0x77, 0x69, 0x63, 0x65, 0x2f, 0x70, 0x6b, 0x67, 0x2f, 0x70, 0x62, 0x62, - 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, + 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x0a, 0x70, 0x65, 0x65, + 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x0f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, + 0x63, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xce, 0x01, 0x0a, 0x05, 0x45, 0x76, 0x65, + 0x6e, 0x74, 0x12, 0x1e, 0x0a, 0x04, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x0a, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x04, 0x74, 0x69, + 0x6d, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x12, 0x20, 0x0a, 0x04, + 0x70, 0x65, 0x65, 0x72, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0a, 0x2e, 0x50, 0x65, 0x65, + 0x72, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x48, 0x00, 0x52, 0x04, 0x70, 0x65, 0x65, 0x72, 0x12, 0x25, + 0x0a, 0x04, 0x69, 0x6e, 0x74, 0x66, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x49, + 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x48, 0x00, 0x52, + 0x04, 0x69, 0x6e, 0x74, 0x66, 0x12, 0x29, 0x0a, 0x07, 0x62, 0x61, 0x63, 0x6b, 0x65, 0x6e, 0x64, + 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0d, 0x2e, 0x42, 0x61, 0x63, 0x6b, 0x65, 0x6e, 0x64, + 0x45, 0x76, 0x65, 0x6e, 0x74, 0x48, 0x00, 0x52, 0x07, 0x62, 0x61, 0x63, 0x6b, 0x65, 0x6e, 0x64, + 0x42, 0x07, 0x0a, 0x05, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x22, 0x42, 0x0a, 0x09, 0x50, 0x65, 0x65, + 0x72, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x19, 0x0a, 0x04, 0x70, 0x65, 0x65, 0x72, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x05, 0x2e, 0x50, 0x65, 0x65, 0x72, 0x52, 0x04, 0x70, 0x65, 0x65, + 0x72, 0x12, 0x1a, 0x0a, 0x08, 0x6d, 0x6f, 0x64, 0x69, 0x66, 0x69, 0x65, 0x64, 0x18, 0x02, 0x20, + 0x03, 0x28, 0x09, 0x52, 0x08, 0x6d, 0x6f, 0x64, 0x69, 0x66, 0x69, 0x65, 0x64, 0x22, 0x3a, 0x0a, + 0x0e, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, + 0x28, 0x0a, 0x09, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x0a, 0x2e, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x52, 0x09, + 0x69, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x22, 0x84, 0x01, 0x0a, 0x0c, 0x42, 0x61, + 0x63, 0x6b, 0x65, 0x6e, 0x64, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x26, 0x0a, 0x04, 0x74, 0x79, + 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x12, 0x2e, 0x42, 0x61, 0x63, 0x6b, 0x65, + 0x6e, 0x64, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x2e, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, 0x74, 0x79, + 0x70, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, + 0x69, 0x64, 0x12, 0x29, 0x0a, 0x10, 0x6c, 0x69, 0x73, 0x74, 0x65, 0x6e, 0x5f, 0x61, 0x64, 0x64, + 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0f, 0x6c, 0x69, + 0x73, 0x74, 0x65, 0x6e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x22, 0x11, 0x0a, + 0x04, 0x54, 0x79, 0x70, 0x65, 0x12, 0x09, 0x0a, 0x05, 0x52, 0x45, 0x41, 0x44, 0x59, 0x10, 0x00, + 0x42, 0x16, 0x5a, 0x14, 0x72, 0x69, 0x61, 0x73, 0x63, 0x2e, 0x65, 0x75, 0x2f, 0x77, 0x69, 0x63, + 0x65, 0x2f, 0x70, 0x6b, 0x67, 0x2f, 0x70, 0x62, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, } var ( @@ -420,6 +431,8 @@ func file_event_proto_init() { return } file_common_proto_init() + file_peer_proto_init() + file_interface_proto_init() if !protoimpl.UnsafeEnabled { file_event_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*Event); i { diff --git a/pkg/pb/event.proto b/pkg/pb/event.proto index 8e1d7c6d..1d5b6824 100644 --- a/pkg/pb/event.proto +++ b/pkg/pb/event.proto @@ -3,6 +3,8 @@ syntax = "proto3"; option go_package = "riasc.eu/wice/pkg/pb"; import "common.proto"; +import "peer.proto"; +import "interface.proto"; message Event { Timestamp time = 1; @@ -19,7 +21,7 @@ message Event { message PeerEvent { Peer peer = 1; - + repeated string modified = 2; } message InterfaceEvent { diff --git a/pkg/pb/generate.go b/pkg/pb/generate.go new file mode 100644 index 00000000..60c39673 --- /dev/null +++ b/pkg/pb/generate.go @@ -0,0 +1,4 @@ +package pb + +//go:generate protoc --go_out=. --go_opt=paths=source_relative socket.proto candidate.proto common.proto event.proto interface.proto offer.proto peer.proto +//go:generate protoc --go-grpc_out=. --go-grpc_opt=paths=source_relative socket.proto diff --git a/pkg/pb/interface.pb.go b/pkg/pb/interface.pb.go new file mode 100644 index 00000000..ed7ffb0a --- /dev/null +++ b/pkg/pb/interface.pb.go @@ -0,0 +1,271 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.27.1 +// protoc v3.14.0 +// source: interface.proto + +package pb + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +type Interface_Type int32 + +const ( + Interface_UNKNOWN Interface_Type = 0 + Interface_LINUX_KERNEL Interface_Type = 1 + Interface_OPENBSD_KERNEL Interface_Type = 2 + Interface_WINDOWS_KERNEL Interface_Type = 3 + Interface_USERSPACE Interface_Type = 4 +) + +// Enum value maps for Interface_Type. +var ( + Interface_Type_name = map[int32]string{ + 0: "UNKNOWN", + 1: "LINUX_KERNEL", + 2: "OPENBSD_KERNEL", + 3: "WINDOWS_KERNEL", + 4: "USERSPACE", + } + Interface_Type_value = map[string]int32{ + "UNKNOWN": 0, + "LINUX_KERNEL": 1, + "OPENBSD_KERNEL": 2, + "WINDOWS_KERNEL": 3, + "USERSPACE": 4, + } +) + +func (x Interface_Type) Enum() *Interface_Type { + p := new(Interface_Type) + *p = x + return p +} + +func (x Interface_Type) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (Interface_Type) Descriptor() protoreflect.EnumDescriptor { + return file_interface_proto_enumTypes[0].Descriptor() +} + +func (Interface_Type) Type() protoreflect.EnumType { + return &file_interface_proto_enumTypes[0] +} + +func (x Interface_Type) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use Interface_Type.Descriptor instead. +func (Interface_Type) EnumDescriptor() ([]byte, []int) { + return file_interface_proto_rawDescGZIP(), []int{0, 0} +} + +type Interface struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + Type Interface_Type `protobuf:"varint,2,opt,name=type,proto3,enum=Interface_Type" json:"type,omitempty"` + PrivateKey []byte `protobuf:"bytes,3,opt,name=private_key,json=privateKey,proto3" json:"private_key,omitempty"` + PublicKey []byte `protobuf:"bytes,4,opt,name=public_key,json=publicKey,proto3" json:"public_key,omitempty"` + ListenPort uint32 `protobuf:"varint,5,opt,name=listen_port,json=listenPort,proto3" json:"listen_port,omitempty"` + FirewallMark uint32 `protobuf:"varint,6,opt,name=firewall_mark,json=firewallMark,proto3" json:"firewall_mark,omitempty"` + Peers []*Peer `protobuf:"bytes,7,rep,name=peers,proto3" json:"peers,omitempty"` +} + +func (x *Interface) Reset() { + *x = Interface{} + if protoimpl.UnsafeEnabled { + mi := &file_interface_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Interface) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Interface) ProtoMessage() {} + +func (x *Interface) ProtoReflect() protoreflect.Message { + mi := &file_interface_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Interface.ProtoReflect.Descriptor instead. +func (*Interface) Descriptor() ([]byte, []int) { + return file_interface_proto_rawDescGZIP(), []int{0} +} + +func (x *Interface) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *Interface) GetType() Interface_Type { + if x != nil { + return x.Type + } + return Interface_UNKNOWN +} + +func (x *Interface) GetPrivateKey() []byte { + if x != nil { + return x.PrivateKey + } + return nil +} + +func (x *Interface) GetPublicKey() []byte { + if x != nil { + return x.PublicKey + } + return nil +} + +func (x *Interface) GetListenPort() uint32 { + if x != nil { + return x.ListenPort + } + return 0 +} + +func (x *Interface) GetFirewallMark() uint32 { + if x != nil { + return x.FirewallMark + } + return 0 +} + +func (x *Interface) GetPeers() []*Peer { + if x != nil { + return x.Peers + } + return nil +} + +var File_interface_proto protoreflect.FileDescriptor + +var file_interface_proto_rawDesc = []byte{ + 0x0a, 0x0f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x1a, 0x0a, 0x70, 0x65, 0x65, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xc5, 0x02, + 0x0a, 0x09, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6e, + 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, + 0x23, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x0f, 0x2e, + 0x49, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x2e, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, + 0x74, 0x79, 0x70, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x70, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x5f, + 0x6b, 0x65, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x70, 0x72, 0x69, 0x76, 0x61, + 0x74, 0x65, 0x4b, 0x65, 0x79, 0x12, 0x1d, 0x0a, 0x0a, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, + 0x6b, 0x65, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x70, 0x75, 0x62, 0x6c, 0x69, + 0x63, 0x4b, 0x65, 0x79, 0x12, 0x1f, 0x0a, 0x0b, 0x6c, 0x69, 0x73, 0x74, 0x65, 0x6e, 0x5f, 0x70, + 0x6f, 0x72, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0a, 0x6c, 0x69, 0x73, 0x74, 0x65, + 0x6e, 0x50, 0x6f, 0x72, 0x74, 0x12, 0x23, 0x0a, 0x0d, 0x66, 0x69, 0x72, 0x65, 0x77, 0x61, 0x6c, + 0x6c, 0x5f, 0x6d, 0x61, 0x72, 0x6b, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0c, 0x66, 0x69, + 0x72, 0x65, 0x77, 0x61, 0x6c, 0x6c, 0x4d, 0x61, 0x72, 0x6b, 0x12, 0x1b, 0x0a, 0x05, 0x70, 0x65, + 0x65, 0x72, 0x73, 0x18, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x05, 0x2e, 0x50, 0x65, 0x65, 0x72, + 0x52, 0x05, 0x70, 0x65, 0x65, 0x72, 0x73, 0x22, 0x5c, 0x0a, 0x04, 0x54, 0x79, 0x70, 0x65, 0x12, + 0x0b, 0x0a, 0x07, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12, 0x10, 0x0a, 0x0c, + 0x4c, 0x49, 0x4e, 0x55, 0x58, 0x5f, 0x4b, 0x45, 0x52, 0x4e, 0x45, 0x4c, 0x10, 0x01, 0x12, 0x12, + 0x0a, 0x0e, 0x4f, 0x50, 0x45, 0x4e, 0x42, 0x53, 0x44, 0x5f, 0x4b, 0x45, 0x52, 0x4e, 0x45, 0x4c, + 0x10, 0x02, 0x12, 0x12, 0x0a, 0x0e, 0x57, 0x49, 0x4e, 0x44, 0x4f, 0x57, 0x53, 0x5f, 0x4b, 0x45, + 0x52, 0x4e, 0x45, 0x4c, 0x10, 0x03, 0x12, 0x0d, 0x0a, 0x09, 0x55, 0x53, 0x45, 0x52, 0x53, 0x50, + 0x41, 0x43, 0x45, 0x10, 0x04, 0x42, 0x16, 0x5a, 0x14, 0x72, 0x69, 0x61, 0x73, 0x63, 0x2e, 0x65, + 0x75, 0x2f, 0x77, 0x69, 0x63, 0x65, 0x2f, 0x70, 0x6b, 0x67, 0x2f, 0x70, 0x62, 0x62, 0x06, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_interface_proto_rawDescOnce sync.Once + file_interface_proto_rawDescData = file_interface_proto_rawDesc +) + +func file_interface_proto_rawDescGZIP() []byte { + file_interface_proto_rawDescOnce.Do(func() { + file_interface_proto_rawDescData = protoimpl.X.CompressGZIP(file_interface_proto_rawDescData) + }) + return file_interface_proto_rawDescData +} + +var file_interface_proto_enumTypes = make([]protoimpl.EnumInfo, 1) +var file_interface_proto_msgTypes = make([]protoimpl.MessageInfo, 1) +var file_interface_proto_goTypes = []interface{}{ + (Interface_Type)(0), // 0: Interface.Type + (*Interface)(nil), // 1: Interface + (*Peer)(nil), // 2: Peer +} +var file_interface_proto_depIdxs = []int32{ + 0, // 0: Interface.type:type_name -> Interface.Type + 2, // 1: Interface.peers:type_name -> Peer + 2, // [2:2] is the sub-list for method output_type + 2, // [2:2] is the sub-list for method input_type + 2, // [2:2] is the sub-list for extension type_name + 2, // [2:2] is the sub-list for extension extendee + 0, // [0:2] is the sub-list for field type_name +} + +func init() { file_interface_proto_init() } +func file_interface_proto_init() { + if File_interface_proto != nil { + return + } + file_peer_proto_init() + if !protoimpl.UnsafeEnabled { + file_interface_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Interface); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_interface_proto_rawDesc, + NumEnums: 1, + NumMessages: 1, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_interface_proto_goTypes, + DependencyIndexes: file_interface_proto_depIdxs, + EnumInfos: file_interface_proto_enumTypes, + MessageInfos: file_interface_proto_msgTypes, + }.Build() + File_interface_proto = out.File + file_interface_proto_rawDesc = nil + file_interface_proto_goTypes = nil + file_interface_proto_depIdxs = nil +} diff --git a/pkg/pb/interface.proto b/pkg/pb/interface.proto new file mode 100644 index 00000000..cc1b7431 --- /dev/null +++ b/pkg/pb/interface.proto @@ -0,0 +1,27 @@ +syntax = "proto3"; + +option go_package = "riasc.eu/wice/pkg/pb"; + +import "peer.proto"; + +message Interface { + enum Type { + UNKNOWN = 0; + LINUX_KERNEL = 1; + OPENBSD_KERNEL = 2; + WINDOWS_KERNEL = 3; + USERSPACE = 4; + } + + string name = 1; + Type type = 2; + + bytes private_key = 3; + bytes public_key = 4; + + uint32 listen_port = 5; + + uint32 firewall_mark = 6; + + repeated Peer peers = 7; +} diff --git a/pkg/pb/offer.go b/pkg/pb/offer.go new file mode 100644 index 00000000..ac1e5e31 --- /dev/null +++ b/pkg/pb/offer.go @@ -0,0 +1,5 @@ +package pb + +const ( + OfferVersion = 1 +) diff --git a/pkg/pb/offer.pb.go b/pkg/pb/offer.pb.go index 3a620def..9fb05313 100644 --- a/pkg/pb/offer.pb.go +++ b/pkg/pb/offer.pb.go @@ -63,7 +63,7 @@ func (x Offer_Role) Number() protoreflect.EnumNumber { // Deprecated: Use Offer_Role.Descriptor instead. func (Offer_Role) EnumDescriptor() ([]byte, []int) { - return file_offer_proto_rawDescGZIP(), []int{1, 0} + return file_offer_proto_rawDescGZIP(), []int{0, 0} } type Offer_Implementation int32 @@ -109,82 +109,78 @@ func (x Offer_Implementation) Number() protoreflect.EnumNumber { // Deprecated: Use Offer_Implementation.Descriptor instead. func (Offer_Implementation) EnumDescriptor() ([]byte, []int) { - return file_offer_proto_rawDescGZIP(), []int{1, 1} + return file_offer_proto_rawDescGZIP(), []int{0, 1} } -type SignedOffer struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields +type Offer_Type int32 - Offer []byte `protobuf:"bytes,1,opt,name=offer,proto3" json:"offer,omitempty"` - Sigature []byte `protobuf:"bytes,2,opt,name=sigature,proto3" json:"sigature,omitempty"` -} +const ( + Offer_OFFER Offer_Type = 0 + Offer_ANSWER Offer_Type = 1 +) -func (x *SignedOffer) Reset() { - *x = SignedOffer{} - if protoimpl.UnsafeEnabled { - mi := &file_offer_proto_msgTypes[0] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) +// Enum value maps for Offer_Type. +var ( + Offer_Type_name = map[int32]string{ + 0: "OFFER", + 1: "ANSWER", } -} - -func (x *SignedOffer) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*SignedOffer) ProtoMessage() {} - -func (x *SignedOffer) ProtoReflect() protoreflect.Message { - mi := &file_offer_proto_msgTypes[0] - if protoimpl.UnsafeEnabled && x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms + Offer_Type_value = map[string]int32{ + "OFFER": 0, + "ANSWER": 1, } - return mi.MessageOf(x) +) + +func (x Offer_Type) Enum() *Offer_Type { + p := new(Offer_Type) + *p = x + return p } -// Deprecated: Use SignedOffer.ProtoReflect.Descriptor instead. -func (*SignedOffer) Descriptor() ([]byte, []int) { - return file_offer_proto_rawDescGZIP(), []int{0} +func (x Offer_Type) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) } -func (x *SignedOffer) GetOffer() []byte { - if x != nil { - return x.Offer - } - return nil +func (Offer_Type) Descriptor() protoreflect.EnumDescriptor { + return file_offer_proto_enumTypes[2].Descriptor() } -func (x *SignedOffer) GetSigature() []byte { - if x != nil { - return x.Sigature - } - return nil +func (Offer_Type) Type() protoreflect.EnumType { + return &file_offer_proto_enumTypes[2] } +func (x Offer_Type) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use Offer_Type.Descriptor instead. +func (Offer_Type) EnumDescriptor() ([]byte, []int) { + return file_offer_proto_rawDescGZIP(), []int{0, 2} +} + +// SDP-like session description +// See: https://www.rfc-editor.org/rfc/rfc8866.html type Offer struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - Version int64 `protobuf:"varint,1,opt,name=version,proto3" json:"version,omitempty"` + // Version of the WICE signalling protocoll (currently always 1) + Version int64 `protobuf:"varint,1,opt,name=version,proto3" json:"version,omitempty"` + // Session epoch, incremented with each offer Epoch int64 `protobuf:"varint,2,opt,name=epoch,proto3" json:"epoch,omitempty"` - Role Offer_Role `protobuf:"varint,3,opt,name=role,proto3,enum=wice.Offer_Role" json:"role,omitempty"` - Implementation Offer_Implementation `protobuf:"varint,4,opt,name=implementation,proto3,enum=wice.Offer_Implementation" json:"implementation,omitempty"` - Candidates []*Candidate `protobuf:"bytes,5,rep,name=candidates,proto3" json:"candidates,omitempty"` + Type Offer_Type `protobuf:"varint,3,opt,name=type,proto3,enum=wice.Offer_Type" json:"type,omitempty"` + Role Offer_Role `protobuf:"varint,4,opt,name=role,proto3,enum=wice.Offer_Role" json:"role,omitempty"` + Implementation Offer_Implementation `protobuf:"varint,5,opt,name=implementation,proto3,enum=wice.Offer_Implementation" json:"implementation,omitempty"` Ufrag string `protobuf:"bytes,6,opt,name=Ufrag,proto3" json:"Ufrag,omitempty"` Pwd string `protobuf:"bytes,7,opt,name=Pwd,proto3" json:"Pwd,omitempty"` + Candidates []*Candidate `protobuf:"bytes,8,rep,name=candidates,proto3" json:"candidates,omitempty"` } func (x *Offer) Reset() { *x = Offer{} if protoimpl.UnsafeEnabled { - mi := &file_offer_proto_msgTypes[1] + mi := &file_offer_proto_msgTypes[0] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -197,7 +193,7 @@ func (x *Offer) String() string { func (*Offer) ProtoMessage() {} func (x *Offer) ProtoReflect() protoreflect.Message { - mi := &file_offer_proto_msgTypes[1] + mi := &file_offer_proto_msgTypes[0] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -210,7 +206,7 @@ func (x *Offer) ProtoReflect() protoreflect.Message { // Deprecated: Use Offer.ProtoReflect.Descriptor instead. func (*Offer) Descriptor() ([]byte, []int) { - return file_offer_proto_rawDescGZIP(), []int{1} + return file_offer_proto_rawDescGZIP(), []int{0} } func (x *Offer) GetVersion() int64 { @@ -227,6 +223,13 @@ func (x *Offer) GetEpoch() int64 { return 0 } +func (x *Offer) GetType() Offer_Type { + if x != nil { + return x.Type + } + return Offer_OFFER +} + func (x *Offer) GetRole() Offer_Role { if x != nil { return x.Role @@ -241,13 +244,6 @@ func (x *Offer) GetImplementation() Offer_Implementation { return Offer_FULL } -func (x *Offer) GetCandidates() []*Candidate { - if x != nil { - return x.Candidates - } - return nil -} - func (x *Offer) GetUfrag() string { if x != nil { return x.Ufrag @@ -262,76 +258,45 @@ func (x *Offer) GetPwd() string { return "" } -type Candidate struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields -} - -func (x *Candidate) Reset() { - *x = Candidate{} - if protoimpl.UnsafeEnabled { - mi := &file_offer_proto_msgTypes[2] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) +func (x *Offer) GetCandidates() []*Candidate { + if x != nil { + return x.Candidates } -} - -func (x *Candidate) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*Candidate) ProtoMessage() {} - -func (x *Candidate) ProtoReflect() protoreflect.Message { - mi := &file_offer_proto_msgTypes[2] - if protoimpl.UnsafeEnabled && x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use Candidate.ProtoReflect.Descriptor instead. -func (*Candidate) Descriptor() ([]byte, []int) { - return file_offer_proto_rawDescGZIP(), []int{2} + return nil } var File_offer_proto protoreflect.FileDescriptor var file_offer_proto_rawDesc = []byte{ 0x0a, 0x0b, 0x6f, 0x66, 0x66, 0x65, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x04, 0x77, - 0x69, 0x63, 0x65, 0x22, 0x3f, 0x0a, 0x0b, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x4f, 0x66, 0x66, - 0x65, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x6f, 0x66, 0x66, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x0c, 0x52, 0x05, 0x6f, 0x66, 0x66, 0x65, 0x72, 0x12, 0x1a, 0x0a, 0x08, 0x73, 0x69, 0x67, 0x61, - 0x74, 0x75, 0x72, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, 0x73, 0x69, 0x67, 0x61, - 0x74, 0x75, 0x72, 0x65, 0x22, 0xc9, 0x02, 0x0a, 0x05, 0x4f, 0x66, 0x66, 0x65, 0x72, 0x12, 0x18, + 0x69, 0x63, 0x65, 0x1a, 0x0f, 0x63, 0x61, 0x6e, 0x64, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x89, 0x03, 0x0a, 0x05, 0x4f, 0x66, 0x66, 0x65, 0x72, 0x12, 0x18, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x14, 0x0a, 0x05, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x12, 0x24, - 0x0a, 0x04, 0x72, 0x6f, 0x6c, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x10, 0x2e, 0x77, - 0x69, 0x63, 0x65, 0x2e, 0x4f, 0x66, 0x66, 0x65, 0x72, 0x2e, 0x52, 0x6f, 0x6c, 0x65, 0x52, 0x04, - 0x72, 0x6f, 0x6c, 0x65, 0x12, 0x42, 0x0a, 0x0e, 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x6d, 0x65, 0x6e, - 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1a, 0x2e, 0x77, - 0x69, 0x63, 0x65, 0x2e, 0x4f, 0x66, 0x66, 0x65, 0x72, 0x2e, 0x49, 0x6d, 0x70, 0x6c, 0x65, 0x6d, - 0x65, 0x6e, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0e, 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x6d, - 0x65, 0x6e, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x2f, 0x0a, 0x0a, 0x63, 0x61, 0x6e, 0x64, - 0x69, 0x64, 0x61, 0x74, 0x65, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x77, - 0x69, 0x63, 0x65, 0x2e, 0x43, 0x61, 0x6e, 0x64, 0x69, 0x64, 0x61, 0x74, 0x65, 0x52, 0x0a, 0x63, - 0x61, 0x6e, 0x64, 0x69, 0x64, 0x61, 0x74, 0x65, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x55, 0x66, 0x72, - 0x61, 0x67, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x55, 0x66, 0x72, 0x61, 0x67, 0x12, - 0x10, 0x0a, 0x03, 0x50, 0x77, 0x64, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x50, 0x77, - 0x64, 0x22, 0x27, 0x0a, 0x04, 0x52, 0x6f, 0x6c, 0x65, 0x12, 0x0e, 0x0a, 0x0a, 0x43, 0x4f, 0x4e, - 0x54, 0x52, 0x4f, 0x4c, 0x4c, 0x45, 0x44, 0x10, 0x00, 0x12, 0x0f, 0x0a, 0x0b, 0x43, 0x4f, 0x4e, - 0x54, 0x52, 0x4f, 0x4c, 0x4c, 0x49, 0x4e, 0x47, 0x10, 0x01, 0x22, 0x24, 0x0a, 0x0e, 0x49, 0x6d, - 0x70, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x08, 0x0a, 0x04, - 0x46, 0x55, 0x4c, 0x4c, 0x10, 0x00, 0x12, 0x08, 0x0a, 0x04, 0x4c, 0x49, 0x54, 0x45, 0x10, 0x01, - 0x22, 0x0b, 0x0a, 0x09, 0x43, 0x61, 0x6e, 0x64, 0x69, 0x64, 0x61, 0x74, 0x65, 0x42, 0x16, 0x5a, - 0x14, 0x72, 0x69, 0x61, 0x73, 0x63, 0x2e, 0x65, 0x75, 0x2f, 0x77, 0x69, 0x63, 0x65, 0x2f, 0x70, - 0x6b, 0x67, 0x2f, 0x70, 0x62, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, + 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x10, 0x2e, 0x77, + 0x69, 0x63, 0x65, 0x2e, 0x4f, 0x66, 0x66, 0x65, 0x72, 0x2e, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, + 0x74, 0x79, 0x70, 0x65, 0x12, 0x24, 0x0a, 0x04, 0x72, 0x6f, 0x6c, 0x65, 0x18, 0x04, 0x20, 0x01, + 0x28, 0x0e, 0x32, 0x10, 0x2e, 0x77, 0x69, 0x63, 0x65, 0x2e, 0x4f, 0x66, 0x66, 0x65, 0x72, 0x2e, + 0x52, 0x6f, 0x6c, 0x65, 0x52, 0x04, 0x72, 0x6f, 0x6c, 0x65, 0x12, 0x42, 0x0a, 0x0e, 0x69, 0x6d, + 0x70, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x05, 0x20, 0x01, + 0x28, 0x0e, 0x32, 0x1a, 0x2e, 0x77, 0x69, 0x63, 0x65, 0x2e, 0x4f, 0x66, 0x66, 0x65, 0x72, 0x2e, + 0x49, 0x6d, 0x70, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0e, + 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x14, + 0x0a, 0x05, 0x55, 0x66, 0x72, 0x61, 0x67, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x55, + 0x66, 0x72, 0x61, 0x67, 0x12, 0x10, 0x0a, 0x03, 0x50, 0x77, 0x64, 0x18, 0x07, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x03, 0x50, 0x77, 0x64, 0x12, 0x2a, 0x0a, 0x0a, 0x63, 0x61, 0x6e, 0x64, 0x69, 0x64, + 0x61, 0x74, 0x65, 0x73, 0x18, 0x08, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0a, 0x2e, 0x43, 0x61, 0x6e, + 0x64, 0x69, 0x64, 0x61, 0x74, 0x65, 0x52, 0x0a, 0x63, 0x61, 0x6e, 0x64, 0x69, 0x64, 0x61, 0x74, + 0x65, 0x73, 0x22, 0x27, 0x0a, 0x04, 0x52, 0x6f, 0x6c, 0x65, 0x12, 0x0e, 0x0a, 0x0a, 0x43, 0x4f, + 0x4e, 0x54, 0x52, 0x4f, 0x4c, 0x4c, 0x45, 0x44, 0x10, 0x00, 0x12, 0x0f, 0x0a, 0x0b, 0x43, 0x4f, + 0x4e, 0x54, 0x52, 0x4f, 0x4c, 0x4c, 0x49, 0x4e, 0x47, 0x10, 0x01, 0x22, 0x24, 0x0a, 0x0e, 0x49, + 0x6d, 0x70, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x08, 0x0a, + 0x04, 0x46, 0x55, 0x4c, 0x4c, 0x10, 0x00, 0x12, 0x08, 0x0a, 0x04, 0x4c, 0x49, 0x54, 0x45, 0x10, + 0x01, 0x22, 0x1d, 0x0a, 0x04, 0x54, 0x79, 0x70, 0x65, 0x12, 0x09, 0x0a, 0x05, 0x4f, 0x46, 0x46, + 0x45, 0x52, 0x10, 0x00, 0x12, 0x0a, 0x0a, 0x06, 0x41, 0x4e, 0x53, 0x57, 0x45, 0x52, 0x10, 0x01, + 0x42, 0x16, 0x5a, 0x14, 0x72, 0x69, 0x61, 0x73, 0x63, 0x2e, 0x65, 0x75, 0x2f, 0x77, 0x69, 0x63, + 0x65, 0x2f, 0x70, 0x6b, 0x67, 0x2f, 0x70, 0x62, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, } var ( @@ -346,24 +311,25 @@ func file_offer_proto_rawDescGZIP() []byte { return file_offer_proto_rawDescData } -var file_offer_proto_enumTypes = make([]protoimpl.EnumInfo, 2) -var file_offer_proto_msgTypes = make([]protoimpl.MessageInfo, 3) +var file_offer_proto_enumTypes = make([]protoimpl.EnumInfo, 3) +var file_offer_proto_msgTypes = make([]protoimpl.MessageInfo, 1) var file_offer_proto_goTypes = []interface{}{ (Offer_Role)(0), // 0: wice.Offer.Role (Offer_Implementation)(0), // 1: wice.Offer.Implementation - (*SignedOffer)(nil), // 2: wice.SignedOffer + (Offer_Type)(0), // 2: wice.Offer.Type (*Offer)(nil), // 3: wice.Offer - (*Candidate)(nil), // 4: wice.Candidate + (*Candidate)(nil), // 4: Candidate } var file_offer_proto_depIdxs = []int32{ - 0, // 0: wice.Offer.role:type_name -> wice.Offer.Role - 1, // 1: wice.Offer.implementation:type_name -> wice.Offer.Implementation - 4, // 2: wice.Offer.candidates:type_name -> wice.Candidate - 3, // [3:3] is the sub-list for method output_type - 3, // [3:3] is the sub-list for method input_type - 3, // [3:3] is the sub-list for extension type_name - 3, // [3:3] is the sub-list for extension extendee - 0, // [0:3] is the sub-list for field type_name + 2, // 0: wice.Offer.type:type_name -> wice.Offer.Type + 0, // 1: wice.Offer.role:type_name -> wice.Offer.Role + 1, // 2: wice.Offer.implementation:type_name -> wice.Offer.Implementation + 4, // 3: wice.Offer.candidates:type_name -> Candidate + 4, // [4:4] is the sub-list for method output_type + 4, // [4:4] is the sub-list for method input_type + 4, // [4:4] is the sub-list for extension type_name + 4, // [4:4] is the sub-list for extension extendee + 0, // [0:4] is the sub-list for field type_name } func init() { file_offer_proto_init() } @@ -371,20 +337,9 @@ func file_offer_proto_init() { if File_offer_proto != nil { return } + file_candidate_proto_init() if !protoimpl.UnsafeEnabled { file_offer_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*SignedOffer); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_offer_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*Offer); i { case 0: return &v.state @@ -396,26 +351,14 @@ func file_offer_proto_init() { return nil } } - file_offer_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*Candidate); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } } type x struct{} out := protoimpl.TypeBuilder{ File: protoimpl.DescBuilder{ GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: file_offer_proto_rawDesc, - NumEnums: 2, - NumMessages: 3, + NumEnums: 3, + NumMessages: 1, NumExtensions: 0, NumServices: 0, }, diff --git a/pkg/pb/offer.proto b/pkg/pb/offer.proto index c9a18dd5..02ea22f7 100644 --- a/pkg/pb/offer.proto +++ b/pkg/pb/offer.proto @@ -3,11 +3,10 @@ package wice; option go_package = "riasc.eu/wice/pkg/pb"; -message SignedOffer { - bytes offer = 1; - bytes sigature = 2; -} +import "candidate.proto"; +// SDP-like session description +// See: https://www.rfc-editor.org/rfc/rfc8866.html message Offer { enum Role { CONTROLLED = 0; @@ -19,26 +18,23 @@ message Offer { LITE = 1; } - int64 version = 1; - int64 epoch = 2; - Role role = 3; - Implementation implementation = 4; + enum Type { + OFFER = 0; + ANSWER = 1; + } - repeated Candidate candidates = 5; + // Version of the WICE signalling protocoll (currently always 1) + int64 version = 1; + + // Session epoch, incremented with each offer + int64 epoch = 2; + + Type type = 3; + Role role = 4; + Implementation implementation = 5; string Ufrag = 6; string Pwd = 7; -} -message Candidate { - // Type string `json:"type"` - // Foundation string `json:"foundation"` - // Component int `json:"component"` - // NetworkType string `json:"network"` - // Priority int `json:"priority"` - // Address string `json:"address"` - // Port int `json:"port"` - // TCPType *string `json:"tcp_type,omitempty"` - // RelAddr *string `json:"related_address,omitempty"` - // RelPort *int `json:"related_port,omitempty"` -} \ No newline at end of file + repeated Candidate candidates = 8; +} diff --git a/pkg/pb/peer.go b/pkg/pb/peer.go new file mode 100644 index 00000000..f04cb5b2 --- /dev/null +++ b/pkg/pb/peer.go @@ -0,0 +1,9 @@ +package pb + +import ( + "riasc.eu/wice/pkg/crypto" +) + +func (p *Peer) Key() crypto.Key { + return *(*crypto.Key)(p.PublicKey) +} diff --git a/pkg/pb/peer.pb.go b/pkg/pb/peer.pb.go new file mode 100644 index 00000000..efe0aef0 --- /dev/null +++ b/pkg/pb/peer.pb.go @@ -0,0 +1,316 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.27.1 +// protoc v3.14.0 +// source: peer.proto + +package pb + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +type PeerDescriptor struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + PublicKey []byte `protobuf:"bytes,1,opt,name=public_key,json=publicKey,proto3" json:"public_key,omitempty"` + Hostname string `protobuf:"bytes,2,opt,name=hostname,proto3" json:"hostname,omitempty"` + AllowedIps []string `protobuf:"bytes,3,rep,name=allowed_ips,json=allowedIps,proto3" json:"allowed_ips,omitempty"` +} + +func (x *PeerDescriptor) Reset() { + *x = PeerDescriptor{} + if protoimpl.UnsafeEnabled { + mi := &file_peer_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *PeerDescriptor) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PeerDescriptor) ProtoMessage() {} + +func (x *PeerDescriptor) ProtoReflect() protoreflect.Message { + mi := &file_peer_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use PeerDescriptor.ProtoReflect.Descriptor instead. +func (*PeerDescriptor) Descriptor() ([]byte, []int) { + return file_peer_proto_rawDescGZIP(), []int{0} +} + +func (x *PeerDescriptor) GetPublicKey() []byte { + if x != nil { + return x.PublicKey + } + return nil +} + +func (x *PeerDescriptor) GetHostname() string { + if x != nil { + return x.Hostname + } + return "" +} + +func (x *PeerDescriptor) GetAllowedIps() []string { + if x != nil { + return x.AllowedIps + } + return nil +} + +type Peer struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + PublicKey []byte `protobuf:"bytes,1,opt,name=public_key,json=publicKey,proto3" json:"public_key,omitempty"` + Endpoint []string `protobuf:"bytes,2,rep,name=Endpoint,proto3" json:"Endpoint,omitempty"` + PersistentKeepaliveInterval uint32 `protobuf:"varint,3,opt,name=persistent_keepalive_interval,json=persistentKeepaliveInterval,proto3" json:"persistent_keepalive_interval,omitempty"` + LastHandshake *Timestamp `protobuf:"bytes,4,opt,name=last_handshake,json=lastHandshake,proto3" json:"last_handshake,omitempty"` + TransmitBytes int64 `protobuf:"varint,5,opt,name=transmit_bytes,json=transmitBytes,proto3" json:"transmit_bytes,omitempty"` + ReceiveBytes int64 `protobuf:"varint,6,opt,name=receive_bytes,json=receiveBytes,proto3" json:"receive_bytes,omitempty"` + AllowedIps []string `protobuf:"bytes,7,rep,name=allowed_ips,json=allowedIps,proto3" json:"allowed_ips,omitempty"` + ProtocolVersion uint32 `protobuf:"varint,8,opt,name=protocol_version,json=protocolVersion,proto3" json:"protocol_version,omitempty"` + State ConnectionState `protobuf:"varint,9,opt,name=state,proto3,enum=ConnectionState" json:"state,omitempty"` +} + +func (x *Peer) Reset() { + *x = Peer{} + if protoimpl.UnsafeEnabled { + mi := &file_peer_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Peer) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Peer) ProtoMessage() {} + +func (x *Peer) ProtoReflect() protoreflect.Message { + mi := &file_peer_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Peer.ProtoReflect.Descriptor instead. +func (*Peer) Descriptor() ([]byte, []int) { + return file_peer_proto_rawDescGZIP(), []int{1} +} + +func (x *Peer) GetPublicKey() []byte { + if x != nil { + return x.PublicKey + } + return nil +} + +func (x *Peer) GetEndpoint() []string { + if x != nil { + return x.Endpoint + } + return nil +} + +func (x *Peer) GetPersistentKeepaliveInterval() uint32 { + if x != nil { + return x.PersistentKeepaliveInterval + } + return 0 +} + +func (x *Peer) GetLastHandshake() *Timestamp { + if x != nil { + return x.LastHandshake + } + return nil +} + +func (x *Peer) GetTransmitBytes() int64 { + if x != nil { + return x.TransmitBytes + } + return 0 +} + +func (x *Peer) GetReceiveBytes() int64 { + if x != nil { + return x.ReceiveBytes + } + return 0 +} + +func (x *Peer) GetAllowedIps() []string { + if x != nil { + return x.AllowedIps + } + return nil +} + +func (x *Peer) GetProtocolVersion() uint32 { + if x != nil { + return x.ProtocolVersion + } + return 0 +} + +func (x *Peer) GetState() ConnectionState { + if x != nil { + return x.State + } + return ConnectionState_NEW +} + +var File_peer_proto protoreflect.FileDescriptor + +var file_peer_proto_rawDesc = []byte{ + 0x0a, 0x0a, 0x70, 0x65, 0x65, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x0c, 0x63, 0x6f, + 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x6c, 0x0a, 0x0e, 0x50, 0x65, + 0x65, 0x72, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x12, 0x1d, 0x0a, 0x0a, + 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, + 0x52, 0x09, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x12, 0x1a, 0x0a, 0x08, 0x68, + 0x6f, 0x73, 0x74, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x68, + 0x6f, 0x73, 0x74, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x61, 0x6c, 0x6c, 0x6f, 0x77, + 0x65, 0x64, 0x5f, 0x69, 0x70, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x61, 0x6c, + 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x49, 0x70, 0x73, 0x22, 0xf8, 0x02, 0x0a, 0x04, 0x50, 0x65, 0x65, + 0x72, 0x12, 0x1d, 0x0a, 0x0a, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, + 0x12, 0x1a, 0x0a, 0x08, 0x45, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x03, + 0x28, 0x09, 0x52, 0x08, 0x45, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x42, 0x0a, 0x1d, + 0x70, 0x65, 0x72, 0x73, 0x69, 0x73, 0x74, 0x65, 0x6e, 0x74, 0x5f, 0x6b, 0x65, 0x65, 0x70, 0x61, + 0x6c, 0x69, 0x76, 0x65, 0x5f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x0d, 0x52, 0x1b, 0x70, 0x65, 0x72, 0x73, 0x69, 0x73, 0x74, 0x65, 0x6e, 0x74, 0x4b, + 0x65, 0x65, 0x70, 0x61, 0x6c, 0x69, 0x76, 0x65, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, + 0x12, 0x31, 0x0a, 0x0e, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x68, 0x61, 0x6e, 0x64, 0x73, 0x68, 0x61, + 0x6b, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0a, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, + 0x74, 0x61, 0x6d, 0x70, 0x52, 0x0d, 0x6c, 0x61, 0x73, 0x74, 0x48, 0x61, 0x6e, 0x64, 0x73, 0x68, + 0x61, 0x6b, 0x65, 0x12, 0x25, 0x0a, 0x0e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x6d, 0x69, 0x74, 0x5f, + 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0d, 0x74, 0x72, 0x61, + 0x6e, 0x73, 0x6d, 0x69, 0x74, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x23, 0x0a, 0x0d, 0x72, 0x65, + 0x63, 0x65, 0x69, 0x76, 0x65, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, + 0x03, 0x52, 0x0c, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, + 0x1f, 0x0a, 0x0b, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x5f, 0x69, 0x70, 0x73, 0x18, 0x07, + 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x49, 0x70, 0x73, + 0x12, 0x29, 0x0a, 0x10, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x5f, 0x76, 0x65, 0x72, + 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0f, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x63, 0x6f, 0x6c, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x26, 0x0a, 0x05, 0x73, + 0x74, 0x61, 0x74, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x10, 0x2e, 0x43, 0x6f, 0x6e, + 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x05, 0x73, 0x74, + 0x61, 0x74, 0x65, 0x42, 0x16, 0x5a, 0x14, 0x72, 0x69, 0x61, 0x73, 0x63, 0x2e, 0x65, 0x75, 0x2f, + 0x77, 0x69, 0x63, 0x65, 0x2f, 0x70, 0x6b, 0x67, 0x2f, 0x70, 0x62, 0x62, 0x06, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x33, +} + +var ( + file_peer_proto_rawDescOnce sync.Once + file_peer_proto_rawDescData = file_peer_proto_rawDesc +) + +func file_peer_proto_rawDescGZIP() []byte { + file_peer_proto_rawDescOnce.Do(func() { + file_peer_proto_rawDescData = protoimpl.X.CompressGZIP(file_peer_proto_rawDescData) + }) + return file_peer_proto_rawDescData +} + +var file_peer_proto_msgTypes = make([]protoimpl.MessageInfo, 2) +var file_peer_proto_goTypes = []interface{}{ + (*PeerDescriptor)(nil), // 0: PeerDescriptor + (*Peer)(nil), // 1: Peer + (*Timestamp)(nil), // 2: Timestamp + (ConnectionState)(0), // 3: ConnectionState +} +var file_peer_proto_depIdxs = []int32{ + 2, // 0: Peer.last_handshake:type_name -> Timestamp + 3, // 1: Peer.state:type_name -> ConnectionState + 2, // [2:2] is the sub-list for method output_type + 2, // [2:2] is the sub-list for method input_type + 2, // [2:2] is the sub-list for extension type_name + 2, // [2:2] is the sub-list for extension extendee + 0, // [0:2] is the sub-list for field type_name +} + +func init() { file_peer_proto_init() } +func file_peer_proto_init() { + if File_peer_proto != nil { + return + } + file_common_proto_init() + if !protoimpl.UnsafeEnabled { + file_peer_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*PeerDescriptor); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_peer_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Peer); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_peer_proto_rawDesc, + NumEnums: 0, + NumMessages: 2, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_peer_proto_goTypes, + DependencyIndexes: file_peer_proto_depIdxs, + MessageInfos: file_peer_proto_msgTypes, + }.Build() + File_peer_proto = out.File + file_peer_proto_rawDesc = nil + file_peer_proto_goTypes = nil + file_peer_proto_depIdxs = nil +} diff --git a/pkg/pb/peer.proto b/pkg/pb/peer.proto new file mode 100644 index 00000000..11eea02e --- /dev/null +++ b/pkg/pb/peer.proto @@ -0,0 +1,26 @@ +syntax = "proto3"; + +option go_package = "riasc.eu/wice/pkg/pb"; + +import "common.proto"; + +message PeerDescriptor { + bytes public_key = 1; + string hostname = 2; + repeated string allowed_ips = 3; +} + +message Peer { + bytes public_key = 1; + + repeated string Endpoint = 2; + + uint32 persistent_keepalive_interval = 3; + Timestamp last_handshake = 4; + int64 transmit_bytes = 5; + int64 receive_bytes = 6; + repeated string allowed_ips = 7; + uint32 protocol_version = 8; + + ConnectionState state = 9; +} \ No newline at end of file diff --git a/pkg/pb/socket.pb.go b/pkg/pb/socket.pb.go index c469880d..24933e23 100644 --- a/pkg/pb/socket.pb.go +++ b/pkg/pb/socket.pb.go @@ -10,6 +10,7 @@ import ( protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" reflect "reflect" + sync "sync" ) const ( @@ -19,40 +20,326 @@ const ( _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) ) +type Status struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Interfaces []*Interface `protobuf:"bytes,1,rep,name=interfaces,proto3" json:"interfaces,omitempty"` +} + +func (x *Status) Reset() { + *x = Status{} + if protoimpl.UnsafeEnabled { + mi := &file_socket_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Status) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Status) ProtoMessage() {} + +func (x *Status) ProtoReflect() protoreflect.Message { + mi := &file_socket_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Status.ProtoReflect.Descriptor instead. +func (*Status) Descriptor() ([]byte, []int) { + return file_socket_proto_rawDescGZIP(), []int{0} +} + +func (x *Status) GetInterfaces() []*Interface { + if x != nil { + return x.Interfaces + } + return nil +} + +type UnWaitParams struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *UnWaitParams) Reset() { + *x = UnWaitParams{} + if protoimpl.UnsafeEnabled { + mi := &file_socket_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *UnWaitParams) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*UnWaitParams) ProtoMessage() {} + +func (x *UnWaitParams) ProtoReflect() protoreflect.Message { + mi := &file_socket_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use UnWaitParams.ProtoReflect.Descriptor instead. +func (*UnWaitParams) Descriptor() ([]byte, []int) { + return file_socket_proto_rawDescGZIP(), []int{1} +} + +type SyncConfigParams struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *SyncConfigParams) Reset() { + *x = SyncConfigParams{} + if protoimpl.UnsafeEnabled { + mi := &file_socket_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SyncConfigParams) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SyncConfigParams) ProtoMessage() {} + +func (x *SyncConfigParams) ProtoReflect() protoreflect.Message { + mi := &file_socket_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SyncConfigParams.ProtoReflect.Descriptor instead. +func (*SyncConfigParams) Descriptor() ([]byte, []int) { + return file_socket_proto_rawDescGZIP(), []int{2} +} + +type SyncInterfaceParams struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *SyncInterfaceParams) Reset() { + *x = SyncInterfaceParams{} + if protoimpl.UnsafeEnabled { + mi := &file_socket_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SyncInterfaceParams) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SyncInterfaceParams) ProtoMessage() {} + +func (x *SyncInterfaceParams) ProtoReflect() protoreflect.Message { + mi := &file_socket_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SyncInterfaceParams.ProtoReflect.Descriptor instead. +func (*SyncInterfaceParams) Descriptor() ([]byte, []int) { + return file_socket_proto_rawDescGZIP(), []int{3} +} + +type ShutdownParams struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *ShutdownParams) Reset() { + *x = ShutdownParams{} + if protoimpl.UnsafeEnabled { + mi := &file_socket_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ShutdownParams) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ShutdownParams) ProtoMessage() {} + +func (x *ShutdownParams) ProtoReflect() protoreflect.Message { + mi := &file_socket_proto_msgTypes[4] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ShutdownParams.ProtoReflect.Descriptor instead. +func (*ShutdownParams) Descriptor() ([]byte, []int) { + return file_socket_proto_rawDescGZIP(), []int{4} +} + +type StreamEventsParams struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *StreamEventsParams) Reset() { + *x = StreamEventsParams{} + if protoimpl.UnsafeEnabled { + mi := &file_socket_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *StreamEventsParams) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*StreamEventsParams) ProtoMessage() {} + +func (x *StreamEventsParams) ProtoReflect() protoreflect.Message { + mi := &file_socket_proto_msgTypes[5] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use StreamEventsParams.ProtoReflect.Descriptor instead. +func (*StreamEventsParams) Descriptor() ([]byte, []int) { + return file_socket_proto_rawDescGZIP(), []int{5} +} + var File_socket_proto protoreflect.FileDescriptor var file_socket_proto_rawDesc = []byte{ 0x0a, 0x0c, 0x73, 0x6f, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x04, 0x77, 0x69, 0x63, 0x65, 0x1a, 0x0c, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, - 0x74, 0x6f, 0x1a, 0x0b, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, - 0x5f, 0x0a, 0x06, 0x53, 0x6f, 0x63, 0x6b, 0x65, 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x47, 0x65, 0x74, - 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x05, 0x2e, 0x56, 0x6f, 0x69, 0x64, 0x1a, 0x07, 0x2e, - 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x17, 0x0a, 0x06, 0x55, 0x6e, 0x57, 0x61, 0x69, 0x74, - 0x12, 0x05, 0x2e, 0x56, 0x6f, 0x69, 0x64, 0x1a, 0x06, 0x2e, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x12, - 0x1f, 0x0a, 0x0c, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x12, - 0x05, 0x2e, 0x56, 0x6f, 0x69, 0x64, 0x1a, 0x06, 0x2e, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x30, 0x01, - 0x42, 0x16, 0x5a, 0x14, 0x72, 0x69, 0x61, 0x73, 0x63, 0x2e, 0x65, 0x75, 0x2f, 0x77, 0x69, 0x63, - 0x65, 0x2f, 0x70, 0x6b, 0x67, 0x2f, 0x70, 0x62, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, + 0x74, 0x6f, 0x1a, 0x0b, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, + 0x0f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x22, 0x34, 0x0a, 0x06, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x2a, 0x0a, 0x0a, 0x69, 0x6e, + 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0a, + 0x2e, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x52, 0x0a, 0x69, 0x6e, 0x74, 0x65, + 0x72, 0x66, 0x61, 0x63, 0x65, 0x73, 0x22, 0x0e, 0x0a, 0x0c, 0x55, 0x6e, 0x57, 0x61, 0x69, 0x74, + 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x12, 0x0a, 0x10, 0x53, 0x79, 0x6e, 0x63, 0x43, 0x6f, + 0x6e, 0x66, 0x69, 0x67, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x15, 0x0a, 0x13, 0x53, 0x79, + 0x6e, 0x63, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, + 0x73, 0x22, 0x10, 0x0a, 0x0e, 0x53, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, 0x50, 0x61, 0x72, + 0x61, 0x6d, 0x73, 0x22, 0x14, 0x0a, 0x12, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x45, 0x76, 0x65, + 0x6e, 0x74, 0x73, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x32, 0x9d, 0x02, 0x0a, 0x06, 0x53, 0x6f, + 0x63, 0x6b, 0x65, 0x74, 0x12, 0x22, 0x0a, 0x09, 0x47, 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x75, + 0x73, 0x12, 0x05, 0x2e, 0x56, 0x6f, 0x69, 0x64, 0x1a, 0x0c, 0x2e, 0x77, 0x69, 0x63, 0x65, 0x2e, + 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x34, 0x0a, 0x0c, 0x53, 0x74, 0x72, 0x65, + 0x61, 0x6d, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x18, 0x2e, 0x77, 0x69, 0x63, 0x65, 0x2e, + 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x50, 0x61, 0x72, 0x61, + 0x6d, 0x73, 0x1a, 0x06, 0x2e, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x22, 0x00, 0x30, 0x01, 0x12, 0x26, + 0x0a, 0x06, 0x55, 0x6e, 0x57, 0x61, 0x69, 0x74, 0x12, 0x12, 0x2e, 0x77, 0x69, 0x63, 0x65, 0x2e, + 0x55, 0x6e, 0x57, 0x61, 0x69, 0x74, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x1a, 0x06, 0x2e, 0x45, + 0x72, 0x72, 0x6f, 0x72, 0x22, 0x00, 0x12, 0x2a, 0x0a, 0x08, 0x53, 0x68, 0x75, 0x74, 0x64, 0x6f, + 0x77, 0x6e, 0x12, 0x14, 0x2e, 0x77, 0x69, 0x63, 0x65, 0x2e, 0x53, 0x68, 0x75, 0x74, 0x64, 0x6f, + 0x77, 0x6e, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x1a, 0x06, 0x2e, 0x45, 0x72, 0x72, 0x6f, 0x72, + 0x22, 0x00, 0x12, 0x2e, 0x0a, 0x0a, 0x53, 0x79, 0x6e, 0x63, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, + 0x12, 0x16, 0x2e, 0x77, 0x69, 0x63, 0x65, 0x2e, 0x53, 0x79, 0x6e, 0x63, 0x43, 0x6f, 0x6e, 0x66, + 0x69, 0x67, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x1a, 0x06, 0x2e, 0x45, 0x72, 0x72, 0x6f, 0x72, + 0x22, 0x00, 0x12, 0x35, 0x0a, 0x0e, 0x53, 0x79, 0x6e, 0x63, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x66, + 0x61, 0x63, 0x65, 0x73, 0x12, 0x19, 0x2e, 0x77, 0x69, 0x63, 0x65, 0x2e, 0x53, 0x79, 0x6e, 0x63, + 0x49, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x1a, + 0x06, 0x2e, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x00, 0x42, 0x16, 0x5a, 0x14, 0x72, 0x69, 0x61, + 0x73, 0x63, 0x2e, 0x65, 0x75, 0x2f, 0x77, 0x69, 0x63, 0x65, 0x2f, 0x70, 0x6b, 0x67, 0x2f, 0x70, + 0x62, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, } +var ( + file_socket_proto_rawDescOnce sync.Once + file_socket_proto_rawDescData = file_socket_proto_rawDesc +) + +func file_socket_proto_rawDescGZIP() []byte { + file_socket_proto_rawDescOnce.Do(func() { + file_socket_proto_rawDescData = protoimpl.X.CompressGZIP(file_socket_proto_rawDescData) + }) + return file_socket_proto_rawDescData +} + +var file_socket_proto_msgTypes = make([]protoimpl.MessageInfo, 6) var file_socket_proto_goTypes = []interface{}{ - (*Void)(nil), // 0: Void - (*Status)(nil), // 1: Status - (*Error)(nil), // 2: Error - (*Event)(nil), // 3: Event + (*Status)(nil), // 0: wice.Status + (*UnWaitParams)(nil), // 1: wice.UnWaitParams + (*SyncConfigParams)(nil), // 2: wice.SyncConfigParams + (*SyncInterfaceParams)(nil), // 3: wice.SyncInterfaceParams + (*ShutdownParams)(nil), // 4: wice.ShutdownParams + (*StreamEventsParams)(nil), // 5: wice.StreamEventsParams + (*Interface)(nil), // 6: Interface + (*Void)(nil), // 7: Void + (*Event)(nil), // 8: Event + (*Error)(nil), // 9: Error } var file_socket_proto_depIdxs = []int32{ - 0, // 0: wice.Socket.GetStatus:input_type -> Void - 0, // 1: wice.Socket.UnWait:input_type -> Void - 0, // 2: wice.Socket.StreamEvents:input_type -> Void - 1, // 3: wice.Socket.GetStatus:output_type -> Status - 2, // 4: wice.Socket.UnWait:output_type -> Error - 3, // 5: wice.Socket.StreamEvents:output_type -> Event - 3, // [3:6] is the sub-list for method output_type - 0, // [0:3] is the sub-list for method input_type - 0, // [0:0] is the sub-list for extension type_name - 0, // [0:0] is the sub-list for extension extendee - 0, // [0:0] is the sub-list for field type_name + 6, // 0: wice.Status.interfaces:type_name -> Interface + 7, // 1: wice.Socket.GetStatus:input_type -> Void + 5, // 2: wice.Socket.StreamEvents:input_type -> wice.StreamEventsParams + 1, // 3: wice.Socket.UnWait:input_type -> wice.UnWaitParams + 4, // 4: wice.Socket.Shutdown:input_type -> wice.ShutdownParams + 2, // 5: wice.Socket.SyncConfig:input_type -> wice.SyncConfigParams + 3, // 6: wice.Socket.SyncInterfaces:input_type -> wice.SyncInterfaceParams + 0, // 7: wice.Socket.GetStatus:output_type -> wice.Status + 8, // 8: wice.Socket.StreamEvents:output_type -> Event + 9, // 9: wice.Socket.UnWait:output_type -> Error + 9, // 10: wice.Socket.Shutdown:output_type -> Error + 9, // 11: wice.Socket.SyncConfig:output_type -> Error + 9, // 12: wice.Socket.SyncInterfaces:output_type -> Error + 7, // [7:13] is the sub-list for method output_type + 1, // [1:7] is the sub-list for method input_type + 1, // [1:1] is the sub-list for extension type_name + 1, // [1:1] is the sub-list for extension extendee + 0, // [0:1] is the sub-list for field type_name } func init() { file_socket_proto_init() } @@ -62,18 +349,94 @@ func file_socket_proto_init() { } file_common_proto_init() file_event_proto_init() + file_interface_proto_init() + if !protoimpl.UnsafeEnabled { + file_socket_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Status); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_socket_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*UnWaitParams); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_socket_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SyncConfigParams); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_socket_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SyncInterfaceParams); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_socket_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ShutdownParams); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_socket_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*StreamEventsParams); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } type x struct{} out := protoimpl.TypeBuilder{ File: protoimpl.DescBuilder{ GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: file_socket_proto_rawDesc, NumEnums: 0, - NumMessages: 0, + NumMessages: 6, NumExtensions: 0, NumServices: 1, }, GoTypes: file_socket_proto_goTypes, DependencyIndexes: file_socket_proto_depIdxs, + MessageInfos: file_socket_proto_msgTypes, }.Build() File_socket_proto = out.File file_socket_proto_rawDesc = nil diff --git a/pkg/pb/socket.proto b/pkg/pb/socket.proto index 99c524f4..f2754d4b 100644 --- a/pkg/pb/socket.proto +++ b/pkg/pb/socket.proto @@ -5,16 +5,30 @@ option go_package = "riasc.eu/wice/pkg/pb"; import "common.proto"; import "event.proto"; +import "interface.proto"; + +message Status { + repeated Interface interfaces = 1; +} + +message UnWaitParams {} +message SyncConfigParams {} +message SyncInterfaceParams {} +message ShutdownParams {} +message StreamEventsParams {} service Socket { - rpc GetStatus(Void) returns (Status); - rpc UnWait(Void) returns (Error); - // rpc Shutdown(Void) returns (Error); - // rpc SyncConfig(Void) returns (Error); - // rpc SyncInterfaces(Void) returns (Error); - // rpc AddInterface(Interface) returns (Error); - // rpc RemoveInterface(Interface) returns (Error); - // rpc AddPeer(Peer) returns (Error); + rpc GetStatus(Void) returns (Status) {} + rpc StreamEvents(StreamEventsParams) returns (stream Event) {} - rpc StreamEvents(Void) returns (stream Event); + rpc UnWait(UnWaitParams) returns (Error) {} + rpc Shutdown(ShutdownParams) returns (Error) {} + + rpc SyncConfig(SyncConfigParams) returns (Error) {} + rpc SyncInterfaces(SyncInterfaceParams) returns (Error) {} + + // rpc AddInterface(Interface) returns (Error) {} + // rpc RemoveInterface(Interface) returns (Error) {} + + // rpc AddPeer(Peer) returns (Error) {} } diff --git a/pkg/pb/socket_grpc.pb.go b/pkg/pb/socket_grpc.pb.go index 8e79f1bf..ef19ff2d 100644 --- a/pkg/pb/socket_grpc.pb.go +++ b/pkg/pb/socket_grpc.pb.go @@ -19,8 +19,11 @@ const _ = grpc.SupportPackageIsVersion7 // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. type SocketClient interface { GetStatus(ctx context.Context, in *Void, opts ...grpc.CallOption) (*Status, error) - UnWait(ctx context.Context, in *Void, opts ...grpc.CallOption) (*Error, error) - StreamEvents(ctx context.Context, in *Void, opts ...grpc.CallOption) (Socket_StreamEventsClient, error) + StreamEvents(ctx context.Context, in *StreamEventsParams, opts ...grpc.CallOption) (Socket_StreamEventsClient, error) + UnWait(ctx context.Context, in *UnWaitParams, opts ...grpc.CallOption) (*Error, error) + Shutdown(ctx context.Context, in *ShutdownParams, opts ...grpc.CallOption) (*Error, error) + SyncConfig(ctx context.Context, in *SyncConfigParams, opts ...grpc.CallOption) (*Error, error) + SyncInterfaces(ctx context.Context, in *SyncInterfaceParams, opts ...grpc.CallOption) (*Error, error) } type socketClient struct { @@ -40,16 +43,7 @@ func (c *socketClient) GetStatus(ctx context.Context, in *Void, opts ...grpc.Cal return out, nil } -func (c *socketClient) UnWait(ctx context.Context, in *Void, opts ...grpc.CallOption) (*Error, error) { - out := new(Error) - err := c.cc.Invoke(ctx, "/wice.Socket/UnWait", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil -} - -func (c *socketClient) StreamEvents(ctx context.Context, in *Void, opts ...grpc.CallOption) (Socket_StreamEventsClient, error) { +func (c *socketClient) StreamEvents(ctx context.Context, in *StreamEventsParams, opts ...grpc.CallOption) (Socket_StreamEventsClient, error) { stream, err := c.cc.NewStream(ctx, &Socket_ServiceDesc.Streams[0], "/wice.Socket/StreamEvents", opts...) if err != nil { return nil, err @@ -81,13 +75,52 @@ func (x *socketStreamEventsClient) Recv() (*Event, error) { return m, nil } +func (c *socketClient) UnWait(ctx context.Context, in *UnWaitParams, opts ...grpc.CallOption) (*Error, error) { + out := new(Error) + err := c.cc.Invoke(ctx, "/wice.Socket/UnWait", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *socketClient) Shutdown(ctx context.Context, in *ShutdownParams, opts ...grpc.CallOption) (*Error, error) { + out := new(Error) + err := c.cc.Invoke(ctx, "/wice.Socket/Shutdown", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *socketClient) SyncConfig(ctx context.Context, in *SyncConfigParams, opts ...grpc.CallOption) (*Error, error) { + out := new(Error) + err := c.cc.Invoke(ctx, "/wice.Socket/SyncConfig", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *socketClient) SyncInterfaces(ctx context.Context, in *SyncInterfaceParams, opts ...grpc.CallOption) (*Error, error) { + out := new(Error) + err := c.cc.Invoke(ctx, "/wice.Socket/SyncInterfaces", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + // SocketServer is the server API for Socket service. // All implementations must embed UnimplementedSocketServer // for forward compatibility type SocketServer interface { GetStatus(context.Context, *Void) (*Status, error) - UnWait(context.Context, *Void) (*Error, error) - StreamEvents(*Void, Socket_StreamEventsServer) error + StreamEvents(*StreamEventsParams, Socket_StreamEventsServer) error + UnWait(context.Context, *UnWaitParams) (*Error, error) + Shutdown(context.Context, *ShutdownParams) (*Error, error) + SyncConfig(context.Context, *SyncConfigParams) (*Error, error) + SyncInterfaces(context.Context, *SyncInterfaceParams) (*Error, error) mustEmbedUnimplementedSocketServer() } @@ -98,11 +131,20 @@ type UnimplementedSocketServer struct { func (UnimplementedSocketServer) GetStatus(context.Context, *Void) (*Status, error) { return nil, status.Errorf(codes.Unimplemented, "method GetStatus not implemented") } -func (UnimplementedSocketServer) UnWait(context.Context, *Void) (*Error, error) { +func (UnimplementedSocketServer) StreamEvents(*StreamEventsParams, Socket_StreamEventsServer) error { + return status.Errorf(codes.Unimplemented, "method StreamEvents not implemented") +} +func (UnimplementedSocketServer) UnWait(context.Context, *UnWaitParams) (*Error, error) { return nil, status.Errorf(codes.Unimplemented, "method UnWait not implemented") } -func (UnimplementedSocketServer) StreamEvents(*Void, Socket_StreamEventsServer) error { - return status.Errorf(codes.Unimplemented, "method StreamEvents not implemented") +func (UnimplementedSocketServer) Shutdown(context.Context, *ShutdownParams) (*Error, error) { + return nil, status.Errorf(codes.Unimplemented, "method Shutdown not implemented") +} +func (UnimplementedSocketServer) SyncConfig(context.Context, *SyncConfigParams) (*Error, error) { + return nil, status.Errorf(codes.Unimplemented, "method SyncConfig not implemented") +} +func (UnimplementedSocketServer) SyncInterfaces(context.Context, *SyncInterfaceParams) (*Error, error) { + return nil, status.Errorf(codes.Unimplemented, "method SyncInterfaces not implemented") } func (UnimplementedSocketServer) mustEmbedUnimplementedSocketServer() {} @@ -135,26 +177,8 @@ func _Socket_GetStatus_Handler(srv interface{}, ctx context.Context, dec func(in return interceptor(ctx, in, info, handler) } -func _Socket_UnWait_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(Void) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(SocketServer).UnWait(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/wice.Socket/UnWait", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(SocketServer).UnWait(ctx, req.(*Void)) - } - return interceptor(ctx, in, info, handler) -} - func _Socket_StreamEvents_Handler(srv interface{}, stream grpc.ServerStream) error { - m := new(Void) + m := new(StreamEventsParams) if err := stream.RecvMsg(m); err != nil { return err } @@ -174,6 +198,78 @@ func (x *socketStreamEventsServer) Send(m *Event) error { return x.ServerStream.SendMsg(m) } +func _Socket_UnWait_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(UnWaitParams) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(SocketServer).UnWait(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/wice.Socket/UnWait", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(SocketServer).UnWait(ctx, req.(*UnWaitParams)) + } + return interceptor(ctx, in, info, handler) +} + +func _Socket_Shutdown_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ShutdownParams) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(SocketServer).Shutdown(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/wice.Socket/Shutdown", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(SocketServer).Shutdown(ctx, req.(*ShutdownParams)) + } + return interceptor(ctx, in, info, handler) +} + +func _Socket_SyncConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SyncConfigParams) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(SocketServer).SyncConfig(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/wice.Socket/SyncConfig", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(SocketServer).SyncConfig(ctx, req.(*SyncConfigParams)) + } + return interceptor(ctx, in, info, handler) +} + +func _Socket_SyncInterfaces_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SyncInterfaceParams) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(SocketServer).SyncInterfaces(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/wice.Socket/SyncInterfaces", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(SocketServer).SyncInterfaces(ctx, req.(*SyncInterfaceParams)) + } + return interceptor(ctx, in, info, handler) +} + // Socket_ServiceDesc is the grpc.ServiceDesc for Socket service. // It's only intended for direct use with grpc.RegisterService, // and not to be introspected or modified (even as a copy) @@ -189,6 +285,18 @@ var Socket_ServiceDesc = grpc.ServiceDesc{ MethodName: "UnWait", Handler: _Socket_UnWait_Handler, }, + { + MethodName: "Shutdown", + Handler: _Socket_Shutdown_Handler, + }, + { + MethodName: "SyncConfig", + Handler: _Socket_SyncConfig_Handler, + }, + { + MethodName: "SyncInterfaces", + Handler: _Socket_SyncInterfaces_Handler, + }, }, Streams: []grpc.StreamDesc{ { diff --git a/pkg/socket/client.go b/pkg/socket/client.go index c49c574c..c19e4492 100644 --- a/pkg/socket/client.go +++ b/pkg/socket/client.go @@ -9,6 +9,8 @@ import ( "go.uber.org/zap" "google.golang.org/grpc" + ginsecure "google.golang.org/grpc/credentials/insecure" + "riasc.eu/wice/pkg/crypto" "riasc.eu/wice/pkg/pb" ) @@ -49,23 +51,25 @@ func Connect(path string) (*Client, error) { } tgt := fmt.Sprintf("unix://%s", path) - conn, err := grpc.Dial(tgt, grpc.WithInsecure()) + conn, err := grpc.Dial(tgt, grpc.WithTransportCredentials(ginsecure.NewCredentials())) if err != nil { return nil, err } + logger := zap.L().Named("socket.client").With(zap.String("path", path)) + client := &Client{ SocketClient: pb.NewSocketClient(conn), grpc: conn, - logger: zap.L().Named("socket.client"), + logger: logger, Events: make(chan *pb.Event, 100), } - sts, err := client.UnWait(context.Background(), &pb.Void{}) + rerr, err := client.UnWait(context.Background(), &pb.UnWaitParams{}) if err != nil { return nil, fmt.Errorf("failed RPC request: %w", err) - } else if !sts.Ok { - return nil, fmt.Errorf("received RPC error: %s", sts.Error) + } else if !rerr.Ok() && rerr.Code != pb.Error_EALREADY { + return nil, fmt.Errorf("received RPC error: %w", rerr) } go client.streamEvents() @@ -80,7 +84,7 @@ func (c *Client) Close() error { } func (c *Client) streamEvents() { - str, err := c.StreamEvents(context.Background(), &pb.Void{}) + str, err := c.StreamEvents(context.Background(), &pb.StreamEventsParams{}) if err != nil { c.logger.Error("Failed to stream events", zap.Error(err)) } @@ -108,9 +112,10 @@ func (c *Client) WaitForEvent(flt *pb.Event) *pb.Event { return nil } -func (c *Client) WaitPeerHandshake() { +func (c *Client) WaitPeerHandshake(peer crypto.Key) { c.WaitForEvent(&pb.Event{ - Type: "handshake", + Type: "handshake", + State: "new", }) } diff --git a/pkg/socket/handlers.go b/pkg/socket/handlers.go new file mode 100644 index 00000000..9ecded1e --- /dev/null +++ b/pkg/socket/handlers.go @@ -0,0 +1,62 @@ +package socket + +import ( + "context" + + "riasc.eu/wice/pkg/pb" +) + +func (s *Server) GetStatus(ctx context.Context, _ *pb.Void) (*pb.Status, error) { + return &pb.Status{}, nil +} + +func (s *Server) StreamEvents(params *pb.StreamEventsParams, stream pb.Socket_StreamEventsServer) error { + ch := make(chan *pb.Event, 100) + + s.eventListenersLock.Lock() + s.eventListeners[ch] = nil + s.eventListenersLock.Unlock() + + for evt := range ch { + stream.Send(evt) + } + + return nil +} + +func (s *Server) UnWait(ctx context.Context, params *pb.UnWaitParams) (*pb.Error, error) { + var e = &pb.Error{ + Code: pb.Error_EALREADY, + Message: "already unwaited", + } + + s.waitOnce.Do(func() { + s.logger.Info("Control socket un-waited") + s.waitGroup.Done() + e = pb.Success + }) + + return e, nil +} + +func (s *Server) Shutdown(ctx context.Context, params *pb.ShutdownParams) (*pb.Error, error) { + // Notify main loop + s.Requests <- params + + return pb.Success, nil +} + +func (s *Server) SyncInterfaces(ctx context.Context, params *pb.SyncInterfaceParams) (*pb.Error, error) { + // Notify main loop + s.Requests <- params + + return pb.Success, nil +} + +func (s *Server) SyncConfig(ctx context.Context, params *pb.SyncConfigParams) (*pb.Error, error) { + + return &pb.Error{ + Code: pb.Error_ENOTSUP, + Message: "not implemented yet", + }, nil +} diff --git a/pkg/socket/server.go b/pkg/socket/server.go index 0cfa54a8..fb36e9ab 100644 --- a/pkg/socket/server.go +++ b/pkg/socket/server.go @@ -1,7 +1,6 @@ package socket import ( - "context" "sync" "go.uber.org/zap" @@ -19,6 +18,8 @@ type Server struct { listener net.Listener grpc *grpc.Server + Requests chan interface{} + eventListeners map[chan *pb.Event]interface{} eventListenersLock sync.Mutex @@ -47,6 +48,7 @@ func Listen(network string, address string, wait bool) (*Server, error) { logger: logger, grpc: grpc.NewServer(), eventListeners: map[chan *pb.Event]interface{}{}, + Requests: make(chan interface{}), } pb.RegisterSocketServer(s.grpc, s) @@ -78,36 +80,3 @@ func (s *Server) BroadcastEvent(e *pb.Event) error { return nil } - -func (s *Server) GetStatus(ctx context.Context, _ *pb.Void) (*pb.Status, error) { - return &pb.Status{}, nil -} - -func (s *Server) StreamEvents(_ *pb.Void, stream pb.Socket_StreamEventsServer) error { - ch := make(chan *pb.Event, 100) - - s.eventListenersLock.Lock() - s.eventListeners[ch] = nil - s.eventListenersLock.Unlock() - - for evt := range ch { - stream.Send(evt) - } - - return nil -} - -func (s *Server) UnWait(context.Context, *pb.Void) (*pb.Error, error) { - var e = &pb.Error{ - Ok: false, - Error: "already unwaited", - } - - s.waitOnce.Do(func() { - s.logger.Info("Control socket un-waited") - s.waitGroup.Done() - e = &pb.Ok - }) - - return e, nil -}