added /:/info pseudofile (just a sample)

[k8muffin.git] / src / fusedrv / fusedrv.c

#define FUSE_USE_VERSION  26

#ifndef _BSD_SOURCE
# define _BSD_SOURCE
#endif
#ifndef _GNU_SOURCE
# define _GNU_SOURCE
#endif

#include <ctype.h>
#include <dirent.h>
#include <errno.h>
#include <fcntl.h>
#include <fuse.h>
#include <iconv.h>
#include <libgen.h>
#include <limits.h>
#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <unistd.h>

#include <sys/stat.h>
#include <sys/types.h>
#include <sys/xattr.h>

#include "../libdbg/dbglog.h"
#include "../uthash.h"
#include "translit.h"


////////////////////////////////////////////////////////////////////////////////
#include "../tagload.c"
#include "../search.c"


////////////////////////////////////////////////////////////////////////////////
//#define CTR ((my_data_struct_t *)(fuse_get_context()->private_data))


// report errors to logfile and give -errno to caller
/*
static int tfs_error (const char *str) {
  int ret = -errno;
  dlogf("  ERROR %s: %s", str, strerror(errno));
  return ret;
}
*/


static tagvalue_t *find_by_tag_name (const char *name, tagvalue_t **hash) {
  tagvalue_t *tv;
  const char *t = strrchr(name, '/');
  if (t == NULL) t = name; else ++t;
  HASH_FIND_STR(*hash, t, tv);
  return tv;
}



// short names are unique, so we can skip queries
static file_info_t *find_by_short_name (const char *path) {
  file_sname_t *sf;
  const char *t = strrchr(path, '/');
  if (t == NULL) t = path; else ++t;
  HASH_FIND_STR(file_sname_hash, t, sf);
  return (sf != NULL ? sf->fi : NULL);
}


////////////////////////////////////////////////////////////////////////////////
typedef struct {
  int fd; // <0: internal file
  int size;
  char *data;
  //UT_hash_handle hh;
} filehandle_t;


//static filehandle_t *fhandles = NULL;


static filehandle_t *colon_create_info_file (const char *path) {
  filehandle_t *fh = NULL;
  dlogf("colon_create_info_file: [%s]\n", path);
  if (strcmp(path, "/:/info") == 0) {
    fh = calloc(1, sizeof(*fh));
    fh->fd = -1;
    fh->data = calloc(8192, 1);
    snprintf(fh->data, 8192, "files: %d; otags: %d; ntags: %d\n", HASH_COUNT(file_name_hash), HASH_COUNT(tagv_hash_o), HASH_COUNT(tagv_hash_t));
    fh->size = strlen(fh->data);
  }
  return fh;
}


static filehandle_t *fht_open (const char *realpath) {
  int fd = open(realpath, O_RDONLY);
  if (fd >= 0) {
    filehandle_t *fh = calloc(1, sizeof(*fh));
    fh->fd = fd;
    return fh;
  }
  return NULL;
}


static void fht_close (filehandle_t *fh) {
  if (fh != NULL) {
    if (fh->fd >= 0) close(fh->fd);
    if (fh->data != NULL) free(fh->data);
    free(fh);
  }
}


static int fht_read (const char *path, char *buf, size_t size, off_t offset, filehandle_t *fh) {
  if (fh != NULL) {
    if (fh->fd >= 0) {
      ssize_t rd;
      //dlogf("tfs_read: path=[%s], buf=0x%p, size=%d, offset=%lld, fi=0x%p", path, buf, size, offset, fi);
      if (fh->fd < 0) return -EPERM;
      if (offset >= 0x7fffffff || size >= 0x7fffffff) return 0;/*-EPERM;*/ //???
      if (lseek(fh->fd, offset, SEEK_SET) == (off_t)-1) return -EPERM;
      rd = read(fh->fd, buf, size);
      if (rd < 0) return -EPERM;
      return rd;
    }
    if (fh->data != NULL) {
      if (offset >= fh->size) return 0;
      if ((uint64_t)offset+size > fh->size) size = fh->size-offset;
      if (size == 0) return 0;
      memcpy(buf, fh->data+offset, size);
      return size;
    }
  }
  return -EPERM;
}


