Refactor

server/handlers.go

@@ -0,0 +1,238 @@
+package server
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"log"
+	"net/http"
+	"net/url"
+	"sync/atomic"
+
+	"github.com/gorilla/websocket"
+	"github.com/pkg/errors"
+
+	"github.com/yudai/gotty/webtty"
+)
+
+func (server *Server) generateHandleWS(ctx context.Context, cancel context.CancelFunc) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		if server.options.Once {
+			if atomic.LoadInt64(server.once) > 0 {
+				http.Error(w, "Server is shutting down", http.StatusServiceUnavailable)
+				return
+			}
+			atomic.AddInt64(server.once, 1)
+		}
+		connections := atomic.AddInt64(server.connections, 1)
+		server.wsWG.Add(1)
+		server.stopTimer()
+		closeReason := "unknown reason"
+
+		defer func() {
+			server.wsWG.Done()
+
+			connections := atomic.AddInt64(server.connections, -1)
+			if connections == 0 {
+				server.resetTimer()
+			}
+
+			log.Printf(
+				"Connection closed by %s: %s, connections: %d/%d",
+				closeReason, r.RemoteAddr, connections, server.options.MaxConnection,
+			)
+
+			if server.options.Once {
+				cancel()
+			}
+		}()
+
+		log.Printf("New client connected: %s", r.RemoteAddr)
+		if int64(server.options.MaxConnection) != 0 {
+			if connections > int64(server.options.MaxConnection) {
+				closeReason = "exceeding max number of connections"
+				return
+			}
+		}
+
+		if r.Method != "GET" {
+			http.Error(w, "Method not allowed", 405)
+			return
+		}
+
+		conn, err := server.upgrader.Upgrade(w, r, nil)
+		if err != nil {
+			http.Error(w, "Failed to upgrade connection: "+err.Error(), 500)
+			return
+		}
+		defer conn.Close()
+
+		err = server.processWSConn(ctx, conn)
+
+		switch err {
+		case ctx.Err():
+			closeReason = "cancelation"
+		case webtty.ErrSlaveClosed:
+			closeReason = server.factory.Name()
+		case webtty.ErrMasterClosed:
+			closeReason = "client"
+		default:
+			closeReason = fmt.Sprintf("an error: %s", err)
+		}
+	}
+}
+
+func (server *Server) processWSConn(ctx context.Context, conn *websocket.Conn) error {
+	typ, initLine, err := conn.ReadMessage()
+	if err != nil {
+		return errors.Wrapf(err, "failed to authenticate websocket connection")
+	}
+	if typ != websocket.TextMessage {
+		return errors.New("failed to authenticate websocket connection: invalid message type")
+	}
+
+	var init InitMessage
+	err = json.Unmarshal(initLine, &init)
+	if err != nil {
+		return errors.Wrapf(err, "failed to authenticate websocket connection")
+	}
+	if init.AuthToken != server.options.Credential {
+		return errors.New("failed to authenticate websocket connection")
+	}
+
+	queryPath := "?"
+	if server.options.PermitArguments && init.Arguments != "" {
+		queryPath = init.Arguments
+	}
+
+	query, err := url.Parse(queryPath)
+	if err != nil {
+		return errors.Wrapf(err, "failed to parse arguments")
+	}
+	params := query.Query()
+	var slave Slave
+	slave, err = server.factory.New(params)
+	if err != nil {
+		return errors.Wrapf(err, "failed to create backend")
+	}
+	defer slave.Close()
+
+	titleVars := server.titleVariables(
+		[]string{"server", "master", "slave"},
+		map[string]map[string]interface{}{
+			"server": server.options.TitleVariables,
+			"master": map[string]interface{}{
+				"remote_addr": conn.RemoteAddr(),
+			},
+			"slave": slave.WindowTitleVariables(),
+		},
+	)
+
+	titleBuf := new(bytes.Buffer)
+	err = server.titleTemplate.Execute(titleBuf, titleVars)
+	if err != nil {
+		return errors.Wrapf(err, "failed to fill window title template")
+	}
+
+	opts := []webtty.Option{
+		webtty.WithWindowTitle(titleBuf.Bytes()),
+	}
+	if server.options.PermitWrite {
+		opts = append(opts, webtty.WithPermitWrite())
+	}
+	if server.options.EnableReconnect {
+		opts = append(opts, webtty.WithReconnect(server.options.ReconnectTime))
+	}
+	if server.options.Width > 0 || server.options.Height > 0 {
+		width, height, err := slave.GetTerminalSize()
+		if err != nil {
+			return errors.Wrapf(err, "failed to get default terminal size")
+		}
+		if server.options.Width > 0 {
+			width = server.options.Width
+		}
+		if server.options.Height > 0 {
+			height = server.options.Height
+		}
+		err = slave.ResizeTerminal(width, height)
+		if err != nil {
+			return errors.Wrapf(err, "failed to resize terminal")
+		}
+
+		opts = append(opts, webtty.WithFixedSize(server.options.Width, server.options.Height))
+	}
+	if server.options.Preferences != nil {
+		opts = append(opts, webtty.WithMasterPreferences(server.options.Preferences))
+	}
+
+	tty, err := webtty.New(conn, slave, opts...)
+	if err != nil {
+		return errors.Wrapf(err, "failed to create webtty")
+	}
+
+	err = tty.Run(ctx)
+
+	return err
+}
+
+func (server *Server) handleIndex(w http.ResponseWriter, r *http.Request) {
+	titleVars := server.titleVariables(
+		[]string{"server", "master"},
+		map[string]map[string]interface{}{
+			"server": server.options.TitleVariables,
+			"master": map[string]interface{}{
+				"remote_addr": r.RemoteAddr,
+			},
+		},
+	)
+
+	titleBuf := new(bytes.Buffer)
+	err := server.titleTemplate.Execute(titleBuf, titleVars)
+	if err != nil {
+		http.Error(w, "Internal Server Error", 500)
+		return
+	}
+
+	indexVars := map[string]interface{}{
+		"title": titleBuf.String(),
+	}
+
+	indexBuf := new(bytes.Buffer)
+	err = server.indexTemplate.Execute(indexBuf, indexVars)
+	if err != nil {
+		http.Error(w, "Internal Server Error", 500)
+		return
+	}
+
+	w.Write(indexBuf.Bytes())
+}
+
+func (server *Server) handleAuthToken(w http.ResponseWriter, r *http.Request) {
+	w.Header().Set("Content-Type", "application/javascript")
+	// @TODO hashing?
+	w.Write([]byte("var gotty_auth_token = '" + server.options.Credential + "';"))
+}
+
+// titleVariables merges maps in a specified order.
+// varUnits are name-keyed maps, whose names will be iterated using order.
+func (server *Server) titleVariables(order []string, varUnits map[string]map[string]interface{}) map[string]interface{} {
+	titleVars := map[string]interface{}{}
+
+	for _, name := range order {
+		vars, ok := varUnits[name]
+		if !ok {
+			panic("title variable name error")
+		}
+		for key, val := range vars {
+			titleVars[key] = val
+		}
+	}
+
+	// safe net for conflicted keys
+	for _, name := range order {
+		titleVars[name] = varUnits[name]
+	}
+
+	return titleVars
+}

