static int fuse_link(struct dentry *entry, struct inode *newdir,
		     struct dentry *newent)
{
	int err;
	struct fuse_link_in inarg;
	struct inode *inode = entry->d_inode;
	struct fuse_conn *fc = get_fuse_conn(inode);
	struct fuse_req *req = fuse_get_req(fc);
	if (IS_ERR(req))
		return PTR_ERR(req);

	memset(&inarg, 0, sizeof(inarg));
	inarg.oldnodeid = get_node_id(inode);
	req->in.h.opcode = FUSE_LINK;
	req->in.numargs = 2;
	req->in.args[0].size = sizeof(inarg);
	req->in.args[0].value = &inarg;
	req->in.args[1].size = newent->d_name.len + 1;
	req->in.args[1].value = newent->d_name.name;
	err = create_new_entry(fc, req, newdir, newent, inode->i_mode);
	if (!err) {
		struct fuse_inode *fi = get_fuse_inode(inode);

		spin_lock(&fc->lock);
		fi->attr_version = ++fc->attr_version;
		inc_nlink(inode);
		spin_unlock(&fc->lock);
		fuse_invalidate_attr(inode);
	} else if (err == -EINTR) {
		fuse_invalidate_attr(inode);
	}
	return err;
}

static int fuse_link(struct dentry *entry, struct inode *newdir,
		     struct dentry *newent)
{
	int err;
	struct fuse_link_in inarg;
	struct inode *inode = entry->d_inode;
	struct fuse_conn *fc = get_fuse_conn(inode);
	struct fuse_req *req = fuse_get_req(fc);
	if (IS_ERR(req))
		return PTR_ERR(req);

	memset(&inarg, 0, sizeof(inarg));
	inarg.oldnodeid = get_node_id(inode);
	req->in.h.opcode = FUSE_LINK;
	req->in.numargs = 2;
	req->in.args[0].size = sizeof(inarg);
	req->in.args[0].value = &inarg;
	req->in.args[1].size = newent->d_name.len + 1;
	req->in.args[1].value = newent->d_name.name;
	err = create_new_entry(fc, req, newdir, newent, inode->i_mode);
	/* Contrary to "normal" filesystems it can happen that link
	   makes two "logical" inodes point to the same "physical"
	   inode.  We invalidate the attributes of the old one, so it
	   will reflect changes in the backing inode (link count,
	   etc.)
	*/
	if (!err || err == -EINTR)
		fuse_invalidate_attr(inode);
	return err;
}

route_table_mgr::route_table_mgr() : netlink_socket_mgr<route_val>(ROUTE_DATA_TYPE), cache_table_mgr<route_rule_table_key, route_val*>("route_table_mgr")
{
	rt_mgr_logdbg("");

	//Read Route table from kernel and save it in local variable. 
	update_tbl();

	// create route_entry for each net_dev- needed for receiving port up/down events for net_dev_entry
	route_val *p_val;
	for (int i = 0; i < m_tab.entries_num; i++)
	{
		p_val = &m_tab.value[i];
		in_addr_t src_addr = p_val->get_src_addr();
		std::tr1::unordered_map<in_addr_t, route_entry*>::iterator iter = m_rte_list_for_each_net_dev.find(src_addr);
		// if src_addr of interface exists in the map, no need to create another route_entry
		if (iter == m_rte_list_for_each_net_dev.end()) {
			in_addr_t dst_ip	= src_addr;
			in_addr_t src_ip	= 0;
			uint8_t tos		= 0;
			m_rte_list_for_each_net_dev.insert(pair<in_addr_t, route_entry*> (src_addr, create_new_entry(route_rule_table_key(dst_ip, src_ip, tos), NULL)));
		}
	}

	//Print table
	print_val_tbl();
	
	// register to netlink event
	g_p_netlink_handler->register_event(nlgrpROUTE, this);
	rt_mgr_logdbg("Registered to g_p_netlink_handler");

	rt_mgr_logdbg("Done");
}

void *memory_cache_insert (vmi_instance_t vmi, addr_t paddr)
{
    memory_cache_entry_t entry = NULL;
    addr_t paddr_aligned = paddr & ~( ((addr_t) vmi->page_size) - 1);
    if (paddr != paddr_aligned){
        errprint("Memory cache request for non-aligned page\n");
        return NULL;
    }

    gint64 *key = safe_malloc(sizeof(gint64));
    *key = paddr;
    if ((entry = g_hash_table_lookup(vmi->memory_cache, key)) != NULL){
        dbprint("--MEMORY cache hit 0x%llx\n", paddr);
        free(key);
        return validate_and_return_data(vmi, entry);
    }
    else{
        dbprint("--MEMORY cache set 0x%llx\n", paddr);
        entry = create_new_entry(vmi, paddr, vmi->page_size);
        if (!entry) {
            errprint ("create_new_entry failed\n");
            return 0;
        }

        g_hash_table_insert(vmi->memory_cache, key, entry);

        gint64 *key2 = safe_malloc(sizeof(gint64));
        *key2 = paddr;
        vmi->memory_cache_lru = g_list_prepend(vmi->memory_cache_lru, key2);
        vmi->memory_cache_size++;

        return entry->data;
    }
}