////////////////////////////////////////////////////////////////////////////////
// this is used in getattr() and readdir()
// note that readdir() will call this with 'filename.ext' and getattr() will call this with full path
static int do_stat (const char *path, struct stat *statbuf, int do_real_stat) {
  file_info_t *nfo;
  const char *name;
  memset(statbuf, 0, sizeof(*statbuf));
  //
  //FIXME!
  statbuf->st_uid = fuse_get_context()->uid;
  statbuf->st_gid = fuse_get_context()->gid;
  //
  statbuf->st_mode = S_IFDIR|0555;
  //TODO: set to 2? do we rally want 'find' to work on muffin?
  statbuf->st_nlink = 1; // actually, this should be set to 'subdir_count+2' (or 1), else 'find' will fail
  //
  if (strcmp(path, "/") == 0 || strcmp(path, "/:otags") == 0 || strcmp(path, "/:") == 0) return 0;
  if (strncmp(path, "/:/", 3) == 0) {
    // all files are regular ones here
    statbuf->st_mode = S_IFREG|0444;
    statbuf->st_size = 4096; // arbitrary, but must be bigger than the actual 'info' files
    return 0;
  }
  //
  name = strrchr(path, '/');
  if (name == NULL) name = path; else ++name;
  //
  if (name[0] == ':') {
    for (size_t f = 0; f < ARRAYLEN(specdirs); ++f) if (strcmp(specdirs[f], name) == 0) return 0;
    if (strcmp(name, ":files") == 0) return 0;
    return -ENOENT;
  }
  //
  if ((nfo = find_by_short_name(name)) != NULL) {
    // normal file
    if (do_real_stat) {
      if (stat(nfo->fullname, statbuf) == 0) return 0;
      return -ENOENT; //TODO: return better error here
    }
    statbuf->st_mode = S_IFREG|0444;
    return 0;
  }
  //
  if (find_by_tag_name(name, &tagv_hash_t) != NULL || find_by_tag_name(name, &tagv_hash_o) != NULL) return 0; // this is dirs too
  //
  return -ENOENT;
}


/** Get file attributes.
 *
 * Similar to stat().  The 'st_dev' and 'st_blksize' fields are
 * ignored.  The 'st_ino' field is ignored except if the 'use_ino'
 * mount option is given.
 */
static int tfs_getattr (const char *path, struct stat *statbuf) {
  //dlogf("tfs_getattr: path=[%s]", path);
  return do_stat(path, statbuf, 1);
}


/** Read the target of a symbolic link
 *
 * The buffer should be filled with a null terminated string.  The
 * buffer size argument includes the space for the terminating
 * null character.  If the linkname is too long to fit in the
 * buffer, it should be truncated.  The return value should be 0
 * for success.
 */
// Note the system readlink() will truncate and lose the terminating
// null.  So, the size passed to to the system readlink() must be one
// less than the size passed to tfs_readlink()
static int tfs_readlink (const char *path, char *link, size_t size) {
  //dlogf("tfs_readlink: path=[%s]", path);
  return -ENOENT; // there are no symlinks
}


/** Create a file node
 *
 * This is called for creation of all non-directory, non-symlink
 * nodes.  If the filesystem defines a create() method, then for
 * regular files that will be called instead.
 */
static int tfs_mknod (const char *path, mode_t mode, dev_t dev) {
  //dlogf("tfs_mknod: path=[%s], mode=0%03o, dev=%lld", path, mode, dev);
  //
  //if (!S_ISREG(mode)) return -EINVAL; // only regular files can be created
  // no new files can be created here
  //return (exists ? EEXIST : EFAULT);
  return -EFAULT;
}


/** Create a directory
 *
 * Note that the mode argument may not have the type specification
 * bits set, i.e. S_ISDIR(mode) can be false.  To obtain the
 * correct directory type bits use  mode|S_IFDIR
 */
static int tfs_mkdir (const char *path, mode_t mode) {
  //dlogf("tfs_mkdir: path=[%s], mode=0%03o", path, mode);
  // no new directories can be created here
  return -EFAULT;
}


/** Remove a file */
static int tfs_unlink (const char *path) {
  //dlogf("tfs_unlink: path=[%s]", path);
  return -EFAULT;
}


/** Remove a directory */
static int tfs_rmdir (const char *path) {
  //dlogf("tfs_rmdir: path=[%s]", path);
  return -EFAULT;
}


/** Create a symbolic link */
// The parameters here are a little bit confusing, but do correspond
// to the symlink() system call.  The 'path' is where the link points,
// while the 'link' is the link itself.  So we need to leave the path
// unaltered, but insert the link into the mounted directory.
static int tfs_symlink (const char *path, const char *link) {
  //dlogf("tfs_symlink: path=[%s]; link=[%s]", path, link);
  return -EFAULT;
}


/** Rename a file */
// both path and newpath are fs-relative
static int tfs_rename (const char *path, const char *newpath) {
  //dlogf("tfs_rename: path=[%s]; newpath=[%s]", path, newpath);
  return -EFAULT;
}


/** Create a hard link to a file */
static int tfs_link (const char *path, const char *newpath) {
  //dlogf("tfs_link: path=[%s]; newpath=[%s]", path, newpath);
  return -EFAULT;
}


/** Change the permission bits of a file */
static int tfs_chmod (const char *path, mode_t mode) {
  //dlogf("tfs_chmod: path=[%s], mode=0%03o", path, mode);
  return 0;
}


/** Change the owner and group of a file */
static int tfs_chown (const char *path, uid_t uid, gid_t gid) {
  //dlogf("tfs_chown: path=[%s], uid=%d, gid=%d", path, uid, gid);
  return 0;
}


/** Change the size of a file */
static int tfs_truncate (const char *path, off_t newsize) {
  //dlogf("tfs_truncate: path=[%s], newsize=%lld", path, newsize);
  return -EFAULT;
}


