move server to server directory.

server/internal/websocket/handler/clipboard.go

@@ -0,0 +1,23 @@
+package handler
+
+import (
+	"errors"
+
+	"github.com/demodesk/neko/pkg/types"
+	"github.com/demodesk/neko/pkg/types/message"
+)
+
+func (h *MessageHandlerCtx) clipboardSet(session types.Session, payload *message.ClipboardData) error {
+	if !session.Profile().CanAccessClipboard {
+		return errors.New("cannot access clipboard")
+	}
+
+	if !session.IsHost() {
+		return errors.New("is not the host")
+	}
+
+	return h.desktop.ClipboardSetText(types.ClipboardText{
+		Text: payload.Text,
+		// TODO: Send HTML?
+	})
+}

server/internal/websocket/handler/control.go

@@ -0,0 +1,228 @@
+package handler
+
+import (
+	"errors"
+
+	"github.com/demodesk/neko/pkg/types"
+	"github.com/demodesk/neko/pkg/types/event"
+	"github.com/demodesk/neko/pkg/types/message"
+	"github.com/demodesk/neko/pkg/xorg"
+)
+
+var (
+	ErrIsNotAllowedToHost = errors.New("is not allowed to host")
+	ErrIsNotTheHost       = errors.New("is not the host")
+	ErrIsAlreadyTheHost   = errors.New("is already the host")
+	ErrIsAlreadyHosted    = errors.New("is already hosted")
+)
+
+func (h *MessageHandlerCtx) controlRelease(session types.Session) error {
+	if !session.Profile().CanHost || session.PrivateModeEnabled() {
+		return ErrIsNotAllowedToHost
+	}
+
+	if !session.IsHost() {
+		return ErrIsNotTheHost
+	}
+
+	h.desktop.ResetKeys()
+	session.ClearHost()
+
+	return nil
+}
+
+func (h *MessageHandlerCtx) controlRequest(session types.Session) error {
+	if !session.Profile().CanHost || session.PrivateModeEnabled() {
+		return ErrIsNotAllowedToHost
+	}
+
+	if session.IsHost() {
+		return ErrIsAlreadyTheHost
+	}
+
+	if h.sessions.Settings().LockedControls && !session.Profile().IsAdmin {
+		return ErrIsNotAllowedToHost
+	}
+
+	// if implicit hosting is enabled, set session as host without asking
+	if h.sessions.Settings().ImplicitHosting {
+		session.SetAsHost()
+		return nil
+	}
+
+	// if there is no host, set session as host
+	host, hasHost := h.sessions.GetHost()
+	if !hasHost {
+		session.SetAsHost()
+		return nil
+	}
+
+	// TODO: Some throttling mechanism to prevent spamming.
+
+	// let host know that someone wants to take control
+	host.Send(
+		event.CONTROL_REQUEST,
+		message.SessionID{
+			ID: session.ID(),
+		})
+
+	return ErrIsAlreadyHosted
+}
+
+func (h *MessageHandlerCtx) controlMove(session types.Session, payload *message.ControlPos) error {
+	if err := h.controlRequest(session); err != nil && !errors.Is(err, ErrIsAlreadyTheHost) {
+		return err
+	}
+
+	// handle active cursor movement
+	h.desktop.Move(payload.X, payload.Y)
+	h.webrtc.SetCursorPosition(payload.X, payload.Y)
+	return nil
+}
+
+func (h *MessageHandlerCtx) controlScroll(session types.Session, payload *message.ControlScroll) error {
+	if err := h.controlRequest(session); err != nil && !errors.Is(err, ErrIsAlreadyTheHost) {
+		return err
+	}
+
+	// TOOD: remove this once the client is fixed
+	if payload.DeltaX == 0 && payload.DeltaY == 0 {
+		payload.DeltaX = payload.X
+		payload.DeltaY = payload.Y
+	}
+
+	h.desktop.Scroll(payload.DeltaX, payload.DeltaY, payload.ControlKey)
+	return nil
+}
+
+func (h *MessageHandlerCtx) controlButtonPress(session types.Session, payload *message.ControlButton) error {
+	if payload.ControlPos != nil {
+		if err := h.controlMove(session, payload.ControlPos); err != nil {
+			return err
+		}
+	} else if err := h.controlRequest(session); err != nil && !errors.Is(err, ErrIsAlreadyTheHost) {
+		return err
+	}
+
+	return h.desktop.ButtonPress(payload.Code)
+}
+
+func (h *MessageHandlerCtx) controlButtonDown(session types.Session, payload *message.ControlButton) error {
+	if payload.ControlPos != nil {
+		if err := h.controlMove(session, payload.ControlPos); err != nil {
+			return err
+		}
+	} else if err := h.controlRequest(session); err != nil && !errors.Is(err, ErrIsAlreadyTheHost) {
+		return err
+	}
+
+	return h.desktop.ButtonDown(payload.Code)
+}
+
+func (h *MessageHandlerCtx) controlButtonUp(session types.Session, payload *message.ControlButton) error {
+	if payload.ControlPos != nil {
+		if err := h.controlMove(session, payload.ControlPos); err != nil {
+			return err
+		}
+	} else if err := h.controlRequest(session); err != nil && !errors.Is(err, ErrIsAlreadyTheHost) {
+		return err
+	}
+
+	return h.desktop.ButtonUp(payload.Code)
+}
+
+func (h *MessageHandlerCtx) controlKeyPress(session types.Session, payload *message.ControlKey) error {
+	if payload.ControlPos != nil {
+		if err := h.controlMove(session, payload.ControlPos); err != nil {
+			return err
+		}
+	} else if err := h.controlRequest(session); err != nil && !errors.Is(err, ErrIsAlreadyTheHost) {
+		return err
+	}
+
+	return h.desktop.KeyPress(payload.Keysym)
+}
+
+func (h *MessageHandlerCtx) controlKeyDown(session types.Session, payload *message.ControlKey) error {
+	if payload.ControlPos != nil {
+		if err := h.controlMove(session, payload.ControlPos); err != nil {
+			return err
+		}
+	} else if err := h.controlRequest(session); err != nil && !errors.Is(err, ErrIsAlreadyTheHost) {
+		return err
+	}
+
+	return h.desktop.KeyDown(payload.Keysym)
+}
+
+func (h *MessageHandlerCtx) controlKeyUp(session types.Session, payload *message.ControlKey) error {
+	if payload.ControlPos != nil {
+		if err := h.controlMove(session, payload.ControlPos); err != nil {
+			return err
+		}
+	} else if err := h.controlRequest(session); err != nil && !errors.Is(err, ErrIsAlreadyTheHost) {
+		return err
+	}
+
+	return h.desktop.KeyUp(payload.Keysym)
+}
+
+func (h *MessageHandlerCtx) controlTouchBegin(session types.Session, payload *message.ControlTouch) error {
+	if err := h.controlRequest(session); err != nil && !errors.Is(err, ErrIsAlreadyTheHost) {
+		return err
+	}
+	return h.desktop.TouchBegin(payload.TouchId, payload.X, payload.Y, payload.Pressure)
+}
+
+func (h *MessageHandlerCtx) controlTouchUpdate(session types.Session, payload *message.ControlTouch) error {
+	if err := h.controlRequest(session); err != nil && !errors.Is(err, ErrIsAlreadyTheHost) {
+		return err
+	}
+	return h.desktop.TouchUpdate(payload.TouchId, payload.X, payload.Y, payload.Pressure)
+}
+
+func (h *MessageHandlerCtx) controlTouchEnd(session types.Session, payload *message.ControlTouch) error {
+	if err := h.controlRequest(session); err != nil && !errors.Is(err, ErrIsAlreadyTheHost) {
+		return err
+	}
+	return h.desktop.TouchEnd(payload.TouchId, payload.X, payload.Y, payload.Pressure)
+}
+
+func (h *MessageHandlerCtx) controlCut(session types.Session) error {
+	if err := h.controlRequest(session); err != nil && !errors.Is(err, ErrIsAlreadyTheHost) {
+		return err
+	}
+
+	return h.desktop.KeyPress(xorg.XK_Control_L, xorg.XK_x)
+}
+
+func (h *MessageHandlerCtx) controlCopy(session types.Session) error {
+	if err := h.controlRequest(session); err != nil && !errors.Is(err, ErrIsAlreadyTheHost) {
+		return err
+	}
+
+	return h.desktop.KeyPress(xorg.XK_Control_L, xorg.XK_c)
+}
+
+func (h *MessageHandlerCtx) controlPaste(session types.Session, payload *message.ClipboardData) error {
+	if err := h.controlRequest(session); err != nil && !errors.Is(err, ErrIsAlreadyTheHost) {
+		return err
+	}
+
+	// if there have been set clipboard data, set them first
+	if payload != nil && payload.Text != "" {
+		if err := h.clipboardSet(session, payload); err != nil {
+			return err
+		}
+	}
+
+	return h.desktop.KeyPress(xorg.XK_Control_L, xorg.XK_v)
+}
+
+func (h *MessageHandlerCtx) controlSelectAll(session types.Session) error {
+	if err := h.controlRequest(session); err != nil && !errors.Is(err, ErrIsAlreadyTheHost) {
+		return err
+	}
+
+	return h.desktop.KeyPress(xorg.XK_Control_L, xorg.XK_a)
+}

