boost::archive::binary_iarchive 构造函数直接崩溃而不会仅在 linux 中引发异常

Question

我们有类似下面的代码：

#include <sstream>
#include <iostream>
#include <fstream>

#include "boost/archive/binary_iarchive.hpp"
#include "boost/archive/binary_oarchive.hpp"

using namespace std;

class MetaData
{
public:
    int old_GroupID;
    int new_GroupID;
    double newpos;
    string newmessg;

    template <typename Archive>
    void serialize(Archive& ar, const unsigned int version)
    {
        ar& old_GroupID;
        ar& new_GroupID;
        ar& newpos;
        ar& newmessg;
    }

};

void Serialization(const MetaData &object, ofstream &fileStream)
{
    try
    {
        boost::archive::binary_oarchive oarch(fileStream);
        oarch & object;
    }
    catch (boost::archive::archive_exception e)
    {

        cout << "boost::archive::archive_exception:exception while serialisation" << e.what() << endl;

    }
    catch (...)
    {
        cout << "unknow exception caught in Serialization" << endl;
    }

}

void DeSerialization(const MetaData &object, stringstream &stringStreamer)
{
    try
    {
        // This crashes instead of throwing
        boost::archive::binary_iarchive iarch(stringStreamer);
        iarch & object;
    }
    catch (boost::archive::archive_exception e)
    {
        cout << "boost::archive::archive_exception: exception" << e.what() << endl;
    }
    catch (...)
    {
        cout << "unknown exception caught" << endl;
    }
}

int main()
{

    string tempfilename = "/storage/serilazationfile.tmp";

    {

        ofstream OutputStream;
        OutputStream.open(tempfilename, ios::out | ios::binary); //assuming file is opened

        MetaData metadataobjectone;
        metadataobjectone.old_GroupID = 1;
        metadataobjectone.new_GroupID = 5;
        metadataobjectone.newpos = 600.156;
        metadataobjectone.newmessg = "A newmessage for object one";

        Serialization(metadataobjectone, ofstream);

        MetaData metadataobjecttwo;
        metadataobjecttwo.old_GroupID = 2;
        metadataobjecttwo.new_GroupID = 6;
        metadataobjecttwo.newpos = 800.192;
        metadataobjecttwo.newmessg = "A newmessage for object two";

        Serialization(metadataobjecttwo, ofstream); //this seralize object , in the file should be corrupted like adding spaces or add unwanted data. 

        OutputStream.flush();
        OutputStream.close();

    }

    stringstream stringStreamer;
    ifstream InputStream;
    InputStream.open(tempfilename, ios::in | ios::binary);
    stringStreamer << InputStream.rdbuf();
    stringStreamer.seekg(0, stringStreamer.end);
    size_t FileSize = stringStreamer.tellg();
    stringStreamer.seekg(0, stringStreamer.beg);

    while (true)
    {
        MetaData object;//MetaData is a userdefined structure
        DeSerialization(object, stringStreamer); //while deserializing 2nd oject(corrupted) exe will be crash in linux but it will not crash in windows.
        //doing something with deserialized data
        if (FileSize == stringStreamer.tellg())
        {
            break;
        }
    }


}

我们故意破坏serilazationfile.tmp（通过添加换行符或不需要的数据）以处理负面情况，例如文件偶然损坏或文件在实际环境中包含无效数据。

在 Windows 中，当反序列化损坏的文件时，会抛出一些异常并捕获“未知异常”，但在 Linux 中它会直接崩溃，即在 Linux 中它是无法捕获的。

那么这里的问题是什么，为什么在 Linux 中无法捕获这种情况？

使用 Boost 版本 1_58、x64bit ubuntu 18.05 和 x64bit Windows server 2016 进行测试。

我们得到了下面的调用栈：-

#0  __GI_raise (sig=sig@entry=6) at ../sysdeps/unix/sysv/linux/raise.c:51
#1  0x00007f36efef7921 in __GI_abort () at abort.c:79
#2  0x00007f36edd53b21 in Vmacore::PanicExit(char const*) () from /usr/lib/vmware/libvmacore.so
#3  0x00007f36edb1a75d in ?? () from /usr/lib/vmware/libvmacore.so
#4  0x00007f36f08f12ac in operator new(unsigned long) () from /usr/lib/x86_64-linux-gnu/libstdc++.so.6
#5  0x00007f36f0931c29 in std::string::_Rep::_S_create(unsigned long, unsigned long, std::allocator<char> const&) () from /usr/lib/x86_64-linux-gnu/libstdc++.so.6
#6  0x00007f36f0932afb in std::string::_Rep::_M_clone(std::allocator<char> const&, unsigned long) () from /usr/lib/x86_64-linux-gnu/libstdc++.so.6
#7  0x00007f36f0932bb4 in std::string::reserve(unsigned long) () from /usr/lib/x86_64-linux-gnu/libstdc++.so.6
#8  0x00007f36f0932f9c in std::string::append(unsigned long, char) () from /usr/lib/x86_64-linux-gnu/libstdc++.so.6
#9  0x0000000002d97876 in boost::archive::basic_binary_iprimitive<boost::archive::binary_iarchive, char, std::char_traits<char> >::load(std::string&) ()
#10 0x0000000002d97a35 in boost::archive::basic_binary_iarchive<boost::archive::binary_iarchive>::init() ()
#11 0x00000000017a4ea3 in boost::archive::binary_iarchive_impl<boost::archive::binary_iarchive, char, std::char_traits<char> >::init (this=0x7f365d139570, flags=0)
    at /usr/local/include/boost/archive/binary_iarchive_impl.hpp:68
#12 0x00000000017a4182 in boost::archive::binary_iarchive_impl<boost::archive::binary_iarchive, char, std::char_traits<char> >::binary_iarchive_impl (
    this=0x7f365d139570, is=..., flags=0) at /usr/local/include/boost/archive/binary_iarchive_impl.hpp:97