/** Change the access and/or modification times of a file
 *
 * Deprecated, use utimens() instead.
 */
/*
static int tfs_utime (const char *path, struct utimbuf *ubuf) {
  return 0;
}
*/


/** File open operation
 *
 * No creation (O_CREAT, O_EXCL) and by default also no
 * truncation (O_TRUNC) flags will be passed to open(). If an
 * application specifies O_TRUNC, fuse first calls truncate()
 * and then open(). Only if 'atomic_o_trunc' has been
 * specified and kernel version is 2.6.24 or later, O_TRUNC is
 * passed on to open.
 *
 * Unless the 'default_permissions' mount option is given,
 * open should check if the operation is permitted for the
 * given flags. Optionally open may also return an arbitrary
 * filehandle in the fuse_file_info structure, which will be
 * passed to all file operations.
 *
 * Changed in version 2.2
 */
static int tfs_open (const char *path, struct fuse_file_info *fi) {
  file_info_t *nfo;
  filehandle_t *fh = NULL;
  //dlogf("tfs_open: path=[%s], fi=0x%p; append=%d; trunc=%d\n", path, fi, (fi->flags&O_APPEND ? 1 : 0), (fi->flags&O_TRUNC ? 1 : 0));
  if ((fi->flags&O_APPEND) || (fi->flags&O_TRUNC)) {
    //dlogf(" bad flags!\n");
    return -EPERM;
  }
  switch (fi->flags&(O_RDONLY|O_WRONLY|O_RDWR)) {
    case O_RDONLY: break;
    case O_WRONLY:
    case O_RDWR:
      //dlogf(" bad access mode!\n");
      return -EPERM;
  }
  //
  if (strncmp(path, "/:/", 3) == 0) {
    fh = colon_create_info_file(path);
  } else {
    if ((nfo = find_by_short_name(path)) != NULL) {
      //dlogf(" found: [%s]\n", nfo->fullname);
      fh = fht_open(nfo->fullname);
    }
  }
  if (fh != NULL) {
    fi->fh = (uintptr_t)fh;
    return 0;
  }
  //dlogf(" shit!\n");
  return -ENOENT;
}


/** Read data from an open file
 *
 * Read should return exactly the number of bytes requested except
 * on EOF or error, otherwise the rest of the data will be
 * substituted with zeroes.  An exception to this is when the
 * 'direct_io' mount option is specified, in which case the return
 * value of the read system call will reflect the return value of
 * this operation.
 *
 * Changed in version 2.2
 */
static int tfs_read (const char *path, char *buf, size_t size, off_t offset, struct fuse_file_info *fi) {
  filehandle_t *fh = (filehandle_t *)(uintptr_t)(fi->fh);
  return fht_read(path, buf, size, offset, fh);
}


/** Write data to an open file
 *
 * Write should return exactly the number of bytes requested
 * except on error.  An exception to this is when the 'direct_io'
 * mount option is specified (see read operation).
 *
 * Changed in version 2.2
 */
static int tfs_write (const char *path, const char *buf, size_t size, off_t offset, struct fuse_file_info *fi) {
  //dlogf("tfs_write: path=[%s], buf=0x%p, size=%d, offset=%lld, fi=0x%p", path, buf, size, offset, fi);
  return -EPERM;
}


/** Get file system statistics
 *
 * The 'f_frsize', 'f_favail', 'f_fsid' and 'f_flag' fields are ignored
 *
 * Replaced 'struct statfs' parameter with 'struct statvfs' in
 * version 2.5
 */
static int tfs_statfs (const char *path, struct statvfs *statv) {
  return -EPERM;
  //
  //statvfs
  //memset(statv, 0, sizeof(*statv));
  //statv->f_bsize = 8192; // fixme
  //dlogf("tfs_statfs: path=[%s], statv=0x%p", path, statv);
  //return retstat;
}


/** Possibly flush cached data
 *
 * BIG NOTE: This is not equivalent to fsync().  It's not a
 * request to sync dirty data.
 *
 * Flush is called on each close() of a file descriptor.  So if a
 * filesystem wants to return write errors in close() and the file
 * has cached dirty data, this is a good place to write back data
 * and return any errors.  Since many applications ignore close()
 * errors this is not always useful.
 *
 * NOTE: The flush() method may be called more than once for each
 * open().  This happens if more than one file descriptor refers
 * to an opened file due to dup(), dup2() or fork() calls.  It is
 * not possible to determine if a flush is final, so each flush
 * should be treated equally.  Multiple write-flush sequences are
 * relatively rare, so this shouldn't be a problem.
 *
 * Filesystems shouldn't assume that flush will always be called
 * after some writes, or that if will be called at all.
 *
 * Changed in version 2.2
 */
static int tfs_flush (const char *path, struct fuse_file_info *fi) {
  //dlogf("tfs_flush: path=[%s], fi=0x%p", path, fi);
  return 0;
}


