Singularity-Viewer/SingularityViewer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'master' of https://github.com/singularity-viewer/SingularityViewer.git

Browse Source 
# Conflicts:
#	indra/llmath/lloctree.h
#	indra/newview/llsurface.cpp
This commit is contained in:
Shyotl
2020-03-15 00:53:20 -05:00
parent 26976b715d e502b87b63
commit a29491658b
353 changed files with 22075 additions and 10251 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
indra/llcommon/CMakeLists.txt
View File

@@ -269,12 +269,6 @@ list(APPEND llcommon_SOURCE_FILES ${cwdebug_SOURCE_FILES})
list(APPEND llcommon_SOURCE_FILES ${llcommon_HEADER_FILES})
if(NOT WORD_SIZE EQUAL 32)
if(NOT WINDOWS)
add_definitions(-fPIC)
endif(NOT WINDOWS)
endif(NOT WORD_SIZE EQUAL 32)
if(LLCOMMON_LINK_SHARED)
add_library (llcommon SHARED ${llcommon_SOURCE_FILES})
if(WINDOWS)
@@ -286,6 +280,8 @@ else(LLCOMMON_LINK_SHARED)
add_library (llcommon ${llcommon_SOURCE_FILES})
endif(LLCOMMON_LINK_SHARED)
set_target_properties(llcommon PROPERTIES POSITION_INDEPENDENT_CODE TRUE)
target_link_libraries(
llcommon
PUBLIC
@@ -304,6 +300,7 @@ target_link_libraries(
${Boost_SYSTEM_LIBRARY}
${CORESERVICES_LIBRARY}
${URIPARSER_LIBRARY}
${RT_LIBRARY}
)
if (DARWIN)

7
indra/llcommon/llerror.cpp
View File

@@ -1338,7 +1338,7 @@ namespace LLError
}
#if LL_WINDOWS
// VC80 was optimizing the error away.
// MSVC is optimizing the error away.
#pragma optimize("", off)
#endif
void crashAndLoop(const std::string& message)
@@ -1347,9 +1347,8 @@ namespace LLError
DoutFatal(dc::core, message);
#else
// Now, we go kaboom!
int* make_me_crash = NULL;
*make_me_crash = 0;
int* make_me_crash = nullptr;
*make_me_crash = 0xDEADBEEF;
while(true)
{

5
indra/llcommon/llfile.cpp
View File

@@ -282,6 +282,11 @@ int LLFile::rename_nowarn(const std::string& filename, const std::string& newnam
int rc = _wrename(utf16filename.c_str(),utf16newname.c_str());
#else
int rc = ::rename(filename.c_str(),newname.c_str());
if (rc == -1 && errno == EXDEV)
{
rc = std::system(("mv '" + filename + "' '" + newname + '\'').data());
errno = 0;
}
#endif
return rc;
}

168
indra/llcommon/llsd.cpp
View File

@@ -126,9 +126,9 @@ public:
virtual Date asDate() const { return LLDate(); }
virtual URI asURI() const { return LLURI(); }
virtual const Binary& asBinary() const { static const std::vector<U8> empty; return empty; }
virtual const String& asStringRef() const { static const std::string empty; return empty; }
virtual const String& asStringRef() const { static const std::string empty; return empty; }
virtual bool has(const String&) const { return false; }
virtual LLSD get(const String&) const { return LLSD(); }
virtual LLSD getKeys() const { return LLSD::emptyArray(); }
@@ -142,11 +142,11 @@ public:
virtual const std::map<String, LLSD>& map() const { static const std::map<String, LLSD> empty; return empty; }
virtual std::map<String, LLSD>& map() { static std::map<String, LLSD> empty; return empty; }
LLSD::map_const_iterator beginMap() const { return endMap(); }
LLSD::map_const_iterator beginMap() const { return map().begin(); }
LLSD::map_const_iterator endMap() const { return map().end(); }
virtual const std::vector<LLSD>& array() const { static const std::vector<LLSD> empty; return empty; }
virtual std::vector<LLSD>& array() { static std::vector<LLSD> empty; return empty; }
LLSD::array_const_iterator beginArray() const { return endArray(); }
LLSD::array_const_iterator beginArray() const { return array().begin(); }
LLSD::array_const_iterator endArray() const { return array().end(); }
virtual void dumpStats() const;
@@ -187,10 +187,11 @@ namespace
public:
ImplBase(DataRef value) : mValue(value) { }
virtual LLSD::Type type() const { return T; }
LLSD::Type type() const override { return T; }
using LLSD::Impl::assign; // Unhiding base class virtuals...
virtual void assign(LLSD::Impl*& var, DataRef value) {
void assign(LLSD::Impl*& var, DataRef value) override
{
if (shared())
{
Impl::assign(var, value);
@@ -203,16 +204,16 @@ namespace
};
class ImplBoolean
class ImplBoolean final
: public ImplBase<LLSD::TypeBoolean, LLSD::Boolean>
{
public:
ImplBoolean(LLSD::Boolean v) : Base(v) { }
virtual LLSD::Boolean asBoolean() const { return mValue; }
virtual LLSD::Integer asInteger() const { return mValue ? 1 : 0; }
virtual LLSD::Real asReal() const { return mValue ? 1 : 0; }
virtual LLSD::String asString() const;
LLSD::Boolean asBoolean() const override { return mValue; }
LLSD::Integer asInteger() const override { return mValue ? 1 : 0; }
LLSD::Real asReal() const override { return mValue ? 1 : 0; }
LLSD::String asString() const override;
};
LLSD::String ImplBoolean::asString() const
@@ -224,32 +225,32 @@ namespace
{ return mValue ? "true" : ""; }
class ImplInteger
class ImplInteger final
: public ImplBase<LLSD::TypeInteger, LLSD::Integer>
{
public:
ImplInteger(LLSD::Integer v) : Base(v) { }
virtual LLSD::Boolean asBoolean() const { return mValue != 0; }
virtual LLSD::Integer asInteger() const { return mValue; }
virtual LLSD::Real asReal() const { return mValue; }
virtual LLSD::String asString() const;
LLSD::Boolean asBoolean() const override { return mValue != 0; }
LLSD::Integer asInteger() const override { return mValue; }
LLSD::Real asReal() const override { return mValue; }
LLSD::String asString() const override;
};
LLSD::String ImplInteger::asString() const
{ return llformat("%d", mValue); }
class ImplReal
class ImplReal final
: public ImplBase<LLSD::TypeReal, LLSD::Real>
{
public:
ImplReal(LLSD::Real v) : Base(v) { }
virtual LLSD::Boolean asBoolean() const;
virtual LLSD::Integer asInteger() const;
virtual LLSD::Real asReal() const { return mValue; }
virtual LLSD::String asString() const;
LLSD::Boolean asBoolean() const override;
LLSD::Integer asInteger() const override;
LLSD::Real asReal() const override { return mValue; }
LLSD::String asString() const override;
};
LLSD::Boolean ImplReal::asBoolean() const
@@ -262,21 +263,21 @@ namespace
{ return llformat("%lg", mValue); }
class ImplString
class ImplString final
: public ImplBase<LLSD::TypeString, LLSD::String, const LLSD::String&>
{
public:
ImplString(const LLSD::String& v) : Base(v) { }
virtual LLSD::Boolean asBoolean() const { return !mValue.empty(); }
virtual LLSD::Integer asInteger() const;
virtual LLSD::Real asReal() const;
virtual LLSD::String asString() const { return mValue; }
virtual LLSD::UUID asUUID() const { return LLUUID(mValue); }
virtual LLSD::Date asDate() const { return LLDate(mValue); }
virtual LLSD::URI asURI() const { return LLURI(mValue); }
virtual int size() const { return mValue.size(); }
virtual const LLSD::String& asStringRef() const { return mValue; }
LLSD::Boolean asBoolean() const override { return !mValue.empty(); }
LLSD::Integer asInteger() const override;
LLSD::Real asReal() const override;
LLSD::String asString() const override { return mValue; }
LLSD::UUID asUUID() const override { return LLUUID(mValue); }
LLSD::Date asDate() const override { return LLDate(mValue); }
LLSD::URI asURI() const override { return LLURI(mValue); }
int size() const override { return mValue.size(); }
const LLSD::String& asStringRef() const override { return mValue; }
};
LLSD::Integer ImplString::asInteger() const
@@ -306,18 +307,18 @@ namespace
}
class ImplUUID
class ImplUUID final
: public ImplBase<LLSD::TypeUUID, LLSD::UUID, const LLSD::UUID&>
{
public:
ImplUUID(const LLSD::UUID& v) : Base(v) { }
virtual LLSD::String asString() const{ return mValue.asString(); }
virtual LLSD::UUID asUUID() const { return mValue; }
LLSD::String asString() const override { return mValue.asString(); }
LLSD::UUID asUUID() const override { return mValue; }
};
class ImplDate
class ImplDate final
: public ImplBase<LLSD::TypeDate, LLSD::Date, const LLSD::Date&>
{
public:
@@ -325,41 +326,42 @@ namespace
: ImplBase<LLSD::TypeDate, LLSD::Date, const LLSD::Date&>(v)
{ }
virtual LLSD::Integer asInteger() const
LLSD::Integer asInteger() const override
{
return (LLSD::Integer)(mValue.secondsSinceEpoch());
}
virtual LLSD::Real asReal() const
LLSD::Real asReal() const override
{
return mValue.secondsSinceEpoch();
}
virtual LLSD::String asString() const{ return mValue.asString(); }
virtual LLSD::Date asDate() const { return mValue; }
LLSD::String asString() const override { return mValue.asString(); }
LLSD::Date asDate() const override { return mValue; }
};
class ImplURI
class ImplURI final
: public ImplBase<LLSD::TypeURI, LLSD::URI, const LLSD::URI&>
{
public:
ImplURI(const LLSD::URI& v) : Base(v) { }
virtual LLSD::String asString() const{ return mValue.asString(); }
virtual LLSD::URI asURI() const { return mValue; }
LLSD::String asString() const override { return mValue.asString(); }
LLSD::URI asURI() const override { return mValue; }
};
class ImplBinary
class ImplBinary final
: public ImplBase<LLSD::TypeBinary, LLSD::Binary, const LLSD::Binary&>
{
public:
ImplBinary(const LLSD::Binary& v) : Base(v) { }
virtual const LLSD::Binary& asBinary() const{ return mValue; }
const LLSD::Binary& asBinary() const override { return mValue; }
};
class ImplMap : public LLSD::Impl
class ImplMap final : public LLSD::Impl
{
private:
typedef std::map<LLSD::String, LLSD> DataMap;
@@ -372,31 +374,31 @@ namespace
public:
ImplMap() { }
virtual ImplMap& makeMap(LLSD::Impl*&);
ImplMap& makeMap(LLSD::Impl*&) override;
virtual LLSD::Type type() const { return LLSD::TypeMap; }
LLSD::Type type() const override { return LLSD::TypeMap; }
virtual LLSD::Boolean asBoolean() const { return !mData.empty(); }
LLSD::Boolean asBoolean() const override { return !mData.empty(); }
virtual bool has(const LLSD::String&) const;
bool has(const LLSD::String&) const override;
using LLSD::Impl::get; // Unhiding get(LLSD::Integer)
using LLSD::Impl::erase; // Unhiding erase(LLSD::Integer)
using LLSD::Impl::ref; // Unhiding ref(LLSD::Integer)
virtual LLSD get(const LLSD::String&) const;
virtual LLSD getKeys() const;
LLSD get(const LLSD::String&) const override;
LLSD getKeys() const override;
void insert(const LLSD::String& k, const LLSD& v);
virtual void erase(const LLSD::String&);
void erase(const LLSD::String&) override;
LLSD& ref(const LLSD::String&);
virtual const LLSD& ref(const LLSD::String&) const;
const LLSD& ref(const LLSD::String&) const override;
virtual int size() const { return mData.size(); }
int size() const override { return mData.size(); }
DataMap& map() final override { return mData; }
const DataMap& map() const final override { return mData; }
virtual void dumpStats() const;
virtual void calcStats(S32 type_counts[], S32 share_counts[]) const;
void dumpStats() const override;
void calcStats(S32 type_counts[], S32 share_counts[]) const override;
};
ImplMap& ImplMap::makeMap(LLSD::Impl*& var)
@@ -483,7 +485,7 @@ namespace
{
//std::cout << " " << (*iter).first << ": " << (*iter).second << std::endl;
Impl::calcStats((*iter).second, type_counts, share_counts);
iter++;
++iter;
}
// Add in the values for this map
@@ -491,7 +493,7 @@ namespace
}
class ImplArray : public LLSD::Impl
class ImplArray final : public LLSD::Impl
{
private:
typedef std::vector<LLSD> DataVector;
@@ -504,28 +506,28 @@ namespace
public:
ImplArray() { }
virtual ImplArray& makeArray(Impl*&);
ImplArray& makeArray(Impl*&) override;
virtual LLSD::Type type() const { return LLSD::TypeArray; }
LLSD::Type type() const override { return LLSD::TypeArray; }
virtual LLSD::Boolean asBoolean() const { return !mData.empty(); }
LLSD::Boolean asBoolean() const override { return !mData.empty(); }
using LLSD::Impl::get; // Unhiding get(LLSD::String)
using LLSD::Impl::erase; // Unhiding erase(LLSD::String)
using LLSD::Impl::ref; // Unhiding ref(LLSD::String)
virtual int size() const;
virtual LLSD get(LLSD::Integer) const;
int size() const override;
LLSD get(LLSD::Integer) const override;
void set(LLSD::Integer, const LLSD&);
void insert(LLSD::Integer, const LLSD&);
LLSD& append(const LLSD&);
virtual void erase(LLSD::Integer);
void erase(LLSD::Integer) override;
LLSD& ref(LLSD::Integer);
virtual const LLSD& ref(LLSD::Integer) const;
const LLSD& ref(LLSD::Integer) const override;
DataVector& array() final override { return mData; }
const DataVector& array() const final override { return mData; }
virtual void calcStats(S32 type_counts[], S32 share_counts[]) const;
void calcStats(S32 type_counts[], S32 share_counts[]) const override;
};
ImplArray& ImplArray::makeArray(Impl*& var)
@@ -629,7 +631,7 @@ namespace
while (iter != endArray())
{ // Add values for all items held in the array
Impl::calcStats((*iter), type_counts, share_counts);
iter++;
++iter;
}
// Add in the values for this array
@@ -701,7 +703,7 @@ void LLSD::Impl::assign(Impl*& var, const Impl* other)
void LLSD::Impl::assignUndefined(Impl*& var)
{
reset(var, 0);
reset(var, nullptr);
}
void LLSD::Impl::assign(Impl*& var, LLSD::Boolean v)
@@ -777,7 +779,7 @@ void LLSD::Impl::calcStats(S32 type_counts[], S32 share_counts[]) const
S32 tp = S32(type());
if (0 <= tp && tp < LLSD::TypeLLSDNumTypes)
{
type_counts[tp]++;
type_counts[tp]++;
if (shared())
{
share_counts[tp]++;
@@ -811,10 +813,10 @@ namespace
}
LLSD::LLSD() : impl(0) { ALLOC_LLSD_OBJECT; }
LLSD::~LLSD() { FREE_LLSD_OBJECT; Impl::reset(impl, 0); }
LLSD::LLSD() : impl(nullptr) { ALLOC_LLSD_OBJECT; }
LLSD::~LLSD() { FREE_LLSD_OBJECT; Impl::reset(impl, nullptr); }
LLSD::LLSD(const LLSD& other) : impl(0) { ALLOC_LLSD_OBJECT; assign(other); }
LLSD::LLSD(const LLSD& other) : impl(nullptr) { ALLOC_LLSD_OBJECT; assign(other); }
void LLSD::assign(const LLSD& other) { Impl::assign(impl, other.impl); }
@@ -823,17 +825,17 @@ void LLSD::clear() { Impl::assignUndefined(impl); }
LLSD::Type LLSD::type() const { return safe(impl).type(); }
// Scalar Constructors
LLSD::LLSD(Boolean v) : impl(0) { ALLOC_LLSD_OBJECT; assign(v); }
LLSD::LLSD(Integer v) : impl(0) { ALLOC_LLSD_OBJECT; assign(v); }
LLSD::LLSD(Real v) : impl(0) { ALLOC_LLSD_OBJECT; assign(v); }
LLSD::LLSD(const UUID& v) : impl(0) { ALLOC_LLSD_OBJECT; assign(v); }
LLSD::LLSD(const String& v) : impl(0) { ALLOC_LLSD_OBJECT; assign(v); }
LLSD::LLSD(const Date& v) : impl(0) { ALLOC_LLSD_OBJECT; assign(v); }
LLSD::LLSD(const URI& v) : impl(0) { ALLOC_LLSD_OBJECT; assign(v); }
LLSD::LLSD(const Binary& v) : impl(0) { ALLOC_LLSD_OBJECT; assign(v); }
LLSD::LLSD(Boolean v) : impl(nullptr) { ALLOC_LLSD_OBJECT; assign(v); }
LLSD::LLSD(Integer v) : impl(nullptr) { ALLOC_LLSD_OBJECT; assign(v); }
LLSD::LLSD(Real v) : impl(nullptr) { ALLOC_LLSD_OBJECT; assign(v); }
LLSD::LLSD(const UUID& v) : impl(nullptr) { ALLOC_LLSD_OBJECT; assign(v); }
LLSD::LLSD(const String& v) : impl(nullptr) { ALLOC_LLSD_OBJECT; assign(v); }
LLSD::LLSD(const Date& v) : impl(nullptr) { ALLOC_LLSD_OBJECT; assign(v); }
LLSD::LLSD(const URI& v) : impl(nullptr) { ALLOC_LLSD_OBJECT; assign(v); }
LLSD::LLSD(const Binary& v) : impl(nullptr) { ALLOC_LLSD_OBJECT; assign(v); }
// Convenience Constructors
LLSD::LLSD(F32 v) : impl(0) { ALLOC_LLSD_OBJECT; assign((Real)v); }
LLSD::LLSD(F32 v) : impl(nullptr) { ALLOC_LLSD_OBJECT; assign((Real)v); }
// Scalar Assignment
void LLSD::assign(Boolean v) { safe(impl).assign(impl, v); }
@@ -858,7 +860,7 @@ const LLSD::Binary& LLSD::asBinary() const { return safe(impl).asBinary(); }
const LLSD::String& LLSD::asStringRef() const { return safe(impl).asStringRef(); }
// const char * helpers
LLSD::LLSD(const char* v) : impl(0) { ALLOC_LLSD_OBJECT; assign(v); }
LLSD::LLSD(const char* v) : impl(nullptr) { ALLOC_LLSD_OBJECT; assign(v); }
void LLSD::assign(const char* v)
{
if(v) assign(std::string(v));
@@ -925,7 +927,7 @@ static const char *llsd_dump(const LLSD &llsd, bool useXMLFormat)
// sStorage will point to the result of the last call. This will actually
// be one leak, but since this is used only when running under the
// debugger, it should not be an issue.
static char *sStorage = NULL;
static char *sStorage = nullptr;
delete[] sStorage;
std::string out_string;
{

6
indra/llcommon/llsd.h
View File

@@ -389,9 +389,9 @@ public:
using an arbitrary pointer or scalar type to std::string.
*/
//@{
LLSD(const void*); ///< construct from aribrary pointers
void assign(const void*); ///< assign from arbitrary pointers
LLSD& operator=(const void*); ///< assign from arbitrary pointers
LLSD(const void*) = delete; ///< construct from aribrary pointers
void assign(const void*) = delete; ///< assign from arbitrary pointers
LLSD& operator=(const void*) = delete; ///< assign from arbitrary pointers
bool has(Integer) const; ///< has() only works for Maps
//@}

11
indra/llcommon/llsdjson.cpp
View File

@@ -79,6 +79,17 @@ LLSD LlsdFromJson(const nlohmann::json &val)
return result;
}
LLSD LlsdFromJsonString(const std::string& str)
{
auto json = nlohmann::json::parse(str, nullptr, false);
if (json.is_discarded())
{
LL_WARNS() << "Cannot parse invalid json string:\n" << str << LL_ENDL;
return LLSD();
}
return LlsdFromJson(json);
}
//=========================================================================
nlohmann::json LlsdToJson(const LLSD &val)
{

1
indra/llcommon/llsdjson.h
View File

@@ -54,6 +54,7 @@
/// For maps and arrays child entries will be converted and added to the structure.
/// Order is preserved for an array but not for objects.
LLSD LlsdFromJson(const nlohmann::json &val);
LLSD LlsdFromJsonString(const std::string& body);
/// Convert an LLSD object into Parsed JSON object maintaining member names and
/// array indexs.

94
indra/llcommon/llsdserialize.cpp
View File

@@ -118,7 +118,7 @@ bool LLSDSerialize::deserialize(LLSD& sd, std::istream& str, S32 max_bytes)
fail_if_not_legacy = true;
}
if (!strncasecmp(LEGACY_NON_HEADER, hdr_buf, strlen(LEGACY_NON_HEADER))) /* Flawfinder: ignore */
if (!strnicmp(LEGACY_NON_HEADER, hdr_buf, strlen(LEGACY_NON_HEADER))) /* Flawfinder: ignore */
{
legacy_no_header = true;
inbuf = (int)str.gcount();
@@ -141,9 +141,8 @@ bool LLSDSerialize::deserialize(LLSD& sd, std::istream& str, S32 max_bytes)
}
header = hdr_buf;
std::string::size_type start = std::string::npos;
std::string::size_type start = header.find_first_not_of("<? ");
std::string::size_type end = std::string::npos;
start = header.find_first_not_of("<? ");
if (start != std::string::npos)
{
end = header.find_first_of(" ?", start);
@@ -1304,8 +1303,8 @@ S32 LLSDNotationFormatter::format_impl(const LLSD& data, std::ostream& ostr, U32
}
bool need_comma = false;
LLSD::map_const_iterator iter = data.beginMap();
LLSD::map_const_iterator end = data.endMap();
auto iter = data.beginMap();
auto end = data.endMap();
for(; iter != end; ++iter)
{
if(need_comma) ostr << ",";
@@ -1390,22 +1389,22 @@ S32 LLSDNotationFormatter::format_impl(const LLSD& data, std::ostream& ostr, U32
// *FIX: memory inefficient.
const std::vector<U8>& buffer = data.asBinary();
ostr << "b(" << buffer.size() << ")\"";
if(buffer.size())
if(!buffer.empty())
{
if (options & LLSDFormatter::OPTIONS_PRETTY_BINARY)
{
std::ios_base::fmtflags old_flags = ostr.flags();
ostr.setf( std::ios::hex, std::ios::basefield );
ostr << "0x";
for (size_t i = 0; i < buffer.size(); i++)
for (unsigned char i : buffer)
{
ostr << (int) buffer[i];
ostr << static_cast<int>(i);
}
ostr.flags(old_flags);
}
else
{
ostr.write((const char*)&buffer[0], buffer.size());
ostr.write(reinterpret_cast<const char*>(&buffer[0]), buffer.size());
}
}
ostr << "\"";
@@ -1442,9 +1441,9 @@ S32 LLSDBinaryFormatter::format(const LLSD& data, std::ostream& ostr, U32 option
{
ostr.put('{');
U32 size_nbo = htonl(data.size());
ostr.write((const char*)(&size_nbo), sizeof(U32));
LLSD::map_const_iterator iter = data.beginMap();
LLSD::map_const_iterator end = data.endMap();
ostr.write(reinterpret_cast<const char*>(&size_nbo), sizeof(U32));
auto iter = data.beginMap();
auto end = data.endMap();
for(; iter != end; ++iter)
{
ostr.put('k');
@@ -1459,7 +1458,7 @@ S32 LLSDBinaryFormatter::format(const LLSD& data, std::ostream& ostr, U32 option
{
ostr.put('[');
U32 size_nbo = htonl(data.size());
ostr.write((const char*)(&size_nbo), sizeof(U32));
ostr.write(reinterpret_cast<const char*>(&size_nbo), sizeof(U32));
for (const auto& entry : data.array())
{
format_count += format(entry, ostr);
@@ -1525,7 +1524,7 @@ S32 LLSDBinaryFormatter::format(const LLSD& data, std::ostream& ostr, U32 option
const std::vector<U8>& buffer = data.asBinary();
U32 size_nbo = htonl(buffer.size());
ostr.write((const char*)(&size_nbo), sizeof(U32));
if(buffer.size()) ostr.write((const char*)&buffer[0], buffer.size());
if(!buffer.empty()) ostr.write((const char*)&buffer[0], buffer.size());
break;
}
@@ -1702,12 +1701,12 @@ int deserialize_string_raw(
// *FIX: This is memory inefficient.
S32 len = strtol(buf + 1, NULL, 0);
if((max_bytes>0)&&(len>max_bytes)) return LLSDParser::PARSE_FAILURE;
std::vector<char> buf;
std::vector<char> buf2;
if(len)
{
buf.resize(len);
count += (int)fullread(istr, (char *)&buf[0], len);
value.assign(buf.begin(), buf.end());
buf2.resize(len);
count += (int)fullread(istr, (char *)&buf2[0], len);
value.assign(buf2.begin(), buf2.end());
}
c = istr.get();
++count;
@@ -2091,7 +2090,18 @@ std::string zip_llsd(LLSD& data)
}
have = CHUNK-strm.avail_out;
output = (U8*) realloc(output, cur_size+have);
U8* new_output = (U8*) realloc(output, cur_size+have);
if (new_output == NULL)
{
LL_WARNS() << "Failed to compress LLSD block: can't reallocate memory, current size: " << cur_size << " bytes; requested " << cur_size + have << " bytes." << LL_ENDL;
deflateEnd(&strm);
if (output)
{
free(output);
}
return std::string();
}
output = new_output;
memcpy(output+cur_size, out, have);
cur_size += have;
}
@@ -2110,15 +2120,6 @@ std::string zip_llsd(LLSD& data)
deflateEnd(&strm);
free(output);
#if 0 //verify results work with unzip_llsd
std::istringstream test(result);
LLSD test_sd;
if (!unzip_llsd(test_sd, test, result.size()))
{
LL_ERRS() << "Invalid compression result!" << LL_ENDL;
}
#endif
return result;
}
@@ -2169,7 +2170,19 @@ bool unzip_llsd(LLSD& data, std::istream& is, S32 size)
U32 have = CHUNK-strm.avail_out;
result = (U8*) realloc(result, cur_size + have);
U8* new_result = (U8*)realloc(result, cur_size + have);
if (new_result == NULL)
{
LL_WARNS() << "Failed to unzip LLSD block: can't reallocate memory, current size: " << cur_size << " bytes; requested " << cur_size + have << " bytes." << LL_ENDL;
inflateEnd(&strm);
if (result)
{
free(result);
}
delete in;
return false;
}
result = new_result;
memcpy(result+cur_size, out, have);
cur_size += have;
@@ -2215,6 +2228,11 @@ bool unzip_llsd(LLSD& data, std::istream& is, S32 size)
//and trailers are different for the formats.
U8* unzip_llsdNavMesh( bool& valid, unsigned int& outsize, std::istream& is, S32 size )
{
if (size == 0)
{
LL_WARNS() << "No data to unzip." << LL_ENDL;
return NULL;
}
U8* result = NULL;
U32 cur_size = 0;
z_stream strm;
@@ -2254,7 +2272,23 @@ U8* unzip_llsdNavMesh( bool& valid, unsigned int& outsize, std::istream& is, S32
}
U32 have = CHUNK-strm.avail_out;
result = (U8*) realloc(result, cur_size + have);
U8* new_result = (U8*) realloc(result, cur_size + have);
if (new_result == NULL)
{
LL_WARNS() << "Failed to unzip LLSD NavMesh block: can't reallocate memory, current size: " << cur_size
<< " bytes; requested " << cur_size + have
<< " bytes; total syze: ." << size << " bytes."
<< LL_ENDL;
inflateEnd(&strm);
if (result)
{
free(result);
}
delete [] in;
valid = false;
return NULL;
}
result = new_result;
memcpy(result+cur_size, out, have);
cur_size += have;