Boolean shelf_push(int i, Boolean absolute, Boolean pushdir)
{
FilePtr file = dirFile(shelfdir, i);
String action;
char path1[MAXPATHLEN+1], path2[MAXPATHLEN+1];
root_modified = cur_modified = shelf_modified = cur_changed = False;
if (file)
if (!((action = push_action(fileType(file))) && *action) &&
S_ISDIR(fileStats(file)->st_mode)) {
return
cur_chdir(resolve(path1, pathname(path2, dirName(shelfdir),
fileName(file))));
} else {
Boolean ret =
filePush(shelfdir, i,
(pushdir && (fileStats(file)->st_mode &
(S_IXUSR | S_IXGRP | S_IXOTH)))?
dirName(curdir):NULL, absolute, True);
update();
return ret;
}
else
return False;
}
static Boolean dir_is_drop_target(DirPtr dir, int i)
{
FilePtr file = dirFile(dir, i);
String action = drop_action(fileType(file));
return i == NONE || file &&
(action && *action ||
S_ISDIR(fileStats(file)->st_mode) ||
(fileStats(file)->st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)));
}
//////////////////////////////////////////////////////////////////////////
// updateFileMonitoring
void FsCoreImplHTML5::updateFileMonitoring()
{
std::lock_guard< std::mutex > Lock( FileMonitorLock_ );
// Check 1 file per update to prevent slowdown.
if( FileMonitorMapIterator_ == FileMonitorMap_.end() )
{
FileMonitorMapIterator_ = FileMonitorMap_.begin();
}
else
{
// Grab file stats.
const std::string& FileName = (*FileMonitorMapIterator_).first;
FsStats& OldFileStats = (*FileMonitorMapIterator_).second;
FsStats NewFileStats;
if( fileStats( FileName.c_str(), NewFileStats ) )
{
// Compare timestamps.
if( NewFileStats.ModifiedTime_ != OldFileStats.ModifiedTime_ )
{
// Publish message that file has changed/been created.
if( OldFileStats.ModifiedTime_.isNull() == BcTrue )
{
PSY_LOG( "FsCoreImplHTML5: File created: %s\n", FileName.c_str() );
EvtPublisher::publish( fsEVT_MONITOR_CREATED, FsEventMonitor( FileName.c_str(), OldFileStats, NewFileStats ) );
}
else
{
PSY_LOG( "FsCoreImplHTML5: File modified: %s\n", FileName.c_str() );
EvtPublisher::publish( fsEVT_MONITOR_MODIFIED, FsEventMonitor( FileName.c_str(), OldFileStats, NewFileStats ) );
}
}
}
else
{
// Publish message that file has been deleted.
if( OldFileStats.ModifiedTime_.isNull() == BcFalse )
{
PSY_LOG( "FsCoreImplHTML5: File deleted: %s\n", FileName.c_str() );
EvtPublisher::publish( fsEVT_MONITOR_DELETED, FsEventMonitor( FileName.c_str(), OldFileStats, NewFileStats ) );
}
}
// Store new stats.
OldFileStats = NewFileStats;
// Advance to next file.
++FileMonitorMapIterator_;
}
}
Boolean cur_drop(int i, int op, SelPtr sel, Boolean absolute,
Boolean dirtarget)
{
Boolean ret;
FilePtr file = dirFile(curdir, i);
String action;
char path[MAXPATHLEN+1];
if (i != NONE)
if (!((action = drop_action(fileType(file))) && *action) &&
S_ISDIR(fileStats(file)->st_mode))
ret = fileMov(op)(sel, pathname(path, dirName(curdir),
fileName(file)), absolute);
else
ret = fileDrop(curdir, i, sel, absolute, dirtarget, False);
else
ret = fileMov(op)(sel, dirName(curdir), absolute);
update();
return ret;
}
Boolean cur_push(int i, Boolean absolute, Boolean pushdir)
{
FilePtr file = dirFile(curdir, i);
String action;
char path1[MAXPATHLEN+1], path2[MAXPATHLEN+1];
root_modified = cur_modified = shelf_modified = cur_changed = False;
if (file)
if (!((action = push_action(fileType(file))) && *action) &&
S_ISDIR(fileStats(file)->st_mode)) {
return
cur_chdir(shortestpath(path1, pathname(path2, dirName(curdir),
fileName(file))));
} else {
Boolean ret = filePush(curdir, i, NULL, absolute, False);
update();
return ret;
}
else
return False;
}
//////////////////////////////////////////////////////////////////////////
// addFileMonitor
void FsCoreImplHTML5::addFileMonitor( const BcChar* pFilename )
{
std::lock_guard< std::mutex > Lock( FileMonitorLock_ );
// Attempt to find it.
TFileMonitorMapIterator FoundIter = FileMonitorMap_.find( pFilename );
if( FoundIter == FileMonitorMap_.end() )
{
FsStats FileStats;
// Try to get stats, and add file.
if( fileStats( pFilename, FileStats ) )
{
// Add to monitor list.
FileMonitorMap_[ pFilename ] = FileStats;
// Reset monitor iterator.
FileMonitorMapIterator_ = FileMonitorMap_.begin();
}
}
}
bool fileExist(const String name)
{
spiffs_stat stat = {0};
if (fileStats(name.c_str(), &stat) < 0) return false;
return stat.name[0] != '\0';
}
String FileStream::fileName()
{
spiffs_stat stat;
fileStats(handle, &stat);
return String((char*)stat.name);
}
STDMETHODIMP GuestSessionEventListener::HandleEvent(VBoxEventType_T aType, IEvent *aEvent)
{
switch (aType)
{
case VBoxEventType_OnGuestFileRegistered:
{
HRESULT rc;
do
{
ComPtr<IGuestFileRegisteredEvent> pEvent = aEvent;
Assert(!pEvent.isNull());
ComPtr<IGuestFile> pFile;
CHECK_ERROR_BREAK(pEvent, COMGETTER(File)(pFile.asOutParam()));
AssertBreak(!pFile.isNull());
BOOL fRegistered;
CHECK_ERROR_BREAK(pEvent, COMGETTER(Registered)(&fRegistered));
Bstr strPath;
CHECK_ERROR_BREAK(pFile, COMGETTER(FileName)(strPath.asOutParam()));
RTPrintf("File \"%s\" %s\n",
Utf8Str(strPath).c_str(),
fRegistered ? "registered" : "unregistered");
if (fRegistered)
{
if (mfVerbose)
RTPrintf("Registering ...\n");
/* Register for IGuestFile events. */
ComObjPtr<GuestFileEventListenerImpl> pListener;
pListener.createObject();
CHECK_ERROR_BREAK(pListener, init(new GuestFileEventListener()));
ComPtr<IEventSource> es;
CHECK_ERROR_BREAK(pFile, COMGETTER(EventSource)(es.asOutParam()));
com::SafeArray<VBoxEventType_T> eventTypes;
eventTypes.push_back(VBoxEventType_OnGuestFileStateChanged);
CHECK_ERROR_BREAK(es, RegisterListener(pListener, ComSafeArrayAsInParam(eventTypes),
true /* Active listener */));
GuestFileStats fileStats(pListener);
mFiles[pFile] = fileStats;
}
else
{
GuestEventFiles::iterator itFile = mFiles.find(pFile);
if (itFile != mFiles.end())
{
if (mfVerbose)
RTPrintf("Unregistering file ...\n");
if (!itFile->first.isNull())
{
/* Listener unregistration. */
ComPtr<IEventSource> pES;
CHECK_ERROR(itFile->first, COMGETTER(EventSource)(pES.asOutParam()));
if (!pES.isNull())
CHECK_ERROR(pES, UnregisterListener(itFile->second.mListener));
itFile->first->Release();
}
mFiles.erase(itFile);
}
}
} while (0);
break;
}
case VBoxEventType_OnGuestProcessRegistered:
{
HRESULT rc;
do
{
ComPtr<IGuestProcessRegisteredEvent> pEvent = aEvent;
Assert(!pEvent.isNull());
ComPtr<IGuestProcess> pProcess;
CHECK_ERROR_BREAK(pEvent, COMGETTER(Process)(pProcess.asOutParam()));
AssertBreak(!pProcess.isNull());
BOOL fRegistered;
CHECK_ERROR_BREAK(pEvent, COMGETTER(Registered)(&fRegistered));
Bstr strPath;
CHECK_ERROR_BREAK(pProcess, COMGETTER(ExecutablePath)(strPath.asOutParam()));
RTPrintf("Process \"%s\" %s\n",
Utf8Str(strPath).c_str(),
fRegistered ? "registered" : "unregistered");
if (fRegistered)
{
if (mfVerbose)
RTPrintf("Registering ...\n");
/* Register for IGuestProcess events. */
ComObjPtr<GuestProcessEventListenerImpl> pListener;
pListener.createObject();
CHECK_ERROR_BREAK(pListener, init(new GuestProcessEventListener()));
ComPtr<IEventSource> es;
CHECK_ERROR_BREAK(pProcess, COMGETTER(EventSource)(es.asOutParam()));
com::SafeArray<VBoxEventType_T> eventTypes;
eventTypes.push_back(VBoxEventType_OnGuestProcessStateChanged);
CHECK_ERROR_BREAK(es, RegisterListener(pListener, ComSafeArrayAsInParam(eventTypes),
true /* Active listener */));
GuestProcStats procStats(pListener);
mProcs[pProcess] = procStats;
}
else
{
GuestEventProcs::iterator itProc = mProcs.find(pProcess);
if (itProc != mProcs.end())
{
if (mfVerbose)
RTPrintf("Unregistering process ...\n");
if (!itProc->first.isNull())
{
/* Listener unregistration. */
ComPtr<IEventSource> pES;
CHECK_ERROR(itProc->first, COMGETTER(EventSource)(pES.asOutParam()));
if (!pES.isNull())
CHECK_ERROR(pES, UnregisterListener(itProc->second.mListener));
itProc->first->Release();
}
mProcs.erase(itProc);
}
}
} while (0);
break;
}
case VBoxEventType_OnGuestSessionStateChanged:
{
HRESULT rc;
do
{
ComPtr<IGuestSessionStateChangedEvent> pEvent = aEvent;
Assert(!pEvent.isNull());
ComPtr<IGuestSession> pSession;
CHECK_ERROR_BREAK(pEvent, COMGETTER(Session)(pSession.asOutParam()));
AssertBreak(!pSession.isNull());
GuestSessionStatus_T sessSts;
CHECK_ERROR_BREAK(pSession, COMGETTER(Status)(&sessSts));
ULONG uID;
CHECK_ERROR_BREAK(pSession, COMGETTER(Id)(&uID));
Bstr strName;
CHECK_ERROR_BREAK(pSession, COMGETTER(Name)(strName.asOutParam()));
RTPrintf("Session ID=%RU32 \"%s\" changed status to [%s]\n",
uID, Utf8Str(strName).c_str(), gctlGuestSessionStatusToText(sessSts));
} while (0);
break;
}
default:
AssertFailed();
}
return S_OK;
}
