void CheckStart (void *arg) { int iStart, iStop = 0; daemonize ("chkstrt", 0); while (1) { iStart = StrToInt(pStart->data); if (1 == iStart) { if (1 == iStop) { iStop = 0; HookReg (); } mdelay (2000); } else if (0 == iStart) { if (0 == iStop) { iStop = 1; nf_unregister_hook(&stPreHook); nf_unregister_hook(&stPostHook); } mdelay (2000); } } }
static int init_or_cleanup(int init) { int ret = 0; need_ip_conntrack(); if (!init) goto cleanup; ret = ip_nat_rule_init(); if (ret < 0) { printk("ip_nat_init: can't setup rules.\n"); goto cleanup_nothing; } ret = ip_nat_init(); if (ret < 0) { printk("ip_nat_init: can't setup rules.\n"); goto cleanup_rule_init; } ret = nf_register_hook(&ip_nat_in_ops); if (ret < 0) { printk("ip_nat_init: can't register in hook.\n"); goto cleanup_nat; } ret = nf_register_hook(&ip_nat_out_ops); if (ret < 0) { printk("ip_nat_init: can't register out hook.\n"); goto cleanup_inops; } #ifdef CONFIG_IP_NF_NAT_LOCAL ret = nf_register_hook(&ip_nat_local_out_ops); if (ret < 0) { printk("ip_nat_init: can't register local out hook.\n"); goto cleanup_outops; } ret = nf_register_hook(&ip_nat_local_in_ops); if (ret < 0) { printk("ip_nat_init: can't register local in hook.\n"); goto cleanup_localoutops; } #endif return ret; cleanup: #ifdef CONFIG_IP_NF_NAT_LOCAL nf_unregister_hook(&ip_nat_local_in_ops); cleanup_localoutops: nf_unregister_hook(&ip_nat_local_out_ops); cleanup_outops: #endif nf_unregister_hook(&ip_nat_out_ops); cleanup_inops: nf_unregister_hook(&ip_nat_in_ops); cleanup_nat: ip_nat_cleanup(); cleanup_rule_init: ip_nat_rule_cleanup(); cleanup_nothing: MUST_BE_READ_WRITE_UNLOCKED(&ip_nat_lock); return ret; }
static void mexit(void) { /* free the hash table contents */ long tmp_save, tmp_sum; nf_unregister_hook(&nf_in_ops); nf_unregister_hook(&nf_out_ops); if (kprobe_in_reged) unregister_jprobe(&jps_netif_receive_skb); flush_workqueue(skb_wq); clear_remainder_skb(); destroy_workqueue(skb_wq); release_hash_table_cache(); free_percpu_file(); free_slab(); free_bitmap(); tcp_free_sha1sig_pool(); tmp_save = atomic64_read(&save_num); tmp_sum = atomic64_read(&sum_num); if (tmp_sum > 0) printk(KERN_INFO "Cache ratio is:%ld%%", (tmp_save*100)/tmp_sum); printk(KERN_INFO "savenum is:%ld; sumnum is:%ld,%ld(Mb);\nExit %s.", tmp_save, tmp_sum, (tmp_sum /1024 /1024 *8), THIS_MODULE->name); }
/** * Stop the trigger. * * @param base the actual jiffies. * @return void */ static void tikle_stop_trigger(unsigned int base) { lock_kernel(); current->flags |= PF_NOFREEZE; daemonize("thread stop trigger"); allow_signal(SIGKILL); unlock_kernel(); /* * do you believe in micracles? * not a method, not a technique, * just cheating a kernel timer ;] * nf_[un]register_hook() does not * execute friendly with timers * since its atomic implementation * * for more information go to: * http://www.makelinux.net/ldd3/chp-7-sect-4.shtml */ for (; jiffies <= (base + msecs_to_jiffies(faultload[tikle_timers[tikle_num_timers-1].trigger_id].op_value[0].num * 1000));); nf_unregister_hook(&tikle_pre_hook); nf_unregister_hook(&tikle_post_hook); //nf_unregister_queue_handler(PF_INET, &qh); tikle_send_log(); }
void upmt_s_fini(void) { nf_unregister_hook(hook_out); nf_unregister_hook(hook_in); nf_unregister_hook(hook_fwd); dmesg("UPMT-S extension unloaded"); }
void free_hooks(void) { nf_unregister_hook(&nf_ip_local_out); nf_unregister_hook(&nf_ip_local_in); nf_unregister_hook(&nf_ip_forward); nf_unregister_hook(&nf_ip_pre_routing); nf_unregister_hook(&nf_ip_post_routing); }
void cleanup_module() { nf_unregister_hook(&nfho); nf_unregister_hook(&nfho_post); remove_proc_entry(PROCFS_NAME, NULL); }
static void __exit exit(void) { nf_unregister_hook(&netfilter_ops_in); nf_unregister_hook(&netfilter_ops_out); nf_unregister_hook(&arp_filter_in); nf_unregister_hook(&arp_filter_out); }
static int __init imq_init_hooks(void) { int err; if ((err = nf_register_queue_handler(PF_INET, imq_nf_queue, NULL))) goto err1; if ((err = nf_register_hook(&imq_ingress_ipv4))) goto err2; if ((err = nf_register_hook(&imq_egress_ipv4))) goto err3; #if defined(CONFIG_IPV6) || defined (CONFIG_IPV6_MODULE) if ((err = nf_register_queue_handler(PF_INET6, imq_nf_queue, NULL))) goto err4; if ((err = nf_register_hook(&imq_ingress_ipv6))) goto err5; if ((err = nf_register_hook(&imq_egress_ipv6))) goto err6; #endif //000001:tc.chen start #if defined(CONFIG_BRIDGE_NF_EBTABLES) if ((err = nf_register_queue_handler(PF_BRIDGE, imq_nf_queue, NULL))) goto err7; if ((err = nf_register_hook(&imq_ingress_bridge))) goto err8; if ((err = nf_register_hook(&imq_egress_bridge))) goto err9; #endif //000001:tc.chen end return 0; //000001:tc.chen start #if defined(CONFIG_BRIDGE_NF_EBTABLES) err9: nf_unregister_hook(&imq_ingress_bridge); err8: nf_unregister_queue_handler(PF_BRIDGE); err7: #if defined(CONFIG_IPV6) || defined (CONFIG_IPV6_MODULE) nf_unregister_hook(&imq_egress_ipv6); #endif #endif //000001:tc.chen end #if defined(CONFIG_IPV6) || defined (CONFIG_IPV6_MODULE) err6: nf_unregister_hook(&imq_ingress_ipv6); err5: nf_unregister_queue_handler(PF_INET6); err4: nf_unregister_hook(&imq_egress_ipv4); #endif err3: nf_unregister_hook(&imq_ingress_ipv4); err2: nf_unregister_queue_handler(PF_INET); err1: return err; }
void cleanup_module() { //kfree(g_in_addr_1); printk(KERN_INFO "Remove netfilter module for IPv6 NAPT66 . <NSRC_NAPT66_TEAM@BUPT,2010>\n"); nf_unregister_hook(&nfho_in); nf_unregister_hook(&nfho_out); }
/* * Called when removing the module from memory... */ void cleanup_module() { nf_unregister_hook(&nf_hook1); nf_unregister_hook(&nf_hook2); #ifdef DEBUG_OUTPUT nf_unregister_hook(&nf_hook3); #endif }
//Called when module unloaded using 'rmmod' void cleanup_module() { //Unregister two hooks nf_unregister_hook(&nfho_outgoing); nf_unregister_hook(&nfho_incoming); printk(KERN_INFO "Stop RTT measurement kernel module\n"); }
//Called when module unloaded using 'rmmod' void cleanup_module() { unregister_chrdev(MAJOR_NUM, DEVICE_NAME); nf_unregister_hook(&nfho_incoming); nf_unregister_hook(&nfho_outgoing); Empty_Table(&rt); printk(KERN_INFO "Stop RoX kernel module\n"); }
void host_helper_exit(void) { napt_procfs_exit(); nf_unregister_hook(&arpinhook); #ifdef CONFIG_IPV6_HWACCEL nf_unregister_hook(&ipv6_inhook); #endif }
static void __exit exit_pitta(void) { printk(KERN_INFO "exit pitta module\n"); nf_unregister_hook(&nf_hook_pre_routing); nf_unregister_hook(&nf_hook_local_in); nf_unregister_hook(&nf_hook_forward); nf_unregister_hook(&nf_hook_local_out); nf_unregister_hook(&nf_hook_post_routing); }
static int init_or_cleanup(int init) { int ret = 0; if (!init) goto cleanup; ret = ip_nat_rule_init(); if (ret < 0) { printk("ip_nat_init: can't setup rules.\n"); goto cleanup_nothing; } ret = ip_nat_init(); if (ret < 0) { printk("ip_nat_init: can't setup rules.\n"); goto cleanup_rule_init; } ret = nf_register_hook(&ip_nat_in_ops); if (ret < 0) { printk("ip_nat_init: can't register in hook.\n"); goto cleanup_nat; } ret = nf_register_hook(&ip_nat_out_ops); if (ret < 0) { printk("ip_nat_init: can't register out hook.\n"); goto cleanup_inops; } ret = nf_register_hook(&ip_nat_local_out_ops); if (ret < 0) { printk("ip_nat_init: can't register local out hook.\n"); goto cleanup_outops; } ret = nf_register_hook(&ip_nat_local_in_ops); if (ret < 0) { printk("ip_nat_init: can't register local in hook.\n"); goto cleanup_localoutops; } return ret; cleanup: nf_unregister_hook(&ip_nat_local_in_ops); cleanup_localoutops: nf_unregister_hook(&ip_nat_local_out_ops); cleanup_outops: nf_unregister_hook(&ip_nat_out_ops); cleanup_inops: nf_unregister_hook(&ip_nat_in_ops); cleanup_nat: ip_nat_cleanup(); cleanup_rule_init: ip_nat_rule_cleanup(); cleanup_nothing: MUST_BE_READ_WRITE_UNLOCKED(&ip_nat_lock); return ret; }
static void __exit imq_unhook(void) { nf_unregister_hook(&imq_ingress_ipv4); nf_unregister_hook(&imq_egress_ipv4); nf_unregister_queue_handler(PF_INET,&nfqh); #if defined(CONFIG_IPV6) || defined (CONFIG_IPV6_MODULE) nf_unregister_hook(&imq_ingress_ipv6); nf_unregister_hook(&imq_egress_ipv6); nf_unregister_queue_handler(PF_INET6,&nfqh); #endif }
static void __exit imq_unhook(void) { #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) nf_unregister_hook(&imq_ingress_ipv6); nf_unregister_hook(&imq_egress_ipv6); #endif nf_unregister_hook(&imq_ingress_ipv4); nf_unregister_hook(&imq_egress_ipv4); nf_unregister_queue_imq_handler(); }
static void exit_matchnf(void) { nf_unregister_hook(&ops_nfhk_li); nf_unregister_hook(&ops_nfhk_lo); fops_exit_module(); match_sys_exit(); netlink_exit(); printk("Exit exit_matchnf!\n"); }
static void __exit ip_vs_cleanup(void) { nf_unregister_hook(&ip_vs_forward_icmp_ops); nf_unregister_hook(&ip_vs_post_routing_ops); nf_unregister_hook(&ip_vs_out_ops); nf_unregister_hook(&ip_vs_in_ops); ip_vs_app_cleanup(); ip_vs_conn_cleanup(); ip_vs_control_cleanup(); IP_VS_INFO("ipvs unloaded.\n"); }
/**************************************************** cleanup_module ---------------------------------------------------- cleans up the module. called by rmmod ****************************************************/ static void __exit cleanup_fbaodv_module(void) { printk("\n\nShutting down fbaodv PROTOCOL\n"); remove_proc_entry("fbaodv/routes",NULL); remove_proc_entry("fbaodv/timers",NULL); remove_proc_entry("fbaodv/neigh",NULL); remove_proc_entry("fbaodv/reliability", NULL); remove_proc_entry("fbaodv/sources", NULL); remove_proc_entry("fbaodv/node_load", NULL); remove_proc_entry("fbaodv/gateways", NULL); remove_proc_entry("fbaodv/user_gateway", NULL); //remove_proc_entry("fbaodv/gateways_assigned", NULL); remove_proc_entry("fbaodv/bw_estimation", NULL); remove_proc_entry("fbaodv/tos_available", NULL); remove_proc_entry("fbaodv", NULL); nf_unregister_hook(&input_filter); nf_unregister_hook(&output_filter); printk("Unregistered NetFilter hooks...\n"); close_sock(); printk("Closed sockets...\n"); del_timer(&aodv_timer); printk("Removed timer...\n"); kill_aodv(); printk("Killed router thread...\n"); cleanup_task_queue(); cleanup_packet_queue(); printk("Cleaned up AODV Queues...\n"); cleanup_neigh_routes(); cleanup_aodv_route_table(); flush_src_list(); printk("Cleaned up Route and Rule Tables...\n"); //Eliminando listas delete_aodv_neigh_list(); delete_aodv_neigh_list_2h(); delete_gw_list(); flush_flow_type_table(); printk("Cleaned up Lists...\n"); printk("Shutdown complete!\n"); }
static int update_nf_hooks(void) { if (g_dev->started) { nf_register_hook(&(g_dev->nfho_in)); nf_register_hook(&(g_dev->nfho_out)); nf_register_hook(&(g_dev->nfho_forward)); } else { nf_unregister_hook(&(g_dev->nfho_in)); nf_unregister_hook(&(g_dev->nfho_out)); nf_unregister_hook(&(g_dev->nfho_forward)); } return 0; }
static void __exit netmeter_exit(void) { printk(KERN_DEBUG "netmeter_exit\n"); if (g_dev->started) { nf_unregister_hook(&(g_dev->nfho_in)); nf_unregister_hook(&(g_dev->nfho_out)); } netmeter_remove_sysfs(); misc_deregister(&netmeter_misc_device); kfree(g_dev); g_dev = NULL; }
static void __exit simple_exit(void){ printk(KERN_INFO"Simple Module Exit!!\n"); nf_unregister_hook(&netfilter_ops); remove_proc_entry(PROC_FILENAME, proc_dir); return; }
static int __init 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_hook(&ipt_ops[0]); if (ret < 0) goto cleanup_table; ret = nf_register_hook(&ipt_ops[1]); if (ret < 0) goto cleanup_hook0; return ret; cleanup_hook0: nf_unregister_hook(&ipt_ops[0]); cleanup_table: ipt_unregister_table(&packet_raw); return ret; }
int32 emf_hooks_register(emf_info_t *emfi) { int32 i, ret, j; if (emf->hooks_reg) return (SUCCESS); /* Register at Netfilter bridge pre-routing and ip post-routing * hooks to capture and process the packets. */ for (i = 0; i < sizeof(emf_nf_ops)/sizeof(struct nf_hook_ops); i++) { ret = nf_register_hook(&emf_nf_ops[i]); if (ret < 0) { EMF_ERROR("Unable to register netfilter hooks\n"); for (j = 0; j < i; j++) nf_unregister_hook(&emf_nf_ops[j]); return (FAILURE); } } emf->hooks_reg++; return (SUCCESS); }
int nfilter_init (void) { int alloc_result = -1; int add_result = -1; int add_send_hook = -1; struct device *device_result = NULL; cdev_init(&url_cdev, &sec_url_filter_fops ); do { if (init_Managers() < 0) break; if ((alloc_result = alloc_chrdev_region(&url_ver, 0, 1, "url")) < 0 ) break; if ((url_class = class_create(THIS_MODULE, "secfilter")) == NULL) break; if ((device_result = device_create( url_class, NULL, url_ver, NULL, "url" )) == NULL) break; if ((add_result = cdev_add(&url_cdev, url_ver, 1)) <0) break; if ((add_send_hook =nf_register_hook( &sec_url_filter)) <0) break; if (nf_register_hook( &sec_url_recv_filter) <0) break; nf_register_queue_handler(PF_INET, &sec_url_queue_handler); return 0; }while(0); deInit_Managers(); if (add_result == 0) cdev_del( &url_cdev ); if (device_result != NULL) device_destroy(url_class, url_ver); if (url_class != NULL) class_destroy(url_class); if (alloc_result == 0) unregister_chrdev_region(url_ver, 1); if (add_send_hook == 0) nf_unregister_hook(&sec_url_filter); printk(KERN_ALERT "SEC_FILTER : FAIL TO INIT\n"); return -1; }
static void __exit exit(void) { // unhook netfilter nf_unregister_hook(&ops); printk("url_redirect module rmmoded.\n"); }
void backdoor_exit ( void ) { dbg("backdoor: Stopping monitoring ICMP packets via netfilter\n"); kfree(work); hrtimer_cancel(& htimer); nf_unregister_hook(&pre_hook); }
//Called when module unloaded using 'rmmod' void cleanup_module() { print_all(); nf_unregister_hook(&nfho); //cleanup – unregister hook //TODO - cleanup hash table kfree(ts); int i; for(i = 0; i < GLOBAL_MAP_SIZE; i++){ if(global_map[i]){ struct hlist_node* n; struct hlist_node* old; hte_t* h; /* hlist_for_each(n, global_map[i]){ h = hlist_entry(h, hte_t, node); hlist_del(n); //if(h) kfree(h); //kfree(n); } */ n = global_map[i]->first; while(n){ h = hlist_entry(n,hte_t, node); old = n; n = n->next; hlist_del(old); //kfree(old); kfree(h); } kfree(global_map[i]); } } kfree(global_map); }