monitor.h File Reference

Monitor files for changes. More...

#include <stdbool.h>

Include dependency graph for monitor.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
int	mutt_monitor_add (struct Mailbox *m)
	Add a watch for a mailbox.
int	mutt_monitor_remove (struct Mailbox *m)
	Remove a watch for a mailbox.
int	mutt_monitor_poll (void)
	Check for filesystem changes.

Variables
bool	MonitorFilesChanged
	true after a monitored file has changed
bool	MonitorCurMboxChanged
	true after the current mailbox has changed

Detailed Description

Monitor files for changes.

Authors

• Gero Treuner
• Richard Russon

Copyright

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 2 of the License, or (at your option) any later version.

This program 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 General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Definition in file monitor.h.

Function Documentation

mutt_monitor_add()

int mutt_monitor_add

(

struct Mailbox *

m

)

Add a watch for a mailbox.

Parameters

m	Mailbox to watch

Return values

0	success: new or already existing monitor
-1	failed: no mailbox, inaccessible file, create monitor/watcher failed

If m is NULL, try to get the current mailbox from the Index.

Definition at line 484 of file monitor.c.

{
  struct MonitorInfo info = { 0 };
 
  int rc = 0;
  enum ResolveResult desc = monitor_resolve(&info, m);
  if (desc != RESOLVE_RES_OK_NOTEXISTING)
  {
    if (!m && (desc == RESOLVE_RES_OK_EXISTING))
      MonitorCurMboxDescriptor = info.monitor->desc;
    rc = (desc == RESOLVE_RES_OK_EXISTING) ? 0 : -1;
    goto cleanup;
  }
 
  uint32_t mask = info.is_dir ? INOTIFY_MASK_DIR : INOTIFY_MASK_FILE;
  if (((INotifyFd == -1) && (monitor_init() == -1)) ||
      ((desc = inotify_add_watch(INotifyFd, info.path, mask)) == -1))
  {
    mutt_debug(LL_DEBUG2, "inotify_add_watch failed for '%s', errno=%d %s\n",
               info.path, errno, strerror(errno));
    rc = -1;
    goto cleanup;
  }
 
  mutt_debug(LL_DEBUG3, "inotify_add_watch descriptor=%d for '%s'\n", desc, info.path);
  if (!m)
    MonitorCurMboxDescriptor = desc;
 
  monitor_new(&info, desc);
 
cleanup:
  monitor_info_free(&info);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_monitor_remove()

int mutt_monitor_remove

(

struct Mailbox *

m

)

Remove a watch for a mailbox.

Parameters

m

Mailbox

Return values

0	monitor removed (not shared)
1	monitor not removed (shared)
2	no monitor

If m is NULL, try to get the current mailbox from the Index.

Definition at line 528 of file monitor.c.

{
  struct MonitorInfo info = { 0 };
  struct MonitorInfo info2 = { 0 };
  int rc = 0;
 
  if (!m)
  {
    MonitorCurMboxDescriptor = -1;
    MonitorCurMboxChanged = false;
  }
 
  if (monitor_resolve(&info, m) != RESOLVE_RES_OK_EXISTING)
  {
    rc = 2;
    goto cleanup;
  }
 
  struct Mailbox *m_cur = get_current_mailbox();
  if (m_cur)
  {
    if (m)
    {
      if ((monitor_resolve(&info2, NULL) == RESOLVE_RES_OK_EXISTING) &&
          (info.st_ino == info2.st_ino) && (info.st_dev == info2.st_dev))
      {
        rc = 1;
        goto cleanup;
      }
    }
    else
    {
      if (mailbox_find(m_cur->realpath))
      {
        rc = 1;
        goto cleanup;
      }
    }
  }
 
  inotify_rm_watch(info.monitor->desc, INotifyFd);
  mutt_debug(LL_DEBUG3, "inotify_rm_watch for '%s' descriptor=%d\n", info.path,
             info.monitor->desc);
 
  monitor_delete(info.monitor);
  monitor_check_cleanup();
 
cleanup:
  monitor_info_free(&info);
  monitor_info_free(&info2);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_monitor_poll()

int mutt_monitor_poll

(

void

)

Check for filesystem changes.

Return values

-3	unknown/unexpected events: poll timeout / fds not handled by us
-2	monitor detected changes, no STDIN input
-1	error (see errno)
0	(1) input ready from STDIN, or (2) monitoring inactive -> no poll()

Wait for I/O ready file descriptors or signals.

MonitorFilesChanged also reflects changes to monitored files.

Only STDIN and INotify file handles currently expected/supported. More would ask for common infrastructure (sockets?).

Definition at line 401 of file monitor.c.

{
  int rc = 0;
  char buf[EVENT_BUFLEN]
      __attribute__((aligned(__alignof__(struct inotify_event)))) = { 0 };
 
  MonitorFilesChanged = false;
 
  if (INotifyFd != -1)
  {
    int fds = poll(PollFds, PollFdsCount, 1000); // 1 Second
 
    if (fds == -1)
    {
      rc = -1;
      if (errno != EINTR)
      {
        mutt_debug(LL_DEBUG2, "poll() failed, errno=%d %s\n", errno, strerror(errno));
      }
    }
    else
    {
      bool input_ready = false;
      for (int i = 0; fds && (i < PollFdsCount); i++)
      {
        if (PollFds[i].revents)
        {
          fds--;
          if (PollFds[i].fd == 0)
          {
            input_ready = true;
          }
          else if (PollFds[i].fd == INotifyFd)
          {
            MonitorFilesChanged = true;
            mutt_debug(LL_DEBUG3, "file change(s) detected\n");
            char *ptr = buf;
            const struct inotify_event *event = NULL;
 
            while (true)
            {
              int len = read(INotifyFd, buf, sizeof(buf));
              if (len == -1)
              {
                if (errno != EAGAIN)
                {
                  mutt_debug(LL_DEBUG2, "read inotify events failed, errno=%d %s\n",
                             errno, strerror(errno));
                }
                break;
              }
 
              while (ptr < (buf + len))
              {
                event = (const struct inotify_event *) ptr;
                mutt_debug(LL_DEBUG3, "+ detail: descriptor=%d mask=0x%x\n",
                           event->wd, event->mask);
                if (event->mask & IN_IGNORED)
                  monitor_handle_ignore(event->wd);
                else if (event->wd == MonitorCurMboxDescriptor)
                  MonitorCurMboxChanged = true;
                ptr += sizeof(struct inotify_event) + event->len;
              }
            }
          }
        }
      }
      if (!input_ready)
        rc = MonitorFilesChanged ? -2 : -3;
    }
  }
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

MonitorFilesChanged

bool MonitorFilesChanged

extern

true after a monitored file has changed

Set to true when a monitored file has changed.

true after a monitored file has changed

Definition at line 53 of file monitor.c.

MonitorCurMboxChanged

bool MonitorCurMboxChanged

extern

true after the current mailbox has changed

Set to true when the current mailbox has changed.

true after the current mailbox has changed

Definition at line 55 of file monitor.c.