akka-apps, screenshare: add broadcast and subscribe permission check messages

Used by bbb-webrtc-sfu to enrich its validation on whether a user is allowed to broadcast a screen or subscribe to one

akka-bbb-apps/src/main/scala/org/bigbluebutton/core/apps/screenshare/GetScreenBroadcastPermissionReqMsgHdlr.scala

+package org.bigbluebutton.core2.message.handlers
+
+import org.bigbluebutton.common2.msgs._
+import org.bigbluebutton.core.running.{ MeetingActor, OutMsgRouter }
+import org.bigbluebutton.core.models.Users2x
+import org.bigbluebutton.core.apps.{ PermissionCheck, RightsManagementTrait }
+import org.bigbluebutton.core2.message.senders.MsgBuilder
+
+trait GetScreenBroadcastPermissionReqMsgHdlr {
+  this: MeetingActor =>
+
+  val outGW: OutMsgRouter
+
+  def handleGetScreenBroadcastPermissionReqMsg(msg: GetScreenBroadcastPermissionReqMsg) {
+    var allowed = false
+
+    for {
+      user <- Users2x.findWithIntId(liveMeeting.users2x, msg.body.userId)
+    } yield {
+      if (permissionFailed(PermissionCheck.GUEST_LEVEL, PermissionCheck.PRESENTER_LEVEL, liveMeeting.users2x, msg.header.userId)) {
+        val meetingId = liveMeeting.props.meetingProp.intId
+        val reason = "No permission to share the screen."
+        PermissionCheck.ejectUserForFailedPermission(meetingId, msg.header.userId, reason, outGW, liveMeeting)
+      } else if (!user.userLeftFlag.left
+        && user.authed
+        && liveMeeting.props.meetingProp.intId == msg.body.meetingId
+        && liveMeeting.props.voiceProp.voiceConf == msg.body.voiceConf) {
+        allowed = true
+      }
+    }
+
+    val event = MsgBuilder.buildGetScreenBroadcastPermissionRespMsg(
+      liveMeeting.props.meetingProp.intId,
+      liveMeeting.props.voiceProp.voiceConf,
+      msg.body.userId,
+      msg.body.sfuSessionId,
+      allowed
+    )
+    outGW.send(event)
+  }
+}

akka-bbb-apps/src/main/scala/org/bigbluebutton/core/apps/screenshare/GetScreenSubscribePermissionReqMsgHdlr.scala

+package org.bigbluebutton.core2.message.handlers
+
+import org.bigbluebutton.common2.msgs._
+import org.bigbluebutton.core.running.{ MeetingActor, OutMsgRouter }
+import org.bigbluebutton.core.models.Users2x
+import org.bigbluebutton.core.apps.ScreenshareModel
+import org.bigbluebutton.core.apps.{ ScreenshareModel, PermissionCheck, RightsManagementTrait }
+import org.bigbluebutton.core2.message.senders.MsgBuilder
+
+trait GetScreenSubscribePermissionReqMsgHdlr {
+  this: MeetingActor =>
+
+  val outGW: OutMsgRouter
+
+  def handleGetScreenSubscribePermissionReqMsg(msg: GetScreenSubscribePermissionReqMsg) {
+    var allowed = false
+
+    for {
+      user <- Users2x.findWithIntId(liveMeeting.users2x, msg.body.userId)
+    } yield {
+      if (!user.userLeftFlag.left
+        && user.authed
+        && liveMeeting.props.meetingProp.intId == msg.body.meetingId
+        && liveMeeting.props.voiceProp.voiceConf == msg.body.voiceConf
+        && ScreenshareModel.getRTMPBroadcastingUrl(liveMeeting.screenshareModel) == msg.body.streamId) {
+        allowed = true
+      }
+    }
+
+    val event = MsgBuilder.buildGetScreenSubscribePermissionRespMsg(
+      liveMeeting.props.meetingProp.intId,
+      liveMeeting.props.voiceProp.voiceConf,
+      msg.body.userId,
+      msg.body.streamId,
+      msg.body.sfuSessionId,
+      allowed
+    )
+    outGW.send(event)
+  }
+}

