/*
 * eset_rtp (ESET Real-time file system protection module)
 * Copyright (C) 1992-2025 ESET, spol. s r.o.
 *
 * 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/>.
 *
 * In case of any questions, you can contact us at ESET, spol. s r.o., Einsteinova 24, 851 01 Bratislava, Slovakia.
 */

#ifndef _ERTP_EVENT_H
#define _ERTP_EVENT_H

#include <linux/file.h>
#include <linux/fs.h>
#include <linux/path.h>
#include <linux/spinlock.h>
#include <linux/stat.h>
#include <linux/types.h>

#include "ertp_heap.h"
#include "ertp_memory_dev.h"
#include "ertp_path.h"
#include "ertp_qos_event_data.h"
#include "ertp_stats.h"
#include "ertp_types.h"
#include "eset_rtp.h"

enum ertp_event_class {
  ERTP_EVENT_CLASS_GENERIC = 0,
  ERTP_EVENT_CLASS_MEMORY,
  ERTP_EVENT_CLASS_REMOVE,
};

enum ertp_signal_handler {
  ERTP_SIGNAL_HANDLER_UNINITIALIZED = 0,
  ERTP_SIGNAL_HANDLER_RESTART_INTR,
  ERTP_SIGNAL_HANDLER_RESTART,
  ERTP_SIGNAL_HANDLER_WAIT,
  ERTP_SIGNAL_HANDLER_IGNORE,
};

struct ertp_event_generic_info;
struct ertp_event_flex_buffer;

struct ertp_event {
  struct ertp_heap_node node;
  struct ertp_qos_event_data qos_data;

  atomic_t count;
  uint32_t class;
  int32_t id;

  struct completion wait_qos;
  struct completion wait_scanner;
  int result;
  struct spinlock result_lock;
  bool save_context;
  enum ertp_signal_handler signal_handler;

  struct ertp_event_stats stats;

  void (*destroy)(struct ertp_event *);
  int (*serialize)(struct ertp_event *, struct eset_rtp_event *,
                   struct ertp_event_flex_buffer *);
  size_t (*flex_members_size)(const struct ertp_event *);
};

enum ertp_event_type {
  ERTP_EVENT_TYPE_OPEN = 1,
  ERTP_EVENT_TYPE_CLOSE,
  ERTP_EVENT_TYPE_EXEC,
};

struct ertp_event_generic {
  struct ertp_event base;

  enum ertp_event_type type;
  bool modified;

  struct path path;
  struct ertp_path *file_path;
  bool under_fuse;

  kuid_t uid;
  kgid_t gid;
  pid_t pid;
  struct ertp_path *process_path;
  bool mnt_namespace;

  uint64_t ino;
  uint64_t dev;
  loff_t file_size;
  ertp_timespec_t ctime;
  ertp_timespec_t mtime;
  uint16_t mode;

  struct file *file;
};

struct ertp_event_memory {
  struct ertp_event base;

  enum ertp_event_type type;

  kuid_t uid;
  kgid_t gid;
  pid_t pid;
  struct ertp_path *process_path;

  struct ertp_mem_dev_info *dev_info;

  const unsigned char *memory;
  size_t size;

  struct file *file;
  int fd;
  unsigned int flags;
};

struct ertp_event_remove {
  struct ertp_event base;

  uint64_t ino;
  uint64_t dev;
};

#define ERTP_EVENT(e) (struct ertp_event *)(e)
#define ERTP_EVENT_GENERIC(e) (struct ertp_event_generic *)(e)
#define ERTP_EVENT_MEMORY(e) (struct ertp_event_memory *)(e)
#define ERTP_EVENT_REMOVE(e) (struct ertp_event_remove *)(e)

struct ertp_event_generic_info {
  const struct file *file;
  enum ertp_event_type type;
  bool modified;
  struct ertp_path *file_path;
  struct ertp_path *process_path;
  struct kstat attr_info;
  enum ertp_signal_handler signal_handler;
};

struct ertp_event_memory_info {
  enum ertp_event_type type;
  struct ertp_path *process_path;
  const unsigned char *memory_to_scan;
  size_t size;
  enum ertp_signal_handler signal_handler;
};

struct ertp_event_remove_info {
  const struct path *path;
  const struct ertp_path *file_path;
  struct ertp_path *process_path;
  enum ertp_signal_handler signal_handler;
};

struct ertp_event_flex_buffer {
  void *data;
  size_t size;
};

void ertp_event_flex_buffer_init(struct ertp_event_flex_buffer *buffer);
void ertp_event_flex_buffer_deinit(struct ertp_event_flex_buffer *buffer);
bool ertp_event_flex_buffer_empty(struct ertp_event_flex_buffer *buffer);

struct ertp_event *ertp_event_generic_new(
    const struct ertp_event_generic_info *params);
struct ertp_event *ertp_event_memory_new(
    const struct ertp_event_memory_info *params, unsigned int timeout);
struct ertp_event *ertp_event_remove_new(
    const struct ertp_event_remove_info *params);

struct ertp_event *ertp_event_ref(struct ertp_event *event);
void ertp_event_unref(struct ertp_event *event);

const char *ertp_event_type_to_str(enum ertp_event_type type);

const char *ertp_event_class_to_str(enum ertp_event_class class);

int ertp_event_init(void);
void ertp_event_deinit(void);

void ertp_event_finished(struct ertp_event *event, int result);

void ertp_event_unblock(struct ertp_event *event, int result);

void ertp_event_disable_context(struct ertp_event *event);

int ertp_event_get_result(struct ertp_event *event);

#endif