static int fuse_symlink(struct inode *dir, struct dentry *entry,
			const char *link)
{
	struct fuse_conn *fc = get_fuse_conn(dir);
	unsigned len = strlen(link) + 1;
	FUSE_ARGS(args);

	args.in.h.opcode = FUSE_SYMLINK;
	args.in.numargs = 2;
	args.in.args[0].size = entry->d_name.len + 1;
	args.in.args[0].value = entry->d_name.name;
	args.in.args[1].size = len;
	args.in.args[1].value = link;
	return create_new_entry(fc, &args, dir, entry, S_IFLNK);
}

static int fuse_mkdir(struct inode *dir, struct dentry *entry, umode_t mode)
{
	struct fuse_mkdir_in inarg;
	struct fuse_conn *fc = get_fuse_conn(dir);
	FUSE_ARGS(args);

	if (!fc->dont_mask)
		mode &= ~current_umask();

	memset(&inarg, 0, sizeof(inarg));
	inarg.mode = mode;
	inarg.umask = current_umask();
	args.in.h.opcode = FUSE_MKDIR;
	args.in.numargs = 2;
	args.in.args[0].size = sizeof(inarg);
	args.in.args[0].value = &inarg;
	args.in.args[1].size = entry->d_name.len + 1;
	args.in.args[1].value = entry->d_name.name;
	return create_new_entry(fc, &args, dir, entry, S_IFDIR);
}

route_table_mgr::route_table_mgr() : cache_table_mgr<ip_address,route_val*>("route_table_mgr")
{
	rt_mgr_logdbg("");

	m_pid = getpid();
	m_buff_size = MSG_BUFF_SIZE;
	m_seq_num = 0;

	// Create Socket
	BULLSEYE_EXCLUDE_BLOCK_START
	if ((m_fd = orig_os_api.socket(PF_NETLINK, SOCK_DGRAM, NETLINK_ROUTE)) < 0) {
		rt_mgr_logerr("NL socket Creation: ");
		return;
	}
	BULLSEYE_EXCLUDE_BLOCK_END

	//save the routing table
	rt_mgr_update_tbl();

	// create route_entry for each net_dev- needed for receiving port up/down events for net_dev_entry
	route_val *p_rtv;
	for (int i = 0; i < m_rt_tab.entries_num; i++)
	{
		p_rtv = &m_rt_tab.rtv[i];
		in_addr_t src_addr = p_rtv->get_src_addr();
		std::tr1::unordered_map<in_addr_t, route_entry*>::iterator iter = m_rte_list_for_each_net_dev.find(src_addr);
		// if src_addr of interface exists in the map, no need to create another route_entry
		if (iter == m_rte_list_for_each_net_dev.end()) {
			m_rte_list_for_each_net_dev.insert(pair<in_addr_t, route_entry*> (src_addr, create_new_entry(ip_address(src_addr), NULL)));
		}
	}

	print_route_tbl();

	// register to netlink event
	g_p_netlink_handler->register_event(nlgrpROUTE, this);
	rt_mgr_logdbg("Registered to g_p_netlink_handler");

	rt_mgr_logdbg("Done");
}

static int fuse_link(struct dentry *entry, struct inode *newdir,
		     struct dentry *newent)
{
	int err;
	struct fuse_link_in inarg;
	struct inode *inode = d_inode(entry);
	struct fuse_conn *fc = get_fuse_conn(inode);
	FUSE_ARGS(args);

	memset(&inarg, 0, sizeof(inarg));
	inarg.oldnodeid = get_node_id(inode);
	args.in.h.opcode = FUSE_LINK;
	args.in.numargs = 2;
	args.in.args[0].size = sizeof(inarg);
	args.in.args[0].value = &inarg;
	args.in.args[1].size = newent->d_name.len + 1;
	args.in.args[1].value = newent->d_name.name;
	err = create_new_entry(fc, &args, newdir, newent, inode->i_mode);
	/* Contrary to "normal" filesystems it can happen that link
	   makes two "logical" inodes point to the same "physical"
	   inode.  We invalidate the attributes of the old one, so it
	   will reflect changes in the backing inode (link count,
	   etc.)
	*/
	if (!err) {
		struct fuse_inode *fi = get_fuse_inode(inode);

		spin_lock(&fc->lock);
		fi->attr_version = ++fc->attr_version;
		inc_nlink(inode);
		spin_unlock(&fc->lock);
		fuse_invalidate_attr(inode);
		fuse_update_ctime(inode);
	} else if (err == -EINTR) {
		fuse_invalidate_attr(inode);
	}
	return err;
}

