VOID
FatDumpDataHeader (
)
/*++
Routine Description:
Dump the top data structures and all Device structures
Arguments:
None
Return Value:
None
--*/
{
PFAT_DATA Ptr;
PLIST_ENTRY Links;
Ptr = &FatData;
TestForNull("FatDumpDataHeader");
DumpNewLine();
DbgPrint("FatData@ %lx", (Ptr));
DumpNewLine();
DumpField (NodeTypeCode);
DumpField (NodeByteSize);
DumpListEntry (VcbQueue);
DumpField (DriverObject);
DumpField (OurProcess);
DumpNewLine();
for (Links = Ptr->VcbQueue.Flink;
Links != &Ptr->VcbQueue;
Links = Links->Flink) {
FatDumpVcb(CONTAINING_RECORD(Links, VCB, VcbLinks));
}
return;
}
void DumpRpcVersion (
FILE *output,
char *prefix,
RPC_VERSION *pRpcVersion
) {
int field;
int pos = 0;
for (field = 0; field < sizeof_array(structure); field++) {
DumpField (output, prefix, &structure[field], pRpcVersion, &pos);
}
}
VOID
FatDumpCcb (
IN PCCB Ptr
)
/*++
Routine Description:
Dump a Ccb structure
Arguments:
Ptr - Supplies the Ccb record to be dumped
Return Value:
None
--*/
{
TestForNull("FatDumpCcb");
DumpNewLine();
DbgPrint("Ccb@ %lx", (Ptr));
DumpNewLine();
DumpField (NodeTypeCode);
DumpField (NodeByteSize);
DumpField (UnicodeQueryTemplate.Length);
DumpName (UnicodeQueryTemplate.Buffer, 32);
DumpField (OffsetToStartSearchFrom);
DumpNewLine();
return;
}
void DumpMidlInformation (
FILE *output,
char *prefix,
MIDL_INFORMATION *pMidlInformation,
int ProcNum
) {
int field;
int pos = 0;
for (field = 0; field < sizeof_array(structure); field++) {
DumpField(output, prefix, &structure[field], pMidlInformation, &pos);
switch (field) {
case MIDL_INFORMATION_ServerRoutineTable:
fprintf(output, "%s\tServerFunc called = 0x%08X\n", prefix, *(int *)((int)(pMidlInformation->ServerRoutineTable) + 4 * ProcNum));
break;
}
}
}
/* static */ wxString
wxDbgHelpDLL::DumpUDT(PSYMBOL_INFO pSym, void *pVariable, unsigned level)
{
wxString s;
// we have to limit the depth of UDT dumping as otherwise we get in
// infinite loops trying to dump linked lists... 10 levels seems quite
// reasonable, full information is in minidump file anyhow
if ( level > 10 )
return s;
s.reserve(512);
s = GetSymbolName(pSym);
#if !wxUSE_STL
// special handling for ubiquitous wxString: although the code below works
// for it as well, it shows the wxStringBase class and takes 4 lines
// instead of only one as this branch
if ( s == _T("wxString") )
{
wxString *ps = (wxString *)pVariable;
s << _T("(\"") << *ps << _T(")\"");
}
else // any other UDT
#endif // !wxUSE_STL
{
// Determine how many children this type has.
DWORD dwChildrenCount = 0;
DoGetTypeInfo(pSym, TI_GET_CHILDRENCOUNT, &dwChildrenCount);
// Prepare to get an array of "TypeIds", representing each of the children.
TI_FINDCHILDREN_PARAMS *children = (TI_FINDCHILDREN_PARAMS *)
malloc(sizeof(TI_FINDCHILDREN_PARAMS) +
(dwChildrenCount - 1)*sizeof(ULONG));
if ( !children )
return s;
children->Count = dwChildrenCount;
children->Start = 0;
// Get the array of TypeIds, one for each child type
if ( !DoGetTypeInfo(pSym, TI_FINDCHILDREN, children) )
{
free(children);
return s;
}
s << _T(" {\n");
// Iterate through all children
SYMBOL_INFO sym;
wxZeroMemory(sym);
sym.ModBase = pSym->ModBase;
for ( unsigned i = 0; i < dwChildrenCount; i++ )
{
sym.TypeIndex = children->ChildId[i];
// children here are in lexicographic sense, i.e. we get all our nested
// classes and not only our member fields, but we can't get the values
// for the members of the nested classes, of course!
DWORD nested;
if ( DoGetTypeInfo(&sym, TI_GET_NESTED, &nested) && nested )
continue;
// avoid infinite recursion: this does seem to happen sometimes with
// complex typedefs...
if ( sym.TypeIndex == pSym->TypeIndex )
continue;
s += DumpField(&sym, pVariable, level + 1);
}
free(children);
s << wxString(_T('\t'), level + 1) << _T('}');
}
return s;
}
RecordBuffer* DbCreatorsList::getList(thread_db* tdbb, jrd_rel* relation)
{
fb_assert(relation);
fb_assert(relation->rel_id == rel_sec_db_creators);
RecordBuffer* buffer = getData(relation);
if (buffer)
{
return buffer;
}
RefPtr<IAttachment> att;
RefPtr<ITransaction> tra;
const char* dbName = tdbb->getDatabase()->dbb_config->getSecurityDatabase();
if (!openDb(dbName, att, tra))
{
// In embedded mode we are not raising any errors - silent return
if (MasterInterfacePtr()->serverMode(-1) < 0)
return makeBuffer(tdbb);
(Arg::Gds(isc_crdb_nodb) << dbName).raise();
}
Message gr;
Field<ISC_SHORT> uType(gr);
Field<Varying> u(gr, MAX_SQL_IDENTIFIER_LEN);
FbLocalStatus st;
RefPtr<IResultSet> curs(att->openCursor(&st, tra, 0,
"select RDB$USER_TYPE, RDB$USER from RDB$DB_CREATORS",
SQL_DIALECT_V6, NULL, NULL, gr.getMetadata(), NULL, 0));
if (st->getState() & IStatus::STATE_ERRORS)
{
if (!fb_utils::containsErrorCode(st->getErrors(), isc_dsql_relation_err))
check("IAttachment::openCursor", &st);
// isc_dsql_relation_err when opening cursor - i.e. table
// is missing due to non-FB3 security DB
// In embedded mode we are not raising any errors - silent return
if (MasterInterfacePtr()->serverMode(-1) < 0)
return makeBuffer(tdbb);
(Arg::Gds(isc_crdb_notable) << dbName).raise();
}
try
{
buffer = makeBuffer(tdbb);
while (curs->fetchNext(&st, gr.getBuffer()) == IStatus::RESULT_OK)
{
Record* record = buffer->getTempRecord();
record->nullify();
putField(tdbb, record,
DumpField(f_sec_crt_user, VALUE_STRING, u->len, u->data));
SINT64 v = uType;
putField(tdbb, record,
DumpField(f_sec_crt_u_type, VALUE_INTEGER, sizeof(v), &v));
buffer->store(record);
}
check("IResultSet::fetchNext", &st);
}
catch (const Exception&)
{
clearSnapshot();
throw;
}
return getData(relation);
}
/* static */ wxString
wxDbgHelpDLL::DumpUDT(wxPSYMBOL_INFO pSym, void *pVariable, unsigned level)
{
wxString s;
// we have to limit the depth of UDT dumping as otherwise we get in
// infinite loops trying to dump linked lists... 10 levels seems quite
// reasonable, full information is in minidump file anyhow
if ( level > 10 )
return s;
s.reserve(512);
s = GetSymbolName(pSym);
#if !wxUSE_STD_STRING
// special handling for ubiquitous wxString: although the code below works
// for it as well, it shows the wxStringBase class and takes 4 lines
// instead of only one as this branch
if ( s == wxT("wxString") )
{
wxString *ps = (wxString *)pVariable;
// we can't just dump wxString directly as it could be corrupted or
// invalid and it could also be locked for writing (i.e. if we're
// between GetWriteBuf() and UngetWriteBuf() calls) and assert when we
// try to access it contents using public methods, so instead use our
// knowledge of its internals
const wxChar *p = NULL;
if ( !::IsBadReadPtr(ps, sizeof(wxString)) )
{
p = ps->data();
wxStringData *data = (wxStringData *)p - 1;
if ( ::IsBadReadPtr(data, sizeof(wxStringData)) ||
::IsBadReadPtr(p, sizeof(wxChar *)*data->nAllocLength) )
{
p = NULL; // don't touch this pointer with 10 feet pole
}
}
s << wxT("(\"") << (p ? p : wxT("???")) << wxT(")\"");
}
else // any other UDT
#endif // !wxUSE_STD_STRING
{
// Determine how many children this type has.
DWORD dwChildrenCount = 0;
DoGetTypeInfo(pSym, TI_GET_CHILDRENCOUNT, &dwChildrenCount);
// Prepare to get an array of "TypeIds", representing each of the children.
TI_FINDCHILDREN_PARAMS *children = (TI_FINDCHILDREN_PARAMS *)
malloc(sizeof(TI_FINDCHILDREN_PARAMS) +
(dwChildrenCount - 1)*sizeof(ULONG));
if ( !children )
return s;
children->Count = dwChildrenCount;
children->Start = 0;
// Get the array of TypeIds, one for each child type
if ( !DoGetTypeInfo(pSym, TI_FINDCHILDREN, children) )
{
free(children);
return s;
}
s << wxT(" {\n");
// Iterate through all children
wxSYMBOL_INFO sym;
wxZeroMemory(sym);
sym.ModBase = pSym->ModBase;
for ( unsigned i = 0; i < dwChildrenCount; i++ )
{
sym.TypeIndex = children->ChildId[i];
// children here are in lexicographic sense, i.e. we get all our nested
// classes and not only our member fields, but we can't get the values
// for the members of the nested classes, of course!
DWORD nested;
if ( DoGetTypeInfo(&sym, TI_GET_NESTED, &nested) && nested )
continue;
// avoid infinite recursion: this does seem to happen sometimes with
// complex typedefs...
if ( sym.TypeIndex == pSym->TypeIndex )
continue;
s += DumpField(&sym, pVariable, level + 1);
}
free(children);
s << wxString(wxT('\t'), level + 1) << wxT('}');
}
return s;
}
VOID
FatDumpFcb (
IN PFCB Ptr
)
/*++
Routine Description:
Dump an Fcb structure, its various queues
Arguments:
Ptr - Supplies the Fcb record to be dumped
Return Value:
None
--*/
{
PLIST_ENTRY Links;
TestForNull("FatDumpFcb");
DumpNewLine();
if (NodeType(&Ptr->Header) == FAT_NTC_FCB) {DbgPrint("Fcb@ %lx", (Ptr));}
else if (NodeType(&Ptr->Header) == FAT_NTC_DCB) {DbgPrint("Dcb@ %lx", (Ptr));}
else if (NodeType(&Ptr->Header) == FAT_NTC_ROOT_DCB) {DbgPrint("RootDcb@ %lx", (Ptr));}
else {DbgPrint("NonFcb NodeType @ %lx", (Ptr));}
DumpNewLine();
DumpField (Header.NodeTypeCode);
DumpField (Header.NodeByteSize);
DumpListEntry (ParentDcbLinks);
DumpField (ParentDcb);
DumpField (Vcb);
DumpField (FcbState);
DumpField (FcbCondition);
DumpField (UncleanCount);
DumpField (OpenCount);
DumpField (DirentOffsetWithinDirectory);
DumpField (DirentFatFlags);
DumpField (FullFileName.Length);
DumpField (FullFileName.Buffer);
DumpName (FullFileName.Buffer, 32);
DumpField (ShortName.Name.Oem.Length);
DumpField (ShortName.Name.Oem.Buffer);
DumpField (NonPaged);
DumpField (Header.AllocationSize.LowPart);
DumpField (NonPaged->SectionObjectPointers.DataSectionObject);
DumpField (NonPaged->SectionObjectPointers.SharedCacheMap);
DumpField (NonPaged->SectionObjectPointers.ImageSectionObject);
if ((Ptr->Header.NodeTypeCode == FAT_NTC_DCB) ||
(Ptr->Header.NodeTypeCode == FAT_NTC_ROOT_DCB)) {
DumpListEntry (Specific.Dcb.ParentDcbQueue);
DumpField (Specific.Dcb.DirectoryFileOpenCount);
DumpField (Specific.Dcb.DirectoryFile);
} else if (Ptr->Header.NodeTypeCode == FAT_NTC_FCB) {
DumpField (Header.FileSize.LowPart);
} else {
DumpNewLine();
DbgPrint("Illegal Node type code");
}
DumpNewLine();
if ((Ptr->Header.NodeTypeCode == FAT_NTC_DCB) ||
(Ptr->Header.NodeTypeCode == FAT_NTC_ROOT_DCB)) {
for (Links = Ptr->Specific.Dcb.ParentDcbQueue.Flink;
Links != &Ptr->Specific.Dcb.ParentDcbQueue;
Links = Links->Flink) {
FatDumpFcb(CONTAINING_RECORD(Links, FCB, ParentDcbLinks));
}
}
return;
}
VOID
FatDumpVcb (
IN PVCB Ptr
)
/*++
Routine Description:
Dump an Device structure, its Fcb queue amd direct access queue.
Arguments:
Ptr - Supplies the Device record to be dumped
Return Value:
None
--*/
{
TestForNull("FatDumpVcb");
DumpNewLine();
DbgPrint("Vcb@ %lx", (Ptr));
DumpNewLine();
DumpField (VolumeFileHeader.NodeTypeCode);
DumpField (VolumeFileHeader.NodeByteSize);
DumpListEntry (VcbLinks);
DumpField (TargetDeviceObject);
DumpField (Vpb);
DumpField (VcbState);
DumpField (VcbCondition);
DumpField (RootDcb);
DumpField (DirectAccessOpenCount);
DumpField (OpenFileCount);
DumpField (ReadOnlyCount);
DumpField (AllocationSupport);
DumpField (AllocationSupport.RootDirectoryLbo);
DumpField (AllocationSupport.RootDirectorySize);
DumpField (AllocationSupport.FileAreaLbo);
DumpField (AllocationSupport.NumberOfClusters);
DumpField (AllocationSupport.NumberOfFreeClusters);
DumpField (AllocationSupport.FatIndexBitSize);
DumpField (AllocationSupport.LogOfBytesPerSector);
DumpField (AllocationSupport.LogOfBytesPerCluster);
DumpField (DirtyFatMcb);
DumpField (FreeClusterBitMap);
DumpField (VirtualVolumeFile);
DumpField (SectionObjectPointers.DataSectionObject);
DumpField (SectionObjectPointers.SharedCacheMap);
DumpField (SectionObjectPointers.ImageSectionObject);
DumpField (ClusterHint);
DumpNewLine();
FatDumpFcb(Ptr->RootDcb);
return;
}
