void LLTemplateMessageBuilderTestObject::test<43>() // read past end of message -> default values (forward compatibility) { // build message with single block LLMessageTemplate messageTemplate = defaultTemplate(); messageTemplate.addBlock(defaultBlock(MVT_U32, 4, MBT_SINGLE)); U32 outValue, outValue2, inValue = 0xbbbbbbbb; LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate); builder->addU32(_PREHASH_Test0, inValue); const U32 bufferSize = 1024; U8 buffer[bufferSize]; memset(buffer, 0xaa, bufferSize); memset(buffer, 0, LL_PACKET_ID_SIZE); U32 builtSize = builder->buildMessage(buffer, bufferSize, 0); delete builder; // add block to reader template messageTemplate.addBlock(createBlock(_PREHASH_Test1, MVT_U32, 4, MBT_SINGLE)); // read message value and default value numberMap[1] = &messageTemplate; LLTemplateMessageReader* reader = new LLTemplateMessageReader(numberMap); reader->validateMessage(buffer, builtSize, LLHost()); reader->readMessage(buffer, LLHost()); reader->getU32(_PREHASH_Test0, _PREHASH_Test0, outValue); reader->getU32(_PREHASH_Test1, _PREHASH_Test0, outValue2); ensure_equals("Ensure present value ", outValue, inValue); ensure_equals("Ensure default value ", outValue2, 0); delete reader; }
void LLTemplateMessageBuilderTestObject::test<44>() // read variable block past end of message -> 0 repeats { // build message with single block LLMessageTemplate messageTemplate = defaultTemplate(); messageTemplate.addBlock(defaultBlock(MVT_U32, 4, MBT_SINGLE)); U32 outValue, outValue2, inValue = 0xbbbbbbbb; LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate); builder->addU32(_PREHASH_Test0, inValue); const U32 bufferSize = 1024; U8 buffer[bufferSize]; memset(buffer, 0xaa, bufferSize); memset(buffer, 0, LL_PACKET_ID_SIZE); U32 builtSize = builder->buildMessage(buffer, bufferSize, 0); delete builder; // add variable block to reader template messageTemplate.addBlock(createBlock(const_cast<char*>(_PREHASH_Test1), MVT_U32, 4)); // read message value and check block repeat count numberMap[1] = &messageTemplate; LLTemplateMessageReader* reader = new LLTemplateMessageReader(numberMap); reader->validateMessage(buffer, builtSize, LLHost()); reader->readMessage(buffer, LLHost()); reader->getU32(_PREHASH_Test0, _PREHASH_Test0, outValue); outValue2 = reader->getNumberOfBlocks(_PREHASH_Test1); ensure_equals("Ensure present value ", outValue, inValue); ensure_equals("Ensure 0 repeats ", outValue2, 0); delete reader; }
boost::signals2::connection LLCacheName::Impl::addPending(const LLUUID& id, const LLCacheNameCallback& callback) { PendingReply* reply = new PendingReply(id, LLHost()); boost::signals2::connection res = reply->setCallback(callback); mReplyQueue.push_back(reply); return res; }
// static bool LLFloaterMessageLog::onConfirmCloseCircuit(const LLSD& notification, const LLSD& response ) { S32 option = LLNotificationsUtil::getSelectedOption(notification, response); LLCircuitData* cdp = gMessageSystem->mCircuitInfo.findCircuit(LLHost(notification["payload"]["circuittoclose"].asString())); if(!cdp) return false; LLViewerRegion* regionp = LLWorld::getInstance()->getRegion(cdp->getHost()); switch(option) { case 0: // yes gMessageSystem->newMessageFast(_PREHASH_CloseCircuit); gMessageSystem->sendReliable(cdp->getHost()); break; case 2: // cancel return false; break; case 1: // no default: break; } if(gMessageSystem->findCircuitCode(cdp->getHost())) gMessageSystem->disableCircuit(cdp->getHost()); else gMessageSystem->mCircuitInfo.removeCircuitData(cdp->getHost()); if(regionp) { LLHost myhost = regionp->getHost(); LLSD args; args["MESSAGE"] = "That host had a region associated with it.\nDo you want to clean that up?"; LLSD payload; payload["regionhost"] = myhost.getString(); LLNotificationsUtil::add("GenericAlertYesCancel", args, payload, onConfirmRemoveRegion); } return false; }
// static bool LLFloaterMessageLog::onConfirmRemoveRegion(const LLSD& notification, const LLSD& response ) { S32 option = LLNotificationsUtil::getSelectedOption(notification, response); if(option == 0) // yes LLWorld::getInstance()->removeRegion(LLHost(notification["payload"]["regionhost"].asString())); return false; }
/** Takes ownership of builder */ static LLTemplateMessageReader* setReader( LLMessageTemplate& messageTemplate, LLTemplateMessageBuilder* builder, U8 offset = 0) { numberMap[1] = &messageTemplate; const U32 bufferSize = 1024; U8 buffer[bufferSize]; // zero out the packet ID field memset(buffer, 0, LL_PACKET_ID_SIZE); U32 builtSize = builder->buildMessage(buffer, bufferSize, offset); delete builder; LLTemplateMessageReader* reader = new LLTemplateMessageReader(numberMap); reader->validateMessage(buffer, builtSize, LLHost()); reader->readMessage(buffer, LLHost()); return reader; }
data(): pumps(LLEventPumps::instance()), uri(std::string("http://") + LLHost("127.0.0.1", commtest_data::getport("PORT")).getString()) { // These variables are required by machinery used by // LLXMLRPCTransaction. The values reflect reality for this test // executable; hopefully these values are correct. gSavedSettings.declareBOOL("BrowserProxyEnabled", FALSE, "", FALSE); // don't persist gSavedSettings.declareBOOL("NoVerifySSLCert", TRUE, "", FALSE); // don't persist }
LLViewerObject *LLViewerObjectList::replaceObject(const LLUUID &id, const LLPCode pcode, LLViewerRegion *regionp) { LLViewerObject *old_instance = findObject(id); if (old_instance) { cleanupReferences(old_instance); old_instance->markDead(); return createObject(pcode, regionp, id, old_instance->getLocalID(), LLHost()); } return NULL; }
int LunaMessageBuilder::SendMessage(lua_State* L) { bool ret = false; size_t len = 0; const char* arg = luaL_optlstring(L, 2, gAgent.getRegionHost().getString().c_str(), &len); std::string region_host(arg, len); LLHost proper_region_host = LLHost(region_host); //check that this was a valid host if(proper_region_host.isOk()) ret = sendMessage(proper_region_host, mMessageBuffer); mMessageBuffer = ""; lua_pushboolean(L, ret); return 1; }
void LLTemplateMessageBuilderTestObject::test<45>() // read variable length data past end of message -> 0 length { // build message with single block LLMessageTemplate messageTemplate = defaultTemplate(); messageTemplate.addBlock(defaultBlock(MVT_U32, 4, MBT_SINGLE)); U32 outValue, outValue2, inValue = 0xbbbbbbbb; LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate); builder->addU32(_PREHASH_Test0, inValue); const U32 bufferSize = 1024; U8 buffer[bufferSize]; memset(buffer, 0xaa, bufferSize); memset(buffer, 0, LL_PACKET_ID_SIZE); U32 builtSize = builder->buildMessage(buffer, bufferSize, 0); delete builder; // add variable block to reader template messageTemplate.addBlock(createBlock(_PREHASH_Test1, MVT_VARIABLE, 4, MBT_SINGLE)); // read message value and default string numberMap[1] = &messageTemplate; LLTemplateMessageReader* reader = new LLTemplateMessageReader(numberMap); reader->validateMessage(buffer, builtSize, LLHost()); reader->readMessage(buffer, LLHost()); reader->getU32(_PREHASH_Test0, _PREHASH_Test0, outValue); char outBuffer[bufferSize]; memset(buffer, 0xcc, bufferSize); reader->getString(_PREHASH_Test1, _PREHASH_Test0, bufferSize, outBuffer); outValue2 = reader->getNumberOfBlocks(_PREHASH_Test1); ensure_equals("Ensure present value ", outValue, inValue); ensure_equals("Ensure unchanged buffer ", strlen(outBuffer), 0); delete reader; }
void LLTrustedMessageService::post(LLHTTPNode::ResponsePtr response, const LLSD& context, const LLSD& input) const { std::string name = context["request"]["wildcard"]["message-name"]; std::string senderIP = context["request"]["remote-host"]; std::string senderPort = context["request"]["headers"] ["x-GIS-udp-listen-port"]; LLSD message_data; std::string sender = senderIP + ":" + senderPort; message_data["sender"] = sender; message_data["body"] = input; // untrusted senders should not have access to the trusted message // service, but this can happen in development, so check and warn LLMessageConfig::SenderTrust trust = LLMessageConfig::getSenderTrustedness(name); if ((trust == LLMessageConfig::TRUSTED || (trust == LLMessageConfig::NOT_SET && gMessageSystem->isTrustedMessage(name))) && !gMessageSystem->isTrustedSender(LLHost(sender))) { LL_WARNS("Messaging") << "trusted message POST to /trusted-message/" << name << " from unknown or untrusted sender " << sender << llendl; response->status(403, "Unknown or untrusted sender"); } else { gMessageSystem->receivedMessageFromTrustedSender(); if (input.has("binary-template-data")) { llinfos << "Dispatching template: " << input << llendl; // try and send this message using udp dispatch LLMessageSystem::dispatchTemplate(name, message_data, response); } else { llinfos << "Dispatching without template: " << input << llendl; LLMessageSystem::dispatch(name, message_data, response); } } }
int LunaMessageBuilder::SendRawMessage(lua_State* L) { int nArgs = lua_gettop(L)-1; //element 1 is the table we are in. std::string region_host = gAgent.getRegionHost().getString(); int i = 2; //arg magic bool ret = false; if(nArgs >= 2) { region_host.assign(luaL_checkstring(L, i)); i++; } std::string message(luaL_checkstring(L,i)); mMessageBuffer = ""; LLHost proper_region_host = LLHost(region_host); //check that this was a valid host if(proper_region_host.isOk()) ret = sendMessage(proper_region_host, message); lua_pushboolean(L, ret); return 1; }
static void variable_table_push(lua_State* L, LLMessageSystem *msg, const char* block_name, const int block_num, LLLuaTable &block_variable_table, LLMessageVariable* variable) { const char* var_name = variable->getName(); block_variable_table.pushkeystring(L, var_name); switch(variable->getType()) { case MVT_U8: { U8 value; msg->getU8Fast(block_name, var_name, value, block_num); block_variable_table.pushvalue(L, value); } break; case MVT_U16: { U16 value; msg->getU16Fast(block_name, var_name, value, block_num); block_variable_table.pushvalue(L, value); } break; case MVT_U32: { U32 value; msg->getU32Fast(block_name, var_name, value, block_num); block_variable_table.pushvalue(L, value); } break; case MVT_U64: { U64 value; msg->getU64Fast(block_name, var_name, value, block_num); block_variable_table.pushvalue(L, value); } break; case MVT_S8: { S8 value; msg->getS8Fast(block_name, var_name, value, block_num); block_variable_table.pushvalue(L, value); } break; case MVT_S16: { S16 value; msg->getS16Fast(block_name, var_name, value, block_num); block_variable_table.pushvalue(L, value); } break; case MVT_S32: { S32 value; msg->getS32Fast(block_name, var_name, value, block_num); block_variable_table.pushvalue(L, value); } break; case MVT_F32: { F32 value; msg->getF32Fast(block_name, var_name, value, block_num); block_variable_table.pushvalue(L, value); } break; case MVT_F64: { F64 value; msg->getF64Fast(block_name, var_name, value, block_num); block_variable_table.pushvalue(L, value); } break; case MVT_LLVector3: { LLVector3 value; msg->getVector3Fast(block_name, var_name, value, block_num); LLLuaTable vector(L); for(int i = 0; i < 3; i++) { vector.pushvalue(L, value.mV[i]); } block_variable_table.push(L); } break; case MVT_LLVector3d: { LLVector3d value; msg->getVector3dFast(block_name, var_name, value, block_num); LLLuaTable vector(L); for(int i = 0; i < 3; i++) { vector.pushvalue(L, value.mdV[i]); } block_variable_table.push(L); } break; case MVT_LLVector4: { LLVector4 value; msg->getVector4Fast(block_name, var_name, value, block_num); LLLuaTable vector(L); for(int i = 0; i < 4; i++) { vector.pushvalue(L, value.mV[i]); } block_variable_table.push(L); } break; case MVT_LLQuaternion: { LLQuaternion value; msg->getQuatFast(block_name, var_name, value, block_num); LLLuaTable quat(L); for(int i = 0; i < 4; i++) { quat.pushvalue(L, value.mQ[i]); } block_variable_table.push(L); } break; case MVT_LLUUID: { LLUUID value; msg->getUUIDFast(block_name, var_name, value, block_num); block_variable_table.pushvalue(L, value.asString().c_str()); } break; case MVT_BOOL: { BOOL value; msg->getBOOLFast(block_name, var_name, value, block_num); block_variable_table.pushvalue(L, value); } break; case MVT_IP_ADDR: { U32 value; msg->getIPAddrFast(block_name, var_name, value, block_num); block_variable_table.pushvalue(L, LLHost(value, 0).getIPString().c_str()); } break; case MVT_IP_PORT: { U16 value; msg->getIPPort(block_name, var_name, value, block_num); block_variable_table.pushvalue(L, value); } case MVT_VARIABLE: case MVT_FIXED: default: { S32 size = msg->getSize(block_name, block_num, var_name); if(size) { std::ostringstream stream; char* value = new char[size + 1]; msg->getBinaryDataFast(block_name, var_name, value, size, block_num); value[size] = '\0'; S32 readable = 0; S32 unreadable = 0; for(S32 i = 0; i < size; i++) { if(!value[i]) { if(i != (size - 1)) { // don't want null terminator hiding data unreadable = S32_MAX; break; } } else if(value[i] < 0x20 || value[i] >= 0x7F) { unreadable = S32_MAX; break; } else readable++; } if(readable >= unreadable) { stream << value; delete[] value; } else { for(S32 i = 0; i < size; i++) stream << llformat("%02X ", (U8)value[i]); } block_variable_table.pushvalue(L, stream.str().c_str()); } else { block_variable_table.pushvalue(L,""); //empty string } } break; } //end switch }
LLHost get_sender() { return LLHost(stSrcAddr.sin_addr.s_addr, ntohs(stSrcAddr.sin_port)); }
LLHost get_receiving_interface() { return LLHost(gsnReceivingIFAddr, INVALID_PORT); }
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 doSendPacket(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 = doSendPacket(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 = doSendPacket(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. llwarns << "Throwing away outbound packet, overflowing buffer" << llendl; } else { static LLTimer queue_timer; if ((mOutBufferLength > 4192) && queue_timer.getElapsedTimeF32() > 1.f) { // Add it to the queue llinfos << "Outbound packet queue " << mOutBufferLength << " bytes" << llendl; queue_timer.reset(); } packetp = new LLPacketBuffer(host, send_buffer, buf_size); mOutBufferLength += packetp->getSize(); mSendQueue.push(packetp); } } return status; }
// static void LLFloaterMessageLog::onConfirmRemoveRegion(S32 option, LLSD payload) { if(option == 0) // yes LLWorld::getInstance()->removeRegion(LLHost(payload["regionhost"].asString())); }
// static std::string LLFloaterMessageLogItem::getString(LLTemplateMessageReader* readerp, const char* block_name, S32 block_num, const char* var_name, e_message_variable_type var_type, BOOL &returned_hex, BOOL summary_mode) { returned_hex = FALSE; std::stringstream stream; char* value; U32 valueU32; U16 valueU16; LLVector3 valueVector3; LLVector3d valueVector3d; LLVector4 valueVector4; LLQuaternion valueQuaternion; LLUUID valueLLUUID; switch(var_type) { case MVT_U8: U8 valueU8; readerp->getU8(block_name, var_name, valueU8, block_num); stream << U32(valueU8); break; case MVT_U16: readerp->getU16(block_name, var_name, valueU16, block_num); stream << valueU16; break; case MVT_U32: readerp->getU32(block_name, var_name, valueU32, block_num); stream << valueU32; break; case MVT_U64: U64 valueU64; readerp->getU64(block_name, var_name, valueU64, block_num); stream << valueU64; break; case MVT_S8: S8 valueS8; readerp->getS8(block_name, var_name, valueS8, block_num); stream << S32(valueS8); break; case MVT_S16: S16 valueS16; readerp->getS16(block_name, var_name, valueS16, block_num); stream << valueS16; break; case MVT_S32: S32 valueS32; readerp->getS32(block_name, var_name, valueS32, block_num); stream << valueS32; break; /*case MVT_S64: S64 valueS64; readerp->getS64(block_name, var_name, valueS64, block_num); stream << valueS64; break;*/ case MVT_F32: F32 valueF32; readerp->getF32(block_name, var_name, valueF32, block_num); stream << valueF32; break; case MVT_F64: F64 valueF64; readerp->getF64(block_name, var_name, valueF64, block_num); stream << valueF64; break; case MVT_LLVector3: readerp->getVector3(block_name, var_name, valueVector3, block_num); //stream << valueVector3; stream << "<" << valueVector3.mV[0] << ", " << valueVector3.mV[1] << ", " << valueVector3.mV[2] << ">"; break; case MVT_LLVector3d: readerp->getVector3d(block_name, var_name, valueVector3d, block_num); //stream << valueVector3d; stream << "<" << valueVector3d.mdV[0] << ", " << valueVector3d.mdV[1] << ", " << valueVector3d.mdV[2] << ">"; break; case MVT_LLVector4: readerp->getVector4(block_name, var_name, valueVector4, block_num); //stream << valueVector4; stream << "<" << valueVector4.mV[0] << ", " << valueVector4.mV[1] << ", " << valueVector4.mV[2] << ", " << valueVector4.mV[3] << ">"; break; case MVT_LLQuaternion: readerp->getQuat(block_name, var_name, valueQuaternion, block_num); //stream << valueQuaternion; stream << "<" << valueQuaternion.mQ[0] << ", " << valueQuaternion.mQ[1] << ", " << valueQuaternion.mQ[2] << ", " << valueQuaternion.mQ[3] << ">"; break; case MVT_LLUUID: readerp->getUUID(block_name, var_name, valueLLUUID, block_num); stream << valueLLUUID; break; case MVT_BOOL: BOOL valueBOOL; readerp->getBOOL(block_name, var_name, valueBOOL, block_num); stream << valueBOOL; break; case MVT_IP_ADDR: readerp->getIPAddr(block_name, var_name, valueU32, block_num); stream << LLHost(valueU32, 0).getIPString(); break; case MVT_IP_PORT: readerp->getIPPort(block_name, var_name, valueU16, block_num); stream << valueU16; case MVT_VARIABLE: case MVT_FIXED: default: S32 size = readerp->getSize(block_name, block_num, var_name); if(size) { value = new char[size + 1]; readerp->getBinaryData(block_name, var_name, value, size, block_num); value[size] = '\0'; S32 readable = 0; S32 unreadable = 0; S32 end = (summary_mode && (size > 64)) ? 64 : size; for(S32 i = 0; i < end; i++) { if(!value[i]) { if(i != (end - 1)) { // don't want null terminator hiding data unreadable = S32_MAX; break; } } else if(value[i] < 0x20 || value[i] >= 0x7F) { if(summary_mode) unreadable++; else { // never want any wrong characters outside of summary mode unreadable = S32_MAX; break; } } else readable++; } if(readable >= unreadable) { if(summary_mode && (size > 64)) { for(S32 i = 60; i < 63; i++) value[i] = '.'; value[63] = '\0'; } stream << value; delete[] value; } else { returned_hex = TRUE; S32 end = (summary_mode && (size > 8)) ? 8 : size; for(S32 i = 0; i < end; i++) //stream << std::uppercase << std::hex << U32(value[i]) << " "; stream << llformat("%02X ", (U8)value[i]); if(summary_mode && (size > 8)) stream << " ... "; } } break; } return stream.str(); }
BOOL LLFloaterMessageLogItem::isOutgoing() { return mFromHost == LLHost(16777343, gMessageSystem->getListenPort()); }
void LLPluginProcessChild::init(U32 launcher_port) { mLauncherHost = LLHost("127.0.0.1", launcher_port); setState(STATE_INITIALIZED); }