static int __init dn_rtmsg_init(void)
{
int rv = 0;
struct netlink_kernel_cfg cfg = {
.groups = DNRNG_NLGRP_MAX,
.input = dnrmg_receive_user_skb,
};
dnrmg = netlink_kernel_create(&init_net, NETLINK_DNRTMSG, &cfg);
if (dnrmg == NULL) {
printk(KERN_ERR "dn_rtmsg: Cannot create netlink socket");
return -ENOMEM;
}
rv = nf_register_net_hook(&init_net, &dnrmg_ops);
if (rv) {
netlink_kernel_release(dnrmg);
}
return rv;
}
/*
* 初始化init-function for netlink
*/
void mkm_nl_init(void)
{
mkm_userspace_pid = -1;
#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22))
nl_sock = netlink_kernel_create( NETLINK_MKM, 0, recv_msg, THIS_MODULE);
#elif (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24))
nl_sock = netlink_kernel_create( NETLINK_MKM, 0, recv_msg, NULL, THIS_MODULE);
#elif(LINUX_VERSION_CODE < KERNEL_VERSION(3,6,0))
nl_sock = netlink_kernel_create(&init_net, NETLINK_MKM, 0, recv_msg, NULL, THIS_MODULE);
#else
{
struct netlink_kernel_cfg cfg = {
.input = recv_msg,
.groups = 1,
};
#if(LINUX_VERSION_CODE < KERNEL_VERSION(3,7,0))
nl_sock = netlink_kernel_create(&init_net, NETLINK_MKM,THIS_MODULE, &cfg);
#else
nl_sock = netlink_kernel_create(&init_net, NETLINK_MKM, &cfg);
#endif
}
#endif
if(!nl_sock) {
printk(KERN_WARNING "%s,failed to create netlink socket\n",__FUNCTION__);
}
printk(KERN_INFO "MKM (monitor kernel module) Create socket\n");
}
void mkm_nl_close(void)
{
mutex_lock(&mkm_nl_mutex);
netlink_kernel_release(nl_sock);
mutex_unlock(&mkm_nl_mutex);
}
static void __exit netlinkuser_exit(void)
{
printk(KERN_INFO "Exiting netlinkuser module\n");
netlink_kernel_release(nl_sk);
}
static void __exit hello_exit(void){
printk(KERN_INFO "exiting hello module\n");
netlink_kernel_release(nl_sk);
}
static void __exit my_module_exit(void)
{
netlink_kernel_release(nl_sk);
printk(KERN_INFO "Goodbye\n");
}
static void __exit dn_rtmsg_fini(void)
{
nf_unregister_net_hook(&init_net, &dnrmg_ops);
netlink_kernel_release(dnrmg);
}
void user_comm_exit(void) {
if (_sock) netlink_kernel_release(_sock);
}
static int __init pkt_mangle_init(void)
{
printk(KERN_ALERT "\npkt_mangle output module started ...\n");
//pre_routing
pre_routing.pf = NFPROTO_IPV4;
pre_routing.priority = NF_IP_PRI_NAT_SRC;
pre_routing.hooknum = NF_IP_PRE_ROUTING;
pre_routing.hook = incoming_change_begin;
nf_register_hook(& pre_routing);
//out put does to localout and mangle the hdr
local_out.pf = NFPROTO_IPV4;
local_out.priority = NF_IP_PRI_NAT_DST;
local_out.hooknum = NF_IP_POST_ROUTING;
local_out.hook = outgoing_change_begin;
nf_register_hook(& local_out);
//net link also initilizaed here
printk(KERN_ALERT "Entering: %s\n", __FUNCTION__);
struct netlink_kernel_cfg cfg = {
.groups = 1,
.input = hello_nl_recv_msg,
};
nl_sk = netlink_kernel_create(&init_net, NETLINK_USER, &cfg);
if (!nl_sk)
{
printk(KERN_ALERT "Error creating socket.\n");
return -10;
}
struct timespec ts_start,ts_end,test_of_time;
//create a hash table
//getnstimeofday(&ts_start);
record_t l, *p, *r;
//add hash entry in the hash table
r = (record_t*)kmalloc( sizeof(record_t) , GFP_KERNEL);
memset(r, 0, sizeof(record_t));
r->key.src = in_aton("128.112.93.107");
r->key.dport =5001;
r->src = in_aton("128.112.93.106");
r->dst = in_aton("128.112.93.108");
//r->dport = 5001;
HASH_ADD(hh, records, key, sizeof(record_key_t), r);
r = (record_t*)kmalloc( sizeof(record_t) , GFP_KERNEL);
memset(r, 0, sizeof(record_t));
r->key.src = in_aton("128.112.93.108");
r->key.sport =5001;
r->dst = in_aton("128.112.93.107");
r->src = in_aton("128.112.93.106");
HASH_ADD(hh, records, key, sizeof(record_key_t), r);
return 0;
}
static void __exit pkt_mangle_exit(void)
{
//nf_unregister_hook(&post_routing);
nf_unregister_hook(&local_out);
nf_unregister_hook(&pre_routing);
netlink_kernel_release(nl_sk);
//this is hash table
struct timespec ts_start,ts_end,test_of_time;
getnstimeofday(&ts_start);
record_t *p, *tmp;
int counter;
counter = 0;
HASH_ITER(hh, records, p, tmp) {
HASH_DEL(records, p);
counter ++;
kfree(p);
}
static void __exit netlinktest_exit(void)
{
printk(KERN_INFO"Leave netlink test module.\n");
netlink_kernel_release(nltest_sock);
}
/*
* Deinit the netlink service.
* Netlink service is unusable after this.
*/
void nl_srv_exit(void)
{
netlink_kernel_release(nl_srv_sock);
nl_srv_sock = NULL;
}
void __exit ecc_exit(void) {
// netlink clean up
if(sock_fd != NULL)
netlink_kernel_release(sock_fd);
}
void nlhandler_destroy(void)
{
error_pool_destroy();
if (nl_socket)
netlink_kernel_release(nl_socket);
}
static void __exit kexp_mod_cleanup(void)
{
printk(KERN_INFO "kexp module exiting...\n");
netlink_kernel_release(socket);
}
static void deth_exit_net(struct net* net)
{
struct deth_net* dn = net_generic(net, deth_net_id);
netlink_kernel_release(dn->nl_sk);
}
static void __exit spi_exit(void) {
printk(KERN_INFO "exiting SPI module\n");
spi_release();
gpio_free(gpio_pin_chipselect);
netlink_kernel_release(nl_sk);
}
void nlhandler_destroy(void)
{
netlink_kernel_release(nl_socket);
}
void netlink_exit(struct sock *sock)
{
netlink_kernel_release(sock);
}
void nat64_config_destroy(void)
{
/* Netlink sockets. */
if (my_nl_sock)
netlink_kernel_release(my_nl_sock);
}
void pna_alert_cleanup(void)
{
netlink_kernel_release(pna_alert_sock);
}
/**
* rmnet_config_exit() - Cleans up all netlink related resources
*/
void rmnet_config_exit(void)
{
netlink_kernel_release(nl_socket_handle);
}
static void __exit kudp_exit(void)
{
//sock_release(netlink_sock->sk_socket);
netlink_kernel_release(netlink_sock);
printk("netlink driver remove successfully\n");
}
static void __exit dummyflt_exit(void)
{
netlink_kernel_release(nl_sk);
redirfs_delete_filter(dummyflt);
}
void cleanup_module(void)
{
unregister_jprobe(&my_jprobe_udp);
netlink_kernel_release(nl_sk_udp);
printk("jprobe unregistered\n");
}
static void dispmgr_nl_exit(void)
{
printk(KERN_INFO "kdispmgr: exiting hello module\n");
netlink_kernel_release(nl_sk);
g_pid = 0;
}
static void __exit netsession_nl_exit(void)
{
printk("Removing netsession_nl NETLINK layer.\n");
netlink_kernel_release(netsession_nl);
return;
}
static void __exit nfnetlink_exit(void)
{
printk("Removing netfilter NETLINK layer.\n");
netlink_kernel_release(nfnl);
return;
}
int dest_Broadcast(){
netlink_kernel_release(netlink_broadcast_socket);
return 200;
}
/**
* ecryptfs_release_netlink
*
* Frees all memory used by the netlink context array and releases the
* netlink socket.
*/
void ecryptfs_release_netlink(void)
{
netlink_kernel_release(ecryptfs_nl_sock);
ecryptfs_nl_sock = NULL;
}
void nl_halt(void){
netlink_kernel_release(nl_sk);
kthread_stop(nl_thread), nl_thread = NULL;
}
