«Случайная» ошибка сегментации - PullRequest
1 голос
/ 13 мая 2019

Проблема связана с анализатором GRIB (ссылка на файл GRIB https://github.com/Gifciak/GRIB), Когда я выполняю свой код (хотя кодовые блоки или на Linux через консоль - g++ main.cpp -pedantic), я получаю ошибку, ошибку сегментации, но это не всегда происходит.

Как, например, во время компиляции 10 раз, 8 раз будет ошибка, и 2 раза все будет работать нормально, что даст мне вывод на консоль и информацию.

Как я уже исследовал, проблема связана с std::copy, так как он может пытаться скопировать итератор, который больше не существует.

Может кто-нибудь объяснить, почему это происходит? Почему не всегда происходит сбой или успех?

#include <iostream>
#include <vector>
#include <fstream>
#include <iterator>
#include <algorithm>
using ByteVec = std::vector<uint8_t>;


template<typename T, size_t size = sizeof(T)>
auto getReverseEndianValue(const auto & iter) {
    union {
        T result;
        char tmp[size];
    } buffer;

    auto reverseIter = std::make_reverse_iterator(std::next(iter, size));
    std::copy(reverseIter, std::next(reverseIter, size), buffer.tmp);

    return buffer.result;
}

enum Edition {
    Edition_Unknown = -1,
    Edition_GRIB1 = 1,
};

namespace section {
    class IS {
    public:
        uint32_t magicFlag;
        uint32_t size;
        Edition edition;

        static IS read(const auto & iter) {
            IS result;
            result.magicFlag = getReverseEndianValue<uint32_t>(iter);
            result.size = getReverseEndianValue<uint32_t, 3>(iter + 4);
            result.edition = (*(iter + 7) == 1 ? Edition_GRIB1 : Edition_Unknown);
            return result;
        }
    };

    class PDS {
    public:
        uint32_t size;
        uint8_t tableVersion;
        uint8_t indentificatorOfCenter;
        uint8_t numProcessID;
        uint8_t gridIndentification;
        uint8_t flagForGDSorBMS;
        uint8_t indParamAndUnit;
        uint8_t indTypeOfLevelOrLayer;
        uint16_t levelOrLayer;
        uint8_t year;
        uint8_t month;
        uint8_t day;
        uint8_t hour;
        uint8_t minute;
        uint8_t forecastTimeUnit;
        uint8_t p1;
        uint8_t p2;
        uint8_t indTimeRange;
        uint16_t averageOrAccumulate;
        uint8_t missing;
        uint8_t century;
        uint8_t subcenterId;
        uint16_t decimalScale;
        ByteVec data;

        static PDS read(const auto& iter) {
            PDS result;
            result.size = getReverseEndianValue<uint32_t, 3>(iter);
            result.tableVersion = getReverseEndianValue<uint8_t>(iter + 3);
            result.indentificatorOfCenter = getReverseEndianValue<uint8_t>(iter + 4);
            result.numProcessID = getReverseEndianValue<uint8_t>(iter + 5);
            result.gridIndentification = getReverseEndianValue<uint8_t>(iter + 6);
            result.flagForGDSorBMS = getReverseEndianValue<uint8_t>(iter + 7);
            result.indParamAndUnit = getReverseEndianValue<uint8_t>(iter + 8);
            result.indTypeOfLevelOrLayer = getReverseEndianValue<uint8_t>(iter + 9);
            result.levelOrLayer = getReverseEndianValue<uint16_t>(iter + 10);
            result.year = getReverseEndianValue<uint8_t>(iter + 12);
            result.month = getReverseEndianValue<uint8_t>(iter + 13);
            result.day = getReverseEndianValue<uint8_t>(iter + 14);
            result.hour = getReverseEndianValue<uint8_t>(iter + 15);
            result.minute = getReverseEndianValue<uint8_t>(iter + 16);
            result.forecastTimeUnit = getReverseEndianValue<uint8_t>(iter + 17);
            result.p1 = getReverseEndianValue<uint8_t>(iter + 18);
            result.p2 = getReverseEndianValue<uint8_t>(iter + 19);
            result.indTimeRange = getReverseEndianValue<uint8_t>(iter + 20);
            result.averageOrAccumulate = getReverseEndianValue<uint16_t>(iter + 21);
            result.missing = getReverseEndianValue<uint8_t>(iter + 23);
            result.century = getReverseEndianValue<uint8_t>(iter + 24);
            result.subcenterId = getReverseEndianValue<uint8_t>(iter + 25);
            result.decimalScale = getReverseEndianValue<uint16_t>(iter + 26);
            return result;
        }
    };
}

class GribData {
private:
    section::IS secIS;
    section::PDS secPDS;

public:
    void print() {
        std::cout
            << "### Section IS ###\n"
            << "magicFlag: " << +secIS.magicFlag << "\n"
            << "size: " << +secIS.size << "\n"
            << "edition: " << +secIS.edition << "\n"

            << "\n### Section PDS ###\n"
            << "size: " << +secPDS.size << "\n"
            << "tableVersion: " << +secPDS.tableVersion << "\n"
            << "indentificatorOfCenter: " << +secPDS.indentificatorOfCenter << "\n"
            << "numProcessID: " << +secPDS.numProcessID << "\n"
            << "gridIndentification: " << +secPDS.gridIndentification << "\n"
            << "flagForGDSorBMS: " << +secPDS.flagForGDSorBMS << "\n"
            << "indParamAndUnit: " << +secPDS.indParamAndUnit << "\n"
            << "indTypeOfLevelOrLayer: " << +secPDS.indTypeOfLevelOrLayer << "\n"
            << "levelOrLayer: " << +secPDS.levelOrLayer << "\n"
            << "year: " << +secPDS.year << "\n"
            << "month: " << +secPDS.month << "\n"
            << "day: " << +secPDS.day << "\n"
            << "hour: " << +secPDS.hour << "\n"
            << "minute: " << +secPDS.minute << "\n"
            << "forecastTimeUnit: " << +secPDS.forecastTimeUnit << "\n"
            << "p1: " << +secPDS.p1 << "\n"
            << "p2: " << +secPDS.p2 << "\n"
            << "indTimeRange: " << +secPDS.indTimeRange << "\n"
            << "averageOrAccumulate: " << +secPDS.averageOrAccumulate << "\n"
            << "missing: " << +secPDS.missing << "\n"
            << "century: " << +secPDS.century << "\n"
            << "subcenterId: " << +secPDS.subcenterId << "\n"
            << "decimalScale: " << +secPDS.decimalScale << "\n";

    }

    static GribData loadData(const ByteVec& rawdata) {
        GribData result;

        constexpr char MAGIC_START[4] = { 'G', 'R', 'I', 'B' };
        constexpr char MAGIC_END[4] = { '7', '7', '7', '7' };

        auto start = std::search(rawdata.cbegin(),
            rawdata.cend(),
            std::begin(MAGIC_START),
            std::end(MAGIC_START));

        auto end = std::search(rawdata.cbegin(),
            rawdata.cend(),
            std::begin(MAGIC_END),
            std::end(MAGIC_END));

        ByteVec data(start, end + sizeof(MAGIC_END));

        result.secIS = section::IS::read(data.cbegin());
        result.secPDS = section::PDS::read(data.cbegin() + 8);

        auto size = getReverseEndianValue<uint32_t, 3>(data.cbegin() + 4);

        auto sec1 = getReverseEndianValue<uint32_t, 3>(data.cbegin() + 8);
        auto sec2 = getReverseEndianValue<uint32_t, 3>(data.cbegin() + 8 + sec1);
        auto sec3 = getReverseEndianValue<uint32_t, 3>(data.cbegin() + 8 + sec1 + sec2);

        std::cout
            << "size: " << size << "\n"
            << "sec0: " << 8 << "\n"
            << "sec1: " << sec1 << "\n"
            << "sec2: " << sec2 << "\n"
            << "sec3: " << sec3 << "\n"
            << "end flag: " << sizeof(MAGIC_END) << "\n"
            << "sum: " << 8 + sec1 + sec2 + sec3 + sizeof(MAGIC_END) << "\n\n";

        return result;
    }

    static GribData loadDataFromFile(const std::string& path) {
        std::ifstream file(path, std::ios::binary);

        ByteVec data;
        std::copy(std::istreambuf_iterator<char>(file),
            {},
            std::back_inserter(data));

        return loadData(data);
    }
};


int main() {
    auto grib = GribData::loadDataFromFile("message_2_G1.grib");
    grib.print();
}

Вот ожидаемый результат, так как я скопировал его из консоли

size: 4538
sec0: 8
sec1: 28
sec2: 178
sec3: 4320
end flag: 4
sum: 4538

### Section IS ###
magicFlag: 1196575042
size: 1191186874
edition: 1

### Section PDS ###
size: 28
tableVersion: 2
indentificatorOfCenter: 7
numProcessID: 81
gridIndentification: 37
flagForGDSorBMS: 128
indParamAndUnit: 33
indTypeOfLevelOrLayer: 100
levelOrLayer: 850
year: 15
month: 3
day: 10
hour: 0
minute: 0
forecastTimeUnit: 1
p1: 0
p2: 0
indTimeRange: 10
averageOrAccumulate: 0
missing: 0
century: 21
subcenterId: 0
decimalScale: 1

1 Ответ

5 голосов
/ 13 мая 2019

Во-первых, использовать g++ main.cpp -pedantic не очень полезно, потому что вы не включили никаких предупреждений. Добавьте -Wall -Wextra к вашим флагам компилятора, а также -g, чтобы вы могли отладить его.

Компиляция с -fsanitize=undefined показывает ошибку времени выполнения, вызванную использованием нулевого указателя, где требуется действительный указатель:

/usr/include/c++/8/bits/stl_algobase.h:368:23: runtime error: null pointer passed as argument 2, which is declared to never be null
Segmentation fault (core dumped)

Это означает, что в вашей программе есть ошибка.

Компиляция с -D_GLIBCXX_DEBUG добавит дополнительные проверки к std::vector, и это сообщит вам о проблеме:

/usr/include/c++/8/debug/safe_iterator.h:374:
Error: attempt to advance a past-the-end iterator 4 steps, which falls 
outside its valid range.

Objects involved in the operation:
    iterator @ 0x0x7fffb09ceb90 {
      type = __gnu_debug::_Safe_iterator<__gnu_cxx::__normal_iterator<unsigned char const*, std::__cxx1998::vector<unsigned char, std::allocator<unsigned char> > >, std::__debug::vector<unsigned char, std::allocator<unsigned char> > > (constant iterator);
      state = past-the-end;
      references sequence with type 'std::__debug::vector<unsigned char, std::allocator<unsigned char> >' @ 0x0x7fffb09cf050
    }
Aborted (core dumped)

Вам следует запустить программу в отладчике, чтобы увидеть, где происходит это неправильное приращение итератора. Запуск программы в GDB, а затем использование ее команды up для перемещения вверх по стеку показывает, что ошибка происходит здесь, в loadData:

    constexpr char MAGIC_START[4] = { 'G', 'R', 'I', 'B' };
    constexpr char MAGIC_END[4] = { '7', '7', '7', '7' };

    auto start = std::search(rawdata.cbegin(),
        rawdata.cend(),
        std::begin(MAGIC_START),
        std::end(MAGIC_START));

    auto end = std::search(rawdata.cbegin(),
        rawdata.cend(),
        std::begin(MAGIC_END),
        std::end(MAGIC_END));

    ByteVec data(start, end + sizeof(MAGIC_END));
                        ^^^^^^^^^^^^^^^^^^^^^^^

Рассмотрим, что происходит, когда rawdata не содержит символов MAGIC_START, но содержит символы MAGIC_END. start и end сформируют допустимый диапазон итераторов?

Рассмотрим, что происходит, когда rawdata не содержит символов MAGIC_END. Будет ли end + sizeof(MAGIC_END) действительным?

Не следует считать, что два вызова std::search работают как положено. Вы должны добавить некоторую проверку ошибок, проверяя, start == rawdata.end() или end == rawdata.end(). Если что-то из этого верно, что-то пошло не так (возможно, неверный ввод в строке rawdata).

Вы также должны узнать, как использовать отладчик, и узнать о дополнительных инструментах, которые ваш компилятор предоставляет для обнаружения ошибок (например, параметры GCC -fsanitize=undefined и -D_GLIBCXX_DEBUG должны использоваться для подтверждения наличия ошибок, а GDB должен использоваться, чтобы найти, где эти ошибки происходят).

...