LLPointer<LLSpeaker> LLSpeakerMgr::setSpeaker(const LLUUID& id, const std::string& name, LLSpeaker::ESpeakerStatus status, LLSpeaker::ESpeakerType type) { if (id.isNull()) return NULL; LLPointer<LLSpeaker> speakerp; if (mSpeakers.find(id) == mSpeakers.end()) { speakerp = new LLSpeaker(id, name, type); speakerp->mStatus = status; mSpeakers.insert(std::make_pair(speakerp->mID, speakerp)); mSpeakersSorted.push_back(speakerp); fireEvent(new LLSpeakerListChangeEvent(this, speakerp->mID), "add"); } else { speakerp = findSpeaker(id); if (speakerp.notNull()) { // keep highest priority status (lowest value) instead of overriding current value speakerp->mStatus = llmin(speakerp->mStatus, status); speakerp->mActivityTimer.resetWithExpiry(SPEAKER_TIMEOUT); // RN: due to a weird behavior where IMs from attached objects come from the wearer's agent_id // we need to override speakers that we think are objects when we find out they are really // residents if (type == LLSpeaker::SPEAKER_AGENT) { speakerp->mType = LLSpeaker::SPEAKER_AGENT; speakerp->lookupName(); } } } return speakerp; }
//virtual (WORKER THREAD) void LLTextureCacheWorker::finishWork(S32 param, bool completed) { if (mResponder.notNull()) { bool success = (completed && mDataSize > 0); if (param == 0) { // read if (success) { mResponder->setData(mReadData, mDataSize, mImageSize, mImageFormat, mImageLocal); mReadData = NULL; // responder owns data mDataSize = 0; } else { delete[] mReadData; mReadData = NULL; } } else { // write mWriteData = NULL; // we never owned data mDataSize = 0; } mCache->addCompleted(mResponder, success); } }
// static void LLSDSerialize::serialize(const LLSD& sd, std::ostream& str, ELLSD_Serialize type, U32 options) { LLPointer<LLSDFormatter> f = NULL; switch (type) { case LLSD_BINARY: str << "<? " << LLSD_BINARY_HEADER << " ?>\n"; f = new LLSDBinaryFormatter; break; case LLSD_XML: str << "<? " << LLSD_XML_HEADER << " ?>\n"; f = new LLSDXMLFormatter; break; default: llwarns << "serialize request for unkown ELLSD_Serialize" << llendl; } if (f.notNull()) { f->format(sd, str, options); } }
void LLPanelPrimMediaControls::setMediaFace(LLPointer<LLViewerObject> objectp, S32 face, viewer_media_t media_impl, LLVector3 pick_normal) { if (media_impl.notNull() && objectp.notNull()) { LLUUID prev_id = mTargetImplID; mTargetImplID = media_impl->getMediaTextureID(); mTargetObjectID = objectp->getID(); mTargetObjectFace = face; mTargetObjectNormal = pick_normal; mClearFaceOnFade = false; if (prev_id != mTargetImplID) mVolumeSliderCtrl->setValue(media_impl->getVolume()); } else { // This happens on a timer now. // mTargetImplID = LLUUID::null; // mTargetObjectID = LLUUID::null; // mTargetObjectFace = 0; mClearFaceOnFade = true; } updateShape(); }
void LLSpeakerMgr::setSpeakerTyping(const LLUUID& speaker_id, BOOL typing) { LLPointer<LLSpeaker> speakerp = findSpeaker(speaker_id); if (speakerp.notNull()) { speakerp->mTyping = typing; } }
//----------------------------------------------------------------------------- // addJointState() //----------------------------------------------------------------------------- BOOL LLPose::addJointState(const LLPointer<LLJointState>& jointState) { llassert_always(jointState.notNull()); if (mJointMap.find(jointState->getJoint()->getName()) == mJointMap.end()) { mJointMap[jointState->getJoint()->getName()] = jointState; } return TRUE; }
// speaker has chatted via either text or voice void LLSpeakerMgr::speakerChatted(const LLUUID& speaker_id) { LLPointer<LLSpeaker> speakerp = findSpeaker(speaker_id); if (speakerp.notNull()) { speakerp->mLastSpokeTime = mSpeechTimer.getElapsedTimeF32(); speakerp->mHasSpoken = TRUE; } }
void LLViewerInventoryItem::cloneViewerItem(LLPointer<LLViewerInventoryItem>& newitem) const { newitem = new LLViewerInventoryItem(this); if(newitem.notNull()) { LLUUID item_id; item_id.generate(); newitem->setUUID(item_id); } }
//static void LLPanelActiveSpeakers::onDoubleClickSpeaker(void* user_data) { LLPanelActiveSpeakers* panelp = (LLPanelActiveSpeakers*)user_data; LLUUID speaker_id = panelp->mSpeakerList->getValue().asUUID(); LLPointer<LLSpeaker> speakerp = panelp->mSpeakerMgr->findSpeaker(speaker_id); if (speaker_id != gAgent.getID() && speakerp.notNull()) { gIMMgr->addSession(speakerp->mDisplayName, IM_NOTHING_SPECIAL, speaker_id); } }
virtual bool doCompare(const LLAvatarListItem* item1, const LLAvatarListItem* item2) const { LLPointer<LLSpeaker> lhs = LLActiveSpeakerMgr::instance().findSpeaker(item1->getAvatarId()); LLPointer<LLSpeaker> rhs = LLActiveSpeakerMgr::instance().findSpeaker(item2->getAvatarId()); if ( lhs.notNull() && rhs.notNull() ) { // Compare by last speaking time if( lhs->mLastSpokeTime != rhs->mLastSpokeTime ) return ( lhs->mLastSpokeTime > rhs->mLastSpokeTime ); } else if ( lhs.notNull() ) { // True if only item1 speaker info available return true; } else if ( rhs.notNull() ) { // False if only item2 speaker info available return false; } // By default compare by name. return LLAvatarItemNameComparator::doCompare(item1, item2); }
// virtual bool LLObservable::setDispatcher(LLPointer<LLEventDispatcher> dispatcher) { if (mDispatcher.notNull()) { mDispatcher->disengage(this); mDispatcher = NULL; } if (dispatcher.notNull() || dispatcher->engage(this)) { mDispatcher = dispatcher; return true; } return false; }
void LLFloaterTexturePicker::updateImageStats() { if (mTexturep.notNull()) { //RN: have we received header data for this image? if (mTexturep->getWidth(0) > 0 && mTexturep->getHeight(0) > 0) { std::string formatted_dims = llformat("%d x %d", mTexturep->getWidth(0),mTexturep->getHeight(0)); mResolutionLabel->setTextArg("[DIMENSIONS]", formatted_dims); } else { mResolutionLabel->setTextArg("[DIMENSIONS]", std::string("[? x ?]")); } } }
void LLCallFloater::initParticipantsVoiceState() { // Set initial status for each participant in the list. std::vector<LLPanel*> items; mAvatarList->getItems(items); std::vector<LLPanel*>::const_iterator it = items.begin(), it_end = items.end(); uuid_vec_t speakers_uuids; get_voice_participants_uuids(speakers_uuids); for(; it != it_end; ++it) { LLAvatarListItem *item = dynamic_cast<LLAvatarListItem*>(*it); if (!item) continue; LLUUID speaker_id = item->getAvatarId(); uuid_vec_t::const_iterator speaker_iter = std::find(speakers_uuids.begin(), speakers_uuids.end(), speaker_id); // If an avatarID assigned to a panel is found in a speakers list // obtained from VoiceClient we assign the JOINED status to the owner // of this avatarID. if (speaker_iter != speakers_uuids.end()) { setState(item, STATE_JOINED); } else { LLPointer<LLSpeaker> speakerp = mSpeakerManager->findSpeaker(speaker_id); // If someone has already left the call before, we create his // avatar row panel with HAS_LEFT status and remove it after // the timeout, otherwise we create a panel with INVITED status if (speakerp.notNull() && speakerp.get()->mHasLeftCurrentCall) { setState(item, STATE_LEFT); } else { setState(item, STATE_INVITED); } } } }
/* Initializes "moderate_mode" of voice session on first join. This is WORKAROUND because a way to request the current voice channel moderation mode exists but is not implemented in viewer yet. See EXT-6937. */ void LLSpeakerMgr::initVoiceModerateMode() { if (!mModerateModeHandledFirstTime && (mVoiceChannel && mVoiceChannel->isActive())) { LLPointer<LLSpeaker> speakerp; if (mSpeakers.find(gAgentID) != mSpeakers.end()) { speakerp = mSpeakers[gAgentID]; } if (speakerp.notNull()) { mVoiceModerated = speakerp->mModeratorMutedVoice; mModerateModeHandledFirstTime = true; } } }
//static void LLPanelActiveSpeakers::onDoubleClickSpeaker(void* user_data) { // [RLVa:KB] - Checked: 2009-07-10 (RLVa-1.0.0g) | Added: RLVa-1.0.0g if (gRlvHandler.hasBehaviour(RLV_BHVR_SHOWNAMES)) { return; } // [/RLVa:KB] LLPanelActiveSpeakers* panelp = (LLPanelActiveSpeakers*)user_data; LLUUID speaker_id = panelp->mSpeakerList->getValue().asUUID(); LLPointer<LLSpeaker> speakerp = panelp->mSpeakerMgr->findSpeaker(speaker_id); if (speaker_id != gAgent.getID() && speakerp.notNull()) { gIMMgr->addSession(speakerp->mDisplayName, IM_NOTHING_SPECIAL, speaker_id); } }
void LLCallFloater::updateNotInVoiceParticipantState(LLAvatarListItem* item) { LLUUID participant_id = item->getAvatarId(); ESpeakerState current_state = getState(participant_id); switch (current_state) { case STATE_JOINED: // If an avatarID is not found in a speakers list from VoiceClient and // a panel with this ID has a JOINED status this means that this person // HAS LEFT the call. setState(item, STATE_LEFT); { LLPointer<LLSpeaker> speaker = mSpeakerManager->findSpeaker(participant_id); if (speaker.notNull()) { speaker->mHasLeftCurrentCall = TRUE; } } break; case STATE_LEFT: // nothing to do. These states should not be changed. break; case STATE_INVITED: // If avatar was invited into group chat and went offline it is still exists in mSpeakerStateMap // If it goes online it will be rendered as JOINED via LAvatarListItem. // Lets update its visual representation. See EXT-6660 case STATE_UNKNOWN: // If an avatarID is not found in a speakers list from VoiceClient and // a panel with this ID has an UNKNOWN status this means that this person // HAS ENTERED session but it is not in voice chat yet. So, set INVITED status setState(item, STATE_INVITED); break; default: // for possible new future states. llwarns << "Unsupported (" << getState(participant_id) << ") state for: " << item->getAvatarName() << llendl; break; } }
void LLFloaterTexturePicker::updateImageStats() { if (mTexturep.notNull()) { //RN: have we received header data for this image? if (mTexturep->getWidth(0) > 0 && mTexturep->getHeight(0) > 0) { std::string formatted_dims = llformat("%d x %d", mTexturep->getWidth(0),mTexturep->getHeight(0)); mResolutionLabel->setTextArg("[DIMENSIONS]", formatted_dims); } else { mResolutionLabel->setTextArg("[DIMENSIONS]", std::string("[? x ?]")); } if (gAgent.isGodlike()) { std::string tstring = "Pick: "; std::string image_id_string = mTexturep->getID().asString(); tstring = tstring + image_id_string.replace(24, 35, 12, '*'); // hide last segment to discourage theft setTitle(tstring); } } }
/* Processed menu items with such parameters: can_allow_text_chat can_moderate_voice */ bool LLParticipantList::LLParticipantListMenu::enableModerateContextMenuItem(const LLSD& userdata) { // only group moderators can perform actions related to this "enable callback" if (!isGroupModerator()) return false; const LLUUID& participant_id = mUUIDs.front(); LLPointer<LLSpeaker> speakerp = mParent.mSpeakerMgr->findSpeaker(participant_id); // not in voice participants can not be moderated bool speaker_in_voice = speakerp.notNull() && speakerp->isInVoiceChannel(); const std::string& item = userdata.asString(); if ("can_moderate_voice" == item) { return speaker_in_voice; } // For now non of menu actions except "can_moderate_voice" can be performed for Avaline callers. bool is_participant_avatar = LLVoiceClient::getInstance()->isParticipantAvatar(participant_id); if (!is_participant_avatar) return false; return true; }
void LLSimInfo::setLandForSaleImage (LLUUID image_id) { LLPointer<LLViewerFetchedTexture> mOverlayImage; if (mMapImageID[SIM_LAYER_OVERLAY].isNull() && image_id.notNull()) { mOverlayImage = LLViewerTextureManager::findFetchedTexture(image_id); if(mOverlayImage.notNull()) { LLAppViewer::getTextureCache()->removeFromCache(image_id); } } mMapImageID[SIM_LAYER_OVERLAY] = image_id; // Fetch the image if (mMapImageID[SIM_LAYER_OVERLAY].notNull()) { mLayerImage[SIM_LAYER_OVERLAY] = LLViewerTextureManager::getFetchedTexture(mMapImageID[SIM_LAYER_OVERLAY], MIPMAP_TRUE, LLViewerTexture::BOOST_MAP, LLViewerTexture::LOD_TEXTURE); mLayerImage[SIM_LAYER_OVERLAY]->forceImmediateUpdate(); mLayerImage[SIM_LAYER_OVERLAY]->setAddressMode(LLTexUnit::TAM_CLAMP); } else { mLayerImage[SIM_LAYER_OVERLAY] = NULL; } }
// //this function reserves an appropriate slot from atlas pool for an image. //return non-NULL if succeeds. //Note: //1, this function does not check if the image this slot assigned for qualifies for atlas or not, // call LLTextureAtlasManager::canAddToAtlas(...) to do the check before calling this function. //2, this function also dose not check if the image is already in atlas. It always assigns a new slot anyway. //3, this function tries to group sub-textures from same spatial group into ONE atlas to improve render batching. // LLPointer<LLTextureAtlasSlot> LLTextureAtlasManager::reserveAtlasSlot(S32 sub_texture_size, S8 ncomponents, LLSpatialGroup* groupp, LLViewerTexture* imagep) { if(!groupp) { //do not insert to atlas if does not have a group. return NULL ; } //bits_len must <= 8 and is a power of two number, i.e.: must be one of these numbers: 1, 2, 4, 8. if(sub_texture_size > LLTextureAtlas::sMaxSubTextureSize) { sub_texture_size = LLTextureAtlas::sMaxSubTextureSize ; } S8 bits_len = sub_texture_size / LLTextureAtlas::sSlotSize ; if(bits_len < 1) { bits_len = 1 ; } S16 col = -1, row = -1; S8 total_bits = bits_len * bits_len ; //insert to the atlas reserved by the same spatial group LLPointer<LLTextureAtlas> atlasp = groupp->getAtlas(ncomponents, total_bits) ; if(atlasp.notNull()) { if(!atlasp->getNextAvailableSlot(bits_len, col, row)) { //failed atlasp = NULL ; } } //search an atlas to fit for 'size' if(!atlasp) { S8 atlas_index = ncomponents - 1 ; ll_texture_atlas_list_t::iterator iter = mAtlasMap[atlas_index].begin() ; for(; iter != mAtlasMap[atlas_index].end(); ++iter) { LLTextureAtlas* cur = (LLTextureAtlas*)*iter ; if(cur->getFullness() < MIN_ATLAS_FULLNESS)//this atlas is empty enough for this group to insert more sub-textures later if necessary. { if(cur->getNextAvailableSlot(bits_len, col, row)) { atlasp = cur ; groupp->addAtlas(atlasp) ; break ; } } } } //create a new atlas if necessary if(!atlasp) { if(mEmptyAtlasMap[ncomponents - 1].size() > 0) { //there is an empty one atlasp = mEmptyAtlasMap[ncomponents - 1].back() ; mEmptyAtlasMap[ncomponents - 1].pop_back() ; } else { atlasp = new LLTextureAtlas(ncomponents, 16) ; } mAtlasMap[ncomponents - 1].push_back(atlasp) ; atlasp->getNextAvailableSlot(bits_len, col, row) ; groupp->addAtlas(atlasp) ; } F32 xoffset, yoffset ; atlasp->getTexCoordOffset(col, row, xoffset, yoffset) ; LLPointer<LLTextureAtlasSlot> slot_infop = new LLTextureAtlasSlot(atlasp, groupp, col, row, xoffset, yoffset, bits_len) ; return slot_infop ; }
bool LLImageRaw::createFromFile(const std::string &filename, bool j2c_lowest_mip_only) { std::string name = filename; size_t dotidx = name.rfind('.'); S8 codec = IMG_CODEC_INVALID; std::string exten; deleteData(); // delete any existing data if (dotidx != std::string::npos) { exten = name.substr(dotidx+1); LLStringUtil::toLower(exten); codec = getCodecFromExtension(exten); } else { exten = find_file(name, &codec); name = name + "." + exten; } if (codec == IMG_CODEC_INVALID) { return false; // format not recognized } llifstream ifs(name, llifstream::binary); if (!ifs.is_open()) { // SJB: changed from llinfos to lldebugs to reduce spam lldebugs << "Unable to open image file: " << name << llendl; return false; } ifs.seekg (0, std::ios::end); int length = ifs.tellg(); if (j2c_lowest_mip_only && length > 2048) { length = 2048; } ifs.seekg (0, std::ios::beg); if (!length) { llinfos << "Zero length file file: " << name << llendl; return false; } LLPointer<LLImageFormatted> image; switch(codec) { //case IMG_CODEC_RGB: case IMG_CODEC_BMP: image = new LLImageBMP(); break; case IMG_CODEC_TGA: image = new LLImageTGA(); break; case IMG_CODEC_JPEG: image = new LLImageJPEG(); break; case IMG_CODEC_J2C: image = new LLImageJ2C(); break; case IMG_CODEC_DXT: image = new LLImageDXT(); break; default: return false; } llassert(image.notNull()); U8 *buffer = image->allocateData(length); ifs.read ((char*)buffer, length); /* Flawfinder: ignore */ ifs.close(); image->updateData(); if (j2c_lowest_mip_only && codec == IMG_CODEC_J2C) { S32 width = image->getWidth(); S32 height = image->getHeight(); S32 discard_level = 0; while (width > 1 && height > 1 && discard_level < MAX_DISCARD_LEVEL) { width >>= 1; height >>= 1; discard_level++; } ((LLImageJ2C *)((LLImageFormatted*)image))->setDiscardLevel(discard_level); }
// static bool LLSDSerialize::deserialize(LLSD& sd, std::istream& str, S32 max_bytes) { LLPointer<LLSDParser> p = NULL; char hdr_buf[MAX_HDR_LEN + 1] = ""; /* Flawfinder: ignore */ int i; int inbuf = 0; bool legacy_no_header = false; bool fail_if_not_legacy = false; std::string header; /* * Get the first line before anything. */ str.get(hdr_buf, MAX_HDR_LEN, '\n'); if (str.fail()) { str.clear(); fail_if_not_legacy = true; } if (!strncasecmp(LEGACY_NON_HEADER, hdr_buf, strlen(LEGACY_NON_HEADER))) /* Flawfinder: ignore */ { legacy_no_header = true; inbuf = str.gcount(); } else { if (fail_if_not_legacy) goto fail; /* * Remove the newline chars */ for (i = 0; i < MAX_HDR_LEN; i++) { if (hdr_buf[i] == 0 || hdr_buf[i] == '\r' || hdr_buf[i] == '\n') { hdr_buf[i] = 0; break; } } header = hdr_buf; std::string::size_type start = std::string::npos; std::string::size_type end = std::string::npos; start = header.find_first_not_of("<? "); if (start != std::string::npos) { end = header.find_first_of(" ?", start); } if ((start == std::string::npos) || (end == std::string::npos)) goto fail; header = header.substr(start, end - start); ws(str); } /* * Create the parser as appropriate */ if (legacy_no_header) { // Create a LLSD XML parser, and parse the first chunk read above LLSDXMLParser* x = new LLSDXMLParser(); x->parsePart(hdr_buf, inbuf); // Parse the first part that was already read x->parseLines(str, sd); // Parse the rest of it delete x; return true; } if (header == LLSD_BINARY_HEADER) { p = new LLSDBinaryParser; } else if (header == LLSD_XML_HEADER) { p = new LLSDXMLParser; } else { llwarns << "deserialize request for unknown ELLSD_Serialize" << llendl; } if (p.notNull()) { p->parse(str, sd, max_bytes); return true; } fail: llwarns << "deserialize LLSD parse failure" << llendl; return false; }
// static void LLPanelLogin::getFields(LLPointer<LLCredential>& credential, BOOL& remember) { if (!sInstance) { llwarns << "Attempted getFields with no login view shown" << llendl; return; } // load the credential so we can pass back the stored password or hash if the user did // not modify the password field. credential = gSecAPIHandler->loadCredential(LLGridManager::getInstance()->getGrid()); LLSD identifier = LLSD::emptyMap(); LLSD authenticator = LLSD::emptyMap(); if(credential.notNull()) { authenticator = credential->getAuthenticator(); } std::string username = sInstance->getChild<LLUICtrl>("username_edit")->getValue().asString(); LLStringUtil::trim(username); std::string password = sInstance->getChild<LLUICtrl>("password_edit")->getValue().asString(); LL_INFOS2("Credentials", "Authentication") << "retrieving username:"******"Credentials", "Authentication") << "account: " << username << LL_ENDL; // single username, so this is a 'clear' identifier identifier["type"] = CRED_IDENTIFIER_TYPE_ACCOUNT; identifier["account_name"] = username; if (LLPanelLogin::sInstance->mPasswordModified) { authenticator = LLSD::emptyMap(); // password is plaintext authenticator["type"] = CRED_AUTHENTICATOR_TYPE_CLEAR; authenticator["secret"] = password; } } else { std::string first = username.substr(0, separator_index); std::string last = username.substr(separator_index, username.npos); LLStringUtil::trim(last); if (last.find_first_of(' ') == last.npos) { LL_INFOS2("Credentials", "Authentication") << "agent: " << username << LL_ENDL; // traditional firstname / lastname identifier["type"] = CRED_IDENTIFIER_TYPE_AGENT; identifier["first_name"] = first; identifier["last_name"] = last; if (LLPanelLogin::sInstance->mPasswordModified) { authenticator = LLSD::emptyMap(); authenticator["type"] = CRED_AUTHENTICATOR_TYPE_HASH; authenticator["algorithm"] = "md5"; LLMD5 pass((const U8 *)password.c_str()); char md5pass[33]; /* Flawfinder: ignore */ pass.hex_digest(md5pass); authenticator["secret"] = md5pass; } } } credential = gSecAPIHandler->createCredential(LLGridManager::getInstance()->getGrid(), identifier, authenticator); remember = sInstance->getChild<LLUICtrl>("remember_check")->getValue(); }
// static void FSPanelLogin::getFields(LLPointer<LLCredential>& credential, BOOL& remember) { if (!sInstance) { LL_WARNS() << "Attempted getFields with no login view shown" << LL_ENDL; return; } // load the credential so we can pass back the stored password or hash if the user did // not modify the password field. credential = gSecAPIHandler->loadCredential(credentialName()); LLSD identifier = LLSD::emptyMap(); LLSD authenticator = LLSD::emptyMap(); if(credential.notNull()) { authenticator = credential->getAuthenticator(); } std::string username = sInstance->getChild<LLUICtrl>("username_combo")->getValue().asString(); LLStringUtil::trim(username); size_t arobase = username.find("@"); if (arobase != std::string::npos) { username = username.substr(0, arobase); } std::string password = sInstance->getChild<LLUICtrl>("password_edit")->getValue().asString(); sPassword = password; LL_INFOS("Credentials", "Authentication") << "retrieving username:"******"Credentials", "Authentication") << "account: " << username << LL_ENDL; // single username, so this is a 'clear' identifier identifier["type"] = CRED_IDENTIFIER_TYPE_ACCOUNT; identifier["account_name"] = username; if (FSPanelLogin::sInstance->mPasswordModified) { authenticator = LLSD::emptyMap(); // password is plaintext authenticator["type"] = CRED_AUTHENTICATOR_TYPE_CLEAR; authenticator["secret"] = password; } } else { // Be lenient in terms of what separators we allow for two-word names // and allow legacy users to login with firstname.lastname #ifdef OPENSIM if (LLGridManager::getInstance()->isInSecondLife()) { separator_index = username.find_first_of(" ._"); } else { separator_index = username.find_first_of(" ."); } #else separator_index = username.find_first_of(" ._"); #endif std::string first = username.substr(0, separator_index); std::string last; if (separator_index != username.npos) { last = username.substr(separator_index + 1, username.npos); LLStringUtil::trim(last); } else { // ...on Linden grids, single username users as considered to have // last name "Resident" // *TODO: Make login.cgi support "account_name" like above last = "Resident"; } if (last.find_first_of(' ') == last.npos) { LL_INFOS("Credentials", "Authentication") << "agent: " << username << LL_ENDL; // traditional firstname / lastname identifier["type"] = CRED_IDENTIFIER_TYPE_AGENT; identifier["first_name"] = first; identifier["last_name"] = last; if (FSPanelLogin::sInstance->mPasswordModified) { authenticator = LLSD::emptyMap(); authenticator["type"] = CRED_AUTHENTICATOR_TYPE_HASH; authenticator["algorithm"] = "md5"; LLMD5 pass((const U8 *)password.c_str()); char md5pass[33]; /* Flawfinder: ignore */ pass.hex_digest(md5pass); authenticator["secret"] = md5pass; } } } credential = gSecAPIHandler->createCredential(credentialName(), identifier, authenticator); remember = sInstance->getChild<LLUICtrl>("remember_check")->getValue(); }
void LLViewerMediaFocus::setFocusFace(LLPointer<LLViewerObject> objectp, S32 face, viewer_media_t media_impl, LLVector3 pick_normal) { LLParcel *parcel = LLViewerParcelMgr::getInstance()->getAgentParcel(); LLViewerMediaImpl *old_media_impl = getFocusedMediaImpl(); if(old_media_impl) { old_media_impl->focus(false); } // Always clear the current selection. If we're setting focus on a face, we'll reselect the correct object below. LLSelectMgr::getInstance()->deselectAll(); mSelection = NULL; if (media_impl.notNull() && objectp.notNull()) { bool face_auto_zoom = false; mFocusedImplID = media_impl->getMediaTextureID(); mFocusedObjectID = objectp->getID(); mFocusedObjectFace = face; mFocusedObjectNormal = pick_normal; // Set the selection in the selection manager so we can draw the focus ring. mSelection = LLSelectMgr::getInstance()->selectObjectOnly(objectp, face); // Focusing on a media face clears its disable flag. media_impl->setDisabled(false); LLTextureEntry* tep = objectp->getTE(face); if(tep->hasMedia()) { LLMediaEntry* mep = tep->getMediaData(); face_auto_zoom = mep->getAutoZoom(); if(!media_impl->hasMedia()) { std::string url = mep->getCurrentURL().empty() ? mep->getHomeURL() : mep->getCurrentURL(); media_impl->navigateTo(url, "", true); } } else { // This should never happen. llwarns << "Can't find media entry for focused face" << llendl; } media_impl->focus(true); gFocusMgr.setKeyboardFocus(this); // We must do this before processing the media HUD zoom, or it may zoom to the wrong face. update(); if(mMediaControls.get()) { if(face_auto_zoom && ! parcel->getMediaPreventCameraZoom()) { // Zoom in on this face mMediaControls.get()->resetZoomLevel(false); mMediaControls.get()->nextZoomLevel(); } else { // Reset the controls' zoom level without moving the camera. // This fixes the case where clicking focus between two non-autozoom faces doesn't change the zoom-out button back to a zoom-in button. mMediaControls.get()->resetZoomLevel(false); } } } else { if(hasFocus()) { gFocusMgr.setKeyboardFocus(NULL); } mFocusedImplID = LLUUID::null; if (objectp.notNull()) { // Still record the focused object...it may mean we need to load media data. // This will aid us in determining this object is "important enough" mFocusedObjectID = objectp->getID(); mFocusedObjectFace = face; } else { mFocusedObjectID = LLUUID::null; mFocusedObjectFace = 0; } } }
// static void LLPanelLogin::getFields(LLPointer<LLCredential>& credential, BOOL& remember) { if (!sInstance) { llwarns << "Attempted getFields with no login view shown" << llendl; return; } // load the credential so we can pass back the stored password or hash if the user did // not modify the password field. credential = gSecAPIHandler->loadCredential(credential_name()); LLSD identifier = LLSD::emptyMap(); LLSD authenticator = LLSD::emptyMap(); if(credential.notNull()) { authenticator = credential->getAuthenticator(); } std::string username = sInstance->getChild<LLComboBox>("username_combo")->getValue().asString(); LLStringUtil::trim(username); U32 arobase = username.find("@"); if(arobase>0) username = username.substr(0, arobase); std::string password = sInstance->getChild<LLUICtrl>("password_edit")->getValue().asString(); LL_INFOS2("Credentials", "Authentication") << "retrieving username:"******"Credentials", "Authentication") << "account: " << username << LL_ENDL; // single username, so this is a 'clear' identifier identifier["type"] = CRED_IDENTIFIER_TYPE_ACCOUNT; identifier["account_name"] = username; if (LLPanelLogin::sInstance->mPasswordModified) { authenticator = LLSD::emptyMap(); // password is plaintext authenticator["type"] = CRED_AUTHENTICATOR_TYPE_CLEAR; authenticator["secret"] = password; } } else { // Be lenient in terms of what separators we allow for two-word names // and allow legacy users to login with firstname.lastname separator_index = username.find_first_of(" ._"); std::string first = username.substr(0, separator_index); std::string last; if (separator_index != username.npos) { last = username.substr(separator_index+1, username.npos); LLStringUtil::trim(last); } else { // ...on Linden grids, single username users as considered to have // last name "Resident" // *TODO: Make login.cgi support "account_name" like above last = "Resident"; } if (last.find_first_of(' ') == last.npos) { LL_INFOS2("Credentials", "Authentication") << "agent: " << username << LL_ENDL; // traditional firstname / lastname identifier["type"] = CRED_IDENTIFIER_TYPE_AGENT; identifier["first_name"] = first; identifier["last_name"] = last; if (LLPanelLogin::sInstance->mPasswordModified) { authenticator = LLSD::emptyMap(); authenticator["type"] = CRED_AUTHENTICATOR_TYPE_HASH; authenticator["algorithm"] = "md5"; LLMD5 pass((const U8 *)password.c_str()); char md5pass[33]; /* Flawfinder: ignore */ pass.hex_digest(md5pass); authenticator["secret"] = md5pass; } } } // <FS:AW FIRE-6492 Firestorm doesn't always honor the start location option> /* switch(LLSLURL(sInstance->getChild<LLComboBox>("start_location_combo")->getValue()).getType()) { case LLSLURL::HOME_LOCATION: { identifier["startlocation"] = LLSLURL::SIM_LOCATION_HOME; break; } case LLSLURL::LAST_LOCATION: { identifier["startlocation"] = LLSLURL::SIM_LOCATION_LAST; break; } case LLSLURL::INVALID: { break; } case LLSLURL::LOCATION: { break; } case LLSLURL::APP: { break; } case LLSLURL::HELP: { break; } } */ // </FS:AW FIRE-6492 Firestorm doesn't always honor the start location option> credential = gSecAPIHandler->createCredential(credential_name(), identifier, authenticator); remember = sInstance->getChild<LLUICtrl>("remember_check")->getValue(); }
void LLIMSpeakerMgr::updateSpeakers(const LLSD& update) { if ( !update.isMap() ) return; if ( update.has("agent_updates") && update["agent_updates"].isMap() ) { LLSD::map_const_iterator update_it; for( update_it = update["agent_updates"].beginMap(); update_it != update["agent_updates"].endMap(); ++update_it) { LLUUID agent_id(update_it->first); LLPointer<LLSpeaker> speakerp = findSpeaker(agent_id); LLSD agent_data = update_it->second; if (agent_data.isMap() && agent_data.has("transition")) { if (agent_data["transition"].asString() == "LEAVE" && speakerp.notNull()) { setSpeakerNotInChannel(speakerp); } else if (agent_data["transition"].asString() == "ENTER") { // add or update speaker speakerp = setSpeaker(agent_id); } else { llwarns << "bad membership list update " << ll_print_sd(agent_data["transition"]) << llendl; } } if (speakerp.isNull()) continue; // should have a valid speaker from this point on if (agent_data.isMap() && agent_data.has("info")) { LLSD agent_info = agent_data["info"]; if (agent_info.has("is_moderator")) { BOOL is_moderator = speakerp->mIsModerator; speakerp->mIsModerator = agent_info["is_moderator"]; // Fire event only if moderator changed if ( is_moderator != speakerp->mIsModerator ) fireEvent(new LLSpeakerUpdateModeratorEvent(speakerp), "update_moderator"); } if (agent_info.has("mutes")) { speakerp->mModeratorMutedText = agent_info["mutes"]["text"]; } } } } else if ( update.has("updates") && update["updates"].isMap() ) { LLSD::map_const_iterator update_it; for ( update_it = update["updates"].beginMap(); update_it != update["updates"].endMap(); ++update_it) { LLUUID agent_id(update_it->first); LLPointer<LLSpeaker> speakerp = findSpeaker(agent_id); std::string agent_transition = update_it->second.asString(); if (agent_transition == "LEAVE" && speakerp.notNull()) { setSpeakerNotInChannel(speakerp); } else if ( agent_transition == "ENTER") { // add or update speaker speakerp = setSpeaker(agent_id); } else { llwarns << "bad membership list update " << agent_transition << llendl; } } } }
bool LLImageRaw::createFromFile(const std::string &filename, bool j2c_lowest_mip_only) { std::string name = filename; size_t dotidx = name.rfind('.'); S8 codec = IMG_CODEC_INVALID; std::string exten; deleteData(); // delete any existing data if (dotidx != std::string::npos) { exten = name.substr(dotidx+1); LLStringUtil::toLower(exten); codec = getCodecFromExtension(exten); } else { exten = find_file(name, &codec); name = name + "." + exten; } if (codec == IMG_CODEC_INVALID) { return false; // format not recognized } llifstream ifs(name, llifstream::binary); if (!ifs.is_open()) { // SJB: changed from LL_INFOS() to LL_DEBUGS() to reduce spam LL_DEBUGS() << "Unable to open image file: " << name << LL_ENDL; return false; } ifs.seekg (0, std::ios::end); int length = ifs.tellg(); if (j2c_lowest_mip_only && length > 2048) { length = 2048; } ifs.seekg (0, std::ios::beg); if (!length) { LL_INFOS() << "Zero length file file: " << name << LL_ENDL; return false; } LLPointer<LLImageFormatted> image = LLImageFormatted::createFromType(codec); llassert(image.notNull()); U8 *buffer = image->allocateData(length); ifs.read ((char*)buffer, length); ifs.close(); BOOL success; success = image->updateData(); if (success) { if (j2c_lowest_mip_only && codec == IMG_CODEC_J2C) { S32 width = image->getWidth(); S32 height = image->getHeight(); S32 discard_level = 0; while (width > 1 && height > 1 && discard_level < MAX_DISCARD_LEVEL) { width >>= 1; height >>= 1; discard_level++; } ((LLImageJ2C *)((LLImageFormatted*)image))->setDiscardLevel(discard_level); } success = image->decode(this, 100000.0f); }
void LLIMSpeakerMgr::updateSpeakers(const LLSD& update) { if ( !update.isMap() ) return; if ( update.has("agent_updates") && update["agent_updates"].isMap() ) { LLSD::map_const_iterator update_it; for( update_it = update["agent_updates"].beginMap(); update_it != update["agent_updates"].endMap(); ++update_it) { LLUUID agent_id(update_it->first); LLPointer<LLSpeaker> speakerp = findSpeaker(agent_id); LLSD agent_data = update_it->second; if (agent_data.isMap() && agent_data.has("transition")) { if (agent_data["transition"].asString() == "LEAVE" && speakerp.notNull()) { speakerp->mStatus = LLSpeaker::STATUS_NOT_IN_CHANNEL; speakerp->mDotColor = INACTIVE_COLOR; speakerp->mActivityTimer.resetWithExpiry(SPEAKER_TIMEOUT); } else if (agent_data["transition"].asString() == "ENTER") { // add or update speaker speakerp = setSpeaker(agent_id); } else { llwarns << "bad membership list update " << ll_print_sd(agent_data["transition"]) << llendl; } } if (speakerp.isNull()) continue; // should have a valid speaker from this point on if (agent_data.isMap() && agent_data.has("info")) { LLSD agent_info = agent_data["info"]; if (agent_info.has("is_moderator")) { speakerp->mIsModerator = agent_info["is_moderator"]; } if (agent_info.has("mutes")) { speakerp->mModeratorMutedText = agent_info["mutes"]["text"]; } } } } else if ( update.has("updates") && update["updates"].isMap() ) { LLSD::map_const_iterator update_it; for ( update_it = update["updates"].beginMap(); update_it != update["updates"].endMap(); ++update_it) { LLUUID agent_id(update_it->first); LLPointer<LLSpeaker> speakerp = findSpeaker(agent_id); std::string agent_transition = update_it->second.asString(); if (agent_transition == "LEAVE" && speakerp.notNull()) { speakerp->mStatus = LLSpeaker::STATUS_NOT_IN_CHANNEL; speakerp->mDotColor = INACTIVE_COLOR; speakerp->mActivityTimer.resetWithExpiry(SPEAKER_TIMEOUT); } else if ( agent_transition == "ENTER") { // add or update speaker speakerp = setSpeaker(agent_id); } else { llwarns << "bad membership list update " << agent_transition << llendl; } } } }