analyser.cpp

/*
  This file is part of the Fairytale project

  Copyright (C) 2018 Márcio Pais

  This library is free software: you can redistribute it and/or modify
  it under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.

  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "analyser.h"
#include "parsers/bitmapparser.h"
#include "parsers/ddsparser.h"
#include "parsers/deflateparser.h"
#include "parsers/jpegparser.h"
#include "parsers/jsonparser.h"
#include "parsers/modparser.h"
#include "parsers/textparser.h"

Analyser::Analyser(const Array<Parsers>* parsers) : strict(0), fuzzy(0), data{ { 0 } } {
  size_t l = parsers->size();
  bool used[static_cast<size_t>(Parsers::Count)] = { 0 };
  for (size_t i = 0; i < l; i++) {
    Parsers parser = ((*parsers)[i]);
    if (parser >= Parsers::Count || used[static_cast<size_t>(parser)])
      continue;

    switch (parser) {
      case Parsers::DEFLATE: {
        if (!used[static_cast<size_t>(Parsers::DEFLATE_BRUTE)])
          strict.push_back(new DeflateParser<false>());
        break;
      }
      case Parsers::DEFLATE_BRUTE: {
        if (!used[static_cast<size_t>(Parsers::DEFLATE)])
          strict.push_back(new DeflateParser<true>());
        break;
      }
      case Parsers::JPEG: {
        if (!used[static_cast<size_t>(Parsers::JPEG_PROGRESSIVE)])
          strict.push_back(new JpegParser<false>());
        break;
      }
      case Parsers::JPEG_PROGRESSIVE: {
        if (!used[static_cast<size_t>(Parsers::JPEG)])
          strict.push_back(new JpegParser<true>());
        break;
      }
      case Parsers::BITMAP: {
        if (!used[static_cast<size_t>(Parsers::BITMAP_NOHDR)])
          strict.push_back(new BitmapParser<true>());
        break;
      }
      case Parsers::BITMAP_NOHDR: {
        if (!used[static_cast<size_t>(Parsers::BITMAP)])
          strict.push_back(new BitmapParser<false>());
        break;
      }
      case Parsers::TEXT: {
        fuzzy.push_back(new TextParser());
        break;
      }
      case Parsers::DDS: {
        strict.push_back(new DDSParser());
        break;
      }
      case Parsers::MOD: {
        strict.push_back(new ModParser());
        break;
      }
      case Parsers::JSON: {
        fuzzy.push_back(new JsonParser());
        break;
      }
      default: {};
    }
  }
  // todo: sort by priorities
}

bool Analyser::analyse(Block* block, StorageManager* manager, Deduper* deduper) {
  if (block == nullptr || block->data == nullptr || block->level >= MAX_RECURSION_LEVEL || manager == nullptr)
    return false;
  if (block->level > 0 && ((HybridStream*)block->data)->wasPurged() && (!block->attemptRevival(manager)))
    return false;
  if (deduper != nullptr)
    deduper->process(block, nullptr, manager);
  uint32_t level = block->level;
  bool result = false;   // true if we found anything at all
  bool detected = false; // true if we found anything in this recursion level
  Block *b, *next;

  do {
    detected = false;
    for (int stage = 0; stage < 2; stage++) {
      LOG("Starting %s analysis at recursion level %u\n", (stage) ? "fuzzy" : "strict", level);
      size_t len = (stage) ? fuzzy.size() : strict.size();
      for (size_t i = 0; i < len; i++) {
        b = block;
        if (b->level != level || b->done)
          b = b->nextAtLevel(level);
        while (b != nullptr) {
          if (level > 0) {
            // attempt stream revival if needed
            if (((HybridStream*)b->data)->wasPurged()) {
              if (!b->attemptRevival(manager))
                break;
            }
            else
              // don't let it be purged from storage
              ((HybridStream*)b->data)->setPurgeStatus(false);
          }
          else if (!manager->wakeUp((FileStream*)b->data))
            break;

          // get current reference to next block at this recursion level,
          // the segmentation may change that
          next = b->nextAtLevel(level);

          bool found = (stage ? fuzzy[i]->parse(b, &data, manager) : strict[i]->parse(b, &data, manager)); // true if this parser found anything
          result |= detected |= found;

          if (found || next == nullptr) {
            Block* cur = b;
            while (cur != nullptr && cur != next) {
              if (!cur->hashed)
                cur->calculateHash();
              cur = cur->next;
            }
          }

          if (deduper != nullptr && found)
            deduper->process(b, next, manager);

          if (next == nullptr || next->data != b->data) {
            if (level > 0)
              ((HybridStream*)b->data)->setPurgeStatus(true);
            else
              ((FileStream*)b->data)->goToSleep();
          }

          b = next;
        }
      }
    }
    level++;
  } while (detected && level <= MAX_RECURSION_LEVEL);
  return result;
}

Analyser::~Analyser() {
  size_t l = strict.size();
  for (size_t i = 0; i < l; i++) {
    delete strict[i];
  }
  l = fuzzy.size();
  for (size_t i = 0; i < l; i++) {
    delete fuzzy[i];
  }
}