// ===========================================================================
// method definitions
// ===========================================================================
void
AGHousehold::generatePeople() {
AGDataAndStatistics* ds = &(myCity->statData);
//the first adult
AGAdult pers(ds->getRandomPopDistributed(ds->limitAgeChildren, ds->limitEndAge));
adults.push_back(pers);
//the second adult
if (decisionProba(ds->secondPersProb)) {
if (pers.getAge() < ds->limitAgeRetirement) {
AGAdult pers2(ds->getRandomPopDistributed(ds->limitAgeChildren, ds->limitAgeRetirement));
adults.push_back(pers2);
} else {
AGAdult pers2(ds->getRandomPopDistributed(ds->limitAgeRetirement, ds->limitEndAge));
adults.push_back(pers2);
}
}
//Children
if (pers.getAge() < ds->limitAgeRetirement) {
int numChild = ds->getPoissonsNumberOfChildren(ds->meanNbrChildren);
while (numChild > 0) {
AGChild chl(ds->getRandomPopDistributed(0, ds->limitAgeChildren));
children.push_back(chl);
--numChild;
}
}
}
// ===========================================================================
// method definitions
// ===========================================================================
void
AGHousehold::generatePeople(int numAdults, int numChilds, bool firstRetired) {
AGDataAndStatistics* ds = &(myCity->statData);
//the first adult
AGAdult pers(ds->getRandomPopDistributed(ds->limitAgeChildren, ds->limitEndAge));
if (firstRetired) {
pers = AGAdult(ds->getRandomPopDistributed(ds->limitAgeRetirement, ds->limitEndAge));
}
myAdults.push_back(pers);
//further adults
while (static_cast<int>(myAdults.size()) < numAdults) {
if (firstRetired) {
AGAdult pers2(ds->getRandomPopDistributed(ds->limitAgeRetirement, ds->limitEndAge));
myAdults.push_back(pers2);
} else {
AGAdult pers2(ds->getRandomPopDistributed(ds->limitAgeChildren, ds->limitAgeRetirement));
myAdults.push_back(pers2);
}
}
//Children
while (static_cast<int>(myChildren.size()) < numChilds) {
AGChild chl(ds->getRandomPopDistributed(0, ds->limitAgeChildren));
myChildren.push_back(chl);
}
}
const FileHeader&
FileFilterFrameWithHeader<FileStream,FileData,FileHeader>::backHeader()
const throw(gpstk::InvalidRequest)
{
try { chl("backHeader"); }
catch(gpstk::InvalidRequest exc)
{ GPSTK_RETHROW(exc); }
return headerList.back();
}
FileHeader&
FileFilterFrameWithHeader<FileStream,FileData,FileHeader>::frontHeader()
throw(gpstk::InvalidRequest)
{
try { chl("frontHeader"); }
catch(gpstk::InvalidRequest exc)
{ GPSTK_RETHROW(exc); }
return headerList.front();
}
typename std::list<FileHeader>::iterator
FileFilterFrameWithHeader<FileStream,FileData,FileHeader>::endHeader()
throw(gpstk::InvalidRequest)
{
try { chl("endHeader"); }
catch(gpstk::InvalidRequest exc)
{ GPSTK_RETHROW(exc); }
return headerList.end();
}
typename std::list<FileHeader>::const_iterator
FileFilterFrameWithHeader<FileStream,FileData,FileHeader>::beginHeader()
const throw(gpstk::InvalidRequest)
{
try { chl("beginHeader"); }
catch(gpstk::InvalidRequest exc)
{ GPSTK_RETHROW(exc); }
return headerList.begin();
}
bool TScramAuth::validateLogin(const TCHAR *challenge)
{
unsigned chlLen;
ptrA chl((char*)mir_base64_decode(_T2A(challenge), &chlLen));
return chl && strncmp((char*)chl + 2, serverSignature, chlLen - 2) == 0;
}
char* TScramAuth::getChallenge(const TCHAR *challenge)
{
unsigned chlLen, saltLen = 0;
ptrA snonce, salt;
int ind = -1;
ptrA chl((char*)mir_base64_decode(_T2A(challenge), &chlLen));
for (char *p = strtok(NEWSTR_ALLOCA(chl), ","); p != NULL; p = strtok(NULL, ",")) {
if (*p == 'r' && p[1] == '=') { // snonce
if (strncmp(cnonce, p + 2, mir_strlen(cnonce)))
return NULL;
snonce = mir_strdup(p + 2);
}
else if (*p == 's' && p[1] == '=') // salt
salt = (char*)mir_base64_decode(p + 2, &saltLen);
else if (*p == 'i' && p[1] == '=')
ind = atoi(p + 2);
}
if (snonce == NULL || salt == NULL || ind == -1)
return NULL;
ptrA passw(mir_utf8encodeT(info->conn.password));
size_t passwLen = mir_strlen(passw);
BYTE saltedPassw[MIR_SHA1_HASH_SIZE];
Hi(saltedPassw, passw, passwLen, salt, saltLen, ind);
BYTE clientKey[MIR_SHA1_HASH_SIZE];
mir_hmac_sha1(clientKey, saltedPassw, sizeof(saltedPassw), (BYTE*)"Client Key", 10);
BYTE storedKey[MIR_SHA1_HASH_SIZE];
mir_sha1_ctx ctx;
mir_sha1_init(&ctx);
mir_sha1_append(&ctx, clientKey, MIR_SHA1_HASH_SIZE);
mir_sha1_finish(&ctx, storedKey);
char authmsg[4096];
int authmsgLen = mir_snprintf(authmsg, _countof(authmsg), "%s,%s,c=biws,r=%s", msg1, chl, snonce);
BYTE clientSig[MIR_SHA1_HASH_SIZE];
mir_hmac_sha1(clientSig, storedKey, sizeof(storedKey), (BYTE*)authmsg, authmsgLen);
BYTE clientProof[MIR_SHA1_HASH_SIZE];
for (unsigned j = 0; j < sizeof(clientKey); j++)
clientProof[j] = clientKey[j] ^ clientSig[j];
/* Calculate the server signature */
BYTE serverKey[MIR_SHA1_HASH_SIZE];
mir_hmac_sha1(serverKey, saltedPassw, sizeof(saltedPassw), (BYTE*)"Server Key", 10);
BYTE srvSig[MIR_SHA1_HASH_SIZE];
mir_hmac_sha1(srvSig, serverKey, sizeof(serverKey), (BYTE*)authmsg, authmsgLen);
serverSignature = mir_base64_encode((PBYTE)srvSig, sizeof(srvSig));
char buf[4096];
ptrA encproof(mir_base64_encode((PBYTE)clientProof, sizeof(clientProof)));
int cbLen = mir_snprintf(buf, "c=biws,r=%s,p=%s", snonce, encproof);
return mir_base64_encode((PBYTE)buf, cbLen);
}