int main()
{
	s_erc error = S_SUCCESS;
	SAddendum *addendum = NULL;
	SPlugin *addendumJSONPlugin = NULL;
	SList *wordInfo = NULL;
	s_bool syllabified;


	S_CLR_ERR(&error);

	/*
	 * initialize speect
	 */
	error = speect_init(NULL);
	if (error != S_SUCCESS)
	{
		printf("Failed to initialize Speect\n");
		return 1;
	}

	/*
	 * load the addendum-json plug-in
	 */
	addendumJSONPlugin = s_pm_load_plugin(addendum_json_plugin_path, &error);
	if (S_CHK_ERR(&error, S_CONTERR,
				  "main",
				  "Failed to load plug-in at '%s'", addendum_json_plugin_path))
	{
		printf("failed to load plug-in\n");
		goto quit;
	}
	else
	{
		printf("plug-in loaded\n");
	}

	/* load addendum */
	addendum = (SAddendum*)SObjectLoad("addendum_example.txt", "spct_addendum", &error);
	if (S_CHK_ERR(&error, S_CONTERR,
				  "main",
				  "Failed to load addendum"))
		goto quit;

	/* get a word from the addendum, NULL features (get first match) */
	wordInfo = S_ADDENDUM_CALL(addendum, get_word)(addendum, test_word, NULL, &syllabified,
											 &error);
	if (S_CHK_ERR(&error, S_CONTERR,
				  "main",
				  "Call to method \"get_word\" failed"))
		goto quit;

	if (wordInfo != NULL)
	{
		printf("found word\n");
		print_word(wordInfo, &error);
		if (S_CHK_ERR(&error, S_CONTERR,
					  "main",
					  "Call to \"print_word\" failed"))
			goto quit;
		S_DELETE(wordInfo, "main", &error);
	}
	else
	{
		printf("word '%s' not found, adding it\n", test_word);
		create_new_entry(addendum, &error);
		if (S_CHK_ERR(&error, S_CONTERR,
					  "main",
					  "Call to \"create_new_entry\" failed"))
			goto quit;

		/* now search for word again */
		printf("searching for added word '%s'\n", test_word);
		wordInfo = S_ADDENDUM_CALL(addendum, get_word)(addendum, test_word, NULL, &syllabified,
													   &error);
		if (S_CHK_ERR(&error, S_CONTERR,
					  "main",
					  "Call to method \"get_word\" failed"))
			goto quit;

		if (wordInfo == NULL)
		{
			printf("failed to find added word, error\n");
			goto quit;
		}
		else
		{
			printf("found added word\n");
			print_word(wordInfo, &error);
			if (S_CHK_ERR(&error, S_CONTERR,
						  "main",
						  "Call to \"print_word\" failed"))
				goto quit;
			S_DELETE(wordInfo, "main", &error);
		}
	}

quit:
	if (wordInfo != NULL)
		S_DELETE(wordInfo, "main", &error);
//.........这里部分代码省略.........

void blacklist_blacklist_node(const struct sockaddr *sa, unsigned char * md) {
	if (!enabled)
		return;
	struct sockaddr_in * ip4addr;
	struct sockaddr_in6 * ip6addr;
	struct blacklist_entry * prev;
	int i = 0, maxlevel = 0;
	u_int16_t port = 0;
	unsigned char addr[16];
	unsigned char pos = 0;
	//	printf("BLACKLIST ");
	//	printf_addr(sa);
	switch (sa->sa_family) {
	case AF_INET:
		maxlevel = 4;
		ip4addr = (struct sockaddr_in*) sa;
		if (IPv4_blacklist == NULL) {
			IPv4_blacklist = create_new_entry(0);
		}
		prev = IPv4_blacklist;
		memcpy(addr, &(ip4addr->sin_addr.s_addr), maxlevel);
		port = ip4addr->sin_port;
		//		printf(" Port %d", ntohs(ip4addr->sin_port));
		break;
	case AF_INET6:
		maxlevel = 16;
		ip6addr = (struct sockaddr_in6*) sa;
		memcpy(addr, &(ip6addr->sin6_addr.s6_addr), maxlevel);
		if (IPv6_blacklist == NULL) {
			IPv6_blacklist = create_new_entry(0);
		}
		prev = IPv6_blacklist;
		port = ip6addr->sin6_port;
		//		printf(" Port %d", ntohs(ip6addr->sin6_port));
		break;
	default:
		return;
	}
	//	printf("\n");
	for (i = 1; i <= maxlevel; i++) {
		if (i < maxlevel) {
			if (prev->children[addr[i - 1]] == NULL) {
				prev->children[addr[i - 1]] = create_new_entry(i + 1);
			}
		} else {
			if (prev->children[addr[i - 1]] == NULL) {
				switch (sa->sa_family) {
				case AF_INET:
					number_of_entries_ipv4++;
					break;
				case AF_INET6:
					number_of_entries_ipv6++;
					break;
				}
			}
			prev->children[addr[i - 1]] = create_new_leaf(port, md);
		}
		prev = prev->children[addr[i - 1]];
	}
	//	printf_blacklist();
}