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);
}