server/internal/websocket/handler/handler.go

@@ -0,0 +1,203 @@
+package handler
+
+import (
+	"github.com/rs/zerolog"
+	"github.com/rs/zerolog/log"
+
+	"github.com/demodesk/neko/pkg/types"
+	"github.com/demodesk/neko/pkg/types/event"
+	"github.com/demodesk/neko/pkg/types/message"
+	"github.com/demodesk/neko/pkg/utils"
+)
+
+func New(
+	sessions types.SessionManager,
+	desktop types.DesktopManager,
+	capture types.CaptureManager,
+	webrtc types.WebRTCManager,
+) *MessageHandlerCtx {
+	return &MessageHandlerCtx{
+		logger:   log.With().Str("module", "websocket").Str("submodule", "handler").Logger(),
+		sessions: sessions,
+		desktop:  desktop,
+		capture:  capture,
+		webrtc:   webrtc,
+	}
+}
+
+type MessageHandlerCtx struct {
+	logger   zerolog.Logger
+	sessions types.SessionManager
+	webrtc   types.WebRTCManager
+	desktop  types.DesktopManager
+	capture  types.CaptureManager
+}
+
+func (h *MessageHandlerCtx) Message(session types.Session, data types.WebSocketMessage) bool {
+	var err error
+	switch data.Event {
+	// System Events
+	case event.SYSTEM_LOGS:
+		payload := &message.SystemLogs{}
+		err = utils.Unmarshal(payload, data.Payload, func() error {
+			return h.systemLogs(session, payload)
+		})
+
+	// Signal Events
+	case event.SIGNAL_REQUEST:
+		payload := &message.SignalRequest{}
+		err = utils.Unmarshal(payload, data.Payload, func() error {
+			return h.signalRequest(session, payload)
+		})
+	case event.SIGNAL_RESTART:
+		err = h.signalRestart(session)
+	case event.SIGNAL_OFFER:
+		payload := &message.SignalDescription{}
+		err = utils.Unmarshal(payload, data.Payload, func() error {
+			return h.signalOffer(session, payload)
+		})
+	case event.SIGNAL_ANSWER:
+		payload := &message.SignalDescription{}
+		err = utils.Unmarshal(payload, data.Payload, func() error {
+			return h.signalAnswer(session, payload)
+		})
+	case event.SIGNAL_CANDIDATE:
+		payload := &message.SignalCandidate{}
+		err = utils.Unmarshal(payload, data.Payload, func() error {
+			return h.signalCandidate(session, payload)
+		})
+	case event.SIGNAL_VIDEO:
+		payload := &message.SignalVideo{}
+		err = utils.Unmarshal(payload, data.Payload, func() error {
+			return h.signalVideo(session, payload)
+		})
+	case event.SIGNAL_AUDIO:
+		payload := &message.SignalAudio{}
+		err = utils.Unmarshal(payload, data.Payload, func() error {
+			return h.signalAudio(session, payload)
+		})
+
+	// Control Events
+	case event.CONTROL_RELEASE:
+		err = h.controlRelease(session)
+	case event.CONTROL_REQUEST:
+		err = h.controlRequest(session)
+	case event.CONTROL_MOVE:
+		payload := &message.ControlPos{}
+		err = utils.Unmarshal(payload, data.Payload, func() error {
+			return h.controlMove(session, payload)
+		})
+	case event.CONTROL_SCROLL:
+		payload := &message.ControlScroll{}
+		err = utils.Unmarshal(payload, data.Payload, func() error {
+			return h.controlScroll(session, payload)
+		})
+	case event.CONTROL_BUTTONPRESS:
+		payload := &message.ControlButton{}
+		err = utils.Unmarshal(payload, data.Payload, func() error {
+			return h.controlButtonPress(session, payload)
+		})
+	case event.CONTROL_BUTTONDOWN:
+		payload := &message.ControlButton{}
+		err = utils.Unmarshal(payload, data.Payload, func() error {
+			return h.controlButtonDown(session, payload)
+		})
+	case event.CONTROL_BUTTONUP:
+		payload := &message.ControlButton{}
+		err = utils.Unmarshal(payload, data.Payload, func() error {
+			return h.controlButtonUp(session, payload)
+		})
+	case event.CONTROL_KEYPRESS:
+		payload := &message.ControlKey{}
+		err = utils.Unmarshal(payload, data.Payload, func() error {
+			return h.controlKeyPress(session, payload)
+		})
+	case event.CONTROL_KEYDOWN:
+		payload := &message.ControlKey{}
+		err = utils.Unmarshal(payload, data.Payload, func() error {
+			return h.controlKeyDown(session, payload)
+		})
+	case event.CONTROL_KEYUP:
+		payload := &message.ControlKey{}
+		err = utils.Unmarshal(payload, data.Payload, func() error {
+			return h.controlKeyUp(session, payload)
+		})
+	// touch
+	case event.CONTROL_TOUCHBEGIN:
+		payload := &message.ControlTouch{}
+		err = utils.Unmarshal(payload, data.Payload, func() error {
+			return h.controlTouchBegin(session, payload)
+		})
+	case event.CONTROL_TOUCHUPDATE:
+		payload := &message.ControlTouch{}
+		err = utils.Unmarshal(payload, data.Payload, func() error {
+			return h.controlTouchUpdate(session, payload)
+		})
+	case event.CONTROL_TOUCHEND:
+		payload := &message.ControlTouch{}
+		err = utils.Unmarshal(payload, data.Payload, func() error {
+			return h.controlTouchEnd(session, payload)
+		})
+	// actions
+	case event.CONTROL_CUT:
+		err = h.controlCut(session)
+	case event.CONTROL_COPY:
+		err = h.controlCopy(session)
+	case event.CONTROL_PASTE:
+		payload := &message.ClipboardData{}
+		err = utils.Unmarshal(payload, data.Payload, func() error {
+			return h.controlPaste(session, payload)
+		})
+	case event.CONTROL_SELECT_ALL:
+		err = h.controlSelectAll(session)
+
+	// Screen Events
+	case event.SCREEN_SET:
+		payload := &message.ScreenSize{}
+		err = utils.Unmarshal(payload, data.Payload, func() error {
+			return h.screenSet(session, payload)
+		})
+
+	// Clipboard Events
+	case event.CLIPBOARD_SET:
+		payload := &message.ClipboardData{}
+		err = utils.Unmarshal(payload, data.Payload, func() error {
+			return h.clipboardSet(session, payload)
+		})
+
+	// Keyboard Events
+	case event.KEYBOARD_MAP:
+		payload := &message.KeyboardMap{}
+		err = utils.Unmarshal(payload, data.Payload, func() error {
+			return h.keyboardMap(session, payload)
+		})
+	case event.KEYBOARD_MODIFIERS:
+		payload := &message.KeyboardModifiers{}
+		err = utils.Unmarshal(payload, data.Payload, func() error {
+			return h.keyboardModifiers(session, payload)
+		})
+
+	// Send Events
+	case event.SEND_UNICAST:
+		payload := &message.SendUnicast{}
+		err = utils.Unmarshal(payload, data.Payload, func() error {
+			return h.sendUnicast(session, payload)
+		})
+	case event.SEND_BROADCAST:
+		payload := &message.SendBroadcast{}
+		err = utils.Unmarshal(payload, data.Payload, func() error {
+			return h.sendBroadcast(session, payload)
+		})
+	default:
+		return false
+	}
+
+	if err != nil {
+		h.logger.Warn().Err(err).
+			Str("event", data.Event).
+			Str("session_id", session.ID()).
+			Msg("message handler has failed")
+	}
+
+	return true
+}