akka-bbb-apps/src/main/scala/org/bigbluebutton/core/pubsub/senders/ReceivedJsonMsgHandlerActor.scala

@@ -317,6 +317,10 @@ class ReceivedJsonMsgHandlerActor(
         routeVoiceMsg[ScreenshareStartedVoiceConfEvtMsg](envelope, jsonNode)
       case ScreenshareStoppedVoiceConfEvtMsg.NAME =>
         routeVoiceMsg[ScreenshareStoppedVoiceConfEvtMsg](envelope, jsonNode)
+      case GetScreenBroadcastPermissionReqMsg.NAME =>
+        routeGenericMsg[GetScreenBroadcastPermissionReqMsg](envelope, jsonNode)
+      case GetScreenSubscribePermissionReqMsg.NAME =>
+        routeGenericMsg[GetScreenSubscribePermissionReqMsg](envelope, jsonNode)
 
       // GroupChats
       case GetGroupChatsReqMsg.NAME =>

akka-bbb-apps/src/main/scala/org/bigbluebutton/core/running/MeetingActor.scala

@@ -75,6 +75,8 @@ class MeetingActor(
   with MuteMeetingCmdMsgHdlr
   with IsMeetingMutedReqMsgHdlr
   with GetGlobalAudioPermissionReqMsgHdlr
+  with GetScreenBroadcastPermissionReqMsgHdlr
+  with GetScreenSubscribePermissionReqMsgHdlr
 
   with EjectUserFromVoiceCmdMsgHdlr
   with EndMeetingSysCmdMsgHdlr
@@ -481,6 +483,8 @@ class MeetingActor(
       case m: ScreenshareRtmpBroadcastStartedVoiceConfEvtMsg => screenshareApp2x.handle(m, liveMeeting, msgBus)
       case m: ScreenshareRtmpBroadcastStoppedVoiceConfEvtMsg => screenshareApp2x.handle(m, liveMeeting, msgBus)
       case m: GetScreenshareStatusReqMsg                     => screenshareApp2x.handle(m, liveMeeting, msgBus)
+      case m: GetScreenBroadcastPermissionReqMsg             => handleGetScreenBroadcastPermissionReqMsg(m)
+      case m: GetScreenSubscribePermissionReqMsg             => handleGetScreenSubscribePermissionReqMsg(m)
 
       // GroupChat
       case m: CreateGroupChatReqMsg =>

akka-bbb-apps/src/main/scala/org/bigbluebutton/core2/message/senders/MsgBuilder.scala

@@ -344,4 +344,51 @@ object MsgBuilder {
     val event = RegisteredUserJoinTimeoutMsg(header, body)
     BbbCommonEnvCoreMsg(envelope, event)
   }
+
+  def buildGetScreenSubscribePermissionRespMsg(
+      meetingId:    String,
+      voiceConf:    String,
+      userId:       String,
+      streamId:     String,
+      sfuSessionId: String,
+      allowed:      Boolean
+  ): BbbCommonEnvCoreMsg = {
+    val routing = Routing.addMsgToClientRouting(MessageTypes.DIRECT, meetingId, userId)
+    val envelope = BbbCoreEnvelope(GetScreenSubscribePermissionRespMsg.NAME, routing)
+    val header = BbbClientMsgHeader(GetScreenSubscribePermissionRespMsg.NAME, meetingId, userId)
+    val body = GetScreenSubscribePermissionRespMsgBody(
+      meetingId,
+      voiceConf,
+      userId,
+      streamId,
+      sfuSessionId,
+      allowed
+    )
+    val event = GetScreenSubscribePermissionRespMsg(header, body)
+
+    BbbCommonEnvCoreMsg(envelope, event)
+  }
+
+  def buildGetScreenBroadcastPermissionRespMsg(
+      meetingId:    String,
+      voiceConf:    String,
+      userId:       String,
+      sfuSessionId: String,
+      allowed:      Boolean
+  ): BbbCommonEnvCoreMsg = {
+    val routing = Routing.addMsgToClientRouting(MessageTypes.DIRECT, meetingId, userId)
+    val envelope = BbbCoreEnvelope(GetScreenBroadcastPermissionRespMsg.NAME, routing)
+    val header = BbbClientMsgHeader(GetScreenBroadcastPermissionRespMsg.NAME, meetingId, userId)
+
+    val body = GetScreenBroadcastPermissionRespMsgBody(
+      meetingId,
+      voiceConf,
+      userId,
+      sfuSessionId,
+      allowed
+    )
+    val event = GetScreenBroadcastPermissionRespMsg(header, body)
+
+    BbbCommonEnvCoreMsg(envelope, event)
+  }
 }

bbb-common-message/src/main/scala/org/bigbluebutton/common2/msgs/VoiceConfMsgs.scala

@@ -106,6 +106,66 @@ case class ScreenshareStopRtmpBroadcastVoiceConfMsg(
 ) extends BbbCoreMsg
 case class ScreenshareStopRtmpBroadcastVoiceConfMsgBody(voiceConf: String, screenshareConf: String, url: String, timestamp: String)
 
+/* Sent by bbb-webrtc-sfu to ask permission for broadcasting a screen stream
+ */
+object GetScreenBroadcastPermissionReqMsg { val NAME = "GetScreenBroadcastPermissionReqMsg" }
+case class GetScreenBroadcastPermissionReqMsg(
+    header: BbbClientMsgHeader,
+    body:   GetScreenBroadcastPermissionReqMsgBody
+) extends StandardMsg
+case class GetScreenBroadcastPermissionReqMsgBody(
+    meetingId:    String,
+    voiceConf:    String,
+    userId:       String,
+    sfuSessionId: String
+)
+
+/* Sent to bbb-webrtc-sfu to grant or deny screen sharing permission
+ */
+object GetScreenBroadcastPermissionRespMsg { val NAME = "GetScreenBroadcastPermissionRespMsg" }
+case class GetScreenBroadcastPermissionRespMsg(
+    header: BbbClientMsgHeader,
+    body:   GetScreenBroadcastPermissionRespMsgBody
+) extends StandardMsg
+case class GetScreenBroadcastPermissionRespMsgBody(
+    meetingId:    String,
+    voiceConf:    String,
+    userId:       String,
+    sfuSessionId: String,
+    allowed:      Boolean
+)
+
+/* Sent by bbb-webrtc-sfu to ask permission for subscring to a broadcasted
+ * screen stream
+ */
+object GetScreenSubscribePermissionReqMsg { val NAME = "GetScreenSubscribePermissionReqMsg" }
+case class GetScreenSubscribePermissionReqMsg(
+    header: BbbClientMsgHeader,
+    body:   GetScreenSubscribePermissionReqMsgBody
+) extends StandardMsg
+case class GetScreenSubscribePermissionReqMsgBody(
+    meetingId:    String,
+    voiceConf:    String,
+    userId:       String,
+    streamId:     String,
+    sfuSessionId: String
+)
+
+/* Sent to bbb-webrtc-sfu to grant or deny a screen sharing subscribe request
+ */
+object GetScreenSubscribePermissionRespMsg { val NAME = "GetScreenSubscribePermissionRespMsg" }
+case class GetScreenSubscribePermissionRespMsg(
+    header: BbbClientMsgHeader,
+    body:   GetScreenSubscribePermissionRespMsgBody
+) extends StandardMsg
+case class GetScreenSubscribePermissionRespMsgBody(
+    meetingId:    String,
+    voiceConf:    String,
+    userId:       String,
+    streamId:     String,
+    sfuSessionId: String,
+    allowed:      Boolean
+)
 /**
  * Sent to FS to eject all users from the voice conference.
  */