/*
 * eset_rtp (ESET Real-time file system protection module)
 * Copyright (C) 1992-2023 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.
 */

#include "ertp_memory_dev.h"
#include "ertp.h"
#include "ertp_event.h"
#include "ertp_event_queue.h"
#include "ertp_logs.h"
#include "ertp_scanner.h"

#include <linux/cdev.h>
#include <linux/cred.h>
#include <linux/device.h>
#include <linux/module.h>
#include <linux/semaphore.h>
#include <linux/slab.h>
#include <linux/spinlock.h>
#include <linux/version.h>

#define ERTP_MEM_DEV_BASE_MINOR 0
#define ERTP_MEM_DEV_MAX_COUNT 24
static dev_t mem_dev_base;

static struct cdev ertp_mem_cdev;

static struct ertp_event_memory *mem_dev_minors_usage[ERTP_MEM_DEV_MAX_COUNT];
static DEFINE_SPINLOCK(ertp_mem_dev_num_lock);

static struct class *mem_dev_class;

#define ERTP_MEM_DEV_NAME_SIZE 128
static const char *ERTP_MEM_DEV_PREFIX = "eset/mem_";

static const char *ERTP_MEM_DEV_NAME = "ertp_mem";
static const char *ERTP_MEM_CLASS_NAME = "ertp_mem_class";

struct semaphore ertp_mem_dev_semaphore;

static void init_mem_dev_minors_usage(void) {
  int i;
  spin_lock(&ertp_mem_dev_num_lock);

  for (i = 0; i < ERTP_MEM_DEV_MAX_COUNT; i++) {
    mem_dev_minors_usage[i] = NULL;
  }

  spin_unlock(&ertp_mem_dev_num_lock);
}

static bool get_available_mem_dev_num(struct ertp_event_memory *event,
                                      dev_t *out) {
  int i;
  spin_lock(&ertp_mem_dev_num_lock);

  for (i = 0; i < ERTP_MEM_DEV_MAX_COUNT; i++) {
    if (!mem_dev_minors_usage[i]) {
      mem_dev_minors_usage[i] = event;
      spin_unlock(&ertp_mem_dev_num_lock);
      ertp_event_ref(ERTP_EVENT(event));
      *out = MKDEV(MAJOR(mem_dev_base), ERTP_MEM_DEV_BASE_MINOR + i);
      return true;
    }
  }

  spin_unlock(&ertp_mem_dev_num_lock);
  return false;
}

static void release_mem_dev_minor_usage(dev_t num) {
  struct ertp_event_memory *event = NULL;
  int index = MINOR(num) - ERTP_MEM_DEV_BASE_MINOR;
  if (index < 0 || index >= ERTP_MEM_DEV_MAX_COUNT ||
      !mem_dev_minors_usage[index]) {
    BUG();
    return;
  }
  event = mem_dev_minors_usage[index];

  spin_lock(&ertp_mem_dev_num_lock);
  mem_dev_minors_usage[index] = NULL;
  spin_unlock(&ertp_mem_dev_num_lock);

  ertp_event_unref(ERTP_EVENT(event));
}

static struct ertp_event_memory *get_memory_event_of_used_dev_num(dev_t num) {
  struct ertp_event_memory *event = NULL;
  int index = MINOR(num) - ERTP_MEM_DEV_BASE_MINOR;
  if (index < 0 || index >= ERTP_MEM_DEV_MAX_COUNT ||
      !mem_dev_minors_usage[index]) {
    BUG();
    return NULL;
  }
  spin_lock(&ertp_mem_dev_num_lock);
  event = mem_dev_minors_usage[index];
  spin_unlock(&ertp_mem_dev_num_lock);

  ertp_event_ref(ERTP_EVENT(event));
  return event;
}

static void ertp_mem_dev_info_free(struct ertp_mem_dev_info *info) {
  if (info) {
    if (info->name) {
      kfree(info->name);
    }
    kfree(info);
  }
}

static char *compute_dev_name(const char *id_str) {
  char *dev_name = kmalloc(ERTP_MEM_DEV_NAME_SIZE, GFP_KERNEL);
  if (unlikely(!dev_name)) {
    return NULL;
  }
  dev_name[0] = '\0';
  strlcat(dev_name, ERTP_MEM_DEV_PREFIX, ERTP_MEM_DEV_NAME_SIZE);
  strlcat(dev_name, id_str, ERTP_MEM_DEV_NAME_SIZE);

  return dev_name;
}

static int ertp_mem_dev_open(struct inode *inode, struct file *file) {
  struct ertp_event_memory *mem_event = NULL;
  if (!try_module_get(THIS_MODULE)) {
    return -EINVAL;
  }

  if (!(file->f_mode & FMODE_READ)) {
    goto error;
  }

  mem_event = get_memory_event_of_used_dev_num(inode->i_rdev);
  if (!mem_event) {
    goto error;
  }

  file->private_data = mem_event;
  return 0;

error:
  module_put(THIS_MODULE);
  return -EINVAL;
}

