/*
 * 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.
 */

#include <linux/module.h>

#include "ertp.h"
#include "ertp_cache.h"
#include "ertp_logs.h"
#include "ertp_qos.h"
#include "ertp_stats.h"

static ssize_t ertp_cache_size_show(struct kobject *s,
                                    struct kobj_attribute *attr, char *buf) {
  return sprintf(buf, "%ld\n", ertp_cache_get_size());
}

static ssize_t ertp_cache_size_store(struct kobject *s,
                                     struct kobj_attribute *attr,
                                     const char *buf, size_t count) {
  size_t size;
  int err = kstrtoul(buf, 10, &size);

  if (err) {
    ertp_pr_warning("invalid cache size: %s", buf);
    return err;
  }

  ertp_cache_set_size(size);
  ertp_pr_info("max size of kernel module's cache has been changed to %zu",
               size);
  return strlen(buf);
}

static ssize_t ertp_enabler_show(struct kobject *s, struct kobj_attribute *attr,
                                 char *buf) {
  return sprintf(buf, "%d\n", ertp_qos_enabled());
}

static ssize_t ertp_enabler_store(struct kobject *s,
                                  struct kobj_attribute *attr, const char *buf,
                                  size_t count) {
  int enable = 0;
  int err = kstrtoint(buf, 10, &enable);

  if (err) {
    ertp_pr_warning("invalid value: %s", buf);
    return err;
  }

  if (enable) {
    ertp_qos_scanner_enable();
    ertp_pr_info("scanner enabled");
  } else {
    ertp_qos_scanner_disable();
    ertp_pr_info("scanner disabled");
  }

  return strlen(buf);
}

static ssize_t ertp_logs_enabler_show(struct kobject *s,
                                      struct kobj_attribute *attr, char *buf) {
  return sprintf(buf, "%d\n", ertp_logs_enabled());
}

static ssize_t ertp_logs_enabler_store(struct kobject *s,
                                       struct kobj_attribute *attr,
                                       const char *buf, size_t count) {
  int enable = 0;
  int err = kstrtoint(buf, 10, &enable);

  if (err) {
    ertp_pr_warning("invalid value: %s", buf);
    return err;
  }

  if (enable) {
    ertp_logs_enable();
    ertp_pr_info("additional logs enabled");
  } else {
    ertp_logs_disable();
    ertp_pr_info("additional logs disabled");
  }

  return strlen(buf);
}

static ssize_t ertp_stats_show(struct kobject *s, struct kobj_attribute *attr,
                               char *buf) {
  return ertp_stats_print(buf, PAGE_SIZE);
}

static ssize_t ertp_stats_store(struct kobject *s, struct kobj_attribute *attr,
                                const char *buf, size_t count) {
  ertp_stats_reset();
  ertp_pr_info("statistics have been reset");
  return strlen(buf);
}

static struct kobject *ertp_kobj;
static const struct kobj_attribute enabler_attr =
    __ATTR(enable, 0600, ertp_enabler_show, ertp_enabler_store);

static struct kobject *ertp_cache_kobj;
static const struct kobj_attribute cache_attr =
    __ATTR(max_size, 0600, ertp_cache_size_show, ertp_cache_size_store);

static struct kobject *ertp_logs_kobj;
static const struct kobj_attribute logs_attr =
    __ATTR(enable, 0600, ertp_logs_enabler_show, ertp_logs_enabler_store);

static const struct kobj_attribute stats_attr =
    __ATTR(statistics, 0600, ertp_stats_show, ertp_stats_store);

int ertp_sysfs_init(void) {
  int ret;

  ertp_kobj = kobject_create_and_add("settings", &THIS_MODULE->mkobj.kobj);
  if (!ertp_kobj) {
    ret = -ENOMEM;
    goto error;
  }

  ertp_cache_kobj = kobject_create_and_add("cache", ertp_kobj);
  if (!ertp_cache_kobj) {
    ret = -ENOMEM;
    goto error;
  }

  ertp_logs_kobj = kobject_create_and_add("logs", ertp_kobj);
  if (!ertp_logs_kobj) {
    ret = -ENOMEM;
    goto error;
  }

  ret = sysfs_create_file(ertp_kobj, &enabler_attr.attr);
  if (ret) goto error;

  ret = sysfs_create_file(ertp_cache_kobj, &cache_attr.attr);
  if (ret) goto err_cache;

  ret = sysfs_create_file(ertp_logs_kobj, &logs_attr.attr);
  if (ret) goto err_logs;

  ret = sysfs_create_file(&THIS_MODULE->mkobj.kobj, &stats_attr.attr);
  if (ret) goto err_stats;

  return 0;

err_stats:
  sysfs_remove_file(ertp_logs_kobj, &logs_attr.attr);
err_logs:
  sysfs_remove_file(ertp_cache_kobj, &cache_attr.attr);
err_cache:
  sysfs_remove_file(ertp_kobj, &enabler_attr.attr);
error:
  if (ertp_logs_kobj) kobject_put(ertp_logs_kobj);

  if (ertp_cache_kobj) kobject_put(ertp_cache_kobj);

  if (ertp_kobj) kobject_put(ertp_kobj);

  return ret;
}

void ertp_sysfs_deinit(void) {
  sysfs_remove_file(&THIS_MODULE->mkobj.kobj, &stats_attr.attr);

  sysfs_remove_file(ertp_cache_kobj, &cache_attr.attr);
  kobject_put(ertp_cache_kobj);

  sysfs_remove_file(ertp_logs_kobj, &logs_attr.attr);
  kobject_put(ertp_logs_kobj);

  sysfs_remove_file(ertp_kobj, &enabler_attr.attr);
  kobject_put(ertp_kobj);
}