server/internal/websocket/handler/keyboard.go

@@ -0,0 +1,25 @@
+package handler
+
+import (
+	"errors"
+
+	"github.com/demodesk/neko/pkg/types"
+	"github.com/demodesk/neko/pkg/types/message"
+)
+
+func (h *MessageHandlerCtx) keyboardMap(session types.Session, payload *message.KeyboardMap) error {
+	if !session.IsHost() {
+		return errors.New("is not the host")
+	}
+
+	return h.desktop.SetKeyboardMap(payload.KeyboardMap)
+}
+
+func (h *MessageHandlerCtx) keyboardModifiers(session types.Session, payload *message.KeyboardModifiers) error {
+	if !session.IsHost() {
+		return errors.New("is not the host")
+	}
+
+	h.desktop.SetKeyboardModifiers(payload.KeyboardModifiers)
+	return nil
+}

server/internal/websocket/handler/screen.go

@@ -0,0 +1,26 @@
+package handler
+
+import (
+	"errors"
+
+	"github.com/demodesk/neko/pkg/types"
+	"github.com/demodesk/neko/pkg/types/event"
+	"github.com/demodesk/neko/pkg/types/message"
+)
+
+func (h *MessageHandlerCtx) screenSet(session types.Session, payload *message.ScreenSize) error {
+	if !session.Profile().IsAdmin {
+		return errors.New("is not the admin")
+	}
+
+	size, err := h.desktop.SetScreenSize(payload.ScreenSize)
+	if err != nil {
+		return err
+	}
+
+	h.sessions.Broadcast(event.SCREEN_UPDATED, message.ScreenSizeUpdate{
+		ID:         session.ID(),
+		ScreenSize: size,
+	})
+	return nil
+}