server/init_message.go

@@ -0,0 +1,6 @@
+package server
+
+type InitMessage struct {
+	Arguments string `json:"Arguments,omitempty"`
+	AuthToken string `json:"AuthToken,omitempty"`
+}

server/log_response_writer.go

@@ -0,0 +1,23 @@
+package server
+
+import (
+	"bufio"
+	"net"
+	"net/http"
+)
+
+type logResponseWriter struct {
+	http.ResponseWriter
+	status int
+}
+
+func (w *logResponseWriter) WriteHeader(status int) {
+	w.status = status
+	w.ResponseWriter.WriteHeader(status)
+}
+
+func (w *logResponseWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) {
+	hj, _ := w.ResponseWriter.(http.Hijacker)
+	w.status = http.StatusSwitchingProtocols
+	return hj.Hijack()
+}

server/middleware.go

@@ -0,0 +1,51 @@
+package server
+
+import (
+	"encoding/base64"
+	"log"
+	"net/http"
+	"strings"
+)
+
+func (server *Server) wrapLogger(handler http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		rw := &logResponseWriter{w, 200}
+		handler.ServeHTTP(rw, r)
+		log.Printf("%s %d %s %s", r.RemoteAddr, rw.status, r.Method, r.URL.Path)
+	})
+}
+
+func (server *Server) wrapHeaders(handler http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		// todo add version
+		w.Header().Set("Server", "GoTTY")
+		handler.ServeHTTP(w, r)
+	})
+}
+
+func (server *Server) wrapBasicAuth(handler http.Handler, credential string) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		token := strings.SplitN(r.Header.Get("Authorization"), " ", 2)
+
+		if len(token) != 2 || strings.ToLower(token[0]) != "basic" {
+			w.Header().Set("WWW-Authenticate", `Basic realm="GoTTY"`)
+			http.Error(w, "Bad Request", http.StatusUnauthorized)
+			return
+		}
+
+		payload, err := base64.StdEncoding.DecodeString(token[1])
+		if err != nil {
+			http.Error(w, "Internal Server Error", http.StatusInternalServerError)
+			return
+		}
+
+		if credential != string(payload) {
+			w.Header().Set("WWW-Authenticate", `Basic realm="GoTTY"`)
+			http.Error(w, "authorization failed", http.StatusUnauthorized)
+			return
+		}
+
+		log.Printf("Basic Authentication Succeeded: %s", r.RemoteAddr)
+		handler.ServeHTTP(w, r)
+	})
+}

