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; }
bool is_asset_exportable(const LLUUID& asset_id) { if (asset_id.isNull()) return true; // Don't permission-check null textures LLViewerInventoryCategory::cat_array_t cats; LLViewerInventoryItem::item_array_t items; LLAssetIDMatches asset_id_matches(asset_id); gInventory.collectDescendentsIf(LLUUID::null, cats, items, true, asset_id_matches, false); for (U32 i = 0; i < items.size(); ++i) { if (perms_allow_export(items[i]->getPermissions())) return true; } return false; }
const LLUUID& LLFloaterLandmark::findItemID(const LLUUID& asset_id, BOOL copyable_only) { 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()) { // search for copyable version first for (U32 i = 0; i < items.size(); i++) { LLInventoryItem* itemp = items[i]; LLPermissions item_permissions = itemp->getPermissions(); if (item_permissions.allowCopyBy(gAgent.getID(), gAgent.getGroupID())) { return itemp->getUUID(); } } // otherwise just return first instance, unless copyable requested if (copyable_only) { return LLUUID::null; } else { return items[0]->getUUID(); } } return LLUUID::null; }
// static bool LLGiveInventory::handleCopyProtectedCategory(const LLSD& notification, const LLSD& response) { S32 option = LLNotificationsUtil::getSelectedOption(notification, response); LLInventoryCategory* cat = NULL; bool give_successful = true; switch(option) { case 0: // "Yes" cat = gInventory.getCategory(notification["payload"]["folder_id"].asUUID()); if(cat) { give_successful = LLGiveInventory::commitGiveInventoryCategory(notification["payload"]["agent_id"].asUUID(), cat); LLViewerInventoryCategory::cat_array_t cats; LLViewerInventoryItem::item_array_t items; LLUncopyableItems remove; gInventory.collectDescendentsIf(cat->getUUID(), cats, items, LLInventoryModel::EXCLUDE_TRASH, remove); S32 count = items.size(); for(S32 i = 0; i < count; ++i) { gInventory.deleteObject(items.at(i)->getUUID()); } gInventory.notifyObservers(); if (give_successful && notification["payload"]["success_notification"].isDefined()) { LLNotificationsUtil::add(notification["payload"]["success_notification"].asString()); } } else { LLNotificationsUtil::add("CannotGiveCategory"); give_successful = false; } break; default: // no, cancel, whatever, who cares, not yes. LLNotificationsUtil::add("TransactionCancelled"); give_successful = false; break; } return give_successful; }
//static bool LLObjectBackup::validateTexturePerms(const LLUUID& asset_id) { if (LFSimFeatureHandler::instance().exportPolicy() == ep_full_perm) { // If we are not in Second Life and we don't have export-permission // support, don't bother and unconditionally accept the texture export // (legacy behaviour). return true; } if (asset_id == LL_TEXTURE_PLYWOOD || asset_id == LL_TEXTURE_BLANK || asset_id == LL_TEXTURE_INVISIBLE || asset_id == LL_TEXTURE_TRANSPARENT || asset_id == LL_TEXTURE_MEDIA) { // Allow to export a few default SL textures. return true; } 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); S32 count = items.size(); if (count > 0) { for (S32 i = 0; i < count; ++i) { const LLPermissions item_permissions = items[i]->getPermissions(); if (validatePerms(&item_permissions)) { return true; } } } return false; }
// static bool LLGiveInventory::commitGiveInventoryCategory(const LLUUID& to_agent, const LLInventoryCategory* cat, const LLUUID& im_session_id) { if (!cat) { return false; } LL_INFOS() << "LLGiveInventory::commitGiveInventoryCategory() - " << cat->getUUID() << LL_ENDL; // Test out how many items are being given. LLViewerInventoryCategory::cat_array_t cats; LLViewerInventoryItem::item_array_t items; LLGiveable giveable; gInventory.collectDescendentsIf(cat->getUUID(), cats, items, LLInventoryModel::EXCLUDE_TRASH, giveable); bool give_successful = true; // MAX ITEMS is based on (sizeof(uuid)+2) * count must be < // MTUBYTES or 18 * count < 1200 => count < 1200/18 => // 66. I've cut it down a bit from there to give some pad. S32 count = items.size() + cats.size(); if(count > MAX_ITEMS) { LLNotificationsUtil::add("TooManyItems"); give_successful = false; } else if(count == 0) { LLNotificationsUtil::add("NoItems"); give_successful = false; } else { std::string name; LLAgentUI::buildFullname(name); LLUUID transaction_id; transaction_id.generate(); S32 bucket_size = (sizeof(U8) + UUID_BYTES) * (count + 1); U8* bucket = new U8[bucket_size]; U8* pos = bucket; U8 type = (U8)cat->getType(); memcpy(pos, &type, sizeof(U8)); /* Flawfinder: ignore */ pos += sizeof(U8); memcpy(pos, &(cat->getUUID()), UUID_BYTES); /* Flawfinder: ignore */ pos += UUID_BYTES; S32 i; count = cats.size(); for(i = 0; i < count; ++i) { memcpy(pos, &type, sizeof(U8)); /* Flawfinder: ignore */ pos += sizeof(U8); memcpy(pos, &(cats.at(i)->getUUID()), UUID_BYTES); /* Flawfinder: ignore */ pos += UUID_BYTES; } count = items.size(); for(i = 0; i < count; ++i) { type = (U8)items.at(i)->getType(); memcpy(pos, &type, sizeof(U8)); /* Flawfinder: ignore */ pos += sizeof(U8); memcpy(pos, &(items.at(i)->getUUID()), UUID_BYTES); /* Flawfinder: ignore */ pos += UUID_BYTES; } pack_instant_message( gMessageSystem, gAgent.getID(), FALSE, gAgent.getSessionID(), to_agent, name, cat->getName(), IM_ONLINE, IM_INVENTORY_OFFERED, transaction_id, 0, LLUUID::null, gAgent.getPositionAgent(), NO_TIMESTAMP, bucket, bucket_size); gAgent.sendReliableMessage(); delete[] bucket; // <edit> if (gSavedSettings.getBOOL("BroadcastViewerEffects")) { // </edit> // VEFFECT: giveInventoryCategory LLHUDEffectSpiral *effectp = (LLHUDEffectSpiral *)LLHUDManager::getInstance()->createViewerEffect(LLHUDObject::LL_HUD_EFFECT_BEAM, TRUE); effectp->setSourceObject(gAgentAvatarp); effectp->setTargetObject(gObjectList.findObject(to_agent)); effectp->setDuration(LL_HUD_DUR_SHORT); effectp->setColor(LLColor4U(gAgent.getEffectColor())); // <edit> } // </edit> gFloaterTools->dirty(); LLMuteList::getInstance()->autoRemove(to_agent, LLMuteList::AR_INVENTORY); logInventoryOffer(to_agent, im_session_id); } return give_successful; }
bool LLGiveInventory::doGiveInventoryCategory(const LLUUID& to_agent, const LLInventoryCategory* cat, const LLUUID& im_session_id, const std::string& notification_name) { if (!cat) { return false; } LL_INFOS() << "LLGiveInventory::giveInventoryCategory() - " << cat->getUUID() << LL_ENDL; if (!isAgentAvatarValid()) { return false; } bool give_successful = true; // Test out how many items are being given. LLViewerInventoryCategory::cat_array_t cats; LLViewerInventoryItem::item_array_t items; LLGiveable giveable; gInventory.collectDescendentsIf(cat->getUUID(), cats, items, LLInventoryModel::EXCLUDE_TRASH, giveable); S32 count = cats.size(); bool complete = true; for(S32 i = 0; i < count; ++i) { if(!gInventory.isCategoryComplete(cats.at(i)->getUUID())) { complete = false; break; } } if(!complete) { LLNotificationsUtil::add("IncompleteInventory"); give_successful = false; } count = items.size() + cats.size(); if(count > MAX_ITEMS) { LLNotificationsUtil::add("TooManyItems"); give_successful = false; } else if(count == 0) { LLNotificationsUtil::add("NoItems"); give_successful = false; } else if (give_successful) { if(0 == giveable.countNoCopy()) { give_successful = LLGiveInventory::commitGiveInventoryCategory(to_agent, cat, im_session_id); } else { LLSD args; args["COUNT"] = llformat("%d",giveable.countNoCopy()); LLSD payload; payload["agent_id"] = to_agent; payload["folder_id"] = cat->getUUID(); if (!notification_name.empty()) { payload["success_notification"] = notification_name; } LLNotificationsUtil::add("CannotCopyCountItems", args, payload, &LLGiveInventory::handleCopyProtectedCategory); give_successful = false; } } return give_successful; }
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; }