/** Release an open file
 *
 * Release is called when there are no more references to an open
 * file: all file descriptors are closed and all memory mappings
 * are unmapped.
 *
 * For every open() call there will be exactly one release() call
 * with the same flags and file descriptor.  It is possible to
 * have a file opened more than once, in which case only the last
 * release will mean, that no more reads/writes will happen on the
 * file.  The return value of release is ignored.
 *
 * Changed in version 2.2
 */
static int tfs_release (const char *path, struct fuse_file_info *fi) {
  filehandle_t *fh = (filehandle_t *)(uintptr_t)(fi->fh);
  fht_close(fh);
  fi->fh = 0;
  return 0;
}


/** Synchronize file contents
 *
 * If the datasync parameter is non-zero, then only the user data
 * should be flushed, not the meta data.
 *
 * Changed in version 2.2
 */
static int tfs_fsync (const char *path, int datasync, struct fuse_file_info *fi) {
  //dlogf("tfs_fsync: path=[%s], datasync=%d, fi=0x%p", path, datasync, fi);
  return 0;
}


/** Set extended attributes */
static int tfs_setxattr (const char *path, const char *name, const char *value, size_t size, int flags) {
  //dlogf("tfs_setxattr: path=[%s], name=[%s], value=[%s], size=%d, flags=0x%08x", path, name, value, size, (unsigned int)flags);
  return -EPERM;
}


/** Get extended attributes */
// If the given node described by path has the named extended attribute, and the vlen is zero,
// return the number of bytes required to provide the value of the extended attribute.
// The next call will have a buffer that is long enough to hold the value. Copy the value into
// the buffer and return the number of bytes that the value occupies.
static int tfs_getxattr (const char *path, const char *name, char *value, size_t size) {
  //dlogf("tfs_getxattr: path=[%s], name=[%s], value=0x%p, size=%d", path, name, value, size);
  if (name != NULL && name[0]) {
    file_info_t *nfo;
    const char *val = NULL;
    int len;
    if ((nfo = find_by_short_name(path)) == NULL) return -ENOENT;
    if (strcmp(name, "user.realname") == 0) {
      val = nfo->fullname;
    } else if (strcmp(name, "user.oartist") == 0 || strcmp(name, "user.artist") == 0) {
      if (nfo->artist_o != NULL) val = nfo->artist_o->s;
    } else if (strcmp(name, "user.oalbum") == 0 || strcmp(name, "user.album") == 0) {
      if (nfo->album_o != NULL) val = nfo->album_o->s;
    } else if (strcmp(name, "user.otitle") == 0 || strcmp(name, "user.title") == 0) {
      if (nfo->title_o != NULL) val = nfo->title_o->s;
    } else if (strcmp(name, "user.ogenre") == 0 || strcmp(name, "user.genre") == 0) {
      if (nfo->genre_o != NULL) val = nfo->genre_o->s;
    } else if (strcmp(name, "user.oyear") == 0 || strcmp(name, "user._year") == 0 || strcmp(name, "user.year") == 0) {
      if (nfo->year_o != NULL) val = nfo->year_o->s;
    } else if (strcmp(name, "user._artist") == 0) {
      if (nfo->artist_t != NULL) val = nfo->artist_t->s;
    } else if (strcmp(name, "user._album") == 0) {
      if (nfo->album_t != NULL) val = nfo->album_t->s;
    } else if (strcmp(name, "user._title") == 0) {
      if (nfo->title_t != NULL) val = nfo->title_t->s;
    } else if (strcmp(name, "user._genre") == 0) {
      if (nfo->genre_t != NULL) val = nfo->genre_t->s;
    }
    if (val != NULL) {
      len = strlen(val);
      if (size > 0 && len > 0) memcpy(value, val, len);
      return len;
    }
    return 0;
  }
  //return -EPERM;
  return 0;
}


#define STRXCPY(str)  do { \
  const char *s = (str); \
  if (s != NULL && s[0]) { \
    int xlen = strlen(s)+1; \
    if (list != NULL) { memcpy(list, s, xlen); list += xlen; } \
    tlen += xlen; \
  } \
} while (0)


static inline int ok_tv (const tagvalue_t *tv, const char *unk) {
  if (tv != NULL) {
    if (unk != NULL && strcmp(unk, tv->s) == 0) return 0;
    if (tv->s[0] == 0) return 0;
    return 1;
  }
  return 0;
}


