C++ sock_unregister函数代码示例

_STATIC void socket_notify_remove(void)
{
#if defined(CONFIG_IPV6)
	sock_unregister(hooked_inet6_family_ops.family);
	reinstall_family("IPv6", &inet6_family_ops);
#endif
	sock_unregister(hooked_inet_family_ops.family);
	unregister_jprobe(&inet_sock_destruct_jprobe);
	reinstall_family("IPv4", &inet_family_ops);
	synchronize_net();
}

static void __exit af_ieee802154_remove(void)
{
	dev_remove_pack(&ieee802154_packet_type);
	sock_unregister(PF_IEEE802154);
	proto_unregister(&ieee802154_dgram_prot);
	proto_unregister(&ieee802154_raw_prot);
}

void cleanup_module(void)
{
	/* First of all disallow new sockets creation. */
	sock_unregister(PF_INET6);
#ifdef CONFIG_PROC_FS
	proc_net_unregister(proc_net_raw6.low_ino);
	proc_net_unregister(proc_net_tcp6.low_ino);
	proc_net_unregister(proc_net_udp6.low_ino);
	proc_net_unregister(proc_net_sockstat6.low_ino);
	proc_net_unregister(proc_net_snmp6.low_ino);
#endif
	/* Cleanup code parts. */
	sit_cleanup();
	ipv6_netdev_notif_cleanup();
	ip6_flowlabel_cleanup();
	addrconf_cleanup();
	ip6_route_cleanup();
	ipv6_packet_cleanup();
	igmp6_cleanup();
	ndisc_cleanup();
	icmpv6_cleanup();
#ifdef CONFIG_SYSCTL
	ipv6_sysctl_unregister();	
#endif
}

/* Module registration */
static int __init phonet_init(void)
{
    int err;

    err = phonet_device_init();
    if (err)
        return err;

    err = sock_register(&phonet_proto_family);
    if (err) {
        printk(KERN_ALERT
               "phonet protocol family initialization failed\n");
        goto err_sock;
    }

    dev_add_pack(&phonet_packet_type);
    phonet_sysctl_init();

    err = isi_register();
    if (err)
        goto err;
    return 0;

err:
    phonet_sysctl_exit();
    sock_unregister(PF_PHONET);
    dev_remove_pack(&phonet_packet_type);
err_sock:
    phonet_device_exit();
    return err;
}

static void inet6_exit(void)
{
	/* First of all disallow new sockets creation. */
	sock_unregister(PF_INET6);
#ifdef CONFIG_PROC_FS
	proc_net_remove("raw6");
	proc_net_remove("tcp6");
	proc_net_remove("udp6");
	proc_net_remove("sockstat6");
	proc_net_remove("snmp6");
#endif
	/* Cleanup code parts. */
	sit_cleanup();
	ipv6_netdev_notif_cleanup();
	ip6_flowlabel_cleanup();
	addrconf_cleanup();
	ip6_route_cleanup();
	ipv6_packet_cleanup();
	igmp6_cleanup();
	ndisc_cleanup();
	icmpv6_cleanup();
#ifdef CONFIG_SYSCTL
	ipv6_sysctl_unregister();	
#endif
}

static void __exit llc2_exit(void)
{
	llc_station_exit();
	llc_remove_pack(LLC_DEST_SAP);
	llc_remove_pack(LLC_DEST_CONN);
	sock_unregister(PF_LLC);
	llc_proc_exit();
}

static void __exit phonet_exit(void)
{
    isi_unregister();
    phonet_sysctl_exit();
    sock_unregister(PF_PHONET);
    dev_remove_pack(&phonet_packet_type);
    phonet_device_exit();
}

void tipc_socket_stop(void)
{
	if (!sockets_enabled)
		return;

	sockets_enabled = 0;
	sock_unregister(tipc_family_ops.family);
	proto_unregister(&tipc_proto);
}

