mirror of
https://github.com/opensim/opensim.git
synced 2026-07-19 05:56:12 +08:00
824 lines
37 KiB
C#
824 lines
37 KiB
C#
/*
|
|
* Copyright (c) Contributors, http://opensimulator.org/
|
|
* See CONTRIBUTORS.TXT for a full list of copyright holders.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
* * Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* * Neither the name of the OpenSimulator Project nor the
|
|
* names of its contributors may be used to endorse or promote products
|
|
* derived from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
|
|
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
|
|
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
|
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
using log4net;
|
|
using Mono.Addins;
|
|
using Nini.Config;
|
|
using OpenMetaverse;
|
|
using OpenMetaverse.StructuredData;
|
|
using OpenSim.Framework;
|
|
using OpenSim.Framework.Servers.HttpServer;
|
|
using OpenSim.Region.Framework.Interfaces;
|
|
using OpenSim.Region.Framework.Scenes;
|
|
using OpenSim.Server.Base;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Net;
|
|
using System.Reflection;
|
|
using System.Threading.Tasks;
|
|
using Caps = OpenSim.Framework.Capabilities.Caps;
|
|
using OSDMap = OpenMetaverse.StructuredData.OSDMap;
|
|
|
|
[assembly: Addin("WebRtcVoiceRegionModule", "1.0")]
|
|
[assembly: AddinDependency("OpenSim.Region.Framework", OpenSim.VersionInfo.VersionNumber)]
|
|
|
|
namespace osWebRtcVoice
|
|
{
|
|
/// <summary>
|
|
/// This module provides the WebRTC voice interface for viewer clients..
|
|
///
|
|
/// In particular, it provides the following capabilities:
|
|
/// ProvisionVoiceAccountRequest, VoiceSignalingRequest and limited ChatSessionRequest
|
|
/// which are the user interface to the voice service.
|
|
///
|
|
/// Initially, when the user connects to the region, the region feature "VoiceServiceType" is
|
|
/// set to "webrtc" and the capabilities that support voice are enabled.
|
|
/// The capabilities then pass the user request information to the IWebRtcVoiceService interface
|
|
/// that has been registered for the reqion.
|
|
/// </summary>
|
|
[Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "RegionVoiceModule")]
|
|
public class WebRtcVoiceRegionModule : ISharedRegionModule
|
|
{
|
|
private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
|
|
private static readonly string LogHeader = "[REGION WEBRTC VOICE]";
|
|
|
|
private static byte[] llsdUndefAnswerBytes = Util.UTF8.GetBytes("<llsd><undef /></llsd>");
|
|
private bool _MessageDetails = false;
|
|
|
|
// Control info
|
|
private static bool m_Enabled = false;
|
|
|
|
private IConfig m_Config;
|
|
|
|
private IWebRtcVoiceService m_spatialVoiceService;
|
|
private IWebRtcVoiceService m_nonSpatialVoiceService;
|
|
|
|
private UUID gridHash = UUID.Zero;
|
|
|
|
// ISharedRegionModule.Initialize
|
|
public void Initialise(IConfigSource config)
|
|
{
|
|
m_Config = config.Configs["WebRtcVoice"];
|
|
if (m_Config is not null)
|
|
{
|
|
m_Enabled = m_Config.GetBoolean("Enabled", false);
|
|
if (m_Enabled)
|
|
{
|
|
// Get the DLLs for the two voice services
|
|
// TODO: spacial/nonspacial names are wrong
|
|
// spacial here means service for region parcels, that can be spacial or not
|
|
// non spacial means for other uses like IMs, that just happen to be non spacial
|
|
// in fact this needs more consideration than just this 2 options
|
|
|
|
string spatialDllName = m_Config.GetString("SpatialVoiceService", string.Empty);
|
|
string nonSpatialDllName = m_Config.GetString("NonSpatialVoiceService", string.Empty);
|
|
if (string.IsNullOrEmpty(spatialDllName) && string.IsNullOrEmpty(nonSpatialDllName))
|
|
{
|
|
m_log.Error($"{LogHeader} No VoiceService specified in configuration");
|
|
m_Enabled = false;
|
|
return;
|
|
}
|
|
|
|
// Default non-spatial to spatial if not specified
|
|
if (string.IsNullOrEmpty(nonSpatialDllName))
|
|
{
|
|
m_log.Debug($"{LogHeader} nonSpatialDllName not specified. Defaulting to spatialDllName");
|
|
nonSpatialDllName = spatialDllName;
|
|
}
|
|
|
|
// Load the two voice services
|
|
m_log.Debug($"{LogHeader} Loading SpatialVoiceService from {spatialDllName}");
|
|
m_spatialVoiceService = ServerUtils.LoadPlugin<IWebRtcVoiceService>(spatialDllName, [config]);
|
|
if (m_spatialVoiceService is null)
|
|
{
|
|
m_log.Error($"{LogHeader} Could not load SpatialVoiceService from {spatialDllName}, module disabled");
|
|
m_Enabled = false;
|
|
return;
|
|
}
|
|
|
|
m_log.Debug($"{LogHeader} Loading NonSpatialVoiceService from {nonSpatialDllName}");
|
|
if (spatialDllName != nonSpatialDllName)
|
|
{
|
|
m_nonSpatialVoiceService = ServerUtils.LoadPlugin<IWebRtcVoiceService>(nonSpatialDllName, [ m_Config ]);
|
|
if (m_nonSpatialVoiceService is null)
|
|
{
|
|
m_log.Error($"{LogHeader} Could not load NonSpatialVoiceService from {nonSpatialDllName}");
|
|
m_Enabled = false;
|
|
}
|
|
}
|
|
else
|
|
m_nonSpatialVoiceService = m_spatialVoiceService;
|
|
|
|
if (m_Enabled)
|
|
{
|
|
_MessageDetails = m_Config.GetBoolean("MessageDetails", false);
|
|
m_log.Info($"{LogHeader} WebRtcVoiceService enabled");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// ISharedRegionModule.PostInitialize
|
|
public void PostInitialise()
|
|
{
|
|
}
|
|
|
|
// ISharedRegionModule.AddRegion
|
|
public void AddRegion(Scene scene)
|
|
{
|
|
// TODO: register module to get parcels changes etc
|
|
}
|
|
|
|
// ISharedRegionModule.RemoveRegion
|
|
public void RemoveRegion(Scene scene)
|
|
{
|
|
}
|
|
|
|
// ISharedRegionModule.RegionLoaded
|
|
public void RegionLoaded(Scene scene)
|
|
{
|
|
if (m_Enabled)
|
|
{
|
|
scene.EventManager.OnRegisterCaps += delegate (UUID agentID, Caps caps)
|
|
{
|
|
OnRegisterCaps(scene, agentID, caps);
|
|
};
|
|
|
|
scene.EventManager.OnRemovePresence += delegate (UUID agentID)
|
|
{
|
|
OnRemovePresence(scene, agentID);
|
|
};
|
|
|
|
scene.EventManager.OnNewClient += OnNewClient;
|
|
|
|
if(gridHash.IsZero())
|
|
{
|
|
if(!string.IsNullOrEmpty(scene.SceneGridInfo.GridUrl))
|
|
gridHash = Util.ComputeShake128UUID(scene.SceneGridInfo.GridUrl + scene.SceneGridInfo.GridName);
|
|
else if (!string.IsNullOrEmpty(scene.SceneGridInfo.HomeURL + scene.SceneGridInfo.GridName))
|
|
gridHash = Util.ComputeShake128UUID(scene.SceneGridInfo.HomeURLNoEndSlash);
|
|
}
|
|
|
|
ISimulatorFeaturesModule simFeatures = scene.RequestModuleInterface<ISimulatorFeaturesModule>();
|
|
simFeatures?.AddFeature("VoiceServerType", OSD.FromString("webrtc"));
|
|
}
|
|
}
|
|
|
|
// ISharedRegionModule.Close
|
|
public void Close()
|
|
{
|
|
}
|
|
|
|
// ISharedRegionModule.Name
|
|
public string Name
|
|
{
|
|
get { return "RegionVoiceModule"; }
|
|
}
|
|
|
|
// ISharedRegionModule.ReplaceableInterface
|
|
public Type ReplaceableInterface
|
|
{
|
|
get { return null; }
|
|
}
|
|
|
|
private void OnNewClient(IClientAPI client)
|
|
{
|
|
client.OnLogout += OnClientLogOut;
|
|
}
|
|
|
|
private void OnClientLogOut(IClientAPI client)
|
|
{
|
|
client.OnLogout -= OnClientLogOut;
|
|
|
|
if(client.SceneAgent is not ScenePresence sp)
|
|
return;
|
|
|
|
List<IVoiceViewerSession> toremove = [];
|
|
if (VoiceViewerSession.TryGetViewerSessionsByAgentAndRegion(sp.UUID, sp.Scene.ID, out IEnumerable<KeyValuePair<string, IVoiceViewerSession>> vSessions))
|
|
{
|
|
foreach(KeyValuePair<string, IVoiceViewerSession> v in vSessions)
|
|
{
|
|
if((v.Value.Flags & IVoiceViewerSession.VFlags.IsParcel) != 0)
|
|
toremove.Add(v.Value);
|
|
}
|
|
|
|
foreach(IVoiceViewerSession v in toremove)
|
|
VoiceViewerSession.RemoveViewerSession(v.ViewerSessionID);
|
|
}
|
|
|
|
Util.FireAndForget( x =>
|
|
{
|
|
try
|
|
{
|
|
OSDMap vreq = new()
|
|
{
|
|
{ "logout" , true},
|
|
{ "viewer_session" , UUID.Zero}
|
|
};
|
|
|
|
m_spatialVoiceService?.ProvisionVoiceAccountRequest(vreq , sp.UUID, sp.Scene.ID);
|
|
if(m_nonSpatialVoiceService != m_spatialVoiceService)
|
|
m_nonSpatialVoiceService?.ProvisionVoiceAccountRequest(vreq , sp.UUID, sp.Scene.ID);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
m_log.Debug($"{LogHeader} OnClientLogOut exception: {ex.Message}");
|
|
}
|
|
});
|
|
}
|
|
|
|
private static void OnRemovePresence(Scene pScene, UUID pAgentID)
|
|
{
|
|
List<IVoiceViewerSession> toremove = [];
|
|
if (VoiceViewerSession.TryGetViewerSessionsByAgentAndRegion(pAgentID, pScene.RegionInfo.RegionID, out IEnumerable<KeyValuePair<string, IVoiceViewerSession>> vSessions))
|
|
{
|
|
foreach(KeyValuePair<string, IVoiceViewerSession> v in vSessions)
|
|
{
|
|
if((v.Value.Flags & IVoiceViewerSession.VFlags.IsParcel) != 0)
|
|
toremove.Add(v.Value);
|
|
}
|
|
|
|
if(toremove.Count > 0)
|
|
{
|
|
foreach(IVoiceViewerSession v in toremove)
|
|
VoiceViewerSession.RemoveViewerSession(v.ViewerSessionID);
|
|
|
|
Util.FireAndForget( x =>
|
|
{
|
|
List<IVoiceViewerSession> toremoveas = toremove;
|
|
foreach(IVoiceViewerSession v in toremoveas)
|
|
try
|
|
{
|
|
OSDMap vreq = new()
|
|
{
|
|
{ "logout" , true},
|
|
{ "viewer_session" , v.ViewerSessionID}
|
|
};
|
|
v.VoiceService.ProvisionVoiceAccountRequest(v, vreq , v.AgentId, v.RegionId);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
m_log.Debug(
|
|
$"{LogHeader} OnRemovePresence: failed for viewer_session {v.ViewerSessionID}: {ex.Message}");
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void CleanupDuplicateSessions(UUID pAgentID, UUID pSceneID, string pKeepViewerSessionId)
|
|
{
|
|
if(VoiceViewerSession.TryGetViewerSessionsByAgentAndRegion(pAgentID, pSceneID, out IEnumerable<KeyValuePair<string, IVoiceViewerSession>> candidates))
|
|
{
|
|
bool noskip = string.IsNullOrEmpty(pKeepViewerSessionId);
|
|
List<IVoiceViewerSession> toremove = [];
|
|
foreach (KeyValuePair<string, IVoiceViewerSession> candidate in candidates)
|
|
{
|
|
if (noskip && candidate.Key == pKeepViewerSessionId)
|
|
continue;
|
|
|
|
m_log.Warn(
|
|
$"{LogHeader} CleanupDuplicateSessions: removing stale viewer_session {candidate.Key} for agent {pAgentID}, scene {pSceneID}");
|
|
toremove.Add(candidate.Value);
|
|
}
|
|
|
|
foreach(IVoiceViewerSession v in toremove)
|
|
VoiceViewerSession.RemoveViewerSession(v.ViewerSessionID);
|
|
|
|
if(toremove.Count > 0)
|
|
{
|
|
Util.FireAndForget( x =>
|
|
{
|
|
foreach(IVoiceViewerSession v in toremove)
|
|
{
|
|
try
|
|
{
|
|
OSDMap vreq = new()
|
|
{
|
|
{ "logout" , true},
|
|
{ "viewer_session" , v.ViewerSessionID}
|
|
};
|
|
v.VoiceService.ProvisionVoiceAccountRequest(v, vreq , v.AgentId, v.RegionId);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
m_log.Debug(
|
|
$"{LogHeader} CleanupDuplicateSessions: shutdown failed for viewer_session {v.ViewerSessionID}: {ex.Message}");
|
|
}
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
// <summary>
|
|
// OnRegisterCaps is invoked via the scene.EventManager
|
|
// everytime OpenSim hands out capabilities to a client
|
|
// (login, region crossing). We contribute three capabilities to
|
|
// the set of capabilities handed back to the client:
|
|
// ProvisionVoiceAccountRequest, VoiceSignalingRequest and limited ChatSessionRequest
|
|
//
|
|
// ProvisionVoiceAccountRequest allows the client to obtain
|
|
// voice communication information the the avater.
|
|
//
|
|
// VoiceSignalingRequest: Used for trickling ICE candidates.
|
|
//
|
|
// ChatSessionRequest
|
|
//
|
|
// Note that OnRegisterCaps is called here via a closure
|
|
// delegate containing the scene of the respective region (see
|
|
// Initialise()).
|
|
// </summary>
|
|
public void OnRegisterCaps(Scene scene, UUID agentID, Caps caps)
|
|
{
|
|
m_log.Debug(
|
|
$"{LogHeader}: OnRegisterCaps called with agentID {agentID} in scene {scene.Name}");
|
|
|
|
caps.RegisterSimpleHandler("ProvisionVoiceAccountRequest",
|
|
new SimpleStreamHandler("/" + UUID.Random(), (IOSHttpRequest httpRequest, IOSHttpResponse httpResponse) =>
|
|
{
|
|
ProvisionVoiceAccountRequest(httpRequest, httpResponse, agentID, scene);
|
|
}));
|
|
|
|
caps.RegisterSimpleHandler("VoiceSignalingRequest",
|
|
new SimpleStreamHandler("/" + UUID.Random(), (IOSHttpRequest httpRequest, IOSHttpResponse httpResponse) =>
|
|
{
|
|
VoiceSignalingRequest(httpRequest, httpResponse, agentID, scene);
|
|
}));
|
|
|
|
caps.RegisterSimpleHandler("ChatSessionRequest",
|
|
new SimpleStreamHandler("/" + UUID.Random(), (IOSHttpRequest httpRequest, IOSHttpResponse httpResponse) =>
|
|
{
|
|
ChatSessionRequest(httpRequest, httpResponse, agentID, scene);
|
|
}));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Callback for a client request for Voice Account Details
|
|
/// </summary>
|
|
/// <param name="scene">current scene object of the client</param>
|
|
/// <param name="request"></param>
|
|
/// <param name="path"></param>
|
|
/// <param name="param"></param>
|
|
/// <param name="agentID"></param>
|
|
/// <param name="caps"></param>
|
|
/// <returns></returns>
|
|
public void ProvisionVoiceAccountRequest(IOSHttpRequest request, IOSHttpResponse response, UUID agentID, Scene scene)
|
|
{
|
|
if(request.HttpMethod != "POST")
|
|
{
|
|
m_log.Debug($"{LogHeader}[ProvisionVoice]: Not a POST request. Agent={agentID}");
|
|
response.StatusCode = (int)HttpStatusCode.NotFound;
|
|
return;
|
|
}
|
|
|
|
// Deserialize the request. Convert the LLSDXml to OSD for our use
|
|
OSDMap map = BodyToMap(request, $"{LogHeader}[ProvisionVoice]");
|
|
if (map is null)
|
|
{
|
|
m_log.Error($"{LogHeader}[ProvisionVoice]: No request data found. Agent={agentID}");
|
|
response.StatusCode = (int)HttpStatusCode.NoContent;
|
|
return;
|
|
}
|
|
|
|
// Make sure the request is for WebRtc voice
|
|
if (map.TryGetValue("voice_server_type", out OSD vstosd))
|
|
{
|
|
if (vstosd is OSDString vst && !((string)vst).Equals("webrtc", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
m_log.Warn($"{LogHeader}[ProvisionVoice]: voice_server_type is not 'webrtc'");
|
|
if (m_log.IsDebugEnabled)
|
|
m_log.Warn($"{LogHeader}[ProvisionVoice]: Request detail: {map}");
|
|
|
|
response.RawBuffer = llsdUndefAnswerBytes;
|
|
response.StatusCode = (int)HttpStatusCode.OK;
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (_MessageDetails) m_log.Debug($"{LogHeader}[ProvisionVoice]: request: {map}");
|
|
|
|
IVoiceViewerSession vSession = null;
|
|
|
|
if (map.TryGetString("viewer_session", out string viewerSessionId))
|
|
{
|
|
if(map.TryGetBool("logout", out bool islog) && islog)
|
|
{
|
|
if(UUID.ZeroString.Equals(viewerSessionId, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
if (VoiceViewerSession.TryGetViewerSessionsByAgentId(agentID, out IEnumerable<KeyValuePair<string, IVoiceViewerSession>> vSessions))
|
|
{
|
|
m_log.Info(
|
|
$"{LogHeader} ProvisionVoiceAccountRequest: doing logout for {vSessions.Count()} stall sessions");
|
|
|
|
OSDMap vreq = new() {{ "logout" , true} };
|
|
|
|
foreach(KeyValuePair<string, IVoiceViewerSession> kvp in vSessions)
|
|
{
|
|
IVoiceViewerSession v = kvp.Value;
|
|
if(v is null)
|
|
continue;
|
|
vreq["viewer_session"] = v.ViewerSessionID;
|
|
VoiceViewerSession.RemoveViewerSession(v.ViewerSessionID);
|
|
v.VoiceService.ProvisionVoiceAccountRequest(v, vreq , agentID, scene.RegionInfo.RegionID);
|
|
}
|
|
}
|
|
|
|
response.RawBuffer = OSDParser.SerializeLLSDXmlBytes(new OSDMap {{ "response", "closed" }});
|
|
response.StatusCode = (int)HttpStatusCode.OK;
|
|
return ;
|
|
}
|
|
|
|
OSDMap logoutresp = null;
|
|
if (VoiceViewerSession.TryGetViewerSession(viewerSessionId, out vSession))
|
|
{
|
|
VoiceViewerSession.RemoveViewerSession(viewerSessionId);
|
|
logoutresp = vSession.VoiceService.ProvisionVoiceAccountRequest(vSession, map, agentID, scene.RegionInfo.RegionID);
|
|
}
|
|
logoutresp ??= new OSDMap() {
|
|
{ "response", "error" },
|
|
{ "message", "Logout session not found" } };
|
|
|
|
response.RawBuffer = OSDParser.SerializeLLSDXmlBytes(logoutresp);
|
|
response.StatusCode = (int)HttpStatusCode.OK;
|
|
return ;
|
|
}
|
|
|
|
// request has a viewer session. Use that to find the voice service
|
|
if (VoiceViewerSession.TryGetViewerSession(viewerSessionId, out vSession))
|
|
{
|
|
CleanupDuplicateSessions(agentID, scene.RegionInfo.RegionID, viewerSessionId);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//no session id.. new channel?
|
|
if (map.TryGetString("channel_type", out string channelType))
|
|
{
|
|
CleanupDuplicateSessions(agentID, scene.RegionInfo.RegionID, null);
|
|
|
|
if(!scene.TryGetScenePresence(agentID, out ScenePresence sp))
|
|
{
|
|
m_log.Debug($"{LogHeader}[ProvisionVoice]:avatar not found");
|
|
response.RawBuffer = llsdUndefAnswerBytes;
|
|
response.StatusCode = (int)HttpStatusCode.NotFound;
|
|
return;
|
|
}
|
|
|
|
IVoiceViewerSession.VFlags flags = IVoiceViewerSession.VFlags.None;
|
|
|
|
//do fully not trust viewers voice parcel requests
|
|
if (channelType == "local")
|
|
{
|
|
if (!scene.RegionInfo.EstateSettings.AllowVoice)
|
|
{
|
|
m_log.Debug($"{LogHeader}[ProvisionVoice]:region \"{scene.Name}\": voice not enabled in estate settings");
|
|
response.RawBuffer = llsdUndefAnswerBytes;
|
|
response.StatusCode = (int)HttpStatusCode.NotImplemented;
|
|
return;
|
|
}
|
|
if (scene.LandChannel == null)
|
|
{
|
|
m_log.Error($"{LogHeader}[ProvisionVoice] region \"{scene.Name}\" land data not yet available");
|
|
response.RawBuffer = llsdUndefAnswerBytes;
|
|
response.StatusCode = (int)HttpStatusCode.NotImplemented;
|
|
return;
|
|
}
|
|
|
|
if(map.TryGetInt("parcel_local_id", out int parcelID))
|
|
{
|
|
ILandObject parcel = scene.LandChannel.GetLandObject(parcelID);
|
|
if (parcel == null)
|
|
{
|
|
response.RawBuffer = llsdUndefAnswerBytes;
|
|
response.StatusCode = (int)HttpStatusCode.NotFound;
|
|
return;
|
|
}
|
|
|
|
LandData land = parcel.LandData;
|
|
if (land == null)
|
|
{
|
|
response.RawBuffer = llsdUndefAnswerBytes;
|
|
response.StatusCode = (int)HttpStatusCode.NotFound;
|
|
return;
|
|
}
|
|
|
|
if (!scene.RegionInfo.EstateSettings.TaxFree && (land.Flags & (uint)ParcelFlags.AllowVoiceChat) == 0)
|
|
{
|
|
m_log.Debug($"{LogHeader}[ProvisionVoice]:parcel voice not allowed");
|
|
response.RawBuffer = llsdUndefAnswerBytes;
|
|
response.StatusCode = (int)HttpStatusCode.Forbidden;
|
|
return;
|
|
}
|
|
|
|
if ((land.Flags & (uint)ParcelFlags.UseEstateVoiceChan) != 0)
|
|
{
|
|
// By removing the parcel_local_id, the voice service will treat this as an estate channel
|
|
// request and return the appropriate voice credentials for the estate channel
|
|
// instead of a parcel channel
|
|
map.Remove("parcel_local_id"); // estate channel
|
|
flags = IVoiceViewerSession.VFlags.IsEstate;
|
|
}
|
|
else
|
|
{
|
|
if(parcel.IsRestrictedFromLand(agentID) || parcel.IsBannedFromLand(agentID))
|
|
{
|
|
// check Z distance?
|
|
m_log.Debug($"{LogHeader}[ProvisionVoice]:agent not allowed on parcel");
|
|
response.RawBuffer = llsdUndefAnswerBytes;
|
|
response.StatusCode = (int)HttpStatusCode.Forbidden;
|
|
return;
|
|
}
|
|
flags = parcel.OwnerID.Equals(agentID) ?
|
|
IVoiceViewerSession.VFlags.IsAdmin | IVoiceViewerSession.VFlags.IsParcel :
|
|
IVoiceViewerSession.VFlags.IsParcel;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
flags = IVoiceViewerSession.VFlags.IsEstate;
|
|
}
|
|
|
|
// TODO: check if this userId is making a new session (case that user is reconnecting)
|
|
vSession = m_spatialVoiceService.CreateViewerSession(map, agentID, scene.RegionInfo.RegionID);
|
|
if(vSession != null)
|
|
{
|
|
if(sp.IsChildAgent)
|
|
flags |= IVoiceViewerSession.VFlags.IsChildAgent;
|
|
else if(scene.Permissions.IsEstateManager(agentID))
|
|
flags |= IVoiceViewerSession.VFlags.IsAdmin;
|
|
vSession.Flags = flags;
|
|
VoiceViewerSession.AddViewerSession(vSession);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(sp.IsChildAgent)
|
|
{
|
|
// check Z distance?
|
|
m_log.Debug($"{LogHeader}[ProvisionVoice]:child agent request non local voice");
|
|
response.RawBuffer = llsdUndefAnswerBytes;
|
|
response.StatusCode = (int)HttpStatusCode.Forbidden;
|
|
return;
|
|
}
|
|
|
|
vSession = m_nonSpatialVoiceService.CreateViewerSession(map, agentID, scene.RegionInfo.RegionID);
|
|
if(vSession != null)
|
|
{
|
|
vSession.Flags = IVoiceViewerSession.VFlags.IsAdmin;
|
|
VoiceViewerSession.AddViewerSession(vSession);
|
|
map["gridhash"] = gridHash;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
OSDMap resp = null;
|
|
if (vSession is not null)
|
|
{
|
|
resp = vSession.VoiceService.ProvisionVoiceAccountRequest(vSession, map, agentID, scene.RegionInfo.RegionID);
|
|
}
|
|
|
|
if (resp is null)
|
|
{
|
|
response.StatusCode = (int)HttpStatusCode.BadRequest;
|
|
if (_MessageDetails) m_log.Debug($"{LogHeader}[ProvisionVoice]: got null response");
|
|
return;
|
|
}
|
|
|
|
if (_MessageDetails) m_log.Debug($"{LogHeader}[ProvisionVoice]: response: {resp}");
|
|
|
|
response.RawBuffer = OSDParser.SerializeLLSDXmlToBytes(resp);
|
|
response.StatusCode = (int)HttpStatusCode.OK;
|
|
return;
|
|
}
|
|
|
|
public void VoiceSignalingRequest(IOSHttpRequest request, IOSHttpResponse response, UUID agentID, Scene scene)
|
|
{
|
|
if(request.HttpMethod != "POST")
|
|
{
|
|
m_log.Error($"{LogHeader}[VoiceSignaling]: Not a POST request. Agent={agentID}");
|
|
response.StatusCode = (int)HttpStatusCode.NotFound;
|
|
return;
|
|
}
|
|
|
|
// Deserialize the request. Convert the LLSDXml to OSD for our use
|
|
OSDMap map = BodyToMap(request, $"{LogHeader}[VoiceSignaling]");
|
|
if (map is null)
|
|
{
|
|
m_log.Error($"{LogHeader}[VoiceSignalingRequest]: No request data found. Agent={agentID}");
|
|
response.StatusCode = (int)HttpStatusCode.NoContent;
|
|
return;
|
|
}
|
|
|
|
// Make sure the request is for WebRTC voice
|
|
if (map.TryGetValue("voice_server_type", out OSD vstosd))
|
|
{
|
|
if (vstosd is OSDString vst && !((string)vst).Equals("webrtc", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
response.RawBuffer = llsdUndefAnswerBytes;
|
|
response.StatusCode = (int)HttpStatusCode.OK;
|
|
return;
|
|
}
|
|
}
|
|
|
|
OSDMap resp = null;
|
|
if (map.TryGetString("viewer_session", out string viewerSessionId))
|
|
{
|
|
// request has a viewer session. Use that to find the voice service
|
|
if (VoiceViewerSession.TryGetViewerSession(viewerSessionId, out IVoiceViewerSession vSession))
|
|
{
|
|
resp = vSession.VoiceService.VoiceSignalingRequest(vSession, map, agentID, scene.RegionInfo.RegionID);
|
|
}
|
|
else
|
|
{
|
|
m_log.Error($"{LogHeader} VoiceSignalingRequest: viewer session {viewerSessionId} not found");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_log.Error($"{LogHeader} VoiceSignalingRequest: no viewer_session in request");
|
|
}
|
|
|
|
if (_MessageDetails) m_log.Debug($"{LogHeader}[VoiceSignalingRequest]: Response: {resp ?? "null"}");
|
|
|
|
// TODO: check for errors
|
|
// viewers ignore response
|
|
response.RawBuffer = llsdUndefAnswerBytes;
|
|
response.StatusCode = (int)HttpStatusCode.OK;
|
|
return;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Callback for a client request for ChatSessionRequest.
|
|
/// The viewer sends this request when the user tries to start a P2P text or voice session
|
|
/// with another user. We need to generate a new session ID and return it to the client.
|
|
/// </summary>
|
|
/// <param name="request"></param>
|
|
/// <param name="response"></param>
|
|
/// <param name="agentID"></param>
|
|
/// <param name="scene"></param>
|
|
public void ChatSessionRequest(IOSHttpRequest request, IOSHttpResponse response, UUID agentID, Scene scene)
|
|
{
|
|
m_log.Debug($"{LogHeader}: ChatSessionRequest received for agent {agentID} in scene {scene.Name}");
|
|
if (request.HttpMethod != "POST")
|
|
{
|
|
response.StatusCode = (int)HttpStatusCode.NotFound;
|
|
return;
|
|
}
|
|
|
|
if (!scene.TryGetScenePresence(agentID, out ScenePresence sp) || sp.IsDeleted)
|
|
{
|
|
m_log.Warn($"{LogHeader} ChatSessionRequest: scene presence not found or deleted for agent {agentID}");
|
|
response.StatusCode = (int)HttpStatusCode.NotFound;
|
|
return;
|
|
}
|
|
|
|
OSDMap reqmap = BodyToMap(request, $"{LogHeader}[ChatSessionRequest]");
|
|
if (reqmap is null)
|
|
{
|
|
m_log.Warn($"{LogHeader} ChatSessionRequest: message body not parsable in request for agent {agentID}");
|
|
response.StatusCode = (int)HttpStatusCode.NoContent;
|
|
return;
|
|
}
|
|
|
|
m_log.Debug($"{LogHeader} ChatSessionRequest");
|
|
|
|
if (!reqmap.TryGetString("method", out string method))
|
|
{
|
|
m_log.Warn($"{LogHeader} ChatSessionRequest: missing required 'method' field in request for agent {agentID}");
|
|
response.StatusCode = (int)HttpStatusCode.NotFound;
|
|
return;
|
|
}
|
|
|
|
if (!reqmap.TryGetUUID("session-id", out UUID sessionID))
|
|
{
|
|
m_log.Warn($"{LogHeader} ChatSessionRequest: missing required 'session-id' field in request for agent {agentID}");
|
|
response.StatusCode = (int)HttpStatusCode.NotFound;
|
|
return;
|
|
}
|
|
|
|
string servertype = null;
|
|
if(reqmap.TryGetOSDMap("alt_params", out OSDMap altparams))
|
|
{
|
|
if(!altparams.TryGetString("voice_server_type", out servertype))
|
|
_ = altparams.TryGetString("preferred_voice_server_type", out servertype);
|
|
}
|
|
|
|
if(!string.IsNullOrEmpty(servertype))
|
|
{
|
|
if(!servertype.Equals("webrtc", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
response.RawBuffer = llsdUndefAnswerBytes;
|
|
response.StatusCode = (int)HttpStatusCode.OK;
|
|
return;
|
|
}
|
|
}
|
|
|
|
switch (method.ToLower())
|
|
{
|
|
// Several different method requests that we don't know how to handle.
|
|
// Just return OK for now.
|
|
case "decline p2p voice":
|
|
case "decline invitation":
|
|
case "start conference":
|
|
case "fetch history":
|
|
response.StatusCode = (int)HttpStatusCode.OK;
|
|
break;
|
|
// Asking to start a P2P voice session. We need to generate a new session ID and return
|
|
// it to the client in a ChatterBoxSessionStartReply event.
|
|
case "start p2p voice":
|
|
UUID newSessionID;
|
|
if (reqmap.TryGetUUID("params", out UUID otherID))
|
|
newSessionID = new(otherID.ulonga ^ agentID.ulonga, otherID.ulongb ^ agentID.ulongb);
|
|
else
|
|
newSessionID = UUID.Random();
|
|
|
|
IEventQueue queue = scene.RequestModuleInterface<IEventQueue>();
|
|
if (queue is null)
|
|
{
|
|
m_log.Error($"{LogHeader}: no event queue for scene {scene.Name}");
|
|
response.StatusCode = (int)HttpStatusCode.InternalServerError;
|
|
}
|
|
else
|
|
{
|
|
queue.ChatterBoxSessionStartReply(
|
|
newSessionID,
|
|
sp.Name,
|
|
2,
|
|
false,
|
|
true,
|
|
sessionID,
|
|
true,
|
|
string.Empty,
|
|
agentID);
|
|
|
|
response.StatusCode = (int)HttpStatusCode.OK;
|
|
}
|
|
break;
|
|
case "call":
|
|
m_log.Debug($"{LogHeader}: ChatSessionRequest call: {reqmap}");
|
|
response.StatusCode = (int)HttpStatusCode.BadRequest;
|
|
break;
|
|
default:
|
|
response.StatusCode = (int)HttpStatusCode.BadRequest;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Convert the LLSDXml body of the request to an OSDMap for easier handling.
|
|
/// Also logs the request if message details is enabled.
|
|
/// </summary>
|
|
/// <param name="request"></param>
|
|
/// <param name="pCaller"></param>
|
|
/// <returns>'null' if the request body is empty or cannot be deserialized</returns>
|
|
private OSDMap BodyToMap(IOSHttpRequest request, string pCaller)
|
|
{
|
|
try
|
|
{
|
|
if (request.InputStream.Length > 0)
|
|
{
|
|
using Stream inputStream = request.InputStream;
|
|
OSD tmp = OSDParser.DeserializeLLSDXml(inputStream);
|
|
if (_MessageDetails)
|
|
m_log.Debug($"{pCaller} BodyToMap: Request: {tmp}");
|
|
if(tmp is OSDMap map)
|
|
return map;
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
m_log.Debug($"{pCaller} BodyToMap: Fail to decode LLSDXml request");
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
}
|