filewatcher.c

/**
 * @file filewatcher.c
 * Mode Control Entity - flag file tracking
 * <p>
 * Copyright (C) 2013-2019 Jolla Ltd.
 * <p>
 * @author Simo Piiroinen <simo.piiroinen@jollamobile.com>
 *
 * mce is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License
 * version 2.1 as published by the Free Software Foundation.
 *
 * mce 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with mce.  If not, see <http://www.gnu.org/licenses/>.
 */

#include "filewatcher.h"

#include "mce-log.h"

#include <sys/inotify.h>

#include <unistd.h>
#include <string.h>
#include <errno.h>

#define DEBUG_INOTIFY_EVENTS 0

static inline void *lea(const void *base, int offs)
{
  return ((char *)base)+offs;
}

/* ------------------------------------------------------------------------- *
 * Inotify event debugging helpers
 * ------------------------------------------------------------------------- */

#if DEBUG_INOTIFY_EVENTS
/** Convert inotify event bitmask to human readable string
 *
 * @param mask event bit mask
 * @param buff where to construct the string
 * @param size how much space buff has (must be > 0)
 *
 * @return string with names of set bits separated with '+'
 */
static
const char *
inotify_mask_repr(uint32_t mask, char *buff, size_t size)
{
  static const struct
  {
    uint32_t    mask;
    const char *name;
  } lut[] =
  {
# define X(tag) { .mask = IN_##tag, .name = #tag },
    X(ACCESS)
    X(MODIFY)
    X(ATTRIB)
    X(CLOSE_WRITE)
    X(CLOSE_NOWRITE)
    X(OPEN)
    X(MOVED_FROM)
    X(MOVED_TO)
    X(CREATE)
    X(DELETE)
    X(DELETE_SELF)
    X(MOVE_SELF)
    X(UNMOUNT)
    X(Q_OVERFLOW)
    X(IGNORED)
    X(ONLYDIR)
    X(DONT_FOLLOW)
    X(EXCL_UNLINK)
    X(MASK_ADD)
    X(ISDIR)
    X(ONESHOT)
# undef X
    { .mask = 0, .name = 0 }
  };

  char *pos = buff;
  char *end = buff + size - 1;

  auto void adds(const char *s)
  {
    while( *s && pos < end) *pos++ = *s++;
  }

  for( size_t i = 0; lut[i].mask; ++i )
  {
    if( mask & lut[i].mask )
    {
      mask ^= lut[i].mask;
      if( pos > buff ) adds("+");
      adds(lut[i].name);
    }
  }
  if( mask )
  {
    char hex[32];
    snprintf(hex, sizeof hex, "0x%"PRIx32, mask);
    if( pos > buff ) adds("+");
    adds(hex);
  }

  return *pos = 0, buff;
}

/** Emit inotify event details
 *
 * @param eve inotify_event pointer
 */
static
void
inotify_event_debug(const struct inotify_event *eve)
{
  char temp[256];
  printf("wd=%d\n", eve->wd);
  printf("mask=%s\n", inotify_mask_repr(eve->mask, temp, sizeof temp));
  if( eve->len )
  {
    printf("name=\"%s\"\n", eve->name);
  }
  printf("\n");
}
#endif /* DEBUG_INOTIFY_EVENTS */

/* ------------------------------------------------------------------------- *
 * File content change tracking
 * ------------------------------------------------------------------------- */

/** Object for tracking file content in a directory */
struct filewatcher_t
{
  /** inotify file descriptor */
  int inotify_fd;

  /** inotify watch descriptor */
  int inotify_wd;

  /** glib input watch for inotify_fd */
  guint watch_id;

  /** the directory to watch over */
  char *watch_path;

  /** the file in the watch_path to track */
  char *watch_file;

  /** function to call when watch_path/watch_file changes */
  filewatcher_changed_fn changed_cb;

  /** user data to pass to changed_cb */
  gpointer user_data;

  /** how to delete user_data when filewatcher_t is deleted */
  GDestroyNotify delete_cb;
};

/* Initialize filewatcher_t object to a sane state
 *
 * @param self pointer to uninitialized filewatcher_t object
 */
static
void
filewatcher_ctor(filewatcher_t *self)
{
  self->inotify_fd = -1;
  self->inotify_wd = -1;
  self->watch_path = 0;
  self->watch_file = 0;

  self->watch_id   = 0;

  self->changed_cb = 0;

  self->delete_cb  = 0;
  self->user_data  = 0;
}

/* Release all dynamic data from filewatcher_t object
 *
 * @param self pointer to initialized filewatcher_t object
 */
