static int __init nf_dummy_init(void) { int err; printk(KERN_DEBUG "nf_dummy_init\n"); err = nf_register_hooks(nf_dummy_ipv4_ops, ARRAY_SIZE(nf_dummy_ipv4_ops)); return err; }
static int nic_hooks_init(void) { int ret = 0; ret = nf_register_hooks(nic_hooks, ARRAY_SIZE(nic_hooks)); if (ret) printk("Failed to register hook\n"); else printk("register hook success\n"); return ret; }
static int __init cache_dst_and_sock_demo_init(void) { int ret; ret = nf_register_hooks(ipv4_conn_cache_ops, ARRAY_SIZE(ipv4_conn_cache_ops)); if (ret) { goto out;; } return 0; out: return ret; }
static int __init graybox_init(void) { int i, error; log_debug("%s", banner); log_debug("Inserting the module..."); /* Init Packet sender's submodules. */ error = config_init(); if (error) goto config_failure; error = dev_init(); if (error) goto device_failure; error = receiver_init(); if (error) goto receiver_failure; error = skbops_init(); if (error) goto skbops_failure; /* Hook Jool to Netfilter. */ for (i = 0; i < ARRAY_SIZE(nfho); i++) { nfho[i].owner = NULL; nfho[i].priority = NF_IP_PRI_FIRST + 25; } error = nf_register_hooks(nfho, ARRAY_SIZE(nfho)); if (error) goto nf_register_hooks_failure; /* Yay */ log_info(MODULE_NAME " module inserted.\n"); return error; nf_register_hooks_failure: skbops_destroy(); skbops_failure: receiver_destroy(); receiver_failure: dev_destroy(); device_failure: config_destroy(); config_failure: return error; }
static int __init init(void) { int ret; ret = nf_register_hooks(mac_ops, ARRAY_SIZE(mac_ops)); if (ret < 0) { printk("http detect:can't register mac_ops detect hook!\n"); return ret; } printk("insmod mac_ops detect module\n"); return 0; }
int nf_register(void) { int err; if ((err = nf_register_hooks(nf_inet_hooks, ARRAY_SIZE(nf_inet_hooks)))) { printk(KERN_ERR "%s: netfilter hook registration failed (error %d)\n", THIS_MODULE->name, err); return -1; } return 0; }
static int __init switch_init(void) { printk("[switch] init.\n"); if (nf_register_hooks( switch_hooks, ARRAY_SIZE(switch_hooks)) < 0 ) { printk("[switch] register hooks: failure.\n"); } else { printk("[switch] register hooks: success.\n"); } return 0; }
static int __init imq_init_hooks(void) { int ret; nf_register_queue_imq_handler(&imq_nfqh); ret = nf_register_hooks(imq_ops, ARRAY_SIZE(imq_ops)); if (ret < 0) nf_unregister_queue_imq_handler(); return ret; }
static int __init ebtable_filter_init(void) { int ret; ret = register_pernet_subsys(&frame_filter_net_ops); if (ret < 0) return ret; ret = nf_register_hooks(ebt_ops_filter, ARRAY_SIZE(ebt_ops_filter)); if (ret < 0) unregister_pernet_subsys(&frame_filter_net_ops); return ret; }
static int __init knamed_init(void) { struct file *filp; int ret; int err; PR_INFO("starting"); PR_INFO("Author: Gu Feng <*****@*****.**>"); PR_INFO("Version: %s", KNAMED_VERSION); PR_INFO("Repository: https://github.com/flygoast/knamed.git"); filp = filp_open(KNAMED_CONF, O_RDONLY, 0); if (IS_ERR(filp)) { PR_INFO("conf file \"%s\" didn't existed, ignored", KNAMED_CONF); goto init; } if (filp) { fput(filp); } init: ret = nf_register_hooks(knamed_ops, ARRAY_SIZE(knamed_ops)); if (ret < 0) { PR_ERR("can't register hooks."); goto cleanup; } knamed_memory_init(); knamed_procfs_init(); knamed_sysctl_register(); dns_init(); knamed_task = kthread_run(knamed_loop, NULL, "knamedtask"); if (IS_ERR(knamed_task)) { PR_ERR("Create kernel thread failed"); err = PTR_ERR(knamed_task); return err; } PR_INFO("started"); return 0; cleanup: return ret; }
static int __init nf_nat_standalone_init(void) { int size, ret = 0; need_conntrack(); size = ALIGN(sizeof(struct nf_conn), __alignof__(struct nf_conn_nat)) + sizeof(struct nf_conn_nat); ret = nf_conntrack_register_cache(NF_CT_F_NAT, "nf_nat:base", size); if (ret < 0) { printk(KERN_ERR "nf_nat_init: Unable to create slab cache\n"); return ret; } size = ALIGN(size, __alignof__(struct nf_conn_help)) + sizeof(struct nf_conn_help); ret = nf_conntrack_register_cache(NF_CT_F_NAT|NF_CT_F_HELP, "nf_nat:help", size); if (ret < 0) { printk(KERN_ERR "nf_nat_init: Unable to create slab cache\n"); goto cleanup_register_cache; } #ifdef CONFIG_XFRM BUG_ON(ip_nat_decode_session != NULL); ip_nat_decode_session = nat_decode_session; #endif ret = nf_nat_rule_init(); if (ret < 0) { printk("nf_nat_init: can't setup rules.\n"); goto cleanup_decode_session; } ret = nf_register_hooks(nf_nat_ops, ARRAY_SIZE(nf_nat_ops)); if (ret < 0) { printk("nf_nat_init: can't register hooks.\n"); goto cleanup_rule_init; } nf_nat_module_is_loaded = 1; return ret; cleanup_rule_init: nf_nat_rule_cleanup(); cleanup_decode_session: #ifdef CONFIG_XFRM ip_nat_decode_session = NULL; synchronize_net(); #endif nf_conntrack_unregister_cache(NF_CT_F_NAT|NF_CT_F_HELP); cleanup_register_cache: nf_conntrack_unregister_cache(NF_CT_F_NAT); return ret; }
static int __init smack_nf_ip_init(void) { int err; if (smack_enabled == 0) return 0; printk(KERN_DEBUG "Smack: Registering netfilter hooks\n"); err = nf_register_hooks(smack_nf_ops, ARRAY_SIZE(smack_nf_ops)); if (err) pr_info("Smack: nf_register_hooks: error %d\n", err); return 0; }
static int __init fp_netfilter_init(void) { int rc; rc = nf_register_hooks(fp_netfilter_ops, ARRAY_SIZE(fp_netfilter_ops)); if (rc < 0) { printk(KERN_ERR "fp_netfilter_ops: can't register hooks.\n"); goto err0; } return 0; err0: return rc; }
static int __init iptable_raw_init(void) { int ret; /* Register table */ ret = ipt_register_table(&packet_raw, &initial_table.repl); if (ret < 0) return ret; /* Register hooks */ ret = nf_register_hooks(ipt_ops, ARRAY_SIZE(ipt_ops)); if (ret < 0) { ipt_unregister_table(&packet_raw); } return ret; }
_STATIC int __init packet_notify_init(void) { int err; if ((err = register_jprobes(inet_jprobes, ARRAY_SIZE(inet_jprobes)))) { printk(KERN_ERR "%s: jprobes registration failed (error %d)\n", THIS_MODULE->name, err); return -1; } if ((err = nf_register_hooks(nf_inet_hooks, ARRAY_SIZE(nf_inet_hooks)))) { printk(KERN_ERR "%s: netfilter hook registration failed (error %d)\n", THIS_MODULE->name, err); unregister_jprobes(inet_jprobes, ARRAY_SIZE(inet_jprobes)); return -1; } return 0; }
static int __init arptable_filter_init(void) { int ret; ret = register_pernet_subsys(&arptable_filter_net_ops); if (ret < 0) return ret; ret = nf_register_hooks(arpt_ops, ARRAY_SIZE(arpt_ops)); if (ret < 0) goto cleanup_table; return ret; cleanup_table: unregister_pernet_subsys(&arptable_filter_net_ops); return ret; }
static int __init arptable_filter_init(void) { int ret; /* Register table */ ret = arpt_register_table(&packet_filter, &initial_table.repl); if (ret < 0) return ret; ret = nf_register_hooks(arpt_ops, ARRAY_SIZE(arpt_ops)); if (ret < 0) goto cleanup_table; return ret; cleanup_table: arpt_unregister_table(&packet_filter); return ret; }
int cs_bridge_hook_insert(void) { /*for linux netfilter */ nf_register_hooks(br_cs_nf_ops, ARRAY_SIZE(br_cs_nf_ops)); /*for core hmu */ memset(&bridge_hmu_entry, 0, sizeof(bridge_hmu_entry)); memset(&bridge_hmu_value, 0, sizeof(bridge_hmu_value)); bridge_hmu_value.type = CS_CORE_HMU_WATCH_SWID64; bridge_hmu_value.mask = 0xFF; bridge_hmu_value.value.swid64 = CS_MOD_BRIDGE_SWID; bridge_hmu_entry.watch_bitmask = CS_CORE_HMU_WATCH_SWID64; bridge_hmu_entry.value_mask = &bridge_hmu_value; bridge_hmu_entry.callback = cs_bridge_callback_core_logic_notify; cs_core_hmu_register_watch(&bridge_hmu_entry); return 0; }
static int __init iptable_nat_init(void) { int err; err = register_pernet_subsys(&iptable_nat_net_ops); if (err < 0) goto err1; err = nf_register_hooks(nf_nat_ipv4_ops, ARRAY_SIZE(nf_nat_ipv4_ops)); if (err < 0) goto err2; return 0; err2: unregister_pernet_subsys(&iptable_nat_net_ops); err1: return err; }
static int __init iptable_security_init(void) { int ret; ret = register_pernet_subsys(&iptable_security_net_ops); if (ret < 0) return ret; ret = nf_register_hooks(ipt_ops, ARRAY_SIZE(ipt_ops)); if (ret < 0) goto cleanup_table; return ret; cleanup_table: unregister_pernet_subsys(&iptable_security_net_ops); return ret; }
static int __init ip6table_raw_init(void) { int ret; ret = register_pernet_subsys(&ip6table_raw_net_ops); if (ret < 0) return ret; /* Register hooks */ ret = nf_register_hooks(ip6t_ops, ARRAY_SIZE(ip6t_ops)); if (ret < 0) goto cleanup_table; return ret; cleanup_table: unregister_pernet_subsys(&ip6table_raw_net_ops); return ret; }
static int __init jool_init(void) { int error; log_debug("Inserting %s...", xlat_get_name()); /* Init Jool's submodules. */ error = xlator_init(); if (error) goto xlator_fail; error = logtime_init(); if (error) goto log_time_fail; error = nlhandler_init(); if (error) goto nlhandler_fail; /* This needs to be last! (except for the hook registering.) */ error = add_instance(); if (error) goto instance_fail; /* Hook Jool to Netfilter. */ error = nf_register_hooks(nfho, ARRAY_SIZE(nfho)); if (error) goto nf_register_hooks_fail; /* Yay */ log_info("%s v" JOOL_VERSION_STR " module inserted.", xlat_get_name()); return 0; nf_register_hooks_fail: xlator_rm(); instance_fail: nlhandler_destroy(); nlhandler_fail: logtime_destroy(); log_time_fail: xlator_destroy(); xlator_fail: return error; }
static int __init br_netfilter_init(void) { int ret; ret = nf_register_hooks(br_nf_ops, ARRAY_SIZE(br_nf_ops)); if (ret < 0) return ret; #ifdef CONFIG_SYSCTL brnf_sysctl_header = register_net_sysctl(&init_net, "net/bridge", brnf_table); if (brnf_sysctl_header == NULL) { printk(KERN_WARNING "br_netfilter: can't register to sysctl.\n"); nf_unregister_hooks(br_nf_ops, ARRAY_SIZE(br_nf_ops)); return -ENOMEM; } #endif printk(KERN_NOTICE "Bridge firewalling registered\n"); return 0; }
static int __init ip6table_mangle_init(void) { int ret; /* Register table */ ret = ip6t_register_table(&packet_mangler, &initial_table.repl); if (ret < 0) return ret; /* Register hooks */ ret = nf_register_hooks(ip6t_ops, ARRAY_SIZE(ip6t_ops)); if (ret < 0) goto cleanup_table; return ret; cleanup_table: ip6t_unregister_table(&packet_mangler); return ret; }
static int __init synproxy_tg6_init(void) { int err; err = nf_register_hooks(ipv6_synproxy_ops, ARRAY_SIZE(ipv6_synproxy_ops)); if (err < 0) goto err1; err = xt_register_target(&synproxy_tg6_reg); if (err < 0) goto err2; return 0; err2: nf_unregister_hooks(ipv6_synproxy_ops, ARRAY_SIZE(ipv6_synproxy_ops)); err1: return err; }
static int __init nf_conntrack_l3proto_ipv4_init(void) { int ret = 0; need_conntrack(); nf_defrag_ipv4_enable(); ret = nf_register_sockopt(&so_getorigdst); if (ret < 0) { printk(KERN_ERR "Unable to register netfilter socket option\n"); return ret; } ret = register_pernet_subsys(&ipv4_net_ops); if (ret < 0) { pr_err("nf_conntrack_ipv4: can't register pernet ops\n"); goto cleanup_sockopt; } ret = nf_register_hooks(ipv4_conntrack_ops, ARRAY_SIZE(ipv4_conntrack_ops)); if (ret < 0) { pr_err("nf_conntrack_ipv4: can't register hooks.\n"); goto cleanup_pernet; } #if defined(CONFIG_PROC_FS) && defined(CONFIG_NF_CONNTRACK_PROC_COMPAT) ret = nf_conntrack_ipv4_compat_init(); if (ret < 0) goto cleanup_hooks; #endif return ret; #if defined(CONFIG_PROC_FS) && defined(CONFIG_NF_CONNTRACK_PROC_COMPAT) cleanup_hooks: nf_unregister_hooks(ipv4_conntrack_ops, ARRAY_SIZE(ipv4_conntrack_ops)); #endif cleanup_pernet: unregister_pernet_subsys(&ipv4_net_ops); cleanup_sockopt: nf_unregister_sockopt(&so_getorigdst); return ret; }
static int __init nf_defrag_init(void) { int ret = 0; ret = nf_ct_frag6_init(); if (ret < 0) { pr_err("nf_defrag_ipv6: can't initialize frag6.\n"); return ret; } ret = nf_register_hooks(ipv6_defrag_ops, ARRAY_SIZE(ipv6_defrag_ops)); if (ret < 0) { pr_err("nf_defrag_ipv6: can't register hooks\n"); goto cleanup_frag6; } return ret; cleanup_frag6: nf_ct_frag6_cleanup(); return ret; }
static int __init ct_modules_init(void) { int ret = 0; ct_klog_fd = klog_init("ntrack", 0x0e, 0); if(!ct_klog_fd) { return -ENOMEM; } nt_info("init nf hooks.\n"); ret = nf_register_hooks(ntrack_nf_hook_ops, ARRAY_SIZE(ntrack_nf_hook_ops)); if (ret) { goto __err; } return 0; __err: if(ct_klog_fd) { klog_fini(ct_klog_fd); } return ret; }
static int __init custom_init_module(void) { int ret = 0; outside_ip = in_aton(masq_ip); if(outside_ip == 0){ printk("Error: try 'insmod eipnat.ko masq_ip=\"1.1.1.1\"'\n"); return -1; } printk("masq_ip = %s/%x\n", masq_ip, ntohl(outside_ip)); printk("nic_name= %s\n", nic_name); ret = nf_register_hooks(myhook_ops, ARRAY_SIZE(myhook_ops)); if(ret < 0){ return -1; } printk(KERN_INFO "init_module() called\n"); return 0; }
static int __init nf_defrag_init(void) { return nf_register_hooks(ipv4_defrag_ops, ARRAY_SIZE(ipv4_defrag_ops)); }