static bool_t
syn_apply_pair (struct DATA *d, const char *m, const char *s)
{
#define NOPLAYER -1
bool_t ok = TRUE;
player_t plyr_0 = NOPLAYER; // to silence warnings
player_t plyr_i = NOPLAYER; // to silence warnings
const char *tagstr;
uint32_t taghsh;
tagstr = m;
taghsh = namehash(tagstr);
if (ok && !name_ispresent (d, tagstr, taghsh, &plyr_0)) {
ok = addplayer (d, tagstr, &plyr_0) && name_register(taghsh,plyr_0,plyr_0);
}
tagstr = s;
taghsh = namehash(tagstr);
if (ok && !name_ispresent (d, tagstr, taghsh, &plyr_i)) {
ok = addplayer (d, tagstr, &plyr_i) && name_register(taghsh,plyr_i,plyr_0);
}
return ok;
}
string ServerState::generatePrivateChannelID(ConnectionPtr con, string& title) {
while (true) {
char buf[1024];
bzero(&buf[0], sizeof (buf));
int size = snprintf(&buf[0], sizeof (buf), "%s%s%f%ld", title.c_str(),
con->characterName.c_str(), (float) Server::getEventTime(),
++ServerState::channelSeed);
string namehash(&buf[0], size);
bzero(&buf[0], sizeof (buf));
namehash = thirdparty::SHA1HashString(namehash);
snprintf(&buf[0], sizeof (buf), "%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x",
(unsigned char) namehash[0], (unsigned char) namehash[1],
(unsigned char) namehash[2], (unsigned char) namehash[3],
(unsigned char) namehash[4], (unsigned char) namehash[5],
(unsigned char) namehash[6], (unsigned char) namehash[7],
(unsigned char) namehash[8], (unsigned char) namehash[9]);
namehash = string(&buf[0], 20);
namehash = "ADH-" + namehash;
string lname = namehash;
int nameSize = lname.size();
for (int i = 0; i < nameSize; ++i) {
lname[i] = (char) tolower(lname[i]);
}
Channel* chan = ServerState::getChannel(lname).get();
if (chan == 0) {
return namehash;
}
}
}
static bool_t
name2player (const struct DATA *d, const char *namestr, player_t *plyr)
{
player_t p = 0; // to silence warning
uint32_t hsh = namehash(namestr);
if (name_ispresent (d, namestr, hsh, &p)) {
*plyr = p;
return TRUE;
}
return FALSE;
}
int dcache_lookup(struct inode * dir, const char * name, int len, unsigned long * ino)
{
struct hash_list * hash;
struct dir_cache_entry *de;
if (len > DCACHE_NAME_LEN)
return 0;
hash = hash_table + hash_fn(dir->i_dev, dir->i_ino, namehash(name,len));
de = find_entry(dir, name, len, hash);
if (!de)
return 0;
*ino = de->ino;
move_to_level2(de, hash);
return 1;
}
void dcache_add(struct inode * dir, const char * name, int len, unsigned long ino)
{
struct hash_list * hash;
struct dir_cache_entry *de;
if (len > DCACHE_NAME_LEN)
return;
hash = hash_table + hash_fn(dir->i_dev, dir->i_ino, namehash(name,len));
if ((de = find_entry(dir, name, len, hash)) != NULL) {
de->ino = ino;
update_lru(de);
return;
}
de = level1_head;
level1_head = de->next_lru;
remove_hash(de);
de->dev = dir->i_dev;
de->dir = dir->i_ino;
de->version = dir->i_version;
de->ino = ino;
de->name_len = len;
memcpy(de->name, name, len);
add_hash(de, hash);
}
static bool_t
pgn_result_collect (struct pgn_result *p, struct DATA *d)
{
#define NOPLAYER -1
player_t i;
player_t j;
bool_t ok = TRUE;
player_t plyr = NOPLAYER; // to silence warnings
const char *tagstr;
uint32_t taghsh;
assert(p);
assert(d);
tagstr = p->wtag;
taghsh = namehash(tagstr);
if (ok && !name_ispresent (d, tagstr, taghsh, &plyr)) {
ok = addplayer (d, tagstr, &plyr) && name_register(taghsh,plyr,plyr);
}
i = plyr;
tagstr = p->btag;
taghsh = namehash(tagstr);
if (ok && !name_ispresent (d, tagstr, taghsh, &plyr)) {
ok = addplayer (d, tagstr, &plyr) && name_register(taghsh,plyr,plyr);
}
j = plyr;
ok = ok && (uint64_t)d->n_games < ((uint64_t)MAXGAMESxBLOCK*(uint64_t)MAXBLOCKS);
assert (i != NOPLAYER && j != NOPLAYER);
if (ok) {
struct GAMEBLOCK *g;
size_t idx = d->gb_idx;
size_t blk = d->gb_filled;
d->gb[blk]->white [idx] = i;
d->gb[blk]->black [idx] = j;
d->gb[blk]->score [idx] = p->result;
d->n_games++;
d->gb_idx++;
if (d->gb_idx == MAXGAMESxBLOCK) { // hit new block
d->gb_idx = 0;
d->gb_filled++;
blk = d->gb_filled;
if (NULL == (g = memnew (sizeof(struct GAMEBLOCK) * (size_t)1))) {
d->gb[blk] = NULL;
ok = FALSE; // failed
} else {
d->gb[blk] = g;
d->gb_allocated++;
ok = TRUE;
}
}
}
return ok;
}