server/options.go

@@ -0,0 +1,97 @@
+package server
+
+import (
+	"github.com/pkg/errors"
+)
+
+type Options struct {
+	Address             string           `hcl:"address" flagName:"address" flagSName:"a" flagDescribe:"IP address to listen" default:"0.0.0.0"`
+	Port                string           `hcl:"port" flagName:"port" flagSName:"p" flagDescribe:"Port number to liten" default:"8080"`
+	PermitWrite         bool             `hcl:"permit_write" flagName:"permit-write" flagSName:"w" flagDescribe:"Permit clients to write to the TTY (BE CAREFUL)" default:"false"`
+	EnableBasicAuth     bool             `hcl:"enable_basic_auth" default:"false"`
+	Credential          string           `hcl:"credential" flagName:"credential" flagSName:"c" flagDescribe:"Credential for Basic Authentication (ex: user:pass, default disabled)" default:""`
+	EnableRandomUrl     bool             `hcl:"enable_random_url" flagName:"random-url" flagSName:"r" flagDescribe:"Add a random string to the URL" default:"false"`
+	RandomUrlLength     int              `hcl:"random_url_length" flagName:"random-url-length" flagDescribe:"Random URL length" default:"8"`
+	EnableTLS           bool             `hcl:"enable_tls" flagName:"tls" flagSName:"t" flagDescribe:"Enable TLS/SSL" default:"false"`
+	TLSCrtFile          string           `hcl:"tls_crt_file" flagName:"tls-crt" flagDescribe:"TLS/SSL certificate file path" default:"~/.gotty.crt"`
+	TLSKeyFile          string           `hcl:"tls_key_file" flagName:"tls-key" flagDescribe:"TLS/SSL key file path" default:"~/.gotty.key"`
+	EnableTLSClientAuth bool             `hcl:"enable_tls_client_auth" default:"false"`
+	TLSCACrtFile        string           `hcl:"tls_ca_crt_file" flagName:"tls-ca-crt" flagDescribe:"TLS/SSL CA certificate file for client certifications" default:"~/.gotty.ca.crt"`
+	IndexFile           string           `hcl:"index_file" flagName:"index" flagDescribe:"Custom index.html file" default:""`
+	TitleFormat         string           `hcl:"title_format" flagName:"title-format" flagSName:"" flagDescribe:"Title format of browser window" default:"{{ .command }}@{{ .hostname }}"`
+	EnableReconnect     bool             `hcl:"enable_reconnect" flagName:"reconnect" flagDescribe:"Enable reconnection" default:"false"`
+	ReconnectTime       int              `hcl:"reconnect_time" flagName:"reconnect-time" flagDescribe:"Time to reconnect" default:"10"`
+	MaxConnection       int              `hcl:"max_connection" flagName:"max-connection" flagDescribe:"Maximum connection to gotty" default:"0"`
+	Once                bool             `hcl:"once" flagName:"once" flagDescribe:"Accept only one client and exit on disconnection" default:"false"`
+	Timeout             int              `hcl:"timeout" flagName:"timeout" flagDescribe:"Timeout seconds for waiting a client(0 to disable)" default:"0"`
+	PermitArguments     bool             `hcl:"permit_arguments" flagName:"permit-arguments" flagDescribe:"Permit clients to send command line arguments in URL (e.g. http://example.com:8080/?arg=AAA&arg=BBB)" default:"true"`
+	Preferences         *HtermPrefernces `hcl:"preferences"`
+	Width               int              `hcl:"width" flagName:"width" flagDescribe:"Static width of the screen, 0(default) means dynamically resize" default:"0"`
+	Height              int              `hcl:"height" flagName:"height" flagDescribe:"Static height of the screen, 0(default) means dynamically resize" default:"0"`
+
+	TitleVariables map[string]interface{}
+}
+
+func (options *Options) Validate() error {
+	if options.EnableTLSClientAuth && !options.EnableTLS {
+		return errors.New("TLS client authentication is enabled, but TLS is not enabled")
+	}
+	return nil
+}
+
+type HtermPrefernces struct {
+	AltGrMode                     *string                      `hcl:"alt_gr_mode" json:"alt-gr-mode,omitempty"`
+	AltBackspaceIsMetaBackspace   bool                         `hcl:"alt_backspace_is_meta_backspace" json:"alt-backspace-is-meta-backspace,omitempty"`
+	AltIsMeta                     bool                         `hcl:"alt_is_meta" json:"alt-is-meta,omitempty"`
+	AltSendsWhat                  string                       `hcl:"alt_sends_what" json:"alt-sends-what,omitempty"`
+	AudibleBellSound              string                       `hcl:"audible_bell_sound" json:"audible-bell-sound,omitempty"`
+	DesktopNotificationBell       bool                         `hcl:"desktop_notification_bell" json:"desktop-notification-bell,omitempty"`
+	BackgroundColor               string                       `hcl:"background_color" json:"background-color,omitempty"`
+	BackgroundImage               string                       `hcl:"background_image" json:"background-image,omitempty"`
+	BackgroundSize                string                       `hcl:"background_size" json:"background-size,omitempty"`
+	BackgroundPosition            string                       `hcl:"background_position" json:"background-position,omitempty"`
+	BackspaceSendsBackspace       bool                         `hcl:"backspace_sends_backspace" json:"backspace-sends-backspace,omitempty"`
+	CharacterMapOverrides         map[string]map[string]string `hcl:"character_map_overrides" json:"character-map-overrides,omitempty"`
+	CloseOnExit                   bool                         `hcl:"close_on_exit" json:"close-on-exit,omitempty"`
+	CursorBlink                   bool                         `hcl:"cursor_blink" json:"cursor-blink,omitempty"`
+	CursorBlinkCycle              [2]int                       `hcl:"cursor_blink_cycle" json:"cursor-blink-cycle,omitempty"`
+	CursorColor                   string                       `hcl:"cursor_color" json:"cursor-color,omitempty"`
+	ColorPaletteOverrides         []*string                    `hcl:"color_palette_overrides" json:"color-palette-overrides,omitempty"`
+	CopyOnSelect                  bool                         `hcl:"copy_on_select" json:"copy-on-select,omitempty"`
+	UseDefaultWindowCopy          bool                         `hcl:"use_default_window_copy" json:"use-default-window-copy,omitempty"`
+	ClearSelectionAfterCopy       bool                         `hcl:"clear_selection_after_copy" json:"clear-selection-after-copy,omitempty"`
+	CtrlPlusMinusZeroZoom         bool                         `hcl:"ctrl_plus_minus_zero_zoom" json:"ctrl-plus-minus-zero-zoom,omitempty"`
+	CtrlCCopy                     bool                         `hcl:"ctrl_c_copy" json:"ctrl-c-copy,omitempty"`
+	CtrlVPaste                    bool                         `hcl:"ctrl_v_paste" json:"ctrl-v-paste,omitempty"`
+	EastAsianAmbiguousAsTwoColumn bool                         `hcl:"east_asian_ambiguous_as_two_column" json:"east-asian-ambiguous-as-two-column,omitempty"`
+	Enable8BitControl             *bool                        `hcl:"enable_8_bit_control" json:"enable-8-bit-control,omitempty"`
+	EnableBold                    *bool                        `hcl:"enable_bold" json:"enable-bold,omitempty"`
+	EnableBoldAsBright            bool                         `hcl:"enable_bold_as_bright" json:"enable-bold-as-bright,omitempty"`
+	EnableClipboardNotice         bool                         `hcl:"enable_clipboard_notice" json:"enable-clipboard-notice,omitempty"`
+	EnableClipboardWrite          bool                         `hcl:"enable_clipboard_write" json:"enable-clipboard-write,omitempty"`
+	EnableDec12                   bool                         `hcl:"enable_dec12" json:"enable-dec12,omitempty"`
+	Environment                   map[string]string            `hcl:"environment" json:"environment,omitempty"`
+	FontFamily                    string                       `hcl:"font_family" json:"font-family,omitempty"`
+	FontSize                      int                          `hcl:"font_size" json:"font-size,omitempty"`
+	FontSmoothing                 string                       `hcl:"font_smoothing" json:"font-smoothing,omitempty"`
+	ForegroundColor               string                       `hcl:"foreground_color" json:"foreground-color,omitempty"`
+	HomeKeysScroll                bool                         `hcl:"home_keys_scroll" json:"home-keys-scroll,omitempty"`
+	Keybindings                   map[string]string            `hcl:"keybindings" json:"keybindings,omitempty"`
+	MaxStringSequence             int                          `hcl:"max_string_sequence" json:"max-string-sequence,omitempty"`
+	MediaKeysAreFkeys             bool                         `hcl:"media_keys_are_fkeys" json:"media-keys-are-fkeys,omitempty"`
+	MetaSendsEscape               bool                         `hcl:"meta_sends_escape" json:"meta-sends-escape,omitempty"`
+	MousePasteButton              *int                         `hcl:"mouse_paste_button" json:"mouse-paste-button,omitempty"`
+	PageKeysScroll                bool                         `hcl:"page_keys_scroll" json:"page-keys-scroll,omitempty"`
+	PassAltNumber                 *bool                        `hcl:"pass_alt_number" json:"pass-alt-number,omitempty"`
+	PassCtrlNumber                *bool                        `hcl:"pass_ctrl_number" json:"pass-ctrl-number,omitempty"`
+	PassMetaNumber                *bool                        `hcl:"pass_meta_number" json:"pass-meta-number,omitempty"`
+	PassMetaV                     bool                         `hcl:"pass_meta_v" json:"pass-meta-v,omitempty"`
+	ReceiveEncoding               string                       `hcl:"receive_encoding" json:"receive-encoding,omitempty"`
+	ScrollOnKeystroke             bool                         `hcl:"scroll_on_keystroke" json:"scroll-on-keystroke,omitempty"`
+	ScrollOnOutput                bool                         `hcl:"scroll_on_output" json:"scroll-on-output,omitempty"`
+	ScrollbarVisible              bool                         `hcl:"scrollbar_visible" json:"scrollbar-visible,omitempty"`
+	ScrollWheelMoveMultiplier     int                          `hcl:"scroll_wheel_move_multiplier" json:"scroll-wheel-move-multiplier,omitempty"`
+	SendEncoding                  string                       `hcl:"send_encoding" json:"send-encoding,omitempty"`
+	ShiftInsertPaste              bool                         `hcl:"shift_insert_paste" json:"shift-insert-paste,omitempty"`
+	UserCss                       string                       `hcl:"user_css" json:"user-css,omitempty"`
+}

