├── docs
    ├── .nojekyll
    ├── CNAME
    ├── logo.png
    ├── favicon.ico
    ├── favicon-16x16.png
    ├── favicon-32x32.png
    ├── apple-touch-icon.png
    ├── _sidebar.md
    ├── faq.md
    ├── config.md
    ├── README.md
    ├── nat-traversal.md
    ├── development.md
    ├── index.html
    ├── proxy.md
    └── install.md
├── .gitignore
├── ui
    ├── src
    │   ├── global.css
    │   ├── react-app-env.d.ts
    │   ├── logo.png
    │   ├── setupTests.ts
    │   ├── Video.tsx
    │   ├── name.ts
    │   ├── url.ts
    │   ├── Router.tsx
    │   ├── useRoomID.ts
    │   ├── useConfig.ts
    │   ├── index.tsx
    │   ├── message.ts
    │   ├── LoginForm.tsx
    │   ├── RoomManage.tsx
    │   ├── serviceWorker.ts
    │   ├── useRoom.ts
    │   └── Room.tsx
    ├── public
    │   ├── favicon.ico
    │   ├── apple-touch-icon.png
    │   └── index.html
    ├── .prettierrc
    ├── .gitignore
    ├── tsconfig.json
    ├── serve.go
    └── package.json
├── users
├── ws
    ├── event.go
    ├── event_name.go
    ├── event_share.go
    ├── once.go
    ├── once_test.go
    ├── event_hostice.go
    ├── event_clientice.go
    ├── event_hostoffer.go
    ├── event_stop_share.go
    ├── event_clientanswer.go
    ├── prometheus.go
    ├── readwrite.go
    ├── event_join.go
    ├── event_disconnected.go
    ├── event_create.go
    ├── outgoing
    │   └── messages.go
    ├── rooms.go
    ├── room.go
    └── client.go
├── hack
    └── packr
    │   └── packr.go
├── Dockerfile
├── screego.config.development
├── config
    ├── mode
    │   ├── mode_test.go
    │   └── mode.go
    ├── error.go
    ├── loglevel_test.go
    ├── loglevel.go
    └── config.go
├── main.go
├── logger
    └── logger.go
├── cmd
    ├── command.go
    ├── hash.go
    └── serve.go
├── .github
    ├── FUNDING.yml
    └── workflows
    │   └── build.yml
├── turn
    ├── none.go
    ├── portrange.go
    └── server.go
├── util
    ├── password.go
    └── sillyname.go
├── go.mod
├── .golangci.yml
├── server
    ├── server.go
    └── server_test.go
├── Makefile
├── README.md
├── router
    └── router.go
├── screego.config.example
├── auth
    └── auth.go
├── .goreleaser.yml
└── go.sum


/docs/.nojekyll:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/docs/CNAME:
--------------------------------------------------------------------------------
1 | screego.net
2 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | /target
2 | /.idea
3 | *-packr.go
4 | /dist/
5 | *.local
6 | 


--------------------------------------------------------------------------------
/ui/src/global.css:
--------------------------------------------------------------------------------
1 | #root,
2 | body,
3 | html {
4 |     height: 100%;
5 | }


--------------------------------------------------------------------------------
/ui/src/react-app-env.d.ts:
--------------------------------------------------------------------------------
1 | /// <reference types="react-scripts" />
2 | 


--------------------------------------------------------------------------------
/docs/logo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/arihant-jain-09/server-1/master/docs/logo.png


--------------------------------------------------------------------------------
/ui/src/logo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/arihant-jain-09/server-1/master/ui/src/logo.png


--------------------------------------------------------------------------------
/docs/favicon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/arihant-jain-09/server-1/master/docs/favicon.ico


--------------------------------------------------------------------------------
/users:
--------------------------------------------------------------------------------
1 | # Password: admin
2 | admin:$2a$12$kNgc2ZYAXzIL6SHY.8PHAOQ8Casi0s1bKatYoG/jupt2yV1M5K5nO
3 | 


--------------------------------------------------------------------------------
/ws/event.go:
--------------------------------------------------------------------------------
1 | package ws
2 | 
3 | type Event interface {
4 | 	Execute(*Rooms, ClientInfo) error
5 | }
6 | 


--------------------------------------------------------------------------------
/docs/favicon-16x16.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/arihant-jain-09/server-1/master/docs/favicon-16x16.png


--------------------------------------------------------------------------------
/docs/favicon-32x32.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/arihant-jain-09/server-1/master/docs/favicon-32x32.png


--------------------------------------------------------------------------------
/ui/public/favicon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/arihant-jain-09/server-1/master/ui/public/favicon.ico


--------------------------------------------------------------------------------
/docs/apple-touch-icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/arihant-jain-09/server-1/master/docs/apple-touch-icon.png


--------------------------------------------------------------------------------
/ui/public/apple-touch-icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/arihant-jain-09/server-1/master/ui/public/apple-touch-icon.png


--------------------------------------------------------------------------------
/hack/packr/packr.go:
--------------------------------------------------------------------------------
1 | package main
2 | 
3 | import "github.com/gobuffalo/packr/v2/packr2/cmd"
4 | 
5 | func main() {
6 | 	cmd.Execute()
7 | }
8 | 


--------------------------------------------------------------------------------
/Dockerfile:
--------------------------------------------------------------------------------
1 | FROM scratch
2 | COPY screego /screego
3 | EXPOSE 3478/tcp
4 | EXPOSE 3478/udp
5 | EXPOSE 5050
6 | WORKDIR "/"
7 | ENTRYPOINT [ "/screego" ]
8 | CMD ["serve"]
9 | 


--------------------------------------------------------------------------------
/screego.config.development:
--------------------------------------------------------------------------------
1 | SCREEGO_SECRET=secure
2 | SCREEGO_LOG_LEVEL=debug
3 | SCREEGO_CORS_ALLOWED_ORIGINS=http://localhost:3000
4 | SCREEGO_USERS_FILE=./users
5 | SCREEGO_TURN_STRICT_AUTH=false
6 | 


--------------------------------------------------------------------------------
/docs/_sidebar.md:
--------------------------------------------------------------------------------
1 | * [Home](/)
2 | * [Installation](install.md)
3 | * [Config](config.md)
4 | * [NAT Traversal](nat-traversal.md)
5 | * [Reverse Proxy](proxy.md)
6 | * [Development](development.md)
7 | * [FAQ](faq.md)
8 | * [GitHub](https://github.com/screego/server)
9 | 


--------------------------------------------------------------------------------
/ui/src/setupTests.ts:
--------------------------------------------------------------------------------
1 | // jest-dom adds custom jest matchers for asserting on DOM nodes.
2 | // allows you to do things like:
3 | // expect(element).toHaveTextContent(/react/i)
4 | // learn more: https://github.com/testing-library/jest-dom
5 | import '@testing-library/jest-dom/extend-expect';
6 | 


--------------------------------------------------------------------------------
/ui/.prettierrc:
--------------------------------------------------------------------------------
 1 | {
 2 |   "printWidth": 100,
 3 |   "tabWidth": 4,
 4 |   "useTabs": false,
 5 |   "semi": true,
 6 |   "singleQuote": true,
 7 |   "trailingComma": "es5",
 8 |   "bracketSpacing": false,
 9 |   "jsxBracketSameLine": true,
10 |   "arrowParens": "always",
11 |   "parser": "typescript"
12 | }


--------------------------------------------------------------------------------
/config/mode/mode_test.go:
--------------------------------------------------------------------------------
 1 | package mode
 2 | 
 3 | import (
 4 | 	"testing"
 5 | 
 6 | 	"github.com/magiconair/properties/assert"
 7 | )
 8 | 
 9 | func TestGet(t *testing.T) {
10 | 	mode = Prod
11 | 	assert.Equal(t, Prod, Get())
12 | }
13 | 
14 | func TestSet(t *testing.T) {
15 | 	Set(Prod)
16 | 	assert.Equal(t, Prod, mode)
17 | }
18 | 


--------------------------------------------------------------------------------
/main.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 | 	"github.com/screego/server/cmd"
 5 | 	pmode "github.com/screego/server/config/mode"
 6 | )
 7 | 
 8 | var (
 9 | 	version    = "unknown"
10 | 	commitHash = "unknown"
11 | 	mode       = pmode.Dev
12 | )
13 | 
14 | func main() {
15 | 	pmode.Set(mode)
16 | 	cmd.Run(version, commitHash)
17 | }
18 | 


--------------------------------------------------------------------------------
/config/mode/mode.go:
--------------------------------------------------------------------------------
 1 | package mode
 2 | 
 3 | const (
 4 | 	// Dev for development mode
 5 | 	Dev = "dev"
 6 | 	// Prod for production mode
 7 | 	Prod = "prod"
 8 | )
 9 | 
10 | var mode = Dev
11 | 
12 | // Set sets the new mode.
13 | func Set(newMode string) {
14 | 	mode = newMode
15 | }
16 | 
17 | // Get returns the current mode.
18 | func Get() string {
19 | 	return mode
20 | }
21 | 


--------------------------------------------------------------------------------
/logger/logger.go:
--------------------------------------------------------------------------------
 1 | package logger
 2 | 
 3 | import (
 4 | 	"os"
 5 | 	"time"
 6 | 
 7 | 	"github.com/rs/zerolog"
 8 | 	"github.com/rs/zerolog/log"
 9 | )
10 | 
11 | // Init initializes the logger
12 | func Init(lvl zerolog.Level) {
13 | 	log.Logger = log.Output(zerolog.ConsoleWriter{Out: os.Stdout, TimeFormat: time.RFC3339}).Level(lvl)
14 | 	log.Debug().Msg("Logger initialized")
15 | }
16 | 


--------------------------------------------------------------------------------
/ui/.gitignore:
--------------------------------------------------------------------------------
 1 | # See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
 2 | 
 3 | # dependencies
 4 | /node_modules
 5 | /.pnp
 6 | .pnp.js
 7 | 
 8 | # testing
 9 | /coverage
10 | 
11 | # production
12 | /build
13 | 
14 | # misc
15 | .DS_Store
16 | .env.local
17 | .env.development.local
18 | .env.test.local
19 | .env.production.local
20 | 
21 | npm-debug.log*
22 | yarn-debug.log*
23 | yarn-error.log*
24 | 


--------------------------------------------------------------------------------
/ui/src/Video.tsx:
--------------------------------------------------------------------------------
 1 | import React from 'react';
 2 | 
 3 | export const Video = ({src, className}: {src: MediaStream; className?: string}) => {
 4 |     const [element, setElement] = React.useState<HTMLVideoElement | null>(null);
 5 | 
 6 |     React.useEffect(() => {
 7 |         if (element) {
 8 |             element.srcObject = src;
 9 |             element.play();
10 |         }
11 |     }, [element, src]);
12 | 
13 |     return <video muted ref={setElement} className={className} />;
14 | };
15 | 


--------------------------------------------------------------------------------
/ui/src/name.ts:
--------------------------------------------------------------------------------
 1 | import * as gen from 'unique-names-generator';
 2 | 
 3 | const roomConfig: gen.Config = {
 4 |     dictionaries: [gen.adjectives, gen.colors, gen.animals],
 5 |     length: 3,
 6 |     separator: '-',
 7 | };
 8 | export const randomRoomName = () => gen.uniqueNamesGenerator(roomConfig);
 9 | 
10 | export const getPermanentName = () => localStorage.getItem('screego_name') ?? undefined;
11 | export const setPermanentName = (name: string) => localStorage.setItem('screego_name', name);
12 | 


--------------------------------------------------------------------------------
/ui/src/url.ts:
--------------------------------------------------------------------------------
 1 | const {port, hostname, protocol, pathname} = window.location;
 2 | const slashes = protocol.concat('//');
 3 | const path = pathname.endsWith('/') ? pathname : pathname.substring(0, pathname.lastIndexOf('/'));
 4 | const url = slashes.concat(port ? hostname.concat(':', port) : hostname) + path;
 5 | export const urlWithSlash =
 6 |     process.env.NODE_ENV === 'development'
 7 |         ? 'http://localhost:5050/'
 8 |         : url.endsWith('/')
 9 |         ? url
10 |         : url.concat('/');
11 | 


--------------------------------------------------------------------------------
/cmd/command.go:
--------------------------------------------------------------------------------
 1 | package cmd
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"os"
 6 | 
 7 | 	"github.com/rs/zerolog/log"
 8 | 	"github.com/urfave/cli"
 9 | )
10 | 
11 | func Run(version, commitHash string) {
12 | 	app := cli.App{
13 | 		Name:    "screego",
14 | 		Version: fmt.Sprintf("%s; screego/server@%s", version, commitHash),
15 | 		Commands: []cli.Command{
16 | 			serveCmd(version),
17 | 			hashCmd,
18 | 		},
19 | 	}
20 | 	err := app.Run(os.Args)
21 | 	if err != nil {
22 | 		log.Fatal().Err(err).Msg("app error")
23 | 	}
24 | }
25 | 


--------------------------------------------------------------------------------
/config/error.go:
--------------------------------------------------------------------------------
 1 | package config
 2 | 
 3 | import "github.com/rs/zerolog"
 4 | 
 5 | // FutureLog is an intermediate type for log messages. It is used before the config was loaded because without loaded
 6 | // config we do not know the log level, so we log these messages once the config was initialized.
 7 | type FutureLog struct {
 8 | 	Level zerolog.Level
 9 | 	Msg   string
10 | }
11 | 
12 | func futureFatal(msg string) FutureLog {
13 | 	return FutureLog{
14 | 		Level: zerolog.FatalLevel,
15 | 		Msg:   msg,
16 | 	}
17 | }
18 | 


--------------------------------------------------------------------------------
/docs/faq.md:
--------------------------------------------------------------------------------
 1 | # Frequently Asked Questions
 2 | 
 3 | ## Stream doesn't load
 4 | 
 5 | Check that
 6 | * you are using https to access Screego.
 7 | * `SCREEGO_EXTERNAL_IP` is set to your external IP. See [Configuration](config.md)
 8 | * you are using TURN for NAT-Traversal. See [NAT-Traversal](nat-traversal.md). *This isn't allowed for app.screego.net, you've to self-host Screego*
 9 | * your browser doesn't block WebRTC (extensions or other settings)
10 | * you have opened ports in your firewall. By default 5050, 3478 and any UDP port when using TURN.
11 | 


--------------------------------------------------------------------------------
/ui/src/Router.tsx:
--------------------------------------------------------------------------------
 1 | import React from 'react';
 2 | import {RoomManage} from './RoomManage';
 3 | import {useRoom} from './useRoom';
 4 | import {Room} from './Room';
 5 | import {useConfig} from './useConfig';
 6 | 
 7 | export const Router = () => {
 8 |     const {room, state, ...other} = useRoom();
 9 |     const config = useConfig();
10 | 
11 |     if (config.loading) {
12 |         // show spinner
13 |         return null;
14 |     }
15 | 
16 |     if (state) {
17 |         return <Room state={state} {...other} />;
18 |     }
19 | 
20 |     return <RoomManage room={room} config={config} />;
21 | };
22 | 


--------------------------------------------------------------------------------
/config/loglevel_test.go:
--------------------------------------------------------------------------------
 1 | package config
 2 | 
 3 | import (
 4 | 	"testing"
 5 | 
 6 | 	"github.com/rs/zerolog"
 7 | 	"github.com/stretchr/testify/assert"
 8 | )
 9 | 
10 | func TestLogLevel_Decode_success(t *testing.T) {
11 | 	ll := new(LogLevel)
12 | 	err := ll.Decode("fatal")
13 | 	assert.Nil(t, err)
14 | 	assert.Equal(t, ll.AsZeroLogLevel(), zerolog.FatalLevel)
15 | }
16 | 
17 | func TestLogLevel_Decode_fail(t *testing.T) {
18 | 	ll := new(LogLevel)
19 | 	err := ll.Decode("asdasdasdasdasdasd")
20 | 	assert.EqualError(t, err, "unknown log level")
21 | 	assert.Equal(t, ll.AsZeroLogLevel(), zerolog.InfoLevel)
22 | }
23 | 


--------------------------------------------------------------------------------
/ui/tsconfig.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "compilerOptions": {
 3 |     "target": "es5",
 4 |     "lib": [
 5 |       "dom",
 6 |       "dom.iterable",
 7 |       "esnext"
 8 |     ],
 9 |     "allowJs": true,
10 |     "skipLibCheck": true,
11 |     "esModuleInterop": true,
12 |     "allowSyntheticDefaultImports": true,
13 |     "strict": true,
14 |     "forceConsistentCasingInFileNames": true,
15 |     "module": "esnext",
16 |     "moduleResolution": "node",
17 |     "resolveJsonModule": true,
18 |     "isolatedModules": true,
19 |     "noEmit": true,
20 |     "jsx": "react"
21 |   },
22 |   "include": [
23 |     "src"
24 |   ]
25 | }
26 | 


--------------------------------------------------------------------------------
/ws/event_name.go:
--------------------------------------------------------------------------------
 1 | package ws
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | )
 6 | 
 7 | func init() {
 8 | 	register("name", func() Event {
 9 | 		return &Name{}
10 | 	})
11 | }
12 | 
13 | type Name struct {
14 | 	UserName string `json:"username"`
15 | }
16 | 
17 | func (e *Name) Execute(rooms *Rooms, current ClientInfo) error {
18 | 	if current.RoomID == "" {
19 | 		return fmt.Errorf("not in a room")
20 | 	}
21 | 
22 | 	room, ok := rooms.Rooms[current.RoomID]
23 | 	if !ok {
24 | 		return fmt.Errorf("room with id %s does not exist", current.RoomID)
25 | 	}
26 | 
27 | 	room.Users[current.ID].Name = e.UserName
28 | 
29 | 	room.notifyInfoChanged()
30 | 	return nil
31 | }
32 | 


--------------------------------------------------------------------------------
/.github/FUNDING.yml:
--------------------------------------------------------------------------------
 1 | # These are supported funding model platforms
 2 | 
 3 | github: jmattheis
 4 | patreon: # Replace with a single Patreon username
 5 | open_collective: # Replace with a single Open Collective username
 6 | ko_fi: # Replace with a single Ko-fi username
 7 | tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
 8 | community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
 9 | liberapay: # Replace with a single Liberapay username
10 | issuehunt: # Replace with a single IssueHunt username
11 | otechie: # Replace with a single Otechie username
12 | custom: https://jmattheis.de/donate
13 | 


--------------------------------------------------------------------------------
/ui/public/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 |   <head>
 4 |     <meta charset="utf-8" />
 5 |     <link rel="icon" href="%PUBLIC_URL%/favicon.ico" />
 6 |     <meta name="viewport" content="width=device-width, initial-scale=1" />
 7 |     <meta name="theme-color" content="#FFFFFF" />
 8 |     <meta
 9 |       name="description"
10 |       content="Screego - screen sharing for developers"
11 |     />
12 |     <link rel="apple-touch-icon" href="%PUBLIC_URL%/apple-touch-icon.png" />
13 |     <title>Screego</title>
14 |   </head>
15 |   <body>
16 |     <noscript>Screego requires JavaScript (:</noscript>
17 |     <div id="root"></div>
18 |   </body>
19 | </html>
20 | 


--------------------------------------------------------------------------------
/config/loglevel.go:
--------------------------------------------------------------------------------
 1 | package config
 2 | 
 3 | import (
 4 | 	"errors"
 5 | 
 6 | 	"github.com/rs/zerolog"
 7 | )
 8 | 
 9 | // LogLevel type that provides helper methods for decoding.
10 | type LogLevel zerolog.Level
11 | 
12 | // Decode decodes a string to a log level.
13 | func (ll *LogLevel) Decode(value string) error {
14 | 	if level, err := zerolog.ParseLevel(value); err == nil {
15 | 		*ll = LogLevel(level)
16 | 		return nil
17 | 	}
18 | 	*ll = LogLevel(zerolog.InfoLevel)
19 | 	return errors.New("unknown log level")
20 | }
21 | 
22 | // AsZeroLogLevel converts the LogLevel to a zerolog.Level.
23 | func (ll LogLevel) AsZeroLogLevel() zerolog.Level {
24 | 	return zerolog.Level(ll)
25 | }
26 | 


--------------------------------------------------------------------------------
/turn/none.go:
--------------------------------------------------------------------------------
 1 | package turn
 2 | 
 3 | import (
 4 | 	"errors"
 5 | 	"net"
 6 | 	"strconv"
 7 | )
 8 | 
 9 | type RelayAddressGeneratorNone struct {}
10 | 
11 | func (r *RelayAddressGeneratorNone) Validate() error {
12 | 	return nil
13 | }
14 | 
15 | func (r *RelayAddressGeneratorNone) AllocatePacketConn(network string, requestedPort int) (net.PacketConn, net.Addr, error) {
16 | 	conn, err := net.ListenPacket("udp", ":"+strconv.Itoa(requestedPort))
17 | 	if err != nil {
18 | 		return nil, nil, err
19 | 	}
20 | 
21 | 	return conn, conn.LocalAddr(), nil
22 | }
23 | 
24 | func (r *RelayAddressGeneratorNone) AllocateConn(network string, requestedPort int) (net.Conn, net.Addr, error) {
25 | 	return nil, nil, errors.New("todo")
26 | }
27 | 


--------------------------------------------------------------------------------
/util/password.go:
--------------------------------------------------------------------------------
 1 | package util
 2 | 
 3 | import (
 4 | 	"crypto/rand"
 5 | 	"math/big"
 6 | )
 7 | 
 8 | func RandString(length int) string {
 9 | 	res := make([]byte, length)
10 | 	for i := range res {
11 | 		index := randIntn(len(tokenCharacters))
12 | 		res[i] = tokenCharacters[index]
13 | 	}
14 | 	return string(res)
15 | }
16 | 
17 | var (
18 | 	tokenCharacters = []byte("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.-_!@#$%^&*()){}\\/=+,.><")
19 | 	randReader      = rand.Reader
20 | )
21 | 
22 | func randIntn(n int) int {
23 | 	max := big.NewInt(int64(n))
24 | 	res, err := rand.Int(randReader, max)
25 | 	if err != nil {
26 | 		panic("random source is not available")
27 | 	}
28 | 	return int(res.Int64())
29 | }
30 | 


--------------------------------------------------------------------------------
/docs/config.md:
--------------------------------------------------------------------------------
 1 | # Config
 2 | 
 3 | !> TLS is required for Screego to work. Either enable TLS inside Screego or 
 4 |    use a reverse proxy to serve Screego via TLS.
 5 | 
 6 | Screego tries to obtain config values from different locations in sequence. 
 7 | Properties will never be overridden. Thus, the first occurrence of a setting will be used.
 8 | 
 9 | #### Order
10 | 
11 | * Environment Variables
12 | * `screego.config.local` (in same path as the binary)
13 | * `screego.config` (in same path as the binary)
14 | * `$HOME/.config/screego/server.config`
15 | * `/etc/screego/server.config`
16 | 
17 | #### Config Example
18 | 
19 | [screego.config.example](https://raw.githubusercontent.com/screego/server/master/screego.config.example ':include :type=code ini')
20 | 


--------------------------------------------------------------------------------
/ws/event_share.go:
--------------------------------------------------------------------------------
 1 | package ws
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | )
 6 | 
 7 | func init() {
 8 | 	register("share", func() Event {
 9 | 		return &StartShare{}
10 | 	})
11 | }
12 | 
13 | type StartShare struct {
14 | }
15 | 
16 | func (e *StartShare) Execute(rooms *Rooms, current ClientInfo) error {
17 | 	if current.RoomID == "" {
18 | 		return fmt.Errorf("not in a room")
19 | 	}
20 | 
21 | 	room, ok := rooms.Rooms[current.RoomID]
22 | 	if !ok {
23 | 		return fmt.Errorf("room with id %s does not exist", current.RoomID)
24 | 	}
25 | 
26 | 	room.Users[current.ID].Streaming = true
27 | 
28 | 	for _, user := range room.Users {
29 | 		if current.ID == user.ID {
30 | 			continue
31 | 		}
32 | 		room.newSession(current.ID, user.ID, rooms)
33 | 	}
34 | 
35 | 	room.notifyInfoChanged()
36 | 	return nil
37 | }
38 | 


--------------------------------------------------------------------------------
/go.mod:
--------------------------------------------------------------------------------
 1 | module github.com/screego/server
 2 | 
 3 | go 1.14
 4 | 
 5 | require (
 6 | 	github.com/gobuffalo/packr/v2 v2.2.0
 7 | 	github.com/gorilla/handlers v1.5.1
 8 | 	github.com/gorilla/mux v1.7.2
 9 | 	github.com/gorilla/sessions v1.2.1
10 | 	github.com/gorilla/websocket v1.4.0
11 | 	github.com/joho/godotenv v1.3.0
12 | 	github.com/kelseyhightower/envconfig v1.4.0
13 | 	github.com/kr/pretty v0.2.0 // indirect
14 | 	github.com/magiconair/properties v1.8.1
15 | 	github.com/phayes/freeport v0.0.0-20180830031419-95f893ade6f2
16 | 	github.com/pion/randutil v0.1.0
17 | 	github.com/pion/turn/v2 v2.0.5
18 | 	github.com/prometheus/client_golang v1.7.1
19 | 	github.com/rs/xid v1.2.1
20 | 	github.com/rs/zerolog v1.19.0
21 | 	github.com/stretchr/testify v1.6.1
22 | 	github.com/urfave/cli v1.20.0
23 | 	golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9
24 | )
25 | 


--------------------------------------------------------------------------------
/ws/once.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2009 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | package ws
 6 | 
 7 | import (
 8 | 	"sync"
 9 | 	"sync/atomic"
10 | )
11 | 
12 | // Modified version of sync.Once (https://github.com/golang/go/blob/master/src/sync/once.go)
13 | // This version unlocks the mutex early and therefore doesn't hold the lock while executing func f().
14 | type once struct {
15 | 	m    sync.Mutex
16 | 	done uint32
17 | }
18 | 
19 | func (o *once) Do(f func()) {
20 | 	if atomic.LoadUint32(&o.done) == 1 {
21 | 		return
22 | 	}
23 | 	if o.mayExecute() {
24 | 		f()
25 | 	}
26 | }
27 | 
28 | func (o *once) mayExecute() bool {
29 | 	o.m.Lock()
30 | 	defer o.m.Unlock()
31 | 	if o.done == 0 {
32 | 		atomic.StoreUint32(&o.done, 1)
33 | 		return true
34 | 	}
35 | 	return false
36 | }
37 | 


--------------------------------------------------------------------------------
/ws/once_test.go:
--------------------------------------------------------------------------------
 1 | package ws
 2 | 
 3 | import (
 4 | 	"testing"
 5 | 	"time"
 6 | 
 7 | 	"github.com/stretchr/testify/assert"
 8 | )
 9 | 
10 | func Test_Execute(t *testing.T) {
11 | 	executeOnce := once{}
12 | 	execution := make(chan struct{})
13 | 	fExecute := func() {
14 | 		execution <- struct{}{}
15 | 	}
16 | 	go executeOnce.Do(fExecute)
17 | 	go executeOnce.Do(fExecute)
18 | 
19 | 	select {
20 | 	case <-execution:
21 | 		// expected
22 | 	case <-time.After(100 * time.Millisecond):
23 | 		t.Fatal("fExecute should be executed once")
24 | 	}
25 | 
26 | 	select {
27 | 	case <-execution:
28 | 		t.Fatal("should only execute once")
29 | 	case <-time.After(100 * time.Millisecond):
30 | 		// expected
31 | 	}
32 | 
33 | 	assert.False(t, executeOnce.mayExecute())
34 | 
35 | 	go executeOnce.Do(fExecute)
36 | 
37 | 	select {
38 | 	case <-execution:
39 | 		t.Fatal("should only execute once")
40 | 	case <-time.After(100 * time.Millisecond):
41 | 		// expected
42 | 	}
43 | }
44 | 


--------------------------------------------------------------------------------
/ws/event_hostice.go:
--------------------------------------------------------------------------------
 1 | package ws
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"github.com/rs/zerolog/log"
 6 | 	"github.com/screego/server/ws/outgoing"
 7 | )
 8 | 
 9 | func init() {
10 | 	register("hostice", func() Event {
11 | 		return &HostICE{}
12 | 	})
13 | }
14 | 
15 | type HostICE outgoing.P2PMessage
16 | 
17 | func (e *HostICE) Execute(rooms *Rooms, current ClientInfo) error {
18 | 	if current.RoomID == "" {
19 | 		return fmt.Errorf("not in a room")
20 | 	}
21 | 
22 | 	room, ok := rooms.Rooms[current.RoomID]
23 | 	if !ok {
24 | 		return fmt.Errorf("room with id %s does not exist", current.RoomID)
25 | 	}
26 | 
27 | 	session, ok := room.Sessions[e.SID]
28 | 
29 | 	if !ok {
30 | 		log.Debug().Str("id", e.SID.String()).Msg("unknown session")
31 | 		return nil
32 | 	}
33 | 
34 | 	if session.Host != current.ID {
35 | 		return fmt.Errorf("permission denied for session %s", e.SID)
36 | 	}
37 | 
38 | 	room.Users[session.Client].Write <- outgoing.HostICE(*e)
39 | 
40 | 	return nil
41 | }
42 | 


