bool FSExportPermsCheck::canExportAsset(LLUUID asset_id, std::string* name, std::string* description)
{
bool exportable = false;
LLViewerInventoryCategory::cat_array_t cats;
LLViewerInventoryItem::item_array_t items;
LLAssetIDMatches asset_id_matches(asset_id);
gInventory.collectDescendentsIf(LLUUID::null,
cats,
items,
LLInventoryModel::INCLUDE_TRASH,
asset_id_matches);
if (items.size())
{
// use the name of the first match
(*name) = items[0]->getName();
(*description) = items[0]->getDescription();
for (S32 i = 0; i < items.size(); ++i)
{
if (!exportable)
{
LLPermissions perms = items[i]->getPermissions();
#ifdef OPENSIM
if (LLGridManager::getInstance()->isInOpenSim())
{
switch (LFSimFeatureHandler::instance().exportPolicy())
{
case EXPORT_ALLOWED:
exportable = (perms.getMaskOwner() & PERM_EXPORT) == PERM_EXPORT;
break;
/// TODO: Once enough grids adopt a version supporting exports, get consensus
/// on whether we should allow full perm exports anymore.
case EXPORT_UNDEFINED:
exportable = (perms.getMaskBase() & PERM_ITEM_UNRESTRICTED) == PERM_ITEM_UNRESTRICTED;
break;
case EXPORT_DENIED:
default:
exportable = perms.getCreator() == gAgentID;
break;
}
}
#endif
if (LLGridManager::getInstance()->isInSecondLife() && (perms.getCreator() == gAgentID))
{
exportable = true;
}
}
}
}
return exportable;
}
// static
bool primbackup::check_perms( LLSelectNode* node )
{
LLPermissions *perms = node->mPermissions;
return (gAgent.getID() == perms->getOwner() &&
gAgent.getID() == perms->getCreator() &&
(PERM_ITEM_UNRESTRICTED &
perms->getMaskOwner()) == PERM_ITEM_UNRESTRICTED);
}
S32 LLInventoryItem::packBinaryBucket(U8* bin_bucket, LLPermissions* perm_override) const
{
// Figure out which permissions to use.
LLPermissions perm;
if (perm_override)
{
// Use the permissions override.
perm = *perm_override;
}
else
{
// Use the current permissions.
perm = getPermissions();
}
// describe the inventory item
char* buffer = (char*) bin_bucket;
std::string creator_id_str;
perm.getCreator().toString(creator_id_str);
std::string owner_id_str;
perm.getOwner().toString(owner_id_str);
std::string last_owner_id_str;
perm.getLastOwner().toString(last_owner_id_str);
std::string group_id_str;
perm.getGroup().toString(group_id_str);
std::string asset_id_str;
getAssetUUID().toString(asset_id_str);
S32 size = sprintf(buffer, /* Flawfinder: ignore */
"%d|%d|%s|%s|%s|%s|%s|%x|%x|%x|%x|%x|%s|%s|%d|%d|%x",
getType(),
getInventoryType(),
getName().c_str(),
creator_id_str.c_str(),
owner_id_str.c_str(),
last_owner_id_str.c_str(),
group_id_str.c_str(),
perm.getMaskBase(),
perm.getMaskOwner(),
perm.getMaskGroup(),
perm.getMaskEveryone(),
perm.getMaskNextOwner(),
asset_id_str.c_str(),
getDescription().c_str(),
getSaleInfo().getSaleType(),
getSaleInfo().getSalePrice(),
getFlags()) + 1;
return size;
}
void permission_object_t::test<2>()
{
LLPermissions permissions;
LLUUID creator("abf0d56b-82e5-47a2-a8ad-74741bb2c29e");
LLUUID owner("68edcf47-ccd7-45b8-9f90-1649d7f12806");
LLUUID lastOwner("5e47a0dc-97bf-44e0-8b40-de06718cee9d");
LLUUID group("9c8eca51-53d5-42a7-bb58-cef070395db8");
permissions.init(creator, owner, lastOwner, group);
ensure_equals("init/getCreator():failed to return the creator ", creator, permissions.getCreator());
ensure_equals("init/getOwner():failed to return the owner ", owner, permissions.getOwner());
ensure_equals("init/getLastOwner():failed to return the group ", lastOwner, permissions.getLastOwner());
ensure_equals("init/getGroup():failed to return the group ", group, permissions.getGroup());
}
void permission_object_t::test<1>()
{
LLPermissions permissions;
LLUUID uuid = permissions.getCreator();
LLUUID uuid1 = permissions.getOwner();
LLUUID uuid2 = permissions.getGroup();
LLUUID uuid3 = permissions.getLastOwner();
ensure("LLPermission Get Functions failed", (uuid == LLUUID::null && uuid1 == LLUUID::null &&
uuid2 == LLUUID::null && uuid3 == LLUUID::null));
ensure("LLPermission Get Functions failed", (permissions.getMaskBase() == PERM_ALL && permissions.getMaskOwner() == PERM_ALL &&
permissions.getMaskGroup() == PERM_ALL && permissions.getMaskEveryone() == PERM_ALL && permissions.getMaskNextOwner() == PERM_ALL));
ensure("Ownership functions failed", (permissions.isGroupOwned() == FALSE && permissions.isOwned() == FALSE));
}
LLSD ll_create_sd_from_permissions(const LLPermissions& perm)
{
LLSD rv;
rv[PERM_CREATOR_ID_LABEL] = perm.getCreator();
rv[PERM_OWNER_ID_LABEL] = perm.getOwner();
rv[PERM_LAST_OWNER_ID_LABEL] = perm.getLastOwner();
rv[PERM_GROUP_ID_LABEL] = perm.getGroup();
rv[PERM_IS_OWNER_GROUP_LABEL] = perm.isGroupOwned();
rv[PERM_BASE_MASK_LABEL] = (S32)perm.getMaskBase();
rv[PERM_OWNER_MASK_LABEL] = (S32)perm.getMaskOwner();
rv[PERM_GROUP_MASK_LABEL] = (S32)perm.getMaskGroup();
rv[PERM_EVERYONE_MASK_LABEL] = (S32)perm.getMaskEveryone();
rv[PERM_NEXT_OWNER_MASK_LABEL] = (S32)perm.getMaskNextOwner();
return rv;
}
// Allow calling cards to be dropped onto text fields. Append the name and
// a carriage return.
// virtual
BOOL LLViewerTextEditor::handleDragAndDrop(S32 x, S32 y, MASK mask,
BOOL drop, EDragAndDropType cargo_type, void *cargo_data,
EAcceptance *accept,
std::string& tooltip_msg)
{
BOOL handled = FALSE;
LLToolDragAndDrop::ESource source = LLToolDragAndDrop::getInstance()->getSource();
if (LLToolDragAndDrop::SOURCE_NOTECARD == source)
{
// We currently do not handle dragging items from one notecard to another
// since items in a notecard must be in Inventory to be verified. See DEV-2891.
return FALSE;
}
if (mTakesNonScrollClicks)
{
if (getEnabled() && acceptsTextInput())
{
switch( cargo_type )
{
// <edit>
// This does not even appear to be used maybe
// Throwing it out so I can embed calling cards
/*
case DAD_CALLINGCARD:
if(acceptsCallingCardNames())
{
if (drop)
{
LLInventoryItem *item = (LLInventoryItem *)cargo_data;
std::string name = item->getName();
appendText(name, true, true);
}
*accept = ACCEPT_YES_COPY_SINGLE;
}
else
{
*accept = ACCEPT_NO;
}
break;
*/
case DAD_CALLINGCARD:
// </edit>
case DAD_TEXTURE:
case DAD_SOUND:
case DAD_LANDMARK:
case DAD_SCRIPT:
case DAD_CLOTHING:
case DAD_OBJECT:
case DAD_NOTECARD:
case DAD_BODYPART:
case DAD_ANIMATION:
case DAD_GESTURE:
{
LLInventoryItem *item = (LLInventoryItem *)cargo_data;
// <edit>
if((item->getPermissions().getMaskOwner() & PERM_ITEM_UNRESTRICTED) != PERM_ITEM_UNRESTRICTED)
{
if(gSavedSettings.getBOOL("ForceNotecardDragCargoPermissive"))
{
item = new LLInventoryItem((LLInventoryItem *)cargo_data);
LLPermissions old = item->getPermissions();
LLPermissions perm;
perm.init(old.getCreator(), old.getOwner(), old.getLastOwner(), old.getGroup());
perm.setMaskBase(PERM_ITEM_UNRESTRICTED);
perm.setMaskEveryone(PERM_ITEM_UNRESTRICTED);
perm.setMaskGroup(PERM_ITEM_UNRESTRICTED);
perm.setMaskNext(PERM_ITEM_UNRESTRICTED);
perm.setMaskOwner(PERM_ITEM_UNRESTRICTED);
item->setPermissions(perm);
}
}
// </edit>
if( item && allowsEmbeddedItems() )
{
U32 mask_next = item->getPermissions().getMaskNextOwner();
// <edit>
//if((mask_next & PERM_ITEM_UNRESTRICTED) == PERM_ITEM_UNRESTRICTED)
if(((mask_next & PERM_ITEM_UNRESTRICTED) == PERM_ITEM_UNRESTRICTED) || gSavedSettings.getBOOL("ForceNotecardDragCargoAcceptance"))
{
if( drop )
{
deselect();
S32 old_cursor = mCursorPos;
setCursorAtLocalPos( x, y, TRUE );
S32 insert_pos = mCursorPos;
setCursorPos(old_cursor);
BOOL inserted = insertEmbeddedItem( insert_pos, item );
if( inserted && (old_cursor > mCursorPos) )
{
setCursorPos(mCursorPos + 1);
}
updateLineStartList();
}
*accept = ACCEPT_YES_COPY_MULTI;
}
else
{
*accept = ACCEPT_NO;
if (tooltip_msg.empty())
{
tooltip_msg.assign("Only items with unrestricted\n"
"'next owner' permissions \n"
"can be attached to notecards.");
}
}
}
else
{
*accept = ACCEPT_NO;
}
break;
}
default:
*accept = ACCEPT_NO;
break;
}
}
else
{
// Not enabled
*accept = ACCEPT_NO;
}
handled = TRUE;
LL_DEBUGS("UserInput") << "dragAndDrop handled by LLViewerTextEditor " << getName() << LL_ENDL;
}
return handled;
}
bool FSExportPermsCheck::canExportNode(LLSelectNode* node, bool dae)
{
if (!node)
{
LL_WARNS("export") << "No node, bailing!" << LL_ENDL;
return false;
}
bool exportable = false;
LLViewerObject* object = node->getObject();
if (LLGridManager::getInstance()->isInSecondLife())
{
LLUUID creator(node->mPermissions->getCreator());
exportable = (object->permYouOwner() && gAgentID == creator);
if (!exportable)
{
// Megaprim check
F32 max_object_size = LLWorld::getInstance()->getRegionMaxPrimScale();
LLVector3 vec = object->getScale();
if (vec.mV[VX] > max_object_size || vec.mV[VY] > max_object_size || vec.mV[VZ] > max_object_size)
exportable = (creator == LLUUID("7ffd02d0-12f4-48b4-9640-695708fd4ae4") // Zwagoth Klaar
|| creator == gAgentID);
}
}
#ifdef OPENSIM
else if (LLGridManager::getInstance()->isInOpenSim())
{
switch (LFSimFeatureHandler::instance().exportPolicy())
{
case EXPORT_ALLOWED:
{
exportable = node->mPermissions->allowExportBy(gAgent.getID());
break;
}
/// TODO: Once enough grids adopt a version supporting exports, get consensus
/// on whether we should allow full perm exports anymore.
case EXPORT_UNDEFINED:
{
exportable = (object->permYouOwner() && object->permModify() && object->permCopy() && object->permTransfer());
break;
}
case EXPORT_DENIED:
default:
exportable = (object->permYouOwner() && gAgentID == node->mPermissions->getCreator());
}
}
#endif // OPENSIM
// We've got perms on the object itself, let's check for sculptmaps and meshes!
if (exportable)
{
LLVOVolume *volobjp = NULL;
if (object->getPCode() == LL_PCODE_VOLUME)
{
volobjp = (LLVOVolume *)object;
}
if (volobjp && volobjp->isSculpted())
{
const LLSculptParams *sculpt_params = (const LLSculptParams *)object->getParameterEntry(LLNetworkData::PARAMS_SCULPT);
if (LLGridManager::getInstance()->isInSecondLife())
{
if(volobjp->isMesh())
{
if (dae)
{
LLSD mesh_header = gMeshRepo.getMeshHeader(sculpt_params->getSculptTexture());
exportable = mesh_header["creator"].asUUID() == gAgentID;
}
else
{
// can not export mesh to oxp
LL_INFOS("export") << "Mesh can not be exported to oxp." << LL_ENDL;
return false;
}
}
else if (sculpt_params)
{
LLViewerFetchedTexture* imagep = LLViewerTextureManager::getFetchedTexture(sculpt_params->getSculptTexture());
if (imagep->mComment.find("a") != imagep->mComment.end())
{
exportable = (LLUUID(imagep->mComment["a"]) == gAgentID);
}
if (!exportable)
{
LLUUID asset_id = sculpt_params->getSculptTexture();
LLViewerInventoryCategory::cat_array_t cats;
LLViewerInventoryItem::item_array_t items;
LLAssetIDMatches asset_id_matches(asset_id);
gInventory.collectDescendentsIf(LLUUID::null, cats, items,
LLInventoryModel::INCLUDE_TRASH,
asset_id_matches);
for (S32 i = 0; i < items.size(); ++i)
{
const LLPermissions perms = items[i]->getPermissions();
exportable = perms.getCreator() == gAgentID;
}
}
if (!exportable)
LL_INFOS("export") << "Sculpt map has failed permissions check." << LL_ENDL;
}
}
#ifdef OPENSIM
else if (LLGridManager::getInstance()->isInOpenSim())
{
if (sculpt_params && !volobjp->isMesh())
{
LLUUID asset_id = sculpt_params->getSculptTexture();
LLViewerInventoryCategory::cat_array_t cats;
LLViewerInventoryItem::item_array_t items;
LLAssetIDMatches asset_id_matches(asset_id);
gInventory.collectDescendentsIf(LLUUID::null, cats, items,
LLInventoryModel::INCLUDE_TRASH,
asset_id_matches);
for (S32 i = 0; i < items.size(); ++i)
{
const LLPermissions perms = items[i]->getPermissions();
switch (LFSimFeatureHandler::instance().exportPolicy())
{
case EXPORT_ALLOWED:
exportable = (perms.getMaskOwner() & PERM_EXPORT) == PERM_EXPORT;
break;
/// TODO: Once enough grids adopt a version supporting exports, get consensus
/// on whether we should allow full perm exports anymore.
case EXPORT_UNDEFINED:
exportable = (perms.getMaskBase() & PERM_ITEM_UNRESTRICTED) == PERM_ITEM_UNRESTRICTED;
break;
case EXPORT_DENIED:
default:
exportable = perms.getCreator() == gAgentID;
}
if (!exportable)
LL_INFOS("export") << "Sculpt map has failed permissions check." << LL_ENDL;
}
}
else
{
exportable = true;
}
}
#endif // OPENSIM
}
else
{
exportable = true;
}
}
return exportable;
}
