The inotify_watch command.

The inotify_watch command watches recursively a set of directories for a set of events and creates commands in the format understood by The ewmscp command. More...

Enumerations
enum	watchDirectoryReturnType { watchDirectoryReturnType::vanished, watchDirectoryReturnType::islink, watchDirectoryReturnType::ignore, watchDirectoryReturnType::iswatched }
	special enum for the return values of watchDirectory. More...

Functions
watchDirectoryReturnType	watchDirectory (int fd, const std::string &name, watchedDirType *parent=nullptr)
	watch a directory. More...
int	main (int argc, const char *argv[])
	main inotify_watch function. More...

Detailed Description

The inotify_watch command watches recursively a set of directories for a set of events and creates commands in the format understood by The ewmscp command.

Bug:

When an anonymous tmp file is created and made visible via open(dirpath, O_WRONLY|O_TMPFILE);inkat(AT_FDCWD, "/proc/self/fd/%fd", AT_FDCWD, path, AT_SYMLINK_FOLLOW) no CLOSE_WRITE event is triggered. Not likely to happen as SL7/Centos7's kernel does not support O_TMPFILE, and also NFS does not support it (apparently)

Bug:

When a file in a watched directory has a hard link from an unwatched directory and is modified using that other link no notification is produced.

Enumeration Type Documentation

watchDirectoryReturnType

enum watchDirectoryReturnType

strong

special enum for the return values of watchDirectory.

Enumerator
vanished
islink
ignore
iswatched

Definition at line 481 of file inotify_watch.cpp.

                                    {
    vanished,
    islink,
    ignore,
    iswatched
};

Function Documentation

main()

int main	(	int	argc,
		const char *	argv[]
	)

main inotify_watch function.

This is the main executable.

