You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
645 lines
16 KiB
645 lines
16 KiB
/**
|
|
* Standalone signaling server for the Nextcloud Spreed app.
|
|
* Copyright (C) 2017 struktur AG
|
|
*
|
|
* @author Joachim Bauch <bauch@struktur.de>
|
|
*
|
|
* @license GNU AGPL version 3 or any later version
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Affero General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU Affero General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Affero General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
package signaling
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"net/url"
|
|
"strings"
|
|
)
|
|
|
|
const (
|
|
// Version that must be sent in a "hello" message.
|
|
HelloVersion = "1.0"
|
|
)
|
|
|
|
// ClientMessage is a message that is sent from a client to the server.
|
|
type ClientMessage struct {
|
|
// The unique request id (optional).
|
|
Id string `json:"id,omitempty"`
|
|
|
|
// The type of the request.
|
|
Type string `json:"type"`
|
|
|
|
// Filled for type "hello"
|
|
Hello *HelloClientMessage `json:"hello,omitempty"`
|
|
|
|
Bye *ByeClientMessage `json:"bye,omitempty"`
|
|
|
|
Room *RoomClientMessage `json:"room,omitempty"`
|
|
|
|
Message *MessageClientMessage `json:"message,omitempty"`
|
|
|
|
Control *ControlClientMessage `json:"control,omitempty"`
|
|
|
|
Internal *InternalClientMessage `json:"internal,omitempty"`
|
|
}
|
|
|
|
func (m *ClientMessage) CheckValid() error {
|
|
switch m.Type {
|
|
case "":
|
|
return fmt.Errorf("type missing")
|
|
case "hello":
|
|
if m.Hello == nil {
|
|
return fmt.Errorf("hello missing")
|
|
} else if err := m.Hello.CheckValid(); err != nil {
|
|
return err
|
|
}
|
|
case "bye":
|
|
// No additional check required.
|
|
case "room":
|
|
if m.Room == nil {
|
|
return fmt.Errorf("room missing")
|
|
} else if err := m.Room.CheckValid(); err != nil {
|
|
return err
|
|
}
|
|
case "message":
|
|
if m.Message == nil {
|
|
return fmt.Errorf("message missing")
|
|
} else if err := m.Message.CheckValid(); err != nil {
|
|
return err
|
|
}
|
|
case "control":
|
|
if m.Control == nil {
|
|
return fmt.Errorf("control missing")
|
|
} else if err := m.Control.CheckValid(); err != nil {
|
|
return err
|
|
}
|
|
case "internal":
|
|
if m.Internal == nil {
|
|
return fmt.Errorf("internal missing")
|
|
} else if err := m.Internal.CheckValid(); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *ClientMessage) String() string {
|
|
data, err := json.Marshal(m)
|
|
if err != nil {
|
|
return fmt.Sprintf("Could not serialize %#v: %s", m, err)
|
|
}
|
|
return string(data)
|
|
}
|
|
|
|
func (m *ClientMessage) NewErrorServerMessage(e *Error) *ServerMessage {
|
|
return &ServerMessage{
|
|
Id: m.Id,
|
|
Type: "error",
|
|
Error: e,
|
|
}
|
|
}
|
|
|
|
func (m *ClientMessage) NewWrappedErrorServerMessage(e error) *ServerMessage {
|
|
if e, ok := e.(*Error); ok {
|
|
return m.NewErrorServerMessage(e)
|
|
}
|
|
|
|
return m.NewErrorServerMessage(NewError("internal_error", e.Error()))
|
|
}
|
|
|
|
// ServerMessage is a message that is sent from the server to a client.
|
|
type ServerMessage struct {
|
|
Id string `json:"id,omitempty"`
|
|
|
|
Type string `json:"type"`
|
|
|
|
Error *Error `json:"error,omitempty"`
|
|
|
|
Hello *HelloServerMessage `json:"hello,omitempty"`
|
|
|
|
Bye *ByeServerMessage `json:"bye,omitempty"`
|
|
|
|
Room *RoomServerMessage `json:"room,omitempty"`
|
|
|
|
Message *MessageServerMessage `json:"message,omitempty"`
|
|
|
|
Control *ControlServerMessage `json:"control,omitempty"`
|
|
|
|
Event *EventServerMessage `json:"event,omitempty"`
|
|
}
|
|
|
|
func (r *ServerMessage) CloseAfterSend(session Session) bool {
|
|
if r.Type == "bye" {
|
|
return true
|
|
}
|
|
|
|
if r.Type == "event" {
|
|
if evt := r.Event; evt != nil && evt.Target == "roomlist" && evt.Type == "disinvite" {
|
|
// Only close session / connection if the disinvite was for the room
|
|
// the session is currently in.
|
|
if session != nil && evt.Disinvite != nil {
|
|
if room := session.GetRoom(); room != nil && evt.Disinvite.RoomId == room.Id() {
|
|
return true
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return false
|
|
}
|
|
|
|
func (r *ServerMessage) IsChatRefresh() bool {
|
|
if r.Type != "message" || r.Message == nil || r.Message.Data == nil || len(*r.Message.Data) == 0 {
|
|
return false
|
|
}
|
|
|
|
var data MessageServerMessageData
|
|
if err := json.Unmarshal(*r.Message.Data, &data); err != nil {
|
|
return false
|
|
}
|
|
|
|
if data.Type != "chat" || data.Chat == nil {
|
|
return false
|
|
}
|
|
|
|
return data.Chat.Refresh
|
|
}
|
|
|
|
func (r *ServerMessage) IsParticipantsUpdate() bool {
|
|
if r.Type != "event" || r.Event == nil {
|
|
return false
|
|
}
|
|
if event := r.Event; event.Target != "participants" || event.Type != "update" {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
func (r *ServerMessage) String() string {
|
|
data, err := json.Marshal(r)
|
|
if err != nil {
|
|
return fmt.Sprintf("Could not serialize %#v: %s", r, err)
|
|
}
|
|
return string(data)
|
|
}
|
|
|
|
type Error struct {
|
|
Code string `json:"code"`
|
|
Message string `json:"message"`
|
|
Details interface{} `json:"details,omitempty"`
|
|
}
|
|
|
|
func NewError(code string, message string) *Error {
|
|
return NewErrorDetail(code, message, nil)
|
|
}
|
|
|
|
func NewErrorDetail(code string, message string, details interface{}) *Error {
|
|
return &Error{
|
|
Code: code,
|
|
Message: message,
|
|
Details: details,
|
|
}
|
|
}
|
|
|
|
func (e *Error) Error() string {
|
|
return e.Message
|
|
}
|
|
|
|
const (
|
|
HelloClientTypeClient = "client"
|
|
HelloClientTypeInternal = "internal"
|
|
|
|
HelloClientTypeVirtual = "virtual"
|
|
)
|
|
|
|
func hasStandardPort(u *url.URL) bool {
|
|
switch u.Scheme {
|
|
case "http":
|
|
return u.Port() == "80"
|
|
case "https":
|
|
return u.Port() == "443"
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
type ClientTypeInternalAuthParams struct {
|
|
Random string `json:"random"`
|
|
Token string `json:"token"`
|
|
|
|
Backend string `json:"backend"`
|
|
parsedBackend *url.URL
|
|
}
|
|
|
|
func (p *ClientTypeInternalAuthParams) CheckValid() error {
|
|
if p.Backend == "" {
|
|
return fmt.Errorf("backend missing")
|
|
} else if u, err := url.Parse(p.Backend); err != nil {
|
|
return err
|
|
} else {
|
|
if strings.Contains(u.Host, ":") && hasStandardPort(u) {
|
|
u.Host = u.Hostname()
|
|
}
|
|
|
|
p.parsedBackend = u
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type HelloClientMessageAuth struct {
|
|
// The client type that is connecting. Leave empty to use the default
|
|
// "HelloClientTypeClient"
|
|
Type string `json:"type,omitempty"`
|
|
|
|
Params *json.RawMessage `json:"params"`
|
|
|
|
Url string `json:"url"`
|
|
parsedUrl *url.URL
|
|
|
|
internalParams ClientTypeInternalAuthParams
|
|
}
|
|
|
|
// Type "hello"
|
|
|
|
type HelloClientMessage struct {
|
|
Version string `json:"version"`
|
|
|
|
ResumeId string `json:"resumeid"`
|
|
|
|
Features []string `json:"features,omitempty"`
|
|
|
|
// The authentication credentials.
|
|
Auth HelloClientMessageAuth `json:"auth"`
|
|
}
|
|
|
|
func (m *HelloClientMessage) CheckValid() error {
|
|
if m.Version != HelloVersion {
|
|
return fmt.Errorf("unsupported hello version: %s", m.Version)
|
|
}
|
|
if m.ResumeId == "" {
|
|
if m.Auth.Params == nil || len(*m.Auth.Params) == 0 {
|
|
return fmt.Errorf("params missing")
|
|
}
|
|
if m.Auth.Type == "" {
|
|
m.Auth.Type = HelloClientTypeClient
|
|
}
|
|
switch m.Auth.Type {
|
|
case HelloClientTypeClient:
|
|
if m.Auth.Url == "" {
|
|
return fmt.Errorf("url missing")
|
|
} else if u, err := url.ParseRequestURI(m.Auth.Url); err != nil {
|
|
return err
|
|
} else {
|
|
if strings.Contains(u.Host, ":") && hasStandardPort(u) {
|
|
u.Host = u.Hostname()
|
|
}
|
|
|
|
m.Auth.parsedUrl = u
|
|
}
|
|
case HelloClientTypeInternal:
|
|
if err := json.Unmarshal(*m.Auth.Params, &m.Auth.internalParams); err != nil {
|
|
return err
|
|
} else if err := m.Auth.internalParams.CheckValid(); err != nil {
|
|
return err
|
|
}
|
|
default:
|
|
return fmt.Errorf("unsupported auth type")
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
const (
|
|
// Features for all clients.
|
|
ServerFeatureMcu = "mcu"
|
|
ServerFeatureSimulcast = "simulcast"
|
|
|
|
// Features for internal clients only.
|
|
ServerFeatureInternalVirtualSessions = "virtual-sessions"
|
|
)
|
|
|
|
var (
|
|
DefaultFeatures []string
|
|
DefaultFeaturesInternal []string = []string{
|
|
ServerFeatureInternalVirtualSessions,
|
|
}
|
|
)
|
|
|
|
type HelloServerMessageServer struct {
|
|
Version string `json:"version"`
|
|
Features []string `json:"features,omitempty"`
|
|
Country string `json:"country,omitempty"`
|
|
}
|
|
|
|
type HelloServerMessage struct {
|
|
Version string `json:"version"`
|
|
|
|
SessionId string `json:"sessionid"`
|
|
ResumeId string `json:"resumeid"`
|
|
UserId string `json:"userid"`
|
|
Server *HelloServerMessageServer `json:"server,omitempty"`
|
|
}
|
|
|
|
// Type "bye"
|
|
|
|
type ByeClientMessage struct {
|
|
}
|
|
|
|
func (m *ByeClientMessage) CheckValid() error {
|
|
// No additional validation required.
|
|
return nil
|
|
}
|
|
|
|
type ByeServerMessage struct {
|
|
Reason string `json:"reason"`
|
|
}
|
|
|
|
// Type "room"
|
|
|
|
type RoomClientMessage struct {
|
|
RoomId string `json:"roomid"`
|
|
SessionId string `json:"sessionid,omitempty"`
|
|
}
|
|
|
|
func (m *RoomClientMessage) CheckValid() error {
|
|
// No additional validation required.
|
|
return nil
|
|
}
|
|
|
|
type RoomServerMessage struct {
|
|
RoomId string `json:"roomid"`
|
|
Properties *json.RawMessage `json:"properties,omitempty"`
|
|
}
|
|
|
|
// Type "message"
|
|
|
|
const (
|
|
RecipientTypeSession = "session"
|
|
RecipientTypeUser = "user"
|
|
RecipientTypeRoom = "room"
|
|
)
|
|
|
|
type MessageClientMessageRecipient struct {
|
|
Type string `json:"type"`
|
|
|
|
SessionId string `json:"sessionid,omitempty"`
|
|
UserId string `json:"userid,omitempty"`
|
|
}
|
|
|
|
type MessageClientMessage struct {
|
|
Recipient MessageClientMessageRecipient `json:"recipient"`
|
|
|
|
Data *json.RawMessage `json:"data"`
|
|
}
|
|
|
|
type MessageClientMessageData struct {
|
|
Type string `json:"type"`
|
|
Sid string `json:"sid"`
|
|
RoomType string `json:"roomType"`
|
|
Payload map[string]interface{} `json:"payload"`
|
|
}
|
|
|
|
func (m *MessageClientMessage) CheckValid() error {
|
|
if m.Data == nil || len(*m.Data) == 0 {
|
|
return fmt.Errorf("message empty")
|
|
}
|
|
switch m.Recipient.Type {
|
|
case RecipientTypeRoom:
|
|
// No additional checks required.
|
|
case RecipientTypeSession:
|
|
if m.Recipient.SessionId == "" {
|
|
return fmt.Errorf("session id missing")
|
|
}
|
|
case RecipientTypeUser:
|
|
if m.Recipient.UserId == "" {
|
|
return fmt.Errorf("user id missing")
|
|
}
|
|
default:
|
|
return fmt.Errorf("unsupported recipient type %v", m.Recipient.Type)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type MessageServerMessageSender struct {
|
|
Type string `json:"type"`
|
|
|
|
SessionId string `json:"sessionid,omitempty"`
|
|
UserId string `json:"userid,omitempty"`
|
|
}
|
|
|
|
type MessageServerMessageDataChat struct {
|
|
Refresh bool `json:"refresh"`
|
|
}
|
|
|
|
type MessageServerMessageData struct {
|
|
Type string `json:"type"`
|
|
|
|
Chat *MessageServerMessageDataChat `json:"chat,omitempty"`
|
|
}
|
|
|
|
type MessageServerMessage struct {
|
|
Sender *MessageServerMessageSender `json:"sender"`
|
|
Recipient *MessageClientMessageRecipient `json:"recipient,omitempty"`
|
|
|
|
Data *json.RawMessage `json:"data"`
|
|
}
|
|
|
|
// Type "control"
|
|
|
|
type ControlClientMessage struct {
|
|
MessageClientMessage
|
|
}
|
|
|
|
func (m *ControlClientMessage) CheckValid() error {
|
|
if err := m.MessageClientMessage.CheckValid(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type ControlServerMessage struct {
|
|
Sender *MessageServerMessageSender `json:"sender"`
|
|
Recipient *MessageClientMessageRecipient `json:"recipient,omitempty"`
|
|
|
|
Data *json.RawMessage `json:"data"`
|
|
}
|
|
|
|
// Type "internal"
|
|
|
|
type CommonSessionInternalClientMessage struct {
|
|
SessionId string `json:"sessionid"`
|
|
|
|
RoomId string `json:"roomid"`
|
|
}
|
|
|
|
func (m *CommonSessionInternalClientMessage) CheckValid() error {
|
|
if m.SessionId == "" {
|
|
return fmt.Errorf("sessionid missing")
|
|
}
|
|
if m.RoomId == "" {
|
|
return fmt.Errorf("roomid missing")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type AddSessionOptions struct {
|
|
ActorId string `json:"actorId,omitempty"`
|
|
ActorType string `json:"actorType,omitempty"`
|
|
}
|
|
|
|
type AddSessionInternalClientMessage struct {
|
|
CommonSessionInternalClientMessage
|
|
|
|
UserId string `json:"userid,omitempty"`
|
|
User *json.RawMessage `json:"user,omitempty"`
|
|
Flags uint32 `json:"flags,omitempty"`
|
|
|
|
Options *AddSessionOptions `json:"options,omitempty"`
|
|
}
|
|
|
|
func (m *AddSessionInternalClientMessage) CheckValid() error {
|
|
if err := m.CommonSessionInternalClientMessage.CheckValid(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type UpdateSessionInternalClientMessage struct {
|
|
CommonSessionInternalClientMessage
|
|
|
|
Flags *uint32 `json:"flags,omitempty"`
|
|
}
|
|
|
|
func (m *UpdateSessionInternalClientMessage) CheckValid() error {
|
|
if err := m.CommonSessionInternalClientMessage.CheckValid(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type RemoveSessionInternalClientMessage struct {
|
|
CommonSessionInternalClientMessage
|
|
|
|
UserId string `json:"userid,omitempty"`
|
|
}
|
|
|
|
func (m *RemoveSessionInternalClientMessage) CheckValid() error {
|
|
if err := m.CommonSessionInternalClientMessage.CheckValid(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type InternalClientMessage struct {
|
|
Type string `json:"type"`
|
|
|
|
AddSession *AddSessionInternalClientMessage `json:"addsession,omitempty"`
|
|
|
|
UpdateSession *UpdateSessionInternalClientMessage `json:"updatesession,omitempty"`
|
|
|
|
RemoveSession *RemoveSessionInternalClientMessage `json:"removesession,omitempty"`
|
|
}
|
|
|
|
func (m *InternalClientMessage) CheckValid() error {
|
|
switch m.Type {
|
|
case "addsession":
|
|
if m.AddSession == nil {
|
|
return fmt.Errorf("addsession missing")
|
|
} else if err := m.AddSession.CheckValid(); err != nil {
|
|
return err
|
|
}
|
|
case "updatesession":
|
|
if m.UpdateSession == nil {
|
|
return fmt.Errorf("updatesession missing")
|
|
} else if err := m.UpdateSession.CheckValid(); err != nil {
|
|
return err
|
|
}
|
|
case "removesession":
|
|
if m.RemoveSession == nil {
|
|
return fmt.Errorf("removesession missing")
|
|
} else if err := m.RemoveSession.CheckValid(); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Type "event"
|
|
|
|
type RoomEventServerMessage struct {
|
|
RoomId string `json:"roomid"`
|
|
Properties *json.RawMessage `json:"properties,omitempty"`
|
|
// TODO(jojo): Change "InCall" to "int" when #914 has landed in NC Talk.
|
|
InCall *json.RawMessage `json:"incall,omitempty"`
|
|
Changed []map[string]interface{} `json:"changed,omitempty"`
|
|
Users []map[string]interface{} `json:"users,omitempty"`
|
|
}
|
|
|
|
const (
|
|
DisinviteReasonDisinvited = "disinvited"
|
|
DisinviteReasonDeleted = "deleted"
|
|
)
|
|
|
|
type RoomDisinviteEventServerMessage struct {
|
|
RoomEventServerMessage
|
|
|
|
Reason string `json:"reason"`
|
|
}
|
|
|
|
type RoomEventMessage struct {
|
|
RoomId string `json:"roomid"`
|
|
Data *json.RawMessage `json:"data,omitempty"`
|
|
}
|
|
|
|
type RoomFlagsServerMessage struct {
|
|
RoomId string `json:"roomid"`
|
|
SessionId string `json:"sessionid"`
|
|
Flags uint32 `json:"flags"`
|
|
}
|
|
|
|
type EventServerMessage struct {
|
|
Target string `json:"target"`
|
|
Type string `json:"type"`
|
|
|
|
// Used for target "room"
|
|
Join []*EventServerMessageSessionEntry `json:"join,omitempty"`
|
|
Leave []string `json:"leave,omitempty"`
|
|
Change []*EventServerMessageSessionEntry `json:"change,omitempty"`
|
|
|
|
// Used for target "roomlist" / "participants"
|
|
Invite *RoomEventServerMessage `json:"invite,omitempty"`
|
|
Disinvite *RoomDisinviteEventServerMessage `json:"disinvite,omitempty"`
|
|
Update *RoomEventServerMessage `json:"update,omitempty"`
|
|
Flags *RoomFlagsServerMessage `json:"flags,omitempty"`
|
|
|
|
// Used for target "message"
|
|
Message *RoomEventMessage `json:"message,omitempty"`
|
|
}
|
|
|
|
type EventServerMessageSessionEntry struct {
|
|
SessionId string `json:"sessionid"`
|
|
UserId string `json:"userid"`
|
|
User *json.RawMessage `json:"user,omitempty"`
|
|
}
|
|
|
|
// MCU-related types
|
|
|
|
type AnswerOfferMessage struct {
|
|
To string `json:"to"`
|
|
From string `json:"from"`
|
|
Type string `json:"type"`
|
|
RoomType string `json:"roomType"`
|
|
Payload map[string]interface{} `json:"payload"`
|
|
}
|
|
|