#13 0x00000000017a3c93 in boost::archive::binary_iarchive::binary_iarchive (this=0x7f365d139570, is=..., flags=0)
    at /usr/local/include/boost/archive/binary_iarchive.hpp:44
**#14 0x0000000002697c4a in CustmSerialization::Deserialization<MetaData*, std::basic_stringstream<char, std::char_traits<char>, std::allocator<char> > > (
    this=0x7f365d13a0dc, object=@0x7f365d1398b0: 0xd68, fileStream=...)

在CustmSerialization::Deserialization 中，我们有与上面示例类似的反序列化逻辑，并且我们有catch(...)，但没有捕获到异常。

Answer 1

没有自包含的复制器，我们只能猜测。

首先，让我写一个没有问题的演示。然后我会猜测你的（隐藏的）实现调用UB的方式。

工作演示

让我们创建一个save 和load 函数，在途中打印一些调试输出：

Live On Coliru

#include "boost/archive/binary_iarchive.hpp"
#include "boost/archive/binary_oarchive.hpp"
#include <fstream>
#include <iostream>
#include <sstream>

struct MetaData {
    int i;
    void serialize(auto& ar, unsigned) { ar& i; }
};

void save(std::vector<MetaData> data, std::string const& filename)
{
    std::ofstream ofs(filename, std::ios::binary);

    for (auto& object : data) {

        try {
            boost::archive::binary_oarchive oa(ofs);
            oa << object;
        } catch (std::exception const& e) {
            std::cerr << e.what() << std::endl;
        } catch (...) {
            std::cerr << "unknown exception caught" << std::endl;
        }
        std::cerr << "save tellp: " << ofs.tellp() << "\n";
    }
}

auto load(std::string const& filename)
{
    std::stringstream mem;
    {
        std::ifstream ifs(filename, std::ios::binary);
        mem << ifs.rdbuf();
    }

    mem.seekg(0, mem.end);
    auto const FileSize = mem.tellg();

    mem.seekg(0, mem.beg);

    std::vector<MetaData> data;
    do {
        std::cerr << "load tellg: " << mem.tellg() << ", FileSize:" << FileSize << "\n";
        auto& object = data.emplace_back();

        try {
            // This crashes instead of throwing
            boost::archive::binary_iarchive iarch(mem);
            iarch >> object;
        } catch (std::exception const& e) {
            std::cerr << "boost::archive::archive_exception: exception" << std::endl;
        } catch (...) {
            std::cerr << "unknown exception caught" << std::endl;
        }

        // doing something with deserialized data
    } while (mem.tellg() < FileSize);

    return data;
}

int main()
{
    save({{11}, {22}, {33}}, "test.bin");

    std::cout << "----\n";
    for (auto& obj : load("test.bin")) {
        std::cout << "object " << obj.i << "\n";
    }
}

打印，例如：

save tellp: 49
save tellp: 98
save tellp: 147
----
load tellg: 0, FileSize:147
load tellg: 49, FileSize:147
load tellg: 98, FileSize:147
object 11
object 22
object 33

进入水晶球

我可以想象您没有在需要时完成归档：

void save(std::vector<MetaData> data, std::string const& filename)
{
    std::ofstream ofs(filename, std::ios::binary);

    try {
        boost::archive::binary_oarchive oa(ofs);
        for (auto& object : data) {
            oa << object;
            std::cerr << "save tellp: " << ofs.tellp() << "\n";
        }
    } catch (std::exception const& e) {
        std::cerr << e.what() << std::endl;
    } catch (...) {
        std::cerr << "unknown exception caught" << std::endl;
    }
}

尝试使用相同的加载函数读取此结果：

load tellg: 0, FileSize:57
load tellg: 49, FileSize:57
=================================================================
==31200==ERROR: AddressSanitizer: allocator is out of memory trying to allocate 0x2100000017 bytes
    #0 0x7fbbe371b717 in operator new(unsigned long) (/usr/lib/x86_64-linux-gnu/libasan.so.6+0xb4717)
    #1 0x7fbbde4bc8b9 in std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >::_M_mutate(unsigned long, unsigned long, char const*, unsigned long) (/usr/lib/x86_64-linux-gnu/libstdc++.so.6+0x13d8b9)

==31200==HINT: if you don't care about these errors you may set allocator_may_return_null=1
SUMMARY: AddressSanitizer: out-of-memory (/usr/lib/x86_64-linux-gnu/libasan.so.6+0xb4717) in operator new(unsigned long)
==31200==ABORTING

这与您的堆栈跟踪非常相似。

你可以像上面那样修复它，或者匹配阅读功能（这就是档案的主要用途）：

Live On Coliru

#include <boost/archive/binary_iarchive.hpp>
#include <boost/archive/binary_oarchive.hpp>
#include <boost/serialization/vector.hpp>
#include <fstream>
#include <iostream>

struct MetaData {
    int i;
    void serialize(auto& ar, unsigned) { ar& i; }
};

void save(std::vector<MetaData> const& data, std::string const& filename) {
    std::ofstream ofs(filename, std::ios::binary);
    boost::archive::binary_oarchive oa(ofs);
    oa << data;
}

auto load(std::string const& filename) {
    std::vector<MetaData> data;

    std::ifstream ifs(filename, std::ios::binary);
    boost::archive::binary_iarchive iarch(ifs);
    iarch >> data;

    return data;
}

int main() {
    save({{11}, {22}, {33}}, "test.bin");

    for (auto& obj : load("test.bin")) {
        std::cout << "object " << obj.i << "\n";
    }
}

打印

object 11
object 22
object 33

注意这个版本是代码的一小部分。