/*****************************************************************************
* CKsPin::HasDataRangeWithSpecifier()
*****************************************************************************
*//*!
* @brief
*/
BOOL
CKsPin::
HasDataRangeWithSpecifier
(
IN REFGUID FormatSpecifier
)
{
BOOL Found = FALSE;
KSDATARANGE * DataRange = m_PinDescriptor.DataRanges;;
// Loop Through the DataRanges
for(ULONG i = 0; i < m_PinDescriptor.DataRangeCount; i++)
{
// Check for a matching Specifier
if (IsEqualGUID(DataRange->Specifier, FormatSpecifier))
{
// Found our matching Pin!
Found = TRUE;
break;
}
// Advance to the next datarange.
DataRange = PKSDATARANGE(PUCHAR(DataRange) + DataRange->FormatSize);
}
return Found;
}
void CFilteringTable::RemoveSpace(LPCTSTR textInput, LPTSTR textOutput, size_t size) const
{
TCHAR buffer[MAX_PATH] = {0};
for(PUCHAR inputPointer = PUCHAR(textInput);
0 < *inputPointer;
inputPointer = _mbsinc((const PUCHAR)inputPointer))
{
LPCTSTR removedSpeicalCharacter = _T("\t\n\r ~`!@#$%^&*()-_=+\\|<,>.?/");
if(_tcschr(removedSpeicalCharacter, *inputPointer))
{
continue;
}
_tcsncat(
buffer,
LPCTSTR(inputPointer),
IsDBCSLeadByte(*inputPointer) ? 2 : 1);
}
SafeStrCpy(
textOutput,
buffer,
size);
}
/*****************************************************************************
* CKsIrpTarget::GetNodePropertySimple()
*****************************************************************************
*//*!
* @brief
* Gets a simple node property.
*/
HRESULT
CKsIrpTarget::
GetNodePropertySimple
(
IN ULONG NodeId,
IN REFGUID PropertySet,
IN ULONG PropertyId,
OUT PVOID Value,
IN ULONG ValueSize,
IN PVOID Instance OPTIONAL,
IN ULONG InstanceSize OPTIONAL
)
{
HRESULT hr = S_OK;
ULONG PropertySize = sizeof(KSNODEPROPERTY) + InstanceSize;
PKSNODEPROPERTY KsNodeProperty = (PKSNODEPROPERTY)new BYTE[PropertySize];
if (NULL == KsNodeProperty)
{
hr = E_OUTOFMEMORY;
}
if (SUCCEEDED(hr))
{
ZeroMemory(KsNodeProperty, sizeof(KSNODEPROPERTY));
KsNodeProperty->Property.Set = PropertySet;
KsNodeProperty->Property.Id = PropertyId;
KsNodeProperty->Property.Flags = KSPROPERTY_TYPE_GET | KSPROPERTY_TYPE_TOPOLOGY;
KsNodeProperty->NodeId = NodeId;
KsNodeProperty->Reserved = 0;
if (Instance)
{
CopyMemory(PUCHAR(KsNodeProperty) + sizeof(KSNODEPROPERTY), Instance, InstanceSize);
}
hr = SynchronizedIoctl
(
m_Handle,
IOCTL_KS_PROPERTY,
KsNodeProperty,
PropertySize,
Value,
ValueSize,
NULL
);
}
//cleanup memory
if (KsNodeProperty)
{
delete[] (BYTE*)KsNodeProperty;
}
return hr;
}
BOOL FixFileRecord(PFILE_RECORD_HEADER file)
{
//int sec = 2048;
PUSHORT usa = PUSHORT(PUCHAR(file) + file->Ntfs.UsaOffset);
PUSHORT sector = PUSHORT(file);
if (file->Ntfs.UsaCount>4)
return FALSE;
for (ULONG i=1;i<file->Ntfs.UsaCount;i++)
{
sector[255] = usa[i];
sector+= 256;
}
return TRUE;
}
ResourceString :: ResourceString (ULONG Id) : psz ("(string load error)")
{
SavedId = Id;
if (DosGetResource (Module(), RT_STRING, Id/16+1, &BlockPointer))
return;
psz = PSZ (BlockPointer) + sizeof(USHORT);
USHORT Index = USHORT (Id % 16);
while (Index--)
{
psz += * PUCHAR (psz);
psz ++;
}
psz ++;
}
/*****************************************************************************
* SynchronizedDMusMPUWrite()
*****************************************************************************
* Writes outgoing MIDI data.
*/
NTSTATUS
SynchronizedDMusMPUWrite
(
IN PINTERRUPTSYNC InterruptSync,
IN PVOID syncWriteContext
)
{
PSYNCWRITECONTEXT context;
context = (PSYNCWRITECONTEXT)syncWriteContext;
ASSERT(context->Miniport);
ASSERT(context->PortBase);
ASSERT(context->BufferAddress);
ASSERT(context->Length);
ASSERT(context->BytesRead);
PUCHAR pChar = PUCHAR(context->BufferAddress);
NTSTATUS ntStatus,readStatus;
ntStatus = STATUS_SUCCESS;
//
// while we're not there yet, and
// while we don't have to wait on an aligned byte (including 0)
// (we never wait on a byte. Better to come back later)
readStatus = DMusMPUInterruptServiceRoutine(InterruptSync,PVOID(context->Miniport));
while ( (*(context->BytesRead) < context->Length)
&& ( TryMPU(context->PortBase)
|| (*(context->BytesRead)%3)
) )
{
ntStatus = WriteMPU(context->PortBase,DATA,*pChar);
if (NT_SUCCESS(ntStatus))
{
pChar++;
*(context->BytesRead) = *(context->BytesRead) + 1;
// readStatus = DMusMPUInterruptServiceRoutine(InterruptSync,PVOID(context->Miniport));
}
else
{
_DbgPrintF(DEBUGLVL_TERSE,("SynchronizedDMusMPUWrite failed (0x%08x)",ntStatus));
break;
}
}
readStatus = DMusMPUInterruptServiceRoutine(InterruptSync,PVOID(context->Miniport));
return ntStatus;
}
extern int main ( int argc, char *argv[] ) {
/**************************************************************************
* Register self. *
**************************************************************************/
Sys_RegisterThread ( ) ;
/**************************************************************************
* Set a default exception filter. *
**************************************************************************/
REGISTER_EXCEPTION_HANDLER(0);
/**************************************************************************
* Start the main block (for constructors/destructors). *
**************************************************************************/
{
/**************************************************************************
* Get the initial file path for loading files from command-line. *
**************************************************************************/
char InitialPath [CCHMAXPATH] ;
_fullpath ( InitialPath, ".", sizeof(InitialPath) ) ;
strcat ( InitialPath, "\\" ) ;
/**************************************************************************
* Determine the home directory. *
**************************************************************************/
char Drive [_MAX_DRIVE+1], Dir[_MAX_DIR+1], Fname[_MAX_FNAME+1], Ext[_MAX_EXT+1] ;
strupr ( argv[0] ) ;
_fullpath ( HomePath, argv[0], sizeof(HomePath) ) ;
_splitpath ( HomePath, Drive, Dir, Fname, Ext ) ;
if ( Dir[strlen(Dir)-1] == '\\' )
Dir[strlen(Dir)-1] = 0 ;
strcpy ( HomePath, Drive ) ;
strcat ( HomePath, Dir ) ;
_chdrive ( Drive[0] - 'A' + 1 ) ;
_chdir ( "\\" ) ;
_chdir ( Dir ) ;
/**************************************************************************
* Set the C RunTime Library error message file handle. *
**************************************************************************/
#ifdef __DEBUG_ALLOC__
Log ( "Escriba::main: Program started." ) ;
_set_crt_msg_handle ( fileno(Logfile) ) ;
#else
#ifdef DEBUG
Log ( "Escriba::main: Program started." ) ;
#endif // DEBUG
#endif // __DEBUG_ALLOC__
/**************************************************************************
* Determine if another instance of this program is present. *
* If so, pass the command-line information to it. *
**************************************************************************/
#ifdef DEBUG
Log ( "Escriba::main: Checking for another instance already loaded." ) ;
#endif // DEBUG
PublicMemory Memory ( MEMORY_NAME, sizeof(SHARED_MEMORY), TRUE ) ;
if ( NOT Memory.QueryCreated() ) {
// Get the main instance's window handle. Wait up to 20 seconds if necessary.
HWND MainWindow = ((SHARED_MEMORY*)Memory.QueryMemory())->MainWindow ;
clock_t LastClock = clock ( ) ;
while ( MainWindow == 0 ) {
if ( ( ( clock() - LastClock ) / CLOCKS_PER_SEC ) > 20 ) {
Log ( "ERROR: Unable to get previous instance window handle." ) ;
return ( 1 ) ;
} /* endif */
DosSleep ( 100 ) ;
MainWindow = ((SHARED_MEMORY*)Memory.QueryMemory())->MainWindow ;
} /* endwhile */
// If any command-line parameters were given . . .
if ( argc > 1 ) {
// Build a command-line string.
char Parms [512] = { 0 } ;
int ParmLength = 0 ;
while ( --argc ) {
strcpy ( Parms+ParmLength, *(++argv) ) ;
ParmLength += strlen(*argv) + 1 ;
} /* endwhile */
Parms[++ParmLength] = 0 ;
// Get the original process's ID.
PID Process ;
TID Thread ;
if ( !WinQueryWindowProcess ( MainWindow, &Process, &Thread ) ) {
char Message [512] ;
Log ( "ERROR: Unable to query window process. %s", InterpretWinError(0,Message) ) ;
return ( 1 ) ;
} /* endif */
// Allocate shared memory to hold the current path.
PVOID Memory1 ;
APIRET Status = DosAllocSharedMem ( &Memory1, 0, strlen(InitialPath)+1, fALLOC | OBJ_GIVEABLE | OBJ_GETTABLE) ;
if ( Status ) {
Log ( "ERROR: Unable to allocate shared memory. Status %d.", Status ) ;
return ( 1 ) ;
} /* endif */
strcpy ( PCHAR(Memory1), InitialPath ) ;
// Allocate shared memory to hold the command-line.
PVOID Memory2 ;
Status = DosAllocSharedMem ( &Memory2, 0, ParmLength, fALLOC | OBJ_GIVEABLE | OBJ_GETTABLE) ;
if ( Status ) {
Log ( "ERROR: Unable to allocate shared memory. Status %d.", Status ) ;
return ( 1 ) ;
} /* endif */
memcpy ( Memory2, Parms, ParmLength ) ;
// Make both shared memory blocks available to the original process.
Status = DosGiveSharedMem ( Memory1, Process, PAG_READ | PAG_WRITE ) ;
DosFreeMem ( Memory1 ) ;
if ( Status ) {
Log ( "ERROR: Unable to give shared memory. Status %d.", Status ) ;
return ( 1 ) ;
} /* endif */
Status = DosGiveSharedMem ( Memory2, Process, PAG_READ | PAG_WRITE ) ;
DosFreeMem ( Memory2 ) ;
if ( Status ) {
Log ( "ERROR: Unable to give shared memory. Status %d.", Status ) ;
return ( 1 ) ;
} /* endif */
// Pass the information to the original process.
Sys_PostMessage ( MainWindow, WM_LOAD_FILE, MPFROMP(Memory1), MPFROMP(Memory2) ) ;
} /* endif */
// Bring the previous instance to the fore.
Sys_SetActiveWindow ( MainWindow ) ;
// We're outta here . . .
return ( 0 ) ;
} /* endif */
/**************************************************************************
* If the ISPELL environment variable isn't set, set it to the current *
* directory, before we change it. This assumes that the current *
* directory is also the directory to which Escriba (and ISPELL) was *
* installed. This is true with the basic installation. *
**************************************************************************/
#ifdef DEBUG
Log ( "Escriba::main: Setting ISPELL environment variable." ) ;
#endif // DEBUG
{
char *p = getenv ( "ISPELL" ) ;
if ( p == 0 ) {
static char SetString [_MAX_PATH+10] ;
sprintf ( SetString, "ISPELL=%s", HomePath ) ;
_putenv ( SetString ) ;
} /* endif */
}
/**************************************************************************
* Get application language module. *
**************************************************************************/
#ifdef DEBUG
Log ( "Escriba::main: Loading default language." ) ;
#endif // DEBUG
char DefaultLanguage [80] = { 0 } ;
{ /* startblock */
Profile IniFile ( PSZ(PROGRAM_NAME), 0, HomePath ) ;
if ( IniFile.QueryHandle() )
IniFile.GetString ( "Language", DefaultLanguage, sizeof(DefaultLanguage) ) ;
else
strcpy ( DefaultLanguage, "English" ) ;
} /* endblock */
Library = Language_Create ( PROGRAM_NAME, REVISION, IDS_TITLE1, DefaultLanguage ) ;
if ( Library == 0 ) {
Process Proc ( PROGRAM_NAME, HWND_DESKTOP, 0 ) ;
Debug ( HWND_DESKTOP, "ERROR: Unable to find language module for %s, %s, %s.", PROGRAM_NAME, REVISION, DefaultLanguage ) ;
return ( 1 ) ;
} /* endif */
LibraryHandle = Library->QueryHandle() ;
/**************************************************************************
* Get the program title. *
**************************************************************************/
ResourceString Title ( Library->QueryHandle(), IDS_TITLE ) ;
/**************************************************************************
* Determine the default codepage. *
**************************************************************************/
#ifdef DEBUG
Log ( "Escriba::main: Determining codepage to use." ) ;
#endif // DEBUG
PUSHORT pCodePage = Library->QueryCodepages() ;
while ( *pCodePage ) {
if ( !DosSetProcessCp ( *pCodePage ) )
break ;
pCodePage ++ ;
} /* endwhile */
if ( *pCodePage == 0 ) {
ResourceString Format ( Library->QueryHandle(), IDS_WARNING_BADCODEPAGE ) ;
CHAR Message [200] ;
sprintf ( Message, PCHAR(Format), *Library->QueryCodepages() ) ;
Log ( "%s", Message ) ;
MessageBox ( HWND_DESKTOP, HWND_DESKTOP, PSZ(Message),
PSZ(Title), 0, MB_ENTER | MB_ICONEXCLAMATION, LibraryHandle, IDS_MESSAGE_BOX_STRINGS ) ;
return ( 1 ) ;
} /* endif */
/**************************************************************************
* Initialize the process with an extra-large message queue. *
**************************************************************************/
#ifdef DEBUG
Log ( "Escriba::main: Connecting to PM." ) ;
#endif // DEBUG
Process Proc ( PCHAR(Title), HWND_DESKTOP, Library->QueryHandle(), 100, *pCodePage ) ;
if ( Proc.QueryAnchor() == 0 )
return ( 1 ) ;
/**************************************************************************
* Register the custom control classes. *
**************************************************************************/
#ifdef DEBUG
Log ( "Escriba::main: Registering custom control classes." ) ;
#endif // DEBUG
RegisterControls ( Proc.QueryAnchor() ) ;
/**************************************************************************
* Open up debug timer. *
**************************************************************************/
#ifdef DEBUG
Log ( "Escriba::main: Opening debug timer." ) ;
#endif // DEBUG
OpenTimer ( ) ;
/**************************************************************************
* Open the registration library, if it is present. *
**************************************************************************/
#ifdef DEBUG
Log ( "Escriba::main: About to open registration file." ) ;
#endif // DEBUG
char *RegistrationName = PROGRAM_NAME"R" ;
Module *pRegistration = new Module ( RegistrationName, FALSE ) ;
if ( pRegistration->QueryHandle() == 0 )
RegistrationName = "PLUMAR" ;
delete pRegistration, pRegistration = 0 ;
Module Registration = Module ( RegistrationName, FALSE ) ;
/**************************************************************************
* Load any extenders (except spell-check). *
**************************************************************************/
#ifdef DEBUG
Log ( "Escriba::main: About to load extenders." ) ;
#endif // DEBUG
AddonList.Build ( DefaultLanguage ) ;
/**************************************************************************
* Get the country information. *
**************************************************************************/
#ifdef DEBUG
Log ( "Escriba::main: About to get country information." ) ;
#endif // DEBUG
GetCountryInfo ( 0, 0 ) ;
/**************************************************************************
* Set any language-specific globals. *
**************************************************************************/
#ifdef DEBUG
Log ( "Escriba::main: About to set language-specific globals." ) ;
#endif // DEBUG
ResourceString AllGraphicFiles ( LibraryHandle, IDS_ALL_GRAPHICS ) ;
GraphicTypeList[0] = PSZ ( AllGraphicFiles ) ;
/**************************************************************************
* Check for command-line options and remove them from the argument list. *
**************************************************************************/
#ifdef DEBUG
Log ( "Escriba::main: About to parse the command line." ) ;
#endif // DEBUG
ResourceString ResetCommand ( Library->QueryHandle(), IDS_PARMS_RESET ) ;
BOOL Reset = FALSE ;
// ResourceString PrintCommand ( Library->QueryHandle(), IDS_PARMS_PRINT ) ;
// BOOL Print = FALSE ;
ResourceString TrapCommand ( Library->QueryHandle(), IDS_PARMS_TRAP ) ;
BOOL Trap = FALSE ;
int i = 1 ;
char **p = argv + 1 ;
while ( i < argc ) {
if ( **p == '-' ) {
if ( !stricmp ( (*p)+1, PCHAR(ResetCommand) ) ) {
Reset = TRUE ;
// } else if ( !stricmp ( (*p)+1, PCHAR(PrintCommand) ) ) {
// Print = TRUE ;
} else if ( !stricmp ( (*p)+1, PCHAR(TrapCommand) ) ) {
Trap = TRUE ;
} else {
Debug ( HWND_DESKTOP, "ERROR: Invalid command-line parameter '%s'.", (*p)+1 ) ;
return ( 1 ) ;
} /* endif */
for ( int j=i+1; j<argc; j++ ) {
argv[j-1] = argv[j] ;
} /* endfor */
argv[j] = 0 ;
argc -- ;
continue ;
} /* endif */
i ++ ;
p ++ ;
} /* endwhile */
/**************************************************************************
* Create the help instance. *
**************************************************************************/
#ifdef DEBUG
Log ( "Escriba::main: About to create the help instance." ) ;
#endif // DEBUG
_splitpath ( Library->QueryName(), Drive, Dir, Fname, Ext ) ;
char HelpFileName [CCHMAXPATH] ;
sprintf ( HelpFileName, "%s.hlp", Fname ) ;
ResourceString HelpTitle ( Library->QueryHandle(), IDS_HELPTITLE ) ;
Help = new HelpWindow ( Proc.QueryAnchor(), 0, ID_MAIN, PSZ(HelpFileName), PSZ(HelpTitle) ) ;
if ( Help->QueryHandle() == 0 ) {
ERRORID Error = Sys_GetLastError ( Proc.QueryAnchor() ) ;
ResourceString Format ( Library->QueryHandle(), IDS_ERROR_CREATEHELP ) ;
CHAR Message [200] ;
sprintf ( Message, PCHAR(Format), Error ) ;
Log ( "%s", Message ) ;
MessageBox ( HWND_DESKTOP, HWND_DESKTOP, PSZ(Message), PSZ(Title), 0, MB_ENTER | MB_ICONEXCLAMATION, LibraryHandle, IDS_MESSAGE_BOX_STRINGS ) ;
} /* endif */
/**************************************************************************
* Open/create the profile file. Reset if requested. *
**************************************************************************/
#ifdef DEBUG
Log ( "Escriba::main: About to open profile file." ) ;
#endif // DEBUG
Profile2 IniFile ( PSZ(PROGRAM_NAME), Proc.QueryAnchor(), Library->QueryHandle(),
IDD_PROFILE_PATH, Help, Reset ) ;
if ( IniFile.QueryHandle() == 0 ) {
ResourceString Message ( Library->QueryHandle(), IDS_ERROR_PRFOPENPROFILE ) ;
Log ( "%s", PSZ(Message) ) ;
MessageBox ( HWND_DESKTOP, HWND_DESKTOP, PSZ(Message), PSZ(Title), 0, MB_ENTER | MB_ICONEXCLAMATION, LibraryHandle, IDS_MESSAGE_BOX_STRINGS ) ;
CloseTimer() ;
return ( 2 ) ;
} /* endif */
/**************************************************************************
* Get profile data. Try the OS2.INI first, then try for private INI. *
* If obtained from OS2.INI, erase it afterwards and resave it. *
**************************************************************************/
#ifdef DEBUG
Log ( "Escriba::main: About to get profile data." ) ;
#endif // DEBUG
INIDATA IniData ( Registration.QueryHandle() ) ;
IniFile.GetIniData ( IniData ) ;
if ( IniData.Language [0] == 0 )
strcpy ( IniData.Language, DefaultLanguage ) ;
/**************************************************************************
* Activate the spell checker, if it is present. *
**************************************************************************/
#ifdef DEBUG
Log ( "Escriba::main: About to open the default dictionary." ) ;
#endif // DEBUG
char SpellerPath [ CCHMAXPATH ] = { 0 } ;
if ( getenv ( "ISPELL" ) ) {
strcpy ( SpellerPath, getenv ( "ISPELL" ) ) ;
strcat ( SpellerPath, "\\" ) ;
} /* endif */
strcat ( SpellerPath, "ISPELLER.DLL" ) ;
Dictionary *Speller = new Dictionary ( SpellerPath, DefaultLanguage ) ;
if ( Speller->QueryLibrary() == 0 ) {
#ifdef DEBUG
Log ( "Escriba::main: Could not find spellchecker. Will try again through LIBPATH." ) ;
#endif // DEBUG
delete Speller, Speller = 0 ;
Speller = new Dictionary ( "ISPELLER", DefaultLanguage ) ;
} /* endif */
if ( Speller->Available() ) {
#ifdef DEBUG
Log ( "Escriba::main: Adding dictionary object to extension list." ) ;
#endif // DEBUG
AddonList.Add ( Speller ) ;
} else {
#ifdef DEBUG
Log ( "Escriba::main: Dictionary object could not be fully created." ) ;
#endif // DEBUG
delete Speller, Speller = 0 ;
} /* endif */
/**************************************************************************
* Create the frame window. *
**************************************************************************/
#ifdef DEBUG
Log ( "Escriba::main: About to create the frame window." ) ;
#endif // DEBUG
FRAMECDATA FrameControlData ;
FrameControlData.cb = sizeof(FrameControlData) ;
FrameControlData.flCreateFlags =
FCF_TITLEBAR | FCF_MENU | FCF_ICON | FCF_NOBYTEALIGN | FCF_ACCELTABLE | FCF_SYSMENU |
( Trap ? 0 : FCF_SIZEBORDER | FCF_MINMAX ) ;
FrameControlData.hmodResources = USHORT ( Library->QueryHandle() ) ;
FrameControlData.idResources = ID_MAIN ;
Window Frame ( HWND_DESKTOP, WC_FRAME, PSZ(Title),
IniData.Animate ? WS_ANIMATE : 0,
0, 0, 0, 0, HWND_DESKTOP, HWND_TOP, ID_MAIN,
&FrameControlData, NULL ) ;
if ( Frame.QueryHandle() == 0 ) {
ERRORID Error = Sys_GetLastError ( Proc.QueryAnchor() ) ;
ResourceString Format ( Library->QueryHandle(), IDS_ERROR_CREATEFRAME ) ;
CHAR Message [200] ;
sprintf ( Message, PCHAR(Format), Error ) ;
Log ( "%s", Message ) ;
MessageBox ( HWND_DESKTOP, HWND_DESKTOP, PSZ(Message), PSZ(Title), 0, MB_ENTER | MB_ICONEXCLAMATION, LibraryHandle, IDS_MESSAGE_BOX_STRINGS ) ;
CloseTimer() ;
return ( 3 ) ;
} /* endif */
/**************************************************************************
* Associate the help instance with the frame window. *
**************************************************************************/
Help->Associate ( Frame.QueryHandle() ) ;
/**************************************************************************
* Register the client window class. *
**************************************************************************/
if ( !WinRegisterClass ( Proc.QueryAnchor(), PSZ(CLASS_NAME),
MessageProcessor, CS_MOVENOTIFY, sizeof(PVOID) ) ) {
ERRORID Error = Sys_GetLastError ( Proc.QueryAnchor() ) ;
ResourceString Format ( Library->QueryHandle(), IDS_ERROR_WINREGISTERCLASS ) ;
CHAR Message [200] ;
sprintf ( Message, PCHAR(Format), CLASS_NAME, Error ) ;
Log ( "%s", Message ) ;
MessageBox ( HWND_DESKTOP, HWND_DESKTOP, PSZ(Message),
PSZ(Title), IDD_ERROR_WINREGISTERCLASS, MB_ENTER | MB_ICONEXCLAMATION | MB_HELP, LibraryHandle, IDS_MESSAGE_BOX_STRINGS ) ;
CloseTimer() ;
return ( 4 ) ;
} /* endif */
/**************************************************************************
* Build the presentation parameters for the main window. *
**************************************************************************/
COLOR BackColor = IniData.fMainColors[0] ? IniData.MainColors[0] :
WinQuerySysColor ( HWND_DESKTOP, SYSCLR_APPWORKSPACE, 0 ) ;
ULONG Ids[] = { PP_BACKGROUNDCOLOR } ;
ULONG ByteCounts[] = { sizeof(BackColor) } ;
PUCHAR Params[] = { PUCHAR(&BackColor) } ;
PPRESPARAMS PresParams = BuildPresParams ( sizeof(Ids)/sizeof(Ids[0]),
Ids, ByteCounts, Params ) ;
/**************************************************************************
* Create client window. If this fails, destroy frame and return. *
**************************************************************************/
#ifdef DEBUG
Log ( "Escriba::main: About to create the client window." ) ;
#endif // DEBUG
PARMS Parms ;
Parms.Filler = 0 ;
Parms.Library = Library ;
Parms.Registration = & Registration ;
Parms.IniFile = & IniFile ;
Parms.IniData = & IniData ;
Parms.Speller = Speller ;
Parms.InitialPath = InitialPath ;
Parms.argc = argc ;
Parms.argv = argv ;
Parms.Trap = Trap ;
Window Client ( Frame.QueryHandle(), PSZ(CLASS_NAME), PSZ(""), WS_CLIPCHILDREN | WS_CLIPSIBLINGS,
0, 0, 0, 0, Frame.QueryHandle(), HWND_BOTTOM, FID_CLIENT, &Parms, PresParams ) ;
free ( PresParams ) ;
if ( Client.QueryHandle() == 0 ) {
ERRORID Error = Sys_GetLastError ( Proc.QueryAnchor() ) ;
ResourceString Format ( Library->QueryHandle(), IDS_ERROR_CREATECLIENT ) ;
CHAR Message [200] ;
sprintf ( Message, PCHAR(Format), Error ) ;
Log ( "%s", Message ) ;
MessageBox ( HWND_DESKTOP, HWND_DESKTOP, PSZ(Message),
PSZ(Title), IDD_ERROR_CREATECLIENT, MB_ENTER | MB_ICONEXCLAMATION | MB_HELP, LibraryHandle, IDS_MESSAGE_BOX_STRINGS ) ;
CloseTimer ( ) ;
return ( 5 ) ;
} /* endif */
((SHARED_MEMORY*)Memory.QueryMemory())->MainWindow = Client.QueryHandle() ;
/**************************************************************************
* Wait for and process messages to the window's queue. Terminate *
* when the WM_QUIT message is received. *
**************************************************************************/
#ifdef DEBUG
Log ( "Escriba::main: About to enter the main message loop." ) ;
#endif // DEBUG
Sys_ProcessMessages ( Proc.QueryAnchor() ) ;
/**************************************************************************
* Discard all that had been requested of the system. *
**************************************************************************/
#ifdef DEBUG
Log ( "Escriba::main: About to close the HR Timer." ) ;
#endif // DEBUG
CloseTimer ( ) ;
/**************************************************************************
* Invoke nearly all the destructors. *
**************************************************************************/
#ifdef DEBUG
Log ( "Escriba::main: Invoking most destructors." ) ;
#endif // DEBUG
} /* Invoke all destructors except the global ones. */
/**************************************************************************
* Invoke the remaining destructors. *
**************************************************************************/
#ifdef DEBUG
Log ( "Escriba::main: Clearing the addon list." ) ;
#endif // DEBUG
AddonList.Clear ( ) ;
#ifdef DEBUG
Log ( "Escriba::main: Clearing the file type list." ) ;
#endif // DEBUG
ClearFileTypeList ( ) ;
#ifdef DEBUG
Log ( "Escriba::main: Clearing the graphic type list." ) ;
#endif // DEBUG
ClearGraphicTypeList ( ) ;
#ifdef DEBUG
Log ( "Escriba::main: Destroying the help instance." ) ;
#endif // DEBUG
if ( Help ) delete Help ;
#ifdef DEBUG
Log ( "Escriba::main: Destroying the language library instance." ) ;
#endif // DEBUG
if ( Library ) delete Library ;
/**************************************************************************
* Check to see if any memory remains allocated. *
**************************************************************************/
#ifdef __DEBUG_ALLOC__
Log ( "Escriba::main: Checking the heap." ) ;
_dump_allocated ( 64 ) ;
Log ( "Escriba::main: Program ended." ) ;
fclose ( Logfile ) ;
#else
#ifdef DEBUG
Log ( "Escriba::main: Program ended." ) ;
#endif // DEBUG
#endif // __DEBUG_ALLOC__
/**************************************************************************
* Discard the exception filter. *
**************************************************************************/
UNREGISTER_EXCEPTION_HANDLER(0);
/**************************************************************************
* Terminate the process. *
**************************************************************************/
return ( 0 ) ;
}
/*****************************************************************************
* InitMPU()
*****************************************************************************
* Synchronized routine to initialize the MPU401.
*/
NTSTATUS
InitMPU
(
IN PINTERRUPTSYNC InterruptSync,
IN PVOID DynamicContext
)
{
UNREFERENCED_PARAMETER(InterruptSync);
_DbgPrintF(DEBUGLVL_BLAB, ("InitMPU"));
if (!DynamicContext)
{
return STATUS_INVALID_PARAMETER_2;
}
PUCHAR portBase = PUCHAR(DynamicContext);
UCHAR status;
ULONGLONG startTime;
BOOLEAN success;
NTSTATUS ntStatus = STATUS_SUCCESS;
//
// Reset the card (puts it into "smart mode")
//
ntStatus = WriteMPU(portBase,COMMAND,MPU401_CMD_RESET);
// wait for the acknowledgement
// NOTE: When the Ack arrives, it will trigger an interrupt.
// Normally the DPC routine would read in the ack byte and we
// would never see it, however since we have the hardware locked (HwEnter),
// we can read the port before the DPC can and thus we receive the Ack.
startTime = PcGetTimeInterval(0);
success = FALSE;
while(PcGetTimeInterval(startTime) < GTI_MILLISECONDS(50))
{
status = READ_PORT_UCHAR(portBase + MPU401_REG_STATUS);
if (UartFifoOkForRead(status)) // Is data waiting?
{
READ_PORT_UCHAR(portBase + MPU401_REG_DATA); // yep.. read ACK
success = TRUE; // don't need to do more
break;
}
KeStallExecutionProcessor(25); // microseconds
}
#if (DBG)
if (!success)
{
_DbgPrintF(DEBUGLVL_VERBOSE,("First attempt to reset the MPU didn't get ACKed.\n"));
}
#endif // (DBG)
// NOTE: We cannot check the ACK byte because if the card was already in
// UART mode it will not send an ACK but it will reset.
// reset the card again
(void) WriteMPU(portBase,COMMAND,MPU401_CMD_RESET);
// wait for ack (again)
startTime = PcGetTimeInterval(0); // This might take a while
BYTE dataByte = 0;
success = FALSE;
while (PcGetTimeInterval(startTime) < GTI_MILLISECONDS(50))
{
status = READ_PORT_UCHAR(portBase + MPU401_REG_STATUS);
if (UartFifoOkForRead(status)) // Is data waiting?
{
dataByte = READ_PORT_UCHAR(portBase + MPU401_REG_DATA); // yep.. read ACK
success = TRUE; // don't need to do more
break;
}
KeStallExecutionProcessor(25);
}
if ((0xFE != dataByte) || !success) // Did we succeed? If no second ACK, something is hosed
{
_DbgPrintF(DEBUGLVL_TERSE,("Second attempt to reset the MPU didn't get ACKed.\n"));
_DbgPrintF(DEBUGLVL_TERSE,("Init Reset failure error. Ack = %X", ULONG(dataByte) ) );
ntStatus = STATUS_IO_DEVICE_ERROR;
}
return ntStatus;
}
CMiniportDMusUARTStream::
Write
(
IN PVOID BufferAddress,
IN ULONG Length,
OUT PULONG BytesWritten
)
{
_DbgPrintF(DEBUGLVL_BLAB, ("Write"));
ASSERT(BytesWritten);
if (!BufferAddress)
{
Length = 0;
}
NTSTATUS ntStatus = STATUS_SUCCESS;
if (!m_fCapture)
{
PUCHAR pMidiData;
ULONG count;
count = 0;
pMidiData = PUCHAR(BufferAddress);
if (Length)
{
SYNCWRITECONTEXT context;
context.Miniport = (m_pMiniport);
context.PortBase = m_pPortBase;
context.BufferAddress = pMidiData;
context.Length = Length;
context.BytesRead = &count;
if (m_pMiniport->m_UseIRQ)
{
ntStatus = m_pMiniport->m_pInterruptSync->
CallSynchronizedRoutine(SynchronizedDMusMPUWrite,PVOID(&context));
}
else // !m_UseIRQ
{
ntStatus = SynchronizedDMusMPUWrite(NULL,PVOID(&context));
} // !m_UseIRQ
if (count == 0)
{
m_NumFailedMPUTries++;
if (m_NumFailedMPUTries >= 100)
{
ntStatus = STATUS_IO_DEVICE_ERROR;
m_NumFailedMPUTries = 0;
}
}
else
{
m_NumFailedMPUTries = 0;
}
} // if we have data at all
*BytesWritten = count;
}
else // called write on the read stream
{
ntStatus = STATUS_INVALID_DEVICE_REQUEST;
}
return ntStatus;
}
int _tmain(int argc, _TCHAR* argv[])
{
HANDLE hVolume;
LPWSTR lpDrive = L"\\\\.\\c:";
NTFS_VOLUME_DATA_BUFFER ntfsVolData = {0};
BOOL bDioControl = FALSE;
DWORD dwWritten = 0;
LARGE_INTEGER num;
LONGLONG total_file_count, i;
NTFS_FILE_RECORD_INPUT_BUFFER mftRecordInput;
PNTFS_FILE_RECORD_OUTPUT_BUFFER output_buffer;
hVolume = CreateFile(lpDrive,
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL,
OPEN_EXISTING,
0,
NULL);
if(hVolume == INVALID_HANDLE_VALUE)
{
wprintf(L"CreateFile() failed!\n");
ErrorMessage(GetLastError());
if(CloseHandle(hVolume) != 0)
wprintf(L"hVolume handle was closed successfully!\n");
else
{
wprintf(L"Failed to close hVolume handle!\n");
ErrorMessage(GetLastError());
}
exit(1);
}
else
wprintf(L"CreateFile() is pretty fine!\n");
// a call to FSCTL_GET_NTFS_VOLUME_DATA returns the structure NTFS_VOLUME_DATA_BUFFER
bDioControl = DeviceIoControl(hVolume, FSCTL_GET_NTFS_VOLUME_DATA, NULL, 0, &ntfsVolData,
sizeof(NTFS_VOLUME_DATA_BUFFER), &dwWritten, NULL);
if(bDioControl == 0)
{
wprintf(L"DeviceIoControl() failed!\n");
ErrorMessage(GetLastError());
if(CloseHandle(hVolume) != 0)
wprintf(L"hVolume handle was closed successfully!\n");
else
{
wprintf(L"Failed to close hVolume handle!\n");
ErrorMessage(GetLastError());
}
exit(1);
}
else
wprintf(L"DeviceIoControl(...,FSCTL_GET_NTFS_VOLUME_DATA,...) is working...\n\n");
wprintf(L"Volume Serial Number: 0X%.8X%.8X\n",ntfsVolData.VolumeSerialNumber.HighPart,ntfsVolData.VolumeSerialNumber.LowPart);
wprintf(L"The number of bytes in a cluster: %u\n",ntfsVolData.BytesPerCluster);
wprintf(L"The number of bytes in a file record segment: %u\n",ntfsVolData.BytesPerFileRecordSegment);
wprintf(L"The number of bytes in a sector: %u\n",ntfsVolData.BytesPerSector);
wprintf(L"The number of clusters in a file record segment: %u\n",ntfsVolData.ClustersPerFileRecordSegment);
wprintf(L"The number of free clusters in the specified volume: %u\n",ntfsVolData.FreeClusters);
wprintf(L"The starting logical cluster number of the master file table mirror: 0X%.8X%.8X\n",ntfsVolData.Mft2StartLcn.HighPart, ntfsVolData.Mft2StartLcn.LowPart);
wprintf(L"The starting logical cluster number of the master file table: 0X%.8X%.8X\n",ntfsVolData.MftStartLcn.HighPart, ntfsVolData.MftStartLcn.LowPart);
wprintf(L"The length of the master file table, in bytes: %u\n",ntfsVolData.MftValidDataLength);
wprintf(L"The ending logical cluster number of the master file table zone: 0X%.8X%.8X\n",ntfsVolData.MftZoneEnd.HighPart, ntfsVolData.MftZoneEnd.LowPart);
wprintf(L"The starting logical cluster number of the master file table zone: 0X%.8X%.8X\n",ntfsVolData.MftZoneStart.HighPart, ntfsVolData.MftZoneStart.LowPart);
wprintf(L"The number of sectors: %u\n",ntfsVolData.NumberSectors);
wprintf(L"Total Clusters (used and free): %u\n",ntfsVolData.TotalClusters);
wprintf(L"The number of reserved clusters: %u\n\n",ntfsVolData.TotalReserved);
num.QuadPart = 1024; // 1024 or 2048
// We divide the MftValidDataLength (Master file table length) by 1024 to find
// the total entry count for the MFT
total_file_count = (ntfsVolData.MftValidDataLength.QuadPart/num.QuadPart);
//total_file_count = 50; //test
wprintf(L"Total file count = %u\n", total_file_count);
MFT_FILE_INFO* pfile_info = (MFT_FILE_INFO*)malloc(sizeof(MFT_FILE_INFO)*total_file_count);
for(i = 0; i < total_file_count;i++)
{
mftRecordInput.FileReferenceNumber.QuadPart = i;
//int kkk = sizeof(mftRecordInput);
// prior to calling the DeviceIoControl() we need to load
// an input record with which entry number we want
//int kk = sizeof(NTFS_FILE_RECORD_OUTPUT_BUFFER)+ntfsVolData.BytesPerFileRecordSegment-1;
// setup outputbuffer - FSCTL_GET_NTFS_FILE_RECORD depends on this
output_buffer = (PNTFS_FILE_RECORD_OUTPUT_BUFFER)malloc(sizeof(NTFS_FILE_RECORD_OUTPUT_BUFFER)+ntfsVolData.BytesPerFileRecordSegment-1);
if(output_buffer == NULL)
{
wprintf(L"malloc() failed - insufficient memory!\n");
ErrorMessage(GetLastError());
exit(1);
}
DWORD ooo = FSCTL_GET_NTFS_FILE_RECORD;
bDioControl = DeviceIoControl(hVolume,
FSCTL_GET_NTFS_FILE_RECORD,
&mftRecordInput,
sizeof(mftRecordInput),
output_buffer,
sizeof(NTFS_FILE_RECORD_OUTPUT_BUFFER) + (ntfsVolData.BytesPerFileRecordSegment)- 1,
&dwWritten,
NULL);
// More data will make DeviceIoControl() fails...
/*if(bDioControl == 0)
{
wprintf(L"DeviceIoControl(...,FSCTL_GET_NTFS_FILE_RECORD,...) failed!\n");
ErrorMessage(GetLastError());
exit(1);
}*/
// FSCTL_GET_NTFS_FILE_RECORD retrieves one MFT entry
// FILE_RECORD_HEADER is the Base struct for the MFT entry
// that we will work from
PFILE_RECORD_HEADER p_file_record_header = (PFILE_RECORD_HEADER)output_buffer->FileRecordBuffer;
PFILENAME_ATTRIBUTE fn;
PSTANDARD_INFORMATION si;
POBJECTID_ATTRIBUTE objid;
PATTRIBUTE attr = (PATTRIBUTE)((LPBYTE)p_file_record_header + p_file_record_header->AttributesOffset);
PRESIDENT_ATTRIBUTE preg;
int stop = min(8,p_file_record_header->NextAttributeNumber);
if(p_file_record_header->Ntfs.Type =='ELIF'){
while(true){
if (attr->AttributeType<0 || attr->AttributeType>0x100) break;
switch(attr->AttributeType)
{
case AttributeFileName:
preg = PRESIDENT_ATTRIBUTE(attr);
fn = PFILENAME_ATTRIBUTE(PUCHAR(attr) + PRESIDENT_ATTRIBUTE(attr)->ValueOffset);
if (fn->NameType & WIN32_NAME || fn->NameType == 0)
{
if(p_file_record_header->Flags & 0x1){
wprintf(L"FileName InUse\n") ;
}else{
wprintf(L"FileName NOt In Use\n") ;
}
if(p_file_record_header->Flags & 0x2){
wprintf(L"FileName Directory\n") ;
}else{
wprintf(L"FileName File\n") ;
}
wprintf(L"FileName i : %u\n", i );
wprintf(L"FileName DirectoryFileReferenceNumber : %u\n", fn->DirectoryFileReferenceNumber );
wprintf(L"FileName DataSize : %u\n", fn->DataSize );
fn->Name[fn->NameLength] = L'\0';
wprintf(L"FileName Name :%s\n", fn->Name) ;
//pfile_info[i].Name = (LPWSTR)malloc((lstrlenW(fn->Name)+1)*sizeof(WCHAR));
pfile_info[i].Name = new WCHAR[lstrlenW(fn->Name)+1];
lstrcpyW(pfile_info[i].Name , fn->Name);
pfile_info[i].Size = fn->DataSize;
//LPWSTR lp = fn->Name;
//wprintf(L"FileName Name :%s\n", lp) ;
if (lstrcmpW(fn->Name, L"3-chmode1.raw")==0) {
//if(i==28635){
int h=0;
}
}
break;
case AttributeStandardInformation:
preg = PRESIDENT_ATTRIBUTE(attr);
si = PSTANDARD_INFORMATION(PUCHAR(attr) + PRESIDENT_ATTRIBUTE(attr)->ValueOffset);
wprintf(L"#####StandardInformation CreationTime : %u\n", si->CreationTime );
break;
//case AttributeObjectId:
// objid = POBJECTID_ATTRIBUTE(PUCHAR(attr) + PRESIDENT_ATTRIBUTE(attr)->ValueOffset);
// wprintf(L"ObjectId Data1 : %u\n", objid->ObjectId.Data1 );
// wprintf(L"ObjectId Data2 : %u\n", objid->ObjectId.Data2 );
// wprintf(L"ObjectId Data3 : %u\n", objid->ObjectId.Data3 );
// wprintf(L"ObjectId Data4[0] : %u\n", objid->ObjectId.Data4[0] );
// wprintf(L"ObjectId Data4[1] : %u\n", objid->ObjectId.Data4[1] );
// wprintf(L"ObjectId Data4[2] : %u\n", objid->ObjectId.Data4[2] );
// wprintf(L"ObjectId Data4[3] : %u\n", objid->ObjectId.Data4[3] );
// wprintf(L"ObjectId Data4[3] : %u\n", objid->ObjectId.Data4[4] );
// wprintf(L"ObjectId Data4[3] : %u\n", objid->ObjectId.Data4[5] );
// wprintf(L"ObjectId Data4[3] : %u\n", objid->ObjectId.Data4[6] );
// wprintf(L"ObjectId Data4[3] : %u\n", objid->ObjectId.Data4[7] );
// break;
default:
break;
};
if (attr->Length>0 && attr->Length < p_file_record_header->BytesInUse)
attr = PATTRIBUTE(PUCHAR(attr) + attr->Length);
else
if (attr->Nonresident == TRUE)
attr = PATTRIBUTE(PUCHAR(attr) + sizeof(NONRESIDENT_ATTRIBUTE));
}
}
wprintf(L"\n");
free(output_buffer);
}
// Let verify
wprintf(L"i\'s count = %u\n", i);
//======================
if(CloseHandle(hVolume) != 0)
wprintf(L"hVolume handle was closed successfully!\n");
else
{
wprintf(L"Failed to close hVolume handle!\n");
ErrorMessage(GetLastError());
}
// De-allocate the memory by malloc()
//free(output_buffer);
//free(pfile_info);
_CrtDumpMemoryLeaks();
return 0;
}
