static int fuse_mknod(struct inode *dir, struct dentry *entry, umode_t mode,
dev_t rdev)
{
struct fuse_mknod_in inarg;
struct fuse_conn *fc = get_fuse_conn(dir);
struct fuse_req *req = fuse_get_req_nopages(fc);
if (IS_ERR(req))
return PTR_ERR(req);
if (!fc->dont_mask)
mode &= ~current_umask();
memset(&inarg, 0, sizeof(inarg));
inarg.mode = mode;
inarg.rdev = new_encode_dev(rdev);
inarg.umask = current_umask();
req->in.h.opcode = FUSE_MKNOD;
req->in.numargs = 2;
req->in.args[0].size = fc->minor < 12 ? FUSE_COMPAT_MKNOD_IN_SIZE :
sizeof(inarg);
req->in.args[0].value = &inarg;
req->in.args[1].size = entry->d_name.len + 1;
req->in.args[1].value = entry->d_name.name;
return create_new_entry(fc, req, dir, entry, mode);
}
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");
}
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);
struct fuse_req *req = fuse_get_req(fc);
int ret;
if (IS_ERR(req))
return PTR_ERR(req);
if (!fc->dont_mask)
mode &= ~current_umask();
memset(&inarg, 0, sizeof(inarg));
inarg.mode = mode;
inarg.umask = current_umask();
req->in.h.opcode = FUSE_MKDIR;
req->in.numargs = 2;
req->in.args[0].size = sizeof(inarg);
req->in.args[0].value = &inarg;
req->in.args[1].size = entry->d_name.len + 1;
req->in.args[1].value = entry->d_name.name;
ret = create_new_entry(fc, req, dir, entry, S_IFDIR);
if (ret == -EBUSY)
fuse_lsof(dir, entry);
return ret;
}
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_symlink(struct inode *dir, struct dentry *entry,
const char *link)
{
struct fuse_conn *fc = get_fuse_conn(dir);
unsigned len = strlen(link) + 1;
struct fuse_req *req = fuse_get_req_nopages(fc);
if (IS_ERR(req))
return PTR_ERR(req);
req->in.h.opcode = FUSE_SYMLINK;
req->in.numargs = 2;
req->in.args[0].size = entry->d_name.len + 1;
req->in.args[0].value = entry->d_name.name;
req->in.args[1].size = len;
req->in.args[1].value = link;
return create_new_entry(fc, req, dir, entry, S_IFLNK);
}
static int fuse_mkdir(struct _inode *dir, struct dentry *entry, int mode)
{
struct fuse_mkdir_in inarg;
struct fuse_conn *fc = get_fuse_conn(dir);
struct fuse_req *req = fuse_get_req(fc);
if (IS_ERR(req))
return PTR_ERR(req);
memset(&inarg, 0, sizeof(inarg));
inarg.mode = mode;
req->in.h.opcode = FUSE_MKDIR;
req->in.numargs = 2;
req->in.args[0].size = sizeof(inarg);
req->in.args[0].value = &inarg;
req->in.args[1].size = entry->d_name.len + 1;
req->in.args[1].value = entry->d_name.name;
return create_new_entry(fc, req, dir, entry, S_IFDIR);
}
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);
}
static int fuse_mknod(struct inode *dir, struct dentry *entry, int mode,
dev_t rdev)
{
struct fuse_mknod_in inarg;
struct fuse_conn *fc = get_fuse_conn(dir);
struct fuse_req *req = fuse_get_req(fc);
if (IS_ERR(req))
return PTR_ERR(req);
memset(&inarg, 0, sizeof(inarg));
inarg.mode = mode;
inarg.rdev = new_encode_dev(rdev);
req->in.h.opcode = FUSE_MKNOD;
req->in.numargs = 2;
req->in.args[0].size = sizeof(inarg);
req->in.args[0].value = &inarg;
req->in.args[1].size = entry->d_name.len + 1;
req->in.args[1].value = entry->d_name.name;
return create_new_entry(fc, req, dir, entry, mode);
}
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);
if (addendum != NULL)
S_DELETE(addendum, "main", &error);
/* unload plug-ins by deleting them */
if (addendumJSONPlugin != NULL)
S_DELETE(addendumJSONPlugin, "main", &error);
/*
* quit speect
*/
error = speect_quit();
if (error != S_SUCCESS)
{
printf("Call to 'speect_quit' failed\n");
return 1;
}
return 0;
}
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();
}
