hashval
unsigned int hashval;
hashval = (unsigned char)*p << 4;
hashval+= *p++;
return (hashval % ATABSIZE);
unsigned int hashval;
hashval = (unsigned char)*p << 4;
hashval += *p++;
return (hashval % CMDTABLESIZE);
unsigned int hashval;
hashval = 0;
hashval = 2 * hashval + (unsigned char)*p++;
vpp = &vartab[hashval % VTABSIZE];
krb5_data ds = empty_data(), hashval = empty_data();
ret = alloc_data(&hashval, ctp->hash->hashsize);
ret = ctp->hash->hash(hash_iov, num_data + 1, &hashval);
iov.data = hashval;
zapfree(hashval.data, hashval.length);
uint64_t hashval;
hashval = k5_siphash24(data, 4, seed);
store_64_be(hashval, tag);
unsigned long hashval = 0;
memcpy(&hashval, digest, sizeof(hashval) < sizeof(digest) ? sizeof(hashval) : sizeof(digest));
return hashval;
const unsigned char *hashval,
if (hashval == NULL) {
hashval = hashvaltmp;
|| !ssl3_finish_mac(s, hashval, hashlen)) {
const unsigned char *hashval,
unsigned char hashval[EVP_MAX_MD_SIZE];
unsigned char *hash = hashval;
|| !EVP_DigestFinal_ex(mdctx, hashval, &hashlenui)) {
hashval, hashlen,
|| !ssl_handshake_hash(s, hashval, sizeof(hashval), &hashlen)) {
hashval, hashlen, s->resumption_master_secret,
uint32_t hashval, num_entries;
hashval = dl->dl_hashval;
hashval = db->db_hashfunc(key)%num_entries;
hashval * _CITRUS_DB_ENTRY_SIZE;
dl->dl_hashval = hashval;
if (be32toh(dex->dex_hash_value) != hashval)
#define _CITRUS_HASH_INSERT(head, elm, field, hashval) \
LIST_INSERT_HEAD(&(head)->chh_table[hashval], elm, field)
#define _CITRUS_HASH_SEARCH(head, elm, field, matchfunc, key, hashval) \
LIST_FOREACH((elm), &(head)->chh_table[hashval], field) \
int hashval, ret = 0;
hashval = hash_func(convname);
convname, hashval);
_CITRUS_HASH_INSERT(&shared_pool, ci, ci_hash_entry, hashval);
int hashval, ret;
hashval = hash_func(mapname);
hashval);
_CITRUS_HASH_INSERT(&ma->ma_cache, cm, cm_entry, hashval);
const Elf32_Word *hashval;
hashval = &obj->chain_zero_gnu[obj->buckets_gnu[bkt]];
while ((*hashval++ & 1u) == 0);
const Elf32_Word *hashval;
hashval = &obj->chain_zero_gnu[bucket];
if (((*hashval ^ req->hash_gnu) >> 1) == 0) {
symnum = hashval - obj->chain_zero_gnu;
} while ((*hashval++ & 1) == 0);
uint32_t hashtype, hashval;
hashval = htobe32(*(uint32_t *)
hashval = htobe32(*(uint32_t *)
mbuf->m_pkthdr.flowid = hashval;
uint32_t hashval;
hashval = hash32_buf(&fhp->fh_fid, sizeof(struct fid), 0);
return (hashval);
uint32_t hashval;
hashval = hash32_buf(sessionid, NFSX_V4SESSIONID, 0);
return (hashval);
uint32_t hashval;
hashval = fnv_32_str(vfc->vfc_name, FNV1_32_INIT);
hashval &= 0xff;
if (hashval == tvfc->vfc_typenum) {
if (hashval == 255 && secondpass == 0) {
hashval = 1;
hashval++;
vfc->vfc_typenum = hashval;
uint32_t *hashval, uint32_t *hashtype)
*hashval = hash;
*hashval = hash;
*hashval = hash;
rss_mbuf_software_hash_v4(const struct mbuf *m, int dir, uint32_t *hashval,
hashval,
hashval,
hashval,
uint32_t *hashval, uint32_t *hashtype);
int proto, uint32_t *hashval,
uint32_t hashval; /* hash value */
uint32_t *hashval, uint32_t *hashtype)
*hashval = hash;
*hashval = hash;
*hashval = hash;
rss_mbuf_software_hash_v6(const struct mbuf *m, int dir, uint32_t *hashval,
hashval,
hashval,
hashval,
uint32_t *hashval, uint32_t *hashtype);
u_short dst_port, int proto, uint32_t *hashval,
bucket = DYN_BUCKET(info->hashval, V_curr_dyn_buckets);
uint32_t ruleid, uint32_t rulenum, uint32_t hashval)
bucket = DYN_BUCKET(hashval, V_curr_dyn_buckets);
bucket = DYN_BUCKET(info->hashval, V_curr_dyn_buckets);
const void *rule, uint32_t ruleid, uint32_t rulenum, uint32_t hashval)
bucket = DYN_BUCKET(hashval, V_curr_dyn_buckets);
uint32_t hashval; /* hash value used for hash resize */
info->hashval = hash_packet(&args->f_id);
uint32_t hashval)
limit->hashval = hashval;
uint32_t hashval, uint16_t fibnum)
data->hashval = hashval;
const struct ipfw_flow_id *pkt, uint32_t hashval, uint32_t version,
bucket = DYN_BUCKET(hashval, V_curr_dyn_buckets);
limit = dyn_alloc_parent(rule, ruleid, rulenum, hashval);
uint32_t hashval; /* hash value used for hash resize */
uint32_t hashval, struct ipfw_dyn_info *info, uint16_t fibnum,
bucket = DYN_BUCKET(hashval, V_curr_dyn_buckets);
info->hashval != hashval ||
pktlen, hashval, fibnum);
const struct ipfw_flow_id *pkt, uint32_t zoneid, uint32_t hashval,
bucket = DYN_BUCKET(hashval, V_curr_dyn_buckets);
limit = dyn_alloc_parent(rule, ruleid, rulenum, hashval);
int pktlen, uint32_t hashval, struct ipfw_dyn_info *info,
bucket = DYN_BUCKET(hashval, V_curr_dyn_buckets);
info->hashval != hashval ||
pktlen, hashval, fibnum);
struct ip_fw *rule, uint32_t hashval, uint32_t limit, uint32_t kidx)
bucket = DYN_BUCKET(hashval, V_curr_dyn_buckets);
rule->rulenum, pkt, hashval, version, kidx);
rule->rulenum, pkt, zoneid, hashval, version,
uint32_t hashval, parent_hashval, ruleid, rulenum;
hashval = hash_packet(pkt);
ulp, pktlen, hashval, info, fibnum, kidx, type);
zoneid, ulp, pktlen, hashval, info, fibnum, kidx, type);
DYN_RELINK_STATES(s4, data->hashval, bucket, ipv4, ipv4);
DYN_RELINK_STATES(s4, limit->hashval, bucket, ipv4_parent,
DYN_RELINK_STATES(s6, data->hashval, bucket, ipv6, ipv6);
DYN_RELINK_STATES(s6, limit->hashval, bucket, ipv6_parent,
dst->hashval = p->hashval;
dst->hashval = data->hashval;
uint32_t hashval; /* hash value */
long hashval = 0;
hashval = (hashval << 1) + *cp++;
i = hashval % NBUCKETS;
if (hp->hval == hashval) {
hp->hval = hashval;
static int hashval(char *p, int len);
hv = hashval((char *)&((struct sockaddr_in *)&ss)->sin_addr,
hv = hashval((char *)&((struct sockaddr_in6 *)&ss)->sin6_addr,
hv = hashval((char *)&pid, sizeof(pid));