server/internal/websocket/handler/send.go

@@ -0,0 +1,39 @@
+package handler
+
+import (
+	"errors"
+
+	"github.com/demodesk/neko/pkg/types"
+	"github.com/demodesk/neko/pkg/types/event"
+	"github.com/demodesk/neko/pkg/types/message"
+)
+
+func (h *MessageHandlerCtx) sendUnicast(session types.Session, payload *message.SendUnicast) error {
+	receiver, ok := h.sessions.Get(payload.Receiver)
+	if !ok {
+		return errors.New("receiver session ID not found")
+	}
+
+	receiver.Send(
+		event.SEND_UNICAST,
+		message.SendUnicast{
+			Sender:   session.ID(),
+			Receiver: receiver.ID(),
+			Subject:  payload.Subject,
+			Body:     payload.Body,
+		})
+
+	return nil
+}
+
+func (h *MessageHandlerCtx) sendBroadcast(session types.Session, payload *message.SendBroadcast) error {
+	h.sessions.Broadcast(
+		event.SEND_BROADCAST,
+		message.SendBroadcast{
+			Sender:  session.ID(),
+			Subject: payload.Subject,
+			Body:    payload.Body,
+		}, session.ID())
+
+	return nil
+}

server/internal/websocket/handler/session.go

@@ -0,0 +1,106 @@
+package handler
+
+import (
+	"github.com/demodesk/neko/pkg/types"
+	"github.com/demodesk/neko/pkg/types/event"
+	"github.com/demodesk/neko/pkg/types/message"
+)
+
+func (h *MessageHandlerCtx) SessionCreated(session types.Session) error {
+	h.sessions.Broadcast(
+		event.SESSION_CREATED,
+		message.SessionData{
+			ID:      session.ID(),
+			Profile: session.Profile(),
+			State:   session.State(),
+		})
+
+	return nil
+}
+
+func (h *MessageHandlerCtx) SessionDeleted(session types.Session) error {
+	h.sessions.Broadcast(
+		event.SESSION_DELETED,
+		message.SessionID{
+			ID: session.ID(),
+		})
+
+	return nil
+}
+
+func (h *MessageHandlerCtx) SessionConnected(session types.Session) error {
+	if err := h.systemInit(session); err != nil {
+		return err
+	}
+
+	if session.Profile().IsAdmin {
+		if err := h.systemAdmin(session); err != nil {
+			return err
+		}
+
+		// update settings in atomic way
+		h.sessions.UpdateSettingsFunc(session, func(settings *types.Settings) bool {
+			// if control protection & locked controls: unlock controls
+			if settings.LockedControls && settings.ControlProtection {
+				settings.LockedControls = false
+				return true // update settings
+			}
+			return false // do not update settings
+		})
+	}
+
+	return h.SessionStateChanged(session)
+}
+
+func (h *MessageHandlerCtx) SessionDisconnected(session types.Session) error {
+	// clear host if exists
+	if session.IsHost() {
+		h.desktop.ResetKeys()
+		session.ClearHost()
+	}
+
+	if session.Profile().IsAdmin {
+		hasAdmin := false
+		h.sessions.Range(func(s types.Session) bool {
+			if s.Profile().IsAdmin && s.ID() != session.ID() && s.State().IsConnected {
+				hasAdmin = true
+				return false
+			}
+			return true
+		})
+
+		// update settings in atomic way
+		h.sessions.UpdateSettingsFunc(session, func(settings *types.Settings) bool {
+			// if control protection & not locked controls & no admin: lock controls
+			if !settings.LockedControls && settings.ControlProtection && !hasAdmin {
+				settings.LockedControls = true
+				return true // update settings
+			}
+			return false // do not update settings
+		})
+	}
+
+	return h.SessionStateChanged(session)
+}
+
+func (h *MessageHandlerCtx) SessionProfileChanged(session types.Session, new, old types.MemberProfile) error {
+	h.sessions.Broadcast(
+		event.SESSION_PROFILE,
+		message.MemberProfile{
+			ID:            session.ID(),
+			MemberProfile: new,
+		})
+
+	return nil
+}
+
+func (h *MessageHandlerCtx) SessionStateChanged(session types.Session) error {
+	h.sessions.Broadcast(
+		event.SESSION_STATE,
+		message.SessionState{
+			ID:           session.ID(),
+			SessionState: session.State(),
+		})
+
+	return nil
+}

