void LLTemplateMessageReader::getQuat(const char *block, const char *var,
LLQuaternion &q, S32 blocknum)
{
LLVector3 vec;
getData(block, var, &vec.mV[0], sizeof(vec.mV), blocknum);
if( vec.isFinite() )
{
q.unpackFromVector3( vec );
}
else
{
llwarns << "non-finite in getQuatFast " << block << " " << var
<< llendl;
q.loadIdentity();
}
}
void LLSDMessageBuilder::copyFromMessageData(const LLMsgData& data)
{
// copy the blocks
// counting variables used to encode multiple block info
S32 block_count = 0;
char* block_name = NULL;
// loop through msg blocks to loop through variables, totalling up size
// data and filling the new (send) message
LLMsgData::msg_blk_data_map_t::const_iterator iter =
data.mMemberBlocks.begin();
LLMsgData::msg_blk_data_map_t::const_iterator end =
data.mMemberBlocks.end();
for(; iter != end; ++iter)
{
const LLMsgBlkData* mbci = iter->second;
if(!mbci) continue;
// do we need to encode a block code?
if (block_count == 0)
{
block_count = mbci->mBlockNumber;
block_name = (char*)mbci->mName;
}
// counting down mutliple blocks
block_count--;
nextBlock(block_name);
// now loop through the variables
LLMsgBlkData::msg_var_data_map_t::const_iterator dit = mbci->mMemberVarData.begin();
LLMsgBlkData::msg_var_data_map_t::const_iterator dend = mbci->mMemberVarData.end();
for(; dit != dend; ++dit)
{
const LLMsgVarData& mvci = *dit;
const char* varname = mvci.getName();
switch(mvci.getType())
{
case MVT_FIXED:
addBinaryData(varname, mvci.getData(), mvci.getSize());
break;
case MVT_VARIABLE:
{
const char end = ((const char*)mvci.getData())[mvci.getSize()-1]; // Ensure null terminated
if (mvci.getDataSize() == 1 && end == 0)
{
addString(varname, (const char*)mvci.getData());
}
else
{
addBinaryData(varname, mvci.getData(), mvci.getSize());
}
break;
}
case MVT_U8:
addU8(varname, *(U8*)mvci.getData());
break;
case MVT_U16:
addU16(varname, *(U16*)mvci.getData());
break;
case MVT_U32:
addU32(varname, *(U32*)mvci.getData());
break;
case MVT_U64:
addU64(varname, *(U64*)mvci.getData());
break;
case MVT_S8:
addS8(varname, *(S8*)mvci.getData());
break;
case MVT_S16:
addS16(varname, *(S16*)mvci.getData());
break;
case MVT_S32:
addS32(varname, *(S32*)mvci.getData());
break;
// S64 not supported in LLSD so we just truncate it
case MVT_S64:
addS32(varname, *(S64*)mvci.getData());
break;
case MVT_F32:
addF32(varname, *(F32*)mvci.getData());
break;
case MVT_F64:
addF64(varname, *(F64*)mvci.getData());
break;
case MVT_LLVector3:
addVector3(varname, *(LLVector3*)mvci.getData());
break;
case MVT_LLVector3d:
addVector3d(varname, *(LLVector3d*)mvci.getData());
break;
case MVT_LLVector4:
addVector4(varname, *(LLVector4*)mvci.getData());
break;
case MVT_LLQuaternion:
{
LLVector3 v = *(LLVector3*)mvci.getData();
LLQuaternion q;
q.unpackFromVector3(v);
addQuat(varname, q);
break;
}
case MVT_LLUUID:
addUUID(varname, *(LLUUID*)mvci.getData());
break;
case MVT_BOOL:
addBOOL(varname, *(BOOL*)mvci.getData());
break;
case MVT_IP_ADDR:
addIPAddr(varname, *(U32*)mvci.getData());
break;
case MVT_IP_PORT:
addIPPort(varname, *(U16*)mvci.getData());
break;
case MVT_U16Vec3:
//treated as an array of 6 bytes
addBinaryData(varname, mvci.getData(), 6);
break;
case MVT_U16Quat:
//treated as an array of 8 bytes
addBinaryData(varname, mvci.getData(), 8);
break;
case MVT_S16Array:
addBinaryData(varname, mvci.getData(), mvci.getSize());
break;
default:
llwarns << "Unknown type in conversion of message to LLSD" << llendl;
break;
}
}
}
}
BOOL LLEasyMessageSender::addField(e_message_variable_type var_type, const char* var_name, std::string input, BOOL hex)
{
LLStringUtil::trim(input);
if(input.length() < 1 && var_type != MVT_VARIABLE)
return FALSE;
U8 valueU8;
U16 valueU16;
U32 valueU32;
U64 valueU64;
S8 valueS8;
S16 valueS16;
S32 valueS32;
// S64 valueS64;
F32 valueF32;
F64 valueF64;
LLVector3 valueVector3;
LLVector3d valueVector3d;
LLVector4 valueVector4;
LLQuaternion valueQuaternion;
LLUUID valueLLUUID;
BOOL valueBOOL;
std::string input_lower = input;
LLStringUtil::toLower(input_lower);
if(input_lower == "$agentid")
input = gAgent.getID().asString();
else if(input_lower == "$sessionid")
input = gAgent.getSessionID().asString();
else if(input_lower == "$uuid")
{
LLUUID id;
id.generate();
input = id.asString();
}
else if(input_lower == "$circuitcode")
{
std::stringstream temp_stream;
temp_stream << gMessageSystem->mOurCircuitCode;
input = temp_stream.str();
}
else if(input_lower == "$regionhandle")
{
std::stringstream temp_stream;
temp_stream << (gAgent.getRegion() ? gAgent.getRegion()->getHandle() : 0);
input = temp_stream.str();
}
else if(input_lower == "$position" || input_lower == "$pos")
{
std::stringstream temp_stream;
valueVector3 = gAgent.getPositionAgent();
temp_stream << "<" << valueVector3[0] << ", " << valueVector3[1] << ", " << valueVector3[2] << ">";
input = temp_stream.str();
}
//convert from a text representation of hex to binary
if(hex)
{
if(var_type != MVT_VARIABLE && var_type != MVT_FIXED)
return FALSE;
int len = input_lower.length();
const char* cstr = input_lower.c_str();
std::string new_input("");
BOOL nibble = FALSE;
char byte = 0;
for(int i = 0; i < len; i++)
{
char c = cstr[i];
if(c >= 0x30 && c <= 0x39)
c -= 0x30;
else if(c >= 0x61 && c <= 0x66)
c -= 0x57;
else if(c != 0x20)
return FALSE;
else
continue;
if(!nibble)
byte = c << 4;
else
new_input.push_back(byte | c);
nibble = !nibble;
}
if(nibble)
return FALSE;
input = new_input;
}
std::stringstream stream(input);
std::vector<std::string> tokens;
switch(var_type)
{
case MVT_U8:
if(input.substr(0, 1) == "-")
return FALSE;
if((stream >> valueU32).fail())
return FALSE;
valueU8 = (U8)valueU32;
gMessageSystem->addU8(var_name, valueU8);
return TRUE;
break;
case MVT_U16:
if(input.substr(0, 1) == "-")
return FALSE;
if((stream >> valueU16).fail())
return FALSE;
gMessageSystem->addU16(var_name, valueU16);
return TRUE;
break;
case MVT_U32:
if(input.substr(0, 1) == "-")
return FALSE;
if((stream >> valueU32).fail())
return FALSE;
gMessageSystem->addU32(var_name, valueU32);
return TRUE;
break;
case MVT_U64:
if(input.substr(0, 1) == "-")
return FALSE;
if((stream >> valueU64).fail())
return FALSE;
gMessageSystem->addU64(var_name, valueU64);
return TRUE;
break;
case MVT_S8:
if((stream >> valueS8).fail())
return FALSE;
gMessageSystem->addS8(var_name, valueS8);
return TRUE;
break;
case MVT_S16:
if((stream >> valueS16).fail())
return FALSE;
gMessageSystem->addS16(var_name, valueS16);
return TRUE;
break;
case MVT_S32:
if((stream >> valueS32).fail())
return FALSE;
gMessageSystem->addS32(var_name, valueS32);
return TRUE;
break;
/*
case MVT_S64:
if((stream >> valueS64).fail())
return FALSE;
gMessageSystem->addS64(var_name, valueS64);
return TRUE;
break;
*/
case MVT_F32:
if((stream >> valueF32).fail())
return FALSE;
gMessageSystem->addF32(var_name, valueF32);
return TRUE;
break;
case MVT_F64:
if((stream >> valueF64).fail())
return FALSE;
gMessageSystem->addF64(var_name, valueF64);
return TRUE;
break;
case MVT_LLVector3:
LLStringUtil::trim(input);
if(input.substr(0, 1) != "<" || input.substr(input.length() - 1, 1) != ">")
return FALSE;
tokens = split(input.substr(1, input.length() - 2), ",");
if(tokens.size() != 3)
return FALSE;
for(int i = 0; i < 3; i++)
{
stream.clear();
stream.str(tokens[i]);
if((stream >> valueF32).fail())
return FALSE;
valueVector3.mV[i] = valueF32;
}
gMessageSystem->addVector3(var_name, valueVector3);
return TRUE;
break;
case MVT_LLVector3d:
LLStringUtil::trim(input);
if(input.substr(0, 1) != "<" || input.substr(input.length() - 1, 1) != ">")
return FALSE;
tokens = split(input.substr(1, input.length() - 2), ",");
if(tokens.size() != 3)
return FALSE;
for(int i = 0; i < 3; i++)
{
stream.clear();
stream.str(tokens[i]);
if((stream >> valueF64).fail())
return FALSE;
valueVector3d.mdV[i] = valueF64;
}
gMessageSystem->addVector3d(var_name, valueVector3d);
return TRUE;
break;
case MVT_LLVector4:
LLStringUtil::trim(input);
if(input.substr(0, 1) != "<" || input.substr(input.length() - 1, 1) != ">")
return FALSE;
tokens = split(input.substr(1, input.length() - 2), ",");
if(tokens.size() != 4)
return FALSE;
for(int i = 0; i < 4; i++)
{
stream.clear();
stream.str(tokens[i]);
if((stream >> valueF32).fail())
return FALSE;
valueVector4.mV[i] = valueF32;
}
gMessageSystem->addVector4(var_name, valueVector4);
return TRUE;
break;
case MVT_LLQuaternion:
LLStringUtil::trim(input);
if(input.substr(0, 1) != "<" || input.substr(input.length() - 1, 1) != ">")
return FALSE;
tokens = split(input.substr(1, input.length() - 2), ",");
if(tokens.size() == 3)
{
for(int i = 0; i < 3; i++)
{
stream.clear();
stream.str(tokens[i]);
if((stream >> valueF32).fail())
return FALSE;
valueVector3.mV[i] = valueF32;
}
valueQuaternion.unpackFromVector3(valueVector3);
}
else if(tokens.size() == 4)
{
for(int i = 0; i < 4; i++)
{
stream.clear();
stream.str(tokens[i]);
if((stream >> valueF32).fail())
return FALSE;
valueQuaternion.mQ[i] = valueF32;
}
}
else
return FALSE;