Definition at line 649 of file inotify_watch.cpp.

                                       {
    std::ios::sync_with_stdio(false);
    options::parser parser("inotify_watch", "", {});
    options::positional<options::container<std::string>>directories(10, "directory",
            "directories to be watched");
    options::single<std::string> workDir('\0', "workDir",
                                         "use DIRECTORY as work dir");
    options::single<std::regex> ignore('i', "ignore",
                                       "regexp for files to be ignored for IN_CLOSE_WRITE");
    options::single<bool> verbose('v', "verbose",
                                  "be verbose", false);
    options::single<std::string> errorStream('\0', "errors",
            "file to write errors to");
 
    options::container<std::string> extraEvents('e', "extraEvents",
            "extra events to listen to");
    maskName::addToRange(extraEvents);
    options::container<std::string> copyTriggers('c', "copyTrigger",
            "extra events beside IN_CLOSE_NOWRITE hat trigger a copy");
    maskName::addToRange(copyTriggers);
    parser.fParse(argc, argv);
 
    logstream::provider errStreamBase(errorStream, std::cerr);
    errStream = &(errStreamBase.getStream());
 
    watchedDirType::setExtraEventMask(maskName::maskFromList(extraEvents));
 
    uint32_t copyTriggerBits = IN_CLOSE_WRITE | maskName::maskFromList(copyTriggers);
    if (verbose) {
        std::cerr << "events of type ";
        maskName::print(std::cerr, copyTriggerBits);
        std::cerr << " (" << std::hex << copyTriggerBits << std::dec << ") will trigger a copy event\n";
    }
    try {
 
        if (pidFileName != "") {
            std::ofstream pidFile(pidFileName);
            pidFile << getpid() << "\n";
            throwcall::good0(std::atexit(pidFileRemover), "can't register pidFileRemover");
            std::signal(SIGTERM, sigTermHandler);
        }
 
        std::signal(SIGPIPE, sigPipeHandler);
        std::signal(SIGUSR1, sigUsrHandler);
 
        auto fd = throwcall::badval(inotify_init(), -1, "inotify_init");
 
        if (workDir.fIsSet()) {
            throwcall::good0(chdir(workDir.c_str()), "can't change work dir to ", workDir);
        }
 
        for (const auto& directory : directories) {
            watchDirectory(fd, directory);
        }
 
        *errStream << errPrefix << "watching " << watchedDirType::size() << " directories" << std::endl;
 
        *errStream << std::fixed;
        char buffer[4096 * 256] __attribute__ ((aligned(__alignof__(struct inotify_event))));
        struct pollfd pfd;
        pfd.fd = fd;
        pfd.events = POLLIN;
 
        commandSender sender;
 
        while (true) {
            if (dumpRequested) {
                dumpRequested = false;
                watchedDirType::dump(*errStream);
            }
            {
                {
                    // process single events that took forever to get a partner
                    commandSender::flushDomain flusher(sender);
                    while (auto copy = inotify_event_copy::getStaleSingles()) {
                        auto event = copy->getEvent();
                        std::string path;
                        watchedDirType::get(event->wd())->buildPath(path, event->name());
 
                        if (event->mask() & IN_MOVED_TO) {
                            auto result = watchDirectory(fd, event->name(), watchedDirType::get(event->wd()));
 
                            if (result == watchDirectoryReturnType::islink) {
                                sender.sendCommand("ln", copy->timeStamp(), path);
                            } else if (result == watchDirectoryReturnType::ignore) {
                                sender.sendCommand("cp", copy->timeStamp(), path);
                            }
 
                            if (verbose && result == watchDirectoryReturnType::iswatched) {
                                *errStream << errPrefix << "watching " << watchedDirType::size() << " directories (added subtree)" << std::endl;
                            }
                        } else {
                            auto parent = watchedDirType::get(event->wd());
                            auto meAsDirChild = parent->getChild(event->name());
 
                            if (meAsDirChild) {
                                delete meAsDirChild;
                            }
 
                            sender.sendCommand("rm", copy->timeStamp(), path);
                        }
 
                        inotify_event_copy::forget(copy);
                    }
                }
                auto result = poll(&pfd, 1, 1000);
 
                if (result == -1) {
                    if (errno == EINTR) {
                        continue;
                    }
 
                    throwcall::badval(result, -1, "poll failed");
                }
 
                if (result == 0) { // timeout, check continued presence of initial dirs
                    for (const auto& directory : directories) {
                        struct stat statbuf;
                        auto retval = stat(directory.c_str(), &statbuf);
 
                        if (retval != 0 && errno == ENOENT) {
                            return 0;
                        } else {
                            throwcall::good0(retval, "can't stat ", directory);
                        }
                    }
                    sender.keepalive();
                    continue;
                }
            }
            auto bytes = throwcall::badval(read(fd, buffer, sizeof(buffer)),
                                           -1, "read inotification");
            auto now = clock_type::now();
 
            if (verbose) {
                *errStream << errPrefix << now << " got " << bytes << " bytes of notification" << std::endl;
            }
 
            commandSender::flushDomain flusher(sender);
 
            for (auto event = inotify_event_wrapper::fromChar(buffer);
                    event < inotify_event_wrapper::fromChar(buffer + bytes);
                    event = event->next()) {
                if (verbose) {
                    *errStream << errPrefix << "watch id " << event->wd() << " @ " << (void*)event << " with name " << event->name() << *event << std::endl;
                }
 
                if (event->mask() & IN_IGNORED) {
                    continue;
                }
 
                if (event->mask() & IN_Q_OVERFLOW) {
                    *errStream << errPrefix << "watch queue overflow" << std::endl;
                    continue; // we cannot do more than lopg this
                }
 
                std::string path;
                auto watchedDir = watchedDirType::get(event->wd());
 
                if (watchedDir == nullptr) {
                    *errStream << errPrefix << "unknown watch id " << event->wd() << " @ " << (void*)event << " with name " << event->name() << *event << std::endl;
                    continue;
                }
 
                watchedDir->buildPath(path, event->name());
 
                if (event->mask() & (IN_MOVED_TO | IN_MOVED_FROM)) {
                    auto partner = inotify_event_copy::getPartner(event, now);
 
                    if (partner) { // we have a partner event
                        std::string partnerPath;
                        watchedDirType::get(partner->getEvent()->wd())->buildPath(partnerPath, partner->getEvent()->name());
                        const inotify_event_wrapper* from;
                        const inotify_event_wrapper* to;
                        const std::string* fromPath;
                        const std::string* toPath;
 
                        if (event->mask() & IN_MOVED_TO) {
                            from = partner->getEvent();
                            to = event;
                            fromPath = &partnerPath;
                            toPath = &path;
                        } else {
                            from = event;
                            to = partner->getEvent();
                            fromPath = &path;
                            toPath = &partnerPath;
                        }
 
                        auto fromAsDirChild = watchedDirType::get(from->wd())->getChild(from->name());
 
                        if (fromAsDirChild) {
                            fromAsDirChild->getAdoptedBy(to->name(), watchedDirType::get(to->wd()));
                        }
 
                        sender.sendCommand("mv", now, *fromPath, *toPath);
                        inotify_event_copy::forget(partner);
                    }
                }
 
                if (event->mask() & copyTriggerBits) {
                    if (!(ignore.fIsSet() && regex_match(path, ignore))) {
                        sender.sendCommand("cp", now, path);
                    }
                }
 
                if (event->mask() & IN_CREATE) { // watch new directories also
                    auto result = watchDirectory(fd, event->name(), watchedDir);
 
                    if (result == watchDirectoryReturnType::islink) {
                        sender.sendCommand("ln", now, path);
                    }
 
                    if (verbose && result == watchDirectoryReturnType::iswatched) {
                        *errStream << errPrefix << "watching " << watchedDirType::size() << " directories (added subtree)" << std::endl;
                    }
                }
 
                if (event->mask() & IN_DELETE_SELF) { // a watched directory is deleted
                    watchedDir->invalidateId();
                    delete watchedDir;
 
                    if (verbose) {
                        *errStream << errPrefix << "watching " << watchedDirType::size() << " directories (removed subtree)" << std::endl;
                    }
                }
 
                if (event->mask() & IN_DELETE) {
                    if (!(ignore.fIsSet() && regex_match(path, ignore))) {
                        sender.sendCommand("rm", now, path);
                    }
                }
            }
            // make copies of all leftover half move events befor re-using buffer
            inotify_event_copy::doCopyLeftovers();
 
            if (watchedDirType::empty()) {
                throwcall::good0(close(fd), "can't close inotify fd");
 
                *errStream << errPrefix << "no more stuff to watch, finishing...\n";
 
                return EXIT_SUCCESS;
            }
        }
    } catch (const std::exception& e) {
        *errStream << logstream::level::crit << errPrefix << " ended badly: " << e.what() << std::endl;
        return EXIT_FAILURE;
    }
 
    return EXIT_SUCCESS;
}