/** List extended attributes */
// size: the same note as for getxattr applies here.
// fill 'list' with asciiz-strings, one just after another.
// note that 'getfattr -d' lists only 'user.' attributes
static int tfs_listxattr (const char *path, char *list, size_t size) {
  file_info_t *nfo;
  int tlen = 0;
  //dlogf("tfs_listxattr: path=[%s], list=0x%p, size=%d", path, list, size);
  if ((nfo = find_by_short_name(path)) == NULL) return -ENOENT;
  STRXCPY("user.realname");
  //
  if (ok_tv(nfo->artist_o, "unknown artist")) STRXCPY("user.artist");
  if (ok_tv(nfo->album_o, "unknown album")) STRXCPY("user.album");
  if (ok_tv(nfo->title_o, "unknown title")) STRXCPY("user.title");
  if (ok_tv(nfo->genre_o, "unknown genre")) STRXCPY("user.genre");
  if (ok_tv(nfo->year_o, NULL)) STRXCPY("user.year");
  //
  if (ok_tv(nfo->artist_t, "unknown artist")) STRXCPY("user._artist");
  if (ok_tv(nfo->album_t, "unknown album")) STRXCPY("user._album");
  if (ok_tv(nfo->title_t, "unknown title")) STRXCPY("user._title");
  if (ok_tv(nfo->genre_t, "unknown genre")) STRXCPY("user._genre");
  //
  return tlen;
  //return -EPERM;
}


/** Remove extended attributes */
static int tfs_removexattr (const char *path, const char *name) {
  //dlogf("tfs_removexattr: path=[%s], name=[%s]", path, name);
  return -EPERM;
}


/** Open directory
 *
 * Unless the 'default_permissions' mount option is given,
 * this method should check if opendir is permitted for this
 * directory. Optionally opendir may also return an arbitrary
 * filehandle in the fuse_file_info structure, which will be
 * passed to readdir, closedir and fsyncdir.
 *
 * Introduced in version 2.3
 */
static int tfs_opendir (const char *path, struct fuse_file_info *fi) {
  dirinfo_t *odir = list_dir(path);
  if (odir == NULL) return -EPERM;
  //dlogf("tfs_opendir: path=[%s], %d entries", path, odir->fcount);
  fi->fh = (uintptr_t)odir; // fh is 64 bit, so this is safe
  return 0;
}


/** Read directory
 *
 * This supersedes the old getdir() interface.  New applications
 * should use this.
 *
 * The filesystem may choose between two modes of operation:
 *
 * 1) The readdir implementation ignores the offset parameter, and
 * passes zero to the filler function's offset.  The filler
 * function will not return '1' (unless an error happens), so the
 * whole directory is read in a single readdir operation.  This
 * works just like the old getdir() method.
 *
 * 2) The readdir implementation keeps track of the offsets of the
 * directory entries.  It uses the offset parameter and always
 * passes non-zero offset to the filler function.  When the buffer
 * is full (or an error happens) the filler function will return
 * '1'.
 *
 * Introduced in version 2.3
 */
/*
 * typedef int (*fuse_fill_dir_t) (void *buf, const char *name, const struct stat *stbuf, off_t off);
 */
static int tfs_readdir (const char *path, void *buf, fuse_fill_dir_t filler, off_t offset, struct fuse_file_info *fi) {
  dirinfo_t *odir = (dirinfo_t *)(uintptr_t)fi->fh;
  struct stat stbuf, *starg = &stbuf;
  //dlogf("tfs_readdir: path=[%s], buf=0x%p, filler=0x%p, offset=%lld, fi=0x%p", path, buf, filler, offset, fi);
  if (odir == NULL) return -EPERM;
  //dlogf("tfs_readdir: path=[%s], %d entries", path, odir->fcount);
  if (offset < 0 || offset >= odir->fcount) return 0;
  // we can build 'struct stat' here, so readdir() will return some useful flags
  // but this is not really necessary, and we can just pass NULL
  if (do_stat(odir->names[offset], starg, 0) != 0) starg = NULL; // don't pass anything on error
  if (filler(buf, odir->names[offset], starg, offset+1)) {
    //dlogf("tfs_readdir: path=[%s], filler failed!", path);
    return -ENOMEM;
  }
  //dlogf("tfs_readdir: path=[%s], name=[%s]", path, odir->names[offset]);
  return 0;
}


/** Release directory
 *
 * Introduced in version 2.3
 */
static int tfs_releasedir (const char *path, struct fuse_file_info *fi) {
  dirinfo_t *odir = (dirinfo_t *)(uintptr_t)fi->fh;
  //dlogf("tfs_releasedir: path=[%s], fi=0x%p", path, fi);
  if (odir == NULL) return -EPERM;
  if (odir->names != NULL) free(odir->names);
  free(odir);
  fi->fh = 0;
  return 0;
}


/** Synchronize directory contents
 *
 * If the datasync parameter is non-zero, then only the user data
 * should be flushed, not the meta data
 *
 * Introduced in version 2.3
 */
// when exactly is this called?  when a user calls fsync and it
// happens to be a directory? ???
static int tfs_fsyncdir (const char *path, int datasync, struct fuse_file_info *fi) {
  //dlogf("tfs_fsyncdir: path=[%s], datasync=%d, fi=0x%p", path, datasync, fi);
  return 0;
}


/**
 * Initialize filesystem
 *
 * The return value will passed in the private_data field of
 * fuse_context to all file operations and as a parameter to the
 * destroy() method.
 *
 * Introduced in version 2.3
 * Changed in version 2.6
 */