server/internal/websocket/handler/signal.go

@@ -0,0 +1,162 @@
+package handler
+
+import (
+	"errors"
+
+	"github.com/demodesk/neko/pkg/types"
+	"github.com/demodesk/neko/pkg/types/event"
+	"github.com/demodesk/neko/pkg/types/message"
+	"github.com/pion/webrtc/v3"
+)
+
+func (h *MessageHandlerCtx) signalRequest(session types.Session, payload *message.SignalRequest) error {
+	if !session.Profile().CanWatch {
+		return errors.New("not allowed to watch")
+	}
+
+	offer, peer, err := h.webrtc.CreatePeer(session)
+	if err != nil {
+		return err
+	}
+
+	// set webrtc as paused if session has private mode enabled
+	if session.PrivateModeEnabled() {
+		peer.SetPaused(true)
+	}
+
+	video := payload.Video
+
+	// use default first video, if not provided
+	if video.Selector == nil {
+		videos := h.capture.Video().IDs()
+		video.Selector = &types.StreamSelector{
+			ID:   videos[0],
+			Type: types.StreamSelectorTypeExact,
+		}
+	}
+
+	// TODO: Remove, used for compatibility with old clients.
+	if video.Auto == nil {
+		video.Auto = &payload.Auto
+	}
+
+	// set video stream
+	err = peer.SetVideo(video)
+	if err != nil {
+		return err
+	}
+
+	audio := payload.Audio
+
+	// enable by default if not requested otherwise
+	if audio.Disabled == nil {
+		disabled := false
+		audio.Disabled = &disabled
+	}
+
+	// set audio stream
+	err = peer.SetAudio(audio)
+	if err != nil {
+		return err
+	}
+
+	session.Send(
+		event.SIGNAL_PROVIDE,
+		message.SignalProvide{
+			SDP:        offer.SDP,
+			ICEServers: h.webrtc.ICEServers(),
+
+			Video: peer.Video(),
+			Audio: peer.Audio(),
+		})
+
+	return nil
+}
+
+func (h *MessageHandlerCtx) signalRestart(session types.Session) error {
+	peer := session.GetWebRTCPeer()
+	if peer == nil {
+		return errors.New("webRTC peer does not exist")
+	}
+
+	offer, err := peer.CreateOffer(true)
+	if err != nil {
+		return err
+	}
+
+	// TODO: Use offer event instead.
+	session.Send(
+		event.SIGNAL_RESTART,
+		message.SignalDescription{
+			SDP: offer.SDP,
+		})
+
+	return nil
+}
+
+func (h *MessageHandlerCtx) signalOffer(session types.Session, payload *message.SignalDescription) error {
+	peer := session.GetWebRTCPeer()
+	if peer == nil {
+		return errors.New("webRTC peer does not exist")
+	}
+
+	err := peer.SetRemoteDescription(webrtc.SessionDescription{
+		SDP:  payload.SDP,
+		Type: webrtc.SDPTypeOffer,
+	})
+	if err != nil {
+		return err
+	}
+
+	answer, err := peer.CreateAnswer()
+	if err != nil {
+		return err
+	}
+
+	session.Send(
+		event.SIGNAL_ANSWER,
+		message.SignalDescription{
+			SDP: answer.SDP,
+		})
+
+	return nil
+}
+
+func (h *MessageHandlerCtx) signalAnswer(session types.Session, payload *message.SignalDescription) error {
+	peer := session.GetWebRTCPeer()
+	if peer == nil {
+		return errors.New("webRTC peer does not exist")
+	}
+
+	return peer.SetRemoteDescription(webrtc.SessionDescription{
+		SDP:  payload.SDP,
+		Type: webrtc.SDPTypeAnswer,
+	})
+}
+
+func (h *MessageHandlerCtx) signalCandidate(session types.Session, payload *message.SignalCandidate) error {
+	peer := session.GetWebRTCPeer()
+	if peer == nil {
+		return errors.New("webRTC peer does not exist")
+	}
+
+	return peer.SetCandidate(payload.ICECandidateInit)
+}
+
+func (h *MessageHandlerCtx) signalVideo(session types.Session, payload *message.SignalVideo) error {
+	peer := session.GetWebRTCPeer()
+	if peer == nil {
+		return errors.New("webRTC peer does not exist")
+	}
+
+	return peer.SetVideo(payload.PeerVideoRequest)
+}
+
+func (h *MessageHandlerCtx) signalAudio(session types.Session, payload *message.SignalAudio) error {
+	peer := session.GetWebRTCPeer()
+	if peer == nil {
+		return errors.New("webRTC peer does not exist")
+	}
+
+	return peer.SetAudio(payload.PeerAudioRequest)
+}