static
void
filewatcher_dtor(filewatcher_t *self)
{
  /* detach user data */
  if( self->delete_cb )
  {
    self->delete_cb(self->user_data);
  }
  self->user_data = 0;

  /* detach glib io watch */
  if( self->watch_id )
  {
    g_source_remove(self->watch_id), self->watch_id = 0;
  }

  /* detach inotify fd */
  if( self->inotify_fd != -1 )
  {
    if( self->inotify_wd != -1 )
    {
      if( inotify_rm_watch(self->inotify_fd, self->inotify_wd) == -1 )
      {
        mce_log(LL_WARN, "inotify_rm_watch: %m");
      }
      self->inotify_wd = -1;
    }
    if( close(self->inotify_fd) == -1 )
    {
      mce_log(LL_WARN, "close inotify fd: %m");
    }
    self->inotify_fd = -1;
  }

  /* release strings */
  g_free(self->watch_path), self->watch_path = 0;
  g_free(self->watch_file), self->watch_file = 0;
}

/* Delete a filewatcher_t object
 *
 * @param self pointer to initialized filewatcher_t object, or NULL
 */
void
filewatcher_delete(filewatcher_t *self)
{
  if( self != 0 )
  {
    filewatcher_dtor(self);
    g_free(self);
  }
}

/** Process inotify events
 *
 * @param self pointer to filewatcher_t object
 *
 * @return TRUE on success, or FALSE if further processing is not possible
 */
static
gboolean
filewatcher_process_events(filewatcher_t *self)
{
  gboolean res = FALSE;
  gboolean flg = FALSE;

  char buf[2048];
  int todo, size;
  struct inotify_event *eve;

  if( !self || self->inotify_fd == -1 )
  {
    goto cleanup;
  }

  todo = read(self->inotify_fd, buf, sizeof buf);

  if( todo < 0 )
  {
    switch( errno )
    {
    case EAGAIN:
    case EINTR:
      res = TRUE;
      break;

    default:
      mce_log(LL_WARN, "read inotify events: %m");
      break;
    }
    goto cleanup;
  }

  if( todo == 0 )
  {
    mce_log(LL_WARN, "read inotify events: EOF");
    goto cleanup;
  }

#if DEBUG_INOTIFY_EVENTS
  printf("----\n");
#endif

  for( eve = lea(buf, 0); todo; todo -= size, eve = lea(eve, size))
  {
    if( todo < (int)sizeof *eve )
    {
      mce_log(LL_WARN, "partial inotify event received");
      goto cleanup;
    }

    size = sizeof *eve + eve->len;

    if( todo < size )
    {
      mce_log(LL_WARN, "oversized inotify event received");
      goto cleanup;
    }

#if DEBUG_INOTIFY_EVENTS
    inotify_event_debug(eve);
#endif

    if( eve->len && !strcmp(self->watch_file, eve->name) )
    {
      flg = TRUE;
    }

    if( eve->mask & IN_IGNORED )
    {
      mce_log(LL_ERR, "inotify watch went defunct");
      flg = TRUE;
      goto cleanup;
    }
  }

  res = TRUE;

cleanup:

  if( flg && self && self->changed_cb )
  {
    self->changed_cb(self->watch_path, self->watch_file, self->user_data);
  }

  return res;
}

/** Glib io glue for processing inotify event input
 *
 * @param source (not used)
 * @param condition (not used)
 * @param data pointer to filewatcher_t object (as void pointer)
 *
 * @return TRUE to keep the io watch alive, or
 *         FALSE if the io watch must be released
 */
static
gboolean
filewatcher_input_cb(GIOChannel *source,
                     GIOCondition condition,
                     gpointer data)
{
  (void)source;

  filewatcher_t *self = data;
  gboolean keep_going = TRUE;

  if( condition & (G_IO_ERR | G_IO_HUP | G_IO_NVAL) )
  {
    keep_going = FALSE;
  }

  if( !filewatcher_process_events(self) )
  {
    keep_going = FALSE;
  }

  if( !keep_going )
  {
    /* Note: This /should/ never happen, but if it does
     *       we must not leave the io watch in a state
     *       where it gets triggered forever. */
    mce_log(LL_CRIT, "stopping inotify event io watch");
    self->watch_id = 0;
  }

  return keep_going;
}

/** Helper for setting up inotify file descriptor
 *
 * @note This function is meant to be called form
 *       filewatcher_create() function only!
 *
 * @param self pointer to filewatcher_t object
 *
 * @return TRUE on success, or FALSE on failure
 */
