| -rw-r--r-- | microkde/kio/kio/kdirwatch.cpp | 1442 | ||||
| -rw-r--r-- | microkde/kio/kio/kdirwatch.h | 288 | ||||
| -rw-r--r-- | microkde/kio/kio/kdirwatch_p.h | 153 |
3 files changed, 1883 insertions, 0 deletions
diff --git a/microkde/kio/kio/kdirwatch.cpp b/microkde/kio/kio/kdirwatch.cpp new file mode 100644 index 0000000..98d24e0 --- a/dev/null +++ b/microkde/kio/kio/kdirwatch.cpp @@ -0,0 +1,1442 @@ +// -*- c-basic-offset: 2 -*- +/* This file is part of the KDE libraries + Copyright (C) 1998 Sven Radej <sven@lisa.exp.univie.ac.at> + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License version 2 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. +*/ + +/* +Enhanced Version of the file for platform independent KDE tools. +Copyright (c) 2004 Ulf Schenk + +$Id$ +*/ + + +// CHANGES: +// Februar 2002 - Add file watching and remote mount check for STAT +// Mar 30, 2001 - Native support for Linux dir change notification. +// Jan 28, 2000 - Usage of FAM service on IRIX (Josef.Weidendorfer@in.tum.de) +// May 24. 1998 - List of times introduced, and some bugs are fixed. (sven) +// May 23. 1998 - Removed static pointer - you can have more instances. +// It was Needed for KRegistry. KDirWatch now emits signals and doesn't +// call (or need) KFM. No more URL's - just plain paths. (sven) +// Mar 29. 1998 - added docs, stop/restart for particular Dirs and +// deep copies for list of dirs. (sven) +// Mar 28. 1998 - Created. (sven) + + +//US #include <config.h> + +#ifdef HAVE_DNOTIFY +#include <unistd.h> +#include <time.h> +#include <fcntl.h> +#include <signal.h> +#include <errno.h> +#endif + +#include <sys/stat.h> +#include <assert.h> +#include <qdir.h> +#include <qfile.h> +#include <qintdict.h> +#include <qptrlist.h> +#include <qsocketnotifier.h> +#include <qstringlist.h> +#include <qtimer.h> + +#include <kapplication.h> +#include <kdebug.h> +#include <kconfig.h> +#include <kconfigbase.h> +#include <kglobal.h> +#include <kstaticdeleter.h> + +#include "kdirwatch.h" +#include "kdirwatch_p.h" +//US #include "global.h" // KIO::probably_slow_mounted + +#define NO_NOTIFY (time_t) 0 + +static KDirWatchPrivate* dwp_self = 0; + +#ifdef HAVE_DNOTIFY + +#include <sys/utsname.h> + +static int dnotify_signal = 0; + +/* DNOTIFY signal handler + * + * As this is called asynchronously, only a flag is set and + * a rescan is requested. + * This is done by writing into a pipe to trigger a QSocketNotifier + * watching on this pipe: a timer is started and after a timeout, + * the rescan is done. + */ +void KDirWatchPrivate::dnotify_handler(int, siginfo_t *si, void *) +{ + // write might change errno, we have to save it and restore it + // (Richard Stevens, Advanced programming in the Unix Environment) + int saved_errno = errno; + + Entry* e = (dwp_self) ? dwp_self->fd_Entry.find(si->si_fd) :0; + +// kdDebug(7001) << "DNOTIFY Handler: fd " << si->si_fd << " path " +// << QString(e ? e->path:"unknown") << endl; + + if(!e || e->dn_fd != si->si_fd) { + qDebug("fatal error in KDirWatch"); + } else + e->dn_dirty = true; + + char c = 0; + write(dwp_self->mPipe[1], &c, 1); + errno = saved_errno; +} + +static struct sigaction old_sigio_act; +/* DNOTIFY SIGIO signal handler + * + * When the kernel queue for the dnotify_signal overflows, a SIGIO is send. + */ +void KDirWatchPrivate::dnotify_sigio_handler(int sig, siginfo_t *si, void *p) +{ + // write might change errno, we have to save it and restore it + // (Richard Stevens, Advanced programming in the Unix Environment) + int saved_errno = errno; + + if (dwp_self) + dwp_self->rescan_all = true; + + char c = 0; + write(dwp_self->mPipe[1], &c, 1); + + errno = saved_errno; + + // Call previous signal handler + if (old_sigio_act.sa_flags & SA_SIGINFO) + { + if (old_sigio_act.sa_sigaction) + (*old_sigio_act.sa_sigaction)(sig, si, p); + } + else + { + if ((old_sigio_act.sa_handler != SIG_DFL) && + (old_sigio_act.sa_handler != SIG_IGN)) + (*old_sigio_act.sa_handler)(sig); + } +} +#endif + + +// +// Class KDirWatchPrivate (singleton) +// + +/* All entries (files/directories) to be watched in the + * application (coming from multiple KDirWatch instances) + * are registered in a single KDirWatchPrivate instance. + * + * At the moment, the following methods for file watching + * are supported: + * - Polling: All files to be watched are polled regularly + * using stat (more precise: QFileInfo.lastModified()). + * The polling frequency is determined from global kconfig + * settings, defaulting to 500 ms for local directories + * and 5000 ms for remote mounts + * - FAM (File Alternation Monitor): first used on IRIX, SGI + * has ported this method to LINUX. It uses a kernel part + * (IMON, sending change events to /dev/imon) and a user + * level damon (fam), to which applications connect for + * notification of file changes. For NFS, the fam damon + * on the NFS server machine is used; if IMON is not built + * into the kernel, fam uses polling for local files. + * - DNOTIFY: In late LINUX 2.3.x, directory notification was + * introduced. By opening a directory, you can request for + * UNIX signals to be sent to the process when a directory + * is changed. + */ + +KDirWatchPrivate::KDirWatchPrivate() +{ + timer = new QTimer(this); + connect (timer, SIGNAL(timeout()), this, SLOT(slotRescan())); + freq = 3600000; // 1 hour as upper bound + statEntries = 0; + delayRemove = false; + m_ref = 0; + +//US KConfigGroup config(KGlobal::config(), QCString("DirWatch")); +//US m_nfsPollInterval = config.readNumEntry("NFSPollInterval", 5000); +//US m_PollInterval = config.readNumEntry("PollInterval", 500); + KConfig *config = KGlobal::config(); + KConfigGroupSaver saver( config, QCString("DirWatch") ); + + m_nfsPollInterval = config->readNumEntry("NFSPollInterval", 5000); + m_PollInterval = config->readNumEntry("PollInterval", 500); + + + QString available("Stat"); + +#ifdef HAVE_FAM + // It's possible that FAM server can't be started + if (FAMOpen(&fc) ==0) { + available += ", FAM"; + use_fam=true; + sn = new QSocketNotifier( FAMCONNECTION_GETFD(&fc), + QSocketNotifier::Read, this); + connect( sn, SIGNAL(activated(int)), + this, SLOT(famEventReceived()) ); + } + else { + kdDebug(7001) << "Can't use FAM (fam daemon not running?)" << endl; + use_fam=false; + } +#endif + +#ifdef HAVE_DNOTIFY + supports_dnotify = true; // not guilty until proven guilty + rescan_all = false; + struct utsname uts; + int major, minor, patch; + if (uname(&uts) < 0) + supports_dnotify = false; // *shrug* + else if (sscanf(uts.release, "%d.%d.%d", &major, &minor, &patch) != 3) + supports_dnotify = false; // *shrug* + else if( major * 1000000 + minor * 1000 + patch < 2004019 ) { // <2.4.19 + kdDebug(7001) << "Can't use DNotify, Linux kernel too old" << endl; + supports_dnotify = false; + } + + if( supports_dnotify ) { + available += ", DNotify"; + + pipe(mPipe); + fcntl(mPipe[0], F_SETFD, FD_CLOEXEC); + fcntl(mPipe[1], F_SETFD, FD_CLOEXEC); + mSn = new QSocketNotifier( mPipe[0], QSocketNotifier::Read, this); + connect(mSn, SIGNAL(activated(int)), this, SLOT(slotActivated())); + connect(&mTimer, SIGNAL(timeout()), this, SLOT(slotRescan())); + struct sigaction act; + act.sa_sigaction = KDirWatchPrivate::dnotify_handler; + sigemptyset(&act.sa_mask); + act.sa_flags = SA_SIGINFO; +#ifdef SA_RESTART + act.sa_flags |= SA_RESTART; +#endif + if( dnotify_signal == 0 ) + dnotify_signal = SIGRTMIN + 8; + sigaction(dnotify_signal, &act, NULL); + + act.sa_sigaction = KDirWatchPrivate::dnotify_sigio_handler; + sigaction(SIGIO, &act, &old_sigio_act); + } +#endif + + kdDebug(7001) << "Available methods: " << available << endl; +} + +/* This should never be called, but doesn't harm */ +KDirWatchPrivate::~KDirWatchPrivate() +{ + timer->stop(); + + /* remove all entries being watched */ + removeEntries(0); + +#ifdef HAVE_FAM + if (use_fam) { + FAMClose(&fc); + kdDebug(7001) << "KDirWatch deleted (FAM closed)" << endl; + } +#endif + +} + +#ifdef HAVE_DNOTIFY +void KDirWatchPrivate::slotActivated() +{ + char dummy_buf[100]; + read(mPipe[0], &dummy_buf, 100); + + if (!mTimer.isActive()) + mTimer.start(200, true); +} + +/* In DNOTIFY mode, only entries which are marked dirty are scanned. + * We first need to mark all yet nonexistant, but possible created + * entries as dirty... + */ +void KDirWatchPrivate::Entry::propagate_dirty() +{ + Entry* sub_entry; + for(sub_entry = m_entries.first(); sub_entry; sub_entry = m_entries.next()) + { + if (!sub_entry->dn_dirty) + { + sub_entry->dn_dirty = true; + sub_entry->propagate_dirty(); + } + } +} + +#else // !HAVE_DNOTIFY +// slots always have to be defined... +void KDirWatchPrivate::slotActivated() {} +#endif + +/* A KDirWatch instance is interested in getting events for + * this file/Dir entry. + */ +void KDirWatchPrivate::Entry::addClient(KDirWatch* instance) +{ + Client* client = m_clients.first(); + for(;client; client = m_clients.next()) + if (client->instance == instance) break; + + if (client) { + client->count++; + return; + } + + client = new Client; + client->instance = instance; + client->count = 1; + client->watchingStopped = instance->isStopped(); + client->pending = NoChange; + + m_clients.append(client); +} + +void KDirWatchPrivate::Entry::removeClient(KDirWatch* instance) +{ + Client* client = m_clients.first(); + for(;client; client = m_clients.next()) + if (client->instance == instance) break; + + if (client) { + client->count--; + if (client->count == 0) { + m_clients.removeRef(client); + delete client; + } + } +} + +/* get number of clients */ +int KDirWatchPrivate::Entry::clients() +{ + int clients = 0; + Client* client = m_clients.first(); + for(;client; client = m_clients.next()) + clients += client->count; + + return clients; +} + + +KDirWatchPrivate::Entry* KDirWatchPrivate::entry(const QString& _path) +{ +// we only support absolute paths + if (_path.left(1) != "/") { + return 0; + } + + QString path = _path; + + if ( path.length() > 1 && path.right(1) == "/" ) + path.truncate( path.length() - 1 ); + + EntryMap::Iterator it = m_mapEntries.find( path ); + if ( it == m_mapEntries.end() ) + return 0; + else + return &(*it); +} + +// set polling frequency for a entry and adjust global freq if needed +void KDirWatchPrivate::useFreq(Entry* e, int newFreq) +{ + e->freq = newFreq; + + // a reasonable frequency for the global polling timer + if (e->freq < freq) { + freq = e->freq; + if (timer->isActive()) timer->changeInterval(freq); + kdDebug(7001) << "Global Poll Freq is now " << freq << " msec" << endl; + } +} + + +#if defined(HAVE_FAM) +// setup FAM notification, returns false if not possible +bool KDirWatchPrivate::useFAM(Entry* e) +{ + if (!use_fam) return false; + + e->m_mode = FAMMode; + + if (e->isDir) { + if (e->m_status == NonExistent) { + // If the directory does not exist we watch the parent directory + addEntry(0, QDir::cleanDirPath(e->path+"/.."), e, true); + } + else { + int res =FAMMonitorDirectory(&fc, QFile::encodeName(e->path), + &(e->fr), e); + if (res<0) { + e->m_mode = UnknownMode; + use_fam=false; + return false; + } + kdDebug(7001) << " Setup FAM (Req " + << FAMREQUEST_GETREQNUM(&(e->fr)) + << ") for " << e->path << endl; + } + } + else { + if (e->m_status == NonExistent) { + // If the file does not exist we watch the directory + addEntry(0, QFileInfo(e->path).dirPath(true), e, true); + } + else { + int res = FAMMonitorFile(&fc, QFile::encodeName(e->path), + &(e->fr), e); + if (res<0) { + e->m_mode = UnknownMode; + use_fam=false; + return false; + } + + kdDebug(7001) << " Setup FAM (Req " + << FAMREQUEST_GETREQNUM(&(e->fr)) + << ") for " << e->path << endl; + } + } + + // handle FAM events to avoid deadlock + // (FAM sends back all files in a directory when monitoring) + famEventReceived(); + + return true; +} +#endif + + +#ifdef HAVE_DNOTIFY +// setup DNotify notification, returns false if not possible +bool KDirWatchPrivate::useDNotify(Entry* e) +{ + e->dn_fd = 0; + if (!supports_dnotify) return false; + + e->m_mode = DNotifyMode; + + if (e->isDir) { + e->dn_dirty = false; + if (e->m_status == Normal) { + int fd = open(QFile::encodeName(e->path).data(), O_RDONLY); + // Migrate fd to somewhere above 128. Some libraries have + // constructs like: + // fd = socket(...) + // if (fd > ARBITRARY_LIMIT) + // return error; + // + // Since programs might end up using a lot of KDirWatch objects + // for a rather long time the above braindamage could get + // triggered. + // + // By moving the kdirwatch fd's to > 128, calls like socket() will keep + // returning fd's < ARBITRARY_LIMIT for a bit longer. + int fd2 = fcntl(fd, F_DUPFD, 128); + if (fd2 >= 0) + { + close(fd); + fd = fd2; + } + if (fd<0) { + e->m_mode = UnknownMode; + return false; + } + + int mask = DN_DELETE|DN_CREATE|DN_RENAME|DN_MULTISHOT; + // if dependant is a file watch, we check for MODIFY & ATTRIB too + for(Entry* dep=e->m_entries.first();dep;dep=e->m_entries.next()) + if (!dep->isDir) { mask |= DN_MODIFY|DN_ATTRIB; break; } + + if(fcntl(fd, F_SETSIG, dnotify_signal) < 0 || + fcntl(fd, F_NOTIFY, mask) < 0) { + + kdDebug(7001) << "Not using Linux Directory Notifications." + << endl; + supports_dnotify = false; + ::close(fd); + e->m_mode = UnknownMode; + return false; + } + + fd_Entry.replace(fd, e); + e->dn_fd = fd; + + kdDebug(7001) << " Setup DNotify (fd " << fd + << ") for " << e->path << endl; + } + else { // NotExisting + addEntry(0, QDir::cleanDirPath(e->path+"/.."), e, true); + } + } + else { // File + // we always watch the directory (DNOTIFY can't watch files alone) + // this notifies us about changes of files therein + addEntry(0, QFileInfo(e->path).dirPath(true), e, true); + } + + return true; +} +#endif + + +bool KDirWatchPrivate::useStat(Entry* e) +{ +//US we have no KIO::probably_slow_mounted. So disable this part +//US if (KIO::probably_slow_mounted(e->path)) +//US useFreq(e, m_nfsPollInterval); +//US else + useFreq(e, m_PollInterval); + + if (e->m_mode != StatMode) { + e->m_mode = StatMode; + statEntries++; + + if ( statEntries == 1 ) { + // if this was first STAT entry (=timer was stopped) + timer->start(freq); // then start the timer + kdDebug(7001) << " Started Polling Timer, freq " << freq << endl; + } + } + + kdDebug(7001) << " Setup Stat (freq " << e->freq + << ") for " << e->path << endl; + + return true; +} + + +/* If <instance> !=0, this KDirWatch instance wants to watch at <_path>, + * providing in <isDir> the type of the entry to be watched. + * Sometimes, entries are dependant on each other: if <sub_entry> !=0, + * this entry needs another entry to watch himself (when notExistent). + */ +void KDirWatchPrivate::addEntry(KDirWatch* instance, const QString& _path, + Entry* sub_entry, bool isDir) +{ + QString path = _path; + if (path.startsWith("/dev/") || (path == "/dev")) + return; // Don't even go there. + + if ( path.length() > 1 && path.right(1) == "/" ) + path.truncate( path.length() - 1 ); + + EntryMap::Iterator it = m_mapEntries.find( path ); + if ( it != m_mapEntries.end() ) + { + if (sub_entry) { + (*it).m_entries.append(sub_entry); + kdDebug(7001) << "Added already watched Entry " << path + << " (for " << sub_entry->path << ")" << endl; +#ifdef HAVE_DNOTIFY + Entry* e = &(*it); + if( e->dn_fd > 0 ) { + int mask = DN_DELETE|DN_CREATE|DN_RENAME|DN_MULTISHOT; + // if dependant is a file watch, we check for MODIFY & ATTRIB too + for(Entry* dep=e->m_entries.first();dep;dep=e->m_entries.next()) + if (!dep->isDir) { mask |= DN_MODIFY|DN_ATTRIB; break; } + if( fcntl(e->dn_fd, F_NOTIFY, mask) < 0) { // shouldn't happen + ::close(e->dn_fd); + e->m_mode = UnknownMode; + fd_Entry.remove(e->dn_fd); + e->dn_fd = 0; + useStat( e ); + } + } +#endif + } + else { + (*it).addClient(instance); + kdDebug(7001) << "Added already watched Entry " << path + << " (now " << (*it).clients() << " clients)" + << QString(" [%1]").arg(instance->name()) << endl; + } + return; + } + + // we have a new path to watch + + struct stat stat_buf; + bool exists = (stat(QFile::encodeName(path), &stat_buf) == 0); + + Entry newEntry; + m_mapEntries.insert( path, newEntry ); + // the insert does a copy, so we have to use <e> now + Entry* e = &(m_mapEntries[path]); + + if (exists) { + e->isDir = S_ISDIR(stat_buf.st_mode); + + if (e->isDir && !isDir) + qWarning("KDirWatch: %s is a directory. Use addDir!", path.ascii()); + else if (!e->isDir && isDir) + qWarning("KDirWatch: %s is a file. Use addFile!", path.ascii()); + + e->m_ctime = stat_buf.st_ctime; + e->m_status = Normal; + e->m_nlink = stat_buf.st_nlink; + } + else { + e->isDir = isDir; + e->m_ctime = invalid_ctime; + e->m_status = NonExistent; + e->m_nlink = 0; + } + + e->path = path; + if (sub_entry) + e->m_entries.append(sub_entry); + else + e->addClient(instance); + + kdDebug(7001) << "Added " << (e->isDir ? "Dir ":"File ") << path + << (e->m_status == NonExistent ? " NotExisting" : "") + << (sub_entry ? QString(" for %1").arg(sub_entry->path) : QString("")) + << (instance ? QString(" [%1]").arg(instance->name()) : QString("")) + << endl; + + + // now setup the notification method + e->m_mode = UnknownMode; + e->msecLeft = 0; + +#if defined(HAVE_FAM) + if (useFAM(e)) return; +#endif + +#ifdef HAVE_DNOTIFY + if (useDNotify(e)) return; +#endif + + useStat(e); +} + + +void KDirWatchPrivate::removeEntry( KDirWatch* instance, + const QString& _path, Entry* sub_entry ) +{ + Entry* e = entry(_path); + if (!e) { + kdWarning(7001) << "KDirWatch::removeDir can't handle '" << _path << "'" << endl; + return; + } + + if (sub_entry) + e->m_entries.removeRef(sub_entry); + else + e->removeClient(instance); + + if (e->m_clients.count() || e->m_entries.count()) + return; + + if (delayRemove) { + // removeList is allowed to contain any entry at most once + if (removeList.findRef(e)==-1) + removeList.append(e); + // now e->isValid() is false + return; + } + +#ifdef HAVE_FAM + if (e->m_mode == FAMMode) { + if ( e->m_status == Normal) { + FAMCancelMonitor(&fc, &(e->fr) ); + kdDebug(7001) << "Cancelled FAM (Req " + << FAMREQUEST_GETREQNUM(&(e->fr)) + << ") for " << e->path << endl; + } + else { + if (e->isDir) + removeEntry(0, QDir::cleanDirPath(e->path+"/.."), e); + else + removeEntry(0, QFileInfo(e->path).dirPath(true), e); + } + } +#endif + +#ifdef HAVE_DNOTIFY + if (e->m_mode == DNotifyMode) { + if (!e->isDir) { + removeEntry(0, QFileInfo(e->path).dirPath(true), e); + } + else { // isDir + // must close the FD. + if ( e->m_status == Normal) { + if (e->dn_fd) { + ::close(e->dn_fd); + fd_Entry.remove(e->dn_fd); + + kdDebug(7001) << "Cancelled DNotify (fd " << e->dn_fd + << ") for " << e->path << endl; + e->dn_fd = 0; + + } + } + else { + removeEntry(0, QDir::cleanDirPath(e->path+"/.."), e); + } + } + } +#endif + + if (e->m_mode == StatMode) { + statEntries--; + if ( statEntries == 0 ) { + timer->stop(); // stop timer if lists are empty + kdDebug(7001) << " Stopped Polling Timer" << endl; + } + } + + kdDebug(7001) << "Removed " << (e->isDir ? "Dir ":"File ") << e->path + << (sub_entry ? QString(" for %1").arg(sub_entry->path) : QString("")) + << (instance ? QString(" [%1]").arg(instance->name()) : QString("")) + << endl; + m_mapEntries.remove( e->path ); // <e> not valid any more +} + + +/* Called from KDirWatch destructor: + * remove <instance> as client from all entries + */ +void KDirWatchPrivate::removeEntries( KDirWatch* instance ) +{ + QPtrList<Entry> list; + int minfreq = 3600000; + + // put all entries where instance is a client in list + EntryMap::Iterator it = m_mapEntries.begin(); + for( ; it != m_mapEntries.end(); ++it ) { + Client* c = (*it).m_clients.first(); + for(;c;c=(*it).m_clients.next()) + if (c->instance == instance) break; + if (c) { + c->count = 1; // forces deletion of instance as client + list.append(&(*it)); + } + else if ( (*it).m_mode == StatMode && (*it).freq < minfreq ) + minfreq = (*it).freq; + } + + for(Entry* e=list.first();e;e=list.next()) + removeEntry(instance, e->path, 0); + + if (minfreq > freq) { + // we can decrease the global polling frequency + freq = minfreq; + if (timer->isActive()) timer->changeInterval(freq); + kdDebug(7001) << "Poll Freq now " << freq << " msec" << endl; + } +} + +// instance ==0: stop scanning for all instances +bool KDirWatchPrivate::stopEntryScan( KDirWatch* instance, Entry* e) +{ + int stillWatching = 0; + Client* c = e->m_clients.first(); + for(;c;c=e->m_clients.next()) { + if (!instance || instance == c->instance) + c->watchingStopped = true; + else if (!c->watchingStopped) + stillWatching += c->count; + } + + kdDebug(7001) << instance->name() << " stopped scanning " << e->path + << " (now " << stillWatching << " watchers)" << endl; + + if (stillWatching == 0) { + // if nobody is interested, we don't watch + e->m_ctime = invalid_ctime; // invalid + // e->m_status = Normal; + } + return true; +} + +// instance ==0: start scanning for all instances +bool KDirWatchPrivate::restartEntryScan( KDirWatch* instance, Entry* e, + bool notify) +{ + int wasWatching = 0, newWatching = 0; + Client* c = e->m_clients.first(); + for(;c;c=e->m_clients.next()) { + if (!c->watchingStopped) + wasWatching += c->count; + else if (!instance || instance == c->instance) { + c->watchingStopped = false; + newWatching += c->count; + } + } + if (newWatching == 0) + return false; + + kdDebug(7001) << instance->name() << " restarted scanning " << e->path + << " (now " << wasWatching+newWatching << " watchers)" << endl; + + // restart watching and emit pending events + + int ev = NoChange; + if (wasWatching == 0) { + if (!notify) { + struct stat stat_buf; + bool exists = (stat(QFile::encodeName(e->path), &stat_buf) == 0); + if (exists) { + e->m_ctime = stat_buf.st_ctime; + e->m_status = Normal; + e->m_nlink = stat_buf.st_nlink; + } + else { + e->m_ctime = invalid_ctime; + e->m_status = NonExistent; + e->m_nlink = 0; + } + } + e->msecLeft = 0; + ev = scanEntry(e); + } + emitEvent(e,ev); + + return true; +} + +// instance ==0: stop scanning for all instances +void KDirWatchPrivate::stopScan(KDirWatch* instance) +{ + EntryMap::Iterator it = m_mapEntries.begin(); + for( ; it != m_mapEntries.end(); ++it ) + stopEntryScan(instance, &(*it)); +} + + +void KDirWatchPrivate::startScan(KDirWatch* instance, + bool notify, bool skippedToo ) +{ + if (!notify) + resetList(instance,skippedToo); + + EntryMap::Iterator it = m_mapEntries.begin(); + for( ; it != m_mapEntries.end(); ++it ) + restartEntryScan(instance, &(*it), notify); + + // timer should still be running when in polling mode +} + + +// clear all pending events, also from stopped +void KDirWatchPrivate::resetList( KDirWatch* /*instance*/, + bool skippedToo ) +{ + EntryMap::Iterator it = m_mapEntries.begin(); + for( ; it != m_mapEntries.end(); ++it ) { + + Client* c = (*it).m_clients.first(); + for(;c;c=(*it).m_clients.next()) + if (!c->watchingStopped || skippedToo) + c->pending = NoChange; + } +} + +// Return event happened on <e> +// +int KDirWatchPrivate::scanEntry(Entry* e) +{ +#ifdef HAVE_FAM + // we do not stat entries using FAM + if (e->m_mode == FAMMode) return NoChange; +#endif + + // Shouldn't happen: Ignore "unknown" notification method + if (e->m_mode == UnknownMode) return NoChange; + +#ifdef HAVE_DNOTIFY + if (e->m_mode == DNotifyMode) { + // we know nothing has changed, no need to stat + if(!e->dn_dirty) return NoChange; + e->dn_dirty = false; + } +#endif + + if (e->m_mode == StatMode) { + // only scan if timeout on entry timer happens; + // e.g. when using 500msec global timer, a entry + // with freq=5000 is only watched every 10th time + + e->msecLeft -= freq; + if (e->msecLeft>0) return NoChange; + e->msecLeft += e->freq; + } + + struct stat stat_buf; + bool exists = (stat(QFile::encodeName(e->path), &stat_buf) == 0); + if (exists) { + + if (e->m_status == NonExistent) { + e->m_ctime = stat_buf.st_ctime; + e->m_status = Normal; + e->m_nlink = stat_buf.st_nlink; + return Created; + } + + if ( (e->m_ctime != invalid_ctime) && + ((stat_buf.st_ctime != e->m_ctime) || +// (stat_buf.st_nlink != (nlink_t) e->m_nlink)) ) { + (stat_buf.st_nlink != e->m_nlink)) ) { + e->m_ctime = stat_buf.st_ctime; + e->m_nlink = stat_buf.st_nlink; + return Changed; + } + + return NoChange; + } + + // dir/file doesn't exist + + if (e->m_ctime == invalid_ctime) + return NoChange; + + e->m_ctime = invalid_ctime; + e->m_nlink = 0; + e->m_status = NonExistent; + + return Deleted; +} + +/* Notify all interested KDirWatch instances about a given event on an entry + * and stored pending events. When watching is stopped, the event is + * added to the pending events. + */ +void KDirWatchPrivate::emitEvent(Entry* e, int event, const QString &fileName) +{ + QString path = e->path; + if (!fileName.isEmpty()) { + if (fileName[0] == '/') + path = fileName; + else + path += "/" + fileName; + } + + Client* c = e->m_clients.first(); + for(;c;c=e->m_clients.next()) { + if (c->instance==0 || c->count==0) continue; + + if (c->watchingStopped) { + // add event to pending... + if (event == Changed) + c->pending |= event; + else if (event == Created || event == Deleted) + c->pending = event; + continue; + } + // not stopped + if (event == NoChange || event == Changed) + event |= c->pending; + c->pending = NoChange; + if (event == NoChange) continue; + + if (event & Deleted) { + c->instance->setDeleted(path); + // emit only Deleted event... + continue; + } + + if (event & Created) { + c->instance->setCreated(path); + // possible emit Change event after creation + } + + if (event & Changed) + c->instance->setDirty(path); + } +} + +// Remove entries which were marked to be removed +void KDirWatchPrivate::slotRemoveDelayed() +{ + Entry* e; + delayRemove = false; + for(e=removeList.first();e;e=removeList.next()) + removeEntry(0, e->path, 0); + removeList.clear(); +} + +/* Scan all entries to be watched for changes. This is done regularly + * when polling and once after a DNOTIFY signal. This is NOT used by FAM. + */ +void KDirWatchPrivate::slotRescan() +{ + EntryMap::Iterator it; + + // People can do very long things in the slot connected to dirty(), + // like showing a message box. We don't want to keep polling during + // that time, otherwise the value of 'delayRemove' will be reset. + bool timerRunning = timer->isActive(); + if ( timerRunning ) + timer->stop(); + + // We delay deletions of entries this way. + // removeDir(), when called in slotDirty(), can cause a crash otherwise + delayRemove = true; + +#ifdef HAVE_DNOTIFY + QPtrList<Entry> dList, cList; + + // for DNotify method, + if (rescan_all) + { + // mark all as dirty + it = m_mapEntries.begin(); + for( ; it != m_mapEntries.end(); ++it ) + (*it).dn_dirty = true; + rescan_all = false; + } + else + { + // progate dirty flag to dependant entries (e.g. file watches) + it = m_mapEntries.begin(); + for( ; it != m_mapEntries.end(); ++it ) + if ( ((*it).m_mode == DNotifyMode) && (*it).dn_dirty ) + (*it).propagate_dirty(); + } + +#endif + + it = m_mapEntries.begin(); + for( ; it != m_mapEntries.end(); ++it ) { + // we don't check invalid entries (i.e. remove delayed) + if (!(*it).isValid()) continue; + + int ev = scanEntry( &(*it) ); + +#ifdef HAVE_DNOTIFY + if ((*it).m_mode == DNotifyMode) { + if ((*it).isDir && (ev == Deleted)) { + dList.append( &(*it) ); + + // must close the FD. + if ((*it).dn_fd) { + ::close((*it).dn_fd); + fd_Entry.remove((*it).dn_fd); + (*it).dn_fd = 0; + } + } + + else if ((*it).isDir && (ev == Created)) { + // For created, but yet without DNOTIFYing ... + if ( (*it).dn_fd == 0) { + cList.append( &(*it) ); + if (! useDNotify( &(*it) )) { + // if DNotify setup fails... + useStat( &(*it) ); + } + } + } + } +#endif + + if ( ev != NoChange ) + emitEvent( &(*it), ev); + } + + +#ifdef HAVE_DNOTIFY + // Scan parent of deleted directories for new creation + Entry* e; + for(e=dList.first();e;e=dList.next()) + addEntry(0, QDir::cleanDirPath( e->path+"/.."), e, true); + + // Remove watch of parent of new created directories + for(e=cList.first();e;e=cList.next()) + removeEntry(0, QDir::cleanDirPath( e->path+"/.."), e); +#endif + + if ( timerRunning ) + timer->start(freq); + + QTimer::singleShot(0, this, SLOT(slotRemoveDelayed())); +} + +#ifdef HAVE_FAM +void KDirWatchPrivate::famEventReceived() +{ + static FAMEvent fe; + + delayRemove = true; + + while(use_fam && FAMPending(&fc)) { + if (FAMNextEvent(&fc, &fe) == -1) { + kdWarning(7001) << "FAM connection problem, switching to polling." + << endl; + use_fam = false; + delete sn; sn = 0; + + // Replace all FAMMode entries with DNotify/Stat + EntryMap::Iterator it; + it = m_mapEntries.begin(); + for( ; it != m_mapEntries.end(); ++it ) + if ((*it).m_mode == FAMMode && (*it).m_clients.count()>0) { +#ifdef HAVE_DNOTIFY + if (useDNotify( &(*it) )) continue; +#endif + useStat( &(*it) ); + } + } + else + checkFAMEvent(&fe); + } + + QTimer::singleShot(0, this, SLOT(slotRemoveDelayed())); +} + +void KDirWatchPrivate::checkFAMEvent(FAMEvent* fe) +{ + // Don't be too verbose ;-) + if ((fe->code == FAMExists) || + (fe->code == FAMEndExist) || + (fe->code == FAMAcknowledge)) return; + + // $HOME/.X.err grows with debug output, so don't notify change + if ( *(fe->filename) == '.') { + if (strncmp(fe->filename, ".X.err", 6) == 0) return; + if (strncmp(fe->filename, ".xsession-errors", 16) == 0) return; + } + + Entry* e = 0; + EntryMap::Iterator it = m_mapEntries.begin(); + for( ; it != m_mapEntries.end(); ++it ) + if (FAMREQUEST_GETREQNUM(&( (*it).fr )) == + FAMREQUEST_GETREQNUM(&(fe->fr)) ) { + e = &(*it); + break; + } + + // Entry* e = static_cast<Entry*>(fe->userdata); + + kdDebug(7001) << "Processing FAM event (" + << ((fe->code == FAMChanged) ? "FAMChanged" : + (fe->code == FAMDeleted) ? "FAMDeleted" : + (fe->code == FAMStartExecuting) ? "FAMStartExecuting" : + (fe->code == FAMStopExecuting) ? "FAMStopExecuting" : + (fe->code == FAMCreated) ? "FAMCreated" : + (fe->code == FAMMoved) ? "FAMMoved" : + (fe->code == FAMAcknowledge) ? "FAMAcknowledge" : + (fe->code == FAMExists) ? "FAMExists" : + (fe->code == FAMEndExist) ? "FAMEndExist" : "Unknown Code") + << ", " << fe->filename + << ", Req " << FAMREQUEST_GETREQNUM(&(fe->fr)) + << ")" << endl; + + if (!e) { + // this happens e.g. for FAMAcknowledge after deleting a dir... + // kdDebug(7001) << "No entry for FAM event ?!" << endl; + return; + } + + if (e->m_status == NonExistent) { + kdDebug(7001) << "FAM event for nonExistent entry " << e->path << endl; + return; + } + + if (e->isDir) + switch (fe->code) + { + case FAMDeleted: + // file absolute: watched dir + if (fe->filename[0] == '/') + { + // a watched directory was deleted + + e->m_status = NonExistent; + FAMCancelMonitor(&fc, &(e->fr) ); // needed ? + kdDebug(7001) << "Cancelled FAMReq " + << FAMREQUEST_GETREQNUM(&(e->fr)) + << " for " << e->path << endl; + // Scan parent for a new creation + addEntry(0, QDir::cleanDirPath( e->path+"/.."), e, true); + } + emitEvent(e, Deleted, QFile::decodeName(fe->filename)); + break; + + case FAMCreated: { + // check for creation of a directory we have to watch + Entry *sub_entry = e->m_entries.first(); + for(;sub_entry; sub_entry = e->m_entries.next()) + if (sub_entry->path == e->path + "/" + fe->filename) break; + if (sub_entry && sub_entry->isDir) { + QString path = e->path; + removeEntry(0,e->path,sub_entry); // <e> can be invalid here!! + sub_entry->m_status = Normal; + if (!useFAM(sub_entry)) + useStat(sub_entry); + + emitEvent(sub_entry, Created); + } + else emitEvent(e, Created, QFile::decodeName(fe->filename)); + break; + } + + case FAMChanged: + emitEvent(e, Changed, QFile::decodeName(fe->filename)); + + default: + break; + } + else switch (fe->code) + { + case FAMCreated: emitEvent(e, Created); + break; + case FAMDeleted: emitEvent(e, Deleted); + break; + case FAMChanged: emitEvent(e, Changed); + break; + default: break; + } +} +#else +void KDirWatchPrivate::famEventReceived() {} +#endif + + +void KDirWatchPrivate::statistics() +{ + EntryMap::Iterator it; + + kdDebug(7001) << "Entries watched:" << endl; + if (m_mapEntries.count()==0) { + kdDebug(7001) << " None." << endl; + } + else { + it = m_mapEntries.begin(); + for( ; it != m_mapEntries.end(); ++it ) { + Entry* e = &(*it); + kdDebug(7001) << " " << e->path << " (" + << ((e->m_status==Normal)?"":"Nonexistent ") + << (e->isDir ? "Dir":"File") << ", using " + << ((e->m_mode == FAMMode) ? "FAM" : + (e->m_mode == DNotifyMode) ? "DNotify" : + (e->m_mode == StatMode) ? "Stat" : "Unknown Method") + << ")" << endl; + + Client* c = e->m_clients.first(); + for(;c; c = e->m_clients.next()) { + QString pending; + if (c->watchingStopped) { + if (c->pending & Deleted) pending += "deleted "; + if (c->pending & Created) pending += "created "; + if (c->pending & Changed) pending += "changed "; + if (!pending.isEmpty()) pending = " (pending: " + pending + ")"; + pending = ", stopped" + pending; + } + kdDebug(7001) << " by " << c->instance->name() + << " (" << c->count << " times)" + << pending << endl; + } + if (e->m_entries.count()>0) { + kdDebug(7001) << " dependent entries:" << endl; + Entry* d = e->m_entries.first(); + for(;d; d = e->m_entries.next()) { + kdDebug(7001) << " " << d->path << endl; + } + } + } + } +} + + +// +// Class KDirWatch +// + +static KStaticDeleter<KDirWatch> sd_dw; +KDirWatch* KDirWatch::s_pSelf = 0L; + +KDirWatch* KDirWatch::self() +{ + if ( !s_pSelf ) { +//US sd_dw.setObject( s_pSelf, new KDirWatch ); + s_pSelf = sd_dw.setObject( new KDirWatch ); + } + + return s_pSelf; +} + +bool KDirWatch::exists() +{ + return s_pSelf != 0; +} + +KDirWatch::KDirWatch (QObject* parent, const char* name) + : QObject(parent,name) +{ + if (!name) { + static int nameCounter = 0; + + nameCounter++; + setName(QString("KDirWatch-%1").arg(nameCounter).ascii()); + } + + if (!dwp_self) + dwp_self = new KDirWatchPrivate; + d = dwp_self; + d->ref(); + + _isStopped = false; +} + +KDirWatch::~KDirWatch() +{ + if (d) d->removeEntries(this); + if ( d->deref() ) + { + // delete it if it's the last one + delete d; + dwp_self = 0L; + } +} + + +// TODO: add watchFiles/recursive support +void KDirWatch::addDir( const QString& _path, + bool watchFiles, bool recursive) +{ + if (watchFiles || recursive) { + kdDebug(7001) << "addDir - recursive/watchFiles not supported in KDE 3.0" + << endl; + } + if (d) d->addEntry(this, _path, 0, true); +} + +void KDirWatch::addFile( const QString& _path ) +{ + if (d) d->addEntry(this, _path, 0, false); +} + +QDateTime KDirWatch::ctime( const QString &_path ) +{ + KDirWatchPrivate::Entry* e = d->entry(_path); + + if (!e) + return QDateTime(); + + QDateTime result; + result.setTime_t(e->m_ctime); + return result; +} + +void KDirWatch::removeDir( const QString& _path ) +{ + if (d) d->removeEntry(this, _path, 0); +} + +void KDirWatch::removeFile( const QString& _path ) +{ + if (d) d->removeEntry(this, _path, 0); +} + +bool KDirWatch::stopDirScan( const QString& _path ) +{ + if (d) { + KDirWatchPrivate::Entry *e = d->entry(_path); + if (e && e->isDir) return d->stopEntryScan(this, e); + } + return false; +} + +bool KDirWatch::restartDirScan( const QString& _path ) +{ + if (d) { + KDirWatchPrivate::Entry *e = d->entry(_path); + if (e && e->isDir) + // restart without notifying pending events + return d->restartEntryScan(this, e, false); + } + return false; +} + +void KDirWatch::stopScan() +{ + if (d) d->stopScan(this); + _isStopped = true; +} + +void KDirWatch::startScan( bool notify, bool skippedToo ) +{ + _isStopped = false; + if (d) d->startScan(this, notify, skippedToo); +} + + +bool KDirWatch::contains( const QString& _path ) const +{ + KDirWatchPrivate::Entry* e = d->entry(_path); + if (!e) + return false; + + KDirWatchPrivate::Client* c = e->m_clients.first(); + for(;c;c=e->m_clients.next()) + if (c->instance == this) return true; + + return false; +} + +void KDirWatch::statistics() +{ + if (!dwp_self) { + kdDebug(7001) << "KDirWatch not used" << endl; + return; + } + dwp_self->statistics(); +} + + +void KDirWatch::setCreated( const QString & _file ) +{ + kdDebug(7001) << name() << " emitting created " << _file << endl; + emit created( _file ); +} + +void KDirWatch::setDirty( const QString & _file ) +{ + kdDebug(7001) << name() << " emitting dirty " << _file << endl; + emit dirty( _file ); +} + +void KDirWatch::setDeleted( const QString & _file ) +{ + kdDebug(7001) << name() << " emitting deleted " << _file << endl; + emit deleted( _file ); +} + +//US #include "kdirwatch.moc" +//US #include "kdirwatch_p.moc" + +//sven + +// vim: sw=2 ts=8 et diff --git a/microkde/kio/kio/kdirwatch.h b/microkde/kio/kio/kdirwatch.h new file mode 100644 index 0000000..bee30c2 --- a/dev/null +++ b/microkde/kio/kio/kdirwatch.h @@ -0,0 +1,288 @@ +/* This file is part of the KDE libraries + Copyright (C) 1998 Sven Radej <sven@lisa.exp.univie.ac.at> + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License version 2 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. +*/ + +/* +Enhanced Version of the file for platform independent KDE tools. +Copyright (c) 2004 Ulf Schenk + +$Id$ +*/ + +#ifndef _KDIRWATCH_H +#define _KDIRWATCH_H + +#include <qtimer.h> +#include <qdatetime.h> +#include <qmap.h> + +#define kdirwatch KDirWatch::self() + +class KDirWatchPrivate; + + /** + * Watch directories and files for changes. + * The watched directories or files don't have to exist yet. + * + * When a watched directory is changed, i.e. when files therein are + * created or deleted, KDirWatch will emit the signal @ref dirty(). + * + * When a watched, but previously not existing directory gets created, + * KDirWatch will emit the signal @ref created(). + * + * When a watched directory gets deleted, KDirWatch will emit the + * signal @ref deleted(). The directory is still watched for new + * creation. + * + * When a watched file is changed, i.e. attributes changed or written + * to, KDirWatch will emit the signal @ref dirty(). + * + * Scanning of particular directories or files can be stopped temporarily + * and restarted. The whole class can be stopped and restarted. + * Directories and files can be added/removed from the list in any state. + * + * The implementation uses the FAM service when available; + * if FAM is not available, the DNOTIFY functionality is used on LINUX. + * As a last resort, a regular polling for change of modification times + * is done; the polling interval is a global config option: + * DirWatch/PollInterval and DirWatch/NFSPollInterval for NFS mounted + * directories. + * + * @see self() + * @short Class for watching directory and file changes. + * @author Sven Radej <sven@lisa.exp.univie.ac.at> + */ +class KDirWatch : public QObject +{ + Q_OBJECT + + public: + /** + * Constructor. + * + * Scanning begins immediatly when a dir/file watch + * is added. + * @param parent the parent of the QObject (or 0 for parent-less KDataTools) + * @param name the name of the QObject, can be 0 + */ + KDirWatch (QObject* parent = 0, const char* name = 0); + + /** + * Destructor. + * + * Stops scanning and cleans up. + */ + ~KDirWatch(); + + /** + * Adds a directory to be watched. + * + * The directory does not have to exist. When @p watchFiles is + * false (the default), the signals dirty(), created(), deleted() + * can be emitted, all for the watched directory. + * When @p watchFiles is true, all files in the watched directory + * are watched for changes, too. Thus, the signals dirty(), + * created(), deleted() can be emitted. + * + * @param path the path to watch + * @param watchFiles if true, the KDirWatch will also watch files + * @param recursive if true, all sub directories are also watched + */ + void addDir(const QString& path, + bool watchFiles = false, bool recursive = false); + + /** + * Adds a file to be watched. + * @param file the file to watch + */ + void addFile(const QString& file); + + /** + * Returns the time the directory/file was last changed. + * @param file the file to check + * @return the date of the last modification + */ + QDateTime ctime(const QString& path); + + /** + * Removes a directory from the list of scanned directories. + * + * If specified path is not in the list this does nothing. + * @param dir the path of the dir to be removed from the list + */ + void removeDir(const QString& path); + + /** + * Removes a file from the list of watched files. + * + * If specified path is not in the list this does nothing. + * @param file the file to be removed from the list + */ + void removeFile(const QString& file); + + /** + * Stops scanning the specified path. + * + * The @p path is not deleted from the interal just, it is just skipped. + * Call this function when you perform an huge operation + * on this directory (copy/move big files or many files). When finished, + * call @ref restartDirScan(path). + * + * @param path the path to skip + * @return true if the @p path is being watched, otherwise false + * @see restartDirScanning() + */ + bool stopDirScan(const QString& path); + + /** + * Restarts scanning for specified path. + * + * Resets ctime. It doesn't notify + * the change (by emitted a signal), since the ctime value is reset. + * + * Call it when you are finished with big operations on that path, + * @em and when @em you have refreshed that path. + * + * @param path the path to restart scanning + * @return true if the @p path is being watched, otherwise false + * @see stopDirScanning() + */ + bool restartDirScan(const QString& path); + + /** + * Starts scanning of all dirs in list. + * + * @param notify If true, all changed directories (since @ref + * stopScan() call) will be notified for refresh. If notify is + * false, all ctimes will be reset (except those who are stopped, + * but only if @p skippedToo is false) and changed dirs won't be + * notified. You can start scanning even if the list is + * empty. First call should be called with @p false or else all + * directories + * in list will be notified. + * @param skippedToo if true, the skipped directoris (scanning of which was + * stopped with @ref stopDirScan() ) will be reset and notified + * for change. Otherwise, stopped directories will continue to be + * unnotified. + */ + void startScan( bool notify=false, bool skippedToo=false ); + + /** + * Stops scanning of all directories in internal list. + * + * The timer is stopped, but the list is not cleared. + */ + void stopScan(); + + /** + * Is scanning stopped? + * After creation of a KDirWatch instance, this is false. + * @return true when scanning stopped + */ + bool isStopped() { return _isStopped; } + + /** + * Check if a directory is being watched by this KDirWatch instance + * @param path the directory to check + * @return true if the directory is being watched + */ + bool contains( const QString& path ) const; + + /** + * Dump statistic information about all KDirWatch instances. + * This checks for consistency, too. + */ + static void statistics(); + + /** + * Emits @ref created(). + * @param path the path of the file or directory + */ + void setCreated( const QString &path ); + /** + * Emits @ref dirty(). + * @param path the path of the file or directory + */ + void setDirty( const QString &path ); + /** + * Emits @ref deleted(). + * @param path the path of the file or directory + */ + void setDeleted( const QString &path ); + + /** + * The KDirWatch instance usually globally used in an application. + * It is automatically deleted when the application exits. + * + * However, you can create an arbitrary number of KDirWatch instances + * aside from this one - for those you have to take care of memory management. + * + * This function returns an instance of KDirWatch. If there is none, it + * will be created. + * + * @return a KDirWatch instance + */ + static KDirWatch* self(); + /** + * Returns true if there is an instance of KDirWatch. + * @return true if there is an instance of KDirWatch. + * @see KDirWatch::self() + * @since 3.1 + */ + static bool exists(); + + signals: + + /** + * Emitted when a watched object is changed. + * For a directory this signal is emitted when files + * therein are created or deleted. + * For a file this signal is emitted when its size or attributes change. + * + * When you watch a directory, changes in the size or attributes of + * contained files may or may not trigger this signal to be emitted + * depending on which backend is used by KDirWatch. + * + * The new ctime is set before the signal is emitted. + * @param path the path of the file or directory + */ + void dirty (const QString &path); + + /** + * Emitted when a file or directory is created. + * @param path the path of the file or directory + */ + void created (const QString &path ); + + /** + * Emitted when a file or directory is deleted. + * + * The object is still watched for new creation. + * @param path the path of the file or directory + */ + void deleted (const QString &path ); + + private: + bool _isStopped; + + KDirWatchPrivate *d; + static KDirWatch* s_pSelf; +}; + +#endif + +// vim: sw=3 et diff --git a/microkde/kio/kio/kdirwatch_p.h b/microkde/kio/kio/kdirwatch_p.h new file mode 100644 index 0000000..0ab482f --- a/dev/null +++ b/microkde/kio/kio/kdirwatch_p.h @@ -0,0 +1,153 @@ +/* Private Header for class of KDirWatchPrivate + * + * this separate header file is needed for MOC processing + * because KDirWatchPrivate has signals and slots + */ + +/* +Enhanced Version of the file for platform independent KDE tools. +Copyright (c) 2004 Ulf Schenk + +$Id$ +*/ + +#ifndef _KDIRWATCH_P_H +#define _KDIRWATCH_P_H + +#ifdef HAVE_FAM +#include <fam.h> +#endif + +#include <qptrlist.h> + +#include <kdirwatch.h> + +#include <ctime> + +#define invalid_ctime ((time_t)-1) + +/* KDirWatchPrivate is a singleton and does the watching + * for every KDirWatch instance in the application. + */ +class KDirWatchPrivate : public QObject +{ + Q_OBJECT +public: + + enum entryStatus { Normal = 0, NonExistent }; + enum entryMode { UnknownMode = 0, StatMode, DNotifyMode, FAMMode }; + enum { NoChange=0, Changed=1, Created=2, Deleted=4 }; + + struct Client { + KDirWatch* instance; + int count; + // did the instance stop watching + bool watchingStopped; + // events blocked when stopped + int pending; + }; + + class Entry + { + public: + // the last observed modification time + time_t m_ctime; + // the last observed link count + int m_nlink; + entryStatus m_status; + entryMode m_mode; + bool isDir; + // instances interested in events + QPtrList<Client> m_clients; + // nonexistent entries of this directory + QPtrList<Entry> m_entries; + QString path; + + int msecLeft, freq; + + void addClient(KDirWatch*); + void removeClient(KDirWatch*); + int clients(); + bool isValid() { return m_clients.count() || m_entries.count(); } + +#ifdef HAVE_FAM + FAMRequest fr; +#endif + +#ifdef HAVE_DNOTIFY + int dn_fd; + bool dn_dirty; + void propagate_dirty(); +#endif + }; + + typedef QMap<QString,Entry> EntryMap; + + KDirWatchPrivate(); + ~KDirWatchPrivate(); + + void resetList (KDirWatch*,bool); + void useFreq(Entry* e, int newFreq); + void addEntry(KDirWatch*,const QString&, Entry*, bool); + void removeEntry(KDirWatch*,const QString&, Entry*); + bool stopEntryScan(KDirWatch*, Entry*); + bool restartEntryScan(KDirWatch*, Entry*, bool ); + void stopScan(KDirWatch*); + void startScan(KDirWatch*, bool, bool); + + void removeEntries(KDirWatch*); + void statistics(); + + Entry* entry(const QString&); + int scanEntry(Entry* e); + void emitEvent(Entry* e, int event, const QString &fileName = QString::null); + + // Memory management - delete when last KDirWatch gets deleted + void ref() { m_ref++; } + bool deref() { return ( --m_ref == 0 ); } + +public slots: + void slotRescan(); + void famEventReceived(); // for FAM + void slotActivated(); // for DNOTIFY + void slotRemoveDelayed(); + +public: + QTimer *timer; + EntryMap m_mapEntries; + +private: + int freq; + int statEntries; + int m_nfsPollInterval, m_PollInterval; + int m_ref; + bool useStat(Entry*); + + bool delayRemove; + QPtrList<Entry> removeList; + +#ifdef HAVE_FAM + QSocketNotifier *sn; + FAMConnection fc; + bool use_fam; + + void checkFAMEvent(FAMEvent*); + bool useFAM(Entry*); +#endif + +#ifdef HAVE_DNOTIFY + bool supports_dnotify; + bool rescan_all; + int mPipe[2]; + QTimer mTimer; + QSocketNotifier *mSn; + QIntDict<Entry> fd_Entry; + + static void dnotify_handler(int, siginfo_t *si, void *); + static void dnotify_sigio_handler(int, siginfo_t *si, void *); + bool useDNotify(Entry*); +#endif +}; + +#endif // KDIRWATCH_P_H + |