server/internal/websocket/handler/system.go

@@ -0,0 +1,96 @@
+package handler
+
+import (
+	"github.com/rs/zerolog"
+	"github.com/rs/zerolog/log"
+
+	"github.com/demodesk/neko/pkg/types"
+	"github.com/demodesk/neko/pkg/types/event"
+	"github.com/demodesk/neko/pkg/types/message"
+)
+
+func (h *MessageHandlerCtx) systemInit(session types.Session) error {
+	host, hasHost := h.sessions.GetHost()
+
+	var hostID string
+	if hasHost {
+		hostID = host.ID()
+	}
+
+	controlHost := message.ControlHost{
+		HasHost: hasHost,
+		HostID:  hostID,
+	}
+
+	sessions := map[string]message.SessionData{}
+	for _, session := range h.sessions.List() {
+		sessionId := session.ID()
+		sessions[sessionId] = message.SessionData{
+			ID:      sessionId,
+			Profile: session.Profile(),
+			State:   session.State(),
+		}
+	}
+
+	session.Send(
+		event.SYSTEM_INIT,
+		message.SystemInit{
+			SessionId:         session.ID(),
+			ControlHost:       controlHost,
+			ScreenSize:        h.desktop.GetScreenSize(),
+			Sessions:          sessions,
+			Settings:          h.sessions.Settings(),
+			TouchEvents:       h.desktop.HasTouchSupport(),
+			ScreencastEnabled: h.capture.Screencast().Enabled(),
+			WebRTC: message.SystemWebRTC{
+				Videos: h.capture.Video().IDs(),
+			},
+		})
+
+	return nil
+}
+
+func (h *MessageHandlerCtx) systemAdmin(session types.Session) error {
+	configurations := h.desktop.ScreenConfigurations()
+
+	list := make([]types.ScreenSize, 0, len(configurations))
+	for _, conf := range configurations {
+		list = append(list, types.ScreenSize{
+			Width:  conf.Width,
+			Height: conf.Height,
+			Rate:   conf.Rate,
+		})
+	}
+
+	broadcast := h.capture.Broadcast()
+	session.Send(
+		event.SYSTEM_ADMIN,
+		message.SystemAdmin{
+			ScreenSizesList: list, // TODO: remove
+			BroadcastStatus: message.BroadcastStatus{
+				IsActive: broadcast.Started(),
+				URL:      broadcast.Url(),
+			},
+		})
+
+	return nil
+}
+
+func (h *MessageHandlerCtx) systemLogs(session types.Session, payload *message.SystemLogs) error {
+	for _, msg := range *payload {
+		level, _ := zerolog.ParseLevel(msg.Level)
+
+		if level < zerolog.DebugLevel || level > zerolog.ErrorLevel {
+			level = zerolog.NoLevel
+		}
+
+		// do not use handler logger context
+		log.WithLevel(level).
+			Fields(msg.Fields).
+			Str("module", "client").
+			Str("session_id", session.ID()).
+			Msg(msg.Message)
+	}
+
+	return nil
+}