static int ertp_mem_dev_release(struct inode *inode, struct file *file) {
  if (file->private_data) {
    ertp_event_unref(ERTP_EVENT(file->private_data));
    file->private_data = NULL;
  }

  module_put(THIS_MODULE);
  return 0;
}

static ssize_t ertp_mem_dev_read(struct file *file, char __user *buf,
                                 size_t size, loff_t *offset) {
  int ret;
  struct ertp_event_memory *mem_event;
  size_t bytes_to_read;

  if (size == 0) {
    return 0;
  }

  if (!file->private_data) {
    return -EINVAL;
  }

  mem_event = ERTP_EVENT_MEMORY(file->private_data);

  if (*offset > mem_event->size) {
    return 0;
  }

  bytes_to_read = ((*offset + size) <= mem_event->size)
                      ? size
                      : (mem_event->size - *offset);
  ret = copy_to_user(buf, mem_event->memory + *offset, bytes_to_read);
  if (ret) {
    return -EFAULT;
  }

  *offset += bytes_to_read;
  return bytes_to_read;
}

static loff_t ertp_mem_dev_llseek(struct file *file, loff_t offset,
                                  int whence) {
  loff_t new_offset = 0;
  struct ertp_event_memory *mem_event = NULL;

  if (!file->private_data) {
    return -EFAULT;
  }
  mem_event = ERTP_EVENT_MEMORY(file->private_data);

  switch (whence) {
    case SEEK_SET:
      new_offset = offset;
      break;
    case SEEK_CUR:
      new_offset = file->f_pos + offset;
      break;
    case SEEK_END:
      new_offset = mem_event->size + offset;
      break;
    default:
      return -EINVAL;
  }

  file->f_pos = new_offset;
  return new_offset;
}

static struct file_operations mem_dev_fops = {.owner = THIS_MODULE,
                                              .open = ertp_mem_dev_open,
                                              .release = ertp_mem_dev_release,
                                              .read = ertp_mem_dev_read,
                                              .llseek = ertp_mem_dev_llseek};

int ertp_mem_dev_create(const char *id_str, struct ertp_event_memory *event,
                        int timeout) {
  int sema_ret;
  struct ertp_mem_dev_info *dev_info = NULL;
  sema_ret = down_timeout(&ertp_mem_dev_semaphore, msecs_to_jiffies(timeout));
  if (sema_ret) {
    ertp_pr_warning("wait for mem dev file timeout, event id: %s", id_str);
    return -ETIMEDOUT;
  }

  dev_info = kmalloc(sizeof(struct ertp_mem_dev_info), GFP_KERNEL);
  if (unlikely(!dev_info)) {
    return -ENOMEM;
  }

  dev_info->name = compute_dev_name(id_str);
  if (!dev_info->name) {
    goto err_dev_info;
  }

  if (!get_available_mem_dev_num(event, &dev_info->dev_num)) {
    goto err_name;
  }

#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 27)
  dev_info->dev =
      device_create(mem_dev_class, NULL, dev_info->dev_num, dev_info->name);
#else
  dev_info->dev = device_create(mem_dev_class, NULL, dev_info->dev_num, NULL,
                                dev_info->name);
#endif
  if (IS_ERR(dev_info->dev)) {
    goto err_name;
  }

  event->dev_info = dev_info;
  return 0;

err_name:
  kfree(dev_info->name);
  dev_info->name = NULL;
err_dev_info:
  kfree(dev_info);
  dev_info = NULL;
  up(&ertp_mem_dev_semaphore);
  return -1;
}

void ertp_mem_dev_destroy(struct ertp_event_memory *event) {
  if (!event->dev_info) {
    BUG();
    return;
  }
  device_destroy(mem_dev_class, event->dev_info->dev_num);
  release_mem_dev_minor_usage(event->dev_info->dev_num);
  ertp_mem_dev_info_free(event->dev_info);
  event->dev_info = NULL;
  up(&ertp_mem_dev_semaphore);
}

int ertp_mem_dev_region_init(void) {
  int ret = alloc_chrdev_region(&mem_dev_base, ERTP_MEM_DEV_BASE_MINOR,
                                ERTP_MEM_DEV_MAX_COUNT, ERTP_MEM_DEV_NAME);
  if (ret) {
    return 1;
  }

  cdev_init(&ertp_mem_cdev, &mem_dev_fops);
  ret = cdev_add(&ertp_mem_cdev, mem_dev_base, ERTP_MEM_DEV_MAX_COUNT);
  if (ret) {
    return 1;
  }

  mem_dev_class = ertp_class_create(ERTP_MEM_CLASS_NAME);
  if (IS_ERR(mem_dev_class)) {
    unregister_chrdev_region(mem_dev_base, ERTP_MEM_DEV_MAX_COUNT);
    return 1;
  }

  init_mem_dev_minors_usage();
  sema_init(&ertp_mem_dev_semaphore, ERTP_MEM_DEV_MAX_COUNT);

  return 0;
}

void ertp_mem_dev_region_deinit(void) {
  cdev_del(&ertp_mem_cdev);
  class_destroy(mem_dev_class);
  unregister_chrdev_region(mem_dev_base, ERTP_MEM_DEV_MAX_COUNT);
}