static
gboolean
filewatcher_setup_inotify(filewatcher_t *self)
{
  gboolean success = FALSE;

  uint32_t mask = (0
                   | IN_CREATE
                   | IN_DELETE
                   | IN_CLOSE_WRITE
                   | IN_MOVED_TO
                   | IN_MOVED_FROM
                   | IN_DONT_FOLLOW
                   | IN_ONLYDIR);

  self->inotify_fd = inotify_init1(IN_CLOEXEC);
  if( self->inotify_fd == -1 )
  {
    mce_log(LL_WARN, "inotify_init: %m");
    goto cleanup;
  }

  self->inotify_wd = inotify_add_watch(self->inotify_fd,
                                       self->watch_path,  mask);
  if( self->inotify_wd == -1 )
  {
    mce_log(LL_WARN, "%s: inotify_add_watch: %m", self->watch_path);
    goto cleanup;
  }

  success = TRUE;

cleanup:
  return success;
}

/** Helper for setting up glib io watch for inotify file descriptor
 *
 * @note This function is meant to be called form
 *       filewatcher_create() function only!
 *
 * @param self pointer to filewatcher_t object
 *
 * @return TRUE on success, or FALSE on failure
 */
static
gboolean
filewatcher_setup_iowatch(filewatcher_t *self)
{
  gboolean success = FALSE;

  GIOChannel *chan  = 0;
  GError     *err   = 0;

  if( !(chan = g_io_channel_unix_new(self->inotify_fd)) )
  {
    mce_log(LL_WARN, "%s: %m", "g_io_channel_unix_new");
    goto cleanup;
  }

  /* the channel does not own the fd  */
  g_io_channel_set_close_on_unref(chan, FALSE);

  /* Set to NULL encoding so that we can turn off the buffering */
  if( g_io_channel_set_encoding(chan, NULL, &err) != G_IO_STATUS_NORMAL )
  {
    mce_log(LL_WARN, "%s: %s", "g_io_channel_set_encoding",
            (err && err->message) ? err->message : "unknown");
  }
  g_io_channel_set_buffered(chan, FALSE);

  self->watch_id = g_io_add_watch(chan,
                                  G_IO_IN | G_IO_ERR | G_IO_HUP | G_IO_NVAL,
                                  filewatcher_input_cb, self);

  if( !self->watch_id )
  {
    mce_log(LL_WARN, "%s: %m", "g_io_add_watch");
    goto cleanup;
  }

  success = TRUE;

cleanup:

  g_clear_error(&err);

  if( chan ) g_io_channel_unref(chan);

  return success;
}

/** Create an filewatcher_t object
 *
 * An inotify watcher is started for the given director/file.
 * A glib io watch is used to process the inotify events.
 * The change_cb is called when contents of the tracked file
 * are assumed to have changed.
 *
 * @note The change_cb function will not be called during the
 *       initialization. You can make initial state evaluation
 *       to happen by calling filewatcher_force_trigger() after
 *       succesfull filewatcher_create().
 *
 * @param dirpath directory to watch over
 * @param filename file to watch in dirpath
 * @param change_cb function to call when dirpath/filename changes
 * @param user_data extra parameter to pass to change_cb
 * @param delete_cb called on user_data when filewatcher_t itself is deleted
 *
 * @return pointer to filewatcher_t object, or NULL in case of errors
 */
filewatcher_t *
filewatcher_create(const char *dirpath,
                   const char *filename,
                   filewatcher_changed_fn change_cb,
                   gpointer user_data,
                   GDestroyNotify delete_cb)
{
  gboolean success = FALSE;

  filewatcher_t *self = g_malloc0(sizeof *self);
  filewatcher_ctor(self);

  self->watch_path = g_strdup(dirpath);
  self->watch_file = g_strdup(filename);

  self->changed_cb = change_cb;

  self->user_data  = user_data;
  self->delete_cb  = delete_cb;

  if( !filewatcher_setup_inotify(self) )
  {
    goto cleanup;
  }
  if( !filewatcher_setup_iowatch(self) )
  {
    goto cleanup;
  }

  success = TRUE;

cleanup:

  if( !success )
  {
    filewatcher_delete(self), self = 0;
  }

  return self;
}

/** Force calling the change notification callback
 *
 * This can be useful for example to feed initial
 * state of tracked file via the same mechanism as
 * the later changes get reported
 *
 * @param self pointer to filewatcher_t object
 */
void
filewatcher_force_trigger(filewatcher_t *self)
{
  if( self->changed_cb )
  {
    self->changed_cb(self->watch_path, self->watch_file, self->user_data);
  }
}