// Undocumented but extraordinarily useful fact:  the fuse_context is
// set up before this function is called, and
// fuse_get_context()->private_data returns the user_data passed to
// fuse_main().  Really seems like either it should be a third
// parameter coming in here, or else the fact should be documented
// (and this might as well return void, as it did in older versions of
// FUSE).
static void *tfs_init (struct fuse_conn_info *conn) {
  char tmpbuf[4096];
  dlogf("tfs_init: protocol v%u.%u", conn->proto_major, conn->proto_minor);
  // dump caps
  if (conn->capable) {
    tmpbuf[0] = 0;
    if (conn->capable&FUSE_CAP_ASYNC_READ) strcat(tmpbuf, " FUSE_CAP_ASYNC_READ");
    if (conn->capable&FUSE_CAP_POSIX_LOCKS) strcat(tmpbuf, " FUSE_CAP_POSIX_LOCKS"); // filesystem supports "remote" locking
    if (conn->capable&FUSE_CAP_ATOMIC_O_TRUNC) strcat(tmpbuf, " FUSE_CAP_ATOMIC_O_TRUNC"); // filesystem handles the O_TRUNC open flag
    if (conn->capable&FUSE_CAP_EXPORT_SUPPORT) strcat(tmpbuf, " FUSE_CAP_EXPORT_SUPPORT"); // filesystem handles lookups of "." and ".."
    if (conn->capable&FUSE_CAP_BIG_WRITES) strcat(tmpbuf, " FUSE_CAP_BIG_WRITES"); // filesystem can handle write size larger than 4kB
    if (conn->capable&FUSE_CAP_DONT_MASK) strcat(tmpbuf, " FUSE_CAP_DONT_MASK"); // don't apply umask to file mode on create operations
    dlogf("kernel caps:%s\n", tmpbuf);
  }
  // set our params
  conn->want = 0; // the only flag we want is FUSE_CAP_BIG_WRITES, but we don't support writing
  conn->async_read = 0; // we don't support async reads
  return fuse_get_context()->private_data;
}


/**
 * Clean up filesystem
 *
 * Called on filesystem exit.
 *
 * Introduced in version 2.3
 */
static void tfs_destroy (void *userdata) {
  dlogf("tfs_destroy: userdata=0x%p", userdata);
}


/**
 * Check file access permissions
 *
 * This will be called for the access() system call.  If the
 * 'default_permissions' mount option is given, this method is not
 * called.
 *
 * This method is not called under Linux kernel versions 2.4.x
 *
 * Introduced in version 2.5
 */
//k8: don't know if mode can be combination of flags, and what to do then
static int tfs_access (const char *path, int mode) {
  const char *name;
  //dlogf("tfs_access: path=[%s], mode=0%d", path, mode);
  if (mode&W_OK) return -EPERM; // can't write
  if (strcmp(path, "/") == 0 || strcmp(path, "/:otags") == 0) return 0; // all perms
  name = strrchr(path, '/')+1;
  if (name[0] == ':') {
    for (size_t f = 0; f < ARRAYLEN(specdirs); ++f) if (strcmp(specdirs[f], name) == 0) return 0;
    if (strcmp(name, ":files") == 0) return 0;
    return -ENOENT;
  }
  if (find_by_tag_name(name, &tagv_hash_t) != NULL) return 0;
  if (find_by_tag_name(name, &tagv_hash_o) != NULL) return 0;
  if (mode&X_OK) return -EPERM; // can't execute
  if (find_by_short_name(name) != NULL) return 0;
  return -EPERM; // no such file
}


/**
 * Create and open a file
 *
 * If the file does not exist, first create it with the specified
 * mode, and then open it.
 *
 * If this method is not implemented or under Linux kernel
 * versions earlier than 2.6.15, the mknod() and open() methods
 * will be called instead.
 *
 * Introduced in version 2.5
 */
static int tfs_create (const char *path, mode_t mode, struct fuse_file_info *fi) {
  //dlogf("tfs_create: path=[%s], mode=0%03o, fi=0x%p", path, mode, fi);
  //fi->fh = fd;
  return -EPERM;
}


/**
 * Change the size of an open file
 *
 * This method is called instead of the truncate() method if the
 * truncation was invoked from an ftruncate() system call.
 *
 * If this method is not implemented or under Linux kernel
 * versions earlier than 2.6.15, the truncate() method will be
 * called instead.
 *
 * Introduced in version 2.5
 */
static int tfs_ftruncate (const char *path, off_t offset, struct fuse_file_info *fi) {
  //dlogf("tfs_ftruncate: path=[%s], offset=%lld, fi=0x%p", path, offset, fi);
  return -EPERM;
}


/**
 * Get attributes from an open file
 *
 * This method is called instead of the getattr() method if the
 * file information is available.
 *
 * Currently this is only called after the create() method if that
 * is implemented (see above).  Later it may be called for
 * invocations of fstat() too.
 *
 * Introduced in version 2.5
 */
static int tfs_fgetattr (const char *path, struct stat *statbuf, struct fuse_file_info *fi) {
  //dlogf("tfs_fgetattr: path=[%s], statbuf=0x%p, fi=0x%p", path, statbuf, fi);
  return tfs_getattr(path, statbuf); // just pass it up
}


