public void Startup(ConfigurationLoader loader)
{
IConfig config = loader.Config.Configs[GetType().FullName];
string inventoryServiceName = config.GetString("InventoryService");
m_InventoryService = loader.GetService <InventoryServiceInterface>(inventoryServiceName);
}
public static bool StartTransferLocal(
UUID transactionID,
UGUI dstAgent,
IReadOnlyList <IUserAgentServicePlugin> userAgentServicePlugins,
IReadOnlyList <IInventoryServicePlugin> inventoryServicePlugins,
IReadOnlyList <IAssetServicePlugin> assetServicePlugins,
UGUIWithName srcAgent,
InventoryServiceInterface srcInventoryService,
AssetServiceInterface srcAssetService,
AssetType givenAssetType,
UUID givenInventoryID,
IMServiceInterface imService,
Action <UUID> inventoryCreate = null) => StartTransfer(
transactionID,
dstAgent,
userAgentServicePlugins,
inventoryServicePlugins,
assetServicePlugins,
srcAgent,
null,
srcInventoryService,
srcAssetService,
givenAssetType,
givenInventoryID,
imService,
inventoryCreate);
public InventoryTransferWorkItem(
UUID transactionID,
UGUI dstAgent,
UserAgentServiceInterface dstUserAgentService,
InventoryServiceInterface dstInventoryService,
AssetServiceInterface dstAssetService,
UGUIWithName srcAgent,
InventoryServiceInterface srcInventoryService,
AssetServiceInterface srcAssetService,
UUID assetid,
InventoryItem item,
IMServiceInterface imService,
Action <UUID> inventoryCreate)
: base(dstAssetService, srcAssetService, assetid, ReferenceSource.Source)
{
m_TransactionID = transactionID;
m_DstUserAgentService = dstUserAgentService;
m_DstInventoryService = dstInventoryService;
m_SrcInventoryService = srcInventoryService;
m_DestinationAgent = dstAgent;
m_Item = item;
m_SrcAgent = srcAgent;
m_IMService = imService;
m_InventoryCreate = inventoryCreate;
}
public NewFileAgentInventoryBase(ViewerAgent agent, string serverURI, string remoteip)
: base(agent.Owner, serverURI, remoteip)
{
m_Agent = agent;
m_InventoryService = agent.InventoryService;
m_AssetService = agent.AssetService;
}
public void Startup(ConfigurationLoader loader)
{
HomeURI = loader.HomeURI;
m_AgentInventoryService = loader.GetService <InventoryServiceInterface>(m_AgentInventoryServiceName);
m_AgentAssetService = loader.GetService <AssetServiceInterface>(m_AgentAssetServiceName);
if (m_AgentProfileServiceName?.Length != 0)
{
m_AgentProfileService = loader.GetService <ProfileServiceInterface>(m_AgentProfileServiceName);
}
m_AgentFriendsService = loader.GetService <FriendsServiceInterface>(m_AgentFriendsServiceName);
m_UserSessionService = loader.GetService <UserSessionServiceInterface>(m_UserSessionServiceName);
m_GridService = loader.GetService <GridServiceInterface>(m_GridServiceName);
if (m_OfflineIMServiceName?.Length != 0)
{
m_OfflineIMService = loader.GetService <OfflineIMServiceInterface>(m_OfflineIMServiceName);
}
if (m_AgentExperienceServiceName?.Length != 0)
{
loader.GetService(m_AgentExperienceServiceName, out m_AgentExperienceService);
}
if (m_AgentGroupsServiceName?.Length != 0)
{
loader.GetService(m_AgentGroupsServiceName, out m_AgentGroupsService);
}
m_UserAccountService = loader.GetService <UserAccountServiceInterface>(m_UserAccountServiceName);
m_AgentUserAgentService = new LocalUserAgentService(m_UserSessionService, m_UserAccountService, m_RequiresInventoryIDAsIMSessionID, HomeURI);
m_Scenes = loader.Scenes;
m_Commands = loader.CommandRegistry;
m_CapsRedirector = loader.CapsRedirector;
m_PacketHandlerPlugins = loader.GetServicesByValue <IProtocolExtender>();
}
public static void StartTransferLocal(
UUID transactionID,
UGUI dstAgent,
UserAgentServiceInterface dstUserAgentService,
InventoryServiceInterface dstInventoryService,
AssetServiceInterface dstAssetService,
UGUIWithName srcAgent,
InventoryServiceInterface srcInventoryService,
AssetServiceInterface srcAssetService,
AssetType givenAssetType,
UUID givenInventoryID,
IMServiceInterface imService,
Action <UUID> inventoryCreate = null) => StartTransfer(
transactionID,
dstAgent,
dstUserAgentService,
dstInventoryService,
dstAssetService,
srcAgent,
null,
srcInventoryService,
srcAssetService,
givenAssetType,
givenInventoryID,
imService,
inventoryCreate);
private static UUID GetPath(
UGUI principalID,
InventoryServiceInterface inventoryService,
Dictionary <UUID, UUID> folders,
string path,
LoadOptions options)
{
path = path.Substring(10); /* Get Rid of inventory/ */
int slashPos = path.LastIndexOf('/');
if (slashPos >= 0)
{
path = path.Substring(0, slashPos);
}
string[] pathcomps = path.Split('/');
var finalpath = new StringBuilder();
UUID folderID = folders[string.Empty];
int pathidx = 0;
if ((options & LoadOptions.Merge) != 0 &&
pathcomps[0].StartsWith("MyInventory") &&
pathcomps[0].Length == 13 + 36)
{
pathidx = 1;
}
for (; pathidx < pathcomps.Length; ++pathidx)
{
if (finalpath.Length != 0)
{
finalpath.Append("/");
}
string uuidstr = pathcomps[pathidx].Substring(pathcomps[pathidx].Length - 36);
UUID nextfolderid = UUID.Parse(uuidstr);
string pname = pathcomps[pathidx].Substring(0, pathcomps[pathidx].Length - 38);
finalpath.Append(pname);
if (folders.ContainsKey(nextfolderid))
{
folderID = folders[nextfolderid];
}
else
{
var folder = new InventoryFolder
{
Owner = principalID,
ParentFolderID = folderID,
Name = EscapingMethods.UnescapeName(pname)
};
inventoryService.Folder.Add(folder);
folderID = folder.ID;
folders[nextfolderid] = folderID;
}
}
return(folderID);
}
public Request(HttpRequest req, InventoryServiceInterface inventoryService, UGUI agent, bool isLibrary, string rawPrefixUrl, string fullPrefixUrl)
{
HttpRequest = req;
InventoryService = inventoryService;
Agent = agent;
IsLibrary = isLibrary;
RawPrefixUrl = rawPrefixUrl;
FullPrefixUrl = fullPrefixUrl;
}
public void Startup(ConfigurationLoader loader)
{
IConfig config = loader.Config.Configs[GetType().FullName];
string inventoryServiceName = config.GetString("InventoryService");
m_InventoryService = loader.GetService <InventoryServiceInterface>(inventoryServiceName);
m_BackendInventoryService = loader.GetService <InventoryServiceInterface>(config.GetString("BackendInventoryService", inventoryServiceName));
m_UserID = new UGUI(config.GetString("User"));
}
public void HandleInventoryDeclined(ViewerAgent dstAgent, AgentCircuit circuit, Message m)
{
var im = (ImprovedInstantMessage)m;
UserAgentServiceInterface userAgentService = dstAgent.UserAgentService;
InventoryServiceInterface inventorySerice = dstAgent.InventoryService;
if (userAgentService == null)
{
return;
}
if (userAgentService.SupportsInventoryTransfer)
{
userAgentService.DeclineInventoryTransfer(dstAgent.ID, im.ID);
}
else
{
SceneInterface scene = circuit.Scene;
if (scene == null)
{
return;
}
UGUI toAgent;
if (!scene.AvatarNameService.TryGetValue(im.ToAgentID, out toAgent))
{
/* pass the unresolved here */
toAgent = new UGUI(im.ToAgentID);
}
InventoryFolder trashFolder;
if (userAgentService.RequiresInventoryIDAsIMSessionID &&
inventorySerice != null &&
inventorySerice.Folder.TryGetValue(dstAgent.ID, AssetType.TrashFolder, out trashFolder))
{
if (inventorySerice.Item.ContainsKey(dstAgent.ID, im.ID))
{
inventorySerice.Item.Move(dstAgent.ID, im.ID, trashFolder.ID);
}
else
{
inventorySerice.Folder.Move(dstAgent.ID, im.ID, trashFolder.ID);
}
}
m_IMService.Send(new GridInstantMessage
{
ToAgent = toAgent,
FromAgent = dstAgent.NamedOwner,
Message = string.Empty,
IMSessionID = im.ID,
Dialog = GridInstantMessageDialog.InventoryDeclined
});
}
}
public UpdateScriptAgent(
ViewerAgent agent,
InventoryServiceInterface inventoryService,
AssetServiceInterface assetService,
string serverURI,
string remoteip)
: base(agent.Owner, serverURI, remoteip)
{
m_Agent = agent;
m_InventoryService = inventoryService;
m_AssetService = assetService;
}
private bool TryGetServices(UGUI targetAgentId, out InventoryServiceInterface inventoryService, out AssetServiceInterface assetService)
{
UserAgentServiceInterface userAgentService = null;
inventoryService = null;
assetService = null;
if (targetAgentId.HomeURI == null)
{
return(false);
}
var homeUri = targetAgentId.HomeURI.ToString();
var heloheaders = ServicePluginHelo.HeloRequest(homeUri);
foreach (IUserAgentServicePlugin userAgentPlugin in UserAgentServicePlugins)
{
if (userAgentPlugin.IsProtocolSupported(homeUri, heloheaders))
{
userAgentService = userAgentPlugin.Instantiate(homeUri);
}
}
if (userAgentService == null)
{
return(false);
}
ServerURIs serverurls = userAgentService.GetServerURLs(targetAgentId);
string inventoryServerURI = serverurls.InventoryServerURI;
string assetServerURI = serverurls.AssetServerURI;
heloheaders = ServicePluginHelo.HeloRequest(inventoryServerURI);
foreach (IInventoryServicePlugin inventoryPlugin in InventoryServicePlugins)
{
if (inventoryPlugin.IsProtocolSupported(inventoryServerURI, heloheaders))
{
inventoryService = inventoryPlugin.Instantiate(inventoryServerURI);
break;
}
}
heloheaders = ServicePluginHelo.HeloRequest(assetServerURI);
foreach (IAssetServicePlugin assetPlugin in AssetServicePlugins)
{
if (assetPlugin.IsProtocolSupported(assetServerURI, heloheaders))
{
assetService = assetPlugin.Instantiate(assetServerURI);
break;
}
}
return(inventoryService != null && assetService != null);
}
public void Startup(ConfigurationLoader loader)
{
m_UserSessionService = loader.GetService <UserSessionServiceInterface>(m_UserSessionServiceName);
m_InventoryService = loader.GetService <InventoryServiceInterface>(m_InventoryServiceName);
m_UserAccountService = loader.GetService <UserAccountServiceInterface>(m_UserAccountServiceName);
m_HttpServer = loader.HttpServer;
m_HttpServer.StartsWithUriHandlers.Add("/UserCAPS/FetchInventoryDescendents2/", CapsHandler);
if (loader.TryGetHttpsServer(out m_HttpsServer))
{
m_HttpsServer.StartsWithUriHandlers.Add("/UserCAPS/FetchInventoryDescendents2/", CapsHandler);
}
}
public void Startup(ConfigurationLoader loader)
{
m_UserAccountService = loader.GetService <UserAccountServiceInterface>(m_UserAccountServiceName);
m_InventoryService = loader.GetService <InventoryServiceInterface>(m_InventoryServiceName);
m_AccountDeleteServices = loader.GetServicesByValue <IUserAccountDeleteServiceInterface>();
m_AuthInfoService = loader.GetService <AuthInfoServiceInterface>(m_AuthInfoServiceName);
m_ServiceURLsGetters = loader.GetServicesByValue <IServiceURLsGetInterface>();
loader.CommandRegistry.AddCreateCommand("user", CreateUserCommand);
loader.CommandRegistry.AddDeleteCommand("user", DeleteUserCommand);
loader.CommandRegistry.AddChangeCommand("user", ChangeUserCommand);
loader.CommandRegistry.AddShowCommand("user", ShowUserCommand);
loader.CommandRegistry.AddShowCommand("serviceurls", ShowServiceUrlsCommand);
loader.CommandRegistry.AddResetCommand("user", ResetUserPasswordCommand);
}
public ObjectTransferItem(
IAgent agent,
SceneInterface scene,
UUID assetid,
List <InventoryItem> items,
string destinationFolder = "")
: base(agent.AssetService, scene.AssetService, assetid, ReferenceSource.Source)
{
m_InventoryService = agent.InventoryService;
m_DestinationAgent = agent.Owner;
m_SceneID = scene.ID;
m_Items = items;
m_DestinationFolder = destinationFolder;
TryGetScene = scene.TryGetScene;
}
public NpcAgent(
UGUIWithName npcID,
AgentServiceList serviceList,
UUID sceneID)
: base(npcID.ID, npcID.HomeURI)
{
FirstName = npcID.FirstName;
LastName = npcID.LastName;
m_InventoryService = serviceList.Get <InventoryServiceInterface>();
m_ProfileService = serviceList.Get <ProfileServiceInterface>();
m_PresenceService = serviceList.Get <IPresenceServiceInterface>();
NpcPresenceService = serviceList.Get <NpcPresenceServiceInterface>();
m_UpdateInfo = new AgentUpdateInfo(this, sceneID);
OnAppearanceUpdate += HandleAppearanceUpdate;
}
public void Startup(ConfigurationLoader loader)
{
m_NpcInventoryService = loader.GetService <InventoryServiceInterface>(m_NpcInventoryServiceName);
m_NpcPresenceService = loader.GetService <NpcPresenceServiceInterface>(m_NpcPresenceServiceName);
m_NpcAssetService = loader.GetService <AssetServiceInterface>(m_NpcAssetServiceName);
foreach (string avatarNameService in m_AvatarNameServiceNames.Split(','))
{
if (!string.IsNullOrEmpty(avatarNameService))
{
m_AvatarNameServices.Add(loader.GetService <AvatarNameServiceInterface>(avatarNameService));
}
}
loader.CommandRegistry.AddLoadCommand("npc-iar", LoadIarCommand);
loader.CommandRegistry.AddSaveCommand("npc-iar", SaveIarCommand);
}
public void Startup(ConfigurationLoader loader)
{
List <IAdminWebIF> webifs = loader.GetServicesByValue <IAdminWebIF>();
if (webifs.Count > 0)
{
m_AdminWebIF = webifs[0];
m_AdminWebIF.JsonMethods.Add("npcs.show", HandleShowNpcs);
m_AdminWebIF.JsonMethods.Add("npc.remove", HandleRemoveNpc);
m_AdminWebIF.JsonMethods.Add("npc.get", HandleGetNpc);
m_AdminWebIF.AutoGrantRights["npcs.manage"].Add("npcs.view");
m_AdminWebIF.ModuleNames.Add("npcs");
}
/* non persistent inventory is needed for baking logic */
m_NonpersistentInventoryService = loader.GetService <InventoryServiceInterface>(m_NonpersistentInventoryServiceName);
m_NonpersistentAgentServices.Add(m_NonpersistentInventoryService);
m_NonpersistentAgentServices.Add(new NpcNonPersistentPresenceService());
/* persistence is optional */
if (!string.IsNullOrEmpty(m_NpcPresenceServiceName) || !string.IsNullOrEmpty(m_PersistentInventoryServiceName))
{
m_NpcPresenceService = loader.GetService <NpcPresenceServiceInterface>(m_NpcPresenceServiceName);
m_PersistentAgentServices.Add(m_NpcPresenceService);
m_PersistentInventoryService = loader.GetService <InventoryServiceInterface>(m_PersistentInventoryServiceName);
m_PersistentAgentServices.Add(m_PersistentInventoryService);
/* profile is optional */
if (!string.IsNullOrEmpty(m_PersistentProfileServiceName))
{
m_PersistentProfileService = loader.GetService <ProfileServiceInterface>(m_PersistentProfileServiceName);
m_PersistentAgentServices.Add(m_PersistentProfileService);
}
}
/* profile is optional */
if (!string.IsNullOrEmpty(m_NonpersistentProfileServiceName))
{
m_NonpersistentProfileService = loader.GetService <ProfileServiceInterface>(m_NonpersistentProfileServiceName);
m_NonpersistentAgentServices.Add(m_NonpersistentProfileService);
}
loader.Scenes.OnRegionAdd += OnSceneAdded;
loader.Scenes.OnRegionRemove += OnSceneRemoved;
loader.CommandRegistry.AddShowCommand("npcs", ShowNpcsCommand);
loader.CommandRegistry.AddRemoveCommand("npc", RemoveNpcCommand);
loader.CommandRegistry.AddCreateCommand("npc", CreateNpcCommand);
loader.CommandRegistry.AddRemoveAllCommand("npcs", RemoveAllNpcsCommand);
}
public void Startup(ConfigurationLoader loader)
{
loader.CommandRegistry.AddSaveCommand("iar", SaveIarCommand);
loader.CommandRegistry.AddLoadCommand("iar", LoadIarCommand);
m_AuthInfoService = loader.GetService <AuthInfoServiceInterface>(m_AuthInfoServiceName);
m_AssetService = loader.GetService <AssetServiceInterface>(m_AssetServiceName);
m_InventoryService = loader.GetService <InventoryServiceInterface>(m_InventoryServiceName);
m_UserAccountService = loader.GetService <UserAccountServiceInterface>(m_UserAccountServiceName);
foreach (string avatarNameService in m_AvatarNameServiceNames.Split(','))
{
if (!string.IsNullOrEmpty(avatarNameService))
{
m_AvatarNameServices.Add(loader.GetService <AvatarNameServiceInterface>(avatarNameService));
}
}
}
public ObjectTransferItem(
InventoryServiceInterface inventoryService,
AssetServiceInterface assetService,
UGUI agentOwner,
SceneInterface scene,
List <UUID> assetids,
List <InventoryItem> items,
AssetType destinationFolderType)
: base(assetService, scene.AssetService, assetids, ReferenceSource.Source)
{
m_InventoryService = inventoryService;
m_DestinationAgent = agentOwner;
m_SceneID = scene.ID;
m_Items = items;
m_DestinationFolderType = destinationFolderType;
TryGetScene = scene.TryGetScene;
}
private static TransferInventoryFolder GetTree(InventoryServiceInterface inventoryService, InventoryFolder baseFolder, List <UUID> assetids)
{
TransferInventoryFolder catBase = new TransferInventoryFolder(baseFolder);
List <TransferInventoryFolder> collect = new List <TransferInventoryFolder>
{
catBase
};
while (collect.Count != 0)
{
InventoryFolderContent content;
TransferInventoryFolder cat = collect[0];
if (inventoryService.Folder.Content.TryGetValue(cat.Owner.ID, cat.ID, out content))
{
foreach (InventoryItem item in content.Items)
{
if (item.AssetType != AssetType.Link && item.AssetType != AssetType.LinkFolder)
{
if (!item.CheckPermissions(cat.Owner, UGI.Unknown, InventoryPermissionsMask.Transfer))
{
return(null);
}
assetids.Add(item.AssetID);
cat.Items.Add(item);
}
}
foreach (InventoryFolder folder in content.Folders)
{
var childFolder = new TransferInventoryFolder(folder);
collect.Add(childFolder);
cat.Folders.Add(childFolder);
}
}
cat.ID = UUID.Random;
collect.RemoveAt(0);
}
return(catBase);
}
public ViewerAgent(
SceneList scenes,
UUID agentID,
string firstName,
string lastName,
Uri homeURI,
UUID sessionID,
UUID secureSessionID,
ClientInfo clientInfo,
UserAccount untrustedAccountInfo,
AgentServiceList serviceList)
: base(agentID, homeURI)
{
m_Scenes = scenes;
m_TeleportServices = serviceList.GetAll <IAgentTeleportServiceInterface>();
foreach (IAgentTeleportServiceInterface service in m_TeleportServices)
{
service.Agent = this;
}
CollisionPlane = Vector4.UnitW;
SessionID = sessionID;
m_UntrustedAccountInfo = untrustedAccountInfo;
m_SecureSessionID = secureSessionID;
Client = clientInfo;
m_AssetService = serviceList.Get <AssetServiceInterface>();
m_InventoryService = serviceList.Get <InventoryServiceInterface>();
m_GroupsService = serviceList.Get <GroupsServiceInterface>();
m_ExperienceService = serviceList.Get <ExperienceServiceInterface>();
m_ProfileService = serviceList.Get <ProfileServiceInterface>();
m_FriendsService = serviceList.Get <FriendsServiceInterface>();
m_UserAgentService = serviceList.Get <UserAgentServiceInterface>();
m_PresenceService = serviceList.Get <IPresenceServiceInterface>();
EconomyService = serviceList.Get <EconomyServiceInterface>();
OfflineIMService = serviceList.Get <OfflineIMServiceInterface>();
MuteListService = serviceList.Get <MuteListServiceInterface>();
FirstName = firstName;
LastName = lastName;
OnPositionChange += ChildUpdateOnPositionChange;
OnAppearanceUpdate += HandleAppearanceUpdate;
}
private void HandleDeclineCallingCard(Message m)
{
var req = (DeclineCallingCard)m;
if (req.AgentID != req.CircuitAgentID ||
req.SessionID != req.CircuitSessionID)
{
return;
}
SceneInterface scene;
if (!m_Scenes.TryGetValue(req.CircuitSceneID, out scene))
{
return;
}
IAgent agent;
if (!scene.Agents.TryGetValue(req.AgentID, out agent))
{
return;
}
InventoryServiceInterface inventoryService = agent.InventoryService;
if (inventoryService == null)
{
return;
}
InventoryFolder folder;
if (inventoryService.Folder.TryGetValue(req.AgentID, AssetType.TrashFolder, out folder))
{
inventoryService.Item.Move(req.AgentID, req.TransactionID, folder.ID);
}
}
public static void Save(
UGUI principal,
InventoryServiceInterface inventoryService,
AssetServiceInterface assetService,
List <AvatarNameServiceInterface> nameServices,
SaveOptions options,
string fileName,
string frompath,
TTY console_io = null)
{
UUID parentFolder = inventoryService.Folder[principal.ID, AssetType.RootFolder].ID;
if (!frompath.StartsWith("/"))
{
throw new InvalidInventoryPathException();
}
foreach (string pathcomp in frompath.Substring(1).Split('/'))
{
List <InventoryFolder> childfolders = inventoryService.Folder.GetFolders(principal.ID, parentFolder);
int idx;
for (idx = 0; idx < childfolders.Count; ++idx)
{
if (pathcomp.ToLower() == childfolders[idx].Name.ToLower())
{
break;
}
}
if (idx == childfolders.Count)
{
throw new InvalidInventoryPathException();
}
parentFolder = childfolders[idx].ID;
}
}
public static bool StartTransfer(
UUID transactionID,
UGUI dstAgent,
IReadOnlyList <IUserAgentServicePlugin> userAgentServicePlugins,
IReadOnlyList <IInventoryServicePlugin> inventoryServicePlugins,
IReadOnlyList <IAssetServicePlugin> assetServicePlugins,
UGUIWithName srcAgent,
UserAgentServiceInterface srcUserAgentService,
InventoryServiceInterface srcInventoryService,
AssetServiceInterface srcAssetService,
AssetType givenAssetType,
UUID givenInventoryID,
IMServiceInterface imService,
Action <UUID> inventoryCreate = null)
{
InventoryServiceInterface dstInventoryService = null;
AssetServiceInterface dstAssetService = null;
UserAgentServiceInterface dstUserAgentService = null;
if (dstAgent.HomeURI == null)
{
m_Log.ErrorFormat("No route to agent id {0}", dstAgent.ID);
return(false);
}
var homeUri = dstAgent.HomeURI.ToString();
var heloheaders = ServicePluginHelo.HeloRequest(homeUri);
foreach (IUserAgentServicePlugin userAgentPlugin in userAgentServicePlugins)
{
if (userAgentPlugin.IsProtocolSupported(homeUri, heloheaders))
{
dstUserAgentService = userAgentPlugin.Instantiate(homeUri);
}
}
if (dstUserAgentService == null)
{
m_Log.ErrorFormat("No user agent service found to agent id {0}", dstAgent.ID);
return(false);
}
ServerURIs uris = dstUserAgentService.GetServerURLs(dstAgent);
heloheaders = ServicePluginHelo.HeloRequest(uris.AssetServerURI);
foreach (IAssetServicePlugin assetPlugin in assetServicePlugins)
{
if (assetPlugin.IsProtocolSupported(homeUri, heloheaders))
{
dstAssetService = assetPlugin.Instantiate(homeUri);
}
}
if (dstAssetService == null)
{
m_Log.ErrorFormat("No asset service found to agent id {0}", dstAgent.ID);
return(false);
}
heloheaders = ServicePluginHelo.HeloRequest(uris.InventoryServerURI);
foreach (IInventoryServicePlugin inventoryPlugin in inventoryServicePlugins)
{
if (inventoryPlugin.IsProtocolSupported(homeUri, heloheaders))
{
dstInventoryService = inventoryPlugin.Instantiate(homeUri);
}
}
if (dstInventoryService == null)
{
m_Log.ErrorFormat("No inventory service found to agent id {0}", dstAgent.ID);
return(false);
}
StartTransfer(
transactionID,
dstAgent,
dstUserAgentService,
dstInventoryService,
dstAssetService,
srcAgent,
srcUserAgentService,
srcInventoryService,
srcAssetService,
givenAssetType,
givenInventoryID,
imService,
inventoryCreate);
return(true);
}
public NpcAgent CreateNpc(UUID sceneid, UGUI owner, UGI group, string firstName, string lastName, Vector3 position, Notecard nc, NpcOptions options = NpcOptions.None)
{
SceneInterface scene;
AgentServiceList agentServiceList = m_NonpersistentAgentServices;
if ((options & NpcOptions.Persistent) != NpcOptions.None)
{
if (m_NpcPresenceService == null)
{
throw new InvalidOperationException("Persistence of NPCs not configured");
}
agentServiceList = m_PersistentAgentServices;
}
NpcPresenceServiceInterface presenceService = agentServiceList.Get <NpcPresenceServiceInterface>();
InventoryServiceInterface inventoryService = agentServiceList.Get <InventoryServiceInterface>();
var npcId = new UGUIWithName
{
ID = UUID.Random,
FirstName = firstName,
LastName = lastName
};
if (m_KnownScenes.TryGetValue(sceneid, out scene))
{
var agent = new NpcAgent(npcId, agentServiceList, sceneid)
{
NpcOwner = owner,
Group = group
};
try
{
m_NpcAgents.Add(agent.ID, agent);
var npcInfo = new NpcPresenceInfo
{
RegionID = sceneid,
Npc = agent.NamedOwner,
Owner = agent.NpcOwner,
Group = agent.Group,
};
inventoryService.CheckInventory(npcInfo.Npc.ID);
presenceService.Store(npcInfo);
agent.CurrentScene = scene;
agent.Position = position;
scene.Add(agent);
}
catch
{
if (m_NpcPresenceService != null)
{
presenceService.Remove(agent.ID);
}
inventoryService.Remove(agent.ID);
m_NpcAgents.Remove(agent.ID);
throw;
}
agent.EnableListen();
scene.SendAgentObjectToAllAgents(agent);
agent.SendAnimations();
ThreadPool.QueueUserWorkItem(LoadAppearanceFromNotecardJob, new RebakeJob {
Notecard = nc, Agent = agent
});
return(agent);
}
throw new KeyNotFoundException("Scene not found");
}
public void Startup(ConfigurationLoader loader)
{
IConfig config = loader.Config.Configs[GetType().FullName];
m_AssetService = loader.GetService <AssetServiceInterface>(config.GetString("AssetService"));
m_InventoryService = loader.GetService <InventoryServiceInterface>(config.GetString("InventoryService"));
m_RootFolderID = new UUID(config.GetString("RootFolderID"));
m_AgentOwner = new UGUI(config.GetString("Owner"));
m_BakeEyesFilename = config.GetString("BakeEyeFilename", string.Empty);
m_BakeHeadFilename = config.GetString("BakeHeadFilename", string.Empty);
m_BakeUpperFilename = config.GetString("BakeUpperFilename", string.Empty);
m_BakeLowerFilename = config.GetString("BakeLowerFilename", string.Empty);
m_BakeHairFilename = config.GetString("BakeHairFilename", string.Empty);
m_BakeSkirtFilename = config.GetString("BakeSkirtFilename", string.Empty);
m_ReferenceBakeEyesFilename = config.GetString("ReferenceBakeEyeFilename", string.Empty);
m_ReferenceBakeHeadFilename = config.GetString("ReferenceBakeHeadFilename", string.Empty);
m_ReferenceBakeUpperFilename = config.GetString("ReferenceBakeUpperFilename", string.Empty);
m_ReferenceBakeLowerFilename = config.GetString("ReferenceBakeLowerFilename", string.Empty);
m_ReferenceBakeHairFilename = config.GetString("ReferenceBakeHairFilename", string.Empty);
m_ReferenceBakeSkirtFilename = config.GetString("ReferenceBakeSkirtFilename", string.Empty);
double tolerance = config.GetDouble("ReferenceBakeTolerance", 0);
m_ReferenceBakeEyesTolerance = config.GetDouble("ReferenceBakeEyesTolerance", tolerance);
m_ReferenceBakeHeadTolerance = config.GetDouble("ReferenceBakeHeadTolerance", tolerance);
m_ReferenceBakeUpperTolerance = config.GetDouble("ReferenceBakeUpperTolerance", tolerance);
m_ReferenceBakeLowerTolerance = config.GetDouble("ReferenceBakeLowerTolerance", tolerance);
m_ReferenceBakeHairTolerance = config.GetDouble("ReferenceBakeHairTolerance", tolerance);
m_ReferenceBakeSkirtTolerance = config.GetDouble("ReferenceBakeSkirtTolerance", tolerance);
if (config.Contains("ReferenceVisualParams"))
{
m_ReferenceVisualParams = Convert.FromBase64String(config.GetString("ReferenceVisualParams"));
}
foreach (string key in config.GetKeys())
{
UUID id;
AvatarTextureIndex atIdx;
if (key.StartsWith("Folder-") && UUID.TryParse(key.Substring(7), out id))
{
m_InventoryFolders[id] = config.GetString(key);
}
else if (key.StartsWith("FolderParent-") && UUID.TryParse(key.Substring(13), out id))
{
m_InventoryFolderParents[id] = new UUID(config.GetString(key));
}
else if (key.StartsWith("FolderType-") && UUID.TryParse(key.Substring(11), out id))
{
m_InventoryFolderTypes[id] = (AssetType)config.GetInt(key);
}
else if (key.StartsWith("Item-") && UUID.TryParse(key.Substring(5), out id))
{
m_InventoryFiles[id] = config.GetString(key);
}
else if (key.StartsWith("ItemParent-") && UUID.TryParse(key.Substring(11), out id))
{
m_InventoryItemParents[id] = new UUID(config.GetString(key));
}
else if (key.StartsWith("ItemAssetID-") && UUID.TryParse(key.Substring(12), out id))
{
m_InventoryItemAssetIDs[id] = new UUID(config.GetString(key));
}
else if (key.StartsWith("ItemIsLink-") && UUID.TryParse(key.Substring(11), out id))
{
m_AssetLinkDescriptions[id] = config.GetString(key);
}
else if (key.StartsWith("Asset-") && UUID.TryParse(key.Substring(6), out id))
{
m_AssetFiles[id] = config.GetString(key);
}
else if (key.StartsWith("ExpectedIdAt-") && Enum.TryParse(key.Substring(13), out atIdx))
{
m_ExpectedTextureIDs[atIdx] = UUID.Parse(config.GetString(key));
}
}
}
protected static void HandleHttpRequest(HttpRequest httpreq, InventoryServiceInterface inventoryService, UUID agentID, UUID ownerID)
{
IValue o;
if (httpreq.Method != "POST")
{
httpreq.ErrorResponse(HttpStatusCode.MethodNotAllowed, "Method not allowed");
return;
}
try
{
o = LlsdXml.Deserialize(httpreq.Body);
}
catch (Exception e)
{
m_Log.WarnFormat("Invalid LLSD_XML: {0} {1}", e.Message, e.StackTrace);
httpreq.ErrorResponse(HttpStatusCode.UnsupportedMediaType, "Unsupported Media Type");
return;
}
var reqmap = o as Map;
if (reqmap == null)
{
httpreq.ErrorResponse(HttpStatusCode.BadRequest, "Misformatted LLSD-XML");
return;
}
using (var res = httpreq.BeginResponse("application/llsd+xml"))
using (var text = res.GetOutputStream().UTF8XmlTextWriter())
{
var baditems = new List <UUID>();
text.WriteStartElement("llsd");
text.WriteStartElement("map");
text.WriteKeyValuePair("agent_id", agentID);
bool wroteheader = false;
foreach (var iv in (AnArray)reqmap["items"])
{
var itemmap = iv as Map;
if (itemmap == null)
{
continue;
}
if (!itemmap.ContainsKey("item_id"))
{
continue;
}
var itemid = itemmap["item_id"].AsUUID;
InventoryItem item;
if (itemid == UUID.Zero)
{
baditems.Add(itemid);
continue;
}
try
{
item = inventoryService.Item[ownerID, itemid];
}
catch
{
baditems.Add(itemid);
continue;
}
if (!wroteheader)
{
wroteheader = true;
text.WriteNamedValue("key", "items");
text.WriteStartElement("array");
}
text.WriteStartElement("map");
WriteInventoryItem(item, text, agentID);
text.WriteEndElement();
}
if (wroteheader)
{
text.WriteEndElement();
}
if (baditems.Count != 0)
{
text.WriteStartElement("key");
text.WriteValue("bad_items");
text.WriteEndElement();
text.WriteStartElement("array");
foreach (var id in baditems)
{
text.WriteNamedValue("uuid", id);
}
text.WriteEndElement();
}
text.WriteEndElement();
text.WriteEndElement();
}
}
protected static void HandleHttpRequest(HttpRequest httpreq, InventoryServiceInterface inventoryService, UUID agentID, UUID requestingOwnerID)
{
IValue o;
if (httpreq.Method != "POST")
{
httpreq.ErrorResponse(HttpStatusCode.MethodNotAllowed, "Method not allowed");
return;
}
try
{
o = LlsdXml.Deserialize(httpreq.Body);
}
catch (Exception e)
{
m_Log.WarnFormat("Invalid LLSD_XML: {0} {1}", e.Message, e.StackTrace);
httpreq.ErrorResponse(HttpStatusCode.UnsupportedMediaType, "Unsupported Media Type");
return;
}
var reqmap = o as Map;
if (reqmap == null)
{
httpreq.ErrorResponse(HttpStatusCode.BadRequest, "Misformatted LLSD-XML");
return;
}
using (var res = httpreq.BeginResponse("application/llsd+xml"))
{
using (var text = res.GetOutputStream().UTF8XmlTextWriter())
{
var badfolders = new Dictionary <UUID, string>();
text.WriteStartElement("llsd");
text.WriteStartElement("map");
var wroteheader = false;
var folderRequests = new Dictionary <UUID, List <Map> >();
var foldersreqarray = (AnArray)reqmap["folders"];
foreach (var iv1 in foldersreqarray)
{
var itemmap = iv1 as Map;
if (itemmap == null)
{
continue;
}
if (!itemmap.ContainsKey("folder_id") ||
!itemmap.ContainsKey("fetch_folders") ||
!itemmap.ContainsKey("fetch_items"))
{
continue;
}
var ownerid = itemmap["owner_id"].AsUUID;
if (!folderRequests.ContainsKey(ownerid))
{
folderRequests[ownerid] = new List <Map>();
}
folderRequests[ownerid].Add(itemmap);
}
var folderContents = new Dictionary <UUID, Dictionary <UUID, InventoryFolderContent> >();
foreach (var req in folderRequests)
{
var list = new List <UUID>();
foreach (var fm in req.Value)
{
if (fm["folder_id"].AsUUID != UUID.Zero && !list.Contains(fm["folder_id"].AsUUID))
{
list.Add(fm["folder_id"].AsUUID);
}
}
try
{
foreach (var folderContent in inventoryService.Folder.Content[requestingOwnerID, list.ToArray()])
{
if (!folderContents.ContainsKey(req.Key))
{
folderContents.Add(req.Key, new Dictionary <UUID, InventoryFolderContent>());
}
folderContents[req.Key][folderContent.FolderID] = folderContent;
}
}
catch
{
/* no action required */
}
}
foreach (var iv in foldersreqarray)
{
var itemmap = iv as Map;
if (iv == null)
{
continue;
}
if (!itemmap.ContainsKey("folder_id") ||
!itemmap.ContainsKey("fetch_folders") ||
!itemmap.ContainsKey("fetch_items"))
{
continue;
}
var folderid = itemmap["folder_id"].AsUUID;
var ownerid = itemmap["owner_id"].AsUUID;
bool fetch_folders = itemmap["fetch_folders"].AsBoolean;
bool fetch_items = itemmap["fetch_items"].AsBoolean;
if (folderContents.ContainsKey(ownerid))
{
if (folderContents[ownerid].ContainsKey(folderid))
{
var fc = folderContents[ownerid][folderid];
if (!wroteheader)
{
wroteheader = true;
text.WriteNamedValue("key", "folders");
text.WriteStartElement("array");
}
WriteInventoryFolderContent(text, fc, fetch_folders, fetch_items, agentID);
}
else if (!badfolders.ContainsKey(folderid))
{
badfolders.Add(folderid, "Not found");
}
}
else if (!badfolders.ContainsKey(folderid))
{
badfolders.Add(folderid, "Not found");
}
}
if (wroteheader)
{
text.WriteEndElement();
}
if (badfolders.Count != 0)
{
text.WriteNamedValue("key", "bad_folders");
text.WriteStartElement("array");
foreach (KeyValuePair <UUID, string> id in badfolders)
{
text.WriteStartElement("map");
text.WriteNamedValue("folder_id", id.Key);
text.WriteNamedValue("error", id.Value);
text.WriteEndElement();
}
text.WriteEndElement();
}
text.WriteEndElement();
text.WriteEndElement();
}
}
}
public static void StartTransfer(
UUID transactionID,
UGUI dstAgent,
UserAgentServiceInterface dstUserAgentService,
InventoryServiceInterface dstInventoryService,
AssetServiceInterface dstAssetService,
UGUIWithName srcAgent,
UserAgentServiceInterface srcUserAgentService,
InventoryServiceInterface srcInventoryService,
AssetServiceInterface srcAssetService,
AssetType givenAssetType,
UUID givenInventoryID,
IMServiceInterface imService,
Action <UUID> inventoryCreate = null)
{
if (dstUserAgentService == null)
{
throw new ArgumentNullException(nameof(dstUserAgentService));
}
if (dstInventoryService == null)
{
throw new ArgumentNullException(nameof(dstInventoryService));
}
if (dstAssetService == null)
{
throw new ArgumentNullException(nameof(dstAssetService));
}
if (srcInventoryService == null)
{
throw new ArgumentNullException(nameof(srcInventoryService));
}
if (srcAssetService == null)
{
throw new ArgumentNullException(nameof(srcAssetService));
}
if (imService == null)
{
throw new ArgumentNullException(nameof(imService));
}
if (srcUserAgentService != null && srcUserAgentService.SupportsInventoryTransfer)
{
srcUserAgentService.InitiateInventoryTransfer(dstAgent, srcAgent, givenAssetType, givenInventoryID, transactionID);
return;
}
if (givenAssetType == AssetType.Folder)
{
InventoryFolder folder;
#if DEBUG
m_Log.DebugFormat("Sending folder {0} from {1} to {2}", givenInventoryID, srcAgent, dstAgent);
#endif
if (srcInventoryService.Folder.TryGetValue(srcAgent.ID, givenInventoryID, out folder))
{
/* this has a whole bunch of such entries, but later only the first 17 bytes are kept and adjusted */
var assetids = new List <UUID>();
TransferInventoryFolder transferFolder = GetTree(srcInventoryService, folder, assetids);
if (transferFolder != null)
{
new InventoryTransferWorkItem(
transactionID,
dstAgent,
dstUserAgentService,
dstInventoryService,
dstAssetService,
srcAgent,
srcInventoryService,
srcAssetService,
assetids,
transferFolder,
imService,
inventoryCreate).QueueWorkItem();
}
}
else
{
#if DEBUG
m_Log.DebugFormat("Sending folder {0} from {1} to {2}: Not found", givenInventoryID, srcAgent, dstAgent);
#endif
}
}
else
{
#if DEBUG
m_Log.DebugFormat("Sending item {0} from {1} to {2}", givenInventoryID, srcAgent, dstAgent);
#endif
/* just some item */
InventoryItem item;
if (srcInventoryService.Item.TryGetValue(srcAgent.ID, givenInventoryID, out item) &&
item.AssetType != AssetType.Link && item.AssetType != AssetType.LinkFolder &&
item.CheckPermissions(srcAgent, UGI.Unknown, InventoryPermissionsMask.Transfer))
{
new InventoryTransferWorkItem(
transactionID,
dstAgent,
dstUserAgentService,
dstInventoryService,
dstAssetService,
srcAgent,
srcInventoryService,
dstAssetService,
item.AssetID,
item,
imService,
inventoryCreate).QueueWorkItem();
}
else
{
#if DEBUG
m_Log.DebugFormat("Sending item {0} from {1} to {2}: Not found", givenInventoryID, srcAgent, dstAgent);
#endif
}
}
}
