void WidgetCheckInstallationFromFolder::execute() { QString filePath = m_WidgetInfo[ EPropertyFilePath ].toString(); if ( !( QFileInfo(filePath).isFile() ) ) { RProcess me; TUidType uidType(me.Type()); TUint32 uid3 = uidType[2].iUid; if (uid3 != BackupRestoreUid && uid3 != MediaManagerUid) { emit aborted( EErrorPermissionDenied ); return; } } emit completed(); return; }
void CSetClientUid::PerformAction(TRequestStatus& aStatus) { switch (iState) { case EMain: { RProcess thisProcess; thisProcess.Open(thisProcess.Id()); CleanupClosePushL(thisProcess); TUidType type = thisProcess.Type(); TUidType newType(type[0], type[1], iUid); thisProcess.SetType(newType); CleanupStack::PopAndDestroy(); // thisProcess iState = EFinished; TRequestStatus* status = &aStatus; User::RequestComplete(status, KErrNone); break; } case EFinished: { TRequestStatus* status = &aStatus; User::RequestComplete(status, aStatus.Int()); if (aStatus == iExpectedResult) { iResult = ETrue; } else { iResult = EFalse; } iActionState = EPostrequisite; } break; } }
TVerdict CFindRunningExe::doTestStepL() { TInt uidValue; _LIT(KUidKey, "uid"); if (!GetHexFromConfig(ConfigSection(), KUidKey, uidValue)) { ERR_PRINTF1(_L("Cannot read UID from config section.")); SetTestStepResult(EFail); return EFail; } TUid exeUid; exeUid.iUid = uidValue; SetTestStepResult(EFail); TInt loop=0; for(;(loop < 20)&&(TestStepResult() == EFail);loop++) { TFindProcess findProcess; TFullName fullName; while((findProcess.Next(fullName) == KErrNone) && (TestStepResult() == EFail)) { RProcess process; TInt ret=KErrNone; TInt count=0; do { count++; ret=process.Open(findProcess); if (ret!=KErrNone) { User::After(200000); } }while (ret!=KErrNone && count<=10); if (ret!=KErrNone) { User::Leave(ret); } TUidType uid = process.Type(); TExitType exitType = process.ExitType(); process.Close(); if(uid[2] == exeUid) { if (exitType == EExitPending) SetTestStepResult(EPass); } } User::After(1000000); } if (TestStepResult() == EPass) { INFO_PRINTF2(_L("Process with UID 0x%x running."), exeUid.iUid); } else { ERR_PRINTF2(_L("No process with UID 0x%x running."), exeUid.iUid); } return TestStepResult(); }
void CTestStepESockSSA::KillC32Start() { // Start by looking for the running configurator and kill it if found. The caller // needs the appropriate capability to do this RDebug::Printf("Finding existing configurator process."); _LIT(KC32StartName, "*"); TInt result; TBool configuratorWasPresent; TInt count = 0; const TInt KMaxKillRetry = 10; do { configuratorWasPresent = EFalse; TFullName fn; TFindProcess fp(KC32StartName); while(fp.Next(fn) == KErrNone) { RProcess proc; result = proc.Open(fn); if(result == KErrNone) { TUidType type = proc.Type(); if(type[2] == TUid::Uid(KUidC32StartProcess) && proc.ExitType() == EExitPending) { // Kill the existing configurator process. RDebug::Print(_L("Opened existing configurator process \"%S\""), &fn); TRequestStatus status; proc.Logon(status); proc.Kill(KErrNone); RDebug::Printf("Killed process."); User::WaitForRequest(status); TExitType exitType = proc.ExitType(); // Create a timer in case some other entity holds an open handle on the // configurator which prevents the kernel from destroying it. We timeout // after one second. TAutoClose<RTimer> timer; if(timer.iObj.CreateLocal() == KErrNone) { // Request destruction notification so we know when it is safe to start // the process again. TRequestStatus destructionStatus; proc.NotifyDestruction(destructionStatus); proc.Close(); enum{ KProcessDestructionTimeout = 1000000 }; TRequestStatus timerStatus; timer.iObj.After(timerStatus, KProcessDestructionTimeout); // Wait for the process to be destroyed or for the timeout. User::WaitForRequest(destructionStatus, timerStatus); if(timerStatus.Int() == KRequestPending) { timer.iObj.Cancel(); User::WaitForRequest(timerStatus); } else { User::CancelMiscNotifier(destructionStatus); User::WaitForRequest(destructionStatus); RDebug::Printf("Existing configurator process has still not been destroyed after %f.0s", KProcessDestructionTimeout / 1000000.0); } } else { proc.Close(); } RDebug::Printf("Process logon completed with %d, exitType %d", status.Int(), exitType); configuratorWasPresent = ETrue; } else { proc.Close(); } } } } while(configuratorWasPresent && ++count < KMaxKillRetry); if (count >= KMaxKillRetry) { RDebug::Printf("KillC32Start - Cannot kill the configurator process, we will try continue and hope all is well"); } // Restart the boot sequence from scratch - the configurator reads this. RProperty::Set(KUidSystemCategory, KUidC32StartPropertyKey.iUid, EReset); }
static bool processIconL(TInt32 uid, QString& newIconPath, const QString& path, const QString& basePath) { LOG("processIconL path" << path); LOG("processIconL basePath " << basePath); // this should never happen as there is usually at least // the default icon path here if (path.isEmpty()) return false; // 3 cases here for widget icon: // 1: default icon (i.e. QT_DEFAULT_ICON) // 2: an image file // 3: svg(z) image file // generate icon path newIconPath = basePath; if (!basePath.endsWith(QDir::separator())) newIconPath.append(QDir::separator()); #ifdef QTWRT_USE_USIF newIconPath.append('[' + QString::number( uid, 16 ) + "].png"); #else newIconPath.append('[' + QString::number( uid, 16 ) + "].mbm"); #endif LOG("processIconL newIconPath" << newIconPath << QFile::exists(newIconPath)); QDir dir = QDir::root(); dir.mkpath(basePath); bool ret = false; QString srcPath = path; if (path == QT_DEFAULT_ICON) { srcPath = newIconPath + ".png"; if (QFile::exists(srcPath)) QFile::remove(srcPath); if (!QFile::copy(path, srcPath)) return false; // when default icon file is read only, so changing the attribute of copied icon file // so that, it can be writable otherwise it may cause problems while deleting/cleanup if (!QFile::setPermissions(srcPath, QFile::WriteOwner)) return false; } RProcess myUID; TUidType uidType(myUID.Type()); TUint32 processuid = uidType[2].iUid; if ((processuid == BACKUP_RESTORE_UID || processuid == MEDIA_MANAGER_UID) && QFile::exists(newIconPath)) { // skip the convertion since the file is good LOG("processIconL skipping conversion"); ret = true; } else { // try to convert the image into symbian specific format QEventLoop* loop = new QEventLoop(); IconConverterWrapper* iconConverter = new IconConverterWrapper(loop); #ifdef QTWRT_USE_USIF // if the destination icon already exists, remove it if (QFile::exists(newIconPath)) QFile::remove(newIconPath); if (srcPath.endsWith(QLatin1String(".png"), Qt::CaseInsensitive) && QFile::copy(srcPath, newIconPath)) ret = true; #else if (iconConverter && iconConverter->Init(srcPath, newIconPath)) { loop->exec(); ret = true; } #endif if (!ret) { // if convert fails, check if the file was .svg ret = processOtherFormats( newIconPath, path, *iconConverter, loop ); } delete iconConverter; delete loop; } return ret; }