CryptoManager::CryptoManager(thread_db* tdbb)
: PermanentStorage(*tdbb->getDatabase()->dbb_permanent),
keyHolderPlugins(getPool()),
cryptThreadId(0),
cryptPlugin(NULL),
dbb(*tdbb->getDatabase()),
needLock(true),
crypt(false),
process(false),
down(false)
{
stateLock = FB_NEW_RPT(getPool(), 0)
Lock(tdbb, 0, LCK_crypt_status, this, blockingAstChangeCryptState);
threadLock = FB_NEW_RPT(getPool(), 0) Lock(tdbb, 0, LCK_crypt);
takeStateLock(tdbb);
}
Lock* Database::createSweepLock(thread_db* tdbb)
{
if (!dbb_sweep_lock)
{
dbb_sweep_lock = FB_NEW_RPT(*dbb_permanent, 0)
Lock(tdbb, 0, LCK_sweep, this, blocking_ast_sweep);
}
return dbb_sweep_lock;
}
static alice_str* alloc_string(const TEXT** ptr)
{
AliceGlobals* tdgbl = AliceGlobals::getSpecific();
const TEXT* p = *ptr;
const USHORT length = (USHORT) *p++;
alice_str* string = FB_NEW_RPT(*tdgbl->getDefaultPool(), length + 1) alice_str;
memcpy(string->str_data, p, length);
string->str_data[length] = 0;
*ptr = p + length;
return string;
}
SLONG Database::SharedCounter::generate(thread_db* tdbb, ULONG space, ULONG prefetch)
{
fb_assert(space < TOTAL_ITEMS);
ValueCache* const counter = &m_counters[space];
if (m_localOnly)
{
SLONG result = 0;
while ( !(result = (SLONG) ++counter->curVal) )
;
return result;
}
Database* const dbb = tdbb->getDatabase();
SyncLockGuard guard(&dbb->dbb_sh_counter_sync, SYNC_EXCLUSIVE, "Database::SharedCounter::generate");
if (!counter->lock)
{
Lock* const lock =
FB_NEW_RPT(*dbb->dbb_permanent, 0) Lock(tdbb, sizeof(SLONG), LCK_shared_counter);
counter->lock = lock;
lock->lck_key.lck_long = space;
LCK_lock(tdbb, lock, LCK_PW, LCK_WAIT);
}
SLONG result = (SLONG) ++counter->curVal;
if (result > counter->maxVal)
{
LCK_convert(tdbb, counter->lock, LCK_PW, LCK_WAIT);
result = LCK_read_data(tdbb, counter->lock);
// zero IDs are somewhat special, so let's better skip them
if (!result)
result = 1;
counter->curVal = result;
counter->maxVal = result + prefetch - 1;
LCK_write_data(tdbb, counter->lock, counter->maxVal + 1);
LCK_convert(tdbb, counter->lock, LCK_SR, LCK_WAIT);
}
return result;
}
GlobalRWLock::GlobalRWLock(thread_db* tdbb, MemoryPool& p, locktype_t lckType,
lck_owner_t lock_owner, bool lock_caching, size_t lockLen, const UCHAR* lockStr)
: PermanentStorage(p), pendingLock(0), readers(0), pendingWriters(0), currentWriter(false),
lockCaching(lock_caching), blocking(false)
{
SET_TDBB(tdbb);
cachedLock = FB_NEW_RPT(getPool(), lockLen) Lock();
cachedLock->lck_type = static_cast<lck_t>(lckType);
cachedLock->lck_owner_handle = LCK_get_owner_handle_by_type(tdbb, lock_owner);
cachedLock->lck_length = lockLen;
Database* dbb = tdbb->getDatabase();
cachedLock->lck_dbb = dbb;
cachedLock->lck_parent = dbb->dbb_lock;
cachedLock->lck_object = this;
cachedLock->lck_ast = lockCaching ? blocking_ast_cached_lock : NULL;
memcpy(&cachedLock->lck_key, lockStr, lockLen);
}
SLONG Database::SharedCounter::generate(thread_db* tdbb, ULONG space, ULONG prefetch)
{
fb_assert(space < TOTAL_ITEMS);
ValueCache* const counter = &m_counters[space];
Database* const dbb = tdbb->getDatabase();
if (!counter->lock)
{
Lock* const lock = FB_NEW_RPT(*dbb->dbb_permanent, sizeof(SLONG)) Lock();
counter->lock = lock;
lock->lck_type = LCK_shared_counter;
lock->lck_owner_handle = LCK_get_owner_handle(tdbb, lock->lck_type);
lock->lck_parent = dbb->dbb_lock;
lock->lck_length = sizeof(SLONG);
lock->lck_key.lck_long = space;
lock->lck_dbb = dbb;
lock->lck_ast = blockingAst;
lock->lck_object = counter;
LCK_lock(tdbb, lock, LCK_PW, LCK_WAIT);
counter->curVal = 1;
counter->maxVal = 0;
}
if (counter->curVal > counter->maxVal)
{
LCK_convert(tdbb, counter->lock, LCK_PW, LCK_WAIT);
counter->curVal = LCK_read_data(tdbb, counter->lock);
if (!counter->curVal)
{
// zero IDs are somewhat special, so let's better skip them
counter->curVal = 1;
}
counter->maxVal = counter->curVal + prefetch - 1;
LCK_write_data(tdbb, counter->lock, counter->maxVal + 1);
}
return counter->curVal++;
}
rem_str* REMOTE_make_string(const SCHAR* input)
{
/**************************************
*
* R E M O T E _ m a k e _ s t r i n g
*
**************************************
*
* Functional description
* Copy a given string to a permanent location, returning
* address of new string.
*
**************************************/
const USHORT length = static_cast<USHORT>(strlen(input));
rem_str* string = FB_NEW_RPT(*getDefaultMemoryPool(), length) rem_str;
#ifdef DEBUG_REMOTE_MEMORY
printf("REMOTE_make_string allocate string %x\n", string);
#endif
strcpy(string->str_data, input);
string->str_length = length;
return string;
}
static void parse_fullpath(tdr* trans)
{
AliceGlobals* tdgbl = AliceGlobals::getSpecific();
// start at the end of the full pathname
const TEXT* p = (TEXT*) trans->tdr_fullpath->str_data;
const TEXT* const start = p;
while (*p)
p++;
const TEXT* const end = p;
// Check for a named pipes name - \\node\path\db or //node/path/db
while (p > start && !(*p == '/' && p[-1] == '/') && !(*p == '\\' && p[-1] == '\\'))
{
--p;
}
if (p > start)
{
// Increment p past slash, & search forward for end of node name
p = p + 1;
const TEXT* q = p;
while (*q && *q != '/' && *q != '\\')
q++;
if (*q)
{
trans->tdr_filename = q + 1;
trans->tdr_remote_site = FB_NEW_RPT(*tdgbl->getDefaultPool(), q - p + 1) alice_str;
strncpy((char*) trans->tdr_remote_site->str_data, (char*) p, q - p);
trans->tdr_remote_site->str_data[q - p] = '\0';
}
}
else
{
p = end;
// If not named pipes, check the other protocols
// work backwards until we find a remote protocol specifier
while (p >= start && (*p != '^' && *p != ':' && *p != '@'))
p--;
// dimitr: make sure that the remote path is parsed correctly
// for win32 servers, i.e. the drive separator is taken into account
if ((p - 2 >= start) && p[-2] == ':' && (p[0] == ':'))
p -= 2;
trans->tdr_filename = p + 1;
// now find the last remote node in the chain
while (p > start && (*p == ':' || *p == '^' || *p == '@'))
p--;
USHORT length = 0;
for (; p >= start && (*p != '^' && *p != ':' && *p != '@'); ++length)
--p;
++p;
if (length)
{
trans->tdr_remote_site = FB_NEW_RPT(*tdgbl->getDefaultPool(), length + 1) alice_str;
TEXT* q = (TEXT *) trans->tdr_remote_site->str_data;
while (length--)
*q++ = *p++;
*q = 0;
}
}
}