add proxy options logic

cmd/install/page_intro.go

@@ -90,7 +90,7 @@ func (p *PageIntro) Content() fyne.CanvasObject {
 	}
 
 	p.proxyCheck = widget.NewCheck("Use proxy", p.proxyChanged)
-	p.proxyCheck.Checked = p.wiz.installer.config.Proxy.ProxyType != config.ProxyTypeNone
+	p.proxyCheck.Checked = p.wiz.installer.config.Proxy.Active
 
 	noteMarkdown := widget.NewRichTextFromMarkdown(NoteText)
 	noteMarkdown.Wrapping = fyne.TextWrapWord
@@ -140,9 +140,7 @@ func (p *PageIntro) AquireData(installer *Installer) error {
 	default:
 		return errors.New("Choose the Sandbox to be used")
 	}
-	if p.proxyCheck.Checked {
-		p.wiz.installer.config.Proxy.ProxyType = config.ProxyTypeHTTP
-	}
+	p.wiz.installer.config.Proxy.Active = p.proxyCheck.Checked
 	return nil
 }
 

cmd/sandboxer/options.go

@@ -209,7 +209,7 @@ func (s *OptionsWindow) Save(w *ModalWindow) {
 	if err := s.proxySettings.Aquire(); err != nil {
 		err = fmt.Errorf("Proxy Setting: %v", err)
 		logging.LogError(err)
-		if s.conf.Proxy.ProxyType != config.ProxyTypeNone {
+		if s.conf.Proxy.Active {
 			dialog.ShowError(err, w.win)
 			return
 		}

go.mod

@@ -12,7 +12,7 @@ require (
 	github.com/lutzky/go-bidi v0.0.0-20200803103754-215e47c2f5df
 	github.com/mpkondrashin/ddan v0.0.87
 	github.com/mpkondrashin/fileicon v0.0.7
-	github.com/mpkondrashin/vone v0.0.29
+	github.com/mpkondrashin/vone v0.0.30
 	github.com/virtuald/go-paniclog v0.0.0-20190812204905-43a7fa316459
 	golang.org/x/mod v0.16.0
 	golang.org/x/text v0.14.0

go.sum

@@ -272,6 +272,8 @@ github.com/mpkondrashin/vone v0.0.28 h1:Rskl7rpEOY94MfPPF+plBuY6yhB2tmEheIMB9xoB
 github.com/mpkondrashin/vone v0.0.28/go.mod h1:tYcqkQ5aJ1ct6To/RR563j87godZ+/Fn824VBwLPpXY=
 github.com/mpkondrashin/vone v0.0.29 h1:NPjZN48f7n24XMmwgBwDFfiYtdCg19IqKu9rOiWVTQc=
 github.com/mpkondrashin/vone v0.0.29/go.mod h1:tYcqkQ5aJ1ct6To/RR563j87godZ+/Fn824VBwLPpXY=
+github.com/mpkondrashin/vone v0.0.30 h1:oTK7EGUvVxutOIKuj/R5scpxk9s9yw0Rh47Ut1SOHmI=
+github.com/mpkondrashin/vone v0.0.30/go.mod h1:tYcqkQ5aJ1ct6To/RR563j87godZ+/Fn824VBwLPpXY=
 github.com/neelance/astrewrite v0.0.0-20160511093645-99348263ae86/go.mod h1:kHJEU3ofeGjhHklVoIGuVj85JJwZ6kWPaJwCIxgnFmo=
 github.com/neelance/sourcemap v0.0.0-20200213170602-2833bce08e4c/go.mod h1:Qr6/a/Q4r9LP1IltGz7tA7iOK1WonHEYhu1HRBA7ZiM=
 github.com/nu7hatch/gouuid v0.0.0-20131221200532-179d4d0c4d8d h1:VhgPp6v9qf9Agr/56bj7Y/xa04UccTW04VP0Qed4vnQ=

pkg/config/proxy.go

@@ -107,77 +107,6 @@ func (a *AuthType) UnmarshalYAML(value *yaml.Node) error {
 	return nil
 }
 
-// Proxy Type
-
-type ProxyType int
-
-const (
-	ProxyTypeNone ProxyType = iota
-	ProxyTypeHTTP
-	ProxyTypeSocks
-)
-
-var ProxyTypeString = []string{
-	"None",
-	"HTTP",
-	"SOCKS",
-}
-
-func (r ProxyType) String() string {
-	return AuthTypeString[r]
-}
-
-func ProxyTypeFromString(s string) (ProxyType, error) {
-	for i, t := range ProxyTypeString {
-		if strings.EqualFold(t, s) {
-			return ProxyType(i), nil
-		}
-	}
-	return 0, fmt.Errorf("%w: %s", ErrUnknownProxyType, s)
-}
-
-// UnmarshalJSON implements the Unmarshaler interface of the json package for ProxyType.
-func (a *ProxyType) UnmarshalJSON(data []byte) error {
-	var v string
-	if err := json.Unmarshal(data, &v); err != nil {
-		return err
-	}
-	authType, err := ProxyTypeFromString(v)
-	if err != nil {
-		return err
-	}
-	*a = authType
-	return nil
-}
-
-// MarshalJSON implements the Marshaler interface of the json package for AuthType.
-func (a ProxyType) MarshalJSON() ([]byte, error) {
-	if a < 0 || a > ProxyTypeSocks {
-		return nil, fmt.Errorf("%d: %w", a, ErrUnknownProxyType)
-	}
-	return []byte(fmt.Sprintf("\"%s\"", a.String())), nil
-}
-
-// MarshalYAML implements the Marshaler interface of the yaml.v3 package for AuthType.
-func (s ProxyType) MarshalYAML() (interface{}, error) {
-	return s.String(), nil
-}
-
-// UnmarshalYAML implements the Unmarshaler interface of the yaml.v3 package for AuthType.
-func (a *ProxyType) UnmarshalYAML(value *yaml.Node) error {
-	var v string
-	err := value.Decode(&v)
-	if err != nil {
-		return err
-	}
-	proxyType, err := ProxyTypeFromString(v)
-	if err != nil {
-		return err
-	}
-	*a = proxyType
-	return nil
-}
-
 // YAMLURL
 /*
 type YAMLURL struct {
@@ -208,7 +137,7 @@ func (y *YAMLURL) UnmarshalYAML(value *yaml.Node) error {
 */
 type Proxy struct {
 	mx        sync.RWMutex `gsetter:"-"`
-	ProxyType ProxyType
+	Active    bool
 	Address   string
 	Port      int
 	AuthType  AuthType
@@ -221,7 +150,7 @@ type Proxy struct {
 
 func NewProxy() *Proxy {
 	return &Proxy{
-		ProxyType: ProxyTypeNone,
+		Active:    false,
 		AuthType:  AuthTypeNone,
 		Timeout:   30 * time.Second,
 		KeepAlive: 30 * time.Second,
@@ -233,7 +162,7 @@ func (p *Proxy) Update(newProxy *Proxy) {
 	defer p.mx.Unlock()
 	newProxy.mx.RLock()
 	defer newProxy.mx.RUnlock()
-	p.ProxyType = newProxy.ProxyType
+	p.Active = newProxy.Active
 	p.Address = newProxy.Address
 	p.Port = newProxy.Port
 	p.AuthType = newProxy.AuthType
@@ -242,24 +171,8 @@ func (p *Proxy) Update(newProxy *Proxy) {
 	p.Domain = newProxy.Domain
 }
 
-/*
-	func (p *Proxy) BasicAuth(Username string, Password string) *Proxy {
-		p.AuthType = AuthTypeBasic
-		p.Username = Username
-		p.Password = Password
-		return p
-	}
-
-	func (p *Proxy) NTLMAuth(Username string, Password string, Domain string) *Proxy {
-		p.AuthType = AuthTypeNTLM
-		p.Username = Username
-		p.Password = Password
-		p.Domain = Domain
-		return p
-	}
-*/
 func (p *Proxy) Modifier() (func(*http.Transport), error) {
-	if p.ProxyType == ProxyTypeNone {
+	if !p.Active {
 		return NullTransportModifier, nil
 	}
 	if p.Address == "" {
@@ -294,16 +207,16 @@ func NullTransportModifier(*http.Transport) {
 
 func (p *Proxy) TransportNoAuth(t *http.Transport) {
 	u := &url.URL{
-		Scheme: p.ProxyType.String(),
-		Host:   p.Address,
+		Scheme: "http",
+		Host:   fmt.Sprintf("%s:%d", p.Address, p.Port),
 	}
 	t.Proxy = http.ProxyURL(u)
 }
 
 func (p *Proxy) TransportBasic(t *http.Transport) {
 	u := &url.URL{
-		Scheme: p.ProxyType.String(),
-		Host:   p.Address,
+		Scheme: "http",
+		Host:   fmt.Sprintf("%s:%d", p.Address, p.Port),
 		User:   url.UserPassword(p.Username, p.Password),
 	}
 	t.Proxy = http.ProxyURL(u)
@@ -315,8 +228,8 @@ func (p *Proxy) TransportNTLM(t *http.Transport) {
 		KeepAlive: p.KeepAlive,
 	}
 	u := url.URL{
-		Scheme: p.ProxyType.String(),
-		Host:   p.Address,
+		Scheme: "http",
+		Host:   fmt.Sprintf("%s:%d", p.Address, p.Port),
 	}
 	ntlmDialContext := ntlm.NewNTLMProxyDialContext(dialer, u, p.Username, p.Password, p.Domain, nil)
 	t.Proxy = nil

pkg/settings/proxy_settings.go

@@ -9,7 +9,6 @@ Vision One sandbox settings widgets
 package settings
 
 import (
-	"errors"
 	"fmt"
 	"sandboxer/pkg/config"
 	"strconv"
@@ -23,15 +22,14 @@ import (
 type Proxy struct {
 	Conf *config.Proxy
 
-	//activeCheck   *widget.Check
-	proxyTypeRadio *widget.RadioGroup
-	addressEntry   *widget.Entry
-	portEntry      *widget.Entry
-	authTypeRadio  *widget.RadioGroup
-	usernameEntry  *widget.Entry
-	passwordEntry  *widget.Entry
-	domainEntry    *widget.Entry
-	form           *widget.Form
+	activeCheck   *widget.Check
+	addressEntry  *widget.Entry
+	portEntry     *widget.Entry
+	authTypeRadio *widget.RadioGroup
+	usernameEntry *widget.Entry
+	passwordEntry *widget.Entry
+	domainEntry   *widget.Entry
+	form          *widget.Form
 	// cancelDetect     context.CancelFunc
 }
 
@@ -42,16 +40,21 @@ func NewProxy(conf *config.Proxy) *Proxy {
 }
 
 func (s *Proxy) Widget() fyne.CanvasObject {
-	s.proxyTypeRadio = widget.NewRadioGroup(config.ProxyTypeString, s.AuthTypeChange)
-	s.proxyTypeRadio.Horizontal = true
-	s.proxyTypeRadio.SetSelected(s.Conf.ProxyType.String())
+	s.activeCheck = widget.NewCheck("Use proxy", func(bool) {
+		s.AuthTypeChange(s.authTypeRadio.Selected)
+	})
+	s.activeCheck.Checked = s.Conf.Active
 
 	s.addressEntry = widget.NewEntry()
 	s.addressEntry.SetText(s.Conf.Address)
 	addressFormItem := widget.NewFormItem("Address:", s.addressEntry)
-	//addressFormItem.HintText = "scheme://address:port, where scheme = socks, http, https"
+
 	s.portEntry = widget.NewEntry()
-	s.portEntry.SetText(strconv.Itoa(s.Conf.Port))
+	if s.Conf.Port == 0 {
+		s.portEntry.SetText("")
+	} else {
+		s.portEntry.SetText(strconv.Itoa(s.Conf.Port))
+	}
 	portFormItem := widget.NewFormItem("Port:", s.portEntry)
 
 	s.authTypeRadio = widget.NewRadioGroup(config.AuthTypeString, s.AuthTypeChange)
@@ -83,14 +86,13 @@ func (s *Proxy) Widget() fyne.CanvasObject {
 	)
 	s.AuthTypeChange(s.authTypeRadio.Selected)
 	return container.NewVBox(
-		s.proxyTypeRadio,
+		s.activeCheck,
 		s.form,
 	)
 }
 
 func (s *Proxy) AuthTypeChange(choice string) {
-	fmt.Println("AuthTypeChange: ", choice)
-	if s.proxyTypeRadio == nil {
+	if s.activeCheck == nil {
 		return
 	}
 	if s.addressEntry == nil {
@@ -111,7 +113,7 @@ func (s *Proxy) AuthTypeChange(choice string) {
 	if s.domainEntry == nil {
 		return
 	}
-	if s.proxyTypeRadio.Selected == config.ProxyTypeNone.String() {
+	if !s.activeCheck.Checked {
 		s.addressEntry.Disable()
 		s.portEntry.Disable()
 		s.authTypeRadio.Disable()
@@ -145,33 +147,29 @@ func (s *Proxy) Update() {
 	//s.DetectDomain(s.tokenEntry.Text)
 }
 
-var ErrUsupportedScheme = errors.New("unsupported scheme")
-
 func (s *Proxy) Aquire() error {
+	s.Conf.Active = s.activeCheck.Checked
+	if !s.Conf.Active {
+		return nil
+	}
 	port, err := strconv.Atoi(strings.TrimSpace(s.portEntry.Text))
 	if err != nil {
 		return fmt.Errorf("wrong port number: %w", err)
 	}
-	proxyType, err := config.ProxyTypeFromString(s.proxyTypeRadio.Selected)
-	if err != nil {
-		return err
-	}
 	authType, err := config.AuthTypeFromString(s.authTypeRadio.Selected)
 	if err != nil {
 		return err
 	}
 	p := &config.Proxy{
-		ProxyType: proxyType,
-		Address:   strings.TrimSpace(s.addressEntry.Text),
-		Port:      port,
-		AuthType:  authType,
-		Username:  strings.TrimSpace(s.usernameEntry.Text),
-		Password:  strings.TrimSpace(s.passwordEntry.Text),
-		Domain:    strings.TrimSpace(s.domainEntry.Text),
+		Active:   true,
+		Address:  strings.TrimSpace(s.addressEntry.Text),
+		Port:     port,
+		AuthType: authType,
+		Username: strings.TrimSpace(s.usernameEntry.Text),
+		Password: strings.TrimSpace(s.passwordEntry.Text),
+		Domain:   strings.TrimSpace(s.domainEntry.Text),
 	}
-
-	_, err = p.Modifier()
-	if err != nil {
+	if _, err := p.Modifier(); err != nil {
 		return err
 	}
 	s.Conf.Update(p)

pkg/settings/vone_settings.go

@@ -91,7 +91,11 @@ func (s *VisionOne) DetectDomain(token string) {
 		if err != nil {
 			logging.LogError(err)
 		}
-		domain := vone.DetectVisionOneDomain(ctx, token, modifier)
+		domain, err := vone.DetectVisionOneDomain(ctx, token, modifier)
+		if err != nil {
+			logging.LogError(err)
+			return
+		}
 		if domain != "" {
 			s.visionOneDomains.SetSelected(domain)
 		}