server/run_option.go

@@ -0,0 +1,21 @@
+package server
+
+import (
+	"context"
+)
+
+// RunOptions holds a set of configurations for Server.Run().
+type RunOptions struct {
+	gracefullCtx context.Context
+}
+
+// RunOption is an option of Server.Run().
+type RunOption func(*RunOptions)
+
+// WithGracefullContext accepts a context to shutdown a Server
+// with care for existing client connections.
+func WithGracefullContext(ctx context.Context) RunOption {
+	return func(options *RunOptions) {
+		options.gracefullCtx = ctx
+	}
+}

server/server.go

@@ -0,0 +1,253 @@
+package server
+
+import (
+	"context"
+	"crypto/tls"
+	"crypto/x509"
+	"html/template"
+	"io/ioutil"
+	"log"
+	"net"
+	"net/http"
+	"net/url"
+	"sync"
+	"sync/atomic"
+	noesctmpl "text/template"
+	"time"
+
+	"github.com/elazarl/go-bindata-assetfs"
+	"github.com/gorilla/websocket"
+	"github.com/pkg/errors"
+
+	"github.com/yudai/gotty/pkg/homedir"
+	"github.com/yudai/gotty/pkg/randomstring"
+	"github.com/yudai/gotty/webtty"
+)
+
+// Server provides a webtty HTTP endpoint.
+type Server struct {
+	factory Factory
+	options *Options
+
+	srv *http.Server
+
+	upgrader *websocket.Upgrader
+
+	indexTemplate *template.Template
+	titleTemplate *noesctmpl.Template
+	titleVars     map[string]interface{}
+	timer         *time.Timer
+	wsWG          sync.WaitGroup
+	url           *url.URL // use URL()
+	connections   *int64   // Use atomic operations
+	once          *int64   // use atomic operations
+}
+
+// New creates a new instance of Server.
+// Server will use the New() of the factory provided to handle each request.
+func New(factory Factory, options *Options) (*Server, error) {
+	indexData, err := Asset("static/index.html")
+	if err != nil {
+		panic("index not found") // must be in bindata
+	}
+	if options.IndexFile != "" {
+		log.Printf("Using index file at " + options.IndexFile)
+		path := homedir.Expand(options.IndexFile)
+		indexData, err = ioutil.ReadFile(path)
+		if err != nil {
+			return nil, errors.Wrapf(err, "failed to read custom index file at `%s`", path)
+		}
+	}
+	indexTemplate, err := template.New("index").Parse(string(indexData))
+	if err != nil {
+		panic("index template parse failed") // must be valid
+	}
+
+	titleTemplate, err := noesctmpl.New("title").Parse(options.TitleFormat)
+	if err != nil {
+		return nil, errors.Wrapf(err, "failed to parse window title format `%s`", options.TitleFormat)
+	}
+
+	connections := int64(0)
+	once := int64(0)
+
+	return &Server{
+		factory: factory,
+		options: options,
+
+		upgrader: &websocket.Upgrader{
+			ReadBufferSize:  1024,
+			WriteBufferSize: 1024,
+			Subprotocols:    webtty.Protocols,
+		},
+		indexTemplate: indexTemplate,
+		titleTemplate: titleTemplate,
+		connections:   &connections,
+		once:          &once,
+	}, nil
+}
+
+// Run starts the main process of the Server.
+// The cancelation of ctx will shutdown the server immediately with aborting
+// existing connections. Use WithGracefullContext() to support gracefull shutdown.
+func (server *Server) Run(ctx context.Context, options ...RunOption) error {
+	cctx, cancel := context.WithCancel(ctx)
+	opts := &RunOptions{gracefullCtx: context.Background()}
+	for _, opt := range options {
+		opt(opts)
+	}
+
+	handlers := server.setupHandlers(cctx, cancel)
+	srv, err := server.setupHTTPServer(handlers)
+	if err != nil {
+		return errors.Wrapf(err, "failed to setup an HTTP server")
+	}
+
+	if server.options.PermitWrite {
+		log.Printf("Permitting clients to write input to the PTY.")
+	}
+
+	if server.options.Once {
+		log.Printf("Once option is provided, accepting only one client")
+	}
+
+	server.srv = srv
+
+	if server.options.Timeout > 0 {
+		server.timer = time.NewTimer(time.Duration(server.options.Timeout) * time.Second)
+		go func() {
+			select {
+			case <-server.timer.C:
+				cancel()
+			case <-cctx.Done():
+			}
+		}()
+	}
+
+	listenErr := make(chan error, 1)
+	go func() {
+		if server.options.EnableTLS {
+			crtFile := homedir.Expand(server.options.TLSCrtFile)
+			keyFile := homedir.Expand(server.options.TLSKeyFile)
+			log.Printf("TLS crt file: " + crtFile)
+			log.Printf("TLS key file: " + keyFile)
+
+			err = srv.ListenAndServeTLS(crtFile, keyFile)
+		} else {
+			err = srv.ListenAndServe()
+		}
+		if err != nil {
+			listenErr <- err
+		}
+	}()
+
+	go func() {
+		select {
+		case <-opts.gracefullCtx.Done():
+			srv.Shutdown(context.Background())
+		case <-cctx.Done():
+		}
+	}()
+
+	select {
+	case err = <-listenErr:
+		if err == http.ErrServerClosed { // by gracefull ctx
+			err = nil
+		} else {
+			cancel()
+		}
+	case <-cctx.Done():
+		srv.Close()
+		err = cctx.Err()
+	}
+
+	conn := atomic.LoadInt64(server.connections)
+	if conn > 0 {
+		log.Printf("Waiting for %d connections to be closed", conn)
+	}
+	server.wsWG.Wait()
+
+	return err
+}
+
+func (server *Server) setupHandlers(ctx context.Context, cancel context.CancelFunc) http.Handler {
+	staticFileHandler := http.FileServer(
+		&assetfs.AssetFS{Asset: Asset, AssetDir: AssetDir, Prefix: "static"},
+	)
+
+	url := server.URL()
+	var siteMux = http.NewServeMux()
+	siteMux.HandleFunc(url.Path, server.handleIndex)
+	siteMux.Handle(url.Path+"js/", http.StripPrefix(url.Path, staticFileHandler))
+	siteMux.Handle(url.Path+"favicon.png", http.StripPrefix(url.Path, staticFileHandler))
+	siteMux.HandleFunc(url.Path+"auth_token.js", server.handleAuthToken)
+
+	siteHandler := http.Handler(siteMux)
+
+	if server.options.EnableBasicAuth {
+		log.Printf("Using Basic Authentication")
+		siteHandler = server.wrapBasicAuth(siteHandler, server.options.Credential)
+	}
+
+	siteHandler = server.wrapHeaders(siteHandler)
+
+	wsMux := http.NewServeMux()
+	wsMux.Handle("/", siteHandler)
+	wsMux.HandleFunc(url.Path+"ws", server.generateHandleWS(ctx, cancel))
+	siteHandler = http.Handler(wsMux)
+
+	return server.wrapLogger(siteHandler)
+}
+
+func (server *Server) setupHTTPServer(handler http.Handler) (*http.Server, error) {
+	url := server.URL()
+	log.Printf("URL: %s", url.String())
+
+	srv := &http.Server{
+		Addr:    url.Host,
+		Handler: handler,
+	}
+
+	if server.options.EnableTLSClientAuth {
+		tlsConfig, err := server.tlsConfig()
+		if err != nil {
+			return nil, errors.Wrapf(err, "failed to setup TLS configuration")
+		}
+		srv.TLSConfig = tlsConfig
+	}
+
+	return srv, nil
+}
+
+func (server *Server) URL() *url.URL {
+	if server.url == nil {
+		host := net.JoinHostPort(server.options.Address, server.options.Port)
+		path := ""
+		if server.options.EnableRandomUrl {
+			path += "/" + randomstring.Generate(server.options.RandomUrlLength)
+		}
+		scheme := "http"
+		if server.options.EnableTLS {
+			scheme = "https"
+		}
+		server.url = &url.URL{Scheme: scheme, Host: host, Path: path + "/"}
+	}
+	return server.url
+}
+
+func (server *Server) tlsConfig() (*tls.Config, error) {
+	caFile := homedir.Expand(server.options.TLSCACrtFile)
+	caCert, err := ioutil.ReadFile(caFile)
+	if err != nil {
+		return nil, errors.New("could not open CA crt file " + caFile)
+	}
+	caCertPool := x509.NewCertPool()
+	if !caCertPool.AppendCertsFromPEM(caCert) {
+		return nil, errors.New("could not parse CA crt file data in " + caFile)
+	}
+	tlsConfig := &tls.Config{
+		ClientCAs:  caCertPool,
+		ClientAuth: tls.RequireAndVerifyClientCert,
+	}
+	return tlsConfig, nil
+}

server/slave.go

@@ -0,0 +1,17 @@
+package server
+
+import (
+	"github.com/yudai/gotty/webtty"
+)
+
+// Slave is webtty.Slave with some additional methods.
+type Slave interface {
+	webtty.Slave
+
+	GetTerminalSize() (width int, height int, err error)
+}
+
+type Factory interface {
+	Name() string
+	New(params map[string][]string) (Slave, error)
+}

server/timer.go

@@ -0,0 +1,17 @@
+package server
+
+import (
+	"time"
+)
+
+func (server *Server) stopTimer() {
+	if server.options.Timeout > 0 {
+		server.timer.Stop()
+	}
+}
+
+func (server *Server) resetTimer() {
+	if server.options.Timeout > 0 {
+		server.timer.Reset(time.Duration(server.options.Timeout) * time.Second)
+	}
+}