static void routing_policy_rule_hash_func(const void *b, struct siphash *state) { const RoutingPolicyRule *rule = b; assert(rule); siphash24_compress(&rule->family, sizeof(rule->family), state); switch (rule->family) { case AF_INET: case AF_INET6: siphash24_compress(&rule->from, FAMILY_ADDRESS_SIZE(rule->family), state); siphash24_compress(&rule->from_prefixlen, sizeof(rule->from_prefixlen), state); siphash24_compress(&rule->to, FAMILY_ADDRESS_SIZE(rule->family), state); siphash24_compress(&rule->to_prefixlen, sizeof(rule->to_prefixlen), state); siphash24_compress(&rule->tos, sizeof(rule->tos), state); siphash24_compress(&rule->fwmark, sizeof(rule->fwmark), state); siphash24_compress(&rule->table, sizeof(rule->table), state); if (rule->iif) siphash24_compress(&rule->iif, strlen(rule->iif), state); if (rule->oif) siphash24_compress(&rule->oif, strlen(rule->oif), state); break; default: /* treat any other address family as AF_UNSPEC */ break; } }
static void dns_server_hash_func(const void *p, struct siphash *state) { const DnsServer *s = p; assert(s); siphash24_compress(&s->family, sizeof(s->family), state); siphash24_compress(&s->address, FAMILY_ADDRESS_SIZE(s->family), state); }
static void etc_hosts_item_hash_func(const void *p, struct siphash *state) { const EtcHostsItem *item = p; siphash24_compress(&item->family, sizeof(item->family), state); if (item->family == AF_INET) siphash24_compress(&item->address.in, sizeof(item->address.in), state); else if (item->family == AF_INET6) siphash24_compress(&item->address.in6, sizeof(item->address.in6), state); }
static int do_test(const uint8_t *in, size_t len, const uint8_t *key) { struct siphash state = {}; uint64_t out = 0; unsigned i, j; out = siphash24(in, len, key); assert_se(out == 0xa129ca6149be45e5); /* verify the internal state as given in the above paper */ siphash24_init(&state, key); assert_se(state.v0 == 0x7469686173716475); assert_se(state.v1 == 0x6b617f6d656e6665); assert_se(state.v2 == 0x6b7f62616d677361); assert_se(state.v3 == 0x7b6b696e727e6c7b); siphash24_compress(in, len, &state); assert_se(state.v0 == 0x4a017198de0a59e0); assert_se(state.v1 == 0x0d52f6f62a4f59a4); assert_se(state.v2 == 0x634cb3577b01fd3d); assert_se(state.v3 == 0xa5224d6f55c7d9c8); out = siphash24_finalize(&state); assert_se(out == 0xa129ca6149be45e5); assert_se(state.v0 == 0xf6bcd53893fecff1); assert_se(state.v1 == 0x54b9964c7ea0d937); assert_se(state.v2 == 0x1b38329c099bb55a); assert_se(state.v3 == 0x1814bb89ad7be679); /* verify that decomposing the input in three chunks gives the same result */ for (i = 0; i < len; i++) { for (j = i; j < len; j++) { siphash24_init(&state, key); siphash24_compress(in, i, &state); siphash24_compress(&in[i], j - i, &state); siphash24_compress(&in[j], len - j, &state); out = siphash24_finalize(&state); assert_se(out == 0xa129ca6149be45e5); } } return 0; }
void path_hash_func(const void *p, struct siphash *state) { const char *q = p; size_t n; assert(q); assert(state); /* Calculates a hash for a path in a way this duplicate inner slashes don't make a differences, and also * whether there's a trailing slash or not. This fits well with the semantics of path_compare(), which does * similar checks and also doesn't care for trailing slashes. Note that relative and absolute paths (i.e. those * which begin in a slash or not) will hash differently though. */ n = strspn(q, "/"); if (n > 0) { /* Eat up initial slashes, and add one "/" to the hash for all of them */ siphash24_compress(q, 1, state); q += n; } for (;;) { /* Determine length of next component */ n = strcspn(q, "/"); if (n == 0) /* Reached the end? */ break; /* Add this component to the hash and skip over it */ siphash24_compress(q, n, state); q += n; /* How many slashes follow this component? */ n = strspn(q, "/"); if (q[n] == 0) /* Is this a trailing slash? If so, we are at the end, and don't care about the slashes anymore */ break; /* We are not add the end yet. Hash exactly one slash for all of the ones we just encountered. */ siphash24_compress(q, 1, state); q += n; } }
static void route_hash_func(const void *b, struct siphash *state) { const Route *route = b; assert(route); siphash24_compress(&route->family, sizeof(route->family), state); switch (route->family) { case AF_INET: case AF_INET6: /* Equality of routes are given by the 4-touple (dst_prefix,dst_prefixlen,tos,priority,table) */ siphash24_compress(&route->dst, FAMILY_ADDRESS_SIZE(route->family), state); siphash24_compress(&route->dst_prefixlen, sizeof(route->dst_prefixlen), state); siphash24_compress(&route->tos, sizeof(route->tos), state); siphash24_compress(&route->priority, sizeof(route->priority), state); siphash24_compress(&route->table, sizeof(route->table), state); break; default: /* treat any other address family as AF_UNSPEC */ break; } }
void devt_hash_func(const void *p, struct siphash *state) { siphash24_compress(p, sizeof(dev_t), state); }
void uint64_hash_func(const void *p, struct siphash *state) { siphash24_compress(p, sizeof(uint64_t), state); }
void trivial_hash_func(const void *p, struct siphash *state) { siphash24_compress(&p, sizeof(p), state); }
void string_hash_func(const void *p, struct siphash *state) { siphash24_compress(p, strlen(p) + 1, state); }
static void network_config_hash_func(const NetworkConfigSection *c, struct siphash *state) { siphash24_compress(c->filename, strlen(c->filename), state); siphash24_compress(&c->line, sizeof(c->line), state); }
static void catalog_hash_func(const void *p, struct siphash *state) { const CatalogItem *i = p; siphash24_compress(&i->id, sizeof(i->id), state); siphash24_compress(i->language, strlen(i->language), state); }
static void ndisc_rdnss_hash_func(const void *p, struct siphash *state) { const NDiscRDNSS *x = p; siphash24_compress(&x->address, sizeof(x->address), state); }
void id128_hash_func(const void *p, struct siphash *state) { siphash24_compress(p, 16, state); }