void cmp_z_mul(cmp_z_t* r, cmp_z_t* a, cmp_z_t* b)
{
unsigned int size = CT_MAX(a->size, b->size);
r->size = 2*size;
r->sign = a->sign * b->sign;
cmp_uint64_mul(r->limbs, a->limbs, b->limbs, size);
}
void cmp_z_tdiv_qr(cmp_z_t* q, cmp_z_t* r, cmp_z_t* n, cmp_z_t* d)
{
unsigned int size = CT_MAX(n->size, d->size);
cmp_uint64_tdiv_qr(q->limbs, r->limbs, n->limbs, d->limbs, size);
r->sign = q->sign = n->sign * d->sign;
r->size = q->size = size;
}
void cmp_z_add(cmp_z_t* r, cmp_z_t* a, cmp_z_t* b)
{
r->size = CT_MAX(a->size, b->size);
if (a->sign == b->sign) {
r->sign = a->sign;
r->size += cmp_uint64_add(r->limbs, a->limbs, b->limbs, r->size, 1);
}
else if (a->sign > b->sign) {
r->sign = cmp_uint64_sub(r->limbs, a->limbs, b->limbs, r->size);
}
else {
r->sign = cmp_uint64_sub(r->limbs, b->limbs, a->limbs, r->size);
}
}
DWORD
LWNetSrvPingCLdapArray(
IN PCSTR pszDnsDomainName,
IN DWORD dwDsFlags,
IN PDNS_SERVER_INFO pServerArray,
IN DWORD dwServerCount,
IN OPTIONAL DWORD dwTimeoutSeconds,
OUT PLWNET_DC_INFO* ppDcInfo,
OUT PBOOLEAN pbFailedFindWritable
)
{
DWORD dwError = 0;
DWORD dwMaxConnCount = 0;
DWORD dwIncrementalConnCount = 0;
DWORD dwActualTimeoutSeconds = 0;
DWORD dwSingleConnTimeoutSeconds = 0;
DWORD dwSingleConnTimeoutMilliseconds = 0;
DWORD dwTimeoutMilliseconds = 0;
LWNET_UNIX_MS_TIME_T StopTime = 0;
LWNET_UNIX_MS_TIME_T CurrentTime = 0;
PLWNET_DC_INFO pDcInfo = NULL;
BOOLEAN bFailedFindWritable = FALSE;
PLWNET_CLDAP_CONNECTION_CONTEXT pConnections = NULL;
DWORD dwActualConnCount = 0;
DWORD dwUsedServers = 0;
DWORD dwIndexConn = 0;
struct pollfd *Readfds = NULL;
// The basic scheme is a big loop over:
//
// 1. starting some CLDAP searches
// 2. polling for responses
// 3. processing responses
//
// When starting CLDAP searches, a portion of the
// available connections will be started followed
// by a short poll until the maximum number of
// connections has been used. Once the maximum
// number of connections are in use, the polling
// timeout will be the single search timeout for
// the oldest connection. This will start the
// maximum number of connections reasonably fast
// yet prevent excess network traffic if a server
// responds quickly.
//
// Active connections will be tracked in a list
// that is ordered by start time. If several
// servers respond at the same time, the one
// nearest the end of the list will be the one
// that responded the fastest.
dwMaxConnCount = CT_MIN(LWNetConfigGetCLdapMaximumConnections(), dwServerCount);
dwIncrementalConnCount = CT_MAX(dwMaxConnCount / 5, LWNET_CLDAP_MINIMUM_INCREMENTAL_CONNECTIONS);
if (dwTimeoutSeconds > 0)
{
dwActualTimeoutSeconds = dwTimeoutSeconds;
}
else
{
dwActualTimeoutSeconds = LWNetConfigGetCLdapSearchTimeoutSeconds();
}
dwSingleConnTimeoutSeconds = CT_MIN(LWNetConfigGetCLdapSingleConnectionTimeoutSeconds(), dwActualTimeoutSeconds);
dwSingleConnTimeoutMilliseconds = dwSingleConnTimeoutSeconds * 1000;
dwError = LWNetAllocateMemory(
dwMaxConnCount * sizeof(*pConnections),
OUT_PPVOID(&pConnections));
BAIL_ON_LWNET_ERROR(dwError);
dwError = LWNetAllocateMemory(
dwMaxConnCount * sizeof(*Readfds),
OUT_PPVOID(&Readfds));
BAIL_ON_LWNET_ERROR(dwError);
dwError = LWNetGetSystemTimeInMs(&CurrentTime);
BAIL_ON_LWNET_ERROR(dwError);
StopTime = CurrentTime + (dwActualTimeoutSeconds * 1000);
for (;;)
{
LWNetSrvPingCLdapNewConnections(
pszDnsDomainName,
dwSingleConnTimeoutMilliseconds,
dwMaxConnCount,
dwServerCount,
dwIncrementalConnCount,
pServerArray,
pConnections,
Readfds,
&dwActualConnCount,
&dwUsedServers);
if (dwActualConnCount == 0)
{
dwError = NERR_DCNotFound;
BAIL_ON_LWNET_ERROR(dwError);
}
dwError = LWNetGetSystemTimeInMs(&CurrentTime);
BAIL_ON_LWNET_ERROR(dwError);
if (CurrentTime > StopTime)
{
dwError = NERR_DCNotFound;
BAIL_ON_LWNET_ERROR(dwError);
}
if (dwActualConnCount < dwMaxConnCount &&
dwUsedServers < dwServerCount)
{
// If there are more connections available,
// use a short timeout
dwTimeoutMilliseconds = LWNET_CLDAP_SHORT_POLL_TIMEOUT_MILLISECONDS;
}
else
{
if (pConnections[0].StartTime +
dwSingleConnTimeoutMilliseconds > CurrentTime)
{
// Use the remaining time for the oldest connection
dwTimeoutMilliseconds = pConnections[0].StartTime +
dwSingleConnTimeoutMilliseconds -
CurrentTime;
dwTimeoutMilliseconds = CT_MIN(dwSingleConnTimeoutMilliseconds, StopTime - CurrentTime);
}
else
{
// The oldest connection has exceeded its limit so
// use the shortest possible timeout to check which
// connections have responded now.
dwTimeoutMilliseconds = 1;
}
}
dwError = LWNetSrvPingCLdapPoll(
dwTimeoutMilliseconds,
dwActualConnCount,
Readfds);
BAIL_ON_LWNET_ERROR(dwError);
dwError = LWNetGetSystemTimeInMs(&CurrentTime);
BAIL_ON_LWNET_ERROR(dwError);
LWNetSrvPingCLdapProcessConnections(
dwDsFlags,
CurrentTime,
dwSingleConnTimeoutMilliseconds,
dwActualConnCount,
Readfds,
pConnections,
&pDcInfo,
&bFailedFindWritable);
if (pDcInfo)
{
break;
}
dwActualConnCount = LWNetSrvPingCLdapPackArrays(
dwActualConnCount,
pConnections,
Readfds);
}
error:
if (pConnections)
{
for (dwIndexConn = 0 ; dwIndexConn < dwActualConnCount ; dwIndexConn++)
{
LWNetSrvPingCLdapEnd(&pConnections[dwIndexConn]);
}
LW_SAFE_FREE_MEMORY(pConnections);
}
LW_SAFE_FREE_MEMORY(Readfds);
if (dwError)
{
LWNET_SAFE_FREE_DC_INFO(pDcInfo);
}
*ppDcInfo = pDcInfo;
*pbFailedFindWritable = pDcInfo ? FALSE : bFailedFindWritable;
return dwError;
}