static void __exit vrr_exit(void)
{
	sock_unregister(AF_VRR);
	dev_remove_pack(&vrr_packet_type);
	del_timer(&vrr_timer);
	/* Cleanup routing/sysfs stuff here */
	kobject_put(vrr_obj);

	proto_unregister(&vrr_proto);
}

void bluez_cleanup(void)
{
	/* Release socket */
	hci_sock_cleanup();

	/* Release core */
	hci_core_cleanup();

	sock_unregister(PF_BLUETOOTH);

	remove_proc_entry("bluetooth", NULL);
}

_STATIC int __init socket_notify_init(void)
{
	int err;

	if ((err = install_hook("IPv4", &inet_family_ops, &hooked_inet_family_ops)))
		return err;
	if ((err = register_jprobe(&inet_sock_destruct_jprobe)) < 0) {
		printk(KERN_ERR "error registering inet_sock_destruct_jprobe\n");
		sock_unregister(hooked_inet_family_ops.family);
		reinstall_family("IPv4", &inet_family_ops);		
		return err;
	}
#if defined(CONFIG_IPV6)
	if ((err = install_hook("IPv6", &inet6_family_ops, &hooked_inet6_family_ops))) {
		unregister_jprobe(&inet_sock_destruct_jprobe);
		sock_unregister(hooked_inet_family_ops.family);
		reinstall_family("IPv4", &inet_family_ops);
		return err;
	}
#endif
	return 0;
}

void vsock_core_exit(void)
{
	mutex_lock(&vsock_register_mutex);

	misc_deregister(&vsock_device);
	sock_unregister(AF_VSOCK);
	proto_unregister(&vsock_proto);

	/* We do not want the assignment below re-ordered. */
	mb();
	transport = NULL;

	mutex_unlock(&vsock_register_mutex);
}

void cleanup_module(void)
{
	/* 
	 * Added by MSEVILLA (12-9-2012)
	 *  Cleanup my character device
	 */
	device_destroy(my_class, MKDEV(major_no, 0));
	class_unregister(my_class);
	class_destroy(my_class);
	unregister_chrdev(major_no, DEVICE_NAME);
	printk(KERN_INFO "removing mobile_host module\n");
    
    proto_unregister(&udpmhost_prot);
    sock_unregister(AF_MHOST);
    dev_remove_pack(&mhost_ptype);
}

/* Module registration */
static int __init phonet_init(void)
{
	int err;

#ifdef ACTIVATE_PHONET_DEBUG
	err = sysfs_create_file(kernel_kobj, &phonet_attr.attr);
	if (err)
		printk(KERN_DEBUG "phonet sysfs_create_file failed: %d\n", err);
#endif

	err = phonet_device_init();
	if (err)
		return err;

	pn_sock_init();
	err = sock_register(&phonet_proto_family);
	if (err) {
		printk(KERN_ALERT
			"phonet protocol family initialization failed\n");
		goto err_sock;
	}

	dev_add_pack(&phonet_packet_type);
	phonet_sysctl_init();

	err = isi_register();
	if (err)
		goto err;
	return 0;

err:
	phonet_sysctl_exit();
	sock_unregister(PF_PHONET);
	dev_remove_pack(&phonet_packet_type);
err_sock:
	phonet_device_exit();
	return err;
}

static int install_hook(const char *name,
		const struct net_proto_family *family_ops,
		const struct net_proto_family *hooked_ops)
{
	int err;

	if (family_ops->family != hooked_ops->family)
		return -EINVAL;
	if (try_module_get(family_ops->owner)) {
		sock_unregister(family_ops->family);
		if ((err = sock_register(hooked_ops))) {
			printk(KERN_ERR "%s: %s hook registration failed (error %d)\n",
					THIS_MODULE->name, name, err);
			reinstall_family(name, family_ops);
			return err;
		}
	} else {
		printk(KERN_ERR "%s: failed to get reference to %s family ops\n",
				THIS_MODULE->name, name);
		return -ENOENT;
	}
	return 0;
}