/**
 * Perform POSIX file locking operation
 *
 * The cmd argument will be either F_GETLK, F_SETLK or F_SETLKW.
 *
 * For the meaning of fields in 'struct flock' see the man page
 * for fcntl(2).  The l_whence field will always be set to
 * SEEK_SET.
 *
 * For checking lock ownership, the 'fuse_file_info->owner'
 * argument must be used.
 *
 * For F_GETLK operation, the library will first check currently
 * held locks, and if a conflicting lock is found it will return
 * information without calling this method.      This ensures, that
 * for local locks the l_pid field is correctly filled in.      The
 * results may not be accurate in case of race conditions and in
 * the presence of hard links, but it's unlikly that an
 * application would rely on accurate GETLK results in these
 * cases.  If a conflicting lock is not found, this method will be
 * called, and the filesystem may fill out l_pid by a meaningful
 * value, or it may leave this field zero.
 *
 * For F_SETLK and F_SETLKW the l_pid field will be set to the pid
 * of the process performing the locking operation.
 *
 * Note: if this method is not implemented, the kernel will still
 * allow file locking to work locally.  Hence it is only
 * interesting for network filesystems and similar.
 *
 * Introduced in version 2.6
 */
/*
static int tfs_lock (const char *path, struct fuse_file_info *fi, int cmd, struct flock *) {
  return -EPERM;
}
*/


/**
 * Change the access and modification times of a file with
 * nanosecond resolution
 *
 * Introduced in version 2.6
 */
static int tfs_utimens (const char *path, const struct timespec tv[2]) {
  return 0; // pretend that we done it
}


/**
 * Map block index within file to block index within device
 *
 * Note: This makes sense only for block device backed filesystems
 * mounted with the 'blkdev' option
 *
 * Introduced in version 2.6
 */
 /*
static int tfs_bmap (const char *path, size_t blocksize, uint64_t *idx) {
  return -EPERM;
}
*/


/**
 * Ioctl
 *
 * flags will have FUSE_IOCTL_COMPAT set for 32bit ioctls in
 * 64bit environment.  The size and direction of data is
 * determined by _IOC_*() decoding of cmd.  For _IOC_NONE,
 * data will be NULL, for _IOC_WRITE data is out area, for
 * _IOC_READ in area and if both are set in/out area.  In all
 * non-NULL cases, the area is of _IOC_SIZE(cmd) bytes.
 *
 * Introduced in version 2.8
 */
/*
static int tfs_ioctl (const char *path, int cmd, void *arg, struct fuse_file_info *, unsigned int flags, void *data) {
  return -EPERM;
}
*/


/**
 * Poll for IO readiness events
 *
 * Note: If ph is non-NULL, the client should notify
 * when IO readiness events occur by calling
 * fuse_notify_poll() with the specified ph.
 *
 * Regardless of the number of times poll with a non-NULL ph
 * is received, single notification is enough to clear all.
 * Notifying more times incurs overhead but doesn't harm
 * correctness.
 *
 * The callee is responsible for destroying ph with
 * fuse_pollhandle_destroy() when no longer in use.
 *
 * Introduced in version 2.8
 */
/*
static int tfs_poll (const char *path, struct fuse_file_info *fi, struct fuse_pollhandle *ph, unsigned *reventsp) {
  return -EPERM;
}
*/


////////////////////////////////////////////////////////////////////////////////
static const struct fuse_operations tfs_oper = {
  .getattr = tfs_getattr,
  .readlink = tfs_readlink,
  .getdir = NULL, // deprecated
  .mknod = tfs_mknod,
  .mkdir = tfs_mkdir,
  .unlink = tfs_unlink,
  .rmdir = tfs_rmdir,
  .symlink = tfs_symlink,
  .rename = tfs_rename,
  .link = tfs_link,
  .chmod = tfs_chmod,
  .chown = tfs_chown,
  .truncate = tfs_truncate,
  .utime = NULL, // deprecated
  .open = tfs_open,
  .read = tfs_read,
  .write = tfs_write,
  .statfs = tfs_statfs,
  .flush = tfs_flush,
  .release = tfs_release,
  .fsync = tfs_fsync,
  .setxattr = tfs_setxattr,
  .getxattr = tfs_getxattr,
  .listxattr = tfs_listxattr,
  .removexattr = tfs_removexattr,
  .opendir = tfs_opendir,
  .readdir = tfs_readdir,
  .releasedir = tfs_releasedir,
  .fsyncdir = tfs_fsyncdir,
  .init = tfs_init,
  .destroy = tfs_destroy,
  .access = tfs_access,
  .create = tfs_create,
  .ftruncate = tfs_ftruncate,
  .fgetattr = tfs_fgetattr,
  //.lock = tfs_lock,
  .utimens = tfs_utimens,
  //.bmap = tfs_bmap,
  //
  /**
   * Flag indicating, that the filesystem can accept a NULL path
   * as the first argument for the following operations:
   *
   * read, write, flush, release, fsync, readdir, releasedir,
   * fsyncdir, ftruncate, fgetattr and lock
   */
  //unsigned int flag_nullpath_ok : 1;
  .flag_nullpath_ok = 0,
  // 2.8 API
  //.ioctl = tfs_ioctl,
  //.poll = tfs_poll,
};


