Memory issue with using C++ Protobuf in a DLL - c++

Question

This question was posted on Google Group's Protobuf group but unfortunately it has gone unanswered.
A DLL has been created that will accept any Protobuf message which through the use of reflection will be filled with data from a database and then returned to the client. The database table name is mapped to the message name and the corresponding table columns are mapped to the message member names.
The issue appears to be with the 'SetString' method of the reflection class. After the call to the DLL has been made and the protobuf message with all the relevant has been received, a memory error is encountered as the program exists.
A typical message will have a .proto file such as the following:
message OperatingSystemInfo {
string manufacturer;
string name;
string release;
string osversion;
string localename;
string bootdevice;
string serialnumber;
}
The code snippets for the DLL functions are as follow:
void EXPORT_DLL ReadMessage(void* protoBufMessage) {
Message* msg = static_cast<Message*>(protoBufMessage);
const Descriptor* descriptor = msg->GetDescriptor();
const Reflection* reflection = msg->GetReflection();
for (int i = 0; i < descriptor->field_count(); i++) {
const FieldDescriptor* field = descriptor->field(i);
const FieldDescriptor::Type type = field->type();
bool isRepeated = field->is_repeated();
std::string name = field->name();
if (type == FieldDescriptor::TYPE_MESSAGE) {
}
else {
//read values from database for each corresponding field and set value
string fieldValue;
SetFieldValues(reflection, field, msg, fieldValue);
}
}
}
void SetFieldValues(const google::protobuf::Reflection reflection,
const google::protobuf::FieldDescriptor field,
google::protobuf::Message msg,
std::string fieldValue) {
switch (field->type()) {
case FieldDescriptor::TYPE_STRING:
reflection->SetString(msg, field, move(fieldValue))
break;
case FieldDescriptor::TYPE_UINT32:
break;
case FieldDescriptor::TYPE_UINT64:
break;
case FieldDescriptor::TYPE_BOOL:
break;
case FieldDescriptor::TYPE_ENUM:
break;
default:
break;
}
}
The client call to the DLL is:
void CallDLL()
{
OperatingSystemInfo* osi = new OperatingSystemInfo();
ReadMessage(osi);
delete osi;
}
The problem is that when the application is about to terminate, the 'Destroy' method for the last string in the message, 'serialnumber', causes a memory error (__acrt_first_block == header in debug_heap.ccp):
inline void OperatingSystemState::SharedDtor() {
GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
_impl_.manufacturer_.Destroy();
_impl_.name_.Destroy();
_impl_.release_.Destroy();
_impl_.osversion_.Destroy();
_impl_.localename_.Destroy();
_impl_.bootdevice_.Destroy();
_impl_.serialnumber_.Destroy();
}
void ArenaStringPtr::Destroy() {
//Line 233 in arenastring.cc
//leads to assertion Expession: __acrt_first_block == header in debug_heap.ccp
delete tagged_ptr_.GetIfAllocated();
}
Naturally this is an attempt to free an already freed memory. It is likely that allocating the memory outside of the DLL is a factor but the nature of the project is such that the DLL has no knowledge of Protobuf message types. Hence the reason that reflection is used.
Any helps or hints in resolving this issue is greatly appreciated.