--------------------------------------------------------------------------------
/ws/event_clientice.go:
--------------------------------------------------------------------------------
 1 | package ws
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"github.com/rs/zerolog/log"
 6 | 	"github.com/screego/server/ws/outgoing"
 7 | )
 8 | 
 9 | func init() {
10 | 	register("clientice", func() Event {
11 | 		return &ClientICE{}
12 | 	})
13 | }
14 | 
15 | type ClientICE outgoing.P2PMessage
16 | 
17 | func (e *ClientICE) Execute(rooms *Rooms, current ClientInfo) error {
18 | 	if current.RoomID == "" {
19 | 		return fmt.Errorf("not in a room")
20 | 	}
21 | 
22 | 	room, ok := rooms.Rooms[current.RoomID]
23 | 	if !ok {
24 | 		return fmt.Errorf("room with id %s does not exist", current.RoomID)
25 | 	}
26 | 
27 | 	session, ok := room.Sessions[e.SID]
28 | 
29 | 	if !ok {
30 | 		log.Debug().Str("id", e.SID.String()).Msg("unknown session")
31 | 		return nil
32 | 	}
33 | 
34 | 	if session.Client != current.ID {
35 | 		return fmt.Errorf("permission denied for session %s", e.SID)
36 | 	}
37 | 
38 | 	room.Users[session.Host].Write <- outgoing.ClientICE(*e)
39 | 
40 | 	return nil
41 | }
42 | 


--------------------------------------------------------------------------------
/ws/event_hostoffer.go:
--------------------------------------------------------------------------------
 1 | package ws
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"github.com/rs/zerolog/log"
 6 | 	"github.com/screego/server/ws/outgoing"
 7 | )
 8 | 
 9 | func init() {
10 | 	register("hostoffer", func() Event {
11 | 		return &HostOffer{}
12 | 	})
13 | }
14 | 
15 | type HostOffer outgoing.P2PMessage
16 | 
17 | func (e *HostOffer) Execute(rooms *Rooms, current ClientInfo) error {
18 | 	if current.RoomID == "" {
19 | 		return fmt.Errorf("not in a room")
20 | 	}
21 | 
22 | 	room, ok := rooms.Rooms[current.RoomID]
23 | 	if !ok {
24 | 		return fmt.Errorf("room with id %s does not exist", current.RoomID)
25 | 	}
26 | 
27 | 	session, ok := room.Sessions[e.SID]
28 | 
29 | 	if !ok {
30 | 		log.Debug().Str("id", e.SID.String()).Msg("unknown session")
31 | 		return nil
32 | 	}
33 | 
34 | 	if session.Host != current.ID {
35 | 		return fmt.Errorf("permission denied for session %s", e.SID)
36 | 	}
37 | 
38 | 	room.Users[session.Client].Write <- outgoing.HostOffer(*e)
39 | 
40 | 	return nil
41 | }
42 | 


--------------------------------------------------------------------------------
/ws/event_stop_share.go:
--------------------------------------------------------------------------------
 1 | package ws
 2 | 
 3 | import (
 4 | 	"bytes"
 5 | 	"fmt"
 6 | 
 7 | 	"github.com/screego/server/ws/outgoing"
 8 | )
 9 | 
10 | func init() {
11 | 	register("stopshare", func() Event {
12 | 		return &StopShare{}
13 | 	})
14 | }
15 | 
16 | type StopShare struct {
17 | }
18 | 
19 | func (e *StopShare) Execute(rooms *Rooms, current ClientInfo) error {
20 | 	if current.RoomID == "" {
21 | 		return fmt.Errorf("not in a room")
22 | 	}
23 | 
24 | 	room, ok := rooms.Rooms[current.RoomID]
25 | 	if !ok {
26 | 		return fmt.Errorf("room with id %s does not exist", current.RoomID)
27 | 	}
28 | 
29 | 	room.Users[current.ID].Streaming = false
30 | 	for id, session := range room.Sessions {
31 | 		if bytes.Equal(session.Host.Bytes(), current.ID.Bytes()) {
32 | 			client, ok := room.Users[session.Client]
33 | 			if ok {
34 | 				client.Write <- outgoing.EndShare(id)
35 | 			}
36 | 			room.closeSession(rooms, id)
37 | 		}
38 | 	}
39 | 
40 | 	room.notifyInfoChanged()
41 | 	return nil
42 | }
43 | 


--------------------------------------------------------------------------------
/ws/event_clientanswer.go:
--------------------------------------------------------------------------------
 1 | package ws
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"github.com/rs/zerolog/log"
 6 | 	"github.com/screego/server/ws/outgoing"
 7 | )
 8 | 
 9 | func init() {
10 | 	register("clientanswer", func() Event {
11 | 		return &ClientAnswer{}
12 | 	})
13 | }
14 | 
15 | type ClientAnswer outgoing.P2PMessage
16 | 
17 | func (e *ClientAnswer) Execute(rooms *Rooms, current ClientInfo) error {
18 | 	if current.RoomID == "" {
19 | 		return fmt.Errorf("not in a room")
20 | 	}
21 | 
22 | 	room, ok := rooms.Rooms[current.RoomID]
23 | 	if !ok {
24 | 		return fmt.Errorf("room with id %s does not exist", current.RoomID)
25 | 	}
26 | 
27 | 	session, ok := room.Sessions[e.SID]
28 | 
29 | 	if !ok {
30 | 		log.Debug().Str("id", e.SID.String()).Msg("unknown session")
31 | 		return nil
32 | 	}
33 | 
34 | 	if session.Client != current.ID {
35 | 		return fmt.Errorf("permission denied for session %s", e.SID)
36 | 	}
37 | 
38 | 	room.Users[session.Host].Write <- outgoing.ClientAnswer(*e)
39 | 
40 | 	return nil
41 | }
42 | 


--------------------------------------------------------------------------------
/docs/README.md:
--------------------------------------------------------------------------------
 1 | # screego/server
 2 | 
 3 | In the past I've had some problems sharing my screen with coworkers using
 4 | corporate chatting solutions like Microsoft Teams. I wanted to show them some
 5 | of my code, but either the stream lagged several seconds behind or the quality
 6 | was so poor that my colleagues couldn't read the code. Or both.
 7 | 
 8 | That's why I created screego. It allows you to share your screen with good
 9 | quality and low latency. Screego is an addition to existing software and 
10 | only helps to share your screen. Nothing else (:.
11 | 
12 | ## Features
13 | 
14 | * Multi User Screenshare
15 | * Secure transfer via WebRTC
16 | * Low latency / High resolution
17 | * Simple Install via [Docker](https://hub.docker.com/r/screego/server) / single binary
18 | * Integrated [TURN](nat-traversal.md) Server see [NAT Traversal](nat-traversal.md)
19 | 
20 | ---
21 | 
22 | [Demo / Public Instance](https://app.screego.net/) ᛫ [Installation](https://screego.net/#/install) ᛫ [Configuration](https://screego.net/#/config) 
23 | 


--------------------------------------------------------------------------------
/.golangci.yml:
--------------------------------------------------------------------------------
 1 | inters:
 2 |   enable:
 3 |   - asciicheck
 4 |   - bodyclose
 5 |   - deadcode
 6 |   - depguard
 7 |   - dogsled
 8 |   - dupl
 9 |   - errcheck
10 |   - exhaustive
11 |   - exportloopref
12 |   - gci
13 |   - gocritic
14 |   - godot
15 |   - goerr113
16 |   - gofmt
17 |   - gofumpt
18 |   - goimports
19 |   - golint
20 |   - gomodguard
21 |   - goprintffuncname
22 |   - gosec
23 |   - gosimple
24 |   - govet
25 |   - ineffassign
26 |   - interfacer
27 |   - misspell
28 |   - nakedret
29 |   - nolintlint
30 |   - prealloc
31 |   - rowserrcheck
32 |   - scopelint
33 |   - sqlclosecheck
34 |   - staticcheck
35 |   - structcheck
36 |   - stylecheck
37 |   - typecheck
38 |   - unconvert
39 |   - unparam
40 |   - unused
41 |   - varcheck
42 |   - whitespace
43 |   disable:
44 |   - funlen
45 |   - gochecknoglobals
46 |   - gocognit
47 |   - goconst
48 |   - gocyclo
49 |   - godox
50 |   - gomnd
51 |   - lll
52 |   - maligned
53 |   - nestif
54 |   - nlreturn
55 |   - noctx
56 |   - testpackage
57 |   - wsl
58 | 
59 | linters-settings:
60 |   gofumpt:
61 |     extra-rules: true
62 |   goimports:
63 |     local-prefixes: github.com/screego/server
64 |   misspell:
65 |     locale: US
66 | 


--------------------------------------------------------------------------------
/ws/prometheus.go:
--------------------------------------------------------------------------------
 1 | package ws
 2 | 
 3 | import (
 4 | 	"github.com/prometheus/client_golang/prometheus"
 5 | 	"github.com/prometheus/client_golang/prometheus/promauto"
 6 | )
 7 | 
 8 | var (
 9 | 	roomsCreatedTotal = promauto.NewCounter(prometheus.CounterOpts{
10 | 		Name: "screego_room_created_total",
11 | 		Help: "The total number of rooms created",
12 | 	})
13 | 	roomsClosedTotal = promauto.NewCounter(prometheus.CounterOpts{
14 | 		Name: "screego_room_closed_total",
15 | 		Help: "The total number of rooms closed",
16 | 	})
17 | 	usersJoinedTotal = promauto.NewCounter(prometheus.CounterOpts{
18 | 		Name: "screego_user_joined_total",
19 | 		Help: "The total number of users joined",
20 | 	})
21 | 	usersLeftTotal = promauto.NewCounter(prometheus.CounterOpts{
22 | 		Name: "screego_user_left_total",
23 | 		Help: "The total number of users left",
24 | 	})
25 | 	sessionCreatedTotal = promauto.NewCounter(prometheus.CounterOpts{
26 | 		Name: "screego_session_created_total",
27 | 		Help: "The total number of sessions created",
28 | 	})
29 | 	sessionClosedTotal = promauto.NewCounter(prometheus.CounterOpts{
30 | 		Name: "screego_session_closed_total",
31 | 		Help: "The total number of sessions closed",
32 | 	})
33 | )
34 | 


--------------------------------------------------------------------------------
/ui/src/useRoomID.ts:
--------------------------------------------------------------------------------
 1 | import React from 'react';
 2 | 
 3 | const getRoomFromURL = (search: string): string | undefined =>
 4 |     search
 5 |         .slice(1)
 6 |         .split('&')
 7 |         .find((param) => param.startsWith('room='))
 8 |         ?.split('=')[1];
 9 | 
10 | export const useRoomID = (): [string | undefined, (v?: string) => void] => {
11 |     const [state, setState] = React.useState<string | undefined>(() =>
12 |         getRoomFromURL(window.location.search)
13 |     );
14 |     React.useEffect(() => {
15 |         const onChange = (): void => setState(getRoomFromURL(window.location.search));
16 |         window.addEventListener('popstate', onChange);
17 |         return () => window.removeEventListener('popstate', onChange);
18 |     }, [setState]);
19 |     return [
20 |         state,
21 |         React.useCallback(
22 |             (id) =>
23 |                 setState((oldId?: string) => {
24 |                     if (oldId !== id) {
25 |                         window.history.pushState({roomId: id}, '', id ? `?room=${id}` : '?');
26 |                     }
27 |                     return id;
28 |                 }),
29 |             [setState]
30 |         ),
31 |     ];
32 | };
33 | 


--------------------------------------------------------------------------------
/ws/readwrite.go:
--------------------------------------------------------------------------------
 1 | package ws
 2 | 
 3 | import (
 4 | 	"encoding/json"
 5 | 	"errors"
 6 | 	"fmt"
 7 | 	"io"
 8 | 
 9 | 	"github.com/screego/server/ws/outgoing"
10 | )
11 | 
12 | type Typed struct {
13 | 	Type    string          `json:"type"`
14 | 	Payload json.RawMessage `json:"payload"`
15 | }
16 | 
17 | func ToTypedOutgoing(outgoing outgoing.Message) (Typed, error) {
18 | 	payload, err := json.Marshal(outgoing)
19 | 	if err != nil {
20 | 		return Typed{}, err
21 | 	}
22 | 	return Typed{
23 | 		Type:    outgoing.Type(),
24 | 		Payload: payload,
25 | 	}, nil
26 | }
27 | 
28 | func ReadTypedIncoming(r io.Reader) (Event, error) {
29 | 	typed := Typed{}
30 | 	if err := json.NewDecoder(r).Decode(&typed); err != nil {
31 | 		return nil, fmt.Errorf("%s e", err)
32 | 	}
33 | 
34 | 	create, ok := provider[typed.Type]
35 | 
36 | 	if !ok {
37 | 		return nil, errors.New("cannot handle " + typed.Type)
38 | 	}
39 | 
40 | 	payload := create()
41 | 
42 | 	if err := json.Unmarshal(typed.Payload, payload); err != nil {
43 | 		return nil, fmt.Errorf("incoming payload %s", err)
44 | 	}
45 | 	return payload, nil
46 | }
47 | 
48 | var provider = map[string]func() Event{}
49 | 
50 | func register(t string, incoming func() Event) {
51 | 	provider[t] = incoming
52 | }
53 | 


--------------------------------------------------------------------------------
/cmd/hash.go:
--------------------------------------------------------------------------------
 1 | package cmd
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"os"
 6 | 	"syscall"
 7 | 
 8 | 	"github.com/rs/zerolog"
 9 | 	"github.com/rs/zerolog/log"
10 | 	"github.com/screego/server/logger"
11 | 	"github.com/urfave/cli"
12 | 	"golang.org/x/crypto/bcrypt"
13 | 	"golang.org/x/crypto/ssh/terminal"
14 | )
15 | 
16 | var hashCmd = cli.Command{
17 | 	Name: "hash",
18 | 	Flags: []cli.Flag{
19 | 		&cli.StringFlag{Name: "name"},
20 | 		&cli.StringFlag{Name: "pass"},
21 | 	},
22 | 	Action: func(ctx *cli.Context) {
23 | 		logger.Init(zerolog.ErrorLevel)
24 | 		name := ctx.String("name")
25 | 		pass := []byte(ctx.String("pass"))
26 | 		if name == "" {
27 | 			log.Fatal().Msg("--name must be set")
28 | 		}
29 | 
30 | 		if len(pass) == 0 {
31 | 			var err error
32 | 			_, _ = fmt.Fprint(os.Stderr, "Enter Password: ")
33 | 			pass, err = terminal.ReadPassword(int(syscall.Stdin))
34 | 			if err != nil {
35 | 				log.Fatal().Err(err).Msg("could not read stdin")
36 | 			}
37 | 			_, _ = fmt.Fprintln(os.Stderr, "")
38 | 		}
39 | 		hashedPw, err := bcrypt.GenerateFromPassword(pass, 12)
40 | 		if err != nil {
41 | 			log.Fatal().Err(err).Msg("could not generate password")
42 | 		}
43 | 
44 | 		fmt.Printf("%s:%s", name, string(hashedPw))
45 | 		fmt.Println("")
46 | 	},
47 | }
48 | 


--------------------------------------------------------------------------------
/ws/event_join.go:
--------------------------------------------------------------------------------
 1 | package ws
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 
 6 | 	"github.com/screego/server/util"
 7 | )
 8 | 
 9 | func init() {
10 | 	register("join", func() Event {
11 | 		return &Join{}
12 | 	})
13 | }
14 | 
15 | type Join struct {
16 | 	ID       string `json:"id"`
17 | 	UserName string `json:"username,omitempty"`
18 | 	Password string `json:"password,omitempty"`
19 | }
20 | 
21 | func (e *Join) Execute(rooms *Rooms, current ClientInfo) error {
22 | 	if current.RoomID != "" {
23 | 		return fmt.Errorf("cannot join room, you are already in one")
24 | 	}
25 | 
26 | 	room, ok := rooms.Rooms[e.ID]
27 | 	if !ok {
28 | 		return fmt.Errorf("room with id %s does not exist", e.ID)
29 | 	}
30 | 	name := e.UserName
31 | 	if current.Authenticated {
32 | 		name = current.AuthenticatedUser
33 | 	}
34 | 	if name == "" {
35 | 		name = util.NewName()
36 | 	}
37 | 
38 | 	room.Users[current.ID] = &User{
39 | 		ID:        current.ID,
40 | 		Name:      name,
41 | 		Streaming: false,
42 | 		Owner:     false,
43 | 		Addr:      current.Addr,
44 | 		Write:     current.Write,
45 | 		Close:     current.Close,
46 | 	}
47 | 	room.notifyInfoChanged()
48 | 	usersJoinedTotal.Inc()
49 | 
50 | 	for _, user := range room.Users {
51 | 		if current.ID == user.ID || !user.Streaming {
52 | 			continue
53 | 		}
54 | 		room.newSession(user.ID, current.ID, rooms)
55 | 	}
56 | 
57 | 	return nil
58 | }
59 | 


--------------------------------------------------------------------------------
/ui/serve.go:
--------------------------------------------------------------------------------
 1 | package ui
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"net/http"
 6 | 
 7 | 	"github.com/gobuffalo/packr/v2"
 8 | 	"github.com/gorilla/mux"
 9 | )
10 | 
11 | var box = packr.New("ui", "build/")
12 | 
13 | // Register registers the ui on the root path.
14 | func Register(r *mux.Router) {
15 | 	r.Handle("/", serveFile("index.html", "text/html", box))
16 | 	r.Handle("/index.html", serveFile("index.html", "text/html", box))
17 | 	r.Handle("/manifest.json", serveFile("manifest.json", "application/json", box))
18 | 	r.Handle("/service-worker.js", serveFile("service-worker.js", "text/javascript", box))
19 | 	r.Handle("/assets-manifest.json", serveFile("asserts-manifest.json", "application/json", box))
20 | 	r.Handle("/static/{type}/{resource}", http.FileServer(box))
21 | 
22 | 	r.Handle("/favicon.ico", serveFile("favicon.ico", "image/x-icon", box))
23 | 	for _, size := range []string{"16x16", "32x32", "192x192", "256x256"} {
24 | 		fileName := fmt.Sprintf("/favicon-%s.png", size)
25 | 		r.Handle(fileName, serveFile(fileName, "image/png", box))
26 | 	}
27 | }
28 | 
29 | func serveFile(name, contentType string, box *packr.Box) http.HandlerFunc {
30 | 	return func(writer http.ResponseWriter, reg *http.Request) {
31 | 		writer.Header().Set("Content-Type", contentType)
32 | 		content, err := box.Find(name)
33 | 		if err != nil {
34 | 			panic(err)
35 | 		}
36 | 		_, _ = writer.Write(content)
37 | 	}
38 | }
39 | 


--------------------------------------------------------------------------------
/turn/portrange.go:
--------------------------------------------------------------------------------
 1 | package turn
 2 | 
 3 | import (
 4 | 	"errors"
 5 | 	"fmt"
 6 | 	"net"
 7 | 
 8 | 	"github.com/pion/randutil"
 9 | )
10 | 
11 | type RelayAddressGeneratorPortRange struct {
12 | 	MinPort uint16
13 | 	MaxPort uint16
14 | 	Rand randutil.MathRandomGenerator
15 | }
16 | 
17 | func (r *RelayAddressGeneratorPortRange) Validate() error {
18 | 	if r.Rand == nil {
19 | 		r.Rand = randutil.NewMathRandomGenerator()
20 | 	}
21 | 
22 | 	return nil
23 | }
24 | 
25 | func (r *RelayAddressGeneratorPortRange) AllocatePacketConn(network string, requestedPort int) (net.PacketConn, net.Addr, error) {
26 | 	if requestedPort != 0 {
27 | 		conn, err := net.ListenPacket("udp", fmt.Sprintf(":%d", requestedPort))
28 | 		if err != nil {
29 | 			return nil, nil, err
30 | 		}
31 | 		relayAddr := conn.LocalAddr().(*net.UDPAddr)
32 | 		return conn, relayAddr, nil
33 | 	}
34 | 
35 | 	for try := 0; try < 10; try++ {
36 | 		port := r.MinPort + uint16(r.Rand.Intn(int((r.MaxPort+1)-r.MinPort)))
37 | 		conn, err := net.ListenPacket("udp", fmt.Sprintf(":%d", port))
38 | 		if err != nil {
39 | 			continue
40 | 		}
41 | 
42 | 		relayAddr := conn.LocalAddr().(*net.UDPAddr)
43 | 		return conn, relayAddr, nil
44 | 	}
45 | 
46 | 	return nil, nil, errors.New("max retries exceeded")
47 | }
48 | 
49 | func (r *RelayAddressGeneratorPortRange) AllocateConn(network string, requestedPort int) (net.Conn, net.Addr, error) {
50 | 	return nil, nil, errors.New("todo")
51 | }
52 | 


--------------------------------------------------------------------------------
/ws/event_disconnected.go:
--------------------------------------------------------------------------------
 1 | package ws
 2 | 
 3 | import (
 4 | 	"bytes"
 5 | 	"github.com/screego/server/ws/outgoing"
 6 | )
 7 | 
 8 | type Disconnected struct {
 9 | }
10 | 
11 | func (e *Disconnected) Execute(rooms *Rooms, current ClientInfo) error {
12 | 	if current.RoomID == "" {
13 | 		return nil
14 | 	}
15 | 
16 | 	room, ok := rooms.Rooms[current.RoomID]
17 | 	if !ok {
18 | 		// room may already be removed
19 | 		return nil
20 | 	}
21 | 
22 | 	user, ok := room.Users[current.ID]
23 | 
24 | 	if !ok {
25 | 		// room may already be removed
26 | 		return nil
27 | 	}
28 | 
29 | 	current.Close <- CloseDone
30 | 	delete(room.Users, current.ID)
31 | 	usersLeftTotal.Inc()
32 | 
33 | 	for id, session := range room.Sessions {
34 | 		if bytes.Equal(session.Client.Bytes(), current.ID.Bytes()) {
35 | 			host, ok := room.Users[session.Host]
36 | 			if ok {
37 | 				host.Write <- outgoing.EndShare(id)
38 | 			}
39 | 			room.closeSession(rooms, id)
40 | 		}
41 | 		if bytes.Equal(session.Host.Bytes(), current.ID.Bytes()) {
42 | 			client, ok := room.Users[session.Client]
43 | 			if ok {
44 | 				client.Write <- outgoing.EndShare(id)
45 | 			}
46 | 			room.closeSession(rooms, id)
47 | 		}
48 | 	}
49 | 
50 | 	if user.Owner && room.CloseOnOwnerLeave {
51 | 		for _, member := range room.Users {
52 | 			member.Close <- CloseOwnerLeft
53 | 		}
54 | 		rooms.closeRoom(current.RoomID)
55 | 		return nil
56 | 	}
57 | 
58 | 	if len(room.Users) == 0 {
59 | 		rooms.closeRoom(current.RoomID)
60 | 		return nil
61 | 	}
62 | 
63 | 	room.notifyInfoChanged()
64 | 
65 | 	return nil
66 | }
67 | 


--------------------------------------------------------------------------------
/docs/nat-traversal.md:
--------------------------------------------------------------------------------
 1 | # NAT Traversal
 2 | 
 3 | In most cases peers cannot directly communicate with each other because of firewalls or other restrictions like NAT.
 4 | To work around this issue, WebRTC uses 
 5 | [Interactive Connectivity Establishment (ICE)](http://en.wikipedia.org/wiki/Interactive_Connectivity_Establishment).
 6 | This is a framework for helping to connect peers.
 7 | 
 8 | ICE uses STUN and/or TURN servers to accomplish this.
 9 | 
10 | ?> Screego exposes a STUN and TURN server. You don't have to configure this separately.
11 |    By default, user authentication is required for using TURN.
12 | 
13 | ## STUN
14 | 
15 | [Session Traversal Utilities for NAT (STUN)](http://en.wikipedia.org/wiki/STUN) is used to find
16 | the public / external ip of a peer. This IP is later sent to others to create a direct connection.
17 | 
18 | When STUN is used, only the connection enstablishment will be done through Screego. The actual video stream will be
19 | directly sent to the other peer and doesn't go through Screego.
20 | 
21 | While STUN should work for most cases, there are stricter NATs f.ex. 
22 | [Symmetric NATs](https://en.wikipedia.org/wiki/Network_address_translation) 
23 | where it doesn't, then, TURN will be used.
24 | 
25 | ## TURN
26 | 
27 | [Traversal Using Relays around NAT (TURN)](http://en.wikipedia.org/wiki/TURN) is used to work around Symmetric NATs.
28 | It does it by relaying all data through a TURN server. As relaying will create traffic on the server,
29 | Screego will require user authentication to use the TURN server. This can be configured see [Configuration](config.md).
30 | 
31 | 


--------------------------------------------------------------------------------
/cmd/serve.go:
--------------------------------------------------------------------------------
 1 | package cmd
 2 | 
 3 | import (
 4 | 	mrand "math/rand"
 5 | 	"os"
 6 | 	"time"
 7 | 
 8 | 	"github.com/rs/zerolog"
 9 | 	"github.com/rs/zerolog/log"
10 | 	"github.com/screego/server/auth"
11 | 	"github.com/screego/server/config"
12 | 	"github.com/screego/server/logger"
13 | 	"github.com/screego/server/router"
14 | 	"github.com/screego/server/server"
15 | 	"github.com/screego/server/turn"
16 | 	"github.com/screego/server/ws"
17 | 	"github.com/urfave/cli"
18 | )
19 | 
20 | func serveCmd(version string) cli.Command {
21 | 	return cli.Command{
22 | 		Name: "serve",
23 | 		Action: func(ctx *cli.Context) {
24 | 
25 | 			mrand.Seed(time.Now().Unix())
26 | 			conf, errs := config.Get()
27 | 			logger.Init(conf.LogLevel.AsZeroLogLevel())
28 | 
29 | 			exit := false
30 | 			for _, err := range errs {
31 | 				log.WithLevel(err.Level).Msg(err.Msg)
32 | 				exit = exit || err.Level == zerolog.FatalLevel || err.Level == zerolog.PanicLevel
33 | 			}
34 | 			if exit {
35 | 				os.Exit(1)
36 | 			}
37 | 			users, err := auth.ReadPasswordsFile(conf.UsersFile, conf.Secret)
38 | 			if err != nil {
39 | 				log.Fatal().Str("file", conf.UsersFile).Err(err).Msg("While loading users file")
40 | 			}
41 | 
42 | 			auth, err := turn.Start(conf)
43 | 			if err != nil {
44 | 				log.Fatal().Err(err).Msg("could not start turn server")
45 | 			}
46 | 
47 | 			rooms := ws.NewRooms(auth, users, conf)
48 | 
49 | 			go rooms.Start()
50 | 
51 | 			r := router.Router(conf, rooms, users, version)
52 | 			if err := server.Start(r, conf.ServerAddress, conf.TLSCertFile, conf.TLSKeyFile); err != nil {
53 | 				log.Fatal().Err(err).Msg("http server")
54 | 			}
55 | 		},
56 | 	}
57 | }
58 | 


--------------------------------------------------------------------------------
/ui/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "ui",
 3 |   "version": "0.1.0",
 4 |   "homepage": ".",
 5 |   "private": true,
 6 |   "dependencies": {
 7 |     "@material-ui/core": "^4.11.0",
 8 |     "@material-ui/icons": "^4.9.1",
 9 |     "@testing-library/jest-dom": "^4.2.4",
10 |     "@testing-library/react": "^9.3.2",
11 |     "@testing-library/user-event": "^7.1.2",
12 |     "@types/jest": "^24.0.0",
13 |     "@types/node": "^12.0.0",
14 |     "@types/react": "^16.9.0",
15 |     "@types/react-dom": "^16.9.0",
16 |     "notistack": "^1.0.0",
17 |     "prettier": "^2.1.2",
18 |     "react": "^16.13.1",
19 |     "react-dom": "^16.13.1",
20 |     "react-router": "^5.2.0",
21 |     "react-router-dom": "^5.2.0",
22 |     "react-scripts": "3.4.1",
23 |     "typescript": "~3.7.2",
24 |     "unique-names-generator": "^4.3.0",
25 |     "use-http": "^1.0.13"
26 |   },
27 |   "proxy": "http://localhost:5050",
28 |   "scripts": {
29 |     "start": "react-scripts start",
30 |     "format": "prettier \"src/**/*.{ts,tsx}\" --write",
31 |     "testformat": "prettier \"src/**/*.{ts,tsx}\" --list-different",
32 |     "build": "react-scripts --max-old-space-size=3000 build",
33 |     "test": "react-scripts test",
34 |     "eject": "react-scripts eject"
35 |   },
36 |   "eslintConfig": {
37 |     "extends": "react-app"
38 |   },
39 |   "browserslist": {
40 |     "production": [
41 |       ">0.2%",
42 |       "not dead",
43 |       "not op_mini all"
44 |     ],
45 |     "development": [
46 |       "last 1 chrome version",
47 |       "last 1 firefox version",
48 |       "last 1 safari version"
49 |     ]
50 |   },
51 |   "devDependencies": {
52 |     "@types/react-router": "^5.1.8",
53 |     "@types/react-router-dom": "^5.1.5"
54 |   }
55 | }
56 | 


--------------------------------------------------------------------------------
/.github/workflows/build.yml:
--------------------------------------------------------------------------------
 1 | name: build
 2 | on: [push, pull_request]
 3 | 
 4 | jobs:
 5 |   screego:
 6 |     runs-on: ubuntu-latest
 7 |     steps:
 8 |       - uses: actions/setup-go@v2
 9 |         with:
10 |           go-version: 1.15.x
11 |       - uses: actions/setup-node@v1
12 |       - uses: actions/cache@v2
13 |         with:
14 |           path: ~/go/pkg/mod
15 |           key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
16 |           restore-keys: |
17 |             ${{ runner.os }}-go-
18 |       - uses: actions/cache@v2
19 |         with:
20 |           path: |
21 |             ui/node_modules
22 |           key: ${{ runner.os }}-node_modules-${{ hashFiles('**/yarn.lock') }}
23 |           restore-keys: ${{ runner.os }}-node_modules-
24 |       - uses: actions/checkout@v2
25 |       - run: go mod download
26 |       - run: (cd ui && yarn)
27 |       - run: (cd ui && yarn build)
28 |       - run: (cd ui && yarn testformat)
29 |       - uses: golangci/golangci-lint-action@v2
30 |         with:
31 |           version: v1.31
32 |       - run: go build ./...
33 |       - run: go test -race ./...
34 |       - if: startsWith(github.ref, 'refs/tags/v')
35 |         run: echo "$DOCKER_PASS" | docker login --username "$DOCKER_USER" --password-stdin
36 |         env:
37 |           DOCKER_USER: ${{ secrets.DOCKER_USER }}
38 |           DOCKER_PASS: ${{ secrets.DOCKER_PASS }}
39 |       - if: startsWith(github.ref, 'refs/tags/v')
40 |         uses: goreleaser/goreleaser-action@v2
41 |         with:
42 |           version: latest
43 |           args: release
44 |         env:
45 |           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
46 |       - if: startsWith(github.ref, 'refs/tags/v')
47 |         run: make VERSION=${GITHUB_REF/refs\/tags\/v/} docker-manifest-annotate docker-manifest-push
48 |         env:
49 |           DOCKER_USER: ${{ secrets.DOCKER_USER }}
50 |           DOCKER_PASS: ${{ secrets.DOCKER_PASS }}
51 | 


--------------------------------------------------------------------------------
/server/server.go:
--------------------------------------------------------------------------------
 1 | package server
 2 | 
 3 | import (
 4 | 	"context"
 5 | 	"net/http"
 6 | 	"os"
 7 | 	"os/signal"
 8 | 	"time"
 9 | 
10 | 	"github.com/rs/zerolog/log"
11 | 
12 | 	"github.com/gorilla/mux"
13 | )
14 | 
15 | var notifySignal = signal.Notify
16 | var serverShutdown = func(server *http.Server, ctx context.Context) error {
17 | 	return server.Shutdown(ctx)
18 | }
19 | 
20 | // Start starts the http server
21 | func Start(mux *mux.Router, address, cert, key string) error {
22 | 	server, shutdown := startServer(mux, address, cert, key)
23 | 	shutdownOnInterruptSignal(server, 2*time.Second, shutdown)
24 | 	return waitForServerToClose(shutdown)
25 | }
26 | 
27 | func startServer(mux *mux.Router, address, cert, key string) (*http.Server, chan error) {
28 | 	srv := &http.Server{
29 | 		Addr:    address,
30 | 		Handler: mux,
31 | 	}
32 | 
33 | 	shutdown := make(chan error)
34 | 	go func() {
35 | 		if cert != "" || key != "" {
36 | 			log.Info().Str("addr", address).Msg("Start HTTP with tls")
37 | 			err := srv.ListenAndServeTLS(cert, key)
38 | 			shutdown <- err
39 | 		} else {
40 | 			log.Info().Str("addr", address).Msg("Start HTTP")
41 | 			err := srv.ListenAndServe()
42 | 			shutdown <- err
43 | 		}
44 | 	}()
45 | 	return srv, shutdown
46 | }
47 | 
48 | func shutdownOnInterruptSignal(server *http.Server, timeout time.Duration, shutdown chan<- error) {
49 | 	interrupt := make(chan os.Signal, 1)
50 | 	notifySignal(interrupt, os.Interrupt)
51 | 
52 | 	go func() {
53 | 		<-interrupt
54 | 		log.Info().Msg("Received interrupt. Shutting down...")
55 | 		ctx, cancel := context.WithTimeout(context.Background(), timeout)
56 | 		defer cancel()
57 | 		if err := serverShutdown(server, ctx); err != nil {
58 | 			shutdown <- err
59 | 		}
60 | 	}()
61 | }
62 | 
63 | func waitForServerToClose(shutdown <-chan error) error {
64 | 	err := <-shutdown
65 | 	if err == http.ErrServerClosed {
66 | 		return nil
67 | 	}
68 | 	return err
69 | }
70 | 


--------------------------------------------------------------------------------
/ui/src/useConfig.ts:
--------------------------------------------------------------------------------
 1 | import {UIConfig} from './message';
 2 | import {useSnackbar} from 'notistack';
 3 | import React from 'react';
 4 | 
 5 | export interface UseConfig extends UIConfig {
 6 |     login: (username: string, password: string) => Promise<void>;
 7 |     refetch: () => void;
 8 |     logout: () => Promise<void>;
 9 |     loading: boolean;
10 | }
11 | 
12 | export const useConfig = (): UseConfig => {
13 |     const {enqueueSnackbar} = useSnackbar();
14 |     const [{loading, ...config}, setConfig] = React.useState<UIConfig & {loading: boolean}>({
15 |         authMode: 'all',
16 |         user: 'guest',
17 |         loggedIn: false,
18 |         loading: true,
19 |         version: 'unknown',
20 |     });
21 | 
22 |     const refetch = React.useCallback(() => {
23 |         fetch(`config`)
24 |             .then((data) => data.json())
25 |             .then(setConfig);
26 |     }, [setConfig]);
27 | 
28 |     const login = async (username: string, password: string) => {
29 |         const body = new FormData();
30 |         body.set('user', username);
31 |         body.set('pass', password);
32 |         const result = await fetch(`login`, {method: 'POST', body});
33 |         const json = await result.json();
34 |         if (result.status !== 200) {
35 |             enqueueSnackbar('Login Failed: ' + json.message, {variant: 'error'});
36 |         } else {
37 |             await refetch();
38 |             enqueueSnackbar('Logged in!', {variant: 'success'});
39 |         }
40 |     };
41 | 
42 |     const logout = async () => {
43 |         const result = await fetch(`logout`, {method: 'POST'});
44 |         if (result.status !== 200) {
45 |             enqueueSnackbar('Logout Failed: ' + (await result.text()), {variant: 'error'});
46 |         } else {
47 |             await refetch();
48 |             enqueueSnackbar('Logged Out.', {variant: 'success'});
49 |         }
50 |     };
51 | 
52 |     React.useEffect(refetch, []);
53 | 
54 |     return {...config, refetch, loading, login, logout};
55 | };
56 | 


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
 1 | DOCKER_MANIFEST=DOCKER_CLI_EXPERIMENTAL=enabled docker manifest
 2 | 
 3 | docker-login-ci:
 4 | 	docker login -u "$$DOCKER_USER" -p "$$DOCKER_PASS";
 5 | 
 6 | docker-manifest-annotate:
 7 | 	echo ${VERSION}
 8 | 	${DOCKER_MANIFEST} create --amend "screego/server:unstable"     "screego/server:amd64-unstable"     "screego/server:386-unstable"     "screego/server:armv7-unstable"     "screego/server:arm64-unstable"     "screego/server:ppc64le-unstable"
 9 | 	${DOCKER_MANIFEST} create --amend "screego/server:${VERSION}" "screego/server:amd64-${VERSION}" "screego/server:386-${VERSION}" "screego/server:armv7-${VERSION}" "screego/server:arm64-${VERSION}" "screego/server:ppc64le-${VERSION}"
10 | 	${DOCKER_MANIFEST} annotate "screego/server:unstable"     "screego/server:amd64-unstable"       --os=linux --arch=amd64
11 | 	${DOCKER_MANIFEST} annotate "screego/server:${VERSION}" "screego/server:amd64-${VERSION}"   --os=linux --arch=amd64
12 | 	${DOCKER_MANIFEST} annotate "screego/server:unstable"     "screego/server:386-unstable"         --os=linux --arch=386
13 | 	${DOCKER_MANIFEST} annotate "screego/server:${VERSION}" "screego/server:386-${VERSION}"     --os=linux --arch=386
14 | 	${DOCKER_MANIFEST} annotate "screego/server:unstable"     "screego/server:armv7-unstable"       --os=linux --arch=arm --variant=v7
15 | 	${DOCKER_MANIFEST} annotate "screego/server:${VERSION}" "screego/server:armv7-${VERSION}"   --os=linux --arch=arm --variant=v7
16 | 	${DOCKER_MANIFEST} annotate "screego/server:unstable"     "screego/server:arm64-unstable"       --os=linux --arch=arm64
17 | 	${DOCKER_MANIFEST} annotate "screego/server:${VERSION}" "screego/server:arm64-${VERSION}"   --os=linux --arch=arm64
18 | 	${DOCKER_MANIFEST} annotate "screego/server:unstable"     "screego/server:ppc64le-unstable"     --os=linux --arch=ppc64le
19 | 	${DOCKER_MANIFEST} annotate "screego/server:${VERSION}" "screego/server:ppc64le-${VERSION}" --os=linux --arch=ppc64le
20 | 
21 | 
22 | docker-manifest-push:
23 | 	${DOCKER_MANIFEST} push "screego/server:${VERSION}"
24 | 	${DOCKER_MANIFEST} push "screego/server:unstable"
25 | 
26 | 


--------------------------------------------------------------------------------
/ws/event_create.go:
--------------------------------------------------------------------------------
 1 | package ws
 2 | 
 3 | import (
 4 | 	"errors"
 5 | 	"fmt"
 6 | 
 7 | 	"github.com/rs/xid"
 8 | 	"github.com/screego/server/config"
 9 | 	"github.com/screego/server/util"
10 | )
11 | 
12 | func init() {
13 | 	register("create", func() Event {
14 | 		return &Create{}
15 | 	})
16 | }
17 | 
18 | type Create struct {
19 | 	ID                string         `json:"id"`
20 | 	Mode              ConnectionMode `json:"mode"`
21 | 	CloseOnOwnerLeave bool           `json:"closeOnOwnerLeave"`
22 | 	UserName          string         `json:"username"`
23 | }
24 | 
25 | func (e *Create) Execute(rooms *Rooms, current ClientInfo) error {
26 | 	if current.RoomID != "" {
27 | 		return fmt.Errorf("cannot join room, you are already in one")
28 | 	}
29 | 
30 | 	if _, ok := rooms.Rooms[e.ID]; ok {
31 | 		return fmt.Errorf("room with id %s does already existn", e.ID)
32 | 	}
33 | 
34 | 	name := e.UserName
35 | 	if current.Authenticated {
36 | 		name = current.AuthenticatedUser
37 | 	}
38 | 	if name == "" {
39 | 		name = util.NewName()
40 | 	}
41 | 
42 | 	switch rooms.config.AuthMode {
43 | 	case config.AuthModeNone:
44 | 	case config.AuthModeAll:
45 | 		if !current.Authenticated {
46 | 			return errors.New("you need to login")
47 | 		}
48 | 	case config.AuthModeTurn:
49 | 		if e.Mode != ConnectionSTUN && e.Mode != ConnectionLocal && !current.Authenticated {
50 | 			return errors.New("you need to login")
51 | 		}
52 | 	default:
53 | 		return errors.New("invalid authmode:" + rooms.config.AuthMode)
54 | 	}
55 | 
56 | 	room := &Room{
57 | 		ID:                e.ID,
58 | 		CloseOnOwnerLeave: e.CloseOnOwnerLeave,
59 | 		Mode:              e.Mode,
60 | 		Sessions:          map[xid.ID]*RoomSession{},
61 | 		Users: map[xid.ID]*User{
62 | 			current.ID: {
63 | 				ID:        current.ID,
64 | 				Name:      name,
65 | 				Streaming: false,
66 | 				Owner:     true,
67 | 				Addr:      current.Addr,
68 | 				Write:     current.Write,
69 | 				Close:     current.Close,
70 | 			},
71 | 		},
72 | 	}
73 | 	rooms.Rooms[e.ID] = room
74 | 	room.notifyInfoChanged()
75 | 	usersJoinedTotal.Inc()
76 | 	roomsCreatedTotal.Inc()
77 | 	return nil
78 | }
79 | 


--------------------------------------------------------------------------------
/ws/outgoing/messages.go:
--------------------------------------------------------------------------------
 1 | package outgoing
 2 | 
 3 | import (
 4 | 	"encoding/json"
 5 | 
 6 | 	"github.com/rs/xid"
 7 | )
 8 | 
 9 | type Message interface {
10 | 	Type() string
11 | }
12 | 
13 | type Room struct {
14 | 	ID    string         `json:"id"`
15 | 	Mode  ConnectionMode `json:"mode"`
16 | 	Users []User         `json:"users"`
17 | }
18 | 
19 | type User struct {
20 | 	ID        xid.ID `json:"id"`
21 | 	Name      string `json:"name"`
22 | 	Streaming bool   `json:"streaming"`
23 | 	You       bool   `json:"you"`
24 | 	Owner     bool   `json:"owner"`
25 | }
26 | 
27 | func (Room) Type() string {
28 | 	return "room"
29 | }
30 | 
31 | type HostSession struct {
32 | 	ID         xid.ID      `json:"id"`
33 | 	Peer       xid.ID      `json:"peer"`
34 | 	ICEServers []ICEServer `json:"iceServers"`
35 | }
36 | 
37 | func (HostSession) Type() string {
38 | 	return "hostsession"
39 | }
40 | 
41 | type ClientSession struct {
42 | 	ID         xid.ID      `json:"id"`
43 | 	Peer       xid.ID      `json:"peer"`
44 | 	ICEServers []ICEServer `json:"iceServers"`
45 | }
46 | 
47 | func (ClientSession) Type() string {
48 | 	return "clientsession"
49 | }
50 | 
51 | type ICEServer struct {
52 | 	URLs       []string `json:"urls"`
53 | 	Credential string   `json:"credential"`
54 | 	Username   string   `json:"username"`
55 | }
56 | 
57 | type P2PMessage struct {
58 | 	SID   xid.ID          `json:"sid"`
59 | 	Value json.RawMessage `json:"value"`
60 | }
61 | 
62 | type HostICE P2PMessage
63 | 
64 | func (HostICE) Type() string {
65 | 	return "hostice"
66 | }
67 | 
68 | type ClientICE P2PMessage
69 | 
70 | func (ClientICE) Type() string {
71 | 	return "clientice"
72 | }
73 | 
74 | type ClientAnswer P2PMessage
75 | 
76 | func (ClientAnswer) Type() string {
77 | 	return "clientanswer"
78 | }
79 | 
80 | type HostOffer P2PMessage
81 | 
82 | func (HostOffer) Type() string {
83 | 	return "hostoffer"
84 | }
85 | 
86 | type EndShare xid.ID
87 | 
88 | func (EndShare) Type() string {
89 | 	return "endshare"
90 | }
91 | 
92 | type ConnectionMode string
93 | 
94 | const (
95 | 	ConnectionLocal ConnectionMode = "local"
96 | 	ConnectionSTUN  ConnectionMode = "stun"
97 | 	ConnectionTURN  ConnectionMode = "turn"
98 | )
99 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | <p align="center">
 2 |     <a href="https://screego.net">
 3 |         <img src="docs/logo.png" />
 4 |     </a>
 5 | </p>
 6 | 
 7 | 
 8 | <h1 align="center">screego/server</h1>
 9 | <p align="center"><i>screen sharing for developers</i></p>
10 | 
11 | <p align="center">
12 |     <a href="https://github.com/screego/server/actions?query=workflow%3Abuild">
13 |         <img alt="Build Status" src="https://github.com/screego/server/workflows/build/badge.svg">
14 |     </a>
15 |     <a href="https://goreportcard.com/report/github.com/screego/server">
16 |         <img alt="Go Report Card" src="https://goreportcard.com/badge/github.com/screego/server">
17 |     </a>
18 |     <a href="https://hub.docker.com/r/screego/server">
19 |         <img alt="Docker Pulls" src="https://img.shields.io/docker/pulls/screego/server.svg">
20 |     </a>
21 |     <a href="https://github.com/screego/server/releases/latest">
22 |         <img alt="latest release" src="https://img.shields.io/github/release/screego/server.svg">
23 |     </a>
24 | </p>
25 | 
26 | 
27 | ## Intro
28 | 
29 | In the past I've had some problems sharing my screen with coworkers using
30 | corporate chatting solutions like Microsoft Teams. I wanted to show them some
31 | of my code, but either the stream lagged several seconds behind or the quality
32 | was so poor that my colleagues couldn't read the code. Or both.
33 | 
34 | That's why I created screego. It allows you to share your screen with good
35 | quality and low latency. Screego is an addition to existing software and 
36 | only helps to share your screen. Nothing else (:.
37 | 
38 | ## Features
39 | 
40 | * Multi User Screenshare
41 | * Secure transfer via WebRTC
42 | * Low latency / High resolution
43 | * Simple Install via Docker / single binary
44 | * Integrated TURN Server see [NAT Traversal](https://screego.net/#/nat-traversal)
45 | 
46 | [Demo / Public Instance](https://app.screego.net/) ᛫ [Installation](https://screego.net/#/install) ᛫ [Configuration](https://screego.net/#/config) 
47 | 
48 | ## Versioning
49 | 
50 | We use [SemVer](http://semver.org/) for versioning. For the versions available, see the
51 | [tags on this repository](https://github.com/screego/server/tags).
52 | 


--------------------------------------------------------------------------------
/server/server_test.go:
--------------------------------------------------------------------------------
 1 | package server
 2 | 
 3 | import (
 4 | 	"context"
 5 | 	"errors"
 6 | 	"net/http"
 7 | 	"os"
 8 | 	"strconv"
 9 | 	"testing"
10 | 	"time"
11 | 
12 | 	"github.com/gorilla/mux"
13 | 	"github.com/phayes/freeport"
14 | 	"github.com/stretchr/testify/assert"
15 | )
16 | 
17 | func TestShutdownOnErrorWhileShutdown(t *testing.T) {
18 | 	disposeInterrupt := fakeInterrupt(t)
19 | 	defer disposeInterrupt()
20 | 
21 | 	shutdownError := errors.New("shutdown error")
22 | 	disposeShutdown := fakeShutdownError(shutdownError)
23 | 	defer disposeShutdown()
24 | 
25 | 	finished := make(chan error)
26 | 
27 | 	go func() {
28 | 		finished <- Start(mux.NewRouter(), ":"+strconv.Itoa(freeport.GetPort()), "", "")
29 | 	}()
30 | 
31 | 	select {
32 | 	case <-time.After(1 * time.Second):
33 | 		t.Fatal("Server should be closed")
34 | 	case err := <-finished:
35 | 		assert.Equal(t, shutdownError, err)
36 | 	}
37 | }
38 | 
39 | func TestShutdownAfterError(t *testing.T) {
40 | 	finished := make(chan error)
41 | 
42 | 	go func() {
43 | 		finished <- Start(mux.NewRouter(), ":-5", "", "")
44 | 	}()
45 | 
46 | 	select {
47 | 	case <-time.After(1 * time.Second):
48 | 		t.Fatal("Server should be closed")
49 | 	case err := <-finished:
50 | 		assert.NotNil(t, err)
51 | 	}
52 | }
53 | 
54 | func TestShutdown(t *testing.T) {
55 | 	dispose := fakeInterrupt(t)
56 | 	defer dispose()
57 | 
58 | 	finished := make(chan error)
59 | 
60 | 	go func() {
61 | 		finished <- Start(mux.NewRouter(), ":"+strconv.Itoa(freeport.GetPort()), "", "")
62 | 	}()
63 | 
64 | 	select {
65 | 	case <-time.After(1 * time.Second):
66 | 		t.Fatal("Server should be closed")
67 | 	case err := <-finished:
68 | 		assert.Nil(t, err)
69 | 	}
70 | }
71 | 
72 | func fakeInterrupt(t *testing.T) func() {
73 | 	oldNotify := notifySignal
74 | 	notifySignal = func(c chan<- os.Signal, sig ...os.Signal) {
75 | 		assert.Contains(t, sig, os.Interrupt)
76 | 		go func() {
77 | 			time.Sleep(100 * time.Millisecond)
78 | 			c <- os.Interrupt
79 | 		}()
80 | 	}
81 | 	return func() {
82 | 		notifySignal = oldNotify
83 | 	}
84 | }
85 | 
86 | func fakeShutdownError(err error) func() {
87 | 	old := serverShutdown
88 | 	serverShutdown = func(server *http.Server, ctx context.Context) error {
89 | 		return err
90 | 	}
91 | 	return func() {
92 | 		serverShutdown = old
93 | 	}
94 | }
95 | 


--------------------------------------------------------------------------------
/ws/rooms.go:
--------------------------------------------------------------------------------
 1 | package ws
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"net/http"
 6 | 	"net/url"
 7 | 	"time"
 8 | 
 9 | 	"github.com/gorilla/websocket"
10 | 	"github.com/rs/zerolog/log"
11 | 	"github.com/screego/server/auth"
12 | 	"github.com/screego/server/config"
13 | 	"github.com/screego/server/turn"
14 | )
15 | 
16 | func NewRooms(tServer *turn.Server, users *auth.Users, conf config.Config) *Rooms {
17 | 	return &Rooms{
18 | 		Rooms:      map[string]*Room{},
19 | 		Incoming:   make(chan ClientMessage),
20 | 		turnServer: tServer,
21 | 		users:      users,
22 | 		config:     conf,
23 | 		upgrader: websocket.Upgrader{
24 | 			ReadBufferSize:  1024,
25 | 			WriteBufferSize: 1024,
26 | 			CheckOrigin: func(r *http.Request) bool {
27 | 				origin := r.Header.Get("origin")
28 | 				u, err := url.Parse(origin)
29 | 				if err != nil {
30 | 					return false
31 | 				}
32 | 				if u.Host == r.Host {
33 | 					return true
34 | 				}
35 | 				return conf.CheckOrigin(origin)
36 | 			},
37 | 		},
38 | 	}
39 | }
40 | 
41 | type Rooms struct {
42 | 	turnServer *turn.Server
43 | 	Rooms      map[string]*Room
44 | 	Incoming   chan ClientMessage
45 | 	upgrader   websocket.Upgrader
46 | 	users      *auth.Users
47 | 	config     config.Config
48 | }
49 | 
50 | func (r *Rooms) Upgrade(w http.ResponseWriter, req *http.Request) {
51 | 	conn, err := r.upgrader.Upgrade(w, req, nil)
52 | 
53 | 	if err != nil {
54 | 		log.Debug().Err(err).Msg("Websocket upgrade")
55 | 		w.WriteHeader(400)
56 | 		_, _ = w.Write([]byte(fmt.Sprintf("Upgrade failed %s", err)))
57 | 		return
58 | 	}
59 | 
60 | 	user, loggedIn := r.users.CurrentUser(req)
61 | 	c := newClient(conn, req, r.Incoming, user, loggedIn, r.config.TrustProxyHeaders)
62 | 
63 | 	go c.startReading(time.Second * 20)
64 | 	go c.startWriteHandler(time.Second * 5)
65 | }
66 | 
67 | func (r *Rooms) Start() {
68 | 	for {
69 | 		msg := <-r.Incoming
70 | 		if err := msg.Incoming.Execute(r, msg.Info); err != nil {
71 | 			msg.Info.Close <- err.Error()
72 | 		}
73 | 	}
74 | }
75 | 
76 | func (r *Rooms) closeRoom(roomId string) {
77 | 	room, ok := r.Rooms[roomId]
78 | 	if !ok {
79 | 		return
80 | 	}
81 | 	usersLeftTotal.Add(float64(len(room.Users)))
82 | 	for id := range room.Sessions {
83 | 		room.closeSession(r, id)
84 | 	}
85 | 
86 | 	delete(r.Rooms, roomId)
87 | 	roomsClosedTotal.Inc()
88 | }
89 | 


--------------------------------------------------------------------------------
/ui/src/index.tsx:
--------------------------------------------------------------------------------
 1 | import React from 'react';
 2 | import ReactDOM from 'react-dom';
 3 | import './global.css';
 4 | import {Button, createMuiTheme, CssBaseline, MuiThemeProvider} from '@material-ui/core';
 5 | import {Router} from './Router';
 6 | import {SnackbarProvider} from 'notistack';
 7 | 
 8 | const theme = createMuiTheme({
 9 |     overrides: {
10 |         MuiSelect: {icon: {position: 'relative'}},
11 |         MuiLink: {
12 |             root: {
13 |                 color: '#458588',
14 |             },
15 |         },
16 |         MuiIconButton: {
17 |             root: {
18 |                 color: 'inherit',
19 |             },
20 |         },
21 |         MuiListItemIcon: {
22 |             root: {
23 |                 color: 'inherit',
24 |             },
25 |         },
26 |         MuiToolbar: {
27 |             root: {
28 |                 background: '#a89984',
29 |             },
30 |         },
31 |         MuiTooltip: {
32 |             tooltip: {
33 |                 fontSize: '1.6em',
34 |             },
35 |         },
36 |     },
37 |     palette: {
38 |         background: {
39 |             default: '#282828',
40 |             paper: '#32302f',
41 |         },
42 |         text: {
43 |             primary: '#fbf1d4',
44 |         },
45 |         primary: {
46 |             main: '#a89984',
47 |         },
48 |         secondary: {
49 |             main: '#f44336',
50 |         },
51 |         type: 'dark',
52 |     },
53 | });
54 | 
55 | const Snackbar: React.FC = ({children}) => {
56 |     const notistackRef = React.createRef<any>();
57 |     const onClickDismiss = (key: unknown) => () => {
58 |         notistackRef.current?.closeSnackbar(key);
59 |     };
60 | 
61 |     return (
62 |         <SnackbarProvider
63 |             maxSnack={3}
64 |             ref={notistackRef}
65 |             action={(key) => (
66 |                 <Button onClick={onClickDismiss(key)} size="small">
67 |                     Dismiss
68 |                 </Button>
69 |             )}>
70 |             {children}
71 |         </SnackbarProvider>
72 |     );
73 | };
74 | 
75 | ReactDOM.render(
76 |     <React.StrictMode>
77 |         <MuiThemeProvider theme={theme}>
78 |             <Snackbar>
79 |                 <CssBaseline />
80 |                 <Router />
81 |             </Snackbar>
82 |         </MuiThemeProvider>
83 |     </React.StrictMode>,
84 |     document.getElementById('root')
85 | );
86 | 


--------------------------------------------------------------------------------
/docs/development.md:
--------------------------------------------------------------------------------
  1 | # Development
  2 | 
  3 | Screego requires:
  4 | 
  5 | - Go 1.15+
  6 | - Node 13.x
  7 | - Yarn 9+
  8 | 
  9 | ## Setup
 10 | 
 11 | ### Clone Repository
 12 | 
 13 | Clone screego/server source from git:
 14 | 
 15 | ```bash
 16 | $ git clone https://github.com/screego/server.git && cd server
 17 | ```
 18 | 
 19 | ### GOPATH
 20 | 
 21 | If you are in GOPATH, enable [go modules](https://github.com/golang/go/wiki/Modules) explicitly:
 22 | 
 23 | ```bash
 24 | $ export GO111MODULE=on
 25 | ```
 26 | 
 27 | ### Download Dependencies:
 28 | 
 29 | ```bash
 30 | # Server
 31 | $ go mod download
 32 | # UI
 33 | $ (cd ui && yarn install)
 34 | ```
 35 | 
 36 | ## Start / Linting
 37 | 
 38 | ### Backend
 39 | 
 40 | Create a file named `screego.config.development.local` inside the screego folder with the content:
 41 | 
 42 | ```ini
 43 | SCREEGO_EXTERNAL_IP=YOURIP
 44 | ```
 45 | 
 46 | and replace `YOURIP` with your external ip.
 47 | 
 48 | Start the server in development mode.
 49 | 
 50 | ```bash
 51 | $ go run . serve
 52 | ```
 53 | 
 54 | The backend is available on [http://localhost:5050](http://localhost:5050)
 55 | 
 56 | ?> When accessing `localhost:5050` it is normal that there are panics with `no such file or directory`.
 57 | The UI will be started separately.
 58 | 
 59 | ### Frontend
 60 | 
 61 | Start the UI development server.
 62 | 
 63 | _Commands must be executed inside the ui directory._
 64 | 
 65 | ```bash
 66 | $ yarn start
 67 | ```
 68 | 
 69 | Open [http://localhost:3000](http://localhost:3000) inside your favorite browser.
 70 | 
 71 | ### Lint
 72 | 
 73 | Screego uses [golangci-lint](https://github.com/golangci/golangci-lint) for linting.
 74 | 
 75 | After installation you can check the source code with:
 76 | 
 77 | ```bash
 78 | $ golangci-lint run
 79 | ```
 80 | 
 81 | ## Build
 82 | 
 83 | 1. [Setup](#setup)
 84 | 
 85 | 1. Build the UI
 86 | 
 87 |    ```bash
 88 |    $ (cd ui && yarn build)
 89 |    ```
 90 | 
 91 | 1. Generate static assets for go.
 92 | 
 93 |    Run [packr](https://github.com/gobuffalo/packr) (embeds static assets in go binaries)
 94 | 
 95 |    ```bash
 96 |    $ go run hack/packr/packr.go
 97 |    ```
 98 | 
 99 | 1. Build the binary
100 |    ```bash
101 |    CGO_ENABLED=0 go build \
102 |      -ldflags '-s -w -X main.version=`git describe --tags HEAD` -X main.mode=Prod' \
103 |      -buildmode=pie -trimpath -tags 'netgo osusergo' main.go
104 |    ```
105 | 


--------------------------------------------------------------------------------
/docs/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 | <head>
 4 |     <meta charset="UTF-8">
 5 |     <title>Screego</title>
 6 |     <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1"/>
 7 |     <meta name="description" content="Screego - open source screen sharing for developers">
 8 |     <meta name="viewport"
 9 |           content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
10 |     <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/docsify-themeable@0/dist/css/theme-simple-dark.css">
11 |     <link rel="apple-touch-icon" sizes="180x180" href="/apple-touch-icon.png">
12 |     <link rel="icon" type="image/png" sizes="32x32" href="/favicon-32x32.png">
13 |     <link rel="icon" type="image/png" sizes="16x16" href="/favicon-16x16.png">
14 |     <meta name="theme-color" content="#ffffff">
15 |     <style>
16 |         .markdown-section h1 {
17 |             border-width: 0;
18 |         }
19 |     </style>
20 | </head>
21 | <body>
22 | <div id="app"></div>
23 | <script>
24 |     const ghVersion = fetch('https://api.github.com/repos/screego/server/tags').then(resp => resp.json()).then(data => data[0].name.slice(1))
25 |     window.$docsify = {
26 |         name: 'screego',
27 |         repo: 'screego/server',
28 |         logo: '/logo.png',
29 |         loadSidebar: true,
30 |         autoHeader: true,
31 |         maxLevel: 4,
32 |         subMaxLevel: 2,
33 |         plugins: [
34 |             function (hook) {
35 |                 hook.afterEach(function (html, next) {
36 |                     ghVersion.then((version) => next(html.replace(/GITHUB_VERSION/g, version)))
37 |                 })
38 |             }
39 |         ]
40 |     }
41 | </script>
42 | <script src="//cdn.jsdelivr.net/npm/docsify/lib/docsify.min.js"></script>
43 | <script src="https://cdn.jsdelivr.net/npm/docsify-themeable@0"></script>
44 | <script src="//cdn.jsdelivr.net/npm/docsify/lib/plugins/search.min.js"></script>
45 | <script src="https://cdn.jsdelivr.net/npm/docsify-tabs@1"></script>
46 | <script src="https://cdn.jsdelivr.net/npm/prismjs@1.21.0/components/prism-yaml.js"></script>
47 | <script src="https://cdn.jsdelivr.net/npm/prismjs@1.21.0/components/prism-ini.js"></script>
48 | <script src="https://cdn.jsdelivr.net/npm/prismjs@1.21.0/components/prism-bash.js"></script>
49 | <script src="https://cdn.jsdelivr.net/npm/prismjs@1.21.0/components/prism-nginx.js"></script>
50 | </body>
51 | </html>
52 | 


--------------------------------------------------------------------------------
/router/router.go:
--------------------------------------------------------------------------------
 1 | package router
 2 | 
 3 | import (
 4 | 	"encoding/json"
 5 | 	"github.com/rs/zerolog/hlog"
 6 | 	"net/http"
 7 | 	"time"
 8 | 
 9 | 	"github.com/gorilla/handlers"
10 | 	"github.com/gorilla/mux"
11 | 	"github.com/prometheus/client_golang/prometheus/promhttp"
12 | 	"github.com/rs/zerolog/log"
13 | 	"github.com/screego/server/auth"
14 | 	"github.com/screego/server/config"
15 | 	"github.com/screego/server/ui"
16 | 	"github.com/screego/server/ws"
17 | )
18 | 
19 | type UIConfig struct {
20 | 	AuthMode string `json:"authMode"`
21 | 	User     string `json:"user"`
22 | 	LoggedIn bool   `json:"loggedIn"`
23 | 	Version  string `json:"version"`
24 | }
25 | 
26 | func Router(conf config.Config, rooms *ws.Rooms, users *auth.Users, version string) *mux.Router {
27 | 	router := mux.NewRouter()
28 | 	router.NotFoundHandler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
29 | 		// https://github.com/gorilla/mux/issues/416
30 | 		accessLogger(r, 404, 0, 0)
31 | 	})
32 | 	router.Use(hlog.AccessHandler(accessLogger))
33 | 	router.Use(handlers.CORS(handlers.AllowedMethods([]string{"GET", "POST"}), handlers.AllowedOriginValidator(conf.CheckOrigin)))
34 | 	router.HandleFunc("/stream", rooms.Upgrade)
35 | 	router.Methods("POST").Path("/login").HandlerFunc(users.Authenticate)
36 | 	router.Methods("POST").Path("/logout").HandlerFunc(users.Logout)
37 | 	router.Methods("GET").Path("/config").HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
38 | 		user, loggedIn := users.CurrentUser(r)
39 | 		_ = json.NewEncoder(w).Encode(&UIConfig{
40 | 			AuthMode: conf.AuthMode,
41 | 			LoggedIn: loggedIn,
42 | 			User:     user,
43 | 			Version:  version,
44 | 		})
45 | 	})
46 | 	if conf.Prometheus {
47 | 		log.Info().Msg("Prometheus enabled")
48 | 		router.Methods("GET").Path("/metrics").Handler(basicAuth(promhttp.Handler(), users))
49 | 	}
50 | 
51 | 	ui.Register(router)
52 | 
53 | 	return router
54 | }
55 | 
56 | func accessLogger(r *http.Request, status, size int, dur time.Duration) {
57 | 	log.Debug().
58 | 		Str("host", r.Host).
59 | 		Int("status", status).
60 | 		Int("size", size).
61 | 		Str("ip", r.RemoteAddr).
62 | 		Str("path", r.URL.Path).
63 | 		Str("duration", dur.String()).
64 | 		Msg("HTTP")
65 | }
66 | 
67 | func basicAuth(handler http.Handler, users *auth.Users) http.HandlerFunc {
68 | 	return func(w http.ResponseWriter, r *http.Request) {
69 | 
70 | 		user, pass, ok := r.BasicAuth()
71 | 
72 | 		if !ok || !users.Validate(user, pass) {
73 | 			w.Header().Set("WWW-Authenticate", `Basic realm="screego"`)
74 | 			w.WriteHeader(401)
75 | 			_, _ = w.Write([]byte("Unauthorised.\n"))
76 | 			return
77 | 		}
78 | 
79 | 		handler.ServeHTTP(w, r)
80 | 	}
81 | }
82 | 


--------------------------------------------------------------------------------
/screego.config.example:
--------------------------------------------------------------------------------
 1 | # The external ip of the server.
 2 | # When using a dual stack setup define both IPv4 & IPv6 separated by a comma.
 3 | # Execute the following command on the server you want to host Screego
 4 | # to find your external ip.
 5 | #   curl 'https://api.ipify.org'
 6 | # Example:
 7 | #   192.168.178.2,2a01:c22:a87c:e500:2d8:61ff:fec7:f92a
 8 | SCREEGO_EXTERNAL_IP=
 9 | 
10 | # A secret which should be unique. Is used for cookie authentication.
11 | SCREEGO_SECRET=
12 | 
13 | # If TLS should be enabled for HTTP requests. Screego requires TLS,
14 | # you either have to enable this setting or serve TLS via a reverse proxy.
15 | SCREEGO_SERVER_TLS=false
16 | # The TLS cert file (only needed if TLS is enabled)
17 | SCREEGO_TLS_CERT_FILE=
18 | # The TLS key file (only needed if TLS is enabled)
19 | SCREEGO_TLS_KEY_FILE=
20 | 
21 | # The address the http server will listen on.
22 | SCREEGO_SERVER_ADDRESS=0.0.0.0:5050
23 | 
24 | # The address the TURN server will listen on.
25 | SCREEGO_TURN_ADDRESS=0.0.0.0:3478
26 | 
27 | # Limit the ports that TURN will use for data relaying.
28 | # Format: min:max
29 | # Example:
30 | #   50000:55000
31 | SCREEGO_TURN_PORT_RANGE=
32 | 
33 | # If true, the TURN server will compare the remote IP of the request with the
34 | # remote ip of the existing WebSocket connection and deny access if it doesn't
35 | # match. Disable this feature, if you use some kind of proxy which changes the
36 | # remote ip.
37 | SCREEGO_TURN_STRICT_AUTH=true
38 | 
39 | # If reverse proxy headers should be trusted.
40 | # Screego uses ip whitelisting for authentication
41 | # of TURN connections. When behind a proxy the ip is always the proxy server.
42 | # To still allow whitelisting this setting must be enabled and
43 | # the `X-Real-Ip` header must be set by the reverse proxy.
44 | SCREEGO_TRUST_PROXY_HEADERS=false
45 | 
46 | # Defines when a user login is required
47 | # Possible values:
48 | #   all: User login is always required
49 | #   turn: User login is required for TURN connections
50 | #   none: User login is never required
51 | SCREEGO_AUTH_MODE=turn
52 | 
53 | # Defines origins that will be allowed to access Screego (HTTP + WebSocket)
54 | # The default value is sufficient for most use-cases.
55 | # Example Value: https://screego.net,https://sub.gotify.net
56 | SCREEGO_CORS_ALLOWED_ORIGINS=
57 | 
58 | # Defines the location of the users file.
59 | # File Format:
60 | #   user1:bcrypt_password_hash
61 | #   user2:bcrypt_password_hash
62 | #
63 | # Example:
64 | #   user1:$2a$12$WEfYCnWGk0PDzbATLTNiTuoZ7e/43v6DM/h7arOnPU6qEtFG.kZQy
65 | #
66 | # The user password pair can be created via
67 | #   screego hash --name "user1" --pass "your password"
68 | SCREEGO_USERS_FILE=
69 | 
70 | # The loglevel (one of: debug, info, warn, error)
71 | SCREEGO_LOG_LEVEL=info
72 | 
73 | # If screego should expose a prometheus endpoint at /metrics. The endpoint
74 | # requires basic authentication from a user in the users file.
75 | SCREEGO_PROMETHEUS=false
76 | 


--------------------------------------------------------------------------------
/ui/src/message.ts:
--------------------------------------------------------------------------------
  1 | export enum ShareMode {
  2 |     Everyone = 'Everyone',
  3 |     Selected = 'Selected',
  4 | }
  5 | 
  6 | type Typed<Base, Type extends string> = {type: Type; payload: Base};
  7 | 
  8 | export interface UIConfig {
  9 |     authMode: 'turn' | 'none' | 'all';
 10 |     user: string;
 11 |     loggedIn: boolean;
 12 |     version: string;
 13 | }
 14 | 
 15 | export interface RoomConfiguration {
 16 |     id?: string;
 17 |     closeOnOwnerLeave?: boolean;
 18 |     mode: RoomMode;
 19 |     username?: string;
 20 | }
 21 | 
 22 | export enum RoomMode {
 23 |     Turn = 'turn',
 24 |     Stun = 'stun',
 25 |     Local = 'local',
 26 | }
 27 | 
 28 | export interface JoinConfiguration {
 29 |     id: string;
 30 |     password?: string;
 31 |     username?: string;
 32 | }
 33 | 
 34 | export interface StringMessage {
 35 |     message: string;
 36 | }
 37 | 
 38 | export interface P2PSession {
 39 |     id: string;
 40 |     peer: string;
 41 |     iceServers: ICEServer[];
 42 | }
 43 | 
 44 | export interface ICEServer {
 45 |     urls: string[];
 46 |     credential: string;
 47 |     username: string;
 48 | }
 49 | 
 50 | export interface RoomInfo {
 51 |     id: string;
 52 |     share: ShareMode;
 53 |     mode: RoomMode;
 54 |     users: RoomUser[];
 55 | }
 56 | 
 57 | export interface RoomUser {
 58 |     id: string;
 59 |     name: string;
 60 |     streaming: boolean;
 61 |     you: boolean;
 62 |     owner: boolean;
 63 | }
 64 | 
 65 | export interface P2PMessage<T> {
 66 |     sid: string;
 67 |     value: T;
 68 | }
 69 | 
 70 | export type Room = Typed<RoomInfo, 'room'>;
 71 | export type Error = Typed<StringMessage, 'Error'>;
 72 | export type HostSession = Typed<P2PSession, 'hostsession'>;
 73 | export type Name = Typed<{username: string}, 'name'>;
 74 | export type ClientSession = Typed<P2PSession, 'clientsession'>;
 75 | export type HostICECandidate = Typed<P2PMessage<RTCIceCandidate>, 'hostice'>;
 76 | export type ClientICECandidate = Typed<P2PMessage<RTCIceCandidate>, 'clientice'>;
 77 | export type HostOffer = Typed<P2PMessage<RTCSessionDescriptionInit>, 'hostoffer'>;
 78 | export type ClientAnswer = Typed<P2PMessage<RTCSessionDescriptionInit>, 'clientanswer'>;
 79 | export type StartSharing = Typed<{}, 'share'>;
 80 | export type StopShare = Typed<{}, 'stopshare'>;
 81 | export type RoomCreate = Typed<RoomConfiguration, 'create'>;
 82 | export type JoinRoom = Typed<JoinConfiguration, 'join'>;
 83 | export type EndShare = Typed<string, 'endshare'>;
 84 | 
 85 | export type IncomingMessage =
 86 |     | Room
 87 |     | Error
 88 |     | HostSession
 89 |     | ClientSession
 90 |     | HostICECandidate
 91 |     | ClientICECandidate
 92 |     | HostOffer
 93 |     | EndShare
 94 |     | ClientAnswer;
 95 | 
 96 | export type OutgoingMessage =
 97 |     | RoomCreate
 98 |     | Name
 99 |     | JoinRoom
100 |     | HostICECandidate
101 |     | ClientICECandidate
102 |     | HostOffer
103 |     | StopShare
104 |     | ClientAnswer
105 |     | StartSharing;
106 | 


--------------------------------------------------------------------------------
/ui/src/LoginForm.tsx:
--------------------------------------------------------------------------------
 1 | import {UseConfig} from './useConfig';
 2 | import React from 'react';
 3 | import {
 4 |     Button,
 5 |     ButtonProps,
 6 |     CircularProgress,
 7 |     FormControl,
 8 |     TextField,
 9 |     Typography,
10 | } from '@material-ui/core';
11 | import {makeStyles} from '@material-ui/core/styles';
12 | import {green} from '@material-ui/core/colors';
13 | 
14 | export const LoginForm = ({config: {login}, hide}: {config: UseConfig; hide?: () => void}) => {
15 |     const [user, setUser] = React.useState('');
16 |     const [pass, setPass] = React.useState('');
17 |     const [loading, setLoading] = React.useState(false);
18 |     const submit = async (event: {preventDefault: () => void}) => {
19 |         event.preventDefault();
20 |         setLoading(true);
21 |         login(user, pass)
22 |             .then(() => {
23 |                 setLoading(false);
24 |             })
25 |             .catch(() => setLoading(false));
26 |     };
27 |     return (
28 |         <div>
29 |             <FormControl fullWidth>
30 |                 <form onSubmit={submit}>
31 |                     <div style={{display: 'flex', alignItems: 'center'}}>
32 |                         <Typography style={{flex: 1}}>Login to Screego</Typography>
33 |                         {hide ? (
34 |                             <Button variant="outlined" size="small" onClick={hide}>
35 |                                 Go Back
36 |                             </Button>
37 |                         ) : undefined}
38 |                     </div>
39 |                     <TextField
40 |                         fullWidth
41 |                         value={user}
42 |                         onChange={(e) => setUser(e.target.value)}
43 |                         label="Username"
44 |                         margin="dense"
45 |                     />
46 |                     <TextField
47 |                         fullWidth
48 |                         value={pass}
49 |                         type="password"
50 |                         onChange={(e) => setPass(e.target.value)}
51 |                         label="Password"
52 |                         margin="dense"
53 |                     />
54 |                     <LoadingButton
55 |                         type="submit"
56 |                         loading={loading}
57 |                         onClick={submit}
58 |                         fullWidth
59 |                         variant="contained">
60 |                         Login
61 |                     </LoadingButton>
62 |                 </form>
63 |             </FormControl>
64 |         </div>
65 |     );
66 | };
67 | 
68 | export const LoadingButton = ({loading, children, ...props}: ButtonProps & {loading: boolean}) => {
69 |     const classes = useStyles();
70 |     return (
71 |         <Button {...props} disabled={loading}>
72 |             {children}
73 |             {loading && (
74 |                 <CircularProgress className={classes.buttonProgress} size={24} color="secondary" />
75 |             )}
76 |         </Button>
77 |     );
78 | };
79 | 
80 | const useStyles = makeStyles(() => ({
81 |     buttonProgress: {
82 |         color: green[500],
83 |         position: 'absolute',
84 |         top: '50%',
85 |         left: '50%',
86 |         marginTop: -12,
87 |         marginLeft: -12,
88 |     },
89 | }));
90 | 


--------------------------------------------------------------------------------
/auth/auth.go:
--------------------------------------------------------------------------------
  1 | package auth
  2 | 
  3 | import (
  4 | 	"encoding/csv"
  5 | 	"encoding/json"
  6 | 	"errors"
  7 | 	"io"
  8 | 	"net/http"
  9 | 	"os"
 10 | 
 11 | 	"github.com/rs/zerolog/log"
 12 | 
 13 | 	"github.com/gorilla/sessions"
 14 | 	"golang.org/x/crypto/bcrypt"
 15 | )
 16 | 
 17 | type Users struct {
 18 | 	Lookup map[string]string
 19 | 	store  sessions.Store
 20 | }
 21 | 
 22 | type UserPW struct {
 23 | 	Name string
 24 | 	Pass string
 25 | }
 26 | 
 27 | func read(r io.Reader) ([]UserPW, error) {
 28 | 	reader := csv.NewReader(r)
 29 | 	reader.Comma = ':'
 30 | 	reader.Comment = '#'
 31 | 	reader.TrimLeadingSpace = true
 32 | 
 33 | 	records, err := reader.ReadAll()
 34 | 
 35 | 	if err != nil {
 36 | 		return nil, err
 37 | 	}
 38 | 
 39 | 	result := []UserPW{}
 40 | 	for _, record := range records {
 41 | 		if len(record) != 2 {
 42 | 			return nil, errors.New("malformed users file")
 43 | 		}
 44 | 		result = append(result, UserPW{Name: record[0], Pass: record[1]})
 45 | 	}
 46 | 	return result, nil
 47 | }
 48 | 
 49 | func ReadPasswordsFile(path string, secret []byte) (*Users, error) {
 50 | 	users := &Users{
 51 | 		Lookup: map[string]string{},
 52 | 		store:  sessions.NewCookieStore(secret),
 53 | 	}
 54 | 	if path == "" {
 55 | 		log.Info().Msg("Users file not specified")
 56 | 		return users, nil
 57 | 	}
 58 | 
 59 | 	file, err := os.Open(path)
 60 | 	if err != nil {
 61 | 		return users, err
 62 | 	}
 63 | 	defer file.Close()
 64 | 	userPws, err := read(file)
 65 | 	if err != nil {
 66 | 		return users, err
 67 | 	}
 68 | 
 69 | 	for _, record := range userPws {
 70 | 		users.Lookup[record.Name] = record.Pass
 71 | 	}
 72 | 	log.Info().Int("amount", len(users.Lookup)).Msg("Loaded Users")
 73 | 	return users, nil
 74 | }
 75 | 
 76 | type Response struct {
 77 | 	Message string `json:"message"`
 78 | }
 79 | 
 80 | func (u *Users) CurrentUser(r *http.Request) (string, bool) {
 81 | 	s, _ := u.store.Get(r, "user")
 82 | 	user, ok := s.Values["user"].(string)
 83 | 	if !ok {
 84 | 		return "guest", ok
 85 | 	}
 86 | 	return user, ok
 87 | }
 88 | 
 89 | func (u *Users) Logout(w http.ResponseWriter, r *http.Request) {
 90 | 	session := sessions.NewSession(u.store, "user")
 91 | 	session.IsNew = true
 92 | 	if err := u.store.Save(r, w, session); err != nil {
 93 | 		w.WriteHeader(500)
 94 | 		_ = json.NewEncoder(w).Encode(&Response{
 95 | 			Message: err.Error(),
 96 | 		})
 97 | 		return
 98 | 	}
 99 | 	w.WriteHeader(200)
100 | }
101 | 
102 | func (u *Users) Authenticate(w http.ResponseWriter, r *http.Request) {
103 | 	user := r.FormValue("user")
104 | 	pass := r.FormValue("pass")
105 | 
106 | 	if !u.Validate(user, pass) {
107 | 		w.WriteHeader(401)
108 | 		_ = json.NewEncoder(w).Encode(&Response{
109 | 			Message: "could not authenticate",
110 | 		})
111 | 		return
112 | 	}
113 | 
114 | 	session := sessions.NewSession(u.store, "user")
115 | 	session.IsNew = true
116 | 	session.Values["user"] = user
117 | 	if err := u.store.Save(r, w, session); err != nil {
118 | 		w.WriteHeader(500)
119 | 		_ = json.NewEncoder(w).Encode(&Response{
120 | 			Message: err.Error(),
121 | 		})
122 | 		return
123 | 	}
124 | 	w.WriteHeader(200)
125 | 	_ = json.NewEncoder(w).Encode(&Response{
126 | 		Message: "authenticated",
127 | 	})
128 | }
129 | 
130 | func (u Users) Validate(user string, password string) bool {
131 | 	realPassword, exists := u.Lookup[user]
132 | 	return exists && bcrypt.CompareHashAndPassword([]byte(realPassword), []byte(password)) == nil
133 | }
134 | 


--------------------------------------------------------------------------------
/docs/proxy.md:
--------------------------------------------------------------------------------
  1 | # Proxy
  2 | 
  3 | !> When using a proxy enable `SCREEGO_TRUST_PROXY_HEADERS`. See [Configuration](config.md).
  4 | 
  5 | ## nginx
  6 | 
  7 | ### At root path
  8 | 
  9 | ```nginx
 10 | upstream screego {
 11 |   # Set this to the address configured in
 12 |   # SCREEGO_SERVER_ADDRESS. Default 5050
 13 |   server 127.0.0.1:5050;
 14 | }
 15 | 
 16 | server {
 17 |   listen 80;
 18 | 
 19 |   # Here goes your domain / subdomain
 20 |   server_name screego.example.com;
 21 | 
 22 |   location / {
 23 |     # Proxy to screego
 24 |     proxy_pass         http://screego;
 25 |     proxy_http_version 1.1;
 26 | 
 27 |     # Set headers for proxying WebSocket
 28 |     proxy_set_header   Upgrade $http_upgrade;
 29 |     proxy_set_header   Connection "upgrade";
 30 |     proxy_redirect     http:// $scheme://;
 31 | 
 32 |     # Set proxy headers
 33 |     proxy_set_header   X-Real-IP $remote_addr;
 34 |     proxy_set_header   X-Forwarded-For $proxy_add_x_forwarded_for;
 35 |     proxy_set_header   X-Forwarded-Proto http;
 36 | 
 37 |     # The proxy must preserve the host because screego verifies it with the origin
 38 |     # for WebSocket connections
 39 |     proxy_set_header   Host $http_host;
 40 |   }
 41 | }
 42 | ```
 43 | 
 44 | ### At a sub path
 45 | 
 46 | ```nginx
 47 | upstream screego {
 48 |   # Set this to the address configured in
 49 |   # SCREEGO_SERVER_ADDRESS. Default 5050
 50 |   server 127.0.0.1:5050;
 51 | }
 52 | 
 53 | server {
 54 |   listen 80;
 55 | 
 56 |   # Here goes your domain / subdomain
 57 |   server_name screego.example.com;
 58 | 
 59 |   location /screego/ {
 60 |     rewrite ^/screego(/.*) $1 break;
 61 |   
 62 |     # Proxy to screego
 63 |     proxy_pass         http://screego;
 64 |     proxy_http_version 1.1;
 65 | 
 66 |     # Set headers for proxying WebSocket
 67 |     proxy_set_header   Upgrade $http_upgrade;
 68 |     proxy_set_header   Connection "upgrade";
 69 |     proxy_redirect     http:// $scheme://;
 70 | 
 71 |     # Set proxy headers
 72 |     proxy_set_header   X-Real-IP $remote_addr;
 73 |     proxy_set_header   X-Forwarded-For $proxy_add_x_forwarded_for;
 74 |     proxy_set_header   X-Forwarded-Proto http;
 75 | 
 76 |     # The proxy must preserve the host because screego verifies it with the origin
 77 |     # for WebSocket connections
 78 |     proxy_set_header   Host $http_host;
 79 |   }
 80 | }
 81 | ```
 82 | 
 83 | ## Apache (httpd)
 84 | 
 85 | The following modules are required:
 86 | 
 87 | * mod_proxy
 88 | * mod_proxy_wstunnel
 89 | * mod_proxy_http
 90 | 
 91 | ### At root path
 92 | 
 93 | ```apache
 94 | <VirtualHost *:80>
 95 |     ServerName sceego.example.com
 96 |     Keepalive On
 97 | 
 98 |     # The proxy must preserve the host because screego verifies it with the origin
 99 |     # for WebSocket connections
100 |     ProxyPreserveHost On
101 | 
102 |     # Replace 5050 with the port defined in SCREEGO_SERVER_ADDRESS.
103 |     # Default 5050
104 | 
105 |     # Proxy web socket requests to /stream
106 |     ProxyPass "/stream" ws://127.0.0.1:5050/stream retry=0 timeout=5
107 | 
108 |     # Proxy all other requests to /
109 |     ProxyPass "/" http://127.0.0.1:5050/ retry=0 timeout=5
110 | 
111 |     ProxyPassReverse / http://127.0.0.1:5050/
112 | </VirtualHost>
113 | ```
114 | 
115 | ### At a sub path
116 | 
117 | ```apache
118 | <VirtualHost *:80>
119 |     ServerName screego.example.com
120 |     Keepalive On
121 | 
122 |     Redirect 301 "/screego" "/screego/"
123 | 
124 |     # The proxy must preserve the host because screego verifies it with the origin
125 |     # for WebSocket connections
126 |     ProxyPreserveHost On
127 | 
128 |     # Proxy web socket requests to /stream
129 |     ProxyPass "/screego/stream" ws://127.0.0.1:5050/stream retry=0 timeout=5
130 | 
131 |     # Proxy all other requests to /
132 |     ProxyPass "/screego/" http://127.0.0.1:5050/ retry=0 timeout=5
133 |     #                 ^- !!trailing slash is required!!
134 | 
135 |     ProxyPassReverse /screego/ http://127.0.0.1:5050/
136 | </VirtualHost>
137 | ```
138 | 


--------------------------------------------------------------------------------
/docs/install.md:
--------------------------------------------------------------------------------
  1 | # Installation
  2 | 
  3 | Latest Version: **GITHUB_VERSION**
  4 | 
  5 | ?> Before starting Screego you may read [Configuration](config.md).
  6 | 
  7 | !> TLS is required for Screego to work. Either enable TLS inside Screego or 
  8 |    use a reverse proxy to serve Screego via TLS.
  9 | 
 10 | ## Docker
 11 | 
 12 | Setting up Screego with docker is pretty easy, you basically just have to start the docker container, and you are ready to go:
 13 | 
 14 | The [screego/server](https://hub.docker.com/r/screego/server) docker images are multi-arch docker images. 
 15 | This means the image will work for `amd64`, `i386`, `ppc64le` (power pc), `arm64`, `arm v7` (Raspberry PI).
 16 | 
 17 | When using [TURN](nat-traversal.md), Screego will allocate ports for relay connections.
 18 | 
 19 | The ports must be mapped that the host system forwards them to the screego container.
 20 | 
 21 | By default, Screego runs on port 5050.
 22 | 
 23 | ?> Replace `YOUREXTERNALIP` with your external IP. One way to find your external ip is with ipify.
 24 |    ```bash
 25 |    $ curl 'https://api.ipify.org'
 26 |    ```
 27 | 
 28 | ### Network Host (recommended)
 29 | 
 30 | ```bash
 31 | $ docker run --net=host -e SCREEGO_EXTERNAL_IP=YOUREXTERNALIP screego/server:GITHUB_VERSION
 32 | ```
 33 | 
 34 | #### docker-compose.yml
 35 | 
 36 | ```yaml
 37 | version: "3.7"
 38 | services:
 39 |   screego:
 40 |     image: screego/server:GITHUB_VERSION
 41 |     network_mode: host
 42 |     environment:
 43 |       SCREEGO_EXTERNAL_IP: "YOUREXTERNALIP"
 44 | ```
 45 | 
 46 | ### Port Range
 47 | 
 48 | `SCREEGO_TURN_STRICT_AUTH` should only be disabled if you enable TLS inside
 49 | Screego and not use a reverse proxy with `SCREEGO_TRUST_PROXY_HEADERS=true`.
 50 | 
 51 | 
 52 | ```bash
 53 | $ docker run \
 54 |     -e SCREEGO_TURN_PORT_RANGE=50000:50100 \
 55 |     -e SCREEGO_TURN_STRICT_AUTH=false \
 56 |     -e SCREEGO_EXTERNAL_IP=YOUREXTERNALIP \
 57 |     -p 5050:5050 \
 58 |     -p 3478:3478 \
 59 |     -p 50000-50100:50000-50100/udp \
 60 |     screego/server:GITHUB_VERSION
 61 | ```
 62 | 
 63 | #### docker-compose.yml
 64 | 
 65 | ```yaml
 66 | version: "3.7"
 67 | services:
 68 |   screego:
 69 |     image: screego/server:GITHUB_VERSION
 70 |     ports:
 71 |       - 5050:5050
 72 |       - 3478:3478
 73 |       - 50000-50100:50000-50100/udp
 74 |     environment:
 75 |       SCREEGO_TURN_PORT_RANGE: "50000:50100"
 76 |       SCREEGO_EXTERNAL_IP: "YOUREXTERNALIP"
 77 |       SCREEGO_TURN_STRICT_AUTH: "false"
 78 | ```
 79 | 
 80 | ## Binary
 81 | 
 82 | ### Supported Platforms:
 83 | 
 84 | * linux_amd64 (64bit)
 85 | * linux_i386 (32bit)
 86 | * armv7 (32bit used for Raspberry Pi)
 87 | * armv6
 88 | * arm64 (ARMv8)
 89 | * ppc64
 90 | * ppc64le
 91 | * windows_i386.exe (32bit)
 92 | * windows_amd64.exe (64bit)
 93 | 
 94 | Download the zip with the binary for your platform from [screego/server Releases](https://github.com/screego/server/releases).
 95 | 
 96 | ```bash
 97 | $ wget https://github.com/screego/server/releases/download/vGITHUB_VERSION/screego_GITHUB_VERSION_{PLATFORM}.tar.gz
 98 | ```
 99 | 
100 | Unzip the archive.
101 | 
102 | ```bash
103 | $ tar xvf screego_GITHUB_VERSION_{PLATFORM}.tar.gz
104 | ```
105 | 
106 | Make the binary executable (linux only).
107 | 
108 | ```bash
109 | $ chmod +x screego
110 | ```
111 | 
112 | Execute screego:
113 | 
114 | ```bash
115 | $ ./screego
116 | # on windows
117 | $ screego.exe
118 | ```
119 | 
120 | ## Arch-Linux(aur)
121 | 
122 | !> Maintenance of the AUR Packages is not performed by the Screego team.
123 |    You should always check the PKGBUILD before installing an AUR package.
124 | 
125 | Screego's latest release is available in the AUR as [screego-server](https://aur.archlinux.org/packages/screego-server/) and [screego-server-bin](https://aur.archlinux.org/packages/screego-server-bin/).
126 | The development-version can be installed with [screego-server-git](https://aur.archlinux.org/packages/screego-server-git/).
127 | 
128 | ## FreeBSD
129 | 
130 | !> Maintenance of the FreeBSD Package is not performed by the Screego team.
131 |    Check yourself, if you can trust it.
132 | 
133 | ```bash
134 | $ pkg install screego
135 | ```
136 | 
137 | ## Source
138 | 
139 | [See Development#build](development.md#build)
140 | 


--------------------------------------------------------------------------------
/ws/room.go:
--------------------------------------------------------------------------------
  1 | package ws
  2 | 
  3 | import (
  4 | 	"fmt"
  5 | 	"net"
  6 | 	"sort"
  7 | 
  8 | 	"github.com/rs/xid"
  9 | 	"github.com/screego/server/config"
 10 | 	"github.com/screego/server/util"
 11 | 	"github.com/screego/server/ws/outgoing"
 12 | )
 13 | 
 14 | type ConnectionMode string
 15 | 
 16 | const (
 17 | 	ConnectionLocal ConnectionMode = "local"
 18 | 	ConnectionSTUN  ConnectionMode = "stun"
 19 | 	ConnectionTURN  ConnectionMode = config.AuthModeTurn
 20 | )
 21 | 
 22 | type Room struct {
 23 | 	ID                string
 24 | 	CloseOnOwnerLeave bool
 25 | 	Mode              ConnectionMode
 26 | 	Users             map[xid.ID]*User
 27 | 	Sessions          map[xid.ID]*RoomSession
 28 | }
 29 | 
 30 | const (
 31 | 	CloseOwnerLeft = "Owner Left"
 32 | 	CloseDone      = "Read End"
 33 | )
 34 | 
 35 | func (r *Room) newSession(host, client xid.ID, rooms *Rooms) {
 36 | 	id := xid.New()
 37 | 	r.Sessions[id] = &RoomSession{
 38 | 		Host:   host,
 39 | 		Client: client,
 40 | 	}
 41 | 	sessionCreatedTotal.Inc()
 42 | 	clientUser := r.Users[client]
 43 | 	hostUser := r.Users[host]
 44 | 
 45 | 	iceHost := []outgoing.ICEServer{}
 46 | 	iceClient := []outgoing.ICEServer{}
 47 | 	switch r.Mode {
 48 | 	case ConnectionLocal:
 49 | 	case ConnectionSTUN:
 50 | 		iceHost = []outgoing.ICEServer{{URLs: []string{rooms.address(hostUser, "stun")}}}
 51 | 		iceClient = []outgoing.ICEServer{{URLs: []string{rooms.address(clientUser, "stun")}}}
 52 | 	case ConnectionTURN:
 53 | 		hostPW := util.RandString(20)
 54 | 		clientPW := util.RandString(20)
 55 | 		hostName := id.String() + "host"
 56 | 		rooms.turnServer.Allow(hostName, hostPW, r.Users[host].Addr)
 57 | 		clientName := id.String() + "client"
 58 | 		rooms.turnServer.Allow(clientName, clientPW, r.Users[client].Addr)
 59 | 		iceHost = []outgoing.ICEServer{{
 60 | 			URLs: []string{
 61 | 				rooms.address(hostUser, "turn"),
 62 | 				rooms.address(hostUser, "turn") + "?transport=tcp",
 63 | 			},
 64 | 			Credential: hostPW,
 65 | 			Username:   hostName,
 66 | 		}}
 67 | 		iceClient = []outgoing.ICEServer{{
 68 | 			URLs: []string{
 69 | 				rooms.address(clientUser, "turn"),
 70 | 				rooms.address(clientUser, "turn") + "?transport=tcp",
 71 | 			},
 72 | 			Credential: clientPW,
 73 | 			Username:   clientName,
 74 | 		}}
 75 | 
 76 | 	}
 77 | 	r.Users[host].Write <- outgoing.HostSession{Peer: client, ID: id, ICEServers: iceHost}
 78 | 	r.Users[client].Write <- outgoing.ClientSession{Peer: host, ID: id, ICEServers: iceClient}
 79 | }
 80 | 
 81 | func (r *Rooms) address(user *User, prefix string) string {
 82 | 	var ip string
 83 | 	if r.config.ExternalIPV6 == nil || (user.Addr.To4() != nil && r.config.ExternalIPV4 != nil) {
 84 | 		ip = r.config.ExternalIPV4.String()
 85 | 	} else {
 86 | 		ip = fmt.Sprintf("[%s]", r.config.ExternalIPV6)
 87 | 	}
 88 | 	return fmt.Sprintf("%s:%s:%s", prefix, ip, r.turnServer.Port)
 89 | }
 90 | 
 91 | func (r *Room) closeSession(rooms *Rooms, id xid.ID) {
 92 | 	if r.Mode == ConnectionTURN {
 93 | 		rooms.turnServer.Disallow(id.String() + "host")
 94 | 		rooms.turnServer.Disallow(id.String() + "client")
 95 | 	}
 96 | 	delete(r.Sessions, id)
 97 | 	sessionClosedTotal.Inc()
 98 | }
 99 | 
100 | type RoomSession struct {
101 | 	Host   xid.ID
102 | 	Client xid.ID
103 | }
104 | 
105 | func (r *Room) notifyInfoChanged() {
106 | 	for _, current := range r.Users {
107 | 		users := []outgoing.User{}
108 | 		for _, user := range r.Users {
109 | 			users = append(users, outgoing.User{
110 | 				ID:        user.ID,
111 | 				Name:      user.Name,
112 | 				Streaming: user.Streaming,
113 | 				You:       current == user,
114 | 				Owner:     user.Owner,
115 | 			})
116 | 		}
117 | 
118 | 		sort.Slice(users, func(i, j int) bool {
119 | 			left := users[i]
120 | 			right := users[j]
121 | 
122 | 			if left.Owner != right.Owner {
123 | 				return left.Owner
124 | 			}
125 | 
126 | 			if left.Streaming != right.Streaming {
127 | 				return left.Streaming
128 | 			}
129 | 
130 | 			return left.Name < right.Name
131 | 		})
132 | 
133 | 		current.Write <- outgoing.Room{
134 | 			ID:    r.ID,
135 | 			Users: users,
136 | 		}
137 | 	}
138 | }
139 | 
140 | type User struct {
141 | 	ID        xid.ID
142 | 	Addr      net.IP
143 | 	Name      string
144 | 	Streaming bool
145 | 	Owner     bool
146 | 	Write     chan<- outgoing.Message
147 | 	Close     chan<- string
148 | }
149 | 


--------------------------------------------------------------------------------
/turn/server.go:
--------------------------------------------------------------------------------
  1 | package turn
  2 | 
  3 | import (
  4 | 	"fmt"
  5 | 	"net"
  6 | 	"strings"
  7 | 	"sync"
  8 | 
  9 | 	"github.com/pion/turn/v2"
 10 | 	"github.com/rs/zerolog/log"
 11 | 	"github.com/screego/server/config"
 12 | )
 13 | 
 14 | type Server struct {
 15 | 	Port       string
 16 | 	lock       sync.RWMutex
 17 | 	strictAuth bool
 18 | 	lookup     map[string]Entry
 19 | }
 20 | 
 21 | type Entry struct {
 22 | 	addr     net.IP
 23 | 	password []byte
 24 | }
 25 | 
 26 | const Realm = "screego"
 27 | 
 28 | type Generator struct {
 29 | 	ipv4 net.IP
 30 | 	ipv6 net.IP
 31 | 	turn.RelayAddressGenerator
 32 | }
 33 | 
 34 | func (r *Generator) AllocatePacketConn(network string, requestedPort int) (net.PacketConn, net.Addr, error) {
 35 | 	conn, addr, err := r.RelayAddressGenerator.AllocatePacketConn(network, requestedPort)
 36 | 	relayAddr := *addr.(*net.UDPAddr)
 37 | 	if r.ipv6 == nil || (relayAddr.IP.To4() != nil && r.ipv4 != nil) {
 38 | 		relayAddr.IP = r.ipv4
 39 | 	} else {
 40 | 		relayAddr.IP = r.ipv6
 41 | 	}
 42 | 	if err == nil {
 43 | 		log.Debug().Str("addr", addr.String()).Str("relayaddr", relayAddr.String()).Msg("TURN allocated")
 44 | 	}
 45 | 	return conn, &relayAddr, err
 46 | }
 47 | 
 48 | func Start(conf config.Config) (*Server, error) {
 49 | 	udpListener, err := net.ListenPacket("udp", conf.TurnAddress)
 50 | 	if err != nil {
 51 | 		return nil, fmt.Errorf("udp: could not listen on %s: %s", conf.TurnAddress, err)
 52 | 	}
 53 | 	tcpListener, err := net.Listen("tcp", conf.TurnAddress)
 54 | 	if err != nil {
 55 | 		return nil, fmt.Errorf("tcp: could not listen on %s: %s", conf.TurnAddress, err)
 56 | 	}
 57 | 
 58 | 	split := strings.Split(conf.TurnAddress, ":")
 59 | 	svr := &Server{
 60 | 		Port:       split[len(split)-1],
 61 | 		lookup:     map[string]Entry{},
 62 | 		strictAuth: conf.TurnStrictAuth,
 63 | 	}
 64 | 
 65 | 	gen := &Generator{
 66 | 		ipv4:                  conf.ExternalIPV4,
 67 | 		ipv6:                  conf.ExternalIPV6,
 68 | 		RelayAddressGenerator: generator(conf),
 69 | 	}
 70 | 
 71 | 	_, err = turn.NewServer(turn.ServerConfig{
 72 | 		Realm:       Realm,
 73 | 		AuthHandler: svr.authenticate,
 74 | 		ListenerConfigs: []turn.ListenerConfig{
 75 | 			{Listener: tcpListener, RelayAddressGenerator: gen},
 76 | 		},
 77 | 		PacketConnConfigs: []turn.PacketConnConfig{
 78 | 			{PacketConn: udpListener, RelayAddressGenerator: gen},
 79 | 		},
 80 | 	})
 81 | 	if err != nil {
 82 | 		return nil, err
 83 | 	}
 84 | 
 85 | 	log.Info().Str("addr", conf.TurnAddress).Msg("Start TURN/STUN")
 86 | 	return svr, nil
 87 | }
 88 | 
 89 | func generator(conf config.Config) turn.RelayAddressGenerator {
 90 | 	min, max, useRange := conf.PortRange()
 91 | 	if useRange {
 92 | 		log.Debug().Uint16("min", min).Uint16("max", max).Msg("Using Port Range")
 93 | 		return &RelayAddressGeneratorPortRange{MinPort: min, MaxPort: max}
 94 | 	}
 95 | 	return &RelayAddressGeneratorNone{}
 96 | }
 97 | 
 98 | func (a *Server) Allow(username, password string, addr net.IP) {
 99 | 	a.lock.Lock()
100 | 	defer a.lock.Unlock()
101 | 	a.lookup[username] = Entry{
102 | 		addr:     addr,
103 | 		password: turn.GenerateAuthKey(username, Realm, password),
104 | 	}
105 | }
106 | 
107 | func (a *Server) Disallow(username string) {
108 | 	a.lock.Lock()
109 | 	defer a.lock.Unlock()
110 | 
111 | 	delete(a.lookup, username)
112 | }
113 | 
114 | func (a *Server) authenticate(username, realm string, addr net.Addr) ([]byte, bool) {
115 | 	a.lock.RLock()
116 | 	defer a.lock.RUnlock()
117 | 
118 | 	var connectedIp net.IP
119 | 	switch addr := addr.(type) {
120 | 	case *net.UDPAddr:
121 | 		connectedIp = addr.IP
122 | 	case *net.TCPAddr:
123 | 		connectedIp = addr.IP
124 | 	default:
125 | 		log.Error().Interface("type", fmt.Sprintf("%T", addr)).Msg("unknown addr type")
126 | 		return nil, false
127 | 	}
128 | 	entry, ok := a.lookup[username]
129 | 
130 | 	if !ok {
131 | 		log.Debug().Interface("addr", addr).Str("username", username).Msg("TURN username not found")
132 | 		return nil, false
133 | 	}
134 | 
135 | 	authIP := entry.addr
136 | 
137 | 	if a.strictAuth && !connectedIp.Equal(authIP) {
138 | 		log.Debug().Interface("allowedIp", addr.String()).Interface("connectingIp", entry.addr.String()).Msg("TURN strict auth check failed")
139 | 		return nil, false
140 | 	}
141 | 
142 | 	log.Debug().Interface("addr", addr.String()).Str("realm", realm).Msg("TURN authenticated")
143 | 	return entry.password, true
144 | }
145 | 


--------------------------------------------------------------------------------
/.goreleaser.yml:
--------------------------------------------------------------------------------
  1 | # This is an example goreleaser.yaml file with some sane defaults.
  2 | # Make sure to check the documentation at http://goreleaser.com
  3 | project_name: screego
  4 | before:
  5 |   hooks:
  6 |     - go mod download
  7 |     - go run hack/packr/packr.go
  8 | builds:
  9 |   - env:
 10 |       - CGO_ENABLED=0
 11 |     goos:
 12 |       - linux
 13 |       - windows
 14 |       - darwin
 15 |       - freebsd
 16 |       - openbsd
 17 |     goarch:
 18 |       - 386
 19 |       - amd64
 20 |       - arm
 21 |       - arm64
 22 |       - ppc64
 23 |       - ppc64le
 24 |     goarm:
 25 |       - 6
 26 |       - 7
 27 |     flags:
 28 |       - '-tags="netgo osusergo"'
 29 |     ldflags:
 30 |       - '-s'
 31 |       - '-w'
 32 |       - '-X main.version={{.Version}}'
 33 |       - '-X main.commitHash={{.Commit}}'
 34 |       - '-X main.mode=prod'
 35 | archives:
 36 |   - files:
 37 |       - LICENSE
 38 |       - README.md
 39 |       - screego.config.example
 40 |     replacements:
 41 |       386: i386
 42 |     format_overrides:
 43 |       - goos: windows
 44 |         format: zip
 45 | checksum:
 46 | changelog:
 47 |   skip: true
 48 | dockers:
 49 |   - goos: linux
 50 |     goarch: amd64
 51 |     goarm: ''
 52 |     binaries:
 53 |       - screego
 54 |     image_templates:
 55 |       - "screego/server:amd64-unstable"
 56 |       - "screego/server:amd64-{{ .RawVersion }}"
 57 |       - "screego/server:amd64-{{ .Major }}"
 58 |     dockerfile: Dockerfile
 59 |     build_flag_templates:
 60 |       - "--label=org.opencontainers.image.created={{.Date}}"
 61 |       - "--label=org.opencontainers.image.title={{.ProjectName}}"
 62 |       - "--label=org.opencontainers.image.revision={{.FullCommit}}"
 63 |       - "--label=org.opencontainers.image.version={{.Version}}"
 64 |   - goos: linux
 65 |     goarch: 386
 66 |     binaries:
 67 |       - screego
 68 |     goarm: ''
 69 |     image_templates:
 70 |       - "screego/server:386-unstable"
 71 |       - "screego/server:386-{{ .RawVersion }}"
 72 |       - "screego/server:386-{{ .Major }}"
 73 |     dockerfile: Dockerfile
 74 |     build_flag_templates:
 75 |       - "--label=org.opencontainers.image.created={{.Date}}"
 76 |       - "--label=org.opencontainers.image.title={{.ProjectName}}"
 77 |       - "--label=org.opencontainers.image.revision={{.FullCommit}}"
 78 |       - "--label=org.opencontainers.image.version={{.Version}}"
 79 |   - goos: linux
 80 |     goarch: arm64
 81 |     goarm: ''
 82 |     binaries:
 83 |       - screego
 84 |     image_templates:
 85 |       - "screego/server:arm64-unstable"
 86 |       - "screego/server:arm64-{{ .RawVersion }}"
 87 |       - "screego/server:arm64-{{ .Major }}"
 88 |     dockerfile: Dockerfile
 89 |     build_flag_templates:
 90 |       - "--label=org.opencontainers.image.created={{.Date}}"
 91 |       - "--label=org.opencontainers.image.title={{.ProjectName}}"
 92 |       - "--label=org.opencontainers.image.revision={{.FullCommit}}"
 93 |       - "--label=org.opencontainers.image.version={{.Version}}"
 94 |   - goos: linux
 95 |     goarch: arm
 96 |     goarm: 7
 97 |     binaries:
 98 |       - screego
 99 |     image_templates:
100 |       - "screego/server:armv7-unstable"
101 |       - "screego/server:armv7-{{ .RawVersion }}"
102 |       - "screego/server:armv7-{{ .Major }}"
103 |     dockerfile: Dockerfile
104 |     build_flag_templates:
105 |       - "--label=org.opencontainers.image.created={{.Date}}"
106 |       - "--label=org.opencontainers.image.title={{.ProjectName}}"
107 |       - "--label=org.opencontainers.image.revision={{.FullCommit}}"
108 |       - "--label=org.opencontainers.image.version={{.Version}}"
109 |   - goos: linux
110 |     goarch: arm
111 |     goarm: 6
112 |     binaries:
113 |       - screego
114 |     image_templates:
115 |       - "screego/server:armv6-unstable"
116 |       - "screego/server:armv6-{{ .RawVersion }}"
117 |       - "screego/server:armv6-{{ .Major }}"
118 |     dockerfile: Dockerfile
119 |     build_flag_templates:
120 |       - "--label=org.opencontainers.image.created={{.Date}}"
121 |       - "--label=org.opencontainers.image.title={{.ProjectName}}"
122 |       - "--label=org.opencontainers.image.revision={{.FullCommit}}"
123 |       - "--label=org.opencontainers.image.version={{.Version}}"
124 |   - goos: linux
125 |     goarch: ppc64le
126 |     goarm: ''
127 |     binaries:
128 |       - screego
129 |     image_templates:
130 |       - "screego/server:ppc64le-unstable"
131 |       - "screego/server:ppc64le-{{ .RawVersion }}"
132 |       - "screego/server:ppc64le-{{ .Major }}"
133 |     dockerfile: Dockerfile
134 |     build_flag_templates:
135 |       - "--label=org.opencontainers.image.created={{.Date}}"
136 |       - "--label=org.opencontainers.image.title={{.ProjectName}}"
137 |       - "--label=org.opencontainers.image.revision={{.FullCommit}}"
138 |       - "--label=org.opencontainers.image.version={{.Version}}"
139 | 


--------------------------------------------------------------------------------
/ws/client.go:
--------------------------------------------------------------------------------
  1 | package ws
  2 | 
  3 | import (
  4 | 	"fmt"
  5 | 	"github.com/gorilla/websocket"
  6 | 	"github.com/rs/xid"
  7 | 	"github.com/rs/zerolog"
  8 | 	"github.com/rs/zerolog/log"
  9 | 	"github.com/screego/server/ws/outgoing"
 10 | 	"net"
 11 | 	"net/http"
 12 | 	"strings"
 13 | 	"time"
 14 | )
 15 | 
 16 | var ping = func(conn *websocket.Conn) error {
 17 | 	return conn.WriteMessage(websocket.PingMessage, nil)
 18 | }
 19 | 
 20 | var writeJSON = func(conn *websocket.Conn, v interface{}) error {
 21 | 	return conn.WriteJSON(v)
 22 | }
 23 | 
 24 | const (
 25 | 	writeWait = 2 * time.Second
 26 | )
 27 | 
 28 | type Client struct {
 29 | 	conn *websocket.Conn
 30 | 	info ClientInfo
 31 | 	once once
 32 | 	read chan<- ClientMessage
 33 | }
 34 | 
 35 | type ClientMessage struct {
 36 | 	Info     ClientInfo
 37 | 	Incoming Event
 38 | }
 39 | 
 40 | type ClientInfo struct {
 41 | 	ID                xid.ID
 42 | 	RoomID            string
 43 | 	Authenticated     bool
 44 | 	AuthenticatedUser string
 45 | 	Write             chan outgoing.Message
 46 | 	Close             chan string
 47 | 	Addr              net.IP
 48 | }
 49 | 
 50 | func newClient(conn *websocket.Conn, req *http.Request, read chan ClientMessage, authenticatedUser string, authenticated, trustProxy bool) *Client {
 51 | 
 52 | 	ip := conn.RemoteAddr().(*net.TCPAddr).IP
 53 | 	if realIP := req.Header.Get("X-Real-IP"); trustProxy && realIP != "" {
 54 | 		ip = net.ParseIP(realIP)
 55 | 	}
 56 | 
 57 | 	client := &Client{
 58 | 		conn: conn,
 59 | 		info: ClientInfo{
 60 | 			Authenticated:     authenticated,
 61 | 			AuthenticatedUser: authenticatedUser,
 62 | 			ID:                xid.New(),
 63 | 			RoomID:            "",
 64 | 			Addr:              ip,
 65 | 			Write:             make(chan outgoing.Message, 1),
 66 | 			Close:             make(chan string, 1),
 67 | 		},
 68 | 		read: read,
 69 | 	}
 70 | 	client.debug().Msg("WebSocket New Connection")
 71 | 	conn.SetCloseHandler(func(code int, text string) error {
 72 | 		message := websocket.FormatCloseMessage(code, text)
 73 | 		client.debug().Str("reason", text).Int("code", code).Msg("WebSocket Close")
 74 | 		return conn.WriteControl(websocket.CloseMessage, message, time.Now().Add(writeWait))
 75 | 	})
 76 | 	return client
 77 | }
 78 | 
 79 | // Close closes the connection.
 80 | func (c *Client) Close() {
 81 | 	c.once.Do(func() {
 82 | 		c.conn.Close()
 83 | 		go func() {
 84 | 			c.read <- ClientMessage{
 85 | 				Info:     c.info,
 86 | 				Incoming: &Disconnected{},
 87 | 			}
 88 | 		}()
 89 | 	})
 90 | }
 91 | 
 92 | // startWriteHandler starts listening on the client connection. As we do not need anything from the client,
 93 | // we ignore incoming messages. Leaves the loop on errors.
 94 | func (c *Client) startReading(pongWait time.Duration) {
 95 | 	defer c.Close()
 96 | 	_ = c.conn.SetReadDeadline(time.Now().Add(pongWait))
 97 | 	c.conn.SetPongHandler(func(appData string) error {
 98 | 		_ = c.conn.SetReadDeadline(time.Now().Add(pongWait))
 99 | 		return nil
100 | 	})
101 | 	for {
102 | 		t, m, err := c.conn.NextReader()
103 | 		if err != nil {
104 | 			c.printWebSocketError("read", err)
105 | 			return
106 | 		}
107 | 		if t == websocket.BinaryMessage {
108 | 			_ = c.conn.CloseHandler()(websocket.CloseUnsupportedData, fmt.Sprintf("unsupported binary message type: %s", err))
109 | 			return
110 | 		}
111 | 
112 | 		incoming, err := ReadTypedIncoming(m)
113 | 		if err != nil {
114 | 			_ = c.conn.CloseHandler()(websocket.CloseNormalClosure, fmt.Sprintf("malformed message: %s", err))
115 | 			return
116 | 		}
117 | 		c.debug().Interface("event", fmt.Sprintf("%T", incoming)).Msg("WebSocket Receive")
118 | 		c.read <- ClientMessage{Info: c.info, Incoming: incoming}
119 | 	}
120 | }
121 | 
122 | // startWriteHandler starts the write loop. The method has the following tasks:
123 | // * ping the client in the interval provided as parameter
124 | // * write messages send by the channel to the client
125 | // * on errors exit the loop
126 | func (c *Client) startWriteHandler(pingPeriod time.Duration) {
127 | 	pingTicker := time.NewTicker(pingPeriod)
128 | 
129 | 	dead := false
130 | 	conClosed := func() {
131 | 		dead = true
132 | 		c.Close()
133 | 		pingTicker.Stop()
134 | 	}
135 | 	defer conClosed()
136 | 	defer func() {
137 | 		c.debug().Msg("WebSocket Done")
138 | 	}()
139 | 	for {
140 | 		select {
141 | 		case reason := <-c.info.Close:
142 | 			if reason == CloseDone {
143 | 				return
144 | 			} else {
145 | 				_ = c.conn.CloseHandler()(websocket.CloseNormalClosure, reason)
146 | 				conClosed()
147 | 			}
148 | 		case message := <-c.info.Write:
149 | 			if dead {
150 | 				c.debug().Msg("WebSocket write on dead connection")
151 | 				continue
152 | 			}
153 | 
154 | 			_ = c.conn.SetWriteDeadline(time.Now().Add(writeWait))
155 | 			typed, err := ToTypedOutgoing(message)
156 | 			c.debug().Interface("event", typed.Type).Msg("WebSocket Send")
157 | 			if err != nil {
158 | 				c.debug().Err(err).Msg("could not get typed message, exiting connection.")
159 | 				conClosed()
160 | 				continue
161 | 			}
162 | 
163 | 			if room, ok := message.(outgoing.Room); ok {
164 | 				c.info.RoomID = room.ID
165 | 			}
166 | 
167 | 			if err := writeJSON(c.conn, typed); err != nil {
168 | 				conClosed()
169 | 				c.printWebSocketError("write", err)
170 | 			}
171 | 		case <-pingTicker.C:
172 | 			_ = c.conn.SetWriteDeadline(time.Now().Add(writeWait))
173 | 			if err := ping(c.conn); err != nil {
174 | 				conClosed()
175 | 				c.printWebSocketError("ping", err)
176 | 			}
177 | 		}
178 | 	}
179 | }
180 | 
181 | func (c *Client) debug() *zerolog.Event {
182 | 	return log.Debug().Str("id", c.info.ID.String()).Str("ip", c.info.Addr.String())
183 | }
184 | 
185 | func (c *Client) printWebSocketError(typex string, err error) {
186 | 	if strings.Contains(err.Error(), "use of closed network connection") {
187 | 		return
188 | 	}
189 | 	closeError, ok := err.(*websocket.CloseError)
190 | 
191 | 	if ok && closeError != nil && (closeError.Code == 1000 || closeError.Code == 1001) {
192 | 		// normal closure
193 | 		return
194 | 	}
195 | 
196 | 	c.debug().Str("type", typex).Err(err).Msg("WebSocket Error")
197 | }
198 | 


--------------------------------------------------------------------------------
/ui/src/RoomManage.tsx:
--------------------------------------------------------------------------------
  1 | import React from 'react';
  2 | import {
  3 |     Button,
  4 |     Checkbox,
  5 |     FormControl,
  6 |     FormControlLabel,
  7 |     Grid,
  8 |     IconButton,
  9 |     InputLabel,
 10 |     MenuItem,
 11 |     Paper,
 12 |     Select,
 13 |     TextField,
 14 |     Typography,
 15 |     Link,
 16 | } from '@material-ui/core';
 17 | import {FCreateRoom, UseRoom} from './useRoom';
 18 | import {RoomMode, UIConfig} from './message';
 19 | import {randomRoomName} from './name';
 20 | import HelpIcon from '@material-ui/icons/Help';
 21 | import logo from './logo.svg';
 22 | import {UseConfig} from './useConfig';
 23 | import {LoginForm} from './LoginForm';
 24 | 
 25 | const defaultMode = (authMode: UIConfig['authMode'], loggedIn: boolean): RoomMode => {
 26 |     if (loggedIn) {
 27 |         return RoomMode.Turn;
 28 |     }
 29 |     switch (authMode) {
 30 |         case 'all':
 31 |             return RoomMode.Turn;
 32 |         case 'turn':
 33 |             return RoomMode.Stun;
 34 |         case 'none':
 35 |         default:
 36 |             return RoomMode.Turn;
 37 |     }
 38 | };
 39 | 
 40 | const CreateRoom = ({room, config}: Pick<UseRoom, 'room'> & {config: UIConfig}) => {
 41 |     const [id, setId] = React.useState(randomRoomName);
 42 |     const [mode, setMode] = React.useState<RoomMode>(defaultMode(config.authMode, config.loggedIn));
 43 |     const [ownerLeave, setOwnerLeave] = React.useState(true);
 44 |     const submit = () =>
 45 |         room({
 46 |             type: 'create',
 47 |             payload: {
 48 |                 mode,
 49 |                 closeOnOwnerLeave: ownerLeave,
 50 |                 id: id || undefined,
 51 |             },
 52 |         });
 53 |     return (
 54 |         <div>
 55 |             <FormControl fullWidth>
 56 |                 <TextField
 57 |                     fullWidth
 58 |                     value={id}
 59 |                     onChange={(e) => setId(e.target.value)}
 60 |                     label="id"
 61 |                     margin="dense"
 62 |                 />
 63 |                 <FormControlLabel
 64 |                     control={
 65 |                         <Checkbox
 66 |                             checked={ownerLeave}
 67 |                             onChange={(_, checked) => setOwnerLeave(checked)}
 68 |                         />
 69 |                     }
 70 |                     label="Close Room after you leave"
 71 |                 />
 72 |                 <FormControl margin="dense">
 73 |                     <InputLabel>NAT Traversal via</InputLabel>
 74 |                     <Select
 75 |                         fullWidth
 76 |                         value={mode}
 77 |                         onChange={(x) => setMode(x.target.value as RoomMode)}
 78 |                         endAdornment={
 79 |                             <IconButton size="small" href="https://screego.net/#/nat-traversal">
 80 |                                 <HelpIcon />
 81 |                             </IconButton>
 82 |                         }>
 83 |                         <MenuItem
 84 |                             value={RoomMode.Stun}
 85 |                             disabled={config.authMode === 'all' && !config.loggedIn}>
 86 |                             STUN
 87 |                         </MenuItem>
 88 |                         <MenuItem
 89 |                             value={RoomMode.Turn}
 90 |                             disabled={config.authMode !== 'none' && !config.loggedIn}>
 91 |                             TURN
 92 |                         </MenuItem>
 93 |                     </Select>
 94 |                 </FormControl>
 95 |                 <Button onClick={submit} fullWidth variant="contained">
 96 |                     Create Room
 97 |                 </Button>
 98 |             </FormControl>
 99 |         </div>
100 |     );
101 | };
102 | 
103 | export const RoomManage = ({room, config}: {room: FCreateRoom; config: UseConfig}) => {
104 |     const [showLogin, setShowLogin] = React.useState(false);
105 | 
106 |     const canCreateRoom = config.authMode !== 'all';
107 |     const loginVisible = !config.loggedIn && (showLogin || !canCreateRoom);
108 | 
109 |     return (
110 |         <Grid
111 |             container={true}
112 |             justify="center"
113 |             style={{paddingTop: 50, maxWidth: 400, width: '100%', margin: '0 auto'}}
114 |             spacing={4}>
115 |             <Grid item xs={12}>
116 |                 <Typography align="center" gutterBottom>
117 |                     <img src={logo} style={{width: 230}} alt="logo" />
118 |                 </Typography>
119 |                 <Paper elevation={3} style={{padding: 20}}>
120 |                     {loginVisible ? (
121 |                         <LoginForm
122 |                             config={config}
123 |                             hide={canCreateRoom ? () => setShowLogin(false) : undefined}
124 |                         />
125 |                     ) : (
126 |                         <>
127 |                             <Typography style={{display: 'flex', alignItems: 'center'}}>
128 |                                 <span style={{flex: 1}}>Hello {config.user}!</span>{' '}
129 |                                 {config.loggedIn ? (
130 |                                     <Button variant="outlined" size="small" onClick={config.logout}>
131 |                                         Logout
132 |                                     </Button>
133 |                                 ) : (
134 |                                     <Button
135 |                                         variant="outlined"
136 |                                         size="small"
137 |                                         onClick={() => setShowLogin(true)}>
138 |                                         Login
139 |                                     </Button>
140 |                                 )}
141 |                             </Typography>
142 | 
143 |                             <CreateRoom room={room} config={config} />
144 |                         </>
145 |                     )}
146 |                 </Paper>
147 |             </Grid>
148 |             <div style={{position: 'absolute', margin: '0 auto', bottom: 0}}>
149 |                 Screego {config.version} |{' '}
150 |                 <Link href="https://github.com/screego/server/">GitHub</Link>
151 |             </div>
152 |         </Grid>
153 |     );
154 | };
155 | 


--------------------------------------------------------------------------------
/ui/src/serviceWorker.ts:
--------------------------------------------------------------------------------
  1 | // This optional code is used to register a service worker.
  2 | // register() is not called by default.
  3 | 
  4 | // This lets the app load faster on subsequent visits in production, and gives
  5 | // it offline capabilities. However, it also means that developers (and users)
  6 | // will only see deployed updates on subsequent visits to a page, after all the
  7 | // existing tabs open on the page have been closed, since previously cached
  8 | // resources are updated in the background.
  9 | 
 10 | // To learn more about the benefits of this model and instructions on how to
 11 | // opt-in, read https://bit.ly/CRA-PWA
 12 | 
 13 | const isLocalhost = Boolean(
 14 |     window.location.hostname === 'localhost' ||
 15 |         // [::1] is the IPv6 localhost address.
 16 |         window.location.hostname === '[::1]' ||
 17 |         // 127.0.0.0/8 are considered localhost for IPv4.
 18 |         window.location.hostname.match(/^127(?:\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)){3}$/)
 19 | );
 20 | 
 21 | type Config = {
 22 |     onSuccess?: (registration: ServiceWorkerRegistration) => void;
 23 |     onUpdate?: (registration: ServiceWorkerRegistration) => void;
 24 | };
 25 | 
 26 | export function register(config?: Config) {
 27 |     if (process.env.NODE_ENV === 'production' && 'serviceWorker' in navigator) {
 28 |         // The URL constructor is available in all browsers that support SW.
 29 |         const publicUrl = new URL(process.env.PUBLIC_URL, window.location.href);
 30 |         if (publicUrl.origin !== window.location.origin) {
 31 |             // Our service worker won't work if PUBLIC_URL is on a different origin
 32 |             // from what our page is served on. This might happen if a CDN is used to
 33 |             // serve assets; see https://github.com/facebook/create-react-app/issues/2374
 34 |             return;
 35 |         }
 36 | 
 37 |         window.addEventListener('load', () => {
 38 |             const swUrl = `${process.env.PUBLIC_URL}/service-worker.js`;
 39 | 
 40 |             if (isLocalhost) {
 41 |                 // This is running on localhost. Let's check if a service worker still exists or not.
 42 |                 checkValidServiceWorker(swUrl, config);
 43 | 
 44 |                 // Add some additional logging to localhost, pointing developers to the
 45 |                 // service worker/PWA documentation.
 46 |                 navigator.serviceWorker.ready.then(() => {
 47 |                     console.log(
 48 |                         'This web app is being served cache-first by a service ' +
 49 |                             'worker. To learn more, visit https://bit.ly/CRA-PWA'
 50 |                     );
 51 |                 });
 52 |             } else {
 53 |                 // Is not localhost. Just register service worker
 54 |                 registerValidSW(swUrl, config);
 55 |             }
 56 |         });
 57 |     }
 58 | }
 59 | 
 60 | function registerValidSW(swUrl: string, config?: Config) {
 61 |     navigator.serviceWorker
 62 |         .register(swUrl)
 63 |         .then((registration) => {
 64 |             registration.onupdatefound = () => {
 65 |                 const installingWorker = registration.installing;
 66 |                 if (installingWorker == null) {
 67 |                     return;
 68 |                 }
 69 |                 installingWorker.onstatechange = () => {
 70 |                     if (installingWorker.state === 'installed') {
 71 |                         if (navigator.serviceWorker.controller) {
 72 |                             // At this point, the updated precached content has been fetched,
 73 |                             // but the previous service worker will still serve the older
 74 |                             // content until all client tabs are closed.
 75 |                             console.log(
 76 |                                 'New content is available and will be used when all ' +
 77 |                                     'tabs for this page are closed. See https://bit.ly/CRA-PWA.'
 78 |                             );
 79 | 
 80 |                             // Execute callback
 81 |                             if (config && config.onUpdate) {
 82 |                                 config.onUpdate(registration);
 83 |                             }
 84 |                         } else {
 85 |                             // At this point, everything has been precached.
 86 |                             // It's the perfect time to display a
 87 |                             // "Content is cached for offline use." message.
 88 |                             console.log('Content is cached for offline use.');
 89 | 
 90 |                             // Execute callback
 91 |                             if (config && config.onSuccess) {
 92 |                                 config.onSuccess(registration);
 93 |                             }
 94 |                         }
 95 |                     }
 96 |                 };
 97 |             };
 98 |         })
 99 |         .catch((error) => {
100 |             console.error('Error during service worker registration:', error);
101 |         });
102 | }
103 | 
104 | function checkValidServiceWorker(swUrl: string, config?: Config) {
105 |     // Check if the service worker can be found. If it can't reload the page.
106 |     fetch(swUrl, {
107 |         headers: {'Service-Worker': 'script'},
108 |     })
109 |         .then((response) => {
110 |             // Ensure service worker exists, and that we really are getting a JS file.
111 |             const contentType = response.headers.get('content-type');
112 |             if (
113 |                 response.status === 404 ||
114 |                 (contentType != null && contentType.indexOf('javascript') === -1)
115 |             ) {
116 |                 // No service worker found. Probably a different app. Reload the page.
117 |                 navigator.serviceWorker.ready.then((registration) => {
118 |                     registration.unregister().then(() => {
119 |                         window.location.reload();
120 |                     });
121 |                 });
122 |             } else {
123 |                 // Service worker found. Proceed as normal.
124 |                 registerValidSW(swUrl, config);
125 |             }
126 |         })
127 |         .catch(() => {
128 |             console.log('No internet connection found. App is running in offline mode.');
129 |         });
130 | }
131 | 
132 | export function unregister() {
133 |     if ('serviceWorker' in navigator) {
134 |         navigator.serviceWorker.ready
135 |             .then((registration) => {
136 |                 registration.unregister();
137 |             })
138 |             .catch((error) => {
139 |                 console.error(error.message);
140 |             });
141 |     }
142 | }
143 | 


--------------------------------------------------------------------------------
/util/sillyname.go:
--------------------------------------------------------------------------------
 1 | // Inspired by https://github.com/TheDeveloper/sillyname/blob/master/index.js#L18
 2 | 
 3 | package util
 4 | 
 5 | import (
 6 | 	"math/rand"
 7 | 	"strings"
 8 | )
 9 | 
10 | var adjectives = []string{"Black", "White", "Gray", "Brown", "Red", "Pink", "Crimson", "Carnelian", "Orange", "Yellow", "Ivory", "Cream", "Green", "Viridian", "Aquamarine", "Cyan", "Blue", "Cerulean", "Azure", "Indigo", "Navy", "Violet", "Purple", "Lavender", "Magenta", "Rainbow", "Iridescent", "Spectrum", "Prism", "Bold", "Vivid", "Pale", "Clear", "Glass", "Translucent", "Misty", "Dark", "Light", "Gold", "Silver", "Copper", "Bronze", "Steel", "Iron", "Brass", "Mercury", "Zinc", "Chrome", "Platinum", "Titanium", "Nickel", "Lead", "Pewter", "Rust", "Metal", "Stone", "Quartz", "Granite", "Marble", "Alabaster", "Agate", "Jasper", "Pebble", "Pyrite", "Crystal", "Geode", "Obsidian", "Mica", "Flint", "Sand", "Gravel", "Boulder", "Basalt", "Ruby", "Beryl", "Scarlet", "Citrine", "Sulpher", "Topaz", "Amber", "Emerald", "Malachite", "Jade", "Abalone", "Lapis", "Sapphire", "Diamond", "Peridot", "Gem", "Jewel", "Bevel", "Coral", "Jet", "Ebony", "Wood", "Tree", "Cherry", "Maple", "Cedar", "Branch", "Bramble", "Rowan", "Ash", "Fir", "Pine", "Cactus", "Alder", "Grove", "Forest", "Jungle", "Palm", "Bush", "Mulberry", "Juniper", "Vine", "Ivy", "Rose", "Lily", "Tulip", "Daffodil", "Honeysuckle", "Fuschia", "Hazel", "Walnut", "Almond", "Lime", "Lemon", "Apple", "Blossom", "Bloom", "Crocus", "Rose", "Buttercup", "Dandelion", "Iris", "Carnation", "Fern", "Root", "Branch", "Leaf", "Seed", "Flower", "Petal", "Pollen", "Orchid", "Mangrove", "Cypress", "Sequoia", "Sage", "Heather", "Snapdragon", "Daisy", "Mountain", "Hill", "Alpine", "Chestnut", "Valley", "Glacier", "Forest", "Grove", "Glen", "Tree", "Thorn", "Stump", "Desert", "Canyon", "Dune", "Oasis", "Mirage", "Well", "Spring", "Meadow", "Field", "Prairie", "Grass", "Tundra", "Island", "Shore", "Sand", "Shell", "Surf", "Wave", "Foam", "Tide", "Lake", "River", "Brook", "Stream", "Pool", "Pond", "Sun", "Sprinkle", "Shade", "Shadow", "Rain", "Cloud", "Storm", "Hail", "Snow", "Sleet", "Thunder", "Lightning", "Wind", "Hurricane", "Typhoon", "Dawn", "Sunrise", "Morning", "Noon", "Twilight", "Evening", "Sunset", "Midnight", "Night", "Sky", "Star", "Stellar", "Comet", "Nebula", "Quasar", "Solar", "Lunar", "Planet", "Meteor", "Sprout", "Pear", "Plum", "Kiwi", "Berry", "Apricot", "Peach", "Mango", "Pineapple", "Coconut", "Olive", "Ginger", "Root", "Plain", "Fancy", "Stripe", "Spot", "Speckle", "Spangle", "Ring", "Band", "Blaze", "Paint", "Pinto", "Shade", "Tabby", "Brindle", "Patch", "Calico", "Checker", "Dot", "Pattern", "Glitter", "Glimmer", "Shimmer", "Dull", "Dust", "Dirt", "Glaze", "Scratch", "Quick", "Swift", "Fast", "Slow", "Clever", "Fire", "Flicker", "Flash", "Spark", "Ember", "Coal", "Flame", "Chocolate", "Vanilla", "Sugar", "Spice", "Cake", "Pie", "Cookie", "Candy", "Caramel", "Spiral", "Round", "Jelly", "Square", "Narrow", "Long", "Short", "Small", "Tiny", "Big", "Giant", "Great", "Atom", "Peppermint", "Mint", "Butter", "Fringe", "Rag", "Quilt", "Truth", "Lie", "Holy", "Curse", "Noble", "Sly", "Brave", "Shy", "Lava", "Foul", "Leather", "Fantasy", "Keen", "Luminous", "Feather", "Sticky", "Gossamer", "Cotton", "Rattle", "Silk", "Satin", "Cord", "Denim", "Flannel", "Plaid", "Wool", "Linen", "Silent", "Flax", "Weak", "Valiant", "Fierce", "Gentle", "Rhinestone", "Splash", "North", "South", "East", "West", "Summer", "Winter", "Autumn", "Spring", "Season", "Equinox", "Solstice", "Paper", "Motley", "Torch", "Ballistic", "Rampant", "Shag", "Freckle", "Wild", "Free", "Chain", "Sheer", "Crazy", "Mad", "Candle", "Ribbon", "Lace", "Notch", "Wax", "Shine", "Shallow", "Deep", "Bubble", "Harvest", "Fluff", "Venom", "Boom", "Slash", "Rune", "Cold", "Quill", "Love", "Hate", "Garnet", "Zircon", "Power", "Bone", "Void", "Horn", "Glory", "Cyber", "Nova", "Hot", "Helix", "Cosmic", "Quark", "Quiver", "Holly", "Clover", "Polar", "Regal", "Ripple", "Ebony", "Wheat", "Phantom", "Dew", "Chisel", "Crack", "Chatter", "Laser", "Foil", "Tin", "Clever", "Treasure", "Maze", "Twisty", "Curly", "Fortune", "Fate", "Destiny", "Cute", "Slime", "Ink", "Disco", "Plume", "Time", "Psychadelic", "Relic", "Fossil", "Water", "Savage", "Ancient", "Rapid", "Road", "Trail", "Stitch", "Button", "Bow", "Nimble", "Zest", "Sour", "Bitter", "Phase", "Fan", "Frill", "Plump", "Pickle", "Mud", "Puddle", "Pond", "River", "Spring", "Stream", "Battle", "Arrow", "Plume", "Roan", "Pitch", "Tar", "Cat", "Dog", "Horse", "Lizard", "Bird", "Fish", "Saber", "Scythe", "Sharp", "Soft", "Razor", "Neon", "Dandy", "Weed", "Swamp", "Marsh", "Bog", "Peat", "Moor", "Muck", "Mire", "Grave", "Fair", "Just", "Brick", "Puzzle", "Skitter", "Prong", "Fork", "Dent", "Dour", "Warp", "Luck", "Coffee", "Split", "Chip", "Hollow", "Heavy", "Legend", "Hickory", "Mesquite", "Nettle", "Rogue", "Charm", "Prickle", "Bead", "Sponge", "Whip", "Bald", "Frost", "Fog", "Oil", "Veil", "Cliff", "Volcano", "Rift", "Maze", "Proud", "Dew", "Mirror", "Shard", "Salt", "Pepper", "Honey", "Thread", "Bristle", "Ripple", "Glow", "Zenith"}
11 | 
12 | var nouns = []string{"head", "crest", "crown", "tooth", "fang", "horn", "frill", "skull", "bone", "tongue", "throat", "voice", "nose", "snout", "chin", "eye", "sight", "seer", "speaker", "singer", "song", "chanter", "howler", "chatter", "shrieker", "shriek", "jaw", "bite", "biter", "neck", "shoulder", "fin", "wing", "arm", "lifter", "grasp", "grabber", "hand", "paw", "foot", "finger", "toe", "thumb", "talon", "palm", "touch", "racer", "runner", "hoof", "fly", "flier", "swoop", "roar", "hiss", "hisser", "snarl", "dive", "diver", "rib", "chest", "back", "ridge", "leg", "legs", "tail", "beak", "walker", "lasher", "swisher", "carver", "kicker", "roarer", "crusher", "spike", "shaker", "charger", "hunter", "weaver", "crafter", "binder", "scribe", "muse", "snap", "snapper", "slayer", "stalker", "track", "tracker", "scar", "scarer", "fright", "killer", "death", "doom", "healer", "saver", "friend", "foe", "guardian", "thunder", "lightning", "cloud", "storm", "forger", "scale", "hair", "braid", "nape", "belly", "thief", "stealer", "reaper", "giver", "taker", "dancer", "player", "gambler", "twister", "turner", "painter", "dart", "drifter", "sting", "stinger", "venom", "spur", "ripper", "swallow", "devourer", "knight", "lady", "lord", "queen", "king", "master", "mistress", "prince", "princess", "duke", "dutchess", "samurai", "ninja", "knave", "slave", "servant", "sage", "wizard", "witch", "warlock", "warrior", "jester", "paladin", "bard", "trader", "sword", "shield", "knife", "dagger", "arrow", "bow", "fighter", "bane", "follower", "leader", "scourge", "watcher", "cat", "panther", "tiger", "cougar", "puma", "jaguar", "ocelot", "lynx", "lion", "leopard", "ferret", "weasel", "wolverine", "bear", "raccoon", "dog", "wolf", "kitten", "puppy", "cub", "fox", "hound", "terrier", "coyote", "hyena", "jackal", "pig", "horse", "donkey", "stallion", "mare", "zebra", "antelope", "gazelle", "deer", "buffalo", "bison", "boar", "elk", "whale", "dolphin", "shark", "fish", "minnow", "salmon", "ray", "fisher", "otter", "gull", "duck", "goose", "crow", "raven", "bird", "eagle", "raptor", "hawk", "falcon", "moose", "heron", "owl", "stork", "crane", "sparrow", "robin", "parrot", "cockatoo", "carp", "lizard", "gecko", "iguana", "snake", "python", "viper", "boa", "condor", "vulture", "spider", "fly", "scorpion", "heron", "oriole", "toucan", "bee", "wasp", "hornet", "rabbit", "bunny", "hare", "brow", "mustang", "ox", "piper", "soarer", "flasher", "moth", "mask", "hide", "hero", "antler", "chill", "chiller", "gem", "ogre", "myth", "elf", "fairy", "pixie", "dragon", "griffin", "unicorn", "pegasus", "sprite", "fancier", "chopper", "slicer", "skinner", "butterfly", "legend", "wanderer", "rover", "raver", "loon", "lancer", "glass", "glazer", "flame", "crystal", "lantern", "lighter", "cloak", "bell", "ringer", "keeper", "centaur", "bolt", "catcher", "whimsey", "quester", "rat", "mouse", "serpent", "wyrm", "gargoyle", "thorn", "whip", "rider", "spirit", "sentry", "bat", "beetle", "burn", "cowl", "stone", "gem", "collar", "mark", "grin", "scowl", "spear", "razor", "edge", "seeker", "jay", "ape", "monkey", "gorilla", "koala", "kangaroo", "yak", "sloth", "ant", "roach", "weed", "seed", "eater", "razor", "shirt", "face", "goat", "mind", "shift", "rider", "face", "mole", "vole", "pirate", "llama", "stag", "bug", "cap", "boot", "drop", "hugger", "sargent", "snagglefoot", "carpet", "curtain"}
13 | 
14 | func noun() string {
15 | 	return nouns[rand.Intn(len(nouns)-1)]
16 | }
17 | 
18 | func adjective() string {
19 | 	return adjectives[rand.Intn(len(adjectives)-1)]
20 | }
21 | 
22 | func NewName() string {
23 | 	return strings.Title(noun() + adjective() + " " + adjective())
24 | }
25 | 


--------------------------------------------------------------------------------
/config/config.go:
--------------------------------------------------------------------------------
  1 | package config
  2 | 
  3 | import (
  4 | 	"crypto/rand"
  5 | 	"errors"
  6 | 	"fmt"
  7 | 	"net"
  8 | 	"os"
  9 | 	"path/filepath"
 10 | 	"regexp"
 11 | 	"strconv"
 12 | 	"strings"
 13 | 
 14 | 	"github.com/joho/godotenv"
 15 | 	"github.com/kelseyhightower/envconfig"
 16 | 	"github.com/rs/zerolog"
 17 | 	"github.com/screego/server/config/mode"
 18 | )
 19 | 
 20 | var (
 21 | 	prefix        = "screego"
 22 | 	files         = []string{"screego.config.development.local", "screego.config.development", "screego.config.local", "screego.config"}
 23 | 	absoluteFiles = []string{"/etc/screego/server.config"}
 24 | 	osExecutable  = os.Executable
 25 | 	osStat        = os.Stat
 26 | )
 27 | 
 28 | const (
 29 | 	AuthModeTurn = "turn"
 30 | 	AuthModeAll  = "all"
 31 | 	AuthModeNone = "none"
 32 | )
 33 | 
 34 | // Config represents the application configuration.
 35 | type Config struct {
 36 | 	LogLevel LogLevel `default:"info" split_words:"true"`
 37 | 
 38 | 	ExternalIP []string `split_words:"true"`
 39 | 
 40 | 	TLSCertFile string `split_words:"true"`
 41 | 	TLSKeyFile  string `split_words:"true"`
 42 | 
 43 | 	ServerTLS     bool   `split_words:"true"`
 44 | 	ServerAddress string `default:":5050" split_words:"true"`
 45 | 	Secret        []byte `split_words:"true"`
 46 | 
 47 | 	TurnAddress    string `default:":3478" required:"true" split_words:"true"`
 48 | 	TurnStrictAuth bool   `default:"true" split_words:"true"`
 49 | 	TurnPortRange  string `split_words:"true"`
 50 | 
 51 | 	TrustProxyHeaders  bool     `split_words:"true"`
 52 | 	AuthMode           string   `default:"turn" split_words:"true"`
 53 | 	CorsAllowedOrigins []string `split_words:"true"`
 54 | 	UsersFile          string   `split_words:"true"`
 55 | 	Prometheus         bool     `split_words:"true"`
 56 | 
 57 | 	CheckOrigin  func(string) bool `ignored:"true" json:"-"`
 58 | 	ExternalIPV4 net.IP            `ignored:"true"`
 59 | 	ExternalIPV6 net.IP            `ignored:"true"`
 60 | }
 61 | 
 62 | func (c Config) parsePortRange() (uint16, uint16, error) {
 63 | 	if c.TurnPortRange == "" {
 64 | 		return 0, 0, nil
 65 | 	}
 66 | 
 67 | 	parts := strings.Split(c.TurnPortRange, ":")
 68 | 	if len(parts) != 2 {
 69 | 		return 0, 0, errors.New("must include one colon")
 70 | 	}
 71 | 	stringMin := parts[0]
 72 | 	stringMax := parts[1]
 73 | 	min64, err := strconv.ParseUint(stringMin, 10, 16)
 74 | 	if err != nil {
 75 | 		return 0, 0, fmt.Errorf("invalid min: %s", err)
 76 | 	}
 77 | 	max64, err := strconv.ParseUint(stringMax, 10, 16)
 78 | 	if err != nil {
 79 | 		return 0, 0, fmt.Errorf("invalid max: %s", err)
 80 | 	}
 81 | 
 82 | 	return uint16(min64), uint16(max64), nil
 83 | }
 84 | 
 85 | func (c Config) PortRange() (uint16, uint16, bool) {
 86 | 	min, max, _ := c.parsePortRange()
 87 | 	return min, max, min != 0 && max != 0
 88 | }
 89 | 
 90 | // Get loads the application config.
 91 | func Get() (Config, []FutureLog) {
 92 | 	var logs []FutureLog
 93 | 	dir, log := getExecutableOrWorkDir()
 94 | 	if log != nil {
 95 | 		logs = append(logs, *log)
 96 | 	}
 97 | 
 98 | 	for _, file := range getFiles(dir) {
 99 | 		_, fileErr := osStat(file)
100 | 		if fileErr == nil {
101 | 			if err := godotenv.Load(file); err != nil {
102 | 				logs = append(logs, futureFatal(fmt.Sprintf("cannot load file %s: %s", file, err)))
103 | 			} else {
104 | 				logs = append(logs, FutureLog{
105 | 					Level: zerolog.DebugLevel,
106 | 					Msg:   fmt.Sprintf("Loading file %s", file)})
107 | 			}
108 | 		} else if os.IsNotExist(fileErr) {
109 | 			continue
110 | 		} else {
111 | 			logs = append(logs, FutureLog{
112 | 				Level: zerolog.WarnLevel,
113 | 				Msg:   fmt.Sprintf("cannot read file %s because %s", file, fileErr)})
114 | 		}
115 | 	}
116 | 
117 | 	config := Config{}
118 | 	err := envconfig.Process(prefix, &config)
119 | 	if err != nil {
120 | 		logs = append(logs,
121 | 			futureFatal(fmt.Sprintf("cannot parse env params: %s", err)))
122 | 	}
123 | 
124 | 	if config.AuthMode != AuthModeTurn && config.AuthMode != AuthModeAll && config.AuthMode != AuthModeNone {
125 | 		logs = append(logs,
126 | 			futureFatal(fmt.Sprintf("invalid SCREEGO_AUTH_MODE: %s", config.AuthMode)))
127 | 	}
128 | 
129 | 	if config.ServerTLS {
130 | 		if config.TLSCertFile == "" {
131 | 			logs = append(logs, futureFatal("SCREEGO_TLS_CERT_FILE must be set if TLS is enabled"))
132 | 		}
133 | 
134 | 		if config.TLSKeyFile == "" {
135 | 			logs = append(logs, futureFatal("SCREEGO_TLS_KEY_FILE must be set if TLS is enabled"))
136 | 		}
137 | 	}
138 | 
139 | 	var compiledAllowedOrigins []*regexp.Regexp
140 | 	for _, origin := range config.CorsAllowedOrigins {
141 | 		compiled, err := regexp.Compile(origin)
142 | 		if err != nil {
143 | 			logs = append(logs, futureFatal(fmt.Sprintf("invalid regex: %s", err)))
144 | 		}
145 | 		compiledAllowedOrigins = append(compiledAllowedOrigins, compiled)
146 | 	}
147 | 
148 | 	config.CheckOrigin = func(origin string) bool {
149 | 		if origin == "" {
150 | 			return true
151 | 		}
152 | 		for _, compiledOrigin := range compiledAllowedOrigins {
153 | 			if compiledOrigin.Match([]byte(strings.ToLower(origin))) {
154 | 				return true
155 | 			}
156 | 		}
157 | 		return false
158 | 	}
159 | 
160 | 	if len(config.Secret) == 0 {
161 | 		config.Secret = make([]byte, 32)
162 | 		if _, err := rand.Read(config.Secret); err == nil {
163 | 			logs = append(logs, FutureLog{
164 | 				Level: zerolog.InfoLevel,
165 | 				Msg:   "SCREEGO_SECRET unset, user logins will be invalidated on restart"})
166 | 		} else {
167 | 			logs = append(logs, futureFatal(fmt.Sprintf("cannot create secret %s", err)))
168 | 		}
169 | 	}
170 | 
171 | 	var errs []FutureLog
172 | 	config.ExternalIPV4, config.ExternalIPV6, errs = validateExternalIP(config.ExternalIP)
173 | 	logs = append(logs, errs...)
174 | 
175 | 	min, max, err := config.parsePortRange()
176 | 	if err != nil {
177 | 		logs = append(logs, futureFatal(fmt.Sprintf("invalid SCREEGO_TURN_PORT_RANGE: %s", err)))
178 | 	} else if min == 0 && max == 0 {
179 | 		// valid; no port range
180 | 	} else if min == 0 || max == 0 {
181 | 		logs = append(logs, futureFatal("invalid SCREEGO_TURN_PORT_RANGE: min or max port is 0"))
182 | 	} else if min > max {
183 | 		logs = append(logs, futureFatal(fmt.Sprintf("invalid SCREEGO_TURN_PORT_RANGE: min port (%d) is higher than max port (%d)", min, max)))
184 | 	} else if (max - min) < 40 {
185 | 		logs = append(logs, FutureLog{
186 | 			Level: zerolog.WarnLevel,
187 | 			Msg:   "Less than 40 ports are available for turn. When using multiple TURN connections this may not be enough"})
188 | 	}
189 | 
190 | 	return config, logs
191 | }
192 | 
193 | func validateExternalIP(ips []string) (net.IP, net.IP, []FutureLog) {
194 | 	if len(ips) == 0 {
195 | 		return nil, nil, []FutureLog{futureFatal("SCREEGO_EXTERNAL_IP must be set")}
196 | 	}
197 | 
198 | 	first := ips[0]
199 | 
200 | 	firstParsed := net.ParseIP(first)
201 | 	if firstParsed == nil || first == "0.0.0.0" {
202 | 		return nil, nil, []FutureLog{futureFatal(fmt.Sprintf("invalid SCREEGO_EXTERNAL_IP: %s", first))}
203 | 	}
204 | 	firstIsIP4 := firstParsed.To4() != nil
205 | 
206 | 	if len(ips) == 1 {
207 | 		if firstIsIP4 {
208 | 			return firstParsed, nil, nil
209 | 		}
210 | 		return nil, firstParsed, nil
211 | 	}
212 | 
213 | 	second := ips[1]
214 | 
215 | 	secondParsed := net.ParseIP(second)
216 | 	if secondParsed == nil || second == "0.0.0.0" {
217 | 		return nil, nil, []FutureLog{futureFatal(fmt.Sprintf("invalid SCREEGO_EXTERNAL_IP: %s", second))}
218 | 	}
219 | 
220 | 	secondIsIP4 := secondParsed.To4() != nil
221 | 
222 | 	if firstIsIP4 == secondIsIP4 {
223 | 		return nil, nil, []FutureLog{futureFatal("invalid SCREEGO_EXTERNAL_IP: the ips must be of different type ipv4/ipv6")}
224 | 	}
225 | 
226 | 	if len(ips) > 2 {
227 | 		return nil, nil, []FutureLog{futureFatal("invalid SCREEGO_EXTERNAL_IP: too many ips supplied")}
228 | 	}
229 | 
230 | 	if !firstIsIP4 {
231 | 		return secondParsed, firstParsed, nil
232 | 	}
233 | 
234 | 	return firstParsed, secondParsed, nil
235 | }
236 | 
237 | func getExecutableOrWorkDir() (string, *FutureLog) {
238 | 	dir, err := getExecutableDir()
239 | 	// when using `go run main.go` the executable lives in th temp directory therefore the env.development
240 | 	// will not be read, this enforces that the current work directory is used in dev mode.
241 | 	if err != nil || mode.Get() == mode.Dev {
242 | 		return filepath.Dir("."), err
243 | 	}
244 | 	return dir, nil
245 | }
246 | 
247 | func getExecutableDir() (string, *FutureLog) {
248 | 	ex, err := osExecutable()
249 | 	if err != nil {
250 | 		return "", &FutureLog{
251 | 			Level: zerolog.ErrorLevel,
252 | 			Msg:   "Could not get path of executable using working directory instead. " + err.Error()}
253 | 	}
254 | 	return filepath.Dir(ex), nil
255 | }
256 | 
257 | func getFiles(relativeTo string) []string {
258 | 	var result []string
259 | 	for _, file := range files {
260 | 		result = append(result, filepath.Join(relativeTo, file))
261 | 	}
262 | 	homeDir, err := os.UserHomeDir()
263 | 	if err == nil {
264 | 		result = append(result, filepath.Join(homeDir, ".config/screego/server.config"))
265 | 	}
266 | 	result = append(result, absoluteFiles...)
267 | 	return result
268 | }
269 | 


--------------------------------------------------------------------------------
/ui/src/useRoom.ts:
--------------------------------------------------------------------------------
  1 | import React from 'react';
  2 | import {
  3 |     ICEServer,
  4 |     IncomingMessage,
  5 |     JoinRoom,
  6 |     OutgoingMessage,
  7 |     RoomCreate,
  8 |     RoomInfo,
  9 | } from './message';
 10 | import {getPermanentName} from './name';
 11 | import {urlWithSlash} from './url';
 12 | import {useSnackbar} from 'notistack';
 13 | import {useRoomID} from './useRoomID';
 14 | 
 15 | export type RoomState = false | ConnectedRoom;
 16 | export type ConnectedRoom = {
 17 |     ws: WebSocket;
 18 |     hostStream?: MediaStream;
 19 |     clientStreams: ClientStream[];
 20 | } & RoomInfo;
 21 | 
 22 | interface ClientStream {
 23 |     id: string;
 24 |     peer_id: string;
 25 |     stream: MediaStream;
 26 | }
 27 | 
 28 | export interface UseRoom {
 29 |     state: RoomState;
 30 |     room: FCreateRoom;
 31 |     share: () => void;
 32 |     setName: (name: string) => void;
 33 |     stopShare: () => void;
 34 | }
 35 | 
 36 | const relayConfig: Partial<RTCConfiguration> =
 37 |     window.location.search.indexOf('forceTurn=true') !== -1 ? {iceTransportPolicy: 'relay'} : {};
 38 | 
 39 | const hostSession = async ({
 40 |     sid,
 41 |     ice,
 42 |     send,
 43 |     done,
 44 |     stream,
 45 | }: {
 46 |     sid: string;
 47 |     ice: ICEServer[];
 48 |     send: (e: OutgoingMessage) => void;
 49 |     done: () => void;
 50 |     stream: MediaStream;
 51 | }): Promise<RTCPeerConnection> => {
 52 |     const peer = new RTCPeerConnection({...relayConfig, iceServers: ice});
 53 |     peer.onicecandidate = (event) => {
 54 |         if (!event.candidate) {
 55 |             return;
 56 |         }
 57 |         send({type: 'hostice', payload: {sid: sid, value: event.candidate}});
 58 |     };
 59 | 
 60 |     peer.onconnectionstatechange = (event) => {
 61 |         console.log('host change', event);
 62 |         if (
 63 |             peer.connectionState === 'closed' ||
 64 |             peer.connectionState === 'disconnected' ||
 65 |             peer.connectionState === 'failed'
 66 |         ) {
 67 |             peer.close();
 68 |             done();
 69 |         }
 70 |     };
 71 | 
 72 |     stream.getTracks().forEach((track) => peer.addTrack(track, stream));
 73 | 
 74 |     const hostOffer = await peer.createOffer({offerToReceiveVideo: true});
 75 |     await peer.setLocalDescription(hostOffer);
 76 |     send({type: 'hostoffer', payload: {value: hostOffer, sid: sid}});
 77 | 
 78 |     return peer;
 79 | };
 80 | 
 81 | const clientSession = async ({
 82 |     sid,
 83 |     ice,
 84 |     send,
 85 |     done,
 86 |     onTrack,
 87 | }: {
 88 |     sid: string;
 89 |     ice: ICEServer[];
 90 |     send: (e: OutgoingMessage) => void;
 91 |     onTrack: (s: MediaStream) => void;
 92 |     done: () => void;
 93 | }): Promise<RTCPeerConnection> => {
 94 |     console.log('ice', ice);
 95 |     const peer = new RTCPeerConnection({...relayConfig, iceServers: ice});
 96 |     peer.onicecandidate = (event) => {
 97 |         if (!event.candidate) {
 98 |             return;
 99 |         }
100 |         send({type: 'clientice', payload: {sid: sid, value: event.candidate}});
101 |     };
102 |     peer.onconnectionstatechange = (event) => {
103 |         console.log('client change', event);
104 |         if (
105 |             peer.connectionState === 'closed' ||
106 |             peer.connectionState === 'disconnected' ||
107 |             peer.connectionState === 'failed'
108 |         ) {
109 |             peer.close();
110 |             done();
111 |         }
112 |     };
113 |     peer.ontrack = (event) => {
114 |         const stream = new MediaStream();
115 |         stream.addTrack(event.track);
116 |         onTrack(stream);
117 |     };
118 | 
119 |     return peer;
120 | };
121 | 
122 | export type FCreateRoom = (room: RoomCreate | JoinRoom) => Promise<string | true>;
123 | 
124 | export const useRoom = (): UseRoom => {
125 |     const [roomID, setRoomID] = useRoomID();
126 |     const {enqueueSnackbar} = useSnackbar();
127 |     const conn = React.useRef<WebSocket>();
128 |     const host = React.useRef<Record<string, RTCPeerConnection>>({});
129 |     const client = React.useRef<Record<string, RTCPeerConnection>>({});
130 |     const stream = React.useRef<MediaStream>();
131 | 
132 |     const [state, setState] = React.useState<RoomState>(false);
133 | 
134 |     const room: FCreateRoom = React.useCallback(
135 |         (create) => {
136 |             return new Promise<true | string>((resolve) => {
137 |                 const ws = (conn.current = new WebSocket(
138 |                     urlWithSlash.replace('http', 'ws') + 'stream'
139 |                 ));
140 |                 const send = (message: OutgoingMessage) => {
141 |                     if (ws.readyState === ws.OPEN) ws.send(JSON.stringify(message));
142 |                 };
143 |                 let first = true;
144 |                 ws.onmessage = (data) => {
145 |                     const event: IncomingMessage = JSON.parse(data.data);
146 |                     if (first) {
147 |                         first = false;
148 |                         if (event.type === 'room') {
149 |                             resolve();
150 |                             enqueueSnackbar(create.type === 'join' ? 'Joined' : 'Room Created', {
151 |                                 variant: 'success',
152 |                             });
153 |                             setState({ws, ...event.payload, clientStreams: []});
154 |                             setRoomID(event.payload.id);
155 |                         } else {
156 |                             resolve();
157 |                             enqueueSnackbar('Unknown Event: ' + event.type, {variant: 'error'});
158 |                             ws.close(1000, 'received unknown event');
159 |                         }
160 |                         return;
161 |                     }
162 | 
163 |                     switch (event.type) {
164 |                         case 'room':
165 |                             setState((current) =>
166 |                                 current ? {...current, ...event.payload} : current
167 |                             );
168 |                             return;
169 |                         case 'hostsession':
170 |                             if (!stream.current) {
171 |                                 return;
172 |                             }
173 |                             hostSession({
174 |                                 sid: event.payload.id,
175 |                                 stream: stream.current!,
176 |                                 ice: event.payload.iceServers,
177 |                                 send,
178 |                                 done: () => delete host.current[event.payload.id],
179 |                             }).then((peer) => {
180 |                                 host.current[event.payload.id] = peer;
181 |                             });
182 |                             return;
183 |                         case 'clientsession':
184 |                             const {id: sid, peer} = event.payload;
185 |                             clientSession({
186 |                                 sid,
187 |                                 send,
188 |                                 ice: event.payload.iceServers,
189 |                                 done: () => {
190 |                                     delete client.current[sid];
191 |                                     setState((current) =>
192 |                                         current
193 |                                             ? {
194 |                                                   ...current,
195 |                                                   clientStreams: current.clientStreams.filter(
196 |                                                       ({id}) => id !== sid
197 |                                                   ),
198 |                                               }
199 |                                             : current
200 |                                     );
201 |                                 },
202 |                                 onTrack: (stream) =>
203 |                                     setState((current) =>
204 |                                         current
205 |                                             ? {
206 |                                                   ...current,
207 |                                                   clientStreams: [
208 |                                                       ...current.clientStreams,
209 |                                                       {
210 |                                                           id: sid,
211 |                                                           stream,
212 |                                                           peer_id: peer,
213 |                                                       },
214 |                                                   ],
215 |                                               }
216 |                                             : current
217 |                                     ),
218 |                             }).then((peer) => (client.current[event.payload.id] = peer));
219 |                             return;
220 |                         case 'clientice':
221 |                             host.current[event.payload.sid]?.addIceCandidate(event.payload.value);
222 |                             return;
223 |                         case 'clientanswer':
224 |                             host.current[event.payload.sid]?.setRemoteDescription(
225 |                                 event.payload.value
226 |                             );
227 |                             return;
228 |                         case 'hostoffer':
229 |                             (async () => {
230 |                                 await client.current[event.payload.sid]?.setRemoteDescription(
231 |                                     event.payload.value
232 |                                 );
233 |                                 const answer = await client.current[
234 |                                     event.payload.sid
235 |                                 ]?.createAnswer();
236 |                                 await client.current[event.payload.sid]?.setLocalDescription(
237 |                                     answer
238 |                                 );
239 |                                 send({
240 |                                     type: 'clientanswer',
241 |                                     payload: {sid: event.payload.sid, value: answer},
242 |                                 });
243 |                             })();
244 |                             return;
245 |                         case 'hostice':
246 |                             client.current[event.payload.sid]?.addIceCandidate(event.payload.value);
247 |                             return;
248 |                         case 'endshare':
249 |                             client.current[event.payload]?.close();
250 |                             host.current[event.payload]?.close();
251 |                             setState((current) =>
252 |                                 current
253 |                                     ? {
254 |                                           ...current,
255 |                                           clientStreams: current.clientStreams.filter(
256 |                                               ({id}) => id !== event.payload
257 |                                           ),
258 |                                       }
259 |                                     : current
260 |                             );
261 |                     }
262 |                 };
263 |                 ws.onclose = (event) => {
264 |                     if (first) {
265 |                         resolve();
266 |                         first = false;
267 |                     }
268 |                     enqueueSnackbar(event.reason, {variant: 'error', persist: true});
269 |                     setState(false);
270 |                 };
271 |                 ws.onerror = (err) => {
272 |                     if (first) {
273 |                         resolve();
274 |                         first = false;
275 |                     }
276 |                     enqueueSnackbar(err, {variant: 'error', persist: true});
277 |                     setState(false);
278 |                 };
279 |                 ws.onopen = () => {
280 |                     create.payload.username = getPermanentName();
281 |                     send(create);
282 |                 };
283 |             });
284 |         },
285 |         [setState, enqueueSnackbar, setRoomID]
286 |     );
287 | 
288 |     const share = async () => {
289 |         if (!navigator.mediaDevices) {
290 |             enqueueSnackbar(
291 |                 'Could not start presentation. (mediaDevices undefined) Are you using https?',
292 |                 {
293 |                     variant: 'error',
294 |                     persist: true,
295 |                 }
296 |             );
297 |             return;
298 |         }
299 |         stream.current = await navigator.mediaDevices
300 |             // @ts-ignore
301 |             .getDisplayMedia({video: true});
302 |         setState((current) => (current ? {...current, hostStream: stream.current} : current));
303 | 
304 |         conn.current?.send(JSON.stringify({type: 'share', payload: {}}));
305 |     };
306 | 
307 |     const stopShare = async () => {
308 |         Object.values(host.current).forEach((peer) => {
309 |             peer.close();
310 |         });
311 |         host.current = {};
312 |         stream.current?.getTracks().forEach((track) => track.stop());
313 |         stream.current = undefined;
314 |         conn.current?.send(JSON.stringify({type: 'stopshare', payload: {}}));
315 |         setState((current) => (current ? {...current, hostStream: undefined} : current));
316 |     };
317 | 
318 |     const setName = (name: string): void => {
319 |         conn.current?.send(JSON.stringify({type: 'name', payload: {username: name}}));
320 |     };
321 | 
322 |     React.useEffect(() => {
323 |         if (roomID) {
324 |             room({type: 'join', payload: {id: roomID}});
325 |         }
326 |         // eslint-disable-next-line react-hooks/exhaustive-deps
327 |     }, []);
328 | 
329 |     return {state, room, share, stopShare, setName};
330 | };
331 | 


--------------------------------------------------------------------------------
/ui/src/Room.tsx:
--------------------------------------------------------------------------------
  1 | import React from 'react';
  2 | import {setPermanentName} from './name';
  3 | import {
  4 |     Badge,
  5 |     Button,
  6 |     Checkbox,
  7 |     Dialog,
  8 |     DialogActions,
  9 |     DialogContent,
 10 |     DialogTitle,
 11 |     FormControlLabel,
 12 |     IconButton,
 13 |     Menu,
 14 |     MenuItem,
 15 |     Paper,
 16 |     TextField,
 17 |     Theme,
 18 |     Tooltip,
 19 |     Typography,
 20 | } from '@material-ui/core';
 21 | import CancelPresentationIcon from '@material-ui/icons/CancelPresentation';
 22 | import PresentToAllIcon from '@material-ui/icons/PresentToAll';
 23 | import FullScreenIcon from '@material-ui/icons/Fullscreen';
 24 | import PeopleIcon from '@material-ui/icons/People';
 25 | import ShowMoreIcon from '@material-ui/icons/MoreVert';
 26 | import {Video} from './Video';
 27 | import {makeStyles} from '@material-ui/core/styles';
 28 | import {ConnectedRoom} from './useRoom';
 29 | import {useSnackbar} from 'notistack';
 30 | import {RoomUser} from './message';
 31 | 
 32 | const HostStream: unique symbol = Symbol('mystream');
 33 | 
 34 | const flags = (user: RoomUser) => {
 35 |     const result: string[] = [];
 36 |     if (user.you) {
 37 |         result.push('You');
 38 |     }
 39 |     if (user.owner) {
 40 |         result.push('Owner');
 41 |     }
 42 |     if (user.streaming) {
 43 |         result.push('Streaming');
 44 |     }
 45 |     if (!result.length) {
 46 |         return '';
 47 |     }
 48 |     return ` (${result.join(', ')})`;
 49 | };
 50 | 
 51 | export const Room = ({
 52 |     state,
 53 |     share,
 54 |     stopShare,
 55 |     setName,
 56 | }: {
 57 |     state: ConnectedRoom;
 58 |     share: () => void;
 59 |     stopShare: () => void;
 60 |     setName: (name: string) => void;
 61 | }) => {
 62 |     const classes = useStyles();
 63 |     const [open, setOpen] = React.useState(false);
 64 |     const {enqueueSnackbar} = useSnackbar();
 65 |     const [nameInput, setNameInput] = React.useState('');
 66 |     const [permanent, setPermanent] = React.useState(false);
 67 |     const [showControl, setShowControl] = React.useState(true);
 68 |     const [hoverControl, setHoverControl] = React.useState();
 69 |     const [showMore, setShowMore] = React.useState<Element>();
 70 |     const [selectedStream, setSelectedStream] = React.useState<string | typeof HostStream>();
 71 |     const [videoElement, setVideoElement] = React.useState<HTMLVideoElement | null>(null);
 72 |     useShowOnMouseMovement(setShowControl);
 73 | 
 74 |     React.useEffect(() => {
 75 |         if (selectedStream === HostStream && state.hostStream) {
 76 |             return;
 77 |         }
 78 |         if (state.clientStreams.some(({id}) => id === selectedStream)) {
 79 |             return;
 80 |         }
 81 |         if (state.clientStreams.length === 0 && selectedStream) {
 82 |             setSelectedStream(undefined);
 83 |             return;
 84 |         }
 85 |         setSelectedStream(state.clientStreams[0]?.id);
 86 |     }, [state.clientStreams, selectedStream, state.hostStream]);
 87 | 
 88 |     const stream =
 89 |         selectedStream === HostStream
 90 |             ? state.hostStream
 91 |             : state.clientStreams.find(({id}) => selectedStream === id)?.stream;
 92 | 
 93 |     const submitName = () => {
 94 |         if (permanent) {
 95 |             setPermanentName(nameInput);
 96 |         }
 97 |         setName(nameInput);
 98 |         setOpen(false);
 99 |     };
100 | 
101 |     React.useEffect(() => {
102 |         if (videoElement && stream) {
103 |             videoElement.srcObject = stream;
104 |             videoElement.play();
105 |         }
106 |     }, [videoElement, stream]);
107 | 
108 |     const copyLink = () => {
109 |         navigator?.clipboard?.writeText(window.location.href)?.then(
110 |             () => enqueueSnackbar('Link Copied', {variant: 'success'}),
111 |             (err) => enqueueSnackbar('Copy Failed ' + err, {variant: 'error'})
112 |         );
113 |     };
114 | 
115 |     const setHoverState = React.useMemo(
116 |         () => ({
117 |             onMouseLeave: () => setHoverControl(false),
118 |             onMouseEnter: () => setHoverControl(true),
119 |         }),
120 |         [setHoverControl]
121 |     );
122 | 
123 |     const controlVisible = showControl || open || showMore || hoverControl;
124 | 
125 |     return (
126 |         <div className={classes.videoContainer}>
127 |             {controlVisible && (
128 |                 <Paper className={classes.title} elevation={10} {...setHoverState}>
129 |                     <Tooltip title="Copy Link">
130 |                         <Typography
131 |                             variant="h4"
132 |                             component="h4"
133 |                             style={{cursor: 'pointer'}}
134 |                             onClick={copyLink}>
135 |                             {state.id}
136 |                         </Typography>
137 |                     </Tooltip>
138 |                 </Paper>
139 |             )}
140 | 
141 |             {stream ? (
142 |                 <video muted ref={setVideoElement} className={classes.video} />
143 |             ) : (
144 |                 <Typography
145 |                     variant="h4"
146 |                     align="center"
147 |                     component="div"
148 |                     style={{
149 |                         top: '50%',
150 |                         left: '50%',
151 |                         position: 'absolute',
152 |                         transform: 'translate(-50%, -50%)',
153 |                     }}>
154 |                     no stream available
155 |                 </Typography>
156 |             )}
157 | 
158 |             {controlVisible && (
159 |                 <Paper className={classes.control} elevation={10} {...setHoverState}>
160 |                     {state.hostStream ? (
161 |                         <Tooltip title="Cancel Presentation" arrow>
162 |                             <IconButton onClick={stopShare}>
163 |                                 <CancelPresentationIcon fontSize="large" />
164 |                             </IconButton>
165 |                         </Tooltip>
166 |                     ) : (
167 |                         <Tooltip title="Start Presentation" arrow>
168 |                             <IconButton onClick={share}>
169 |                                 <PresentToAllIcon fontSize="large" />
170 |                             </IconButton>
171 |                         </Tooltip>
172 |                     )}
173 | 
174 |                     <Tooltip
175 |                         classes={{tooltip: classes.noMaxWidth}}
176 |                         title={
177 |                             <div>
178 |                                 <Typography variant="h5">Member List</Typography>
179 |                                 {state.users.map((user) => (
180 |                                     <Typography>
181 |                                         {user.name} {flags(user)}
182 |                                     </Typography>
183 |                                 ))}
184 |                             </div>
185 |                         }
186 |                         arrow>
187 |                         <Badge badgeContent={state.users.length} color="primary">
188 |                             <PeopleIcon fontSize="large" />
189 |                         </Badge>
190 |                     </Tooltip>
191 |                     <Tooltip title="Fullscreen" arrow>
192 |                         <IconButton
193 |                             onClick={() => videoElement?.requestFullscreen()}
194 |                             disabled={!selectedStream}>
195 |                             <FullScreenIcon fontSize="large" />
196 |                         </IconButton>
197 |                     </Tooltip>
198 |                     <Tooltip title="More" arrow>
199 |                         <IconButton onClick={(e) => setShowMore(e.currentTarget)}>
200 |                             <ShowMoreIcon fontSize="large" />
201 |                         </IconButton>
202 |                     </Tooltip>
203 | 
204 |                     <Menu
205 |                         anchorEl={showMore}
206 |                         keepMounted
207 |                         open={Boolean(showMore)}
208 |                         onClose={(e) => setShowMore(undefined)}>
209 |                         <MenuItem
210 |                             onClick={() => {
211 |                                 setShowMore(undefined);
212 |                                 setOpen(true);
213 |                             }}>
214 |                             Change Name
215 |                         </MenuItem>
216 |                     </Menu>
217 |                 </Paper>
218 |             )}
219 | 
220 |             <div className={classes.bottomContainer}>
221 |                 {state.clientStreams
222 |                     .filter(({id}) => id !== selectedStream)
223 |                     .map((client) => {
224 |                         return (
225 |                             <Paper
226 |                                 elevation={4}
227 |                                 className={classes.smallVideoContainer}
228 |                                 onClick={() => setSelectedStream(client.id)}>
229 |                                 <Video
230 |                                     key={client.id}
231 |                                     src={client.stream}
232 |                                     className={classes.smallVideo}
233 |                                 />
234 |                                 <Typography
235 |                                     variant="subtitle1"
236 |                                     component="div"
237 |                                     align="center"
238 |                                     className={classes.smallVideoLabel}>
239 |                                     {state.users.find(({id}) => client.peer_id === id)?.name ??
240 |                                         'unknown'}
241 |                                 </Typography>
242 |                             </Paper>
243 |                         );
244 |                     })}
245 |                 {state.hostStream && selectedStream !== HostStream && (
246 |                     <Paper
247 |                         elevation={4}
248 |                         className={classes.smallVideoContainer}
249 |                         onClick={() => setSelectedStream(HostStream)}>
250 |                         <Video src={state.hostStream} className={classes.smallVideo} />
251 |                         <Typography
252 |                             variant="subtitle1"
253 |                             component="div"
254 |                             align="center"
255 |                             className={classes.smallVideoLabel}>
256 |                             You
257 |                         </Typography>
258 |                     </Paper>
259 |                 )}
260 |             </div>
261 | 
262 |             <Dialog open={open} onClose={() => setOpen(false)}>
263 |                 <DialogTitle>Change Name</DialogTitle>
264 |                 <DialogContent>
265 |                     <form onSubmit={submitName}>
266 |                         <TextField
267 |                             autoFocus
268 |                             margin="dense"
269 |                             label="Username"
270 |                             value={nameInput}
271 |                             onChange={(e) => setNameInput(e.target.value)}
272 |                             fullWidth
273 |                         />
274 | 
275 |                         <FormControlLabel
276 |                             control={
277 |                                 <Checkbox
278 |                                     checked={permanent}
279 |                                     onChange={(_, checked) => setPermanent(checked)}
280 |                                 />
281 |                             }
282 |                             label="Remember"
283 |                         />
284 |                     </form>
285 |                 </DialogContent>
286 |                 <DialogActions>
287 |                     <Button onClick={() => setOpen(false)} color="primary">
288 |                         Cancel
289 |                     </Button>
290 |                     <Button onClick={submitName} color="primary">
291 |                         Change
292 |                     </Button>
293 |                 </DialogActions>
294 |             </Dialog>
295 |         </div>
296 |     );
297 | };
298 | 
299 | const useShowOnMouseMovement = (doShow: (s: boolean) => void) => {
300 |     const timeoutHandle = React.useRef(0);
301 | 
302 |     React.useEffect(() => {
303 |         const update = () => {
304 |             if (timeoutHandle.current === 0) {
305 |                 doShow(true);
306 |             }
307 | 
308 |             clearTimeout(timeoutHandle.current);
309 |             timeoutHandle.current = window.setTimeout(() => {
310 |                 timeoutHandle.current = 0;
311 |                 doShow(false);
312 |             }, 1000);
313 |         };
314 |         window.addEventListener('mousemove', update);
315 |         return () => window.removeEventListener('mousemove', update);
316 |     }, [doShow]);
317 | 
318 |     React.useEffect(
319 |         () =>
320 |             void (timeoutHandle.current = window.setTimeout(() => {
321 |                 timeoutHandle.current = 0;
322 |                 doShow(false);
323 |             }, 1000)),
324 |         // eslint-disable-next-line react-hooks/exhaustive-deps
325 |         []
326 |     );
327 | };
328 | 
329 | const useStyles = makeStyles((theme: Theme) => ({
330 |     title: {
331 |         padding: 15,
332 |         position: 'fixed',
333 |         background: theme.palette.background.paper,
334 |         top: '30px',
335 |         left: '50%',
336 |         transform: 'translateX(-50%)',
337 |         zIndex: 30,
338 |     },
339 |     bottomContainer: {
340 |         position: 'fixed',
341 |         display: 'flex',
342 |         bottom: 0,
343 |         right: 0,
344 |         zIndex: 20,
345 |     },
346 |     control: {
347 |         padding: 15,
348 |         position: 'fixed',
349 |         background: theme.palette.background.paper,
350 |         bottom: '30px',
351 |         left: '50%',
352 |         transform: 'translateX(-50%)',
353 |         zIndex: 30,
354 |     },
355 |     video: {
356 |         maxWidth: '100%',
357 |         maxHeight: '100%',
358 |         width: 'auto',
359 |         height: 'auto',
360 | 
361 |         position: 'absolute',
362 |         top: '50%',
363 |         left: '50%',
364 |         transform: 'translate(-50%,-50%)',
365 | 
366 |         '&::-webkit-media-controls-start-playback-button': {
367 |             display: 'none!important',
368 |         },
369 |         '&::-webkit-media-controls': {
370 |             display: 'none!important',
371 |         },
372 |     },
373 |     smallVideo: {
374 |         minWidth: '100%',
375 |         minHeight: '100%',
376 |         width: 'auto',
377 |         maxWidth: '300px',
378 | 
379 |         maxHeight: '200px',
380 |     },
381 |     smallVideoLabel: {
382 |         position: 'absolute',
383 |         display: 'block',
384 |         bottom: 0,
385 |         background: 'rgba(0,0,0,.5)',
386 |         padding: '5px 15px',
387 |     },
388 |     noMaxWidth: {
389 |         maxWidth: 'none',
390 |     },
391 |     smallVideoContainer: {
392 |         height: '100%',
393 |         padding: 5,
394 |         maxHeight: 200,
395 |         maxWidth: 400,
396 |         width: '100%',
397 |     },
398 |     videoContainer: {
399 |         position: 'absolute',
400 |         top: 0,
401 |         bottom: 0,
402 |         width: '100%',
403 |         height: '100%',
404 |         overflow: 'hidden',
405 |     },
406 | }));
407 | 


--------------------------------------------------------------------------------
/go.sum:
--------------------------------------------------------------------------------
  1 | github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
  2 | github.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
  3 | github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
  4 | github.com/alecthomas/units v0.0.0-20190717042225-c3de453c63f4/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
  5 | github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
  6 | github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8=
  7 | github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
  8 | github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
  9 | github.com/cespare/xxhash/v2 v2.1.1 h1:6MnRN8NT7+YBpUIWxHtefFZOKTAPgGjpQSxqLNn0+qY=
 10 | github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
 11 | github.com/coreos/go-systemd v0.0.0-20190321100706-95778dfbb74e/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4=
 12 | github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 13 | github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 14 | github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 15 | github.com/felixge/httpsnoop v1.0.1 h1:lvB5Jl89CsZtGIWuTcDM1E/vkVs49/Ml7JJe07l8SPQ=
 16 | github.com/felixge/httpsnoop v1.0.1/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U=
 17 | github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
 18 | github.com/go-kit/kit v0.9.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
 19 | github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=
 20 | github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk=
 21 | github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
 22 | github.com/gobuffalo/attrs v0.0.0-20190224210810-a9411de4debd/go.mod h1:4duuawTqi2wkkpB4ePgWMaai6/Kc6WEz83bhFwpHzj0=
 23 | github.com/gobuffalo/depgen v0.0.0-20190329151759-d478694a28d3/go.mod h1:3STtPUQYuzV0gBVOY3vy6CfMm/ljR4pABfrTeHNLHUY=
 24 | github.com/gobuffalo/envy v1.6.15/go.mod h1:n7DRkBerg/aorDM8kbduw5dN3oXGswK5liaSCx4T5NI=
 25 | github.com/gobuffalo/envy v1.7.0 h1:GlXgaiBkmrYMHco6t4j7SacKO4XUjvh5pwXh0f4uxXU=
 26 | github.com/gobuffalo/envy v1.7.0/go.mod h1:n7DRkBerg/aorDM8kbduw5dN3oXGswK5liaSCx4T5NI=
 27 | github.com/gobuffalo/flect v0.1.0/go.mod h1:d2ehjJqGOH/Kjqcoz+F7jHTBbmDb38yXA598Hb50EGs=
 28 | github.com/gobuffalo/flect v0.1.1/go.mod h1:8JCgGVbRjJhVgD6399mQr4fx5rRfGKVzFjbj6RE/9UI=
 29 | github.com/gobuffalo/genny v0.0.0-20190329151137-27723ad26ef9/go.mod h1:rWs4Z12d1Zbf19rlsn0nurr75KqhYp52EAGGxTbBhNk=
 30 | github.com/gobuffalo/genny v0.0.0-20190403191548-3ca520ef0d9e h1:JbHBQOMhE0wmpSuejnSkdnL2rULqQTwEGgVe85o7+No=
 31 | github.com/gobuffalo/genny v0.0.0-20190403191548-3ca520ef0d9e/go.mod h1:80lIj3kVJWwOrXWWMRzzdhW3DsrdjILVil/SFKBzF28=
 32 | github.com/gobuffalo/gitgen v0.0.0-20190315122116-cc086187d211/go.mod h1:vEHJk/E9DmhejeLeNt7UVvlSGv3ziL+djtTr3yyzcOw=
 33 | github.com/gobuffalo/gogen v0.0.0-20190315121717-8f38393713f5 h1:f3Fpd5AqsFuTHUEhUeEMIFJkX8FpVnzdW+GpYxIyXkA=
 34 | github.com/gobuffalo/gogen v0.0.0-20190315121717-8f38393713f5/go.mod h1:V9QVDIxsgKNZs6L2IYiGR8datgMhB577vzTDqypH360=
 35 | github.com/gobuffalo/logger v0.0.0-20190315122211-86e12af44bc2 h1:8thhT+kUJMTMy3HlX4+y9Da+BNJck+p109tqqKp7WDs=
 36 | github.com/gobuffalo/logger v0.0.0-20190315122211-86e12af44bc2/go.mod h1:QdxcLw541hSGtBnhUc4gaNIXRjiDppFGaDqzbrBd3v8=
 37 | github.com/gobuffalo/mapi v1.0.1/go.mod h1:4VAGh89y6rVOvm5A8fKFxYG+wIW6LO1FMTG9hnKStFc=
 38 | github.com/gobuffalo/mapi v1.0.2 h1:fq9WcL1BYrm36SzK6+aAnZ8hcp+SrmnDyAxhNx8dvJk=
 39 | github.com/gobuffalo/mapi v1.0.2/go.mod h1:4VAGh89y6rVOvm5A8fKFxYG+wIW6LO1FMTG9hnKStFc=
 40 | github.com/gobuffalo/packd v0.0.0-20190315124812-a385830c7fc0 h1:P6naWPiHm/7R3eYx/ub3VhaW9G+1xAMJ6vzACePaGPI=
 41 | github.com/gobuffalo/packd v0.0.0-20190315124812-a385830c7fc0/go.mod h1:M2Juc+hhDXf/PnmBANFCqx4DM3wRbgDvnVWeG2RIxq4=
 42 | github.com/gobuffalo/packr/v2 v2.0.9/go.mod h1:emmyGweYTm6Kdper+iywB6YK5YzuKchGtJQZ0Odn4pQ=
 43 | github.com/gobuffalo/packr/v2 v2.2.0 h1:Ir9W9XIm9j7bhhkKE9cokvtTl1vBm62A/fene/ZCj6A=
 44 | github.com/gobuffalo/packr/v2 v2.2.0/go.mod h1:CaAwI0GPIAv+5wKLtv8Afwl+Cm78K/I/VCm/3ptBN+0=
 45 | github.com/gobuffalo/syncx v0.0.0-20190224160051-33c29581e754 h1:tpom+2CJmpzAWj5/VEHync2rJGi+epHNIeRSWjzGA+4=
 46 | github.com/gobuffalo/syncx v0.0.0-20190224160051-33c29581e754/go.mod h1:HhnNqWY95UYwwW3uSASeV7vtgYkT2t16hJgV3AEPUpw=
 47 | github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
 48 | github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 49 | github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 50 | github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 51 | github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
 52 | github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
 53 | github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=
 54 | github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
 55 | github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
 56 | github.com/golang/protobuf v1.4.2 h1:+Z5KGCizgyZCbGh1KZqA0fcLLkwbsjIzS4aV2v7wJX0=
 57 | github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
 58 | github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
 59 | github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
 60 | github.com/google/go-cmp v0.4.0 h1:xsAVV57WRhGj6kEIi8ReJzQlHHqcBYCElAvkovg3B/4=
 61 | github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 62 | github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
 63 | github.com/gorilla/handlers v1.5.1 h1:9lRY6j8DEeeBT10CvO9hGW0gmky0BprnvDI5vfhUHH4=
 64 | github.com/gorilla/handlers v1.5.1/go.mod h1:t8XrUpc4KVXb7HGyJ4/cEnwQiaxrX/hz1Zv/4g96P1Q=
 65 | github.com/gorilla/mux v1.7.2 h1:zoNxOV7WjqXptQOVngLmcSQgXmgk4NMz1HibBchjl/I=
 66 | github.com/gorilla/mux v1.7.2/go.mod h1:1lud6UwP+6orDFRuTfBEV8e9/aOM/c4fVVCaMa2zaAs=
 67 | github.com/gorilla/securecookie v1.1.1 h1:miw7JPhV+b/lAHSXz4qd/nN9jRiAFV5FwjeKyCS8BvQ=
 68 | github.com/gorilla/securecookie v1.1.1/go.mod h1:ra0sb63/xPlUeL+yeDciTfxMRAA+MP+HVt/4epWDjd4=
 69 | github.com/gorilla/sessions v1.2.1 h1:DHd3rPN5lE3Ts3D8rKkQ8x/0kqfeNmBAaiSi+o7FsgI=
 70 | github.com/gorilla/sessions v1.2.1/go.mod h1:dk2InVEVJ0sfLlnXv9EAgkf6ecYs/i80K/zI+bUmuGM=
 71 | github.com/gorilla/websocket v1.4.0 h1:WDFjx/TMzVgy9VdMMQi2K2Emtwi2QcUQsztZ/zLaH/Q=
 72 | github.com/gorilla/websocket v1.4.0/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ=
 73 | github.com/inconshreveable/mousetrap v1.0.0 h1:Z8tu5sraLXCXIcARxBp/8cbvlwVa7Z1NHg9XEKhtSvM=
 74 | github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8=
 75 | github.com/joho/godotenv v1.3.0 h1:Zjp+RcGpHhGlrMbJzXTrZZPrWj+1vfm90La1wgB6Bhc=
 76 | github.com/joho/godotenv v1.3.0/go.mod h1:7hK45KPybAkOC6peb+G5yklZfMxEjkZhHbwpqxOKXbg=
 77 | github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
 78 | github.com/json-iterator/go v1.1.10/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
 79 | github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w=
 80 | github.com/karrick/godirwalk v1.8.0 h1:ycpSqVon/QJJoaT1t8sae0tp1Stg21j+dyuS7OoagcA=
 81 | github.com/karrick/godirwalk v1.8.0/go.mod h1:H5KPZjojv4lE+QYImBI8xVtrBRgYrIVsaRPx4tDPEn4=
 82 | github.com/kelseyhightower/envconfig v1.4.0 h1:Im6hONhd3pLkfDFsbRgu68RDNkGF1r3dvMUtDTo2cv8=
 83 | github.com/kelseyhightower/envconfig v1.4.0/go.mod h1:cccZRl6mQpaq41TPp5QxidR+Sa3axMbJDNb//FQX6Gg=
 84 | github.com/konsorten/go-windows-terminal-sequences v1.0.1 h1:mweAR1A6xJ3oS2pRaGiHgQ4OO8tzTaLawm8vnODuwDk=
 85 | github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
 86 | github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=
 87 | github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
 88 | github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
 89 | github.com/kr/pretty v0.2.0 h1:s5hAObm+yFO5uHYt5dYjxi2rXrsnmRpJx4OYvIWUaQs=
 90 | github.com/kr/pretty v0.2.0/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
 91 | github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
 92 | github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
 93 | github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 94 | github.com/magiconair/properties v1.8.1 h1:ZC2Vc7/ZFkGmsVC9KvOjumD+G5lXy2RtTKyzRKO2BQ4=
 95 | github.com/magiconair/properties v1.8.1/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
 96 | github.com/markbates/oncer v0.0.0-20181203154359-bf2de49a0be2 h1:JgVTCPf0uBVcUSWpyXmGpgOc62nK5HWUBKAGc3Qqa5k=
 97 | github.com/markbates/oncer v0.0.0-20181203154359-bf2de49a0be2/go.mod h1:Ld9puTsIW75CHf65OeIOkyKbteujpZVXDpWK6YGZbxE=
 98 | github.com/markbates/safe v1.0.1 h1:yjZkbvRM6IzKj9tlu/zMJLS0n/V351OZWRnF3QfaUxI=
 99 | github.com/markbates/safe v1.0.1/go.mod h1:nAqgmRi7cY2nqMc92/bSEeQA+R4OheNU2T1kNSCBdG0=
100 | github.com/matttproud/golang_protobuf_extensions v1.0.1 h1:4hp9jkHxhMHkqkrB3Ix0jegS5sx/RkqARlsWZ6pIwiU=
101 | github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
102 | github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
103 | github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
104 | github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
105 | github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
106 | github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
107 | github.com/phayes/freeport v0.0.0-20180830031419-95f893ade6f2 h1:JhzVVoYvbOACxoUmOs6V/G4D5nPVUW73rKvXxP4XUJc=
108 | github.com/phayes/freeport v0.0.0-20180830031419-95f893ade6f2/go.mod h1:iIss55rKnNBTvrwdmkUpLnDpZoAHvWaiq5+iMmen4AE=
109 | github.com/pion/logging v0.2.2 h1:M9+AIj/+pxNsDfAT64+MAVgJO0rsyLnoJKCqf//DoeY=
110 | github.com/pion/logging v0.2.2/go.mod h1:k0/tDVsRCX2Mb2ZEmTqNa7CWsQPc+YYCB7Q+5pahoms=
111 | github.com/pion/randutil v0.1.0 h1:CFG1UdESneORglEsnimhUjf33Rwjubwj6xfiOXBa3mA=
112 | github.com/pion/randutil v0.1.0/go.mod h1:XcJrSMMbbMRhASFVOlj/5hQial/Y8oH/HVo7TBZq+j8=
113 | github.com/pion/stun v0.3.5 h1:uLUCBCkQby4S1cf6CGuR9QrVOKcvUwFeemaC865QHDg=
114 | github.com/pion/stun v0.3.5/go.mod h1:gDMim+47EeEtfWogA37n6qXZS88L5V6LqFcf+DZA2UA=
115 | github.com/pion/transport v0.10.1 h1:2W+yJT+0mOQ160ThZYUx5Zp2skzshiNgxrNE9GUfhJM=
116 | github.com/pion/transport v0.10.1/go.mod h1:PBis1stIILMiis0PewDw91WJeLJkyIMcEk+DwKOzf4A=
117 | github.com/pion/turn/v2 v2.0.5 h1:iwMHqDfPEDEOFzwWKT56eFmh6DYC6o/+xnLAEzgISbA=
118 | github.com/pion/turn/v2 v2.0.5/go.mod h1:APg43CFyt/14Uy7heYUOGWdkem/Wu4PhCO/bjyrTqMw=
119 | github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
120 | github.com/pkg/errors v0.8.1 h1:iURUrRGxPUNPdy5/HRSm+Yj6okJ6UtLINN0Q9M4+h3I=
121 | github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
122 | github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
123 | github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
124 | github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw=
125 | github.com/prometheus/client_golang v1.0.0/go.mod h1:db9x61etRT2tGnBNRi70OPL5FsnadC4Ky3P0J6CfImo=
126 | github.com/prometheus/client_golang v1.7.1 h1:NTGy1Ja9pByO+xAeH/qiWnLrKtr3hJPNjaVUwnjpdpA=
127 | github.com/prometheus/client_golang v1.7.1/go.mod h1:PY5Wy2awLA44sXw4AOSfFBetzPP4j5+D6mVACh+pe2M=
128 | github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
129 | github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
130 | github.com/prometheus/client_model v0.2.0 h1:uq5h0d+GuxiXLJLNABMgp2qUWDPiLvgCzz2dUR+/W/M=
131 | github.com/prometheus/client_model v0.2.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
132 | github.com/prometheus/common v0.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
133 | github.com/prometheus/common v0.10.0 h1:RyRA7RzGXQZiW+tGMr7sxa85G1z0yOpM1qq5c8lNawc=
134 | github.com/prometheus/common v0.10.0/go.mod h1:Tlit/dnDKsSWFlCLTWaA1cyBgKHSMdTB80sz/V91rCo=
135 | github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
136 | github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
137 | github.com/prometheus/procfs v0.1.3 h1:F0+tqvhOksq22sc6iCHF5WGlWjdwj92p0udFh1VFBS8=
138 | github.com/prometheus/procfs v0.1.3/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU=
139 | github.com/rogpeppe/go-internal v1.1.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
140 | github.com/rogpeppe/go-internal v1.2.2/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
141 | github.com/rogpeppe/go-internal v1.3.0 h1:RR9dF3JtopPvtkroDZuVD7qquD0bnHlKSqaQhgwt8yk=
142 | github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
143 | github.com/rs/xid v1.2.1 h1:mhH9Nq+C1fY2l1XIpgxIiUOfNpRBYH1kKcr+qfKgjRc=
144 | github.com/rs/xid v1.2.1/go.mod h1:+uKXf+4Djp6Md1KODXJxgGQPKngRmWyn10oCKFzNHOQ=
145 | github.com/rs/zerolog v1.19.0 h1:hYz4ZVdUgjXTBUmrkrw55j1nHx68LfOKIQk5IYtyScg=
146 | github.com/rs/zerolog v1.19.0/go.mod h1:IzD0RJ65iWH0w97OQQebJEvTZYvsCUm9WVLWBQrJRjo=
147 | github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
148 | github.com/sirupsen/logrus v1.4.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
149 | github.com/sirupsen/logrus v1.4.1 h1:GL2rEmy6nsikmW0r8opw9JIRScdMF5hA8cOYLH7In1k=
150 | github.com/sirupsen/logrus v1.4.1/go.mod h1:ni0Sbl8bgC9z8RoU9G6nDWqqs/fq4eDPysMBDgk/93Q=
151 | github.com/sirupsen/logrus v1.4.2 h1:SPIRibHv4MatM3XXNO2BJeFLZwZ2LvZgfQ5+UNI2im4=
152 | github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=
153 | github.com/spf13/cobra v0.0.3 h1:ZlrZ4XsMRm04Fr5pSFxBgfND2EBVa1nLpiy1stUsX/8=
154 | github.com/spf13/cobra v0.0.3/go.mod h1:1l0Ry5zgKvJasoi3XT1TypsSe7PqH0Sj9dhYf7v3XqQ=
155 | github.com/spf13/pflag v1.0.3 h1:zPAT6CGy6wXeQ7NtTnaTerfKOsV6V6F8agHXFiazDkg=
156 | github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
157 | github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
158 | github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
159 | github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
160 | github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
161 | github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
162 | github.com/stretchr/testify v1.6.1 h1:hDPOHmpOpP40lSULcqw7IrRb/u7w6RpDC9399XyoNd0=
163 | github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
164 | github.com/urfave/cli v1.20.0 h1:fDqGv3UG/4jbVl/QkFwEdddtEDjh/5Ov6X+0B/3bPaw=
165 | github.com/urfave/cli v1.20.0/go.mod h1:70zkFmudgCuE/ngEzBv17Jvp/497gISqfk5gWijbERA=
166 | golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
167 | golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
168 | golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9 h1:psW17arqaxU48Z5kZ0CQnkZWQJsqcURM6tKiBApRjXI=
169 | golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
170 | golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
171 | golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
172 | golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
173 | golang.org/x/net v0.0.0-20190613194153-d28f0bde5980/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
174 | golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
175 | golang.org/x/net v0.0.0-20200625001655-4c5254603344 h1:vGXIOMxbNfDTk/aXCmfdLgkrSV+Z2tcbze+pEc3v5W4=
176 | golang.org/x/net v0.0.0-20200625001655-4c5254603344/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
177 | golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
178 | golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
179 | golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
180 | golang.org/x/sync v0.0.0-20190412183630-56d357773e84/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
181 | golang.org/x/sync v0.0.0-20190423024810-112230192c58 h1:8gQV6CLnAEikrhgkHFbMAEhagSSnXWGV915qUMm9mrU=
182 | golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
183 | golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e h1:vcxGaoTs7kV8m5Np9uUNQin4BrLOthgV7252N8V+FwY=
184 | golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
185 | golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
186 | golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
187 | golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
188 | golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
189 | golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
190 | golang.org/x/sys v0.0.0-20200106162015-b016eb3dc98e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
191 | golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd h1:xhmwyvizuTgC2qz7ZlMluP20uW+C3Rm0FD/WLDX8884=
192 | golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
193 | golang.org/x/sys v0.0.0-20200615200032-f1bc736245b1 h1:ogLJMz+qpzav7lGMh10LMvAkM/fAoGlaiiHYiFYdm80=
194 | golang.org/x/sys v0.0.0-20200615200032-f1bc736245b1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
195 | golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
196 | golang.org/x/tools v0.0.0-20190329151228-23e29df326fe/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
197 | golang.org/x/tools v0.0.0-20190416151739-9c9e1878f421/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
198 | golang.org/x/tools v0.0.0-20190828213141-aed303cbaa74 h1:4cFkmztxtMslUX2SctSl+blCyXfpzhGOy9LhKAqSMA4=
199 | golang.org/x/tools v0.0.0-20190828213141-aed303cbaa74/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
200 | golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
201 | golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
202 | golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
203 | google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
204 | google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
205 | google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
206 | google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
207 | google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
208 | google.golang.org/protobuf v1.23.0 h1:4MY060fB1DLGMB/7MBTLnwQUY6+F09GEiz6SsrNqyzM=
209 | google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
210 | gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
211 | gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
212 | gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
213 | gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
214 | gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 h1:YR8cESwS4TdDjEe65xsg0ogRM/Nc3DYOhEAlW+xobZo=
215 | gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
216 | gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
217 | gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
218 | gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
219 | gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
220 | gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
221 | gopkg.in/yaml.v2 v2.2.5/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
222 | gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
223 | gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
224 | 


--------------------------------------------------------------------------------