memoryaccessor.h

Go to the documentation of this file.

//    MemoryAccessor - A tool for accessing /proc/PID/mem
//    Copyright (C) 2024  zloymish
//
//    This program is free software: you can redistribute it and/or modify
//    it under the terms of the GNU General Public License as published by
//    the Free Software Foundation, either version 3 of the License, or
//    (at your option) any later version.
//
//    This program 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 General Public License for more details.
//
//    You should have received a copy of the GNU General Public License
//    along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
#ifndef MEMORYACCESSOR_SRC_MEMORYACCESSOR_H_
#define MEMORYACCESSOR_SRC_MEMORYACCESSOR_H_
 
#include <sys/types.h>
 
#include <cstdint>
#include <exception>
#include <fstream>
#include <map>
#include <string>
#include <unordered_set>
#include <vector>
 
#include "segmentinfo.h"
#include "tools.h"
 
class MemoryAccessor {
public:
  class BaseException : public std::exception {
    virtual const char *what() const noexcept override {
      return "Base exception";
    }
  };
 
  class PidEx : public BaseException {
    virtual const char *what() const noexcept override {
      return "PID exception";
    }
  };
 
  class ErrCheckingPidEx : public PidEx {
    virtual const char *what() const noexcept override {
      return "An error occurred while checking if PID exists";
    }
  };
 
  class PidNotExistEx : public PidEx {
    virtual const char *what() const noexcept override {
      return "PID not exist";
    }
  };
 
  class PidNotSetEx : public PidEx {
    virtual const char *what() const noexcept override { return "PID not set"; }
  };
 
  class FileEx : public BaseException {
    virtual const char *what() const noexcept override {
      return "Error in opening file";
    }
  };
 
  class MemFileEx : public FileEx {
    virtual const char *what() const noexcept override {
      return "Error in opening current /proc/PID/mem";
    }
  };
 
  class MapsFileEx : public FileEx {
    virtual const char *what() const noexcept override {
      return "Error in opening current /proc/PID/maps";
    }
  };
 
  class BadMapsEx : public BaseException {
    virtual const char *what() const noexcept override {
      return "Error in parsing /proc/PID/maps";
    }
  };
 
  class SegmentEx : public BaseException {
    virtual const char *what() const noexcept override {
      return "Segment exception";
    }
  };
 
  class SegmentNotExistEx : public SegmentEx {
    virtual const char *what() const noexcept override {
      return "The segment of memory does not exist";
    }
  };
 
  class SegmentAccessDeniedEx : public SegmentEx {
    virtual const char *what() const noexcept override {
      return "Access to the segment of memory denied";
    }
  };
 
  class AddressNotInSegmentEx : public SegmentEx {
    virtual const char *what() const noexcept override {
      return "Address does not belong to any segment";
    }
  };
 
  explicit MemoryAccessor(Tools &tools) noexcept(false);
 
  MemoryAccessor(const MemoryAccessor &origin) = delete;
 
  MemoryAccessor(MemoryAccessor &&origin) = delete;
 
  MemoryAccessor &operator=(const MemoryAccessor &origin) = delete;
 
  MemoryAccessor &operator=(MemoryAccessor &&origin) = delete;
 
  ~MemoryAccessor() noexcept;
 
  pid_t GetPid() const noexcept(false);
  void SetPid(const pid_t &pid) noexcept(false);
  void CheckPid() const noexcept(false);
  void ParseMaps() noexcept(false);
  std::unordered_set<std::string> GetAllSegmentNames() const noexcept;
  size_t AddressInSegment(const size_t &address) const noexcept(false);
  void CheckSegNum(const size_t &num) const noexcept(false);
  void ResetSegments() noexcept;
  void Reset() noexcept;
  size_t ReadSegment(char *dst, const size_t &num, size_t start = 0,
                     size_t amount = SIZE_MAX) noexcept(false);
  size_t WriteSegment(const char *src, const size_t &num, size_t start = 0,
                      size_t amount = SIZE_MAX) noexcept(false);
  void Read(char *dst, size_t address, size_t amount,
            size_t &done_amount) noexcept(false);
  void Write(const char *src, size_t address, size_t amount,
             size_t &done_amount) noexcept(false);
 
  Tools &tools_; 
 
  std::map<std::string, SegmentInfo *>
      special_segment_found_; 
  std::vector<SegmentInfo>
      segment_infos_; 
private:
  void OpenMem() noexcept(false);
  void CheckMem() noexcept(false);
  void CheckSegBoundaries(const size_t &num, const size_t &start,
                          size_t &amount) const noexcept(false);
  void PrepareMemSegment(const size_t &num, const size_t &start,
                         size_t &amount) noexcept(false);
 
  static bool one_instance_created_; 
 
  std::fstream mem_; 
 
  pid_t pid_{0}; 
  bool pid_set_{
      false}; 
};
 
#endif // MEMORYACCESSOR_SRC_MEMORYACCESSOR_H_