example/fusexmp_fh.c

   1 /*
   2   FUSE: Filesystem in Userspace
   3   Copyright (C) 2001-2007  Miklos Szeredi <miklos@szeredi.hu>
   4
   5   This program can be distributed under the terms of the GNU GPL.
   6   See the file COPYING.
   7
   8   gcc -Wall `pkg-config fuse --cflags --libs` -lulockmgr fusexmp_fh.c -o fusexmp_fh
   9 */
  10
  11 #define FUSE_USE_VERSION 26
  12
  13 #ifdef HAVE_CONFIG_H
  14 #include <config.h>
  15 #endif
  16
  17 #define _GNU_SOURCE
  18
  19 #include <fuse.h>
  20 #include <ulockmgr.h>
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <unistd.h>
  25 #include <fcntl.h>
  26 #include <dirent.h>
  27 #include <errno.h>
  28 #include <sys/time.h>
  29 #ifdef HAVE_SETXATTR
  30 #include <sys/xattr.h>
  31 #endif
  32
  33 static int xmp_getattr(const char *path, struct stat *stbuf)
  34 {
  35         int res;
  36
  37         res = lstat(path, stbuf);
  38         if (res == -1)
  39                 return -errno;
  40
  41         return 0;
  42 }
  43
  44 static int xmp_fgetattr(const char *path, struct stat *stbuf,
  45                         struct fuse_file_info *fi)
  46 {
  47         int res;
  48
  49         (void) path;
  50
  51         res = fstat(fi->fh, stbuf);
  52         if (res == -1)
  53                 return -errno;
  54
  55         return 0;
  56 }
  57
  58 static int xmp_access(const char *path, int mask)
  59 {
  60         int res;
  61
  62         res = access(path, mask);
  63         if (res == -1)
  64                 return -errno;
  65
  66         return 0;
  67 }
  68
  69 static int xmp_readlink(const char *path, char *buf, size_t size)
  70 {
  71         int res;
  72
  73         res = readlink(path, buf, size - 1);
  74         if (res == -1)
  75                 return -errno;
  76
  77         buf[res] = '\0';
  78         return 0;
  79 }
  80
  81 struct xmp_dirp {
  82         DIR *dp;
  83         struct dirent *entry;
  84         off_t offset;
  85 };
  86
  87 static int xmp_opendir(const char *path, struct fuse_file_info *fi)
  88 {
  89         int res;
  90         struct xmp_dirp *d = malloc(sizeof(struct xmp_dirp));
  91         if (d == NULL)
  92                 return -ENOMEM;
  93
  94         d->dp = opendir(path);
  95         if (d->dp == NULL) {
  96                 res = -errno;
  97                 free(d);
  98                 return res;
  99         }
 100         d->offset = 0;
 101         d->entry = NULL;
 102
 103         fi->fh = (unsigned long) d;
 104         return 0;
 105 }
 106
 107 static inline struct xmp_dirp *get_dirp(struct fuse_file_info *fi)
 108 {
 109         return (struct xmp_dirp *) (uintptr_t) fi->fh;
 110 }
 111
 112 static int xmp_readdir(const char *path, void *buf, fuse_fill_dir_t filler,
 113                        off_t offset, struct fuse_file_info *fi)
 114 {
 115         struct xmp_dirp *d = get_dirp(fi);
 116
 117         (void) path;
 118         if (offset != d->offset) {
 119                 seekdir(d->dp, offset);
 120                 d->entry = NULL;
 121                 d->offset = offset;
 122         }
 123         while (1) {
 124                 struct stat st;
 125                 off_t nextoff;
 126
 127                 if (!d->entry) {
 128                         d->entry = readdir(d->dp);
 129                         if (!d->entry)
 130                                 break;
 131                 }
 132
 133                 memset(&st, 0, sizeof(st));
 134                 st.st_ino = d->entry->d_ino;
 135                 st.st_mode = d->entry->d_type << 12;
 136                 nextoff = telldir(d->dp);
 137                 if (filler(buf, d->entry->d_name, &st, nextoff))
 138                         break;
 139
 140                 d->entry = NULL;
 141                 d->offset = nextoff;
 142         }
 143
 144         return 0;
 145 }
 146
 147 static int xmp_releasedir(const char *path, struct fuse_file_info *fi)
 148 {
 149         struct xmp_dirp *d = get_dirp(fi);
 150         (void) path;
 151         closedir(d->dp);
 152         free(d);
 153         return 0;
 154 }
 155
 156 static int xmp_mknod(const char *path, mode_t mode, dev_t rdev)
 157 {
 158         int res;
 159
 160         if (S_ISFIFO(mode))
 161                 res = mkfifo(path, mode);
 162         else
 163                 res = mknod(path, mode, rdev);
 164         if (res == -1)
 165                 return -errno;
 166
 167         return 0;
 168 }
 169
 170 static int xmp_mkdir(const char *path, mode_t mode)
 171 {
 172         int res;
 173
 174         res = mkdir(path, mode);
 175         if (res == -1)
 176                 return -errno;
 177
 178         return 0;
 179 }
 180
 181 static int xmp_unlink(const char *path)
 182 {
 183         int res;
 184
 185         res = unlink(path);
 186         if (res == -1)
 187                 return -errno;
 188
 189         return 0;
 190 }
 191
 192 static int xmp_rmdir(const char *path)
 193 {
 194         int res;
 195
 196         res = rmdir(path);
 197         if (res == -1)
 198                 return -errno;
 199
 200         return 0;
 201 }
 202
 203 static int xmp_symlink(const char *from, const char *to)
 204 {
 205         int res;
 206
 207         res = symlink(from, to);
 208         if (res == -1)
 209                 return -errno;
 210
 211         return 0;
 212 }
 213
 214 static int xmp_rename(const char *from, const char *to)
 215 {
 216         int res;
 217
 218         res = rename(from, to);
 219         if (res == -1)
 220                 return -errno;
 221
 222         return 0;
 223 }
 224
 225 static int xmp_link(const char *from, const char *to)
 226 {
 227         int res;
 228
 229         res = link(from, to);
 230         if (res == -1)
 231                 return -errno;
 232
 233         return 0;
 234 }
 235
 236 static int xmp_chmod(const char *path, mode_t mode)
 237 {
 238         int res;
 239
 240         res = chmod(path, mode);
 241         if (res == -1)
 242                 return -errno;
 243
 244         return 0;
 245 }
 246
 247 static int xmp_chown(const char *path, uid_t uid, gid_t gid)
 248 {
 249         int res;
 250
 251         res = lchown(path, uid, gid);
 252         if (res == -1)
 253                 return -errno;
 254
 255         return 0;
 256 }
 257
 258 static int xmp_truncate(const char *path, off_t size)
 259 {
 260         int res;
 261
 262         res = truncate(path, size);
 263         if (res == -1)
 264                 return -errno;
 265
 266         return 0;
 267 }
 268
 269 static int xmp_ftruncate(const char *path, off_t size,
 270                          struct fuse_file_info *fi)
 271 {
 272         int res;
 273
 274         (void) path;
 275
 276         res = ftruncate(fi->fh, size);
 277         if (res == -1)
 278                 return -errno;
 279
 280         return 0;
 281 }
 282
 283 static int xmp_utimens(const char *path, const struct timespec ts[2])
 284 {
 285         int res;
 286         struct timeval tv[2];
 287
 288         tv[0].tv_sec = ts[0].tv_sec;
 289         tv[0].tv_usec = ts[0].tv_nsec / 1000;
 290         tv[1].tv_sec = ts[1].tv_sec;
 291         tv[1].tv_usec = ts[1].tv_nsec / 1000;
 292
 293         res = utimes(path, tv);
 294         if (res == -1)
 295                 return -errno;
 296
 297         return 0;
 298 }
 299
 300 static int xmp_create(const char *path, mode_t mode, struct fuse_file_info *fi)
 301 {
 302         int fd;
 303
 304         fd = open(path, fi->flags, mode);
 305         if (fd == -1)
 306                 return -errno;
 307
 308         fi->fh = fd;
 309         return 0;
 310 }
 311
 312 static int xmp_open(const char *path, struct fuse_file_info *fi)
 313 {
 314         int fd;
 315
 316         fd = open(path, fi->flags);
 317         if (fd == -1)
 318                 return -errno;
 319
 320         fi->fh = fd;
 321         return 0;
 322 }
 323
 324 static int xmp_read(const char *path, char *buf, size_t size, off_t offset,
 325                     struct fuse_file_info *fi)
 326 {
 327         int res;
 328
 329         (void) path;
 330         res = pread(fi->fh, buf, size, offset);
 331         if (res == -1)
 332                 res = -errno;
 333
 334         return res;
 335 }
 336
 337 static int xmp_write(const char *path, const char *buf, size_t size,
 338                      off_t offset, struct fuse_file_info *fi)
 339 {
 340         int res;
 341
 342         (void) path;
 343         res = pwrite(fi->fh, buf, size, offset);
 344         if (res == -1)
 345                 res = -errno;
 346
 347         return res;
 348 }
 349
 350 static int xmp_statfs(const char *path, struct statvfs *stbuf)
 351 {
 352         int res;
 353
 354         res = statvfs(path, stbuf);
 355         if (res == -1)
 356                 return -errno;
 357
 358         return 0;
 359 }
 360
 361 static int xmp_flush(const char *path, struct fuse_file_info *fi)
 362 {
 363         int res;
 364
 365         (void) path;
 366         /* This is called from every close on an open file, so call the
 367            close on the underlying filesystem.  But since flush may be
 368            called multiple times for an open file, this must not really
 369            close the file.  This is important if used on a network
 370            filesystem like NFS which flush the data/metadata on close() */
 371         res = close(dup(fi->fh));
 372         if (res == -1)
 373                 return -errno;
 374
 375         return 0;
 376 }
 377
 378 static int xmp_release(const char *path, struct fuse_file_info *fi)
 379 {
 380         (void) path;
 381         close(fi->fh);
 382
 383         return 0;
 384 }
 385
 386 static int xmp_fsync(const char *path, int isdatasync,
 387                      struct fuse_file_info *fi)
 388 {
 389         int res;
 390         (void) path;
 391
 392 #ifndef HAVE_FDATASYNC
 393         (void) isdatasync;
 394 #else
 395         if (isdatasync)
 396                 res = fdatasync(fi->fh);
 397         else
 398 #endif
 399                 res = fsync(fi->fh);
 400         if (res == -1)
 401                 return -errno;
 402
 403         return 0;
 404 }
 405
 406 #ifdef HAVE_SETXATTR
 407 /* xattr operations are optional and can safely be left unimplemented */
 408 static int xmp_setxattr(const char *path, const char *name, const char *value,
 409                         size_t size, int flags)
 410 {
 411         int res = lsetxattr(path, name, value, size, flags);
 412         if (res == -1)
 413                 return -errno;
 414         return 0;
 415 }
 416
 417 static int xmp_getxattr(const char *path, const char *name, char *value,
 418                         size_t size)
 419 {
 420         int res = lgetxattr(path, name, value, size);
 421         if (res == -1)
 422                 return -errno;
 423         return res;
 424 }
 425
 426 static int xmp_listxattr(const char *path, char *list, size_t size)
 427 {
 428         int res = llistxattr(path, list, size);
 429         if (res == -1)
 430                 return -errno;
 431         return res;
 432 }
 433
 434 static int xmp_removexattr(const char *path, const char *name)
 435 {
 436         int res = lremovexattr(path, name);
 437         if (res == -1)
 438                 return -errno;
 439         return 0;
 440 }
 441 #endif /* HAVE_SETXATTR */
 442
 443 static int xmp_lock(const char *path, struct fuse_file_info *fi, int cmd,
 444                     struct flock *lock)
 445 {
 446         (void) path;
 447
 448         return ulockmgr_op(fi->fh, cmd, lock, &fi->lock_owner,
 449                            sizeof(fi->lock_owner));
 450 }
 451
 452 static struct fuse_operations xmp_oper = {
 453         .getattr        = xmp_getattr,
 454         .fgetattr       = xmp_fgetattr,
 455         .access         = xmp_access,
 456         .readlink       = xmp_readlink,
 457         .opendir        = xmp_opendir,
 458         .readdir        = xmp_readdir,
 459         .releasedir     = xmp_releasedir,
 460         .mknod          = xmp_mknod,
 461         .mkdir          = xmp_mkdir,
 462         .symlink        = xmp_symlink,
 463         .unlink         = xmp_unlink,
 464         .rmdir          = xmp_rmdir,
 465         .rename         = xmp_rename,
 466         .link           = xmp_link,
 467         .chmod          = xmp_chmod,
 468         .chown          = xmp_chown,
 469         .truncate       = xmp_truncate,
 470         .ftruncate      = xmp_ftruncate,
 471         .utimens        = xmp_utimens,
 472         .create         = xmp_create,
 473         .open           = xmp_open,
 474         .read           = xmp_read,
 475         .write          = xmp_write,
 476         .statfs         = xmp_statfs,
 477         .flush          = xmp_flush,
 478         .release        = xmp_release,
 479         .fsync          = xmp_fsync,
 480 #ifdef HAVE_SETXATTR
 481         .setxattr       = xmp_setxattr,
 482         .getxattr       = xmp_getxattr,
 483         .listxattr      = xmp_listxattr,
 484         .removexattr    = xmp_removexattr,
 485 #endif
 486         .lock           = xmp_lock,
 487
 488         .flag_nullpath_ok = 1,
 489 };
 490
 491 int main(int argc, char *argv[])
 492 {
 493         umask(0);
 494         return fuse_main(argc, argv, &xmp_oper, NULL);
 495 }