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;
}
}
}
}
