podman

1
// Package webbrowser provides a simple API for opening web pages on your
2
// default browser.
3
package webbrowser
4

5
import (
6
	"errors"
7
	"fmt"
8
	"net/url"
9
	"os"
10
	"os/exec"
11
	"runtime"
12
	"strings"
13
)
14

15
var (
16
	ErrCantOpenBrowser = errors.New("webbrowser: can't open browser")
17
	ErrNoCandidates    = errors.New("webbrowser: no browser candidate found for your OS")
18
)
19

20
// Candidates contains a list of registered `Browser`s that will be tried with Open.
21
var Candidates []Browser
22

23
type Browser interface {
24
	// Command returns a ready to be used Cmd that will open an URL.
25
	Command(string) (*exec.Cmd, error)
26
	// Open tries to open a URL in your default browser. NOTE: This may cause
27
	// your program to hang until the browser process is closed in some OSes,
28
	// see https://github.com/toqueteos/webbrowser/issues/4.
29
	Open(string) error
30
}
31

32
// Open tries to open a URL in your default browser ensuring you have a display
33
// set up and not running this from SSH. NOTE: This may cause your program to
34
// hang until the browser process is closed in some OSes, see
35
// https://github.com/toqueteos/webbrowser/issues/4.
36
func Open(s string) (err error) {
37
	if len(Candidates) == 0 {
38
		return ErrNoCandidates
39
	}
40

41
	// Try to determine if there's a display available (only linux) and we
42
	// aren't on a terminal (all but windows).
43
	switch runtime.GOOS {
44
	case "linux":
45
		// No display, no need to open a browser. Lynx users **MAY** have
46
		// something to say about this.
47
		if os.Getenv("DISPLAY") == "" {
48
			return fmt.Errorf("webbrowser: tried to open %q, no screen found", s)
49
		}
50
		fallthrough
51
	case "darwin":
52
		// Check SSH env vars.
53
		if os.Getenv("SSH_CLIENT") != "" || os.Getenv("SSH_TTY") != "" {
54
			return fmt.Errorf("webbrowser: tried to open %q, but you are running a shell session", s)
55
		}
56
	}
57

58
	// Try all candidates
59
	for _, candidate := range Candidates {
60
		err := candidate.Open(s)
61
		if err == nil {
62
			return nil
63
		}
64
	}
65

66
	return ErrCantOpenBrowser
67
}
68

69
func init() {
70
	// Register the default Browser for current OS, if it exists.
71
	if os, ok := osCommand[runtime.GOOS]; ok {
72
		Candidates = append(Candidates, browserCommand{os.cmd, os.args})
73
	}
74
}
75

76
var (
77
	osCommand = map[string]*browserCommand{
78
		"android": &browserCommand{"xdg-open", nil},
79
		"darwin":  &browserCommand{"open", nil},
80
		"freebsd": &browserCommand{"xdg-open", nil},
81
		"linux":   &browserCommand{"xdg-open", nil},
82
		"netbsd":  &browserCommand{"xdg-open", nil},
83
		"openbsd": &browserCommand{"xdg-open", nil}, // It may be open instead
84
		"windows": &browserCommand{"cmd", []string{"/c", "start"}},
85
	}
86
	winSchemes = [3]string{"https", "http", "file"}
87
)
88

89
type browserCommand struct {
90
	cmd  string
91
	args []string
92
}
93

94
func (b browserCommand) Command(s string) (*exec.Cmd, error) {
95
	u, err := url.Parse(s)
96
	if err != nil {
97
		return nil, err
98
	}
99

100
	validUrl := ensureValidURL(u)
101

102
	b.args = append(b.args, validUrl)
103

104
	return exec.Command(b.cmd, b.args...), nil
105
}
106

107
func (b browserCommand) Open(s string) error {
108
	cmd, err := b.Command(s)
109
	if err != nil {
110
		return err
111
	}
112

113
	return cmd.Run()
114
}
115

116
func ensureScheme(u *url.URL) {
117
	for _, s := range winSchemes {
118
		if u.Scheme == s {
119
			return
120
		}
121
	}
122
	u.Scheme = "http"
123
}
124

125
func ensureValidURL(u *url.URL) string {
126
	// Enforce a scheme (windows requires scheme to be set to work properly).
127
	ensureScheme(u)
128
	s := u.String()
129

130
	// Escape characters not allowed by cmd/bash
131
	switch runtime.GOOS {
132
	case "windows":
133
		s = strings.Replace(s, "&", `^&`, -1)
134
	}
135

136
	return s
137
}
138