net/netfilter/xt_IDLETIMER.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * linux/net/netfilter/xt_IDLETIMER.c
   4  *
   5  * Netfilter module to trigger a timer when packet matches.
   6  * After timer expires a kevent will be sent.
   7  *
   8  * Copyright (C) 2004, 2010 Nokia Corporation
   9  * Written by Timo Teras <[email protected]>
  10  *
  11  * Converted to x_tables and reworked for upstream inclusion
  12  * by Luciano Coelho <[email protected]>
  13  *
  14  * Contact: Luciano Coelho <[email protected]>
  15  */
  16
  17 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  18
  19 #include <linux/module.h>
  20 #include <linux/timer.h>
  21 #include <linux/alarmtimer.h>
  22 #include <linux/list.h>
  23 #include <linux/mutex.h>
  24 #include <linux/netfilter.h>
  25 #include <linux/netfilter/x_tables.h>
  26 #include <linux/netfilter/xt_IDLETIMER.h>
  27 #include <linux/kdev_t.h>
  28 #include <linux/kobject.h>
  29 #include <linux/workqueue.h>
  30 #include <linux/sysfs.h>
  31
  32 struct idletimer_tg {
  33         struct list_head entry;
  34         struct alarm alarm;
  35         struct timer_list timer;
  36         struct work_struct work;
  37
  38         struct kobject *kobj;
  39         struct device_attribute attr;
  40
  41         unsigned int refcnt;
  42         u8 timer_type;
  43 };
  44
  45 static LIST_HEAD(idletimer_tg_list);
  46 static DEFINE_MUTEX(list_mutex);
  47
  48 static struct kobject *idletimer_tg_kobj;
  49
  50 static
  51 struct idletimer_tg *__idletimer_tg_find_by_label(const char *label)
  52 {
  53         struct idletimer_tg *entry;
  54
  55         list_for_each_entry(entry, &idletimer_tg_list, entry) {
  56                 if (!strcmp(label, entry->attr.attr.name))
  57                         return entry;
  58         }
  59
  60         return NULL;
  61 }
  62
  63 static ssize_t idletimer_tg_show(struct device *dev,
  64                                  struct device_attribute *attr, char *buf)
  65 {
  66         struct idletimer_tg *timer;
  67         unsigned long expires = 0;
  68         struct timespec64 ktimespec = {};
  69         long time_diff = 0;
  70
  71         mutex_lock(&list_mutex);
  72
  73         timer = __idletimer_tg_find_by_label(attr->attr.name);
  74         if (timer) {
  75                 if (timer->timer_type & XT_IDLETIMER_ALARM) {
  76                         ktime_t expires_alarm = alarm_expires_remaining(&timer->alarm);
  77                         ktimespec = ktime_to_timespec64(expires_alarm);
  78                         time_diff = ktimespec.tv_sec;
  79                 } else {
  80                         expires = timer->timer.expires;
  81                         time_diff = jiffies_to_msecs(expires - jiffies) / 1000;
  82                 }
  83         }
  84
  85         mutex_unlock(&list_mutex);
  86
  87         if (time_after(expires, jiffies) || ktimespec.tv_sec > 0)
  88                 return sysfs_emit(buf, "%ld\n", time_diff);
  89
  90         return sysfs_emit(buf, "0\n");
  91 }
  92
  93 static void idletimer_tg_work(struct work_struct *work)
  94 {
  95         struct idletimer_tg *timer = container_of(work, struct idletimer_tg,
  96                                                   work);
  97
  98         sysfs_notify(idletimer_tg_kobj, NULL, timer->attr.attr.name);
  99 }
 100
 101 static void idletimer_tg_expired(struct timer_list *t)
 102 {
 103         struct idletimer_tg *timer = from_timer(timer, t, timer);
 104
 105         pr_debug("timer %s expired\n", timer->attr.attr.name);
 106
 107         schedule_work(&timer->work);
 108 }
 109
 110 static void idletimer_tg_alarmproc(struct alarm *alarm, ktime_t now)
 111 {
 112         struct idletimer_tg *timer = alarm->data;
 113
 114         pr_debug("alarm %s expired\n", timer->attr.attr.name);
 115         schedule_work(&timer->work);
 116 }
 117
 118 static int idletimer_check_sysfs_name(const char *name, unsigned int size)
 119 {
 120         int ret;
 121
 122         ret = xt_check_proc_name(name, size);
 123         if (ret < 0)
 124                 return ret;
 125
 126         if (!strcmp(name, "power") ||
 127             !strcmp(name, "subsystem") ||
 128             !strcmp(name, "uevent"))
 129                 return -EINVAL;
 130
 131         return 0;
 132 }
 133
 134 static int idletimer_tg_create(struct idletimer_tg_info *info)
 135 {
 136         int ret;
 137
 138         info->timer = kzalloc(sizeof(*info->timer), GFP_KERNEL);
 139         if (!info->timer) {
 140                 ret = -ENOMEM;
 141                 goto out;
 142         }
 143
 144         ret = idletimer_check_sysfs_name(info->label, sizeof(info->label));
 145         if (ret < 0)
 146                 goto out_free_timer;
 147
 148         sysfs_attr_init(&info->timer->attr.attr);
 149         info->timer->attr.attr.name = kstrdup(info->label, GFP_KERNEL);
 150         if (!info->timer->attr.attr.name) {
 151                 ret = -ENOMEM;
 152                 goto out_free_timer;
 153         }
 154         info->timer->attr.attr.mode = 0444;
 155         info->timer->attr.show = idletimer_tg_show;
 156
 157         ret = sysfs_create_file(idletimer_tg_kobj, &info->timer->attr.attr);
 158         if (ret < 0) {
 159                 pr_debug("couldn't add file to sysfs");
 160                 goto out_free_attr;
 161         }
 162
 163         list_add(&info->timer->entry, &idletimer_tg_list);
 164
 165         timer_setup(&info->timer->timer, idletimer_tg_expired, 0);
 166         info->timer->refcnt = 1;
 167
 168         INIT_WORK(&info->timer->work, idletimer_tg_work);
 169
 170         mod_timer(&info->timer->timer,
 171                   msecs_to_jiffies(info->timeout * 1000) + jiffies);
 172
 173         return 0;
 174
 175 out_free_attr:
 176         kfree(info->timer->attr.attr.name);
 177 out_free_timer:
 178         kfree(info->timer);
 179 out:
 180         return ret;
 181 }
 182
 183 static int idletimer_tg_create_v1(struct idletimer_tg_info_v1 *info)
 184 {
 185         int ret;
 186
 187         info->timer = kmalloc(sizeof(*info->timer), GFP_KERNEL);
 188         if (!info->timer) {
 189                 ret = -ENOMEM;
 190                 goto out;
 191         }
 192
 193         ret = idletimer_check_sysfs_name(info->label, sizeof(info->label));
 194         if (ret < 0)
 195                 goto out_free_timer;
 196
 197         sysfs_attr_init(&info->timer->attr.attr);
 198         info->timer->attr.attr.name = kstrdup(info->label, GFP_KERNEL);
 199         if (!info->timer->attr.attr.name) {
 200                 ret = -ENOMEM;
 201                 goto out_free_timer;
 202         }
 203         info->timer->attr.attr.mode = 0444;
 204         info->timer->attr.show = idletimer_tg_show;
 205
 206         ret = sysfs_create_file(idletimer_tg_kobj, &info->timer->attr.attr);
 207         if (ret < 0) {
 208                 pr_debug("couldn't add file to sysfs");
 209                 goto out_free_attr;
 210         }
 211
 212         /*  notify userspace  */
 213         kobject_uevent(idletimer_tg_kobj,KOBJ_ADD);
 214
 215         list_add(&info->timer->entry, &idletimer_tg_list);
 216         pr_debug("timer type value is %u", info->timer_type);
 217         info->timer->timer_type = info->timer_type;
 218         info->timer->refcnt = 1;
 219
 220         INIT_WORK(&info->timer->work, idletimer_tg_work);
 221
 222         if (info->timer->timer_type & XT_IDLETIMER_ALARM) {
 223                 ktime_t tout;
 224                 alarm_init(&info->timer->alarm, ALARM_BOOTTIME,
 225                            idletimer_tg_alarmproc);
 226                 info->timer->alarm.data = info->timer;
 227                 tout = ktime_set(info->timeout, 0);
 228                 alarm_start_relative(&info->timer->alarm, tout);
 229         } else {
 230                 timer_setup(&info->timer->timer, idletimer_tg_expired, 0);
 231                 mod_timer(&info->timer->timer,
 232                                 msecs_to_jiffies(info->timeout * 1000) + jiffies);
 233         }
 234
 235         return 0;
 236
 237 out_free_attr:
 238         kfree(info->timer->attr.attr.name);
 239 out_free_timer:
 240         kfree(info->timer);
 241 out:
 242         return ret;
 243 }
 244
 245 /*
 246  * The actual xt_tables plugin.
 247  */
 248 static unsigned int idletimer_tg_target(struct sk_buff *skb,
 249                                          const struct xt_action_param *par)
 250 {
 251         const struct idletimer_tg_info *info = par->targinfo;
 252
 253         pr_debug("resetting timer %s, timeout period %u\n",
 254                  info->label, info->timeout);
 255
 256         mod_timer(&info->timer->timer,
 257                   msecs_to_jiffies(info->timeout * 1000) + jiffies);
 258
 259         return XT_CONTINUE;
 260 }
 261
 262 /*
 263  * The actual xt_tables plugin.
 264  */
 265 static unsigned int idletimer_tg_target_v1(struct sk_buff *skb,
 266                                          const struct xt_action_param *par)
 267 {
 268         const struct idletimer_tg_info_v1 *info = par->targinfo;
 269
 270         pr_debug("resetting timer %s, timeout period %u\n",
 271                  info->label, info->timeout);
 272
 273         if (info->timer->timer_type & XT_IDLETIMER_ALARM) {
 274                 ktime_t tout = ktime_set(info->timeout, 0);
 275                 alarm_start_relative(&info->timer->alarm, tout);
 276         } else {
 277                 mod_timer(&info->timer->timer,
 278                                 msecs_to_jiffies(info->timeout * 1000) + jiffies);
 279         }
 280
 281         return XT_CONTINUE;
 282 }
 283
 284 static int idletimer_tg_helper(struct idletimer_tg_info *info)
 285 {
 286         if (info->timeout == 0) {
 287                 pr_debug("timeout value is zero\n");
 288                 return -EINVAL;
 289         }
 290         if (info->timeout >= INT_MAX / 1000) {
 291                 pr_debug("timeout value is too big\n");
 292                 return -EINVAL;
 293         }
 294         if (info->label[0] == '\0' ||
 295             strnlen(info->label,
 296                     MAX_IDLETIMER_LABEL_SIZE) == MAX_IDLETIMER_LABEL_SIZE) {
 297                 pr_debug("label is empty or not nul-terminated\n");
 298                 return -EINVAL;
 299         }
 300         return 0;
 301 }
 302
 303
 304 static int idletimer_tg_checkentry(const struct xt_tgchk_param *par)
 305 {
 306         struct idletimer_tg_info *info = par->targinfo;
 307         int ret;
 308
 309         pr_debug("checkentry targinfo%s\n", info->label);
 310
 311         ret = idletimer_tg_helper(info);
 312         if(ret < 0)
 313         {
 314                 pr_debug("checkentry helper return invalid\n");
 315                 return -EINVAL;
 316         }
 317         mutex_lock(&list_mutex);
 318
 319         info->timer = __idletimer_tg_find_by_label(info->label);
 320         if (info->timer) {
 321                 info->timer->refcnt++;
 322                 mod_timer(&info->timer->timer,
 323                           msecs_to_jiffies(info->timeout * 1000) + jiffies);
 324
 325                 pr_debug("increased refcnt of timer %s to %u\n",
 326                          info->label, info->timer->refcnt);
 327         } else {
 328                 ret = idletimer_tg_create(info);
 329                 if (ret < 0) {
 330                         pr_debug("failed to create timer\n");
 331                         mutex_unlock(&list_mutex);
 332                         return ret;
 333                 }
 334         }
 335
 336         mutex_unlock(&list_mutex);
 337         return 0;
 338 }
 339
 340 static int idletimer_tg_checkentry_v1(const struct xt_tgchk_param *par)
 341 {
 342         struct idletimer_tg_info_v1 *info = par->targinfo;
 343         int ret;
 344
 345         pr_debug("checkentry targinfo%s\n", info->label);
 346
 347         if (info->send_nl_msg)
 348                 return -EOPNOTSUPP;
 349
 350         ret = idletimer_tg_helper((struct idletimer_tg_info *)info);
 351         if(ret < 0)
 352         {
 353                 pr_debug("checkentry helper return invalid\n");
 354                 return -EINVAL;
 355         }
 356
 357         if (info->timer_type > XT_IDLETIMER_ALARM) {
 358                 pr_debug("invalid value for timer type\n");
 359                 return -EINVAL;
 360         }
 361
 362         mutex_lock(&list_mutex);
 363
 364         info->timer = __idletimer_tg_find_by_label(info->label);
 365         if (info->timer) {
 366                 if (info->timer->timer_type != info->timer_type) {
 367                         pr_debug("Adding/Replacing rule with same label and different timer type is not allowed\n");
 368                         mutex_unlock(&list_mutex);
 369                         return -EINVAL;
 370                 }
 371
 372                 info->timer->refcnt++;
 373                 if (info->timer_type & XT_IDLETIMER_ALARM) {
 374                         /* calculate remaining expiry time */
 375                         ktime_t tout = alarm_expires_remaining(&info->timer->alarm);
 376                         struct timespec64 ktimespec = ktime_to_timespec64(tout);
 377
 378                         if (ktimespec.tv_sec > 0) {
 379                                 pr_debug("time_expiry_remaining %lld\n",
 380                                          ktimespec.tv_sec);
 381                                 alarm_start_relative(&info->timer->alarm, tout);
 382                         }
 383                 } else {
 384                                 mod_timer(&info->timer->timer,
 385                                         msecs_to_jiffies(info->timeout * 1000) + jiffies);
 386                 }
 387                 pr_debug("increased refcnt of timer %s to %u\n",
 388                          info->label, info->timer->refcnt);
 389         } else {
 390                 ret = idletimer_tg_create_v1(info);
 391                 if (ret < 0) {
 392                         pr_debug("failed to create timer\n");
 393                         mutex_unlock(&list_mutex);
 394                         return ret;
 395                 }
 396         }
 397
 398         mutex_unlock(&list_mutex);
 399         return 0;
 400 }
 401
 402 static void idletimer_tg_destroy(const struct xt_tgdtor_param *par)
 403 {
 404         const struct idletimer_tg_info *info = par->targinfo;
 405
 406         pr_debug("destroy targinfo %s\n", info->label);
 407
 408         mutex_lock(&list_mutex);
 409
 410         if (--info->timer->refcnt > 0) {
 411                 pr_debug("decreased refcnt of timer %s to %u\n",
 412                          info->label, info->timer->refcnt);
 413                 mutex_unlock(&list_mutex);
 414                 return;
 415         }
 416
 417         pr_debug("deleting timer %s\n", info->label);
 418
 419         list_del(&info->timer->entry);
 420         mutex_unlock(&list_mutex);
 421
 422         timer_shutdown_sync(&info->timer->timer);
 423         cancel_work_sync(&info->timer->work);
 424         sysfs_remove_file(idletimer_tg_kobj, &info->timer->attr.attr);
 425         kfree(info->timer->attr.attr.name);
 426         kfree(info->timer);
 427 }
 428
 429 static void idletimer_tg_destroy_v1(const struct xt_tgdtor_param *par)
 430 {
 431         const struct idletimer_tg_info_v1 *info = par->targinfo;
 432
 433         pr_debug("destroy targinfo %s\n", info->label);
 434
 435         mutex_lock(&list_mutex);
 436
 437         if (--info->timer->refcnt > 0) {
 438                 pr_debug("decreased refcnt of timer %s to %u\n",
 439                          info->label, info->timer->refcnt);
 440                 mutex_unlock(&list_mutex);
 441                 return;
 442         }
 443
 444         pr_debug("deleting timer %s\n", info->label);
 445
 446         list_del(&info->timer->entry);
 447         mutex_unlock(&list_mutex);
 448
 449         if (info->timer->timer_type & XT_IDLETIMER_ALARM) {
 450                 alarm_cancel(&info->timer->alarm);
 451         } else {
 452                 timer_shutdown_sync(&info->timer->timer);
 453         }
 454         cancel_work_sync(&info->timer->work);
 455         sysfs_remove_file(idletimer_tg_kobj, &info->timer->attr.attr);
 456         kfree(info->timer->attr.attr.name);
 457         kfree(info->timer);
 458 }
 459
 460
 461 static struct xt_target idletimer_tg[] __read_mostly = {
 462         {
 463                 .name           = "IDLETIMER",
 464                 .family         = NFPROTO_IPV4,
 465                 .target         = idletimer_tg_target,
 466                 .targetsize     = sizeof(struct idletimer_tg_info),
 467                 .usersize       = offsetof(struct idletimer_tg_info, timer),
 468                 .checkentry     = idletimer_tg_checkentry,
 469                 .destroy        = idletimer_tg_destroy,
 470                 .me             = THIS_MODULE,
 471         },
 472         {
 473                 .name           = "IDLETIMER",
 474                 .family         = NFPROTO_IPV4,
 475                 .revision       = 1,
 476                 .target         = idletimer_tg_target_v1,
 477                 .targetsize     = sizeof(struct idletimer_tg_info_v1),
 478                 .usersize       = offsetof(struct idletimer_tg_info_v1, timer),
 479                 .checkentry     = idletimer_tg_checkentry_v1,
 480                 .destroy        = idletimer_tg_destroy_v1,
 481                 .me             = THIS_MODULE,
 482         },
 483 #if IS_ENABLED(CONFIG_IP6_NF_IPTABLES)
 484         {
 485                 .name           = "IDLETIMER",
 486                 .family         = NFPROTO_IPV6,
 487                 .target         = idletimer_tg_target,
 488                 .targetsize     = sizeof(struct idletimer_tg_info),
 489                 .usersize       = offsetof(struct idletimer_tg_info, timer),
 490                 .checkentry     = idletimer_tg_checkentry,
 491                 .destroy        = idletimer_tg_destroy,
 492                 .me             = THIS_MODULE,
 493         },
 494         {
 495                 .name           = "IDLETIMER",
 496                 .family         = NFPROTO_IPV6,
 497                 .revision       = 1,
 498                 .target         = idletimer_tg_target_v1,
 499                 .targetsize     = sizeof(struct idletimer_tg_info_v1),
 500                 .usersize       = offsetof(struct idletimer_tg_info_v1, timer),
 501                 .checkentry     = idletimer_tg_checkentry_v1,
 502                 .destroy        = idletimer_tg_destroy_v1,
 503                 .me             = THIS_MODULE,
 504         },
 505 #endif
 506 };
 507
 508 static struct class *idletimer_tg_class;
 509
 510 static struct device *idletimer_tg_device;
 511
 512 static int __init idletimer_tg_init(void)
 513 {
 514         int err;
 515
 516         idletimer_tg_class = class_create("xt_idletimer");
 517         err = PTR_ERR(idletimer_tg_class);
 518         if (IS_ERR(idletimer_tg_class)) {
 519                 pr_debug("couldn't register device class\n");
 520                 goto out;
 521         }
 522
 523         idletimer_tg_device = device_create(idletimer_tg_class, NULL,
 524                                             MKDEV(0, 0), NULL, "timers");
 525         err = PTR_ERR(idletimer_tg_device);
 526         if (IS_ERR(idletimer_tg_device)) {
 527                 pr_debug("couldn't register system device\n");
 528                 goto out_class;
 529         }
 530
 531         idletimer_tg_kobj = &idletimer_tg_device->kobj;
 532
 533         err = xt_register_targets(idletimer_tg, ARRAY_SIZE(idletimer_tg));
 534
 535         if (err < 0) {
 536                 pr_debug("couldn't register xt target\n");
 537                 goto out_dev;
 538         }
 539
 540         return 0;
 541 out_dev:
 542         device_destroy(idletimer_tg_class, MKDEV(0, 0));
 543 out_class:
 544         class_destroy(idletimer_tg_class);
 545 out:
 546         return err;
 547 }
 548
 549 static void __exit idletimer_tg_exit(void)
 550 {
 551         xt_unregister_targets(idletimer_tg, ARRAY_SIZE(idletimer_tg));
 552
 553         device_destroy(idletimer_tg_class, MKDEV(0, 0));
 554         class_destroy(idletimer_tg_class);
 555 }
 556
 557 module_init(idletimer_tg_init);
 558 module_exit(idletimer_tg_exit);
 559
 560 MODULE_AUTHOR("Timo Teras <[email protected]>");
 561 MODULE_AUTHOR("Luciano Coelho <[email protected]>");
 562 MODULE_DESCRIPTION("Xtables: idle time monitor");
 563 MODULE_LICENSE("GPL v2");
 564 MODULE_ALIAS("ipt_IDLETIMER");
 565 MODULE_ALIAS("ip6t_IDLETIMER");