References maskName::addToRange(), throwcall::badval(), watchedDirType::buildPath(), logstream::crit, inotify_event_copy::doCopyLeftovers(), watchedDirType::dump(), dumpRequested(), watchedDirType::empty(), errPrefix, errStream(), options::base::fIsSet(), inotify_event_copy::forget(), inotify_event_wrapper::fromChar(), watchedDirType::get(), watchedDirType::getAdoptedBy(), watchedDirType::getChild(), inotify_event_copy::getPartner(), inotify_event_copy::getStaleSingles(), logstream::provider::getStream(), throwcall::good0(), ignore, islink, iswatched, commandSender::keepalive(), maskName::maskFromList(), inotify_event_wrapper::name(), pidFileName, pidFileRemover(), maskName::print(), commandSender::sendCommand(), watchedDirType::setExtraEventMask(), sigPipeHandler(), sigTermHandler(), sigUsrHandler(), watchedDirType::size(), verbose, watchDirectory(), inotify_event_wrapper::wd(), and workDir.

Here is the call graph for this function:

watchDirectory()

watchDirectoryReturnType watchDirectory	(	int	fd,
		const std::string &	name,
		watchedDirType *	parent = nullptr
	)

watch a directory.

The directory indicated by name will be watched, together with all the subdirs recursively. [in] fd is the fd of the inotify object, [in] name is the basename (if parent != null) of full path (no parent) of the directory. [in] parent pointer to the parent directory, may be nullpr for initial command line args

Definition at line 494 of file inotify_watch.cpp.

                                                                          {
    std::string path;
 
    if (parent) {
        parent->buildPath(path, name);
    } else {
        path = name;
    }
 
    {
        struct stat statbuf;
        auto retval = lstat(path.c_str(), &statbuf);
 
        if (retval && (errno == ENOENT || errno == ENOTDIR)) {
            return watchDirectoryReturnType::vanished; // happens for very short lived files
        }
 
        throwcall::good0(retval, "can't lstat ", path);
 
        if (!S_ISDIR(statbuf.st_mode)) {
            return S_ISLNK(statbuf.st_mode) ? watchDirectoryReturnType::islink : watchDirectoryReturnType::ignore;
        }
    }
 
    auto watchedDir = new watchedDirType(name, fd, parent);
 
    if (watchedDir->getId() == -1) { // vanmished or already watched
        delete watchedDir;
        return  watchDirectoryReturnType::vanished;
    }
 
    // with the subdir list we have only one open dir at a time
    std::list<std::string> subdirs;
    {
        auto result = opendir(path.c_str());
 
        if (result == nullptr && (errno == ENOENT || errno == ENOTDIR)) {
            delete watchedDir;
            return  watchDirectoryReturnType::vanished; // dir vanished before we could check the content
        }
 
        scoped::Dir dir(path, result);
 
        while (auto entry = readdir(dir)) {
            if (entry->d_name[entry->d_name[0] != '.' ? 0 : entry->d_name[1] != '.' ? 1 : 2] == '\0') {
                continue; // skip . .. and empty strings
            }
            if (entry->d_type == DT_DIR) {
                subdirs.emplace_back(entry->d_name);
            }
        }
    }
 
    for (auto& subname : subdirs) {
        watchDirectory(fd, subname, watchedDir);
    }
 
    return watchDirectoryReturnType::iswatched;
}

References watchedDirType::buildPath(), throwcall::good0(), ignore, islink, iswatched, and vanished.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function: