2020-09-18 10:28:05 +02:00
|
|
|
package rtpconn
|
2020-04-24 19:38:21 +02:00
|
|
|
|
|
|
|
import (
|
|
|
|
"encoding/json"
|
|
|
|
"errors"
|
2020-12-04 22:42:20 +01:00
|
|
|
"fmt"
|
2020-04-24 19:38:21 +02:00
|
|
|
"log"
|
|
|
|
"os"
|
|
|
|
"sync"
|
|
|
|
"time"
|
|
|
|
|
|
|
|
"github.com/gorilla/websocket"
|
2020-07-16 20:17:32 +02:00
|
|
|
"github.com/pion/webrtc/v3"
|
2020-04-24 19:38:21 +02:00
|
|
|
|
2020-12-19 17:37:48 +01:00
|
|
|
"github.com/jech/galene/conn"
|
|
|
|
"github.com/jech/galene/diskwriter"
|
|
|
|
"github.com/jech/galene/estimator"
|
|
|
|
"github.com/jech/galene/group"
|
2021-01-02 00:20:47 +01:00
|
|
|
"github.com/jech/galene/ice"
|
2020-04-24 19:38:21 +02:00
|
|
|
)
|
2020-04-25 02:09:11 +02:00
|
|
|
|
2020-11-30 16:26:11 +01:00
|
|
|
func errorToWSCloseMessage(id string, err error) (*clientMessage, []byte) {
|
2020-04-24 19:38:21 +02:00
|
|
|
var code int
|
2020-11-30 16:26:11 +01:00
|
|
|
var m *clientMessage
|
2020-04-24 19:38:21 +02:00
|
|
|
var text string
|
|
|
|
switch e := err.(type) {
|
|
|
|
case *websocket.CloseError:
|
|
|
|
code = websocket.CloseNormalClosure
|
2020-09-13 11:56:35 +02:00
|
|
|
case group.ProtocolError:
|
2020-04-24 19:38:21 +02:00
|
|
|
code = websocket.CloseProtocolError
|
2020-11-30 16:26:11 +01:00
|
|
|
m = &clientMessage{
|
2020-12-19 17:38:47 +01:00
|
|
|
Type: "usermessage",
|
|
|
|
Kind: "error",
|
|
|
|
Dest: id,
|
|
|
|
Privileged: true,
|
2020-12-28 01:42:26 +01:00
|
|
|
Value: e.Error(),
|
2020-11-30 16:26:11 +01:00
|
|
|
}
|
|
|
|
text = e.Error()
|
|
|
|
case group.UserError, group.KickError:
|
2020-04-25 02:09:11 +02:00
|
|
|
code = websocket.CloseNormalClosure
|
2020-11-30 16:26:11 +01:00
|
|
|
m = errorMessage(id, err)
|
|
|
|
text = e.Error()
|
2020-04-24 19:38:21 +02:00
|
|
|
default:
|
|
|
|
code = websocket.CloseInternalServerErr
|
|
|
|
}
|
2020-11-30 16:26:11 +01:00
|
|
|
return m, websocket.FormatCloseMessage(code, text)
|
2020-04-24 19:38:21 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
func isWSNormalError(err error) bool {
|
|
|
|
return websocket.IsCloseError(err,
|
|
|
|
websocket.CloseNormalClosure,
|
|
|
|
websocket.CloseGoingAway)
|
|
|
|
}
|
|
|
|
|
2020-05-27 11:44:49 +02:00
|
|
|
type webClient struct {
|
2020-09-13 11:56:35 +02:00
|
|
|
group *group.Group
|
2020-05-27 11:44:49 +02:00
|
|
|
id string
|
2020-11-29 14:26:42 +01:00
|
|
|
username string
|
|
|
|
password string
|
2020-09-13 11:56:35 +02:00
|
|
|
permissions group.ClientPermissions
|
2020-05-27 11:44:49 +02:00
|
|
|
requested map[string]uint32
|
|
|
|
done chan struct{}
|
|
|
|
writeCh chan interface{}
|
|
|
|
writerDone chan struct{}
|
|
|
|
actionCh chan interface{}
|
|
|
|
|
|
|
|
mu sync.Mutex
|
|
|
|
down map[string]*rtpDownConnection
|
2020-06-08 22:14:28 +02:00
|
|
|
up map[string]*rtpUpConnection
|
2020-05-27 11:44:49 +02:00
|
|
|
}
|
|
|
|
|
2020-09-13 11:56:35 +02:00
|
|
|
func (c *webClient) Group() *group.Group {
|
2020-05-28 02:35:09 +02:00
|
|
|
return c.group
|
|
|
|
}
|
|
|
|
|
2020-06-08 22:14:28 +02:00
|
|
|
func (c *webClient) Id() string {
|
2020-05-28 02:35:09 +02:00
|
|
|
return c.id
|
|
|
|
}
|
|
|
|
|
2020-11-29 14:26:42 +01:00
|
|
|
func (c *webClient) Username() string {
|
|
|
|
return c.username
|
|
|
|
}
|
|
|
|
|
|
|
|
func (c *webClient) Challenge(group string, creds group.ClientCredentials) bool {
|
|
|
|
if creds.Password == nil {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
m, err := creds.Password.Match(c.password)
|
|
|
|
if err != nil {
|
|
|
|
log.Printf("Password match: %v", err)
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
return m
|
2020-05-28 02:35:09 +02:00
|
|
|
}
|
|
|
|
|
2021-01-14 03:56:37 +01:00
|
|
|
func (c *webClient) Permissions() group.ClientPermissions {
|
|
|
|
return c.permissions
|
|
|
|
}
|
|
|
|
|
2020-09-13 11:56:35 +02:00
|
|
|
func (c *webClient) SetPermissions(perms group.ClientPermissions) {
|
2020-09-13 10:16:10 +02:00
|
|
|
c.permissions = perms
|
|
|
|
}
|
|
|
|
|
2020-10-01 13:38:09 +02:00
|
|
|
func (c *webClient) OverridePermissions(g *group.Group) bool {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2020-09-13 11:56:35 +02:00
|
|
|
func (c *webClient) PushClient(id, username string, add bool) error {
|
2020-08-12 13:51:31 +02:00
|
|
|
kind := "add"
|
|
|
|
if !add {
|
|
|
|
kind = "delete"
|
|
|
|
}
|
2020-05-31 20:41:17 +02:00
|
|
|
return c.write(clientMessage{
|
|
|
|
Type: "user",
|
2020-08-12 13:51:31 +02:00
|
|
|
Kind: kind,
|
2020-05-31 20:41:17 +02:00
|
|
|
Id: id,
|
|
|
|
Username: username,
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2020-05-18 00:35:58 +02:00
|
|
|
type rateMap map[string]uint32
|
|
|
|
|
|
|
|
func (v *rateMap) UnmarshalJSON(b []byte) error {
|
|
|
|
var m map[string]interface{}
|
|
|
|
|
|
|
|
err := json.Unmarshal(b, &m)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
n := make(map[string]uint32, len(m))
|
|
|
|
for k, w := range m {
|
|
|
|
switch w := w.(type) {
|
|
|
|
case bool:
|
|
|
|
if w {
|
|
|
|
n[k] = ^uint32(0)
|
|
|
|
} else {
|
|
|
|
n[k] = 0
|
|
|
|
}
|
|
|
|
case float64:
|
|
|
|
if w < 0 || w >= float64(^uint32(0)) {
|
|
|
|
return errors.New("overflow")
|
|
|
|
}
|
|
|
|
n[k] = uint32(w)
|
|
|
|
default:
|
|
|
|
return errors.New("unexpected type in JSON map")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
*v = n
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (v rateMap) MarshalJSON() ([]byte, error) {
|
|
|
|
m := make(map[string]interface{}, len(v))
|
|
|
|
for k, w := range v {
|
|
|
|
switch w {
|
|
|
|
case 0:
|
|
|
|
m[k] = false
|
|
|
|
case ^uint32(0):
|
|
|
|
m[k] = true
|
|
|
|
default:
|
|
|
|
m[k] = w
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return json.Marshal(m)
|
|
|
|
}
|
|
|
|
|
2020-04-24 19:38:21 +02:00
|
|
|
type clientMessage struct {
|
2021-01-03 17:00:58 +01:00
|
|
|
Type string `json:"type"`
|
|
|
|
Kind string `json:"kind,omitempty"`
|
|
|
|
Id string `json:"id,omitempty"`
|
2021-01-31 19:00:09 +01:00
|
|
|
Replace string `json:"replace,omitempty"`
|
2021-01-03 17:00:58 +01:00
|
|
|
Source string `json:"source,omitempty"`
|
|
|
|
Dest string `json:"dest,omitempty"`
|
|
|
|
Username string `json:"username,omitempty"`
|
|
|
|
Password string `json:"password,omitempty"`
|
|
|
|
Privileged bool `json:"privileged,omitempty"`
|
|
|
|
Permissions *group.ClientPermissions `json:"permissions,omitempty"`
|
|
|
|
Group string `json:"group,omitempty"`
|
|
|
|
Value interface{} `json:"value,omitempty"`
|
2021-01-11 16:22:04 +01:00
|
|
|
NoEcho bool `json:"noecho,omitempty"`
|
2021-01-03 17:00:58 +01:00
|
|
|
Time int64 `json:"time,omitempty"`
|
|
|
|
SDP string `json:"sdp,omitempty"`
|
|
|
|
Candidate *webrtc.ICECandidateInit `json:"candidate,omitempty"`
|
|
|
|
Labels map[string]string `json:"labels,omitempty"`
|
|
|
|
Request rateMap `json:"request,omitempty"`
|
|
|
|
RTCConfiguration *webrtc.Configuration `json:"rtcConfiguration,omitempty"`
|
2020-04-24 19:38:21 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
type closeMessage struct {
|
|
|
|
data []byte
|
|
|
|
}
|
|
|
|
|
2020-06-08 22:14:28 +02:00
|
|
|
func getUpConn(c *webClient, id string) *rtpUpConnection {
|
2020-04-28 14:54:50 +02:00
|
|
|
c.mu.Lock()
|
|
|
|
defer c.mu.Unlock()
|
2020-04-24 19:38:21 +02:00
|
|
|
|
|
|
|
if c.up == nil {
|
|
|
|
return nil
|
|
|
|
}
|
2020-06-08 22:14:28 +02:00
|
|
|
return c.up[id]
|
2020-04-24 19:38:21 +02:00
|
|
|
}
|
|
|
|
|
2020-06-08 22:14:28 +02:00
|
|
|
func getUpConns(c *webClient) []*rtpUpConnection {
|
2020-04-28 14:54:50 +02:00
|
|
|
c.mu.Lock()
|
|
|
|
defer c.mu.Unlock()
|
2020-06-08 22:14:28 +02:00
|
|
|
up := make([]*rtpUpConnection, 0, len(c.up))
|
2020-06-08 19:10:08 +02:00
|
|
|
for _, u := range c.up {
|
|
|
|
up = append(up, u)
|
2020-04-25 18:35:32 +02:00
|
|
|
}
|
|
|
|
return up
|
|
|
|
}
|
|
|
|
|
2021-01-11 20:24:09 +01:00
|
|
|
func addUpConn(c *webClient, id string, labels map[string]string, offer string) (*rtpUpConnection, bool, error) {
|
2020-04-28 23:41:18 +02:00
|
|
|
c.mu.Lock()
|
|
|
|
defer c.mu.Unlock()
|
|
|
|
|
|
|
|
if c.up == nil {
|
2020-06-08 22:14:28 +02:00
|
|
|
c.up = make(map[string]*rtpUpConnection)
|
2020-04-28 23:41:18 +02:00
|
|
|
}
|
2020-06-10 20:25:25 +02:00
|
|
|
if c.down != nil && c.down[id] != nil {
|
2020-08-06 23:55:00 +02:00
|
|
|
return nil, false, errors.New("Adding duplicate connection")
|
2020-04-28 23:41:18 +02:00
|
|
|
}
|
2020-06-10 20:25:25 +02:00
|
|
|
|
|
|
|
old := c.up[id]
|
|
|
|
if old != nil {
|
2020-08-06 23:55:00 +02:00
|
|
|
return old, false, nil
|
|
|
|
}
|
|
|
|
|
2021-01-11 20:24:09 +01:00
|
|
|
conn, err := newUpConn(c, id, labels, offer)
|
2020-08-06 23:55:00 +02:00
|
|
|
if err != nil {
|
|
|
|
return nil, false, err
|
2020-06-10 20:25:25 +02:00
|
|
|
}
|
|
|
|
|
2020-04-28 23:41:18 +02:00
|
|
|
c.up[id] = conn
|
|
|
|
|
2020-06-08 22:14:28 +02:00
|
|
|
conn.pc.OnICECandidate(func(candidate *webrtc.ICECandidate) {
|
2020-04-24 19:38:21 +02:00
|
|
|
sendICE(c, id, candidate)
|
|
|
|
})
|
|
|
|
|
2020-08-11 15:13:30 +02:00
|
|
|
conn.pc.OnICEConnectionStateChange(func(state webrtc.ICEConnectionState) {
|
|
|
|
if state == webrtc.ICEConnectionStateFailed {
|
|
|
|
c.action(connectionFailedAction{id: id})
|
|
|
|
}
|
|
|
|
})
|
|
|
|
|
2020-08-06 23:55:00 +02:00
|
|
|
return conn, true, nil
|
2020-04-29 01:57:37 +02:00
|
|
|
}
|
2020-04-24 19:38:21 +02:00
|
|
|
|
2021-01-31 19:00:09 +01:00
|
|
|
var ErrUserMismatch = errors.New("user id mismatch")
|
|
|
|
|
2021-02-01 14:08:54 +01:00
|
|
|
// delUpConn deletes an up connection. If push is closed, the close is
|
|
|
|
// pushed to all corresponding down connections.
|
|
|
|
func delUpConn(c *webClient, id string, userId string, push bool) error {
|
2020-04-28 14:54:50 +02:00
|
|
|
c.mu.Lock()
|
2020-04-24 19:38:21 +02:00
|
|
|
if c.up == nil {
|
2020-06-08 19:10:08 +02:00
|
|
|
c.mu.Unlock()
|
2021-02-01 14:08:54 +01:00
|
|
|
return os.ErrNotExist
|
2020-04-24 19:38:21 +02:00
|
|
|
}
|
|
|
|
conn := c.up[id]
|
|
|
|
if conn == nil {
|
2020-06-08 19:10:08 +02:00
|
|
|
c.mu.Unlock()
|
2021-02-01 14:08:54 +01:00
|
|
|
return os.ErrNotExist
|
2020-04-24 19:38:21 +02:00
|
|
|
}
|
2021-01-31 19:00:09 +01:00
|
|
|
if userId != "" && conn.userId != userId {
|
|
|
|
c.mu.Unlock()
|
2021-02-01 14:08:54 +01:00
|
|
|
return ErrUserMismatch
|
2021-01-31 19:00:09 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
replace := conn.getReplace(true)
|
|
|
|
|
2020-06-08 19:10:08 +02:00
|
|
|
delete(c.up, id)
|
2021-02-01 14:08:54 +01:00
|
|
|
g := c.group
|
2020-06-08 19:10:08 +02:00
|
|
|
c.mu.Unlock()
|
2020-04-24 19:38:21 +02:00
|
|
|
|
2021-02-01 14:08:54 +01:00
|
|
|
conn.pc.Close()
|
|
|
|
|
|
|
|
if push && g != nil {
|
2020-12-01 22:42:06 +01:00
|
|
|
go func(clients []group.Client) {
|
|
|
|
for _, c := range clients {
|
2021-02-01 14:08:54 +01:00
|
|
|
err := c.PushConn(g, id, nil, nil, replace)
|
2020-12-04 12:15:37 +01:00
|
|
|
if err != nil {
|
|
|
|
log.Printf("PushConn: %v", err)
|
|
|
|
}
|
2020-12-01 22:42:06 +01:00
|
|
|
}
|
|
|
|
}(g.GetClients(c))
|
|
|
|
}
|
2020-06-10 20:25:25 +02:00
|
|
|
|
2021-02-01 14:08:54 +01:00
|
|
|
return nil
|
2020-06-10 20:25:25 +02:00
|
|
|
}
|
|
|
|
|
2020-05-27 11:44:49 +02:00
|
|
|
func getDownConn(c *webClient, id string) *rtpDownConnection {
|
2020-04-24 19:38:21 +02:00
|
|
|
if c.down == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2020-04-28 14:54:50 +02:00
|
|
|
c.mu.Lock()
|
|
|
|
defer c.mu.Unlock()
|
2020-04-24 19:38:21 +02:00
|
|
|
conn := c.down[id]
|
|
|
|
if conn == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
return conn
|
|
|
|
}
|
|
|
|
|
2020-05-27 11:44:49 +02:00
|
|
|
func getConn(c *webClient, id string) iceConnection {
|
2020-05-22 22:36:47 +02:00
|
|
|
up := getUpConn(c, id)
|
|
|
|
if up != nil {
|
|
|
|
return up
|
|
|
|
}
|
|
|
|
down := getDownConn(c, id)
|
|
|
|
if down != nil {
|
|
|
|
return down
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2021-02-02 19:38:15 +01:00
|
|
|
func addDownConn(c *webClient, remote conn.Up) (*rtpDownConnection, bool, error) {
|
|
|
|
id := remote.Id()
|
2020-10-01 15:48:00 +02:00
|
|
|
|
2020-06-08 22:14:28 +02:00
|
|
|
c.mu.Lock()
|
|
|
|
defer c.mu.Unlock()
|
2020-04-24 19:38:21 +02:00
|
|
|
|
2021-02-02 19:38:15 +01:00
|
|
|
if c.up != nil && c.up[id] != nil {
|
|
|
|
return nil, false, errors.New("adding duplicate connection")
|
2020-06-10 20:25:25 +02:00
|
|
|
}
|
|
|
|
|
2020-04-24 19:38:21 +02:00
|
|
|
if c.down == nil {
|
2020-05-26 17:44:21 +02:00
|
|
|
c.down = make(map[string]*rtpDownConnection)
|
2020-04-24 19:38:21 +02:00
|
|
|
}
|
2020-05-23 02:22:43 +02:00
|
|
|
|
2021-02-02 19:38:15 +01:00
|
|
|
if down := c.down[id]; down != nil {
|
|
|
|
return down, false, nil
|
2020-04-24 19:38:21 +02:00
|
|
|
}
|
2020-06-08 22:14:28 +02:00
|
|
|
|
2021-02-02 19:38:15 +01:00
|
|
|
down, err := newDownConn(c, id, remote)
|
|
|
|
if err != nil {
|
|
|
|
return nil, false, err
|
|
|
|
}
|
|
|
|
|
|
|
|
down.pc.OnICECandidate(func(candidate *webrtc.ICECandidate) {
|
|
|
|
sendICE(c, down.id, candidate)
|
2020-06-08 22:14:28 +02:00
|
|
|
})
|
|
|
|
|
2021-02-02 19:38:15 +01:00
|
|
|
down.pc.OnICEConnectionStateChange(func(state webrtc.ICEConnectionState) {
|
2020-06-11 20:22:28 +02:00
|
|
|
if state == webrtc.ICEConnectionStateFailed {
|
2021-02-02 19:38:15 +01:00
|
|
|
c.action(connectionFailedAction{id: down.id})
|
2020-06-11 20:22:28 +02:00
|
|
|
}
|
|
|
|
})
|
|
|
|
|
2021-02-02 19:38:15 +01:00
|
|
|
err = remote.AddLocal(down)
|
2020-05-30 03:36:15 +02:00
|
|
|
if err != nil {
|
2021-02-02 19:38:15 +01:00
|
|
|
down.pc.Close()
|
|
|
|
return nil, false, err
|
2020-05-30 03:36:15 +02:00
|
|
|
}
|
2020-05-23 02:22:43 +02:00
|
|
|
|
2021-02-02 19:38:15 +01:00
|
|
|
c.down[down.id] = down
|
|
|
|
|
|
|
|
go rtcpDownSender(down)
|
|
|
|
|
|
|
|
return down, true, nil
|
2020-04-24 19:38:21 +02:00
|
|
|
}
|
|
|
|
|
2021-01-31 19:00:09 +01:00
|
|
|
func delDownConn(c *webClient, id string) error {
|
2020-10-01 15:48:00 +02:00
|
|
|
conn := delDownConnHelper(c, id)
|
|
|
|
if conn != nil {
|
|
|
|
conn.pc.Close()
|
2021-01-31 19:00:09 +01:00
|
|
|
return nil
|
2020-10-01 15:48:00 +02:00
|
|
|
}
|
2021-01-31 19:00:09 +01:00
|
|
|
return os.ErrNotExist
|
2020-10-01 15:48:00 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
func delDownConnHelper(c *webClient, id string) *rtpDownConnection {
|
2020-04-28 14:54:50 +02:00
|
|
|
c.mu.Lock()
|
|
|
|
defer c.mu.Unlock()
|
2020-04-24 19:38:21 +02:00
|
|
|
|
|
|
|
if c.down == nil {
|
2020-10-01 15:48:00 +02:00
|
|
|
return nil
|
2020-04-24 19:38:21 +02:00
|
|
|
}
|
2020-04-25 02:25:51 +02:00
|
|
|
conn := c.down[id]
|
2020-04-24 19:38:21 +02:00
|
|
|
if conn == nil {
|
2020-10-01 15:48:00 +02:00
|
|
|
return nil
|
2020-04-24 19:38:21 +02:00
|
|
|
}
|
2020-04-28 14:54:50 +02:00
|
|
|
|
2020-09-13 11:04:16 +02:00
|
|
|
conn.remote.DelLocal(conn)
|
2020-04-28 14:54:50 +02:00
|
|
|
for _, track := range conn.tracks {
|
2020-05-30 12:33:30 +02:00
|
|
|
// we only insert the track after we get an answer, so
|
|
|
|
// ignore errors here.
|
2020-09-13 11:04:16 +02:00
|
|
|
track.remote.DelLocal(track)
|
2020-04-28 14:54:50 +02:00
|
|
|
}
|
2020-04-24 19:38:21 +02:00
|
|
|
delete(c.down, id)
|
2020-10-01 15:48:00 +02:00
|
|
|
return conn
|
2020-04-24 19:38:21 +02:00
|
|
|
}
|
|
|
|
|
2021-02-02 19:38:15 +01:00
|
|
|
var errUnexpectedTrackType = errors.New("unexpected track type, this shouldn't happen")
|
2021-02-02 19:06:37 +01:00
|
|
|
|
2021-02-02 19:38:15 +01:00
|
|
|
func addDownTrackUnlocked(conn *rtpDownConnection, remoteTrack *rtpUpTrack, remoteConn conn.Up) error {
|
2021-02-02 19:06:37 +01:00
|
|
|
for _, t := range conn.tracks {
|
|
|
|
tt, ok := t.remote.(*rtpUpTrack)
|
|
|
|
if !ok {
|
2021-02-02 19:38:15 +01:00
|
|
|
return errUnexpectedTrackType
|
2021-02-02 19:06:37 +01:00
|
|
|
}
|
2021-02-02 19:38:15 +01:00
|
|
|
if tt == remoteTrack {
|
|
|
|
return os.ErrExist
|
2021-02-02 19:06:37 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-12-04 01:15:52 +01:00
|
|
|
local, err := webrtc.NewTrackLocalStaticRTP(
|
|
|
|
remoteTrack.Codec(),
|
2021-02-02 19:38:15 +01:00
|
|
|
remoteTrack.track.ID(), remoteTrack.track.StreamID(),
|
2020-12-04 01:15:52 +01:00
|
|
|
)
|
2020-04-24 19:38:21 +02:00
|
|
|
if err != nil {
|
2021-02-02 19:38:15 +01:00
|
|
|
return err
|
2020-04-24 19:38:21 +02:00
|
|
|
}
|
|
|
|
|
2020-12-04 01:15:52 +01:00
|
|
|
sender, err := conn.pc.AddTrack(local)
|
2020-04-28 14:54:50 +02:00
|
|
|
if err != nil {
|
2021-02-02 19:38:15 +01:00
|
|
|
return err
|
2020-04-28 14:54:50 +02:00
|
|
|
}
|
2020-04-26 01:33:18 +02:00
|
|
|
|
2020-12-04 01:15:52 +01:00
|
|
|
parms := sender.GetParameters()
|
|
|
|
if len(parms.Encodings) != 1 {
|
2021-02-02 19:38:15 +01:00
|
|
|
return errors.New("got multiple encodings")
|
2020-12-04 01:15:52 +01:00
|
|
|
}
|
|
|
|
|
2020-05-26 17:44:21 +02:00
|
|
|
track := &rtpDownTrack{
|
2020-06-12 17:39:16 +02:00
|
|
|
track: local,
|
2021-02-02 19:38:15 +01:00
|
|
|
sender: sender,
|
2020-12-04 01:15:52 +01:00
|
|
|
ssrc: parms.Encodings[0].SSRC,
|
2020-06-12 17:39:16 +02:00
|
|
|
remote: remoteTrack,
|
|
|
|
maxBitrate: new(bitrate),
|
|
|
|
stats: new(receiverStats),
|
|
|
|
rate: estimator.New(time.Second),
|
2020-12-27 01:24:52 +01:00
|
|
|
atomics: &downTrackAtomics{},
|
2020-04-28 15:26:50 +02:00
|
|
|
}
|
2021-01-19 23:55:33 +01:00
|
|
|
|
2020-04-28 14:54:50 +02:00
|
|
|
conn.tracks = append(conn.tracks, track)
|
|
|
|
|
2020-12-04 01:15:52 +01:00
|
|
|
go rtcpDownListener(conn, track, sender)
|
2020-04-24 19:38:21 +02:00
|
|
|
|
2021-02-02 19:38:15 +01:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func delDownTrackUnlocked(conn *rtpDownConnection, track *rtpDownTrack) error {
|
|
|
|
for i := range conn.tracks {
|
|
|
|
if conn.tracks[i] == track {
|
|
|
|
track.remote.DelLocal(track)
|
|
|
|
conn.tracks =
|
|
|
|
append(conn.tracks[:i], conn.tracks[i+1:]...)
|
|
|
|
return conn.pc.RemoveTrack(track.sender)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return os.ErrNotExist
|
|
|
|
}
|
|
|
|
|
|
|
|
func replaceTracks(conn *rtpDownConnection, remote []conn.UpTrack, remoteConn conn.Up) error {
|
|
|
|
conn.mu.Lock()
|
|
|
|
defer conn.mu.Unlock()
|
|
|
|
|
|
|
|
var add []*rtpUpTrack
|
|
|
|
var del []*rtpDownTrack
|
|
|
|
|
|
|
|
outer:
|
|
|
|
for _, rtrack := range remote {
|
|
|
|
rt, ok := rtrack.(*rtpUpTrack)
|
|
|
|
if !ok {
|
|
|
|
return errUnexpectedTrackType
|
|
|
|
}
|
|
|
|
for _, track := range conn.tracks {
|
|
|
|
rt2, ok := track.remote.(*rtpUpTrack)
|
|
|
|
if !ok {
|
|
|
|
return errUnexpectedTrackType
|
|
|
|
}
|
|
|
|
if rt == rt2 {
|
|
|
|
continue outer
|
|
|
|
}
|
|
|
|
}
|
|
|
|
add = append(add, rt)
|
|
|
|
}
|
|
|
|
|
|
|
|
outer2:
|
|
|
|
for _, track := range conn.tracks {
|
|
|
|
rt, ok := track.remote.(*rtpUpTrack)
|
|
|
|
if !ok {
|
|
|
|
return errUnexpectedTrackType
|
|
|
|
}
|
|
|
|
for _, rtrack := range remote {
|
|
|
|
rt2, ok := rtrack.(*rtpUpTrack)
|
|
|
|
if !ok {
|
|
|
|
return errUnexpectedTrackType
|
|
|
|
}
|
|
|
|
if rt == rt2 {
|
|
|
|
continue outer2
|
|
|
|
}
|
|
|
|
}
|
|
|
|
del = append(del, track)
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, t := range del {
|
|
|
|
err := delDownTrackUnlocked(conn, t)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, rt := range add {
|
|
|
|
err := addDownTrackUnlocked(conn, rt, remoteConn)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
2020-04-24 19:38:21 +02:00
|
|
|
}
|
|
|
|
|
2021-01-31 19:00:09 +01:00
|
|
|
func negotiate(c *webClient, down *rtpDownConnection, restartIce bool, replace string) error {
|
2021-01-12 20:44:48 +01:00
|
|
|
if down.pc.SignalingState() == webrtc.SignalingStateHaveLocalOffer {
|
|
|
|
// avoid sending multiple offers back-to-back
|
|
|
|
if restartIce {
|
|
|
|
down.negotiationNeeded = negotiationRestartIce
|
|
|
|
} else if down.negotiationNeeded == negotiationUnneeded {
|
|
|
|
down.negotiationNeeded = negotiationNeeded
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
down.negotiationNeeded = negotiationUnneeded
|
|
|
|
|
2020-07-16 20:51:51 +02:00
|
|
|
options := webrtc.OfferOptions{ICERestart: restartIce}
|
|
|
|
offer, err := down.pc.CreateOffer(&options)
|
2020-04-24 19:38:21 +02:00
|
|
|
if err != nil {
|
2020-05-17 22:31:29 +02:00
|
|
|
return err
|
2020-04-24 19:38:21 +02:00
|
|
|
}
|
|
|
|
|
2020-05-17 22:31:29 +02:00
|
|
|
err = down.pc.SetLocalDescription(offer)
|
2020-04-24 19:38:21 +02:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2020-05-17 22:31:29 +02:00
|
|
|
|
|
|
|
labels := make(map[string]string)
|
2020-05-21 22:30:31 +02:00
|
|
|
for _, t := range down.pc.GetTransceivers() {
|
2020-12-04 01:15:52 +01:00
|
|
|
var track webrtc.TrackLocal
|
2020-05-21 22:30:31 +02:00
|
|
|
if t.Sender() != nil {
|
|
|
|
track = t.Sender().Track()
|
|
|
|
}
|
|
|
|
if track == nil {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, tr := range down.tracks {
|
|
|
|
if tr.track == track {
|
2020-06-08 22:14:28 +02:00
|
|
|
labels[t.Mid()] = tr.remote.Label()
|
2020-05-21 22:30:31 +02:00
|
|
|
}
|
|
|
|
}
|
2020-04-24 19:38:21 +02:00
|
|
|
}
|
2020-05-17 22:31:29 +02:00
|
|
|
|
2021-01-03 12:04:39 +01:00
|
|
|
source, username := down.remote.User()
|
|
|
|
|
2020-04-24 19:38:21 +02:00
|
|
|
return c.write(clientMessage{
|
2021-01-03 12:04:39 +01:00
|
|
|
Type: "offer",
|
|
|
|
Id: down.id,
|
2021-01-31 19:00:09 +01:00
|
|
|
Replace: replace,
|
2021-01-03 12:04:39 +01:00
|
|
|
Source: source,
|
|
|
|
Username: username,
|
2021-01-11 20:27:39 +01:00
|
|
|
SDP: down.pc.LocalDescription().SDP,
|
2021-01-03 12:04:39 +01:00
|
|
|
Labels: labels,
|
2020-04-24 19:38:21 +02:00
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2020-05-27 11:44:49 +02:00
|
|
|
func sendICE(c *webClient, id string, candidate *webrtc.ICECandidate) error {
|
2020-04-24 19:38:21 +02:00
|
|
|
if candidate == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
cand := candidate.ToJSON()
|
|
|
|
return c.write(clientMessage{
|
|
|
|
Type: "ice",
|
|
|
|
Id: id,
|
|
|
|
Candidate: &cand,
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2021-01-31 19:00:09 +01:00
|
|
|
func gotOffer(c *webClient, id string, sdp string, labels map[string]string, replace string) error {
|
|
|
|
up, _, err := addUpConn(c, id, labels, sdp)
|
2020-06-10 20:25:25 +02:00
|
|
|
if err != nil {
|
|
|
|
return err
|
2020-04-24 19:38:21 +02:00
|
|
|
}
|
2020-08-06 23:55:00 +02:00
|
|
|
|
2021-01-03 12:04:39 +01:00
|
|
|
up.userId = c.Id()
|
|
|
|
up.username = c.Username()
|
2021-02-01 14:08:54 +01:00
|
|
|
if replace != "" {
|
|
|
|
up.replace = replace
|
|
|
|
delUpConn(c, replace, c.Id(), false)
|
|
|
|
}
|
2021-01-03 12:04:39 +01:00
|
|
|
|
2021-01-03 17:00:58 +01:00
|
|
|
err = up.pc.SetRemoteDescription(webrtc.SessionDescription{
|
|
|
|
Type: webrtc.SDPTypeOffer,
|
|
|
|
SDP: sdp,
|
|
|
|
})
|
2020-04-24 19:38:21 +02:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
answer, err := up.pc.CreateAnswer(nil)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
err = up.pc.SetLocalDescription(answer)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2020-05-22 23:07:38 +02:00
|
|
|
err = up.flushICECandidates()
|
|
|
|
if err != nil {
|
|
|
|
log.Printf("ICE: %v", err)
|
|
|
|
}
|
|
|
|
|
2020-04-24 19:38:21 +02:00
|
|
|
return c.write(clientMessage{
|
2021-01-03 17:00:58 +01:00
|
|
|
Type: "answer",
|
|
|
|
Id: id,
|
2021-01-11 20:27:39 +01:00
|
|
|
SDP: up.pc.LocalDescription().SDP,
|
2020-04-24 19:38:21 +02:00
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2020-10-01 13:47:48 +02:00
|
|
|
var ErrUnknownId = errors.New("unknown id")
|
|
|
|
|
2021-01-03 17:00:58 +01:00
|
|
|
func gotAnswer(c *webClient, id string, sdp string) error {
|
2020-05-22 23:07:38 +02:00
|
|
|
down := getDownConn(c, id)
|
|
|
|
if down == nil {
|
2020-10-01 13:47:48 +02:00
|
|
|
return ErrUnknownId
|
2020-04-24 19:38:21 +02:00
|
|
|
}
|
2021-01-19 23:30:01 +01:00
|
|
|
|
2021-02-02 22:57:56 +01:00
|
|
|
err := down.pc.SetRemoteDescription(webrtc.SessionDescription{
|
|
|
|
Type: webrtc.SDPTypeAnswer,
|
|
|
|
SDP: sdp,
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
return err
|
2020-04-24 19:38:21 +02:00
|
|
|
}
|
2020-05-21 00:55:00 +02:00
|
|
|
|
2020-12-25 20:48:42 +01:00
|
|
|
for _, t := range down.tracks {
|
|
|
|
local := t.track.Codec()
|
|
|
|
remote := t.remote.Codec()
|
|
|
|
if local.MimeType != remote.MimeType ||
|
|
|
|
local.ClockRate != remote.ClockRate {
|
|
|
|
return errors.New("negotiation failed")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-02-02 22:57:56 +01:00
|
|
|
err = down.flushICECandidates()
|
2020-05-22 23:07:38 +02:00
|
|
|
if err != nil {
|
|
|
|
log.Printf("ICE: %v", err)
|
|
|
|
}
|
|
|
|
|
2020-10-06 02:41:18 +02:00
|
|
|
add := func() {
|
|
|
|
down.pc.OnConnectionStateChange(nil)
|
|
|
|
for _, t := range down.tracks {
|
|
|
|
t.remote.AddLocal(t)
|
|
|
|
}
|
2020-05-21 00:55:00 +02:00
|
|
|
}
|
2020-10-06 02:41:18 +02:00
|
|
|
down.pc.OnConnectionStateChange(func(state webrtc.PeerConnectionState) {
|
|
|
|
if state == webrtc.PeerConnectionStateConnected {
|
|
|
|
add()
|
|
|
|
}
|
|
|
|
})
|
|
|
|
if down.pc.ConnectionState() == webrtc.PeerConnectionStateConnected {
|
|
|
|
add()
|
|
|
|
}
|
|
|
|
|
2020-04-24 19:38:21 +02:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2020-05-27 11:44:49 +02:00
|
|
|
func gotICE(c *webClient, candidate *webrtc.ICECandidateInit, id string) error {
|
2020-05-22 22:36:47 +02:00
|
|
|
conn := getConn(c, id)
|
|
|
|
if conn == nil {
|
|
|
|
return errors.New("unknown id in ICE")
|
2020-04-24 19:38:21 +02:00
|
|
|
}
|
2020-05-22 23:07:38 +02:00
|
|
|
return conn.addICECandidate(candidate)
|
2020-04-24 19:38:21 +02:00
|
|
|
}
|
|
|
|
|
2020-05-27 11:44:49 +02:00
|
|
|
func (c *webClient) setRequested(requested map[string]uint32) error {
|
2020-05-17 22:31:29 +02:00
|
|
|
c.requested = requested
|
2020-05-09 19:39:34 +02:00
|
|
|
|
2020-12-05 00:07:34 +01:00
|
|
|
go pushConns(c, c.group)
|
2020-05-09 19:39:34 +02:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2020-12-05 00:07:34 +01:00
|
|
|
func pushConns(c group.Client, g *group.Group) {
|
|
|
|
clients := g.GetClients(c)
|
2020-05-30 00:23:54 +02:00
|
|
|
for _, cc := range clients {
|
|
|
|
ccc, ok := cc.(*webClient)
|
|
|
|
if ok {
|
2020-12-05 00:07:34 +01:00
|
|
|
ccc.action(pushConnsAction{g, c})
|
2020-05-30 00:23:54 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-05-27 11:44:49 +02:00
|
|
|
func (c *webClient) isRequested(label string) bool {
|
2020-05-18 00:35:58 +02:00
|
|
|
return c.requested[label] != 0
|
2020-05-09 19:39:34 +02:00
|
|
|
}
|
|
|
|
|
2021-01-31 19:00:09 +01:00
|
|
|
func (c *webClient) PushConn(g *group.Group, id string, up conn.Up, tracks []conn.UpTrack, replace string) error {
|
|
|
|
err := c.action(pushConnAction{g, id, up, tracks, replace})
|
2020-05-28 02:35:09 +02:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
return nil
|
2020-05-12 18:27:40 +02:00
|
|
|
}
|
|
|
|
|
2020-12-01 22:42:06 +01:00
|
|
|
func readMessage(conn *websocket.Conn, m *clientMessage) error {
|
|
|
|
err := conn.SetReadDeadline(time.Now().Add(15 * time.Second))
|
2020-06-08 22:14:28 +02:00
|
|
|
if err != nil {
|
2020-12-01 22:42:06 +01:00
|
|
|
return err
|
2020-06-08 22:14:28 +02:00
|
|
|
}
|
2020-12-01 22:42:06 +01:00
|
|
|
defer conn.SetReadDeadline(time.Time{})
|
|
|
|
|
|
|
|
return conn.ReadJSON(&m)
|
|
|
|
}
|
|
|
|
|
2020-12-05 01:18:27 +01:00
|
|
|
func StartClient(conn *websocket.Conn) (err error) {
|
2020-12-01 22:42:06 +01:00
|
|
|
var m clientMessage
|
|
|
|
|
2020-12-05 01:18:27 +01:00
|
|
|
err = readMessage(conn, &m)
|
2020-06-08 22:14:28 +02:00
|
|
|
if err != nil {
|
|
|
|
conn.Close()
|
2020-12-05 01:18:27 +01:00
|
|
|
return
|
2020-06-08 22:14:28 +02:00
|
|
|
}
|
|
|
|
|
2020-12-01 22:42:06 +01:00
|
|
|
if m.Type != "handshake" {
|
2020-08-12 11:50:30 +02:00
|
|
|
conn.WriteMessage(websocket.CloseMessage,
|
|
|
|
websocket.FormatCloseMessage(
|
|
|
|
websocket.CloseProtocolError,
|
2020-12-01 22:42:06 +01:00
|
|
|
"you must handshake first",
|
2020-08-12 11:50:30 +02:00
|
|
|
),
|
|
|
|
)
|
2020-06-08 22:14:28 +02:00
|
|
|
conn.Close()
|
2020-12-05 01:18:27 +01:00
|
|
|
err = group.ProtocolError("client didn't handshake")
|
|
|
|
return
|
2020-06-08 22:14:28 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
c := &webClient{
|
2020-11-29 14:26:42 +01:00
|
|
|
id: m.Id,
|
2020-06-08 22:14:28 +02:00
|
|
|
actionCh: make(chan interface{}, 10),
|
|
|
|
done: make(chan struct{}),
|
|
|
|
}
|
|
|
|
|
|
|
|
defer close(c.done)
|
|
|
|
|
|
|
|
c.writeCh = make(chan interface{}, 25)
|
2020-12-01 22:42:06 +01:00
|
|
|
c.writerDone = make(chan struct{})
|
|
|
|
go clientWriter(conn, c.writeCh, c.writerDone)
|
2020-06-08 22:14:28 +02:00
|
|
|
defer func() {
|
2020-12-05 01:18:27 +01:00
|
|
|
m, e := errorToWSCloseMessage(c.id, err)
|
|
|
|
if isWSNormalError(err) {
|
|
|
|
err = nil
|
|
|
|
} else if _, ok := err.(group.KickError); ok {
|
|
|
|
err = nil
|
|
|
|
}
|
|
|
|
if m != nil {
|
|
|
|
c.write(*m)
|
2020-06-08 22:14:28 +02:00
|
|
|
}
|
2020-12-01 22:42:06 +01:00
|
|
|
c.close(e)
|
2020-06-08 22:14:28 +02:00
|
|
|
}()
|
|
|
|
|
|
|
|
return clientLoop(c, conn)
|
|
|
|
}
|
|
|
|
|
2020-09-13 11:57:33 +02:00
|
|
|
type pushConnAction struct {
|
2021-01-31 19:00:09 +01:00
|
|
|
group *group.Group
|
|
|
|
id string
|
|
|
|
conn conn.Up
|
|
|
|
tracks []conn.UpTrack
|
|
|
|
replace string
|
2020-09-13 11:57:33 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
type pushConnsAction struct {
|
2020-12-19 17:38:47 +01:00
|
|
|
group *group.Group
|
2020-12-05 00:07:34 +01:00
|
|
|
client group.Client
|
2020-09-13 11:57:33 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
type connectionFailedAction struct {
|
|
|
|
id string
|
|
|
|
}
|
|
|
|
|
|
|
|
type permissionsChangedAction struct{}
|
|
|
|
|
|
|
|
type kickAction struct {
|
2020-11-30 16:26:11 +01:00
|
|
|
id string
|
|
|
|
username string
|
|
|
|
message string
|
2020-09-13 11:57:33 +02:00
|
|
|
}
|
|
|
|
|
2020-09-13 11:04:16 +02:00
|
|
|
func clientLoop(c *webClient, ws *websocket.Conn) error {
|
2020-04-24 19:38:21 +02:00
|
|
|
read := make(chan interface{}, 1)
|
2020-09-13 11:04:16 +02:00
|
|
|
go clientReader(ws, read, c.done)
|
2020-04-24 19:38:21 +02:00
|
|
|
|
2020-12-05 00:07:34 +01:00
|
|
|
defer leaveGroup(c)
|
2020-04-24 19:38:21 +02:00
|
|
|
|
2020-04-25 22:44:24 +02:00
|
|
|
readTime := time.Now()
|
|
|
|
|
2020-06-12 17:39:16 +02:00
|
|
|
ticker := time.NewTicker(10 * time.Second)
|
2020-04-24 19:38:21 +02:00
|
|
|
defer ticker.Stop()
|
|
|
|
|
2021-01-03 12:04:39 +01:00
|
|
|
err := c.write(clientMessage{
|
|
|
|
Type: "handshake",
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2020-04-24 19:38:21 +02:00
|
|
|
for {
|
|
|
|
select {
|
|
|
|
case m, ok := <-read:
|
|
|
|
if !ok {
|
|
|
|
return errors.New("reader died")
|
|
|
|
}
|
|
|
|
switch m := m.(type) {
|
|
|
|
case clientMessage:
|
2020-04-25 22:44:24 +02:00
|
|
|
readTime = time.Now()
|
2020-04-24 19:38:21 +02:00
|
|
|
err := handleClientMessage(c, m)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
case error:
|
|
|
|
return m
|
|
|
|
}
|
|
|
|
case a := <-c.actionCh:
|
|
|
|
switch a := a.(type) {
|
2020-06-10 19:43:08 +02:00
|
|
|
case pushConnAction:
|
2020-12-05 00:07:34 +01:00
|
|
|
g := c.group
|
|
|
|
if g == nil || a.group != g {
|
|
|
|
return nil
|
|
|
|
}
|
2021-02-04 23:51:51 +01:00
|
|
|
var tracks []conn.UpTrack
|
|
|
|
if a.conn != nil {
|
|
|
|
tracks = make([]conn.UpTrack,
|
|
|
|
0, len(a.tracks),
|
|
|
|
)
|
|
|
|
for _, t := range a.tracks {
|
|
|
|
if c.isRequested(t.Label()) {
|
|
|
|
tracks = append(
|
|
|
|
tracks, t,
|
|
|
|
)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if len(tracks) == 0 {
|
|
|
|
closeDownConn(c, a.id, "")
|
2021-01-31 19:00:09 +01:00
|
|
|
if a.replace != "" {
|
2021-02-04 23:51:51 +01:00
|
|
|
closeDownConn(
|
2021-02-02 19:38:15 +01:00
|
|
|
c, a.replace, "",
|
2021-01-31 19:00:09 +01:00
|
|
|
)
|
|
|
|
}
|
2020-06-10 19:43:08 +02:00
|
|
|
continue
|
|
|
|
}
|
2021-02-02 19:38:15 +01:00
|
|
|
|
|
|
|
down, _, err := addDownConn(c, a.conn)
|
2020-05-17 23:51:17 +02:00
|
|
|
if err != nil {
|
|
|
|
return err
|
2020-04-24 19:38:21 +02:00
|
|
|
}
|
2021-02-02 19:38:15 +01:00
|
|
|
err = replaceTracks(down, tracks, a.conn)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2021-02-04 23:51:51 +01:00
|
|
|
if a.replace != "" {
|
|
|
|
err := delDownConn(c, a.replace)
|
|
|
|
if err != nil {
|
|
|
|
log.Printf("Replace: %v", err)
|
|
|
|
}
|
|
|
|
}
|
2021-02-02 19:38:15 +01:00
|
|
|
err = negotiate(
|
|
|
|
c, down, false, a.replace,
|
|
|
|
)
|
|
|
|
if err != nil {
|
|
|
|
log.Printf(
|
|
|
|
"Negotiation failed: %v",
|
|
|
|
err)
|
2021-02-04 23:51:51 +01:00
|
|
|
closeDownConn(c, down.id,
|
|
|
|
"negotiation failed")
|
2021-02-02 19:38:15 +01:00
|
|
|
continue
|
2020-04-24 19:38:21 +02:00
|
|
|
}
|
2020-05-17 23:51:17 +02:00
|
|
|
case pushConnsAction:
|
2020-12-05 00:07:34 +01:00
|
|
|
g := c.group
|
|
|
|
if g == nil || a.group != g {
|
|
|
|
return nil
|
|
|
|
}
|
2020-04-24 19:38:21 +02:00
|
|
|
for _, u := range c.up {
|
2020-11-05 20:47:13 +01:00
|
|
|
if !u.complete() {
|
|
|
|
continue
|
|
|
|
}
|
2020-06-08 19:10:08 +02:00
|
|
|
tracks := u.getTracks()
|
2021-01-31 19:00:09 +01:00
|
|
|
replace := u.getReplace(false)
|
|
|
|
|
2020-09-13 11:04:16 +02:00
|
|
|
ts := make([]conn.UpTrack, len(tracks))
|
2020-06-08 22:14:28 +02:00
|
|
|
for i, t := range tracks {
|
|
|
|
ts[i] = t
|
|
|
|
}
|
2021-01-31 19:00:09 +01:00
|
|
|
go func(u *rtpUpConnection,
|
|
|
|
ts []conn.UpTrack,
|
|
|
|
replace string) {
|
2020-12-05 00:07:34 +01:00
|
|
|
err := a.client.PushConn(
|
2021-01-31 19:00:09 +01:00
|
|
|
g, u.id, u, ts, replace,
|
2020-12-04 12:15:37 +01:00
|
|
|
)
|
|
|
|
if err != nil {
|
|
|
|
log.Printf(
|
|
|
|
"PushConn: %v",
|
|
|
|
err,
|
|
|
|
)
|
|
|
|
}
|
2021-01-31 19:00:09 +01:00
|
|
|
}(u, ts, replace)
|
2020-04-24 19:38:21 +02:00
|
|
|
}
|
2020-05-02 23:41:47 +02:00
|
|
|
case connectionFailedAction:
|
2020-08-11 15:13:30 +02:00
|
|
|
if down := getDownConn(c, a.id); down != nil {
|
2021-01-31 19:00:09 +01:00
|
|
|
err := negotiate(c, down, true, "")
|
2020-08-13 13:48:17 +02:00
|
|
|
if err != nil {
|
2020-08-11 15:13:30 +02:00
|
|
|
return err
|
|
|
|
}
|
2020-07-16 20:51:51 +02:00
|
|
|
tracks := make(
|
2020-09-13 11:04:16 +02:00
|
|
|
[]conn.UpTrack, len(down.tracks),
|
2020-07-16 20:51:51 +02:00
|
|
|
)
|
|
|
|
for i, t := range down.tracks {
|
|
|
|
tracks[i] = t.remote
|
|
|
|
}
|
2020-09-13 11:56:35 +02:00
|
|
|
go c.PushConn(
|
2020-12-05 00:07:34 +01:00
|
|
|
c.group,
|
2020-07-16 20:51:51 +02:00
|
|
|
down.remote.Id(), down.remote,
|
2021-01-31 19:00:09 +01:00
|
|
|
tracks, "",
|
2020-07-16 20:51:51 +02:00
|
|
|
)
|
2020-08-11 15:13:30 +02:00
|
|
|
} else if up := getUpConn(c, a.id); up != nil {
|
|
|
|
c.write(clientMessage{
|
|
|
|
Type: "renegotiate",
|
|
|
|
Id: a.id,
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
log.Printf("Attempting to renegotiate " +
|
|
|
|
"unknown connection")
|
2020-06-11 20:22:28 +02:00
|
|
|
}
|
2020-08-11 15:13:30 +02:00
|
|
|
|
2020-04-25 18:35:32 +02:00
|
|
|
case permissionsChangedAction:
|
2020-12-28 02:25:46 +01:00
|
|
|
g := c.Group()
|
|
|
|
if g == nil {
|
2020-12-01 22:42:06 +01:00
|
|
|
return errors.New("Permissions changed in no group")
|
|
|
|
}
|
2020-11-29 15:46:22 +01:00
|
|
|
perms := c.permissions
|
2020-04-25 17:36:35 +02:00
|
|
|
c.write(clientMessage{
|
2020-12-28 02:25:46 +01:00
|
|
|
Type: "joined",
|
|
|
|
Kind: "change",
|
|
|
|
Group: g.Name(),
|
2021-01-03 12:04:39 +01:00
|
|
|
Username: c.username,
|
2020-12-28 02:25:46 +01:00
|
|
|
Permissions: &perms,
|
2021-01-02 00:20:47 +01:00
|
|
|
RTCConfiguration: ice.ICEConfiguration(),
|
2020-04-25 17:36:35 +02:00
|
|
|
})
|
2020-04-25 19:58:54 +02:00
|
|
|
if !c.permissions.Present {
|
2020-06-08 19:10:08 +02:00
|
|
|
up := getUpConns(c)
|
|
|
|
for _, u := range up {
|
2021-02-01 14:08:54 +01:00
|
|
|
err := delUpConn(
|
|
|
|
c, u.id, c.id, true,
|
|
|
|
)
|
2021-01-31 19:00:09 +01:00
|
|
|
if err == nil {
|
2020-10-01 13:47:48 +02:00
|
|
|
failUpConnection(
|
2020-06-08 19:10:08 +02:00
|
|
|
c, u.id,
|
2020-05-24 13:36:42 +02:00
|
|
|
"permission denied",
|
|
|
|
)
|
|
|
|
}
|
2020-04-25 18:35:32 +02:00
|
|
|
}
|
|
|
|
}
|
2020-04-25 17:36:35 +02:00
|
|
|
case kickAction:
|
2020-11-30 16:26:11 +01:00
|
|
|
return group.KickError{
|
|
|
|
a.id, a.username, a.message,
|
|
|
|
}
|
2020-04-24 19:38:21 +02:00
|
|
|
default:
|
|
|
|
log.Printf("unexpected action %T", a)
|
|
|
|
return errors.New("unexpected action")
|
|
|
|
}
|
|
|
|
case <-ticker.C:
|
2021-01-08 14:05:02 +01:00
|
|
|
if time.Since(readTime) > 75*time.Second {
|
2020-04-25 22:44:24 +02:00
|
|
|
return errors.New("client is dead")
|
|
|
|
}
|
2021-01-08 14:05:02 +01:00
|
|
|
// Some reverse proxies timeout connexions at 60
|
|
|
|
// seconds, make sure we generate some activity
|
|
|
|
// after 55s at most.
|
|
|
|
if time.Since(readTime) > 45*time.Second {
|
2020-04-25 22:44:24 +02:00
|
|
|
err := c.write(clientMessage{
|
|
|
|
Type: "ping",
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
2020-04-24 19:38:21 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-10-01 13:47:48 +02:00
|
|
|
func failUpConnection(c *webClient, id string, message string) error {
|
2020-05-24 13:36:42 +02:00
|
|
|
if id != "" {
|
|
|
|
err := c.write(clientMessage{
|
|
|
|
Type: "abort",
|
|
|
|
Id: id,
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if message != "" {
|
2020-09-13 11:56:35 +02:00
|
|
|
err := c.error(group.UserError(message))
|
2020-05-24 13:36:42 +02:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2020-12-05 00:07:34 +01:00
|
|
|
func leaveGroup(c *webClient) {
|
|
|
|
if c.group == nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
c.setRequested(map[string]uint32{})
|
|
|
|
if c.up != nil {
|
|
|
|
for id := range c.up {
|
2021-02-01 14:08:54 +01:00
|
|
|
delUpConn(c, id, c.id, true)
|
2020-12-05 00:07:34 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
group.DelClient(c)
|
|
|
|
c.permissions = group.ClientPermissions{}
|
|
|
|
c.group = nil
|
|
|
|
}
|
|
|
|
|
2021-02-04 23:51:51 +01:00
|
|
|
func closeDownConn(c *webClient, id string, message string) error {
|
2021-02-02 19:38:15 +01:00
|
|
|
err := delDownConn(c, id)
|
|
|
|
if err != nil && !os.IsNotExist(err) {
|
|
|
|
log.Printf("Close down connection: %v", err)
|
|
|
|
}
|
2020-10-01 13:47:48 +02:00
|
|
|
if id != "" {
|
|
|
|
err := c.write(clientMessage{
|
|
|
|
Type: "close",
|
|
|
|
Id: id,
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if message != "" {
|
|
|
|
err := c.error(group.UserError(message))
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2020-09-13 11:56:35 +02:00
|
|
|
func setPermissions(g *group.Group, id string, perm string) error {
|
|
|
|
client := g.GetClient(id)
|
2020-05-28 02:35:09 +02:00
|
|
|
if client == nil {
|
2020-09-13 11:56:35 +02:00
|
|
|
return group.UserError("no such user")
|
2020-05-28 02:35:09 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
c, ok := client.(*webClient)
|
|
|
|
if !ok {
|
2020-09-13 11:56:35 +02:00
|
|
|
return group.UserError("this is not a real user")
|
2020-05-28 02:35:09 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
switch perm {
|
|
|
|
case "op":
|
|
|
|
c.permissions.Op = true
|
2020-09-13 13:24:05 +02:00
|
|
|
if g.AllowRecording() {
|
2020-05-30 00:23:54 +02:00
|
|
|
c.permissions.Record = true
|
|
|
|
}
|
2020-05-28 02:35:09 +02:00
|
|
|
case "unop":
|
|
|
|
c.permissions.Op = false
|
2020-05-30 00:23:54 +02:00
|
|
|
c.permissions.Record = false
|
2020-05-28 02:35:09 +02:00
|
|
|
case "present":
|
|
|
|
c.permissions.Present = true
|
|
|
|
case "unpresent":
|
|
|
|
c.permissions.Present = false
|
|
|
|
default:
|
2020-09-13 11:56:35 +02:00
|
|
|
return group.UserError("unknown permission")
|
2020-05-28 02:35:09 +02:00
|
|
|
}
|
|
|
|
return c.action(permissionsChangedAction{})
|
|
|
|
}
|
|
|
|
|
2020-11-30 16:26:11 +01:00
|
|
|
func (c *webClient) Kick(id, user, message string) error {
|
|
|
|
return c.action(kickAction{id, user, message})
|
2020-09-12 12:42:48 +02:00
|
|
|
}
|
|
|
|
|
2020-11-30 16:26:11 +01:00
|
|
|
func kickClient(g *group.Group, id, user, dest string, message string) error {
|
|
|
|
client := g.GetClient(dest)
|
2020-05-28 02:35:09 +02:00
|
|
|
if client == nil {
|
2020-09-13 11:56:35 +02:00
|
|
|
return group.UserError("no such user")
|
2020-05-28 02:35:09 +02:00
|
|
|
}
|
|
|
|
|
2020-09-13 11:56:35 +02:00
|
|
|
c, ok := client.(group.Kickable)
|
2020-05-28 02:35:09 +02:00
|
|
|
if !ok {
|
2020-09-13 11:56:35 +02:00
|
|
|
return group.UserError("this client is not kickable")
|
2020-05-28 02:35:09 +02:00
|
|
|
}
|
|
|
|
|
2020-11-30 16:26:11 +01:00
|
|
|
return c.Kick(id, user, message)
|
2020-05-28 02:35:09 +02:00
|
|
|
}
|
|
|
|
|
2020-05-27 11:44:49 +02:00
|
|
|
func handleClientMessage(c *webClient, m clientMessage) error {
|
2021-01-03 12:04:39 +01:00
|
|
|
if m.Source != "" {
|
|
|
|
if m.Source != c.Id() {
|
|
|
|
return group.ProtocolError("spoofed client id")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if m.Type != "join" {
|
|
|
|
if m.Username != "" {
|
|
|
|
if m.Username != c.Username() {
|
|
|
|
return group.ProtocolError("spoofed username")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-04-24 19:38:21 +02:00
|
|
|
switch m.Type {
|
2020-12-01 22:42:06 +01:00
|
|
|
case "join":
|
|
|
|
if m.Kind == "leave" {
|
|
|
|
if c.group == nil || c.group.Name() != m.Group {
|
|
|
|
return group.ProtocolError("you are not joined")
|
|
|
|
}
|
2020-12-05 00:07:34 +01:00
|
|
|
leaveGroup(c)
|
2020-12-01 22:42:06 +01:00
|
|
|
perms := c.permissions
|
|
|
|
return c.write(clientMessage{
|
|
|
|
Type: "joined",
|
|
|
|
Kind: "leave",
|
|
|
|
Group: m.Group,
|
2021-01-03 12:04:39 +01:00
|
|
|
Username: c.username,
|
2020-12-01 22:42:06 +01:00
|
|
|
Permissions: &perms,
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
if m.Kind != "join" {
|
|
|
|
return group.ProtocolError("unknown kind")
|
|
|
|
}
|
|
|
|
|
|
|
|
if c.group != nil {
|
|
|
|
return group.ProtocolError("cannot join multiple groups")
|
|
|
|
}
|
|
|
|
c.username = m.Username
|
|
|
|
c.password = m.Password
|
|
|
|
g, err := group.AddClient(m.Group, c)
|
2020-05-09 19:39:34 +02:00
|
|
|
if err != nil {
|
2020-12-04 22:42:20 +01:00
|
|
|
var s string
|
2020-12-01 22:42:06 +01:00
|
|
|
if os.IsNotExist(err) {
|
2020-12-04 22:42:20 +01:00
|
|
|
s = "group does not exist"
|
2020-12-01 22:42:06 +01:00
|
|
|
} else if err == group.ErrNotAuthorised {
|
2020-12-04 22:42:20 +01:00
|
|
|
s = "not authorised"
|
2020-12-01 22:42:06 +01:00
|
|
|
time.Sleep(200 * time.Millisecond)
|
2020-12-04 22:42:20 +01:00
|
|
|
} else if e, ok := err.(group.UserError); ok {
|
|
|
|
s = string(e)
|
|
|
|
} else {
|
|
|
|
s = "internal server error"
|
2020-12-12 23:21:49 +01:00
|
|
|
log.Printf("Join group: %v", err)
|
2020-12-01 22:42:06 +01:00
|
|
|
}
|
2020-12-04 22:42:20 +01:00
|
|
|
return c.write(clientMessage{
|
|
|
|
Type: "joined",
|
|
|
|
Kind: "fail",
|
|
|
|
Group: m.Group,
|
2021-01-03 12:04:39 +01:00
|
|
|
Username: c.username,
|
2020-12-04 22:42:20 +01:00
|
|
|
Permissions: &group.ClientPermissions{},
|
2020-12-28 01:42:26 +01:00
|
|
|
Value: s,
|
2020-12-04 22:42:20 +01:00
|
|
|
})
|
2020-05-09 19:39:34 +02:00
|
|
|
}
|
2020-12-01 22:42:06 +01:00
|
|
|
if redirect := g.Redirect(); redirect != "" {
|
|
|
|
// We normally redirect at the HTTP level, but the group
|
|
|
|
// description could have been edited in the meantime.
|
2020-12-04 22:42:20 +01:00
|
|
|
return c.write(clientMessage{
|
|
|
|
Type: "joined",
|
|
|
|
Kind: "redirect",
|
|
|
|
Group: m.Group,
|
2021-01-03 12:04:39 +01:00
|
|
|
Username: c.username,
|
2020-12-04 22:42:20 +01:00
|
|
|
Permissions: &group.ClientPermissions{},
|
2020-12-28 01:42:26 +01:00
|
|
|
Value: redirect,
|
2020-12-04 22:42:20 +01:00
|
|
|
})
|
2020-12-01 22:42:06 +01:00
|
|
|
}
|
|
|
|
c.group = g
|
|
|
|
perms := c.permissions
|
2020-12-04 11:31:20 +01:00
|
|
|
err = c.write(clientMessage{
|
2020-12-28 02:25:46 +01:00
|
|
|
Type: "joined",
|
|
|
|
Kind: "join",
|
|
|
|
Group: m.Group,
|
2021-01-03 12:04:39 +01:00
|
|
|
Username: c.username,
|
2020-12-28 02:25:46 +01:00
|
|
|
Permissions: &perms,
|
2021-01-02 00:20:47 +01:00
|
|
|
RTCConfiguration: ice.ICEConfiguration(),
|
2020-12-01 22:42:06 +01:00
|
|
|
})
|
2020-12-04 11:31:20 +01:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
h := c.group.GetChatHistory()
|
|
|
|
for _, m := range h {
|
|
|
|
err := c.write(clientMessage{
|
|
|
|
Type: "chat",
|
|
|
|
Id: m.Id,
|
|
|
|
Username: m.User,
|
|
|
|
Time: m.Time,
|
2020-12-28 01:42:26 +01:00
|
|
|
Value: m.Value,
|
2020-12-04 11:31:20 +01:00
|
|
|
Kind: m.Kind,
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
2020-12-01 22:42:06 +01:00
|
|
|
case "request":
|
|
|
|
return c.setRequested(m.Request)
|
2020-04-24 19:38:21 +02:00
|
|
|
case "offer":
|
2020-04-25 02:25:51 +02:00
|
|
|
if !c.permissions.Present {
|
2021-01-31 19:00:09 +01:00
|
|
|
if m.Replace != "" {
|
2021-02-01 14:08:54 +01:00
|
|
|
delUpConn(c, m.Replace, c.id, true)
|
2021-01-31 19:00:09 +01:00
|
|
|
}
|
2020-04-25 18:29:44 +02:00
|
|
|
c.write(clientMessage{
|
|
|
|
Type: "abort",
|
|
|
|
Id: m.Id,
|
|
|
|
})
|
2020-09-13 11:56:35 +02:00
|
|
|
return c.error(group.UserError("not authorised"))
|
2020-04-25 02:25:51 +02:00
|
|
|
}
|
2021-01-31 19:00:09 +01:00
|
|
|
err := gotOffer(c, m.Id, m.SDP, m.Labels, m.Replace)
|
2020-04-24 19:38:21 +02:00
|
|
|
if err != nil {
|
2020-05-24 13:36:42 +02:00
|
|
|
log.Printf("gotOffer: %v", err)
|
2020-10-01 13:47:48 +02:00
|
|
|
return failUpConnection(c, m.Id, "negotiation failed")
|
2020-04-24 19:38:21 +02:00
|
|
|
}
|
|
|
|
case "answer":
|
2021-01-03 17:00:58 +01:00
|
|
|
err := gotAnswer(c, m.Id, m.SDP)
|
2020-04-24 19:38:21 +02:00
|
|
|
if err != nil {
|
2020-10-01 13:47:48 +02:00
|
|
|
log.Printf("gotAnswer: %v", err)
|
|
|
|
message := ""
|
|
|
|
if err != ErrUnknownId {
|
|
|
|
message = "negotiation failed"
|
|
|
|
}
|
2021-02-04 23:51:51 +01:00
|
|
|
return closeDownConn(c, m.Id, message)
|
2020-04-24 19:38:21 +02:00
|
|
|
}
|
2021-01-12 20:44:48 +01:00
|
|
|
down := getDownConn(c, m.Id)
|
|
|
|
if down.negotiationNeeded > negotiationUnneeded {
|
|
|
|
err := negotiate(
|
2021-01-31 19:00:09 +01:00
|
|
|
c, down,
|
2021-01-12 20:44:48 +01:00
|
|
|
down.negotiationNeeded == negotiationRestartIce,
|
2021-01-31 19:00:09 +01:00
|
|
|
"",
|
2021-01-12 20:44:48 +01:00
|
|
|
)
|
|
|
|
if err != nil {
|
2021-02-04 23:51:51 +01:00
|
|
|
return closeDownConn(
|
2021-01-12 20:44:48 +01:00
|
|
|
c, m.Id, "negotiation failed",
|
|
|
|
)
|
|
|
|
}
|
|
|
|
}
|
2020-08-11 15:13:30 +02:00
|
|
|
case "renegotiate":
|
|
|
|
down := getDownConn(c, m.Id)
|
|
|
|
if down != nil {
|
2021-01-31 19:00:09 +01:00
|
|
|
err := negotiate(c, down, true, "")
|
2020-08-11 15:13:30 +02:00
|
|
|
if err != nil {
|
2021-02-04 23:51:51 +01:00
|
|
|
return closeDownConn(
|
2021-01-12 20:44:48 +01:00
|
|
|
c, m.Id, "renegotiation failed",
|
|
|
|
)
|
2020-08-11 15:13:30 +02:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
log.Printf("Trying to renegotiate unknown connection")
|
|
|
|
}
|
2020-04-24 19:38:21 +02:00
|
|
|
case "close":
|
2021-02-01 14:08:54 +01:00
|
|
|
err := delUpConn(c, m.Id, c.id, true)
|
2021-01-31 19:00:09 +01:00
|
|
|
if err != nil {
|
|
|
|
log.Printf("Deleting up connection %v: %v",
|
|
|
|
m.Id, err)
|
|
|
|
return nil
|
|
|
|
}
|
2020-12-25 18:25:55 +01:00
|
|
|
case "abort":
|
2021-02-04 23:51:51 +01:00
|
|
|
return closeDownConn(c, m.Id, "")
|
2020-04-24 19:38:21 +02:00
|
|
|
case "ice":
|
|
|
|
if m.Candidate == nil {
|
2020-09-13 11:56:35 +02:00
|
|
|
return group.ProtocolError("null candidate")
|
2020-04-24 19:38:21 +02:00
|
|
|
}
|
|
|
|
err := gotICE(c, m.Candidate, m.Id)
|
|
|
|
if err != nil {
|
|
|
|
log.Printf("ICE: %v", err)
|
|
|
|
}
|
2020-11-30 14:06:14 +01:00
|
|
|
case "chat", "usermessage":
|
2020-12-01 22:42:06 +01:00
|
|
|
g := c.group
|
|
|
|
if g == nil {
|
|
|
|
return c.error(group.UserError("join a group first"))
|
2020-11-30 15:22:00 +01:00
|
|
|
}
|
|
|
|
|
2020-10-08 14:38:33 +02:00
|
|
|
tm := group.ToJSTime(time.Now())
|
2020-12-02 19:33:53 +01:00
|
|
|
|
2020-11-30 14:06:14 +01:00
|
|
|
if m.Type == "chat" {
|
|
|
|
if m.Dest == "" {
|
2020-12-01 22:42:06 +01:00
|
|
|
g.AddToChatHistory(
|
2021-01-03 12:04:39 +01:00
|
|
|
m.Source, m.Username, tm, m.Kind, m.Value,
|
2020-11-30 14:06:14 +01:00
|
|
|
)
|
|
|
|
}
|
2020-10-01 16:52:01 +02:00
|
|
|
}
|
2020-09-30 00:33:23 +02:00
|
|
|
mm := clientMessage{
|
2020-12-19 17:38:47 +01:00
|
|
|
Type: m.Type,
|
2021-01-03 12:04:39 +01:00
|
|
|
Source: m.Source,
|
2020-12-19 17:38:47 +01:00
|
|
|
Dest: m.Dest,
|
|
|
|
Username: m.Username,
|
|
|
|
Privileged: c.permissions.Op,
|
|
|
|
Time: tm,
|
|
|
|
Kind: m.Kind,
|
2021-01-11 16:22:04 +01:00
|
|
|
NoEcho: m.NoEcho,
|
2020-12-19 17:38:47 +01:00
|
|
|
Value: m.Value,
|
2020-09-30 00:33:23 +02:00
|
|
|
}
|
2020-10-01 16:52:01 +02:00
|
|
|
if m.Dest == "" {
|
2021-01-11 16:22:04 +01:00
|
|
|
var except group.Client
|
|
|
|
if m.NoEcho {
|
|
|
|
except = c
|
|
|
|
}
|
|
|
|
err := broadcast(g.GetClients(except), mm)
|
2021-01-04 17:52:02 +01:00
|
|
|
if err != nil {
|
|
|
|
log.Printf("broadcast(chat): %v", err)
|
2020-10-01 16:52:01 +02:00
|
|
|
}
|
|
|
|
} else {
|
2020-12-01 22:42:06 +01:00
|
|
|
cc := g.GetClient(m.Dest)
|
2020-10-01 16:52:01 +02:00
|
|
|
if cc == nil {
|
|
|
|
return c.error(group.UserError("user unknown"))
|
|
|
|
}
|
|
|
|
ccc, ok := cc.(*webClient)
|
|
|
|
if !ok {
|
2021-01-04 17:52:02 +01:00
|
|
|
return c.error(group.UserError(
|
|
|
|
"this user doesn't chat",
|
|
|
|
))
|
2020-05-28 02:35:09 +02:00
|
|
|
}
|
2020-10-01 16:52:01 +02:00
|
|
|
ccc.write(mm)
|
2020-04-24 19:38:21 +02:00
|
|
|
}
|
2020-08-12 12:40:40 +02:00
|
|
|
case "groupaction":
|
2020-12-01 22:42:06 +01:00
|
|
|
g := c.group
|
|
|
|
if g == nil {
|
|
|
|
return c.error(group.UserError("join a group first"))
|
2020-11-30 15:39:44 +01:00
|
|
|
}
|
2020-08-12 12:40:40 +02:00
|
|
|
switch m.Kind {
|
|
|
|
case "clearchat":
|
2020-12-01 22:42:06 +01:00
|
|
|
g.ClearChatHistory()
|
2021-01-03 17:47:56 +01:00
|
|
|
m := clientMessage{
|
|
|
|
Type: "usermessage",
|
|
|
|
Kind: "clearchat",
|
|
|
|
Privileged: true,
|
|
|
|
}
|
2021-01-04 17:52:02 +01:00
|
|
|
err := broadcast(g.GetClients(nil), m)
|
|
|
|
if err != nil {
|
|
|
|
log.Printf("broadcast(clearchat): %v", err)
|
2020-05-28 02:35:09 +02:00
|
|
|
}
|
2020-08-12 12:40:40 +02:00
|
|
|
case "lock", "unlock":
|
|
|
|
if !c.permissions.Op {
|
2020-09-13 11:56:35 +02:00
|
|
|
return c.error(group.UserError("not authorised"))
|
2020-05-30 00:23:54 +02:00
|
|
|
}
|
2020-12-02 19:33:53 +01:00
|
|
|
message := ""
|
2020-12-28 01:42:26 +01:00
|
|
|
v, ok := m.Value.(string)
|
|
|
|
if ok {
|
|
|
|
message = v
|
2020-12-02 19:33:53 +01:00
|
|
|
}
|
|
|
|
g.SetLocked(m.Kind == "lock", message)
|
2020-08-12 12:40:40 +02:00
|
|
|
case "record":
|
|
|
|
if !c.permissions.Record {
|
2020-09-13 11:56:35 +02:00
|
|
|
return c.error(group.UserError("not authorised"))
|
2020-08-12 12:40:40 +02:00
|
|
|
}
|
2020-12-01 22:42:06 +01:00
|
|
|
for _, cc := range g.GetClients(c) {
|
2020-10-04 19:01:06 +02:00
|
|
|
_, ok := cc.(*diskwriter.Client)
|
2020-08-12 12:40:40 +02:00
|
|
|
if ok {
|
2020-09-13 11:56:35 +02:00
|
|
|
return c.error(group.UserError("already recording"))
|
2020-08-12 12:40:40 +02:00
|
|
|
}
|
|
|
|
}
|
2020-12-01 22:42:06 +01:00
|
|
|
disk := diskwriter.New(g)
|
|
|
|
_, err := group.AddClient(g.Name(), disk)
|
2020-08-12 12:40:40 +02:00
|
|
|
if err != nil {
|
2020-05-30 00:23:54 +02:00
|
|
|
disk.Close()
|
2020-08-12 12:40:40 +02:00
|
|
|
return c.error(err)
|
2020-05-30 00:23:54 +02:00
|
|
|
}
|
2020-12-05 00:07:34 +01:00
|
|
|
go pushConns(disk, c.group)
|
2020-08-12 12:40:40 +02:00
|
|
|
case "unrecord":
|
|
|
|
if !c.permissions.Record {
|
2020-09-13 11:56:35 +02:00
|
|
|
return c.error(group.UserError("not authorised"))
|
2020-08-12 12:40:40 +02:00
|
|
|
}
|
2020-12-01 22:42:06 +01:00
|
|
|
for _, cc := range g.GetClients(c) {
|
2020-10-04 19:01:06 +02:00
|
|
|
disk, ok := cc.(*diskwriter.Client)
|
2020-08-12 12:40:40 +02:00
|
|
|
if ok {
|
|
|
|
disk.Close()
|
2020-09-13 11:56:35 +02:00
|
|
|
group.DelClient(disk)
|
2020-08-12 12:40:40 +02:00
|
|
|
}
|
|
|
|
}
|
2020-12-02 19:47:32 +01:00
|
|
|
case "subgroups":
|
|
|
|
if !c.permissions.Op {
|
|
|
|
return c.error(group.UserError("not authorised"))
|
|
|
|
}
|
|
|
|
s := ""
|
|
|
|
for _, sg := range group.GetSubGroups(g.Name()) {
|
|
|
|
plural := ""
|
|
|
|
if sg.Clients > 1 {
|
|
|
|
plural = "s"
|
|
|
|
}
|
|
|
|
s = s + fmt.Sprintf("%v (%v client%v)",
|
|
|
|
sg.Name, sg.Clients, plural)
|
|
|
|
}
|
|
|
|
c.write(clientMessage{
|
2020-12-04 22:42:20 +01:00
|
|
|
Type: "chat",
|
|
|
|
Dest: c.id,
|
2020-12-02 19:47:32 +01:00
|
|
|
Username: "Server",
|
2020-12-04 22:42:20 +01:00
|
|
|
Time: group.ToJSTime(time.Now()),
|
2020-12-28 01:42:26 +01:00
|
|
|
Value: s,
|
2020-12-02 19:47:32 +01:00
|
|
|
})
|
2020-08-12 12:40:40 +02:00
|
|
|
default:
|
2020-09-13 11:56:35 +02:00
|
|
|
return group.ProtocolError("unknown group action")
|
2020-05-30 00:23:54 +02:00
|
|
|
}
|
2020-08-12 12:40:40 +02:00
|
|
|
case "useraction":
|
2020-12-01 22:42:06 +01:00
|
|
|
g := c.group
|
|
|
|
if g == nil {
|
|
|
|
return c.error(group.UserError("join a group first"))
|
2020-11-30 15:39:44 +01:00
|
|
|
}
|
2020-08-12 12:40:40 +02:00
|
|
|
switch m.Kind {
|
|
|
|
case "op", "unop", "present", "unpresent":
|
|
|
|
if !c.permissions.Op {
|
2020-09-13 11:56:35 +02:00
|
|
|
return c.error(group.UserError("not authorised"))
|
2020-08-12 12:40:40 +02:00
|
|
|
}
|
2020-12-01 22:42:06 +01:00
|
|
|
err := setPermissions(g, m.Dest, m.Kind)
|
2020-08-12 12:40:40 +02:00
|
|
|
if err != nil {
|
|
|
|
return c.error(err)
|
|
|
|
}
|
|
|
|
case "kick":
|
|
|
|
if !c.permissions.Op {
|
2020-09-13 11:56:35 +02:00
|
|
|
return c.error(group.UserError("not authorised"))
|
2020-08-12 12:40:40 +02:00
|
|
|
}
|
2020-12-02 19:33:53 +01:00
|
|
|
message := ""
|
2020-12-28 01:42:26 +01:00
|
|
|
v, ok := m.Value.(string)
|
|
|
|
if ok {
|
|
|
|
message = v
|
2020-12-02 19:33:53 +01:00
|
|
|
}
|
2021-01-03 12:04:39 +01:00
|
|
|
err := kickClient(g, m.Source, m.Username, m.Dest, message)
|
2020-08-12 12:40:40 +02:00
|
|
|
if err != nil {
|
|
|
|
return c.error(err)
|
|
|
|
}
|
|
|
|
default:
|
2020-09-13 11:56:35 +02:00
|
|
|
return group.ProtocolError("unknown user action")
|
2020-04-25 17:36:35 +02:00
|
|
|
}
|
2020-04-25 22:44:24 +02:00
|
|
|
case "pong":
|
|
|
|
// nothing
|
|
|
|
case "ping":
|
2020-12-01 22:42:06 +01:00
|
|
|
return c.write(clientMessage{
|
2020-04-25 22:44:24 +02:00
|
|
|
Type: "pong",
|
|
|
|
})
|
2020-04-24 19:38:21 +02:00
|
|
|
default:
|
|
|
|
log.Printf("unexpected message: %v", m.Type)
|
2020-09-13 11:56:35 +02:00
|
|
|
return group.ProtocolError("unexpected message")
|
2020-04-24 19:38:21 +02:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func clientReader(conn *websocket.Conn, read chan<- interface{}, done <-chan struct{}) {
|
|
|
|
defer close(read)
|
|
|
|
for {
|
|
|
|
var m clientMessage
|
|
|
|
err := conn.ReadJSON(&m)
|
|
|
|
if err != nil {
|
|
|
|
select {
|
|
|
|
case read <- err:
|
|
|
|
return
|
|
|
|
case <-done:
|
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
|
|
|
select {
|
|
|
|
case read <- m:
|
|
|
|
case <-done:
|
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func clientWriter(conn *websocket.Conn, ch <-chan interface{}, done chan<- struct{}) {
|
|
|
|
defer func() {
|
|
|
|
close(done)
|
|
|
|
conn.Close()
|
|
|
|
}()
|
|
|
|
|
|
|
|
for {
|
|
|
|
m, ok := <-ch
|
|
|
|
if !ok {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
err := conn.SetWriteDeadline(
|
|
|
|
time.Now().Add(2 * time.Second))
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
switch m := m.(type) {
|
|
|
|
case clientMessage:
|
|
|
|
err := conn.WriteJSON(m)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
2021-01-04 17:52:02 +01:00
|
|
|
case []byte:
|
|
|
|
err := conn.WriteMessage(websocket.TextMessage, m)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
2020-04-24 19:38:21 +02:00
|
|
|
case closeMessage:
|
2020-09-08 00:29:30 +02:00
|
|
|
if m.data != nil {
|
|
|
|
conn.WriteMessage(
|
|
|
|
websocket.CloseMessage,
|
|
|
|
m.data,
|
|
|
|
)
|
2020-04-24 19:38:21 +02:00
|
|
|
}
|
2020-09-08 00:29:30 +02:00
|
|
|
return
|
2020-04-24 19:38:21 +02:00
|
|
|
default:
|
|
|
|
log.Printf("clientWiter: unexpected message %T", m)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2020-05-28 02:35:09 +02:00
|
|
|
|
2020-12-23 21:32:32 +01:00
|
|
|
func (c *webClient) Warn(oponly bool, message string) error {
|
|
|
|
if oponly && !c.permissions.Op {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
return c.write(clientMessage{
|
2020-12-27 01:24:52 +01:00
|
|
|
Type: "usermessage",
|
|
|
|
Kind: "warning",
|
|
|
|
Dest: c.id,
|
2020-12-23 21:32:32 +01:00
|
|
|
Privileged: true,
|
2020-12-28 01:42:26 +01:00
|
|
|
Value: message,
|
2020-12-23 21:32:32 +01:00
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2020-09-12 19:52:36 +02:00
|
|
|
var ErrClientDead = errors.New("client is dead")
|
2020-05-30 12:38:13 +02:00
|
|
|
|
2020-05-28 02:35:09 +02:00
|
|
|
func (c *webClient) action(m interface{}) error {
|
|
|
|
select {
|
|
|
|
case c.actionCh <- m:
|
|
|
|
return nil
|
|
|
|
case <-c.done:
|
2020-05-30 12:38:13 +02:00
|
|
|
return ErrClientDead
|
2020-05-28 02:35:09 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (c *webClient) write(m clientMessage) error {
|
|
|
|
select {
|
|
|
|
case c.writeCh <- m:
|
|
|
|
return nil
|
|
|
|
case <-c.writerDone:
|
2020-09-12 19:52:36 +02:00
|
|
|
return ErrClientDead
|
2020-05-28 02:35:09 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-01-04 17:52:02 +01:00
|
|
|
func broadcast(cs []group.Client, m clientMessage) error {
|
|
|
|
b, err := json.Marshal(m)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
for _, c := range cs {
|
|
|
|
cc, ok := c.(*webClient)
|
|
|
|
if !ok {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
select {
|
|
|
|
case cc.writeCh <- b:
|
|
|
|
case <-cc.writerDone:
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2020-09-08 00:29:30 +02:00
|
|
|
func (c *webClient) close(data []byte) error {
|
|
|
|
select {
|
|
|
|
case c.writeCh <- closeMessage{data}:
|
|
|
|
return nil
|
|
|
|
case <-c.writerDone:
|
2020-09-12 19:52:36 +02:00
|
|
|
return ErrClientDead
|
2020-09-08 00:29:30 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-30 16:26:11 +01:00
|
|
|
func errorMessage(id string, err error) *clientMessage {
|
2020-05-28 02:35:09 +02:00
|
|
|
switch e := err.(type) {
|
2020-09-13 11:56:35 +02:00
|
|
|
case group.UserError:
|
2020-11-30 16:26:11 +01:00
|
|
|
return &clientMessage{
|
2020-12-19 17:38:47 +01:00
|
|
|
Type: "usermessage",
|
|
|
|
Kind: "error",
|
|
|
|
Dest: id,
|
|
|
|
Privileged: true,
|
2020-12-28 01:42:26 +01:00
|
|
|
Value: e.Error(),
|
2020-11-30 16:26:11 +01:00
|
|
|
}
|
|
|
|
case group.KickError:
|
|
|
|
message := e.Message
|
|
|
|
if message == "" {
|
|
|
|
message = "you have been kicked out"
|
|
|
|
}
|
|
|
|
return &clientMessage{
|
2020-12-19 17:38:47 +01:00
|
|
|
Type: "usermessage",
|
|
|
|
Kind: "error",
|
|
|
|
Id: e.Id,
|
|
|
|
Username: e.Username,
|
|
|
|
Dest: id,
|
|
|
|
Privileged: true,
|
2020-12-28 01:42:26 +01:00
|
|
|
Value: message,
|
2020-11-30 16:26:11 +01:00
|
|
|
}
|
2020-05-28 02:35:09 +02:00
|
|
|
default:
|
2020-11-30 16:26:11 +01:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (c *webClient) error(err error) error {
|
|
|
|
m := errorMessage(c.id, err)
|
|
|
|
if m == nil {
|
2020-05-28 02:35:09 +02:00
|
|
|
return err
|
|
|
|
}
|
2020-11-30 16:26:11 +01:00
|
|
|
return c.write(*m)
|
2020-05-28 02:35:09 +02:00
|
|
|
}
|