void readFile()
{
int rsize = 0;
if ((strnicmp( filename.c_str(), "cdrom0:", strlen("cdromN:")) == 0) ||
(strnicmp( filename.c_str(), "cdrom1:", strlen("cdromN:")) == 0))
{
int fi;
fi = CDVDFS_open(filename.c_str() + strlen("cdromN:"), 1);//RDONLY
if (fi < 0)
throw Exception::FileNotFound( filename );
CDVDFS_lseek( fi, 0, SEEK_SET );
rsize = CDVDFS_read( fi, (char*)data.GetPtr(), data.GetSizeInBytes() );
CDVDFS_close( fi );
}
else
{
FILE *f;
f = fopen( filename.c_str(), "rb" );
if( f == NULL )
Exception::FileNotFound( filename );
fseek( f, 0, SEEK_SET );
rsize = fread( data.GetPtr(), 1, data.GetSizeInBytes(), f );
fclose( f );
}
if( rsize < data.GetSizeInBytes() )
throw Exception::EndOfStream( filename );
}
void loadProgramHeaders()
{
if ( proghead == NULL )
return;
for( int i = 0 ; i < header.e_phnum ; i++ )
{
ELF_LOG( "Elf32 Program Header\n" );
ELF_LOG( "type: " );
switch ( proghead[ i ].p_type ) {
default:
ELF_LOG( "unknown %x", (int)proghead[ i ].p_type );
break;
case 0x1:
{
ELF_LOG("load");
const uint elfsize = data.GetLength();
if (proghead[ i ].p_offset < elfsize) {
int size;
if ((proghead[ i ].p_filesz + proghead[ i ].p_offset) > elfsize)
size = elfsize - proghead[ i ].p_offset;
else
size = proghead[ i ].p_filesz;
if( proghead[ i ].p_vaddr != proghead[ i ].p_paddr )
Console::Notice( "ElfProgram different load addrs: paddr=0x%8.8x, vaddr=0x%8.8x", params
proghead[ i ].p_paddr, proghead[ i ].p_vaddr);
// used to be paddr
memcpy(
&PS2MEM_BASE[proghead[ i ].p_vaddr & 0x1ffffff],
data.GetPtr(proghead[ i ].p_offset), size
);
ELF_LOG("\t*LOADED*");
}
}
break;
}
ELF_LOG("\n");
ELF_LOG("offset: %08x\n",(int)proghead[i].p_offset);
ELF_LOG("vaddr: %08x\n",(int)proghead[i].p_vaddr);
ELF_LOG("paddr: %08x\n",proghead[i].p_paddr);
ELF_LOG("file size: %08x\n",proghead[i].p_filesz);
ELF_LOG("mem size: %08x\n",proghead[i].p_memsz);
ELF_LOG("flags: %08x\n",proghead[i].p_flags);
ELF_LOG("palign: %08x\n",proghead[i].p_align);
ELF_LOG("\n");
}
}
u32 GetCRC() const
{
u32 CRC = 0;
const u32* srcdata = (u32*)data.GetPtr();
for(u32 i=data.GetSizeInBytes()/4; i; --i, ++srcdata)
CRC ^= *srcdata;
return CRC;
}
/**
* List machine groups.
*
* @returns See produceList.
* @param pVirtualBox Reference to the IVirtualBox smart pointer.
*/
static HRESULT listGroups(const ComPtr<IVirtualBox> &pVirtualBox)
{
SafeArray<BSTR> groups;
CHECK_ERROR2_RET(pVirtualBox, COMGETTER(MachineGroups)(ComSafeArrayAsOutParam(groups)), hrcCheck);
for (size_t i = 0; i < groups.size(); i++)
{
RTPrintf("\"%ls\"\n", groups[i]);
}
return S_OK;
}
Void SafeArray::MoveFrom(SafeArray& other)
{
if (this != &other)
{
Attach(other.Detach());
}
}
s32 FileMemoryCard::Save( uint slot, const u8 *src, u32 adr, int size )
{
wxFFile& mcfp( m_file[slot] );
if( !mcfp.IsOpened() )
{
DevCon.Error( "(FileMcd) Ignoring attempted save/write to disabled slot." );
return 1;
}
if(m_ispsx[slot])
{
m_currentdata.MakeRoomFor( size );
for (int i=0; i<size; i++) m_currentdata[i] = src[i];
}
else
{
if( !Seek(mcfp, adr) ) return 0;
m_currentdata.MakeRoomFor( size );
mcfp.Read( m_currentdata.GetPtr(), size);
for (int i=0; i<size; i++)
{
if ((m_currentdata[i] & src[i]) != src[i])
Console.Warning("(FileMcd) Warning: writing to uncleared data. (%d) [%08X]", slot, adr);
m_currentdata[i] &= src[i];
}
// Checksumness
{
if(adr == m_chkaddr)
Console.Warning("(FileMcd) Warning: checksum sector overwritten. (%d)", slot);
u64 *pdata = (u64*)&m_currentdata[0];
u32 loops = size / 8;
for(u32 i = 0; i < loops; i++)
m_chksum[slot] ^= pdata[i];
}
}
if( !Seek(mcfp, adr) ) return 0;
return mcfp.Write( m_currentdata.GetPtr(), size ) != 0;
}
int main() {
SafeArray arrs[] = {SafeArray(5), SafeArray(10), SafeArray(15)};
for(int i = 0; i < 3; i++) {
SafeArray *safeArray = arrs + i;
for(int j = 0; j < safeArray->length; j++) {
safeArray->set(j, (j + 1) * 10);
}
}
for(int i = 0; i < 3; i++) {
SafeArray *safeArray = arrs + i;
for(int j = 0; j < safeArray->length; j++) {
cout << safeArray->get(j) << " ";
}
cout << endl;
}
return 0;
}
HRESULT ExecuteScript(const wchar_t* scriptPath, const vector<wstring>& arguments)
{
// Transfer all arguments to CLR
//
SafeArray safeArray;
bstr_t bstrScriptPath = scriptPath;
safeArray.CreateVector(VT_BSTR, 0, (ULONG)arguments.size());
for (size_t i = 0; i < arguments.size(); i++)
{
// Intentionally allocating string because SafeArray will automatically dispose of it.
//
safeArray.PutElement((LONG)i, SysAllocString(arguments[i].c_str()));
}
// Execute script function
//
CHECKCOM(instance->ExecuteScript(bstrScriptPath, safeArray));
return S_OK;
}
int main()
{
SafeArray safe;
int num;
cout << "enter the number end with -1" << endl;
while (1)
{
cin >> num;
if (num < 0)
{ cout << "enter over" << endl;
break;
}
safe.setdate(num);
}
for (int i = 0; i < safe.getsize(); i++)
{
cout << safe.getdate(i) << endl;
}
system("pause");
return 0;
}
int handleGetExtraData(HandlerArg *a)
{
HRESULT rc = S_OK;
if (a->argc != 2)
return errorSyntax(USAGE_GETEXTRADATA, "Incorrect number of parameters");
/* global data? */
if (!strcmp(a->argv[0], "global"))
{
/* enumeration? */
if (!strcmp(a->argv[1], "enumerate"))
{
SafeArray<BSTR> aKeys;
CHECK_ERROR(a->virtualBox, GetExtraDataKeys(ComSafeArrayAsOutParam(aKeys)));
for (size_t i = 0;
i < aKeys.size();
++i)
{
Bstr bstrKey(aKeys[i]);
Bstr bstrValue;
CHECK_ERROR(a->virtualBox, GetExtraData(bstrKey.raw(),
bstrValue.asOutParam()));
RTPrintf("Key: %ls, Value: %ls\n", bstrKey.raw(), bstrValue.raw());
}
}
else
{
Bstr value;
CHECK_ERROR(a->virtualBox, GetExtraData(Bstr(a->argv[1]).raw(),
value.asOutParam()));
if (!value.isEmpty())
RTPrintf("Value: %ls\n", value.raw());
else
RTPrintf("No value set!\n");
}
}
else
{
ComPtr<IMachine> machine;
CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
machine.asOutParam()));
if (machine)
{
/* enumeration? */
if (!strcmp(a->argv[1], "enumerate"))
{
SafeArray<BSTR> aKeys;
CHECK_ERROR(machine, GetExtraDataKeys(ComSafeArrayAsOutParam(aKeys)));
for (size_t i = 0;
i < aKeys.size();
++i)
{
Bstr bstrKey(aKeys[i]);
Bstr bstrValue;
CHECK_ERROR(machine, GetExtraData(bstrKey.raw(),
bstrValue.asOutParam()));
RTPrintf("Key: %ls, Value: %ls\n", bstrKey.raw(), bstrValue.raw());
}
}
else
{
Bstr value;
CHECK_ERROR(machine, GetExtraData(Bstr(a->argv[1]).raw(),
value.asOutParam()));
if (!value.isEmpty())
RTPrintf("Value: %ls\n", value.raw());
else
RTPrintf("No value set!\n");
}
}
}
return SUCCEEDED(rc) ? 0 : 1;
}
s32 FileMemoryCard::Save( uint slot, const u8 *src, u32 adr, int size )
{
wxFFile& mcfp( m_file[slot] );
if( !mcfp.IsOpened() )
{
DevCon.Error( "(FileMcd) Ignoring attempted save/write to disabled slot." );
return 1;
}
if(m_ispsx[slot])
{
m_currentdata.MakeRoomFor( size );
for (int i=0; i<size; i++) m_currentdata[i] = src[i];
}
else
{
if( !Seek(mcfp, adr) ) return 0;
m_currentdata.MakeRoomFor( size );
mcfp.Read( m_currentdata.GetPtr(), size);
for (int i=0; i<size; i++)
{
if ((m_currentdata[i] & src[i]) != src[i])
Console.Warning("(FileMcd) Warning: writing to uncleared data. (%d) [%08X]", slot, adr);
m_currentdata[i] &= src[i];
}
// Checksumness
{
if(adr == m_chkaddr)
Console.Warning("(FileMcd) Warning: checksum sector overwritten. (%d)", slot);
u64 *pdata = (u64*)&m_currentdata[0];
u32 loops = size / 8;
for(u32 i = 0; i < loops; i++)
m_chksum[slot] ^= pdata[i];
}
}
if( !Seek(mcfp, adr) ) return 0;
int status = mcfp.Write( m_currentdata.GetPtr(), size );
if( status ) {
static auto last = std::chrono::time_point<std::chrono::system_clock>();
std::chrono::duration<float> elapsed = std::chrono::system_clock::now() - last;
if(elapsed > std::chrono::seconds(5)) {
wxString name, ext;
wxFileName::SplitPath(m_file[slot].GetName(), NULL, NULL, &name, &ext);
OSDlog( Color_StrongYellow, false, "Memory Card %s written.", (const char *)(name + "." + ext).c_str() );
last = std::chrono::system_clock::now();
}
return 1;
}
return 0;
}
int handleModifyHardDisk(HandlerArg *a)
{
HRESULT rc;
int vrc;
ComPtr<IMedium> hardDisk;
MediumType_T DiskType;
bool AutoReset = false;
SafeArray<BSTR> mediumPropNames;
SafeArray<BSTR> mediumPropValues;
bool fModifyDiskType = false;
bool fModifyAutoReset = false;
bool fModifyProperties = false;
bool fModifyCompact = false;
bool fModifyResize = false;
uint64_t cbResize = 0;
const char *FilenameOrUuid = NULL;
int c;
RTGETOPTUNION ValueUnion;
RTGETOPTSTATE GetState;
// start at 0 because main() has hacked both the argc and argv given to us
RTGetOptInit(&GetState, a->argc, a->argv, g_aModifyHardDiskOptions, RT_ELEMENTS(g_aModifyHardDiskOptions),
0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
while ((c = RTGetOpt(&GetState, &ValueUnion)))
{
switch (c)
{
case 't': // --type
vrc = parseDiskType(ValueUnion.psz, &DiskType);
if (RT_FAILURE(vrc))
return errorArgument("Invalid hard disk type '%s'", ValueUnion.psz);
fModifyDiskType = true;
break;
case 'z': // --autoreset
vrc = parseBool(ValueUnion.psz, &AutoReset);
if (RT_FAILURE(vrc))
return errorArgument("Invalid autoreset parameter '%s'", ValueUnion.psz);
fModifyAutoReset = true;
break;
case 'p': // --property
{
/* Parse 'name=value' */
char *pszProperty = RTStrDup(ValueUnion.psz);
if (pszProperty)
{
char *pDelimiter = strchr(pszProperty, '=');
if (pDelimiter)
{
*pDelimiter = '\0';
Bstr bstrName(pszProperty);
Bstr bstrValue(&pDelimiter[1]);
bstrName.detachTo(mediumPropNames.appendedRaw());
bstrValue.detachTo(mediumPropValues.appendedRaw());
fModifyProperties = true;
}
else
{
errorArgument("Invalid --property argument '%s'", ValueUnion.psz);
rc = E_FAIL;
}
RTStrFree(pszProperty);
}
else
{
RTStrmPrintf(g_pStdErr, "Error: Failed to allocate memory for medium property '%s'\n", ValueUnion.psz);
rc = E_FAIL;
}
break;
}
case 'c': // --compact
fModifyCompact = true;
break;
case 'r': // --resize
cbResize = ValueUnion.u64 * _1M;
fModifyResize = true;
break;
case 'R': // --resizebyte
cbResize = ValueUnion.u64;
fModifyResize = true;
break;
case VINF_GETOPT_NOT_OPTION:
if (!FilenameOrUuid)
FilenameOrUuid = ValueUnion.psz;
else
return errorSyntax(USAGE_MODIFYHD, "Invalid parameter '%s'", ValueUnion.psz);
break;
default:
if (c > 0)
{
if (RT_C_IS_PRINT(c))
return errorSyntax(USAGE_MODIFYHD, "Invalid option -%c", c);
else
return errorSyntax(USAGE_MODIFYHD, "Invalid option case %i", c);
}
else if (c == VERR_GETOPT_UNKNOWN_OPTION)
return errorSyntax(USAGE_MODIFYHD, "unknown option: %s\n", ValueUnion.psz);
else if (ValueUnion.pDef)
return errorSyntax(USAGE_MODIFYHD, "%s: %Rrs", ValueUnion.pDef->pszLong, c);
else
return errorSyntax(USAGE_MODIFYHD, "error: %Rrs", c);
}
}
if (!FilenameOrUuid)
return errorSyntax(USAGE_MODIFYHD, "Disk name or UUID required");
if (!fModifyDiskType && !fModifyAutoReset && !fModifyProperties && !fModifyCompact && !fModifyResize)
return errorSyntax(USAGE_MODIFYHD, "No operation specified");
/* Always open the medium if necessary, there is no other way. */
rc = openMedium(a, FilenameOrUuid, DeviceType_HardDisk,
AccessMode_ReadWrite, hardDisk,
false /* fForceNewUuidOnOpen */, false /* fSilent */);
if (FAILED(rc))
return 1;
if (hardDisk.isNull())
{
RTMsgError("Invalid hard disk reference, avoiding crash");
return 1;
}
if (fModifyDiskType)
{
MediumType_T hddType;
CHECK_ERROR(hardDisk, COMGETTER(Type)(&hddType));
if (hddType != DiskType)
CHECK_ERROR(hardDisk, COMSETTER(Type)(DiskType));
}
if (fModifyAutoReset)
{
CHECK_ERROR(hardDisk, COMSETTER(AutoReset)(AutoReset));
}
if (fModifyProperties)
{
CHECK_ERROR(hardDisk, SetProperties(ComSafeArrayAsInParam(mediumPropNames), ComSafeArrayAsInParam(mediumPropValues)));
}
if (fModifyCompact)
{
ComPtr<IProgress> progress;
CHECK_ERROR(hardDisk, Compact(progress.asOutParam()));
if (SUCCEEDED(rc))
rc = showProgress(progress);
if (FAILED(rc))
{
if (rc == E_NOTIMPL)
RTMsgError("Compact hard disk operation is not implemented!");
else if (rc == VBOX_E_NOT_SUPPORTED)
RTMsgError("Compact hard disk operation for this format is not implemented yet!");
else if (!progress.isNull())
CHECK_PROGRESS_ERROR(progress, ("Failed to compact hard disk"));
else
RTMsgError("Failed to compact hard disk!");
}
}
if (fModifyResize)
{
ComPtr<IProgress> progress;
CHECK_ERROR(hardDisk, Resize(cbResize, progress.asOutParam()));
if (SUCCEEDED(rc))
rc = showProgress(progress);
if (FAILED(rc))
{
if (rc == E_NOTIMPL)
RTMsgError("Resize hard disk operation is not implemented!");
else if (rc == VBOX_E_NOT_SUPPORTED)
RTMsgError("Resize hard disk operation for this format is not implemented yet!");
else
CHECK_PROGRESS_ERROR(progress, ("Failed to resize hard disk"));
}
}
return SUCCEEDED(rc) ? 0 : 1;
}
HRESULT Initialize(const wchar_t* csDebugScriptUI)
{
// We should figure out needed runtime version
//
CAutoComPtr<ICLRMetaHostPolicy> pClrHostPolicy;
CHECKCOM(CLRCreateInstance(
CLSID_CLRMetaHostPolicy,
IID_ICLRMetaHostPolicy,
(LPVOID*)&pClrHostPolicy));
wchar_t queriedRuntimeVersion[100] = { 0 };
DWORD length = sizeof(queriedRuntimeVersion) / sizeof(wchar_t);
CHECKCOM(pClrHostPolicy->GetRequestedRuntime(
METAHOST_POLICY_HIGHCOMPAT,
csDebugScriptUI,
nullptr,
queriedRuntimeVersion,
&length,
nullptr,
nullptr,
nullptr,
IID_PPV_ARGS(&runtimeInfo)));
// Set custom memory manager and start CLR
//
CHECKCOM(runtimeInfo->BindAsLegacyV2Runtime());
//CHECKCOM(runtimeInfo->SetDefaultStartupFlags(clrStartupFlags, nullptr));
CHECKCOM(runtimeInfo->GetInterface(CLSID_CLRRuntimeHost, IID_PPV_ARGS(&clrRuntimeHost)));
CHECKCOM(clrRuntimeHost->Start());
// Create a new AppDomain that will contain application configuration.
//
CAutoComPtr<IUnknown> appDomainSetupThunk;
CAutoComPtr<IAppDomainSetup> appDomainSetup;
CAutoComPtr<IUnknown> appDomainThunk;
CHECKCOM(runtimeInfo->GetInterface(CLSID_CorRuntimeHost, IID_PPV_ARGS(&corRuntimeHost)));
CHECKCOM(corRuntimeHost->CreateDomainSetup(&appDomainSetupThunk));
CHECKCOM(appDomainSetupThunk->QueryInterface(IID_PPV_ARGS(&appDomainSetup)));
CHECKCOM(corRuntimeHost->CreateDomainEx(L"MyDomain", appDomainSetup, nullptr, &appDomainThunk));
CHECKCOM(appDomainThunk->QueryInterface(IID_PPV_ARGS(&appDomain)));
// Load our assembly
//
CAutoComPtr<_Assembly> mscorlibAssembly;
CAutoComPtr<_Type> reflectionAssemblyType;
SafeArray loadFromArguments;
variant_t loadFromResult;
variant_t arg1(csDebugScriptUI);
loadFromArguments.CreateVector(VT_VARIANT, 0, 1);
loadFromArguments.PutElement(0, &arg1);
CHECKCOM(GetAssemblyFromAppDomain(appDomain, L"mscorlib", &mscorlibAssembly));
CHECKCOM(mscorlibAssembly->GetType_2(bstr_t(L"System.Reflection.Assembly"), &reflectionAssemblyType));
CHECKCOM(reflectionAssemblyType->InvokeMember_3(bstr_t(L"LoadFrom"), (BindingFlags)(BindingFlags_InvokeMethod | BindingFlags_Public | BindingFlags_Static), nullptr, variant_t(), loadFromArguments, &loadFromResult));
// Create our extension CLR instance
//
CAutoComPtr<_Assembly> assembly = (_Assembly*)(IDispatch*)loadFromResult;
variant_t variant;
CHECKCOM(assembly->CreateInstance_2(bstr_t(L"CsDebugScript.Executor"), true, &variant));
CHECKCOM(variant.punkVal->QueryInterface(&instance));
return S_OK;
}
memSavingState::memSavingState( SafeArray<u8>& save_to ) : memBaseStateInfo( save_to, _("Saving state to: ") )
{
save_to.ChunkSize = ReallocThreshold;
save_to.MakeRoomFor( MemoryBaseAllocSize );
}
int main(int argc, char *argv[])
{
/* Init the runtime without loading the support driver. */
RTR3InitExe(argc, &argv, 0);
RTTEST hTest;
RTEXITCODE rcExit = RTTestInitAndCreate("tstMediumLock", &hTest);
if (rcExit)
return rcExit;
RTTestBanner(hTest);
bool fComInit = false;
ComPtr<IVirtualBox> pVirtualBox;
char szPathTemp[RTPATH_MAX] = "";
ComPtr<IMedium> pMedium;
if (!RTTestSubErrorCount(hTest))
{
RTTestSub(hTest, "Constructing temp image name");
TEST_RT_SUCCESS(hTest, RTPathTemp(szPathTemp, sizeof(szPathTemp)), "temp directory");
RTUUID uuid;
RTUuidCreate(&uuid);
char szFile[50];
RTStrPrintf(szFile, sizeof(szFile), "%RTuuid.vdi", &uuid);
TEST_RT_SUCCESS(hTest, RTPathAppend(szPathTemp, sizeof(szPathTemp), szFile), "concatenate image name");
}
if (!RTTestSubErrorCount(hTest))
{
RTTestSub(hTest, "Initializing COM");
TEST_COM_SUCCESS(hTest, Initialize(), "init");
}
if (!RTTestSubErrorCount(hTest))
{
fComInit = true;
RTTestSub(hTest, "Getting VirtualBox reference");
TEST_COM_SUCCESS(hTest, pVirtualBox.createLocalObject(CLSID_VirtualBox), "vbox reference");
}
if (!RTTestSubErrorCount(hTest))
{
RTTestSub(hTest, "Creating temp hard disk medium");
TEST_COM_SUCCESS(hTest, pVirtualBox->CreateMedium(Bstr("VDI").raw(), Bstr(szPathTemp).raw(), AccessMode_ReadWrite, DeviceType_HardDisk, pMedium.asOutParam()), "create medium");
if (!pMedium.isNull())
{
ComPtr<IProgress> pProgress;
SafeArray<MediumVariant_T> variant;
variant.push_back(MediumVariant_Standard);
TEST_COM_SUCCESS(hTest, pMedium->CreateBaseStorage(_1M, ComSafeArrayAsInParam(variant), pProgress.asOutParam()), "create base storage");
if (!pProgress.isNull())
TEST_COM_SUCCESS(hTest, pProgress->WaitForCompletion(30000), "waiting for completion of create");
}
}
if (!RTTestSubErrorCount(hTest))
{
RTTestSub(hTest, "Write locks");
ComPtr<IToken> pToken1, pToken2;
MediumState_T mediumState = MediumState_NotCreated;
TEST_COM_SUCCESS(hTest, pMedium->COMGETTER(State)(&mediumState), "getting state");
if (mediumState != MediumState_Created)
RTTestFailed(hTest, "wrong medium state %d", mediumState);
TEST_COM_SUCCESS(hTest, pMedium->LockWrite(pToken1.asOutParam()), "write lock");
TEST_COM_SUCCESS(hTest, pMedium->COMGETTER(State)(&mediumState), "getting lock write state");
if (mediumState != MediumState_LockedWrite)
RTTestFailed(hTest, "wrong lock write medium state %d", mediumState);
TEST_COM_FAILURE(hTest, pMedium->LockWrite(pToken2.asOutParam()), "nested write lock succeeded");
if (!pToken2.isNull())
RTTestFailed(hTest, "pToken2 is not null");
TEST_COM_SUCCESS(hTest, pMedium->COMGETTER(State)(&mediumState), "getting after nested lock write state");
if (mediumState != MediumState_LockedWrite)
RTTestFailed(hTest, "wrong after nested lock write medium state %d", mediumState);
if (!pToken1.isNull())
TEST_COM_SUCCESS(hTest, pToken1->Abandon(), "write unlock");
else
RTTestFailed(hTest, "pToken1 is null");
TEST_COM_SUCCESS(hTest, pMedium->COMGETTER(State)(&mediumState), "getting unlock write state");
if (mediumState != MediumState_Created)
RTTestFailed(hTest, "wrong unlock write medium state %d", mediumState);
}
if (!RTTestSubErrorCount(hTest))
{
RTTestSub(hTest, "Read locks");
ComPtr<IToken> pToken1, pToken2;
MediumState_T mediumState = MediumState_NotCreated;
TEST_COM_SUCCESS(hTest, pMedium->COMGETTER(State)(&mediumState), "getting state");
if (mediumState != MediumState_Created)
RTTestFailed(hTest, "wrong medium state %d", mediumState);
TEST_COM_SUCCESS(hTest, pMedium->LockRead(pToken1.asOutParam()), "read lock");
TEST_COM_SUCCESS(hTest, pMedium->COMGETTER(State)(&mediumState), "getting lock read state");
if (mediumState != MediumState_LockedRead)
RTTestFailed(hTest, "wrong lock read medium state %d", mediumState);
TEST_COM_SUCCESS(hTest, pMedium->LockRead(pToken2.asOutParam()), "nested read lock failed");
TEST_COM_SUCCESS(hTest, pMedium->COMGETTER(State)(&mediumState), "getting after nested lock read state");
if (mediumState != MediumState_LockedRead)
RTTestFailed(hTest, "wrong after nested lock read medium state %d", mediumState);
if (!pToken2.isNull())
TEST_COM_SUCCESS(hTest, pToken2->Abandon(), "read nested unlock");
else
RTTestFailed(hTest, "pToken2 is null");
TEST_COM_SUCCESS(hTest, pMedium->COMGETTER(State)(&mediumState), "getting after nested lock read state");
if (mediumState != MediumState_LockedRead)
RTTestFailed(hTest, "wrong after nested lock read medium state %d", mediumState);
if (!pToken1.isNull())
TEST_COM_SUCCESS(hTest, pToken1->Abandon(), "read nested unlock");
else
RTTestFailed(hTest, "pToken1 is null");
TEST_COM_SUCCESS(hTest, pMedium->COMGETTER(State)(&mediumState), "getting unlock read state");
if (mediumState != MediumState_Created)
RTTestFailed(hTest, "wrong unlock read medium state %d", mediumState);
}
if (!RTTestSubErrorCount(hTest))
{
RTTestSub(hTest, "Mixing write and read locks");
ComPtr<IToken> pToken1, pToken2;
MediumState_T mediumState = MediumState_NotCreated;
TEST_COM_SUCCESS(hTest, pMedium->COMGETTER(State)(&mediumState), "getting state");
if (mediumState != MediumState_Created)
RTTestFailed(hTest, "wrong medium state %d", mediumState);
TEST_COM_SUCCESS(hTest, pMedium->LockWrite(pToken1.asOutParam()), "write lock");
TEST_COM_SUCCESS(hTest, pMedium->COMGETTER(State)(&mediumState), "getting lock write state");
if (mediumState != MediumState_LockedWrite)
RTTestFailed(hTest, "wrong lock write medium state %d", mediumState);
TEST_COM_FAILURE(hTest, pMedium->LockRead(pToken2.asOutParam()), "write+read lock succeeded");
if (!pToken2.isNull())
RTTestFailed(hTest, "pToken2 is not null");
TEST_COM_SUCCESS(hTest, pMedium->COMGETTER(State)(&mediumState), "getting after nested lock write state");
if (mediumState != MediumState_LockedWrite)
RTTestFailed(hTest, "wrong after nested lock write medium state %d", mediumState);
if (!pToken1.isNull())
TEST_COM_SUCCESS(hTest, pToken1->Abandon(), "write unlock");
else
RTTestFailed(hTest, "pToken1 is null");
TEST_COM_SUCCESS(hTest, pMedium->COMGETTER(State)(&mediumState), "getting unlock write state");
if (mediumState != MediumState_Created)
RTTestFailed(hTest, "wrong unlock write medium state %d", mediumState);
}
if (!RTTestSubErrorCount(hTest))
{
RTTestSub(hTest, "Mixing read and write locks");
ComPtr<IToken> pToken1, pToken2;
MediumState_T mediumState = MediumState_NotCreated;
TEST_COM_SUCCESS(hTest, pMedium->COMGETTER(State)(&mediumState), "getting state");
if (mediumState != MediumState_Created)
RTTestFailed(hTest, "wrong medium state %d", mediumState);
TEST_COM_SUCCESS(hTest, pMedium->LockRead(pToken1.asOutParam()), "read lock");
TEST_COM_SUCCESS(hTest, pMedium->COMGETTER(State)(&mediumState), "getting lock read state");
if (mediumState != MediumState_LockedRead)
RTTestFailed(hTest, "wrong lock read medium state %d", mediumState);
TEST_COM_FAILURE(hTest, pMedium->LockWrite(pToken2.asOutParam()), "read+write lock succeeded");
if (!pToken2.isNull())
RTTestFailed(hTest, "pToken2 is not null");
TEST_COM_SUCCESS(hTest, pMedium->COMGETTER(State)(&mediumState), "getting after nested lock read state");
if (mediumState != MediumState_LockedRead)
RTTestFailed(hTest, "wrong after nested lock read medium state %d", mediumState);
if (!pToken1.isNull())
TEST_COM_SUCCESS(hTest, pToken1->Abandon(), "read unlock");
else
RTTestFailed(hTest, "pToken1 is null");
TEST_COM_SUCCESS(hTest, pMedium->COMGETTER(State)(&mediumState), "getting unlock read state");
if (mediumState != MediumState_Created)
RTTestFailed(hTest, "wrong unlock read medium state %d", mediumState);
}
/* Cleanup, also part of the testcase */
if (!pMedium.isNull())
{
RTTestSub(hTest, "Closing medium");
MediumState_T mediumState = MediumState_NotCreated;
TEST_COM_SUCCESS(hTest, pMedium->COMGETTER(State)(&mediumState), "getting state");
if (mediumState == MediumState_Created)
{
ComPtr<IProgress> pProgress;
TEST_COM_SUCCESS(hTest, pMedium->DeleteStorage(pProgress.asOutParam()), "deleting storage");
if (!pProgress.isNull())
TEST_COM_SUCCESS(hTest, pProgress->WaitForCompletion(30000), "waiting for completion of delete");
}
TEST_COM_SUCCESS(hTest, pMedium->Close(), "closing");
pMedium.setNull();
}
pVirtualBox.setNull();
/* Make sure that there are no object references alive here, XPCOM does
* a very bad job at cleaning up such leftovers, spitting out warning
* messages in a debug build. */
if (fComInit)
{
RTTestIPrintf(RTTESTLVL_DEBUG, "Shutting down COM...\n");
Shutdown();
}
/*
* Summary.
*/
return RTTestSummaryAndDestroy(hTest);
}
HRESULT Guest::taskCopyFileFromGuest(GuestTask *aTask)
{
LogFlowFuncEnter();
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
/*
* Do *not* take a write lock here since we don't (and won't)
* touch any class-specific data (of IGuest) here - only the member functions
* which get called here can do that.
*/
HRESULT rc = S_OK;
try
{
ComObjPtr<Guest> pGuest = aTask->pGuest;
/* Does our source file exist? */
BOOL fFileExists;
rc = pGuest->FileExists(Bstr(aTask->strSource).raw(),
Bstr(aTask->strUserName).raw(), Bstr(aTask->strPassword).raw(),
&fFileExists);
if (SUCCEEDED(rc))
{
if (!fFileExists)
rc = GuestTask::setProgressErrorInfo(VBOX_E_IPRT_ERROR, aTask->pProgress,
Guest::tr("Source file \"%s\" does not exist, or is not a file"),
aTask->strSource.c_str());
}
else
rc = GuestTask::setProgressErrorInfo(rc, aTask->pProgress, pGuest);
/* Query file size to make an estimate for our progress object. */
if (SUCCEEDED(rc))
{
LONG64 lFileSize;
rc = pGuest->FileQuerySize(Bstr(aTask->strSource).raw(),
Bstr(aTask->strUserName).raw(), Bstr(aTask->strPassword).raw(),
&lFileSize);
if (FAILED(rc))
rc = GuestTask::setProgressErrorInfo(rc, aTask->pProgress, pGuest);
com::SafeArray<IN_BSTR> args;
com::SafeArray<IN_BSTR> env;
if (SUCCEEDED(rc))
{
/*
* Prepare tool command line.
*/
char szSource[RTPATH_MAX];
if (RTStrPrintf(szSource, sizeof(szSource), "%s", aTask->strSource.c_str()) <= sizeof(szSource) - 1)
{
/*
* Normalize path slashes, based on the detected guest.
*/
Utf8Str osType = mData.mOSTypeId;
if ( osType.contains("Microsoft", Utf8Str::CaseInsensitive)
|| osType.contains("Windows", Utf8Str::CaseInsensitive))
{
/* We have a Windows guest. */
RTPathChangeToDosSlashes(szSource, true /* Force conversion. */);
}
else /* ... or something which isn't from Redmond ... */
{
RTPathChangeToUnixSlashes(szSource, true /* Force conversion. */);
}
args.push_back(Bstr(szSource).raw()); /* Tell our cat tool which file to output. */
}
else
rc = GuestTask::setProgressErrorInfo(VBOX_E_IPRT_ERROR, aTask->pProgress,
Guest::tr("Error preparing command line"));
}
ComPtr<IProgress> execProgress;
ULONG uPID;
if (SUCCEEDED(rc))
{
LogRel(("Copying file \"%s\" to host \"%s\" (%u bytes) ...\n",
aTask->strSource.c_str(), aTask->strDest.c_str(), lFileSize));
/*
* Okay, since we gathered all stuff we need until now to start the
* actual copying, start the guest part now.
*/
rc = pGuest->executeAndWaitForTool(Bstr(VBOXSERVICE_TOOL_CAT).raw(),
Bstr("Copying file to host").raw(),
ComSafeArrayAsInParam(args),
ComSafeArrayAsInParam(env),
Bstr(aTask->strUserName).raw(),
Bstr(aTask->strPassword).raw(),
ExecuteProcessFlag_WaitForProcessStartOnly
| ExecuteProcessFlag_WaitForStdOut,
NULL, NULL,
execProgress.asOutParam(), &uPID);
if (FAILED(rc))
rc = GuestTask::setProgressErrorInfo(rc, aTask->pProgress, pGuest);
}
if (SUCCEEDED(rc))
{
BOOL fCompleted = FALSE;
BOOL fCanceled = FALSE;
RTFILE hFileDest;
int vrc = RTFileOpen(&hFileDest, aTask->strDest.c_str(),
RTFILE_O_WRITE | RTFILE_O_OPEN_CREATE | RTFILE_O_DENY_WRITE);
if (RT_FAILURE(vrc))
rc = GuestTask::setProgressErrorInfo(VBOX_E_IPRT_ERROR, aTask->pProgress,
Guest::tr("Unable to create/open destination file \"%s\", rc=%Rrc"),
aTask->strDest.c_str(), vrc);
else
{
size_t cbToRead = lFileSize;
size_t cbTransfered = 0;
while ( SUCCEEDED(execProgress->COMGETTER(Completed(&fCompleted)))
&& !fCompleted)
{
SafeArray<BYTE> aOutputData;
rc = pGuest->GetProcessOutput(uPID, ProcessOutputFlag_None /* StdOut */,
0 /* No timeout. */,
_64K, ComSafeArrayAsOutParam(aOutputData));
if (SUCCEEDED(rc))
{
if (aOutputData.size())
{
vrc = RTFileWrite(hFileDest, aOutputData.raw(), aOutputData.size(), NULL /* No partial writes */);
if (RT_FAILURE(vrc))
{
rc = GuestTask::setProgressErrorInfo(VBOX_E_IPRT_ERROR, aTask->pProgress,
Guest::tr("Error writing to file \"%s\" (%u bytes left), rc=%Rrc"),
aTask->strSource.c_str(), cbToRead, vrc);
break;
}
Assert(cbToRead >= aOutputData.size());
cbToRead -= aOutputData.size();
cbTransfered += aOutputData.size();
aTask->pProgress->SetCurrentOperationProgress(cbTransfered / (lFileSize / 100.0));
}
/* Nothing read this time; try next round. */
}
else
{
rc = GuestTask::setProgressErrorInfo(rc, aTask->pProgress, pGuest);
break;
}
}
RTFileClose(hFileDest);
if (SUCCEEDED(rc))
{
if ( cbTransfered
&& (cbTransfered != lFileSize))
{
/*
* Only bitch about an unexpected end of a file when there already
* was data read from that file. If this was the very first read we can
* be (almost) sure that this file is not meant to be read by the specified user.
*/
rc = GuestTask::setProgressErrorInfo(VBOX_E_IPRT_ERROR, aTask->pProgress,
Guest::tr("Unexpected end of file \"%s\" (%u bytes total, %u bytes transferred)"),
aTask->strSource.c_str(), lFileSize, cbTransfered);
}
if (SUCCEEDED(rc))
aTask->pProgress->notifyComplete(S_OK);
}
}
}
}
}
catch (HRESULT aRC)
{
rc = aRC;
}
/* Clean up */
aTask->rc = rc;
LogFlowFunc(("rc=%Rhrc\n", rc));
LogFlowFuncLeave();
return VINF_SUCCESS;
}
ElfObject( const string& srcfile, uint hdrsize ) :
filename( srcfile )
, data( hdrsize, "ELF headers" )
, header( *(ELF_HEADER*)data.GetPtr() )
, proghead( NULL )
, secthead( NULL )
{
readFile();
if( header.e_phnum > 0 )
proghead = (ELF_PHR*)&data[header.e_phoff];
if( header.e_shnum > 0 )
secthead = (ELF_SHR*)&data[header.e_shoff];
if ( ( header.e_shnum > 0 ) && ( header.e_shentsize != sizeof(ELF_SHR) ) )
Console::Error( "ElfLoader Warning > Size of section headers is not standard" );
if ( ( header.e_phnum > 0 ) && ( header.e_phentsize != sizeof(ELF_PHR) ) )
Console::Error( "ElfLoader Warning > Size of program headers is not standard" );
ELF_LOG( "type: " );
switch( header.e_type )
{
default:
ELF_LOG( "unknown %x", header.e_type );
break;
case 0x0:
ELF_LOG( "no file type" );
break;
case 0x1:
ELF_LOG( "relocatable" );
break;
case 0x2:
ELF_LOG( "executable" );
break;
}
ELF_LOG( "\n" );
ELF_LOG( "machine: " );
switch ( header.e_machine )
{
default:
ELF_LOG( "unknown" );
break;
case 0x8:
ELF_LOG( "mips_rs3000" );
break;
}
ELF_LOG("\n");
ELF_LOG("version: %d\n",header.e_version);
ELF_LOG("entry: %08x\n",header.e_entry);
ELF_LOG("flags: %08x\n",header.e_flags);
ELF_LOG("eh size: %08x\n",header.e_ehsize);
ELF_LOG("ph off: %08x\n",header.e_phoff);
ELF_LOG("ph entsiz: %08x\n",header.e_phentsize);
ELF_LOG("ph num: %08x\n",header.e_phnum);
ELF_LOG("sh off: %08x\n",header.e_shoff);
ELF_LOG("sh entsiz: %08x\n",header.e_shentsize);
ELF_LOG("sh num: %08x\n",header.e_shnum);
ELF_LOG("sh strndx: %08x\n",header.e_shstrndx);
ELF_LOG("\n");
}
void loadSectionHeaders()
{
if( secthead == NULL || header.e_shoff > (u32)data.GetLength() )
return;
const u8* sections_names = data.GetPtr( secthead[ (header.e_shstrndx == 0xffff ? 0 : header.e_shstrndx) ].sh_offset );
int i_st = -1;
int i_dt = -1;
for( int i = 0 ; i < header.e_shnum ; i++ )
{
ELF_LOG( "Elf32 Section Header [%x] %s", i, §ions_names[ secthead[ i ].sh_name ] );
if ( secthead[i].sh_flags & 0x2 )
args_ptr = min( args_ptr, secthead[ i ].sh_addr & 0x1ffffff );
#ifdef PCSX2_DEVBULD
ELF_LOG("\n");
ELF_LOG("type: ");
switch ( secthead[ i ].sh_type )
{
default:
ELF_LOG("unknown %08x",secthead[i].sh_type);
break;
case 0x0:
ELF_LOG("null");
break;
case 0x1:
ELF_LOG("progbits");
break;
case 0x2:
ELF_LOG("symtab");
break;
case 0x3:
ELF_LOG("strtab");
break;
case 0x4:
ELF_LOG("rela");
break;
case 0x8:
ELF_LOG("no bits");
break;
case 0x9:
ELF_LOG("rel");
break;
}
ELF_LOG("\n");
ELF_LOG("flags: %08x\n", secthead[i].sh_flags);
ELF_LOG("addr: %08x\n", secthead[i].sh_addr);
ELF_LOG("offset: %08x\n", secthead[i].sh_offset);
ELF_LOG("size: %08x\n", secthead[i].sh_size);
ELF_LOG("link: %08x\n", secthead[i].sh_link);
ELF_LOG("info: %08x\n", secthead[i].sh_info);
ELF_LOG("addralign: %08x\n", secthead[i].sh_addralign);
ELF_LOG("entsize: %08x\n", secthead[i].sh_entsize);
// dump symbol table
if( secthead[ i ].sh_type == 0x02 )
{
i_st = i;
i_dt = secthead[i].sh_link;
}
#endif
}
if( ( i_st >= 0 ) && ( i_dt >= 0 ) )
{
const char * SymNames;
Elf32_Sym * eS;
SymNames = (char*)data.GetPtr( secthead[ i_dt ].sh_offset );
eS = (Elf32_Sym*)data.GetPtr( secthead[ i_st ].sh_offset );
Console::WriteLn("found %d symbols", params secthead[ i_st ].sh_size / sizeof( Elf32_Sym ));
for( uint i = 1; i < ( secthead[ i_st ].sh_size / sizeof( Elf32_Sym ) ); i++ ) {
if ( ( eS[ i ].st_value != 0 ) && ( ELF32_ST_TYPE( eS[ i ].st_info ) == 2 ) ) {
R5900::disR5900AddSym( eS[i].st_value, &SymNames[ eS[ i ].st_name ] );
}
}
}
}
void print(const SafeArray<T> &a) {
for(int i = 0; i < a.getSize(); ++i) {
cout << a[i] << " ";
}
cout << endl;
}