example/fusexmp_fh.c

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