static inline void addword(const char* s) {
int hash_pos = hashword(s) % HASHMAP_CAPACITY;
int i;
int min_count;
hashmap_element_t* backup_data;
while(hashmap_data[hash_pos].m_count > 0 && cmpword(hashmap_data[hash_pos].m_word, s) != 0) {
hash_pos = (hash_pos + 1) % HASHMAP_CAPACITY;
}
if(hashmap_data[hash_pos].m_count > 0) { /* word existed */
hashmap_data[hash_pos].m_count += 1;
return;
}
/* add a new word */
copyword(hashmap_data[hash_pos].m_word, s);
hashmap_size += 1;
hashmap_data[hash_pos].m_count = 1;
/* remove less used words when hashmap is full */
if(hashmap_size == HASHMAP_MAXSIZE) {
backup_data = malloc(HASHMAP_MAXSIZE * sizeof(hashmap_element_t));
min_count = INT_MAX;
for(i = 0; i < HASHMAP_CAPACITY; i++) {
if(hashmap_data[i].m_count > 0) {
if(hashmap_data[i].m_count < min_count) {
min_count = hashmap_data[i].m_count;
}
strcpy(backup_data[hashmap_size - 1].m_word, hashmap_data[i].m_word);
backup_data[hashmap_size - 1].m_count = hashmap_data[i].m_count;
hashmap_size -= 1;
}
hashmap_data[i].m_count = 0;
}
for(i = 0; i < HASHMAP_MAXSIZE; i++) {
if(backup_data[i].m_count > min_count + 5) { /* regard words with (count <= min_count + 5) as "less used" */
hash_pos = hashword(backup_data[i].m_word) % HASHMAP_CAPACITY;
while(hashmap_data[hash_pos].m_count > 0 && cmpword(hashmap_data[hash_pos].m_word, backup_data[i].m_word) != 0) {
hash_pos = (hash_pos + 1) % HASHMAP_CAPACITY;
}
strcpy(hashmap_data[hash_pos].m_word, backup_data[i].m_word);
hashmap_data[hash_pos].m_count = backup_data[i].m_count;
hashmap_size += 1;
}
}
free(backup_data);
}
return;
}
/* calculate the hash key for this packet
*
* we're using:
* hash_rand -- set at init time
* source address
* destination address
* id
* vlan_id
*/
static inline uint32_t DefragHashGetKey(Packet *p)
{
uint32_t key;
if (p->ip4h != NULL) {
DefragHashKey4 dhk;
if (p->src.addr_data32[0] > p->dst.addr_data32[0]) {
dhk.src = p->src.addr_data32[0];
dhk.dst = p->dst.addr_data32[0];
} else {
dhk.src = p->dst.addr_data32[0];
dhk.dst = p->src.addr_data32[0];
}
dhk.id = (uint32_t)IPV4_GET_IPID(p);
dhk.vlan_id[0] = p->vlan_id[0];
dhk.vlan_id[1] = p->vlan_id[1];
uint32_t hash = hashword(dhk.u32, 4, defrag_config.hash_rand);
key = hash % defrag_config.hash_size;
} else if (p->ip6h != NULL) {
DefragHashKey6 dhk;
if (DefragHashRawAddressIPv6GtU32(p->src.addr_data32, p->dst.addr_data32)) {
dhk.src[0] = p->src.addr_data32[0];
dhk.src[1] = p->src.addr_data32[1];
dhk.src[2] = p->src.addr_data32[2];
dhk.src[3] = p->src.addr_data32[3];
dhk.dst[0] = p->dst.addr_data32[0];
dhk.dst[1] = p->dst.addr_data32[1];
dhk.dst[2] = p->dst.addr_data32[2];
dhk.dst[3] = p->dst.addr_data32[3];
} else {
dhk.src[0] = p->dst.addr_data32[0];
dhk.src[1] = p->dst.addr_data32[1];
dhk.src[2] = p->dst.addr_data32[2];
dhk.src[3] = p->dst.addr_data32[3];
dhk.dst[0] = p->src.addr_data32[0];
dhk.dst[1] = p->src.addr_data32[1];
dhk.dst[2] = p->src.addr_data32[2];
dhk.dst[3] = p->src.addr_data32[3];
}
dhk.id = IPV6_EXTHDR_GET_FH_ID(p);
dhk.vlan_id[0] = p->vlan_id[0];
dhk.vlan_id[1] = p->vlan_id[1];
uint32_t hash = hashword(dhk.u32, 10, defrag_config.hash_rand);
key = hash % defrag_config.hash_size;
} else
key = 0;
return key;
}
/* calculate the hash key for this packet
*
* we're using:
* hash_rand -- set at init time
* source address
*/
uint32_t HostGetKey(Address *a) {
uint32_t key;
if (a->family == AF_INET) {
uint32_t hash = hashword(&a->addr_data32[0], 1, host_config.hash_rand);
key = hash % host_config.hash_size;
} else if (a->family == AF_INET6) {
uint32_t hash = hashword(a->addr_data32, 4, host_config.hash_rand);
key = hash % host_config.hash_size;
} else
key = 0;
return key;
}
void
fsd_color( char *output, size_t len, int n )
{
uint32_t k = n;
k = hashword( &k, 1, 0 );
k %= 12;
snprintf( output, len, "\033[0;%d;%dm", k>=6, 31+k%6 );
}
/* calculate the hash key for this packet
*
* we're using:
* hash_rand -- set at init time
* source address
*/
static uint32_t IPPairGetKey(Address *a, Address *b)
{
uint32_t key;
if (a->family == AF_INET) {
uint32_t addrs[2] = { MIN(a->addr_data32[0], b->addr_data32[0]),
MAX(a->addr_data32[0], b->addr_data32[0]) };
uint32_t hash = hashword(addrs, 2, ippair_config.hash_rand);
key = hash % ippair_config.hash_size;
} else if (a->family == AF_INET6) {
uint32_t addrs[8];
if (IPPairHashRawAddressIPv6GtU32(&a->addr_data32[0],&b->addr_data32[0])) {
addrs[0] = b->addr_data32[0];
addrs[1] = b->addr_data32[1];
addrs[2] = b->addr_data32[2];
addrs[3] = b->addr_data32[3];
addrs[4] = a->addr_data32[0];
addrs[5] = a->addr_data32[1];
addrs[6] = a->addr_data32[2];
addrs[7] = a->addr_data32[3];
} else {
addrs[0] = a->addr_data32[0];
addrs[1] = a->addr_data32[1];
addrs[2] = a->addr_data32[2];
addrs[3] = a->addr_data32[3];
addrs[4] = b->addr_data32[0];
addrs[5] = b->addr_data32[1];
addrs[6] = b->addr_data32[2];
addrs[7] = b->addr_data32[3];
}
uint32_t hash = hashword(addrs, 8, ippair_config.hash_rand);
key = hash % ippair_config.hash_size;
} else
key = 0;
return key;
}
/* Calculate the hash of the 5 tuples of a packet */
uint32_t
pkt_tuple_hash(packet_tuple_t *tuple)
{
int hash = 0;
int len = 0;
int port = tuple->src_port;
uint32_t *tuples = NULL;
port = port + ((int)tuple->dst_port << 16);
switch (lisp_addr_ip_afi(&tuple->src_addr)){
case AF_INET:
/* 1 integer src_addr
* + 1 integer dst_adr
* + 1 integer (ports)
* + 1 integer protocol
* + 1 iid*/
len = 5;
tuples = xmalloc(len * sizeof(uint32_t));
lisp_addr_copy_to(&tuples[0], &tuple->src_addr);
lisp_addr_copy_to(&tuples[1], &tuple->dst_addr);
tuples[2] = port;
tuples[3] = tuple->protocol;
tuples[4] = tuple->iid;
break;
case AF_INET6:
/* 4 integer src_addr
* + 4 integer dst_adr
* + 1 integer (ports)
* + 1 integer protocol
* + 1 iid */
len = 11;
tuples = xmalloc(len * sizeof(uint32_t));
lisp_addr_copy_to(&tuples[0], &tuple->src_addr);
lisp_addr_copy_to(&tuples[4], &tuple->dst_addr);
tuples[8] = port;
tuples[9] = tuple->protocol;
tuples[10] = tuple->iid;
break;
}
/* XXX: why 2013 used as initial value? */
hash = hashword(tuples, len, 2013);
free(tuples);
return (hash);
}
static int sh_write(const char *path, char *buf, size_t size, off_t offset,
struct fuse_file_info *fi) {
struct user* user = find_user(root, path+1);
char uname[9];
printf("write\n");
if(user != NULL || strcmp(path, "/") == 0)
return -ENOENT;
int i = user_from_path(path, uname);
user = find_user(root, uname);
i+=2;
if(user == NULL)
return -ENOENT;
if(strcmp(path+i, "password-hash") == 0) {
char *hashed;
hashed = hashword(buf);
update_hash(root, uname, hashed);
update_daysSinceChanged(root, uname, shadow_time());
}
else if(strcmp(path+i, "days_since_changed") == 0) {
update_daysSinceChanged(root, uname, atoi(buf));
}
else if(strcmp(path+i, "days_until_can_change") == 0) {
update_daysUntilCanChange(root, uname, atoi(buf));
}
else if(strcmp(path+i, "days_until_must_change") == 0) {
update_daysUntilMustChange(root, uname, atoi(buf));
}
else if(strcmp(path+i, "days_before_warning") == 0) {
update_daysBeforeWarning(root, uname, atoi(buf));
}
else if(strcmp(path+i, "days_until_expiration") == 0) {
update_daysUntilExpiration(root, uname, atoi(buf));
}
else if(strcmp(path+i, "days_since_account_deactivated") == 0) {
update_daysSinceDeactivation(root, uname, atoi(buf));
}
else if(strcmp(path+i, "reserved") == 0) {
update_reserved(root, uname, buf);
}
return size;
}
/**
* This needs a to match compare.
*
* @return size_t
*/
size_t sockAddrBase::hash() const
{
/**
* Invalid always hashes to a constant ... 0 seems as good as any?
*/
if (!IsValid())
return 0;
else if (IsIPv4())
{
// May not be the 'best' hash, but it should work. We add DNSP_HASHINIT
// So that address 0.0.0.0 does not collide with !IsValid().
if (!m_allowPort)
return getIPv4Storage()->sin_addr.s_addr + DNSP_HASHINIT;
else
{
const sockaddr_in *storage = getIPv4Storage();
return hashlittle(&storage->sin_port, sizeof(storage->sin_port), storage->sin_addr.s_addr + DNSP_HASHINIT);
}
}
else
{
const sockaddr_in6 *storage = getIPv6Storage();
// Below is to make sure that we can use hashword. This should never fail, but
// without the 'if' some compilers issue a warning.
if (!LogVerify((sizeof(in6_addr) % 4) == 0))
return 0;
// May not be the 'best' hash, but it should work.
uint32_t port = m_allowPort ? storage->sin6_port : 0;
uint32_t hash = hashword(reinterpret_cast<const uint32_t *>(&storage->sin6_addr),
sizeof(in6_addr) / 4, DNSP_HASHINIT + port);
return (hash + storage->sin6_scope_id + storage->sin6_flowinfo);
}
}
static int read_pages(struct ksm_pages *kp, pm_map_t **maps, size_t num_maps, uint8_t pr_flags) {
size_t i, j, k;
size_t len;
uint64_t *pagemap;
size_t map_len;
uint64_t flags;
pm_kernel_t *ker;
int error;
unsigned long vaddr;
int fd;
off_t off;
char filename[MAX_FILENAME];
uint32_t *data;
uint32_t hash;
int rc = 0;
struct ksm_page *cur_page;
pid_t pid;
if (num_maps == 0)
return 0;
pid = pm_process_pid(maps[0]->proc);
ker = maps[0]->proc->ker;
error = snprintf(filename, MAX_FILENAME, "/proc/%d/mem", pid);
if (error < 0 || error >= MAX_FILENAME) {
return -1;
}
data = malloc(pm_kernel_pagesize(ker));
if (data == NULL) {
fprintf(stderr, "warning: not enough memory to malloc data buffer\n");
return -1;
}
fd = open(filename, O_RDONLY);
if (fd < 0) {
fprintf(stderr, "warning: could not open %s\n", filename);
rc = -1;
goto err_open;
}
for (i = 0; i < num_maps; i++) {
error = pm_map_pagemap(maps[i], &pagemap, &map_len);
if (error) {
fprintf(stderr, "warning: could not read the pagemap of %d\n",
pm_process_pid(maps[i]->proc));
continue;
}
for (j = 0; j < map_len; j++) {
error = pm_kernel_flags(ker, PM_PAGEMAP_PFN(pagemap[j]), &flags);
if (error) {
fprintf(stderr, "warning: could not read flags for pfn at address 0x%016" PRIx64 "\n",
pagemap[i]);
continue;
}
if (!(flags & PM_PAGE_KSM)) {
continue;
}
vaddr = pm_map_start(maps[i]) + j * pm_kernel_pagesize(ker);
off = lseek(fd, vaddr, SEEK_SET);
if (off == (off_t)-1) {
fprintf(stderr, "warning: could not lseek to 0x%08lx\n", vaddr);
continue;
}
len = read(fd, data, pm_kernel_pagesize(ker));
if (len != pm_kernel_pagesize(ker)) {
fprintf(stderr, "warning: could not read page at 0x%08lx\n", vaddr);
continue;
}
hash = hashword(data, pm_kernel_pagesize(ker) / sizeof(*data), 17);
for (k = 0; k < kp->len; k++) {
if (kp->pages[k].hash == hash) break;
}
if (k == kp->len) {
if (kp->len == kp->size) {
struct ksm_page *tmp = realloc(kp->pages,
(kp->size + GROWTH_FACTOR) * sizeof(*kp->pages));
if (tmp == NULL) {
fprintf(stderr, "warning: not enough memory to realloc pages struct\n");
free(pagemap);
rc = -1;
goto err_realloc;
}
memset(&tmp[k], 0, sizeof(tmp[k]) * GROWTH_FACTOR);
kp->pages = tmp;
kp->size += GROWTH_FACTOR;
}
rc = pm_kernel_count(ker, PM_PAGEMAP_PFN(pagemap[j]), &kp->pages[kp->len].count);
if (rc) {
fprintf(stderr, "error reading page count\n");
free(pagemap);
goto err_count;
}
kp->pages[kp->len].hash = hash;
kp->pages[kp->len].pattern =
is_pattern((uint8_t *)data, pm_kernel_pagesize(ker)) ?
(data[0] & 0xFF) : NO_PATTERN;
kp->len++;
}
cur_page = &kp->pages[k];
if (pr_flags & PR_VERBOSE) {
if (cur_page->vaddr_len > 0 &&
cur_page->vaddr[cur_page->vaddr_len - 1].pid == pid &&
cur_page->vaddr[cur_page->vaddr_len - 1].addr ==
vaddr - (cur_page->vaddr[cur_page->vaddr_len - 1].num_pages *
pm_kernel_pagesize(ker))) {
cur_page->vaddr[cur_page->vaddr_len - 1].num_pages++;
} else {
if (cur_page->vaddr_len == cur_page->vaddr_size) {
struct vaddr *tmp = realloc(cur_page->vaddr,
(cur_page->vaddr_size + GROWTH_FACTOR) * sizeof(*(cur_page->vaddr)));
if (tmp == NULL) {
fprintf(stderr, "warning: not enough memory to realloc vaddr array\n");
free(pagemap);
rc = -1;
goto err_realloc;
}
memset(&tmp[cur_page->vaddr_len], 0, sizeof(tmp[cur_page->vaddr_len]) * GROWTH_FACTOR);
cur_page->vaddr = tmp;
cur_page->vaddr_size += GROWTH_FACTOR;
}
cur_page->vaddr[cur_page->vaddr_len].addr = vaddr;
cur_page->vaddr[cur_page->vaddr_len].num_pages = 1;
cur_page->vaddr[cur_page->vaddr_len].pid = pid;
cur_page->vaddr_len++;
}
}
cur_page->vaddr_count++;
}
free(pagemap);
}
goto no_err;
err_realloc:
err_count:
if (pr_flags & PR_VERBOSE) {
for (i = 0; i < kp->len; i++) {
free(kp->pages[i].vaddr);
}
}
free(kp->pages);
no_err:
close(fd);
err_open:
free(data);
return rc;
}
/* calculate the hash key for this packet
*
* we're using:
* hash_rand -- set at init time
* source port
* destination port
* source address
* destination address
* recursion level -- for tunnels, make sure different tunnel layers can
* never get mixed up.
*
* For ICMP we only consider UNREACHABLE errors atm.
*/
static inline uint32_t FlowGetKey(const Packet *p)
{
uint32_t key;
if (p->ip4h != NULL) {
if (p->tcph != NULL || p->udph != NULL) {
FlowHashKey4 fhk;
if (p->src.addr_data32[0] > p->dst.addr_data32[0]) {
fhk.src = p->src.addr_data32[0];
fhk.dst = p->dst.addr_data32[0];
} else {
fhk.src = p->dst.addr_data32[0];
fhk.dst = p->src.addr_data32[0];
}
if (p->sp > p->dp) {
fhk.sp = p->sp;
fhk.dp = p->dp;
} else {
fhk.sp = p->dp;
fhk.dp = p->sp;
}
fhk.proto = (uint16_t)p->proto;
fhk.recur = (uint16_t)p->recursion_level;
fhk.vlan_id[0] = p->vlan_id[0];
fhk.vlan_id[1] = p->vlan_id[1];
uint32_t hash = hashword(fhk.u32, 5, flow_config.hash_rand);
key = hash % flow_config.hash_size;
} else if (ICMPV4_DEST_UNREACH_IS_VALID(p)) {
uint32_t psrc = IPV4_GET_RAW_IPSRC_U32(ICMPV4_GET_EMB_IPV4(p));
uint32_t pdst = IPV4_GET_RAW_IPDST_U32(ICMPV4_GET_EMB_IPV4(p));
FlowHashKey4 fhk;
if (psrc > pdst) {
fhk.src = psrc;
fhk.dst = pdst;
} else {
fhk.src = pdst;
fhk.dst = psrc;
}
if (p->icmpv4vars.emb_sport > p->icmpv4vars.emb_dport) {
fhk.sp = p->icmpv4vars.emb_sport;
fhk.dp = p->icmpv4vars.emb_dport;
} else {
fhk.sp = p->icmpv4vars.emb_dport;
fhk.dp = p->icmpv4vars.emb_sport;
}
fhk.proto = (uint16_t)ICMPV4_GET_EMB_PROTO(p);
fhk.recur = (uint16_t)p->recursion_level;
fhk.vlan_id[0] = p->vlan_id[0];
fhk.vlan_id[1] = p->vlan_id[1];
uint32_t hash = hashword(fhk.u32, 5, flow_config.hash_rand);
key = hash % flow_config.hash_size;
} else {
FlowHashKey4 fhk;
if (p->src.addr_data32[0] > p->dst.addr_data32[0]) {
fhk.src = p->src.addr_data32[0];
fhk.dst = p->dst.addr_data32[0];
} else {
fhk.src = p->dst.addr_data32[0];
fhk.dst = p->src.addr_data32[0];
}
fhk.sp = 0xfeed;
fhk.dp = 0xbeef;
fhk.proto = (uint16_t)p->proto;
fhk.recur = (uint16_t)p->recursion_level;
fhk.vlan_id[0] = p->vlan_id[0];
fhk.vlan_id[1] = p->vlan_id[1];
uint32_t hash = hashword(fhk.u32, 5, flow_config.hash_rand);
key = hash % flow_config.hash_size;
}
} else if (p->ip6h != NULL) {
FlowHashKey6 fhk;
if (FlowHashRawAddressIPv6GtU32(p->src.addr_data32, p->dst.addr_data32)) {
fhk.src[0] = p->src.addr_data32[0];
fhk.src[1] = p->src.addr_data32[1];
fhk.src[2] = p->src.addr_data32[2];
fhk.src[3] = p->src.addr_data32[3];
fhk.dst[0] = p->dst.addr_data32[0];
fhk.dst[1] = p->dst.addr_data32[1];
fhk.dst[2] = p->dst.addr_data32[2];
fhk.dst[3] = p->dst.addr_data32[3];
} else {
fhk.src[0] = p->dst.addr_data32[0];
fhk.src[1] = p->dst.addr_data32[1];
fhk.src[2] = p->dst.addr_data32[2];
fhk.src[3] = p->dst.addr_data32[3];
fhk.dst[0] = p->src.addr_data32[0];
fhk.dst[1] = p->src.addr_data32[1];
fhk.dst[2] = p->src.addr_data32[2];
fhk.dst[3] = p->src.addr_data32[3];
}
if (p->sp > p->dp) {
fhk.sp = p->sp;
fhk.dp = p->dp;
} else {
fhk.sp = p->dp;
fhk.dp = p->sp;
}
fhk.proto = (uint16_t)p->proto;
fhk.recur = (uint16_t)p->recursion_level;
fhk.vlan_id[0] = p->vlan_id[0];
fhk.vlan_id[1] = p->vlan_id[1];
uint32_t hash = hashword(fhk.u32, 11, flow_config.hash_rand);
key = hash % flow_config.hash_size;
} else
key = 0;
return key;
}
uint32_t hash2(het_t *val) {
return (uint32_t)hashword(&(val->key),1,0x3243F6A9UL);
}
uint32_t hash1(het_t *val) {
return (uint32_t)hashword(&(val->key),1,0x2B7E1516UL);
}
