BOOL LLPacketRing::sendPacket(int h_socket, char * send_buffer, S32 buf_size, LLHost host)
{
//<edit>
LLMessageLog::log(LLHost(16777343, gMessageSystem->getListenPort()), host, (U8*)send_buffer, buf_size);
//</edit>
BOOL status = TRUE;
if (!mUseOutThrottle)
{
return sendPacketImpl(h_socket, send_buffer, buf_size, host );
}
else
{
mActualBitsOut += buf_size * 8;
LLPacketBuffer *packetp = NULL;
// See if we've got enough throttle to send a packet.
while (!mOutThrottle.checkOverflow(0.f))
{
// While we have enough bandwidth, send a packet from the queue or the current packet
S32 packet_size = 0;
if (!mSendQueue.empty())
{
// Send a packet off of the queue
LLPacketBuffer *packetp = mSendQueue.front();
mSendQueue.pop();
mOutBufferLength -= packetp->getSize();
packet_size = packetp->getSize();
status = sendPacketImpl(h_socket, packetp->getData(), packet_size, packetp->getHost());
delete packetp;
// Update the throttle
mOutThrottle.throttleOverflow(packet_size * 8.f);
}
else
{
// If the queue's empty, we can just send this packet right away.
status = sendPacketImpl(h_socket, send_buffer, buf_size, host );
packet_size = buf_size;
// Update the throttle
mOutThrottle.throttleOverflow(packet_size * 8.f);
// This was the packet we're sending now, there are no other packets
// that we need to send
return status;
}
}
// We haven't sent the incoming packet, add it to the queue
if (mOutBufferLength + buf_size > mMaxBufferLength)
{
// Nuke this packet, we overflowed the buffer.
// Toss it.
LL_WARNS() << "Throwing away outbound packet, overflowing buffer" << LL_ENDL;
}
else
{
static LLTimer queue_timer;
if ((mOutBufferLength > 4192) && queue_timer.getElapsedTimeF32() > 1.f)
{
// Add it to the queue
LL_INFOS() << "Outbound packet queue " << mOutBufferLength << " bytes" << LL_ENDL;
queue_timer.reset();
}
packetp = new LLPacketBuffer(host, send_buffer, buf_size);
mOutBufferLength += packetp->getSize();
mSendQueue.push(packetp);
}
}
return status;
}
void LLQueryResponder::querySuccess()
{
LL_INFOS() << "LLQueryResponder::queryResult not implemented" << LL_ENDL;
}
void LLAres::HostResponder::hostResult(const hostent *ent)
{
LL_INFOS() << "LLAres::HostResponder::hostResult not implemented" << LL_ENDL;
}
/*virtual*/ void LLEnvironmentRequestResponder::error(U32 status, const std::string& reason)
{
LL_INFOS("WindlightCaps") << "Got an error, not using region windlight..." << LL_ENDL;
LLEnvManagerNew::getInstance()->onRegionSettingsResponse(LLSD());
}
int LLQueryResponder::parseRR(const char *buf, size_t len, const char *&pos,
LLPointer<LLDnsRecord> &r)
{
std::string rrname;
size_t enclen;
int ret;
// RR name.
ret = LLAres::expandName(pos, buf, len, rrname, enclen);
if (ret != ARES_SUCCESS)
{
return ret;
}
pos += enclen;
if (pos + NS_RRFIXEDSZ > buf + len)
{
return ARES_EBADRESP;
}
int rrtype = DNS_RR_TYPE(pos);
int rrclass = DNS_RR_CLASS(pos);
int rrttl = DNS_RR_TTL(pos);
int rrlen = DNS_RR_LEN(pos);
if (rrclass != ns_c_in)
{
return ARES_EBADRESP;
}
pos += NS_RRFIXEDSZ;
if (pos + rrlen > buf + len)
{
return ARES_EBADRESP;
}
switch (rrtype)
{
case RES_A:
r = new LLARecord(rrname, rrttl);
break;
case RES_NS:
r = new LLNsRecord(rrname, rrttl);
break;
case RES_CNAME:
r = new LLCnameRecord(rrname, rrttl);
break;
case RES_PTR:
r = new LLPtrRecord(rrname, rrttl);
break;
case RES_AAAA:
r = new LLAaaaRecord(rrname, rrttl);
break;
case RES_SRV:
r = new LLSrvRecord(rrname, rrttl);
break;
default:
LL_INFOS() << "LLQueryResponder::parseRR got unknown RR type " << rrtype
<< LL_ENDL;
return ARES_EBADRESP;
}
ret = r->parse(buf, len, pos, rrlen);
if (ret == ARES_SUCCESS)
{
pos += rrlen;
} else {
r = NULL;
}
return ret;
}
void LLPluginProcessParent::receiveMessage(const LLPluginMessage &message)
{
std::string message_class = message.getClass();
if(message_class == LLPLUGIN_MESSAGE_CLASS_INTERNAL)
{
// internal messages should be handled here
std::string message_name = message.getName();
if(message_name == "hello")
{
if(mState == STATE_CONNECTED)
{
// Plugin host has launched. Tell it which plugin to load.
setState(STATE_HELLO);
}
else
{
LL_WARNS("Plugin") << "received hello message in wrong state -- bailing out" << LL_ENDL;
errorState();
}
}
else if(message_name == "load_plugin_response")
{
if(mState == STATE_LOADING)
{
// Plugin has been loaded.
mPluginVersionString = message.getValue("plugin_version");
LL_INFOS("Plugin") << "plugin version string: " << mPluginVersionString << LL_ENDL;
// Check which message classes/versions the plugin supports.
// TODO: check against current versions
// TODO: kill plugin on major mismatches?
mMessageClassVersions = message.getValueLLSD("versions");
LLSD::map_iterator iter;
for(iter = mMessageClassVersions.beginMap(); iter != mMessageClassVersions.endMap(); iter++)
{
LL_INFOS("Plugin") << "message class: " << iter->first << " -> version: " << iter->second.asString() << LL_ENDL;
}
// Send initial sleep time
setSleepTime(mSleepTime, true);
setState(STATE_RUNNING);
}
else
{
LL_WARNS("Plugin") << "received load_plugin_response message in wrong state -- bailing out" << LL_ENDL;
errorState();
}
}
else if(message_name == "heartbeat")
{
// this resets our timer.
mHeartbeat.setTimerExpirySec(mPluginLockupTimeout);
mCPUUsage = message.getValueReal("cpu_usage");
LL_DEBUGS("Plugin") << "cpu usage reported as " << mCPUUsage << LL_ENDL;
}
else if(message_name == "shm_add_response")
{
// Nothing to do here.
}
else if(message_name == "shm_remove_response")
{
std::string name = message.getValue("name");
sharedMemoryRegionsType::iterator iter = mSharedMemoryRegions.find(name);
if(iter != mSharedMemoryRegions.end())
{
// destroy the shared memory region
iter->second->destroy();
// and remove it from our map
mSharedMemoryRegions.erase(iter);
}
}
else
{
LL_WARNS("Plugin") << "Unknown internal message from child: " << message_name << LL_ENDL;
}
}
else
{
if(mOwner != NULL)
{
mOwner->receivePluginMessage(message);
}
}
}
void FSWSAssetBlacklist::loadBlacklist()
{
if (gDirUtilp->fileExists(mBlacklistFileName))
{
llifstream blacklist_data_stream(mBlacklistFileName.c_str());
if (blacklist_data_stream.is_open())
{
LLSD data;
if (LLSDSerialize::fromXML(data, blacklist_data_stream) >= 1)
{
for (LLSD::map_const_iterator itr = data.beginMap(); itr != data.endMap(); ++itr)
{
LLUUID uid = LLUUID(itr->first);
LLXORCipher cipher(MAGIC_ID.mData, UUID_BYTES);
cipher.decrypt(uid.mData, UUID_BYTES);
LLSD entry_data = itr->second;
if (uid.isNull())
{
continue;
}
LLAssetType::EType type = S32toAssetType(entry_data["asset_type"].asInteger());
if (type == LLAssetType::AT_NONE)
{
continue;
}
addNewItemToBlacklistData(uid, entry_data, false);
}
}
}
blacklist_data_stream.close();
}
else
{
// Try to import old blacklist data from Phoenix
std::string old_file = gDirUtilp->getOSUserDir() + gDirUtilp->getDirDelimiter() + "SecondLife" + gDirUtilp->getDirDelimiter() + "user_settings" + gDirUtilp->getDirDelimiter() + "floater_blist_settings.xml";
if (gDirUtilp->fileExists(old_file))
{
LLSD datallsd;
llifstream oldfile;
oldfile.open(old_file.c_str());
if (oldfile.is_open())
{
LLSDSerialize::fromXMLDocument(datallsd, oldfile);
for (LLSD::map_const_iterator itr = datallsd.beginMap(); itr != datallsd.endMap(); ++itr)
{
LLUUID uid = LLUUID(itr->first);
LLSD data = itr->second;
if (uid.isNull() || !data.has("entry_name") || !data.has("entry_type") || !data.has("entry_date"))
{
continue;
}
LLAssetType::EType type = S32toAssetType(data["entry_type"].asInteger());
LLSD newdata;
newdata["asset_name"] = "[PHOENIX] " + data["entry_name"].asString();
newdata["asset_type"] = type;
newdata["asset_date"] = data["entry_date"].asString();
//if (!data["ID_hashed"].asBoolean())
//{
// uid = LLUUID::generateNewID(uid.asString() + "hash");
//}
addNewItemToBlacklistData(uid, newdata, false);
}
}
oldfile.close();
saveBlacklist();
LL_INFOS("AssetBlacklist") << "Using old Phoenix file: " << old_file << LL_ENDL;
}
else
{
LL_INFOS("AssetBlacklist") << "No Settings file found." << old_file << LL_ENDL;
}
}
}
//static
gboolean LLMediaImplGStreamer::bus_callback(GstBus *bus, GstMessage *message, gpointer data)
{
#ifdef LL_GST_REPORT_STATE_CHANGES
LL_DEBUGS("MediaCallback") << "Got GST message type: " << GST_MESSAGE_TYPE_NAME (message) << LL_ENDL;
#endif
LLMediaImplGStreamer *impl = (LLMediaImplGStreamer*)data;
switch (GST_MESSAGE_TYPE (message))
{
case GST_MESSAGE_BUFFERING:
{
gint percent = 0;
gst_message_parse_buffering(message, &percent);
#ifdef LL_GST_REPORT_STATE_CHANGES
LL_DEBUGS("MediaBuffering") << "GST buffering: " << percent << "%%" << LL_ENDL;
#endif
LLMediaEvent event( impl, percent );
impl->getEventEmitter().update( &LLMediaObserver::onUpdateProgress, event );
}
break;
case GST_MESSAGE_STATE_CHANGED:
{
GstState old_state;
GstState new_state;
GstState pending_state;
gst_message_parse_state_changed(message,
&old_state,
&new_state,
&pending_state);
#ifdef LL_GST_REPORT_STATE_CHANGES
// not generally very useful, and rather spammy.
LL_DEBUGS("MediaState") << "GST state change (old,<new>,pending): "<< get_gst_state_name(old_state) << ",<" << get_gst_state_name(new_state) << ">," << get_gst_state_name(pending_state) << LL_ENDL;
#endif // LL_GST_REPORT_STATE_CHANGES
switch (new_state)
{
case GST_STATE_VOID_PENDING:
break;
case GST_STATE_NULL:
#ifdef LL_GST_REPORT_STATE_CHANGES
LL_DEBUGS("MediaImpl") << "State changed to NULL" << LL_ENDL;
#endif
if (impl->getState() == GST_STATE_PLAYING)
{
// Stream was probably dropped, trying to restart
impl->play();
#ifdef LL_GST_REPORT_STATE_CHANGES
LL_DEBUGS("MediaImpl") << "Trying to restart." << LL_ENDL;
#endif
}
break;
case GST_STATE_READY:
break;
case GST_STATE_PAUSED:
break;
case GST_STATE_PLAYING:
//impl->mLastTitle = "";
LLMediaEvent event( impl, 100 );
impl->getEventEmitter().update( &LLMediaObserver::onUpdateProgress, event );
// emit an event to say that a media source was loaded
LLMediaEvent event2( impl );
impl->getEventEmitter().update( &LLMediaObserver::onMediaLoaded, event2 );
break;
}
break;
}
case GST_MESSAGE_ERROR:
{
GError *err = NULL;
gchar *debug = NULL;
gst_message_parse_error (message, &err, &debug);
LL_WARNS("MediaImpl") << "GST Error: " << err->message << LL_ENDL;
g_error_free (err);
g_free (debug);
impl->addCommand(LLMediaBase::COMMAND_STOP);
//impl->addCommand(LLMediaBase::COMMAND_START);
break;
}
case GST_MESSAGE_INFO:
{
GError *err = NULL;
gchar *debug = NULL;
gst_message_parse_info (message, &err, &debug);
LL_INFOS("MediaImpl") << "GST info: " << err->message
<< LL_ENDL;
g_error_free (err);
g_free (debug);
break;
}
case GST_MESSAGE_WARNING:
{
GError *err = NULL;
gchar *debug = NULL;
gst_message_parse_warning (message, &err, &debug);
LL_WARNS("MediaImpl") << "GST warning: " << err->message
<< LL_ENDL;
g_error_free (err);
g_free (debug);
break;
}
case GST_MESSAGE_TAG:
{
GstTagList *new_tags;
gst_message_parse_tag( message, &new_tags );
gchar *title;
if ( gst_tag_list_get_string(new_tags, GST_TAG_TITLE, &title) )
{
LL_INFOS("MediaInfo") << "Title: " << title << LL_ENDL;
std::string newtitle(title);
gst_tag_list_free(new_tags);
if ( newtitle != impl->mLastTitle && newtitle != "" )
{
impl->mLastTitle = newtitle;
LLMediaEvent event( impl, impl->mLastTitle );
impl->getEventEmitter().update( &LLMediaObserver::onMediaTitleChange, event );
}
g_free(title);
}
break;
}
case GST_MESSAGE_EOS:
{
/* end-of-stream */
LL_DEBUGS("MediaImpl") << "GST end-of-stream." << LL_ENDL;
if (impl->isLooping())
{
LL_DEBUGS("MediaImpl") << "looping media..." << LL_ENDL;
impl->stop();
impl->play();
}
else
{
// inject a COMMAND_STOP
impl->addCommand(LLMediaBase::COMMAND_STOP);
}
break;
}
default:
/* unhandled message */
break;
}
/* we want to be notified again the next time there is a message
* on the bus, so return true (false means we want to stop watching
* for messages on the bus and our callback should not be called again)
*/
return TRUE;
}
///////////////////////////////////////////////////////////////////////////////
// virtual
bool LLMediaImplGStreamer::updateMedia()
{
//LL_DEBUGS("MediaImpl") << "updating media..." << LL_ENDL;
// sanity check
if (mPump == NULL || mPlaybin == NULL)
{
#ifdef LL_GST_REPORT_STATE_CHANGES
LL_DEBUGS("MediaImpl") << "dead media..." << LL_ENDL;
#endif
mState = GST_STATE_NULL;
setStatus(LLMediaBase::STATUS_DEAD);
return false;
}
if (mState == GST_STATE_VOID_PENDING || mState == GST_STATE_NULL)
return false;
// process next outstanding command
switch (nextCommand())
{
case LLMediaBase::COMMAND_START:
LL_DEBUGS("MediaImpl") << "COMMAND_START" << LL_ENDL;
if (getStatus() == LLMediaBase::STATUS_PAUSED ||
getStatus() == LLMediaBase::STATUS_NAVIGATING ||
getStatus() == LLMediaBase::STATUS_STOPPED)
{
play();
setStatus(LLMediaBase::STATUS_STARTED);
clearCommand();
}
break;
case LLMediaBase::COMMAND_STOP:
LL_DEBUGS("MediaImpl") << "COMMAND_STOP" << LL_ENDL;
stop();
setStatus(LLMediaBase::STATUS_STOPPED);
clearCommand();
break;
case LLMediaBase::COMMAND_PAUSE:
LL_DEBUGS("MediaImpl") << "COMMAND_PAUSE" << LL_ENDL;
if (getStatus() == LLMediaBase::STATUS_STARTED)
{
pause();
setStatus(LLMediaBase::STATUS_PAUSED);
clearCommand();
}
break;
default:
LL_INFOS("MediaImpl") << "Unknown command" << LL_ENDL;
clearCommand();
break;
case LLMediaBase::COMMAND_NONE:
break;
}
// deal with results
if (g_main_context_pending(g_main_loop_get_context(mPump)))
{
g_main_context_iteration(g_main_loop_get_context(mPump), FALSE);
}
if (mVideoSink)
{
GST_OBJECT_LOCK(mVideoSink);
if (mVideoSink->retained_frame_ready)
{
#ifdef LL_GST_REPORT_STATE_CHANGES
LL_DEBUGS("MediaImpl") <<"NEW FRAME " << LL_ENDL;
#endif
if (mVideoSink->retained_frame_width != getMediaWidth() ||
mVideoSink->retained_frame_height != getMediaHeight())
// *TODO: also check for change in format
{
// just resize containe
int neww = mVideoSink->retained_frame_width;
int newh = mVideoSink->retained_frame_height;
int newd = SLVPixelFormatBytes[mVideoSink->retained_frame_format];
if (SLV_PF_RGBX == mVideoSink->retained_frame_format)
{
mTextureFormatPrimary = LL_MEDIA_RGBA;
mTextureFormatType = LL_MEDIA_UNSIGNED_INT_8_8_8_8_REV;
}
else
{
mTextureFormatPrimary = LL_MEDIA_BGRA;
mTextureFormatType = LL_MEDIA_UNSIGNED_INT_8_8_8_8_REV;
}
mMediaRowbytes = neww * newd;
LL_DEBUGS("MediaImpl")
<< "video container resized to " <<
neww <<"x"<< newh << LL_ENDL;
delete[] mediaData;
mediaData = new unsigned char[mMediaRowbytes *
newh];
GST_OBJECT_UNLOCK(mVideoSink);
setMediaDepth(newd);
setMediaSize(neww, newh);
return true;
}
// we're gonna totally consume this frame - reset 'ready' flag
mVideoSink->retained_frame_ready = FALSE;
memcpy(mediaData, mVideoSink->retained_frame_data,
mMediaRowbytes * getMediaHeight());
GST_OBJECT_UNLOCK(mVideoSink);
LLMediaEvent event( this );
mEventEmitter.update( &LLMediaObserver::onMediaContentsChange, event );
return true;
}
else
{
// nothing to do yet.
GST_OBJECT_UNLOCK(mVideoSink);
return true;
}
}
return true;
}
void GrowlManager::loadConfig()
{
std::string config_file = gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, "growl_notifications.xml");
if (config_file.empty())
{
LL_WARNS("GrowlConfig") << "Couldn't find growl_notifications.xml" << LL_ENDL;
return;
}
LL_INFOS("GrowlConfig") << "Loading growl notification config from " << config_file << LL_ENDL;
llifstream configs(config_file);
LLSD notificationLLSD;
std::set<std::string> notificationTypes;
notificationTypes.insert("Keyword Alert");
notificationTypes.insert(GROWL_IM_MESSAGE_TYPE);
if (configs.is_open())
{
LLSDSerialize::fromXML(notificationLLSD, configs);
for (LLSD::map_iterator itr = notificationLLSD.beginMap(); itr != notificationLLSD.endMap(); ++itr)
{
GrowlNotification ntype;
ntype.growlName = itr->second.get("GrowlName").asString();
notificationTypes.insert(ntype.growlName);
if (itr->second.has("GrowlTitle"))
{
ntype.growlTitle = itr->second.get("GrowlTitle").asString();
}
if (itr->second.has("GrowlBody"))
{
ntype.growlBody = itr->second.get("GrowlBody").asString();
}
if (itr->second.has("UseDefaultTextForTitle"))
{
ntype.useDefaultTextForTitle = itr->second.get("UseDefaultTextForTitle").asBoolean();
}
else
{
ntype.useDefaultTextForTitle = false;
}
if (itr->second.has("UseDefaultTextForBody"))
{
ntype.useDefaultTextForBody = itr->second.get("UseDefaultTextForBody").asBoolean();
}
else
{
ntype.useDefaultTextForBody = false;
}
if (!ntype.useDefaultTextForBody && !ntype.useDefaultTextForTitle && ntype.growlBody.empty() && ntype.growlTitle.empty())
{
ntype.useDefaultTextForBody = true;
}
this->mNotifications[itr->first] = ntype;
}
configs.close();
this->mNotifier->registerApplication("Firestorm Viewer", notificationTypes);
}
else
{
LL_WARNS("GrowlConfig") << "Couldn't open growl config file." << LL_ENDL;
}
}
////////////////////////////////////////////////////////////////////////////////
// inherited from LLViewerMediaObserver
//virtual
void LLMediaCtrl::handleMediaEvent(LLPluginClassMedia* self, EMediaEvent event)
{
switch(event)
{
case MEDIA_EVENT_CONTENT_UPDATED:
{
// LL_DEBUGS("Media") << "Media event: MEDIA_EVENT_CONTENT_UPDATED " << LL_ENDL;
};
break;
case MEDIA_EVENT_TIME_DURATION_UPDATED:
{
// LL_DEBUGS("Media") << "Media event: MEDIA_EVENT_TIME_DURATION_UPDATED, time is " << self->getCurrentTime() << " of " << self->getDuration() << LL_ENDL;
};
break;
case MEDIA_EVENT_SIZE_CHANGED:
{
LL_DEBUGS("Media") << "Media event: MEDIA_EVENT_SIZE_CHANGED " << LL_ENDL;
LLRect r = getRect();
reshape( r.getWidth(), r.getHeight(), FALSE );
};
break;
case MEDIA_EVENT_CURSOR_CHANGED:
{
LL_DEBUGS("Media") << "Media event: MEDIA_EVENT_CURSOR_CHANGED, new cursor is " << self->getCursorName() << LL_ENDL;
}
break;
case MEDIA_EVENT_NAVIGATE_BEGIN:
{
LL_DEBUGS("Media") << "Media event: MEDIA_EVENT_NAVIGATE_BEGIN, url is " << self->getNavigateURI() << LL_ENDL;
hideNotification();
};
break;
case MEDIA_EVENT_NAVIGATE_COMPLETE:
{
LL_DEBUGS("Media") << "Media event: MEDIA_EVENT_NAVIGATE_COMPLETE, result string is: " << self->getNavigateResultString() << LL_ENDL;
if(mHidingInitialLoad)
{
mHidingInitialLoad = false;
}
};
break;
case MEDIA_EVENT_PROGRESS_UPDATED:
{
LL_DEBUGS("Media") << "Media event: MEDIA_EVENT_PROGRESS_UPDATED, loading at " << self->getProgressPercent() << "%" << LL_ENDL;
};
break;
case MEDIA_EVENT_STATUS_TEXT_CHANGED:
{
LL_DEBUGS("Media") << "Media event: MEDIA_EVENT_STATUS_TEXT_CHANGED, new status text is: " << self->getStatusText() << LL_ENDL;
};
break;
case MEDIA_EVENT_LOCATION_CHANGED:
{
LL_DEBUGS("Media") << "Media event: MEDIA_EVENT_LOCATION_CHANGED, new uri is: " << self->getLocation() << LL_ENDL;
mCurrentNavUrl = self->getLocation();
};
break;
case MEDIA_EVENT_NAVIGATE_ERROR_PAGE:
{
LL_DEBUGS("Media") << "Media event: MEDIA_EVENT_NAVIGATE_ERROR_PAGE" << LL_ENDL;
if ( mErrorPageURL.length() > 0 )
{
navigateTo(mErrorPageURL, "text/html");
};
};
break;
case MEDIA_EVENT_CLICK_LINK_HREF:
{
LL_DEBUGS("Media") << "Media event: MEDIA_EVENT_CLICK_LINK_HREF, target is \"" << self->getClickTarget() << "\", uri is " << self->getClickURL() << LL_ENDL;
// retrieve the event parameters
std::string url = self->getClickURL();
std::string target = self->getClickTarget();
std::string uuid = self->getClickUUID();
LLNotification::Params notify_params("PopupAttempt");
notify_params.payload = LLSD().with("target", target).with("url", url).with("uuid", uuid).with("media_id", mMediaTextureID);
notify_params.functor(boost::bind(&LLMediaCtrl::onPopup, this, _1, _2));
if (mTrusted)
{
LLNotifications::instance().forceResponse(notify_params, 0);
}
else
{
LLNotifications::instance().add(notify_params);
}
break;
};
case MEDIA_EVENT_CLICK_LINK_NOFOLLOW:
{
LL_DEBUGS("Media") << "Media event: MEDIA_EVENT_CLICK_LINK_NOFOLLOW, uri is " << self->getClickURL() << LL_ENDL;
};
break;
case MEDIA_EVENT_PLUGIN_FAILED:
{
LL_DEBUGS("Media") << "Media event: MEDIA_EVENT_PLUGIN_FAILED" << LL_ENDL;
};
break;
case MEDIA_EVENT_PLUGIN_FAILED_LAUNCH:
{
LL_DEBUGS("Media") << "Media event: MEDIA_EVENT_PLUGIN_FAILED_LAUNCH" << LL_ENDL;
};
break;
case MEDIA_EVENT_NAME_CHANGED:
{
LL_DEBUGS("Media") << "Media event: MEDIA_EVENT_NAME_CHANGED" << LL_ENDL;
};
break;
case MEDIA_EVENT_CLOSE_REQUEST:
{
LL_DEBUGS("Media") << "Media event: MEDIA_EVENT_CLOSE_REQUEST" << LL_ENDL;
}
break;
case MEDIA_EVENT_PICK_FILE_REQUEST:
{
LL_DEBUGS("Media") << "Media event: MEDIA_EVENT_PICK_FILE_REQUEST" << LL_ENDL;
}
break;
case MEDIA_EVENT_GEOMETRY_CHANGE:
{
LL_DEBUGS("Media") << "Media event: MEDIA_EVENT_GEOMETRY_CHANGE, uuid is " << self->getClickUUID() << LL_ENDL;
}
break;
case MEDIA_EVENT_AUTH_REQUEST:
{
LLNotification::Params auth_request_params("AuthRequest");
// pass in host name and realm for site (may be zero length but will always exist)
LLSD args;
LLURL raw_url( self->getAuthURL().c_str() );
args["HOST_NAME"] = raw_url.getAuthority();
args["REALM"] = self->getAuthRealm();
auth_request_params.substitutions = args;
auth_request_params.payload = LLSD().with("media_id", mMediaTextureID);
auth_request_params.functor(boost::bind(&LLViewerMedia::onAuthSubmit, _1, _2));
LLNotifications::instance().add(auth_request_params);
};
break;
case MEDIA_EVENT_LINK_HOVERED:
{
LL_DEBUGS("Media") << "Media event: MEDIA_EVENT_LINK_HOVERED, hover text is: " << self->getHoverText() << LL_ENDL;
mHoverTextChanged = true;
};
break;
case MEDIA_EVENT_DEBUG_MESSAGE:
{
LL_INFOS("media") << self->getDebugMessageText() << LL_ENDL;
};
break;
default:
{
LL_WARNS("Media") << "Media event: unknown event type" << LL_ENDL;
};
};
// chain all events to any potential observers of this object.
emitEvent(self, event);
}
void LLChatBar::sendChatFromViewer(const LLWString &wtext, EChatType type, BOOL animate)
{
// Look for "/20 foo" channel chats.
S32 channel = 0;
LLWString out_text = stripChannelNumber(wtext, &channel);
std::string utf8_out_text = wstring_to_utf8str(out_text);
std::string utf8_text = wstring_to_utf8str(wtext);
utf8_text = utf8str_trim(utf8_text);
if (!utf8_text.empty())
{
utf8_text = utf8str_truncate(utf8_text, MAX_STRING - 1);
}
// [RLVa:KB] - Checked: 2010-03-27 (RLVa-1.2.0b) | Modified: RLVa-1.2.0b
if ( (0 == channel) && (rlv_handler_t::isEnabled()) )
{
// Adjust the (public) chat "volume" on chat and gestures (also takes care of playing the proper animation)
if ( ((CHAT_TYPE_SHOUT == type) || (CHAT_TYPE_NORMAL == type)) && (gRlvHandler.hasBehaviour(RLV_BHVR_CHATNORMAL)) )
type = CHAT_TYPE_WHISPER;
else if ( (CHAT_TYPE_SHOUT == type) && (gRlvHandler.hasBehaviour(RLV_BHVR_CHATSHOUT)) )
type = CHAT_TYPE_NORMAL;
else if ( (CHAT_TYPE_WHISPER == type) && (gRlvHandler.hasBehaviour(RLV_BHVR_CHATWHISPER)) )
type = CHAT_TYPE_NORMAL;
animate &= !gRlvHandler.hasBehaviour( (!RlvUtil::isEmote(utf8_text)) ? RLV_BHVR_REDIRCHAT : RLV_BHVR_REDIREMOTE );
}
// [/RLVa:KB]
LLCachedControl<bool> disable_chat_animation("SGDisableChatAnimation");
// Don't animate for chats people can't hear (chat to scripts)
if (animate && (channel == 0) && !disable_chat_animation)
{
if (type == CHAT_TYPE_WHISPER)
{
LL_DEBUGS() << "You whisper " << utf8_text << LL_ENDL;
gAgent.sendAnimationRequest(ANIM_AGENT_WHISPER, ANIM_REQUEST_START);
}
else if (type == CHAT_TYPE_NORMAL)
{
LL_DEBUGS() << "You say " << utf8_text << LL_ENDL;
gAgent.sendAnimationRequest(ANIM_AGENT_TALK, ANIM_REQUEST_START);
}
else if (type == CHAT_TYPE_SHOUT)
{
LL_DEBUGS() << "You shout " << utf8_text << LL_ENDL;
gAgent.sendAnimationRequest(ANIM_AGENT_SHOUT, ANIM_REQUEST_START);
}
else
{
LL_INFOS() << "send_chat_from_viewer() - invalid volume" << LL_ENDL;
return;
}
}
else
{
if (type != CHAT_TYPE_START && type != CHAT_TYPE_STOP)
{
LL_DEBUGS() << "Channel chat: " << utf8_text << LL_ENDL;
}
}
send_chat_from_viewer(utf8_out_text, type, channel);
}
//---------------------------------------------------------------------------
// Public methods
//---------------------------------------------------------------------------
LLPanelLogin::LLPanelLogin(const LLRect& rect)
: LLPanel(std::string("panel_login"), rect, FALSE), // not bordered
mLogoImage(LLUI::getUIImage("startup_logo.j2c"))
{
setFocusRoot(TRUE);
setBackgroundVisible(FALSE);
setBackgroundOpaque(TRUE);
LLPanelLogin::sInstance = this;
// add to front so we are the bottom-most child
gViewerWindow->getRootView()->addChildInBack(this);
LLUICtrlFactory::getInstance()->buildPanel(this, "panel_login.xml");
reshape(rect.getWidth(), rect.getHeight());
LLComboBox* username_combo(getChild<LLComboBox>("username_combo"));
username_combo->setCommitCallback(boost::bind(LLPanelLogin::onSelectLoginEntry, _1, this));
username_combo->setFocusLostCallback(boost::bind(&LLPanelLogin::onLoginComboLostFocus, this, username_combo));
username_combo->setPrevalidate(LLLineEditor::prevalidatePrintableNotPipe);
username_combo->setSuppressTentative(true);
username_combo->setSuppressAutoComplete(true);
childSetCommitCallback("remember_name_check", onNameCheckChanged);
LLLineEditor* password_edit(getChild<LLLineEditor>("password_edit"));
password_edit->setKeystrokeCallback(onPassKey);
// STEAM-14: When user presses Enter with this field in focus, initiate login
password_edit->setCommitCallback(mungePassword, this);
password_edit->setDrawAsterixes(TRUE);
getChild<LLUICtrl>("remove_login")->setCommitCallback(boost::bind(&LLPanelLogin::confirmDelete, this));
// change z sort of clickable text to be behind buttons
sendChildToBack(getChildView("channel_text"));
sendChildToBack(getChildView("forgot_password_text"));
//llinfos << " url history: " << LLSDOStreamer<LLSDXMLFormatter>(LLURLHistory::getURLHistory("regionuri")) << llendl;
LLComboBox* location_combo = getChild<LLComboBox>("start_location_combo");
updateLocationSelectorsVisibility(); // separate so that it can be called from preferences
location_combo->setAllowTextEntry(TRUE, 128, FALSE);
location_combo->setFocusLostCallback( boost::bind(&LLPanelLogin::onLocationSLURL, this) );
LLComboBox *server_choice_combo = getChild<LLComboBox>("grids_combo");
server_choice_combo->setCommitCallback(boost::bind(&LLPanelLogin::onSelectGrid, _1));
server_choice_combo->setFocusLostCallback(boost::bind(&LLPanelLogin::onSelectGrid, server_choice_combo));
// Load all of the grids, sorted, and then add a bar and the current grid at the top
updateGridCombo();
LLSLURL start_slurl(LLStartUp::getStartSLURL());
if ( !start_slurl.isSpatial() ) // has a start been established by the command line or NextLoginLocation ?
{
// no, so get the preference setting
std::string defaultStartLocation = gSavedSettings.getString("LoginLocation");
LL_INFOS("AppInit")<<"default LoginLocation '"<<defaultStartLocation<<"'"<<LL_ENDL;
LLSLURL defaultStart(defaultStartLocation);
if ( defaultStart.isSpatial() )
{
LLStartUp::setStartSLURL(defaultStart); // calls onUpdateStartSLURL
}
else
{
LL_INFOS("AppInit")<<"no valid LoginLocation, using home"<<LL_ENDL;
LLSLURL homeStart(LLSLURL::SIM_LOCATION_HOME);
LLStartUp::setStartSLURL(homeStart); // calls onUpdateStartSLURL
}
}
else
{
LLPanelLogin::onUpdateStartSLURL(start_slurl); // updates grid if needed
}
// Also set default button for subpanels, otherwise hitting enter in text entry fields won't login
{
LLButton* connect_btn(findChild<LLButton>("connect_btn"));
connect_btn->setCommitCallback(boost::bind(&LLPanelLogin::onClickConnect, this));
setDefaultBtn(connect_btn);
findChild<LLPanel>("name_panel")->setDefaultBtn(connect_btn);
findChild<LLPanel>("password_panel")->setDefaultBtn(connect_btn);
findChild<LLPanel>("grids_panel")->setDefaultBtn(connect_btn);
findChild<LLPanel>("location_panel")->setDefaultBtn(connect_btn);
findChild<LLPanel>("login_html")->setDefaultBtn(connect_btn);
}
childSetAction("grids_btn", onClickGrids, this);
std::string channel = gVersionChannel;
std::string version = llformat("%d.%d.%d (%d)",
gVersionMajor,
gVersionMinor,
gVersionPatch,
gVersionBuild );
LLTextBox* channel_text = getChild<LLTextBox>("channel_text");
channel_text->setTextArg("[CHANNEL]", channel); // though not displayed
channel_text->setTextArg("[VERSION]", version);
channel_text->setClickedCallback(boost::bind(&LLPanelLogin::onClickVersion,(void*)NULL));
LLTextBox* forgot_password_text = getChild<LLTextBox>("forgot_password_text");
forgot_password_text->setClickedCallback(boost::bind(&onClickForgotPassword));
LLTextBox* create_new_account_text = getChild<LLTextBox>("create_new_account_text");
create_new_account_text->setClickedCallback(boost::bind(&onClickNewAccount));
// get the web browser control
LLMediaCtrl* web_browser = getChild<LLMediaCtrl>("login_html");
web_browser->addObserver(this);
web_browser->setBackgroundColor(LLColor4::black);
reshapeBrowser();
refreshLoginPage();
gHippoGridManager->setCurrentGridChangeCallback(boost::bind(&LLPanelLogin::onCurGridChange,this,_1,_2));
// Load login history
std::string login_hist_filepath = gDirUtilp->getExpandedFilename(LL_PATH_USER_SETTINGS, "saved_logins_sg2.xml");
mLoginHistoryData = LLSavedLogins::loadFile(login_hist_filepath);
const LLSavedLoginsList& saved_login_entries(mLoginHistoryData.getEntries());
for (LLSavedLoginsList::const_reverse_iterator i = saved_login_entries.rbegin();
i != saved_login_entries.rend(); ++i)
{
LLSD e = i->asLLSD();
if (e.isMap() && gHippoGridManager->getGrid(i->getGrid()))
username_combo->add(getDisplayString(*i), e);
}
if (saved_login_entries.size() > 0)
{
setFields(*saved_login_entries.rbegin());
}
}
S32 start_net(S32& socket_out, int& nPort)
{
// Create socket, make non-blocking
// Init WinSock
int nRet;
int hSocket;
int snd_size = SEND_BUFFER_SIZE;
int rec_size = RECEIVE_BUFFER_SIZE;
int buff_size = 4;
// Initialize windows specific stuff
if(WSAStartup(0x0202, &stWSAData))
{
S32 err = WSAGetLastError();
WSACleanup();
LL_WARNS("AppInit") << "Windows Sockets initialization failed, err " << err << LL_ENDL;
return 1;
}
// Get a datagram socket
hSocket = (int)socket(AF_INET, SOCK_DGRAM, 0);
if (hSocket == INVALID_SOCKET)
{
S32 err = WSAGetLastError();
WSACleanup();
LL_WARNS("AppInit") << "socket() failed, err " << err << LL_ENDL;
return 2;
}
// Name the socket (assign the local port number to receive on)
stLclAddr.sin_family = AF_INET;
stLclAddr.sin_addr.s_addr = htonl(INADDR_ANY);
stLclAddr.sin_port = htons(nPort);
S32 attempt_port = nPort;
LL_DEBUGS("AppInit") << "attempting to connect on port " << attempt_port << LL_ENDL;
nRet = bind(hSocket, (struct sockaddr*) &stLclAddr, sizeof(stLclAddr));
if (nRet == SOCKET_ERROR)
{
// If we got an address in use error...
if (WSAGetLastError() == WSAEADDRINUSE)
{
// Try all ports from PORT_DISCOVERY_RANGE_MIN to PORT_DISCOVERY_RANGE_MAX
for(attempt_port = PORT_DISCOVERY_RANGE_MIN;
attempt_port <= PORT_DISCOVERY_RANGE_MAX;
attempt_port++)
{
stLclAddr.sin_port = htons(attempt_port);
LL_DEBUGS("AppInit") << "trying port " << attempt_port << LL_ENDL;
nRet = bind(hSocket, (struct sockaddr*) &stLclAddr, sizeof(stLclAddr));
if (!(nRet == SOCKET_ERROR &&
WSAGetLastError() == WSAEADDRINUSE))
{
break;
}
}
if (nRet == SOCKET_ERROR)
{
LL_WARNS("AppInit") << "startNet() : Couldn't find available network port." << LL_ENDL;
// Fail gracefully here in release
return 3;
}
}
else
// Some other socket error
{
LL_WARNS("AppInit") << llformat("bind() port: %d failed, Err: %d\n", nPort, WSAGetLastError()) << LL_ENDL;
// Fail gracefully in release.
return 4;
}
}
sockaddr_in socket_address;
S32 socket_address_size = sizeof(socket_address);
getsockname(hSocket, (SOCKADDR*) &socket_address, &socket_address_size);
attempt_port = ntohs(socket_address.sin_port);
LL_INFOS("AppInit") << "connected on port " << attempt_port << LL_ENDL;
nPort = attempt_port;
// Set socket to be non-blocking
unsigned long argp = 1;
nRet = ioctlsocket (hSocket, FIONBIO, &argp);
if (nRet == SOCKET_ERROR)
{
printf("Failed to set socket non-blocking, Err: %d\n",
WSAGetLastError());
}
// set a large receive buffer
nRet = setsockopt(hSocket, SOL_SOCKET, SO_RCVBUF, (char *)&rec_size, buff_size);
if (nRet)
{
LL_INFOS("AppInit") << "Can't set receive buffer size!" << LL_ENDL;
}
nRet = setsockopt(hSocket, SOL_SOCKET, SO_SNDBUF, (char *)&snd_size, buff_size);
if (nRet)
{
LL_INFOS("AppInit") << "Can't set send buffer size!" << LL_ENDL;
}
getsockopt(hSocket, SOL_SOCKET, SO_RCVBUF, (char *)&rec_size, &buff_size);
getsockopt(hSocket, SOL_SOCKET, SO_SNDBUF, (char *)&snd_size, &buff_size);
LL_DEBUGS("AppInit") << "startNet - receive buffer size : " << rec_size << LL_ENDL;
LL_DEBUGS("AppInit") << "startNet - send buffer size : " << snd_size << LL_ENDL;
// Setup a destination address
char achMCAddr[MAXADDRSTR] = " "; /* Flawfinder: ignore */
stDstAddr.sin_family = AF_INET;
stDstAddr.sin_addr.s_addr = inet_addr(achMCAddr);
stDstAddr.sin_port = htons(nPort);
socket_out = hSocket;
return 0;
}
void LLAudioEngine::startNextTransfer()
{
//LL_INFOS() << "LLAudioEngine::startNextTransfer()" << LL_ENDL;
if (mCurrentTransfer.notNull() || getMuted())
{
//LL_INFOS() << "Transfer in progress, aborting" << LL_ENDL;
return;
}
// Get the ID for the next asset that we want to transfer.
// Pick one in the following order:
LLUUID asset_id;
S32 i;
LLAudioSource *asp = NULL;
LLAudioData *adp = NULL;
data_map::iterator data_iter;
// Check all channels for currently playing sounds.
F32 max_pri = -1.f;
for (i = 0; i < MAX_CHANNELS; i++)
{
if (!mChannels[i])
{
continue;
}
asp = mChannels[i]->getSource();
if (!asp)
{
continue;
}
if (asp->getPriority() <= max_pri)
{
continue;
}
if (asp->getPriority() <= max_pri)
{
continue;
}
adp = asp->getCurrentData();
if (!adp)
{
continue;
}
if (!adp->hasLocalData() && adp->hasValidData())
{
asset_id = adp->getID();
max_pri = asp->getPriority();
}
}
// Check all channels for currently queued sounds.
if (asset_id.isNull())
{
max_pri = -1.f;
for (i = 0; i < MAX_CHANNELS; i++)
{
if (!mChannels[i])
{
continue;
}
LLAudioSource *asp;
asp = mChannels[i]->getSource();
if (!asp)
{
continue;
}
if (asp->getPriority() <= max_pri)
{
continue;
}
adp = asp->getQueuedData();
if (!adp)
{
continue;
}
if (!adp->hasLocalData() && adp->hasValidData())
{
asset_id = adp->getID();
max_pri = asp->getPriority();
}
}
}
// Check all live channels for other sounds (preloads).
if (asset_id.isNull())
{
max_pri = -1.f;
for (i = 0; i < MAX_CHANNELS; i++)
{
if (!mChannels[i])
{
continue;
}
LLAudioSource *asp;
asp = mChannels[i]->getSource();
if (!asp)
{
continue;
}
if (asp->getPriority() <= max_pri)
{
continue;
}
for (data_iter = asp->mPreloadMap.begin(); data_iter != asp->mPreloadMap.end(); data_iter++)
{
LLAudioData *adp = data_iter->second;
if (!adp)
{
continue;
}
if (!adp->hasLocalData() && adp->hasValidData())
{
asset_id = adp->getID();
max_pri = asp->getPriority();
}
}
}
}
// Check all sources
if (asset_id.isNull())
{
max_pri = -1.f;
source_map::iterator source_iter;
for (source_iter = mAllSources.begin(); source_iter != mAllSources.end(); source_iter++)
{
asp = source_iter->second;
if (!asp)
{
continue;
}
if (asp->getPriority() <= max_pri)
{
continue;
}
adp = asp->getCurrentData();
if (adp && !adp->hasLocalData() && adp->hasValidData())
{
asset_id = adp->getID();
max_pri = asp->getPriority();
continue;
}
adp = asp->getQueuedData();
if (adp && !adp->hasLocalData() && adp->hasValidData())
{
asset_id = adp->getID();
max_pri = asp->getPriority();
continue;
}
for (data_iter = asp->mPreloadMap.begin(); data_iter != asp->mPreloadMap.end(); data_iter++)
{
LLAudioData *adp = data_iter->second;
if (!adp)
{
continue;
}
if (!adp->hasLocalData() && adp->hasValidData())
{
asset_id = adp->getID();
max_pri = asp->getPriority();
break;
}
}
}
}
if (asset_id.notNull())
{
LL_INFOS() << "Getting asset data for: " << asset_id << LL_ENDL;
mCurrentTransfer = asset_id;
mCurrentTransferTimer.reset();
gAssetStorage->getAssetData(asset_id, LLAssetType::AT_SOUND,
assetCallback, NULL);
}
else
{
//LL_INFOS() << "No pending transfers?" << LL_ENDL;
}
}
void LLAudioEngine_OpenAL::updateWind(LLVector3 wind_vec, F32 camera_altitude)
{
LLVector3 wind_pos;
F64 pitch;
F64 center_freq;
ALenum error;
if (!mEnableWind)
return;
if(!mWindBuf)
return;
if (mWindUpdateTimer.checkExpirationAndReset(LL_WIND_UPDATE_INTERVAL))
{
// wind comes in as Linden coordinate (+X = forward, +Y = left, +Z = up)
// need to convert this to the conventional orientation DS3D and OpenAL use
// where +X = right, +Y = up, +Z = backwards
wind_vec.setVec(-wind_vec.mV[1], wind_vec.mV[2], -wind_vec.mV[0]);
pitch = 1.0 + mapWindVecToPitch(wind_vec);
center_freq = 80.0 * pow(pitch,2.5*(mapWindVecToGain(wind_vec)+1.0));
mWindGen->mTargetFreq = (F32)center_freq;
mWindGen->mTargetGain = (F32)mapWindVecToGain(wind_vec) * mMaxWindGain;
mWindGen->mTargetPanGainR = (F32)mapWindVecToPan(wind_vec);
alSourcei(mWindSource, AL_LOOPING, AL_FALSE);
alSource3f(mWindSource, AL_POSITION, 0.0, 0.0, 0.0);
alSource3f(mWindSource, AL_VELOCITY, 0.0, 0.0, 0.0);
alSourcef(mWindSource, AL_ROLLOFF_FACTOR, 0.0);
alSourcei(mWindSource, AL_SOURCE_RELATIVE, AL_TRUE);
}
// ok lets make a wind buffer now
int processed, queued, unprocessed;
alGetSourcei(mWindSource, AL_BUFFERS_PROCESSED, &processed);
alGetSourcei(mWindSource, AL_BUFFERS_QUEUED, &queued);
unprocessed = queued - processed;
// ensure that there are always at least 3x as many filled buffers
// queued as we managed to empty since last time.
mNumEmptyWindALBuffers = llmin(mNumEmptyWindALBuffers + processed * 3 - unprocessed, MAX_NUM_WIND_BUFFERS-unprocessed);
mNumEmptyWindALBuffers = llmax(mNumEmptyWindALBuffers, 0);
//LL_INFOS("OpenAL") << "mNumEmptyWindALBuffers: " << mNumEmptyWindALBuffers <<" (" << unprocessed << ":" << processed << ")" << LL_ENDL;
while(processed--) // unqueue old buffers
{
ALuint buffer;
int error;
alGetError(); /* clear error */
alSourceUnqueueBuffers(mWindSource, 1, &buffer);
error = alGetError();
if(error != AL_NO_ERROR)
{
LL_WARNS("OpenAL") << "LLAudioEngine_OpenAL::updateWind() error swapping (unqueuing) buffers" << LL_ENDL;
}
else
{
alDeleteBuffers(1, &buffer);
}
}
unprocessed += mNumEmptyWindALBuffers;
while (mNumEmptyWindALBuffers > 0) // fill+queue new buffers
{
ALuint buffer;
alGetError(); /* clear error */
alGenBuffers(1,&buffer);
if((error=alGetError()) != AL_NO_ERROR)
{
LL_WARNS("OpenAL") << "LLAudioEngine_OpenAL::initWind() Error creating wind buffer: " << error << LL_ENDL;
break;
}
alBufferData(buffer,
AL_FORMAT_STEREO16,
mWindGen->windGenerate(mWindBuf,
mWindBufSamples, 2),
mWindBufBytes,
mWindBufFreq);
error = alGetError();
if(error != AL_NO_ERROR)
LL_WARNS("OpenAL") << "LLAudioEngine_OpenAL::updateWind() error swapping (bufferdata) buffers" << LL_ENDL;
alSourceQueueBuffers(mWindSource, 1, &buffer);
error = alGetError();
if(error != AL_NO_ERROR)
LL_WARNS("OpenAL") << "LLAudioEngine_OpenAL::updateWind() error swapping (queuing) buffers" << LL_ENDL;
--mNumEmptyWindALBuffers;
}
int playing;
alGetSourcei(mWindSource, AL_SOURCE_STATE, &playing);
if(playing != AL_PLAYING)
{
alSourcePlay(mWindSource);
LL_INFOS("OpenAL") << "Wind had stopped - probably ran out of buffers - restarting: " << (unprocessed+mNumEmptyWindALBuffers) << " now queued." << LL_ENDL;
}
}
bool LLPluginMessagePipe::pump(F64 timeout)
{
bool result = true;
if(mSocket)
{
apr_status_t status;
apr_size_t size;
if(!mOutput.empty())
{
// write any outgoing messages
size = (apr_size_t)mOutput.size();
setSocketTimeout(0);
// LL_INFOS("Plugin") << "before apr_socket_send, size = " << size << LL_ENDL;
status = apr_socket_send(
mSocket->getSocket(),
(const char*)mOutput.data(),
&size);
// LL_INFOS("Plugin") << "after apr_socket_send, size = " << size << LL_ENDL;
if(status == APR_SUCCESS)
{
// success
mOutput = mOutput.substr(size);
}
else if(APR_STATUS_IS_EAGAIN(status))
{
// Socket buffer is full...
// remove the written part from the buffer and try again later.
mOutput = mOutput.substr(size);
}
else
{
// some other error
// Treat this as fatal.
ll_apr_warn_status(status);
if(mOwner)
{
mOwner->socketError(status);
}
result = false;
}
}
// FIXME: For some reason, the apr timeout stuff isn't working properly on windows.
// Until such time as we figure out why, don't try to use the socket timeout -- just sleep here instead.
#if LL_WINDOWS
if(result)
{
if(timeout != 0.0f)
{
ms_sleep((int)(timeout * 1000.0f));
timeout = 0.0f;
}
}
#endif
// Check for incoming messages
if(result)
{
char input_buf[1024];
apr_size_t request_size;
// Start out by reading one byte, so that any data received will wake us up.
request_size = 1;
// and use the timeout so we'll sleep if no data is available.
setSocketTimeout((apr_interval_time_t)(timeout * 1000000));
while(1)
{
size = request_size;
// LL_INFOS("Plugin") << "before apr_socket_recv, size = " << size << LL_ENDL;
status = apr_socket_recv(
mSocket->getSocket(),
input_buf,
&size);
// LL_INFOS("Plugin") << "after apr_socket_recv, size = " << size << LL_ENDL;
if(size > 0)
mInput.append(input_buf, size);
if(status == APR_SUCCESS)
{
// llinfos << "success, read " << size << llendl;
if(size != request_size)
{
// This was a short read, so we're done.
break;
}
}
else if(APR_STATUS_IS_TIMEUP(status))
{
// llinfos << "TIMEUP, read " << size << llendl;
// Timeout was hit. Since the initial read is 1 byte, this should never be a partial read.
break;
}
else if(APR_STATUS_IS_EAGAIN(status))
{
// llinfos << "EAGAIN, read " << size << llendl;
// We've been doing partial reads, and we're done now.
break;
}
else
{
// some other error
// Treat this as fatal.
ll_apr_warn_status(status);
if(mOwner)
{
mOwner->socketError(status);
}
result = false;
break;
}
// Second and subsequent reads should not use the timeout
setSocketTimeout(0);
// and should try to fill the input buffer
request_size = sizeof(input_buf);
}
processInput();
}
}
if(!result)
{
// If we got an error, we're done.
LL_INFOS("Plugin") << "Error from socket, cleaning up." << LL_ENDL;
delete this;
}
return result;
}
// passwd is already MD5 hashed by the time we get to it.
void LLUserAuth::authenticate(
const std::string& auth_uri,
const std::string& method,
const std::string& firstname,
const std::string& lastname,
const std::string& passwd,
const std::string& start,
BOOL skip_optional,
BOOL accept_tos,
BOOL accept_critical_message,
BOOL last_exec_froze,
const std::vector<const char*>& requested_options,
const std::string& hashed_mac,
const std::string& hashed_volume_serial)
{
std::string dpasswd("$1$");
dpasswd.append(passwd);
LL_INFOS("AppInit", "Authentication") << "Authenticating: " << firstname << " " << lastname << ", "
<< /*dpasswd.c_str() <<*/ LL_ENDL;
std::ostringstream option_str;
option_str << "Options: ";
std::ostream_iterator<const char*> appender(option_str, ", ");
std::copy(requested_options.begin(), requested_options.end(), appender);
option_str << "END";
LL_INFOS("AppInit", "Authentication") << option_str.str().c_str() << LL_ENDL;
mAuthResponse = E_NO_RESPONSE_YET;
//mDownloadTimer.reset();
// create the request
XMLRPC_REQUEST request = XMLRPC_RequestNew();
XMLRPC_RequestSetMethodName(request, method.c_str());
XMLRPC_RequestSetRequestType(request, xmlrpc_request_call);
// stuff the parameters
XMLRPC_VALUE params = XMLRPC_CreateVector(NULL, xmlrpc_vector_struct);
XMLRPC_VectorAppendString(params, "first", firstname.c_str(), 0);
XMLRPC_VectorAppendString(params, "last", lastname.c_str(), 0);
XMLRPC_VectorAppendString(params, "passwd", dpasswd.c_str(), 0);
XMLRPC_VectorAppendString(params, "start", start.c_str(), 0);
XMLRPC_VectorAppendString(params, "version", llformat("%d.%d.%d.%d", gVersionMajor, gVersionMinor, gVersionPatch, gVersionBuild).c_str(), 0);
// Singu Note: At the request of Linden Lab we change channel sent to the login server in the following way:
// * If channel is "Singularity" we change it to "Singularity Release", due to their statistics system
// not being able to distinguish just the release version
// * We append "64" to channel name on 64-bit for systems for the LL stats system to be able to produce independent
// crash statistics depending on the architecture
std::string chan(gVersionChannel);
if (chan == "Singularity")
{
chan += " Release";
}
#if defined(_WIN64) || defined(__x86_64__)
chan += " 64";
#endif
XMLRPC_VectorAppendString(params, "channel", chan.c_str(), 0);
XMLRPC_VectorAppendString(params, "platform", PLATFORM_STRING, 0);
XMLRPC_VectorAppendString(params, "platform_version", LLAppViewer::instance()->getOSInfo().getOSVersionString().c_str(), 0);
XMLRPC_VectorAppendString(params, "mac", hashed_mac.c_str(), 0);
// A bit of security through obscurity: id0 is volume_serial
// ^^^^^^^^^^^^^^^^^^^^
// you f*****g idiot - charbl
XMLRPC_VectorAppendString(params, "id0", hashed_volume_serial.c_str(), 0);
if (skip_optional)
{
XMLRPC_VectorAppendString(params, "skipoptional", "true", 0);
}
if (accept_tos)
{
XMLRPC_VectorAppendString(params, "agree_to_tos", "true", 0);
}
if (accept_critical_message)
{
XMLRPC_VectorAppendString(params, "read_critical", "true", 0);
}
XMLRPC_VectorAppendInt(params, "last_exec_event", (int) last_exec_froze);
// append optional requests in an array
XMLRPC_VALUE options = XMLRPC_CreateVector("options", xmlrpc_vector_array);
std::vector<const char*>::const_iterator it = requested_options.begin();
std::vector<const char*>::const_iterator end = requested_options.end();
for( ; it < end; ++it)
{
XMLRPC_VectorAppendString(options, NULL, (*it), 0);
}
XMLRPC_AddValueToVector(params, options);
// put the parameters on the request
XMLRPC_RequestSetData(request, params);
// Post the XML RPC.
mResponder = new XMLRPCResponder;
LLHTTPClient::postXMLRPC(auth_uri, request, mResponder);
LL_INFOS("AppInit", "Authentication") << "LLUserAuth::authenticate: uri=" << auth_uri << LL_ENDL;
}
void FSData::processData(const LLSD& fsData)
{
// Set Message Of The Day if present
if(fsData.has("MOTD"))
{
gAgent.mMOTD.assign(fsData["MOTD"]);
}
bool local_file = false;
if (!(fsData["Releases"].asInteger() == 0))
{
const std::string releases_filename = gDirUtilp->getExpandedFilename(LL_PATH_USER_SETTINGS, "releases.xml");
llifstream releases_file(releases_filename);
LLSD releases;
if(releases_file.is_open())
{
if(LLSDSerialize::fromXML(releases, releases_file) >= 1)
{
if(releases.has("ReleaseVersion"))
{
if (fsData["Releases"].asInteger() <= releases["ReleaseVersion"].asInteger())
{
processReleasesLLSD(releases);
local_file = true;
}
}
}
releases_file.close();
}
}
if (!local_file)
{
LL_INFOS("Data") << "Downloading " << releases_url << LL_ENDL;
LLHTTPClient::get(releases_url,new FSDownloader(releases_url));
}
local_file = false;
if (!(fsData["Agents"].asInteger() == 0))
{
const std::string agents_filename = gDirUtilp->getExpandedFilename(LL_PATH_USER_SETTINGS, "agents.xml");
llifstream agents_file(agents_filename);
LLSD agents;
if(agents_file.is_open())
{
if(LLSDSerialize::fromXML(agents, agents_file) >= 1)
{
if(agents.has("AgentsVersion"))
{
if (fsData["Agents"].asInteger() <= agents["AgentsVersion"].asInteger())
{
processAgentsLLSD(agents);
local_file = true;
}
}
}
agents_file.close();
}
}
if (!local_file)
{
LL_INFOS("Data") << "Downloading " << agents_url << LL_ENDL;
LLHTTPClient::get(agents_url,new FSDownloader(agents_url));
}
//TODO: add blacklist support
// LL_INFOS("Blacklist") << "Downloading blacklist.xml" << LL_ENDL;
// LLHTTPClient::get(url,new FSDownloader( FSData::msblacklist ),headers);
// FSUseLegacyClienttags: 0=Off, 1=Local Clienttags, 2=Download Clienttags
if(gSavedSettings.getU32("FSUseLegacyClienttags") > 1)
{
LLSD headers;
headers.insert("User-Agent", LLViewerMedia::getCurrentUserAgent());
headers.insert("viewer-version", versionid);
LLHTTPClient::get(legacy_client_list,new FSDownloader(legacy_client_list),headers);
LL_INFOS("CLIENTTAGS DOWNLOADER") << "Getting new tags" << LL_ENDL;
}
else if(gSavedSettings.getU32("FSUseLegacyClienttags") > 0)
{
updateClientTagsLocal();
}
}
void LLUserAuth::authenticate(
const std::string& auth_uri,
const std::string& method,
const std::string& firstname,
const std::string& lastname,
LLUUID web_login_key,
const std::string& start,
BOOL skip_optional,
BOOL accept_tos,
BOOL accept_critical_message,
BOOL last_exec_froze,
const std::vector<const char*>& requested_options,
const std::string& hashed_mac,
const std::string& hashed_volume_serial)
{
LL_INFOS("AppInit", "Authentication") << "Authenticating: " << firstname << " " << lastname << ", "
<< /*dpasswd.c_str() <<*/ LL_ENDL;
std::ostringstream option_str;
option_str << "Options: ";
std::ostream_iterator<const char*> appender(option_str, ", ");
std::copy(requested_options.begin(), requested_options.end(), appender);
option_str << "END";
LL_INFOS("AppInit", "Authentication") << option_str.str() << LL_ENDL;
mAuthResponse = E_NO_RESPONSE_YET;
//mDownloadTimer.reset();
// create the request
XMLRPC_REQUEST request = XMLRPC_RequestNew();
XMLRPC_RequestSetMethodName(request, method.c_str());
XMLRPC_RequestSetRequestType(request, xmlrpc_request_call);
// stuff the parameters
XMLRPC_VALUE params = XMLRPC_CreateVector(NULL, xmlrpc_vector_struct);
XMLRPC_VectorAppendString(params, "first", firstname.c_str(), 0);
XMLRPC_VectorAppendString(params, "last", lastname.c_str(), 0);
XMLRPC_VectorAppendString(params, "web_login_key", web_login_key.getString().c_str(), 0);
XMLRPC_VectorAppendString(params, "start", start.c_str(), 0);
XMLRPC_VectorAppendString(params, "version", gCurrentVersion.c_str(), 0); // Includes channel name
XMLRPC_VectorAppendString(params, "channel", gVersionChannel, 0);
XMLRPC_VectorAppendString(params, "platform", PLATFORM_STRING, 0);
XMLRPC_VectorAppendString(params, "platform_version", LLAppViewer::instance()->getOSInfo().getOSVersionString().c_str(), 0);
XMLRPC_VectorAppendString(params, "mac", hashed_mac.c_str(), 0);
// A bit of security through obscurity: id0 is volume_serial
XMLRPC_VectorAppendString(params, "id0", hashed_volume_serial.c_str(), 0);
if (skip_optional)
{
XMLRPC_VectorAppendString(params, "skipoptional", "true", 0);
}
if (accept_tos)
{
XMLRPC_VectorAppendString(params, "agree_to_tos", "true", 0);
}
if (accept_critical_message)
{
XMLRPC_VectorAppendString(params, "read_critical", "true", 0);
}
XMLRPC_VectorAppendInt(params, "last_exec_event", (int) last_exec_froze);
// append optional requests in an array
XMLRPC_VALUE options = XMLRPC_CreateVector("options", xmlrpc_vector_array);
std::vector<const char*>::const_iterator it = requested_options.begin();
std::vector<const char*>::const_iterator end = requested_options.end();
for( ; it < end; ++it)
{
XMLRPC_VectorAppendString(options, NULL, (*it), 0);
}
XMLRPC_AddValueToVector(params, options);
// put the parameters on the request
XMLRPC_RequestSetData(request, params);
mResponder = new XMLRPCResponder;
LLHTTPClient::postXMLRPC(auth_uri, request, mResponder);
LL_INFOS("AppInit", "Authentication") << "LLUserAuth::authenticate: uri=" << auth_uri << LL_ENDL;
}
// Run all steps until you're either done or hit a wait.
void LLGestureMgr::stepGesture(LLMultiGesture* gesture)
{
if (!gesture)
{
return;
}
if (!isAgentAvatarValid() || hasLoadingAssets(gesture)) return;
// Of the ones that started playing, have any stopped?
std::set<LLUUID>::iterator gest_it;
for (gest_it = gesture->mPlayingAnimIDs.begin();
gest_it != gesture->mPlayingAnimIDs.end();
)
{
if (gesture->mLocal)
{
// Local, erase if no longer playing (or gone)
LLMotion* motion = gAgentAvatarp->findMotion(*gest_it);
if (!motion || motion->isStopped())
gesture->mPlayingAnimIDs.erase(gest_it);
++gest_it;
}
// look in signaled animations (simulator's view of what is
// currently playing.
else if (gAgentAvatarp->mSignaledAnimations.find(*gest_it) != gAgentAvatarp->mSignaledAnimations.end())
{
++gest_it;
}
else
{
// not found, so not currently playing or scheduled to play
// delete from the triggered set
gesture->mPlayingAnimIDs.erase(gest_it++);
}
}
// Of all the animations that we asked the sim to start for us,
// pick up the ones that have actually started.
for (gest_it = gesture->mRequestedAnimIDs.begin();
gest_it != gesture->mRequestedAnimIDs.end();
)
{
LLVOAvatar::AnimIterator play_it = gAgentAvatarp->mSignaledAnimations.find(*gest_it);
if (play_it != gAgentAvatarp->mSignaledAnimations.end())
{
// Hooray, this animation has started playing!
// Copy into playing.
gesture->mPlayingAnimIDs.insert(*gest_it);
gesture->mRequestedAnimIDs.erase(gest_it++);
}
else
{
// nope, not playing yet
++gest_it;
}
}
// Run the current steps
BOOL waiting = FALSE;
while (!waiting && gesture->mPlaying)
{
// Get the current step, if there is one.
// Otherwise enter the waiting at end state.
LLGestureStep* step = NULL;
if (gesture->mCurrentStep < (S32)gesture->mSteps.size())
{
step = gesture->mSteps[gesture->mCurrentStep];
llassert(step != NULL);
}
else
{
// step stays null, we're off the end
gesture->mWaitingAtEnd = TRUE;
}
// If we're waiting at the end, wait for all gestures to stop
// playing.
// TODO: Wait for all sounds to complete as well.
if (gesture->mWaitingAtEnd)
{
// Neither do we have any pending requests, nor are they
// still playing.
if ((gesture->mRequestedAnimIDs.empty()
&& gesture->mPlayingAnimIDs.empty()))
{
// all animations are done playing
gesture->mWaitingAtEnd = FALSE;
gesture->mPlaying = FALSE;
}
else
{
waiting = TRUE;
}
continue;
}
// If we're waiting on our animations to stop, poll for
// completion.
if (gesture->mWaitingAnimations)
{
// Neither do we have any pending requests, nor are they
// still playing.
if ((gesture->mRequestedAnimIDs.empty()
&& gesture->mPlayingAnimIDs.empty()))
{
// all animations are done playing
gesture->mWaitingAnimations = FALSE;
gesture->mCurrentStep++;
}
else if (gesture->mWaitTimer.getElapsedTimeF32() > MAX_WAIT_ANIM_SECS)
{
// we've waited too long for an animation
LL_INFOS() << "Waited too long for animations to stop, continuing gesture."
<< LL_ENDL;
gesture->mWaitingAnimations = FALSE;
gesture->mCurrentStep++;
}
else
{
waiting = TRUE;
}
continue;
}
// If we're waiting a fixed amount of time, check for timer
// expiration.
if (gesture->mWaitingTimer)
{
// We're waiting for a certain amount of time to pass
LLGestureStepWait* wait_step = (LLGestureStepWait*)step;
F32 elapsed = gesture->mWaitTimer.getElapsedTimeF32();
if (elapsed > wait_step->mWaitSeconds)
{
// wait is done, continue execution
gesture->mWaitingTimer = FALSE;
gesture->mCurrentStep++;
}
else
{
// we're waiting, so execution is done for now
waiting = TRUE;
}
continue;
}
// Not waiting, do normal execution
runStep(gesture, step);
}
}
/*virtual*/
void LLClassifiedStatsResponder::httpFailure(void)
{
LL_INFOS() << "httpFailure: " << dumpResponse() << LL_ENDL;
}
////////////////////////////////////////////////////////////////////////////////
// inherited from LLViewerMediaObserver
//virtual
void LLMediaCtrl::handleMediaEvent(LLPluginClassMedia* self, EMediaEvent event)
{
switch(event)
{
case MEDIA_EVENT_CONTENT_UPDATED:
{
// LL_DEBUGS("Media") << "Media event: MEDIA_EVENT_CONTENT_UPDATED " << LL_ENDL;
};
break;
case MEDIA_EVENT_TIME_DURATION_UPDATED:
{
// LL_DEBUGS("Media") << "Media event: MEDIA_EVENT_TIME_DURATION_UPDATED, time is " << self->getCurrentTime() << " of " << self->getDuration() << LL_ENDL;
};
break;
case MEDIA_EVENT_SIZE_CHANGED:
{
LL_DEBUGS("Media") << "Media event: MEDIA_EVENT_SIZE_CHANGED " << LL_ENDL;
LLRect r = getRect();
reshape( r.getWidth(), r.getHeight(), FALSE );
};
break;
case MEDIA_EVENT_CURSOR_CHANGED:
{
LL_INFOS("Media") << "Media event: MEDIA_EVENT_CURSOR_CHANGED, new cursor is " << self->getCursorName() << LL_ENDL;
std::string cursor = self->getCursorName();
if(cursor == "arrow")
mLastSetCursor = UI_CURSOR_ARROW;
else if(cursor == "ibeam")
mLastSetCursor = UI_CURSOR_IBEAM;
else if(cursor == "splith")
mLastSetCursor = UI_CURSOR_SIZEWE;
else if(cursor == "splitv")
mLastSetCursor = UI_CURSOR_SIZENS;
else if(cursor == "hand")
mLastSetCursor = UI_CURSOR_HAND;
else // for anything else, default to the arrow
mLastSetCursor = UI_CURSOR_ARROW;
};
break;
case MEDIA_EVENT_NAVIGATE_BEGIN:
{
LL_DEBUGS("Media") << "Media event: MEDIA_EVENT_NAVIGATE_BEGIN, url is " << self->getNavigateURI() << LL_ENDL;
};
break;
case MEDIA_EVENT_NAVIGATE_COMPLETE:
{
LL_DEBUGS("Media") << "Media event: MEDIA_EVENT_NAVIGATE_COMPLETE, result string is: " << self->getNavigateResultString() << LL_ENDL;
if(mHidingInitialLoad)
{
mHidingInitialLoad = false;
}
};
break;
case MEDIA_EVENT_PROGRESS_UPDATED:
{
LL_DEBUGS("Media") << "Media event: MEDIA_EVENT_PROGRESS_UPDATED, loading at " << self->getProgressPercent() << "%" << LL_ENDL;
};
break;
case MEDIA_EVENT_STATUS_TEXT_CHANGED:
{
LL_DEBUGS("Media") << "Media event: MEDIA_EVENT_STATUS_TEXT_CHANGED, new status text is: " << self->getStatusText() << LL_ENDL;
};
break;
case MEDIA_EVENT_LOCATION_CHANGED:
{
LL_DEBUGS("Media") << "Media event: MEDIA_EVENT_LOCATION_CHANGED, new uri is: " << self->getLocation() << LL_ENDL;
};
break;
case MEDIA_EVENT_NAVIGATE_ERROR_PAGE:
{
LL_DEBUGS("Media") << "Media event: MEDIA_EVENT_NAVIGATE_ERROR_PAGE" << LL_ENDL;
};
break;
case MEDIA_EVENT_CLICK_LINK_HREF:
{
LL_DEBUGS("Media") << "Media event: MEDIA_EVENT_CLICK_LINK_HREF, target is \"" << self->getClickTarget() << "\", uri is " << self->getClickURL() << LL_ENDL;
onClickLinkHref(self);
};
break;
case MEDIA_EVENT_CLICK_LINK_NOFOLLOW:
{
LL_DEBUGS("Media") << "Media event: MEDIA_EVENT_CLICK_LINK_NOFOLLOW, uri is " << self->getClickURL() << LL_ENDL;
onClickLinkNoFollow(self);
};
break;
case MEDIA_EVENT_PLUGIN_FAILED:
{
LL_DEBUGS("Media") << "Media event: MEDIA_EVENT_PLUGIN_FAILED" << LL_ENDL;
};
break;
case MEDIA_EVENT_PLUGIN_FAILED_LAUNCH:
{
LL_DEBUGS("Media") << "Media event: MEDIA_EVENT_PLUGIN_FAILED_LAUNCH" << LL_ENDL;
};
break;
case MEDIA_EVENT_NAME_CHANGED:
{
LL_DEBUGS("Media") << "Media event: MEDIA_EVENT_NAME_CHANGED" << LL_ENDL;
};
break;
case MEDIA_EVENT_CLOSE_REQUEST:
{
LL_DEBUGS("Media") << "Media event: MEDIA_EVENT_CLOSE_REQUEST" << LL_ENDL;
};
break;
case MEDIA_EVENT_PICK_FILE_REQUEST:
{
LL_DEBUGS("Media") << "Media event: MEDIA_EVENT_PICK_FILE_REQUEST" << LL_ENDL;
};
break;
case MEDIA_EVENT_GEOMETRY_CHANGE:
{
LL_DEBUGS("Media") << "Media event: MEDIA_EVENT_GEOMETRY_CHANGE" << LL_ENDL;
};
break;
case MEDIA_EVENT_AUTH_REQUEST:
{
LL_DEBUGS("Media") << "Media event: MEDIA_EVENT_AUTH_REQUEST" << LL_ENDL;
};
break;
case MEDIA_EVENT_LINK_HOVERED:
{
LL_DEBUGS("Media") << "Media event: MEDIA_EVENT_LINK_HOVERED" << LL_ENDL;
};
break;
case MEDIA_EVENT_DEBUG_MESSAGE:
{
LL_INFOS("media") << self->getDebugMessageText() << LL_ENDL;
};
break;
default:
{
LL_WARNS("Media") << "Media event: unknown event type" << LL_ENDL;
};
};
// chain all events to any potential observers of this object.
emitEvent(self, event);
}
// static
void LLViewerTexLayerSetBuffer::dumpTotalByteCount()
{
LL_INFOS() << "Composite System GL Buffers: " << (LLViewerTexLayerSetBuffer::sGLByteCount/1024) << "KB" << LL_ENDL;
}
void LLQueryResponder::queryResult(const char *buf, size_t len)
{
const char *pos = buf;
int qdcount = DNS_HEADER_QDCOUNT(pos);
int ancount = DNS_HEADER_ANCOUNT(pos);
int nscount = DNS_HEADER_NSCOUNT(pos);
int arcount = DNS_HEADER_ARCOUNT(pos);
int ret;
if (qdcount == 0 || ancount + nscount + arcount == 0)
{
ret = ARES_ENODATA;
goto bail;
}
pos += NS_HFIXEDSZ;
for (int i = 0; i < qdcount; i++)
{
std::string ignore;
size_t enclen;
ret = LLAres::expandName(pos, buf, len, i == 0 ? mQuery : ignore,
enclen);
if (ret != ARES_SUCCESS)
{
goto bail;
}
pos += enclen;
if (i == 0)
{
int t = DNS_QUESTION_TYPE(pos);
switch (t)
{
case RES_A:
case RES_NS:
case RES_CNAME:
case RES_PTR:
case RES_AAAA:
case RES_SRV:
mType = (LLResType) t;
break;
default:
LL_INFOS() << "Cannot grok query type " << t << LL_ENDL;
ret = ARES_EBADQUERY;
goto bail;
}
}
pos += NS_QFIXEDSZ;
if (pos > buf + len)
{
ret = ARES_EBADRESP;
goto bail;
}
}
ret = parseSection(buf, len, ancount, pos, mAnswers);
if (ret != ARES_SUCCESS)
{
goto bail;
}
ret = parseSection(buf, len, nscount, pos, mAuthorities);
if (ret != ARES_SUCCESS)
{
goto bail;
}
ret = parseSection(buf, len, arcount, pos, mAdditional);
bail:
mResult = ret;
if (mResult == ARES_SUCCESS)
{
querySuccess();
} else {
queryError(mResult);
}
}
// Create the baked texture, send it out to the server, then wait for it to come
// back so we can switch to using it.
void LLViewerTexLayerSetBuffer::doUpload()
{
LLViewerTexLayerSet* layer_set = getViewerTexLayerSet();
LL_INFOS() << "Uploading baked " << layer_set->getBodyRegionName() << LL_ENDL;
LLViewerStats::getInstance()->incStat(LLViewerStats::ST_TEX_BAKES);
// Don't need caches since we're baked now. (note: we won't *really* be baked
// until this image is sent to the server and the Avatar Appearance message is received.)
layer_set->deleteCaches();
// Get the COLOR information from our texture
U8* baked_color_data = new U8[ mFullWidth * mFullHeight * 4 ];
glReadPixels(mOrigin.mX, mOrigin.mY, mFullWidth, mFullHeight, GL_RGBA, GL_UNSIGNED_BYTE, baked_color_data );
stop_glerror();
// Get the MASK information from our texture
LLGLSUIDefault gls_ui;
LLPointer<LLImageRaw> baked_mask_image = new LLImageRaw(mFullWidth, mFullHeight, 1 );
U8* baked_mask_data = baked_mask_image->getData();
layer_set->gatherMorphMaskAlpha(baked_mask_data,
mOrigin.mX, mOrigin.mY,
mFullWidth, mFullHeight);
// Create the baked image from our color and mask information
const S32 baked_image_components = 5; // red green blue [bump] clothing
LLPointer<LLImageRaw> baked_image = new LLImageRaw( mFullWidth, mFullHeight, baked_image_components );
U8* baked_image_data = baked_image->getData();
S32 i = 0;
for (S32 u=0; u < mFullWidth; u++)
{
for (S32 v=0; v < mFullHeight; v++)
{
baked_image_data[5*i + 0] = baked_color_data[4*i + 0];
baked_image_data[5*i + 1] = baked_color_data[4*i + 1];
baked_image_data[5*i + 2] = baked_color_data[4*i + 2];
baked_image_data[5*i + 3] = baked_color_data[4*i + 3]; // alpha should be correct for eyelashes.
baked_image_data[5*i + 4] = baked_mask_data[i];
i++;
}
}
LLPointer<LLImageJ2C> compressedImage = new LLImageJ2C;
const char* comment_text = LINDEN_J2C_COMMENT_PREFIX "RGBHM"; // writes into baked_color_data. 5 channels (rgb, heightfield/alpha, mask)
if (compressedImage->encode(baked_image, comment_text))
{
LLTransactionID tid;
tid.generate();
const LLAssetID asset_id = tid.makeAssetID(gAgent.getSecureSessionID());
if (LLVFile::writeFile(compressedImage->getData(), compressedImage->getDataSize(),
gVFS, asset_id, LLAssetType::AT_TEXTURE))
{
// Read back the file and validate.
BOOL valid = FALSE;
LLPointer<LLImageJ2C> integrity_test = new LLImageJ2C;
S32 file_size = 0;
U8* data = LLVFile::readFile(gVFS, LLImageBase::getPrivatePool(), asset_id, LLAssetType::AT_TEXTURE, &file_size);
if (data)
{
valid = integrity_test->validate(data, file_size); // integrity_test will delete 'data'
}
else
{
integrity_test->setLastError("Unable to read entire file");
}
if (valid)
{
const bool highest_lod = layer_set->isLocalTextureDataFinal();
// Baked_upload_data is owned by the responder and deleted after the request completes.
LLBakedUploadData* baked_upload_data = new LLBakedUploadData(gAgentAvatarp,
layer_set,
asset_id,
highest_lod);
// upload ID is used to avoid overlaps, e.g. when the user rapidly makes two changes outside of Face Edit.
mUploadID = asset_id;
// Upload the image
const std::string url = gAgent.getRegion()->getCapability("UploadBakedTexture");
if(!url.empty()
&& !LLPipeline::sForceOldBakedUpload // toggle debug setting UploadBakedTexOld to change between the new caps method and old method
&& (mUploadFailCount < (BAKE_UPLOAD_ATTEMPTS - 1))) // Try last ditch attempt via asset store if cap upload is failing.
{
LLSD body = LLSD::emptyMap();
// The responder will call LLViewerTexLayerSetBuffer::onTextureUploadComplete()
LLHTTPClient::post(url, body, new LLSendTexLayerResponder(body, mUploadID, LLAssetType::AT_TEXTURE, baked_upload_data));
LL_INFOS() << "Baked texture upload via capability of " << mUploadID << " to " << url << LL_ENDL;
}
else
{
gAssetStorage->storeAssetData(tid,
LLAssetType::AT_TEXTURE,
LLViewerTexLayerSetBuffer::onTextureUploadComplete,
baked_upload_data,
TRUE, // temp_file
TRUE, // is_priority
TRUE); // store_local
LL_INFOS() << "Baked texture upload via Asset Store." << LL_ENDL;
}
if (highest_lod)
{
// Sending the final LOD for the baked texture. All done, pause
// the upload timer so we know how long it took.
mNeedsUpload = FALSE;
mNeedsUploadTimer.pause();
}
else
{
// Sending a lower level LOD for the baked texture. Restart the upload timer.
mNumLowresUploads++;
mNeedsUploadTimer.unpause();
mNeedsUploadTimer.reset();
}
// Print out notification that we uploaded this texture.
if (gSavedSettings.getBOOL("DebugAvatarRezTime"))
{
const std::string lod_str = highest_lod ? "HighRes" : "LowRes";
LLSD args;
args["EXISTENCE"] = llformat("%d",(U32)layer_set->getAvatar()->debugGetExistenceTimeElapsedF32());
args["TIME"] = llformat("%d",(U32)mNeedsUploadTimer.getElapsedTimeF32());
args["BODYREGION"] = layer_set->getBodyRegionName();
args["RESOLUTION"] = lod_str;
LLNotificationsUtil::add("AvatarRezSelfBakedTextureUploadNotification",args);
LL_DEBUGS("Avatar") << self_av_string() << "Uploading [ name: " << layer_set->getBodyRegionName() << " res:" << lod_str << " time:" << (U32)mNeedsUploadTimer.getElapsedTimeF32() << " ]" << LL_ENDL;
}
}
else
{
// The read back and validate operation failed. Remove the uploaded file.
mUploadPending = FALSE;
LLVFile file(gVFS, asset_id, LLAssetType::AT_TEXTURE, LLVFile::WRITE);
file.remove();
LL_INFOS() << "Unable to create baked upload file (reason: corrupted)." << LL_ENDL;
}
}
}
else
{
// The VFS write file operation failed.
mUploadPending = FALSE;
LL_INFOS() << "Unable to create baked upload file (reason: failed to write file)" << LL_ENDL;
}
delete [] baked_color_data;
}
void LLAres::SrvResponder::srvError(int code)
{
LL_INFOS() << "LLAres::SrvResponder::srvError " << code << ": "
<< LLAres::strerror(code) << LL_ENDL;
}
// static
void LLViewerTexLayerSetBuffer::onTextureUploadComplete(const LLUUID& uuid,
void* userdata,
S32 result,
LLExtStat ext_status) // StoreAssetData callback (not fixed)
{
LLBakedUploadData* baked_upload_data = (LLBakedUploadData*)userdata;
if (isAgentAvatarValid() &&
!gAgentAvatarp->isDead() &&
(baked_upload_data->mAvatar == gAgentAvatarp) && // Sanity check: only the user's avatar should be uploading textures.
(baked_upload_data->mTexLayerSet->hasComposite()))
{
LLViewerTexLayerSetBuffer* layerset_buffer = baked_upload_data->mTexLayerSet->getViewerComposite();
S32 failures = layerset_buffer->mUploadFailCount;
layerset_buffer->mUploadFailCount = 0;
if (layerset_buffer->mUploadID.isNull())
{
// The upload got canceled, we should be in the
// process of baking a new texture so request an
// upload with the new data
// BAP: does this really belong in this callback, as
// opposed to where the cancellation takes place?
// suspect this does nothing.
layerset_buffer->requestUpload();
}
else if (baked_upload_data->mID == layerset_buffer->mUploadID)
{
// This is the upload we're currently waiting for.
layerset_buffer->mUploadID.setNull();
const std::string name(baked_upload_data->mTexLayerSet->getBodyRegionName());
const std::string resolution = baked_upload_data->mIsHighestRes ? " full res " : " low res ";
if (result >= 0)
{
layerset_buffer->mUploadPending = FALSE; // Allows sending of AgentSetAppearance later
LLAvatarAppearanceDefines::ETextureIndex baked_te = gAgentAvatarp->getBakedTE(layerset_buffer->getViewerTexLayerSet());
// Update baked texture info with the new UUID
U64 now = LLFrameTimer::getTotalTime(); // Record starting time
LL_INFOS() << "Baked" << resolution << "texture upload for " << name << " took " << (S32)((now - baked_upload_data->mStartTime) / 1000) << " ms" << LL_ENDL;
gAgentAvatarp->setNewBakedTexture(baked_te, uuid);
}
else
{
++failures;
S32 max_attempts = baked_upload_data->mIsHighestRes ? BAKE_UPLOAD_ATTEMPTS : 1; // only retry final bakes
LL_WARNS() << "Baked" << resolution << "texture upload for " << name << " failed (attempt " << failures << "/" << max_attempts << ")" << LL_ENDL;
if (failures < max_attempts)
{
layerset_buffer->mUploadFailCount = failures;
layerset_buffer->mUploadRetryTimer.start();
layerset_buffer->requestUpload();
}
}
}
else
{
LL_INFOS() << "Received baked texture out of date, ignored." << LL_ENDL;
}
gAgentAvatarp->dirtyMesh();
}
else
{
// Baked texture failed to upload (in which case since we
// didn't set the new baked texture, it means that they'll try
// and rebake it at some point in the future (after login?)),
// or this response to upload is out of date, in which case a
// current response should be on the way or already processed.
LL_WARNS() << "Baked upload failed" << LL_ENDL;
}
delete baked_upload_data;
}
void LLAres::HostResponder::hostError(int code)
{
LL_INFOS() << "LLAres::HostResponder::hostError " << code << ": "
<< LLAres::strerror(code) << LL_ENDL;
}
BOOL LLDXHardware::getInfo(BOOL vram_only)
{
LLTimer hw_timer;
BOOL ok = FALSE;
HRESULT hr;
CoInitialize(NULL);
IDxDiagProvider *dx_diag_providerp = NULL;
IDxDiagContainer *dx_diag_rootp = NULL;
IDxDiagContainer *devices_containerp = NULL;
// IDxDiagContainer *system_device_containerp= NULL;
IDxDiagContainer *device_containerp = NULL;
IDxDiagContainer *file_containerp = NULL;
IDxDiagContainer *driver_containerp = NULL;
// CoCreate a IDxDiagProvider*
LL_DEBUGS("AppInit") << "CoCreateInstance IID_IDxDiagProvider" << LL_ENDL;
hr = CoCreateInstance(CLSID_DxDiagProvider,
NULL,
CLSCTX_INPROC_SERVER,
IID_IDxDiagProvider,
(LPVOID*) &dx_diag_providerp);
if (FAILED(hr))
{
LL_WARNS("AppInit") << "No DXDiag provider found! DirectX 9 not installed!" << LL_ENDL;
gWriteDebug("No DXDiag provider found! DirectX 9 not installed!\n");
goto LCleanup;
}
if (SUCCEEDED(hr)) // if FAILED(hr) then dx9 is not installed
{
// Fill out a DXDIAG_INIT_PARAMS struct and pass it to IDxDiagContainer::Initialize
// Passing in TRUE for bAllowWHQLChecks, allows dxdiag to check if drivers are
// digital signed as logo'd by WHQL which may connect via internet to update
// WHQL certificates.
DXDIAG_INIT_PARAMS dx_diag_init_params;
ZeroMemory(&dx_diag_init_params, sizeof(DXDIAG_INIT_PARAMS));
dx_diag_init_params.dwSize = sizeof(DXDIAG_INIT_PARAMS);
dx_diag_init_params.dwDxDiagHeaderVersion = DXDIAG_DX9_SDK_VERSION;
dx_diag_init_params.bAllowWHQLChecks = TRUE;
dx_diag_init_params.pReserved = NULL;
LL_DEBUGS("AppInit") << "dx_diag_providerp->Initialize" << LL_ENDL;
hr = dx_diag_providerp->Initialize(&dx_diag_init_params);
if(FAILED(hr))
{
goto LCleanup;
}
LL_DEBUGS("AppInit") << "dx_diag_providerp->GetRootContainer" << LL_ENDL;
hr = dx_diag_providerp->GetRootContainer( &dx_diag_rootp );
if(FAILED(hr) || !dx_diag_rootp)
{
goto LCleanup;
}
HRESULT hr;
// Get display driver information
LL_DEBUGS("AppInit") << "dx_diag_rootp->GetChildContainer" << LL_ENDL;
hr = dx_diag_rootp->GetChildContainer(L"DxDiag_DisplayDevices", &devices_containerp);
if(FAILED(hr) || !devices_containerp)
{
goto LCleanup;
}
// Get device 0
LL_DEBUGS("AppInit") << "devices_containerp->GetChildContainer" << LL_ENDL;
hr = devices_containerp->GetChildContainer(L"0", &device_containerp);
if(FAILED(hr) || !device_containerp)
{
goto LCleanup;
}
// Get the English VRAM string
{
std::string ram_str = get_string(device_containerp, L"szDisplayMemoryEnglish");
// We don't need the device any more
SAFE_RELEASE(device_containerp);
// Dump the string as an int into the structure
char *stopstring;
mVRAM = strtol(ram_str.c_str(), &stopstring, 10);
LL_INFOS("AppInit") << "VRAM Detected: " << mVRAM << " DX9 string: " << ram_str << LL_ENDL;
}
if (vram_only)
{
ok = TRUE;
goto LCleanup;
}
/* for now, we ONLY do vram_only the rest of this
is commented out, to ensure no-one is tempted
to use it
// Now let's get device and driver information
// Get the IDxDiagContainer object called "DxDiag_SystemDevices".
// This call may take some time while dxdiag gathers the info.
DWORD num_devices = 0;
WCHAR wszContainer[256];
LL_DEBUGS("AppInit") << "dx_diag_rootp->GetChildContainer DxDiag_SystemDevices" << LL_ENDL;
hr = dx_diag_rootp->GetChildContainer(L"DxDiag_SystemDevices", &system_device_containerp);
if (FAILED(hr))
{
goto LCleanup;
}
hr = system_device_containerp->GetNumberOfChildContainers(&num_devices);
if (FAILED(hr))
{
goto LCleanup;
}
LL_DEBUGS("AppInit") << "DX9 iterating over devices" << LL_ENDL;
S32 device_num = 0;
for (device_num = 0; device_num < (S32)num_devices; device_num++)
{
hr = system_device_containerp->EnumChildContainerNames(device_num, wszContainer, 256);
if (FAILED(hr))
{
goto LCleanup;
}
hr = system_device_containerp->GetChildContainer(wszContainer, &device_containerp);
if (FAILED(hr) || device_containerp == NULL)
{
goto LCleanup;
}
std::string device_name = get_string(device_containerp, L"szDescription");
std::string device_id = get_string(device_containerp, L"szDeviceID");
LLDXDevice *dxdevicep = new LLDXDevice;
dxdevicep->mName = device_name;
dxdevicep->mPCIString = device_id;
mDevices[dxdevicep->mPCIString] = dxdevicep;
// Split the PCI string based on vendor, device, subsys, rev.
std::string str(device_id);
typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
boost::char_separator<char> sep("&\\", "", boost::keep_empty_tokens);
tokenizer tokens(str, sep);
tokenizer::iterator iter = tokens.begin();
S32 count = 0;
BOOL valid = TRUE;
for (;(iter != tokens.end()) && (count < 3);++iter)
{
switch (count)
{
case 0:
if (strcmp(iter->c_str(), "PCI"))
{
valid = FALSE;
}
break;
case 1:
dxdevicep->mVendorID = iter->c_str();
break;
case 2:
dxdevicep->mDeviceID = iter->c_str();
break;
default:
// Ignore it
break;
}
count++;
}
// Now, iterate through the related drivers
hr = device_containerp->GetChildContainer(L"Drivers", &driver_containerp);
if (FAILED(hr) || !driver_containerp)
{
goto LCleanup;
}
DWORD num_files = 0;
hr = driver_containerp->GetNumberOfChildContainers(&num_files);
if (FAILED(hr))
{
goto LCleanup;
}
S32 file_num = 0;
for (file_num = 0; file_num < (S32)num_files; file_num++ )
{
hr = driver_containerp->EnumChildContainerNames(file_num, wszContainer, 256);
if (FAILED(hr))
{
goto LCleanup;
}
hr = driver_containerp->GetChildContainer(wszContainer, &file_containerp);
if (FAILED(hr) || file_containerp == NULL)
{
goto LCleanup;
}
std::string driver_path = get_string(file_containerp, L"szPath");
std::string driver_name = get_string(file_containerp, L"szName");
std::string driver_version = get_string(file_containerp, L"szVersion");
std::string driver_date = get_string(file_containerp, L"szDatestampEnglish");
LLDXDriverFile *dxdriverfilep = new LLDXDriverFile;
dxdriverfilep->mName = driver_name;
dxdriverfilep->mFilepath= driver_path;
dxdriverfilep->mVersionString = driver_version;
dxdriverfilep->mVersion.set(driver_version);
dxdriverfilep->mDateString = driver_date;
dxdevicep->mDriverFiles[driver_name] = dxdriverfilep;
SAFE_RELEASE(file_containerp);
}
SAFE_RELEASE(device_containerp);
}
*/
}
// dumpDevices();
ok = TRUE;
LCleanup:
if (!ok)
{
LL_WARNS("AppInit") << "DX9 probe failed" << LL_ENDL;
gWriteDebug("DX9 probe failed\n");
}
SAFE_RELEASE(file_containerp);
SAFE_RELEASE(driver_containerp);
SAFE_RELEASE(device_containerp);
SAFE_RELEASE(devices_containerp);
SAFE_RELEASE(dx_diag_rootp);
SAFE_RELEASE(dx_diag_providerp);
CoUninitialize();
return ok;
}