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;
	}
Beispiel #3
0
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;
		}
Beispiel #7
0
 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
 }
Beispiel #8
0
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
}
Beispiel #14
0
LLHost get_sender()
{
	return LLHost(stSrcAddr.sin_addr.s_addr, ntohs(stSrcAddr.sin_port));
}
Beispiel #15
0
LLHost get_receiving_interface()
{
	return LLHost(gsnReceivingIFAddr, INVALID_PORT);
}
Beispiel #16
0
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);
}