static void tfs_usage (void) {
  fprintf(stderr,
    "usage: fusedrv [mount options] tags.dat mountpoint\n"
    "special options:\n"
    "  --debug  write some debug logs\n"
    "  --nokoi  don't use koi8 (you will loose some nice features)\n"
    "  --stat   do stat() on startup to skip invalid files\n"
  );
  exit(1);
}


static int tagfile_loaded = 0;
static const char *argv00 = "./me";

// return -1 on error, 0 if arg is to be discarded, 1 if arg should be kept
static int opt_processor (void *data, const char *arg, int key, struct fuse_args *outargs) {
  //fprintf(stderr, "key=%d; arg=%s\n", key, arg);
  //
  if (key == FUSE_OPT_KEY_OPT) {
    // this is not FUSE option, handle it
    // question: how to handle cases like '-x fuck'?
    if (strcmp(arg, "--debug") == 0) {
      static char logname[8192], rn[8192];
      strcpy(logname, argv00);
      if (strrchr(logname, '/')) strrchr(logname, '/')[0] = 0;
      char *pp = realpath(logname, rn);
      if (pp == NULL || pp[0] != '/') {
        fprintf(stderr, "FATAL: realpath(\"%s\") fucked! [%s]\n", logname, pp);
        abort();
      }
      if (pp[strlen(pp)-1] != '/') strcat(pp, "/");
      strcat(pp, "fusedrv.log");
      dbglog_set_filename(pp);
      dbglog_set_screenout(0);
      dbglog_set_fileout(1);
      return 0;
    }
    //
    if (strcmp(arg, "--help") == 0) {
      tfs_usage();
      return 0;
    }
    //
    if (strcmp(arg, "--nodebug") == 0) {
      dbglog_set_screenout(0);
      dbglog_set_fileout(0);
      return 0;
    }
    //
    if (strcmp(arg, "--nokoi") == 0) {
      opt_tagload_koi8 = 0;
      return 0;
    }
    //
    if (strcmp(arg, "--koi") == 0) {
      opt_tagload_koi8 = 1;
      return 0;
    }
    //
    if (strcmp(arg, "--stat") == 0) {
      opt_tagload_dostat = 1;
      return 0;
    }
    //
    if (strcmp(arg, "--nostat") == 0) {
      opt_tagload_dostat = 0;
      return 0;
    }
    //
    if (strcmp(arg, "-h") == 0) { tfs_usage(); exit(0); }
    //fprintf(stderr, "FATAL: unknown option '%s'!\n", arg);
    //exit(1);
    return 1;
  }
  //
  if (key == FUSE_OPT_KEY_NONOPT) {
    // not an option; first non-option arg is tagdb file name
    if (!tagfile_loaded) {
      clock_t stt, ste;
      stt = clock();
      if (load_tagfile(arg) != 0) { fprintf(stderr, "FATAL: can't open tagfile: '%s'!\n", arg); exit(1); }
      ste = clock();
      printf("database load time: %.15g seconds\n", (double)(ste-stt)/(double)CLOCKS_PER_SEC);
      if (file_info_count == 0) { fprintf(stderr, "FATAL: no valid files in tagfile: '%s'!\n", arg); exit(1); }
      tagfile_loaded = 1;
      return 0;
    }
    //
    return 1;
  }
  //
  return 1;
}


int main (int argc, char *argv[]) {
  int fuse_stat;
  struct fuse_args args = FUSE_ARGS_INIT(argc, argv);
  //
  if (argc > 0 && argv[0] != NULL) argv00 = argv[0];
  //
  dbglog_set_screenout(0);
  dbglog_set_fileout(0);
  //
  if (getuid() == 0 || geteuid() == 0) {
    fprintf(stderr, "FATAL: running fusedrv as root is inappropriate!\n");
    return 1;
  }
  //dlogf("=== starting fusedrv ===");
  //
  fuse_opt_parse(&args, NULL, NULL, opt_processor);
  if (!tagfile_loaded) tfs_usage();
  //fuse_opt_add_arg(&args, "-omodules=subdir,subdir=/foo");
  fuse_opt_add_arg(&args, "-s"); // single-threaded
  //
  //for (int f = 0; f < args.argc; ++f) fprintf(stderr, "arg#%d: [%s]\n", f, args.argv[f]);
  //
  //fprintf(stderr, "about to call fuse_main\n");
  fuse_stat = fuse_main(args.argc, args.argv, &tfs_oper, (void *)666);
  //fprintf(stderr, "fuse_main returned %d\n", fuse_stat);
  //
  fuse_opt_free_args(&args);
  return fuse_stat;
}