fuse/guestmount.c

   1 /* guestmount - mount guests using libguestfs and FUSE
   2  * Copyright (C) 2009 Red Hat Inc.
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17  *
  18  * Derived from the example program 'fusexmp.c':
  19  * Copyright (C) 2001-2007  Miklos Szeredi <miklos@szeredi.hu>
  20  *
  21  * This program can be distributed under the terms of the GNU GPL.
  22  * See the file COPYING.
  23  */
  24
  25 #define FUSE_USE_VERSION 26
  26
  27 #include <config.h>
  28
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31 #include <stdint.h>
  32 #include <string.h>
  33 #include <unistd.h>
  34 #include <getopt.h>
  35 #include <fcntl.h>
  36 #include <dirent.h>
  37 #include <errno.h>
  38 #include <signal.h>
  39 #include <time.h>
  40 #include <assert.h>
  41 #include <sys/time.h>
  42 #include <sys/types.h>
  43
  44 #include <fuse.h>
  45 #include <guestfs.h>
  46
  47 #include "progname.h"
  48
  49 #include "guestmount.h"
  50 #include "dircache.h"
  51
  52 /* See <attr/xattr.h> */
  53 #ifndef ENOATTR
  54 #define ENOATTR ENODATA
  55 #endif
  56
  57 static guestfs_h *g = NULL;
  58 static int read_only = 0;
  59 int verbose = 0;
  60 int dir_cache_timeout = 60;
  61
  62 /* This is ugly: guestfs errors are strings, FUSE wants -errno.  We
  63  * have to do the conversion as best we can.
  64  */
  65 #define MAX_ERRNO 256
  66
  67 static int
  68 error (void)
  69 {
  70   int i;
  71   const char *err = guestfs_last_error (g);
  72
  73   if (!err)
  74     return -EINVAL;
  75
  76   if (verbose)
  77     fprintf (stderr, "%s\n", err);
  78
  79   /* Add a few of our own ... */
  80
  81   /* This indicates guestfsd died.  Translate into a hard EIO error.
  82    * Arguably we could relaunch the guest if we hit this error.
  83    */
  84   if (strstr (err, "call launch before using this function"))
  85     return -EIO;
  86
  87   /* See if it matches an errno string in the host. */
  88   for (i = 0; i < MAX_ERRNO; ++i) {
  89     const char *e = strerror (i);
  90     if (e && strstr (err, e) != NULL)
  91       return -i;
  92   }
  93
  94   /* Too bad, return a generic error. */
  95   return -EINVAL;
  96 }
  97
  98 static struct guestfs_xattr_list *
  99 copy_xattr_list (const struct guestfs_xattr *first, size_t num)
 100 {
 101   struct guestfs_xattr_list *xattrs;
 102
 103   xattrs = malloc (sizeof *xattrs);
 104   if (xattrs == NULL) {
 105     perror ("malloc");
 106     return NULL;
 107   }
 108
 109   xattrs->len = num;
 110   xattrs->val = malloc (num * sizeof (struct guestfs_xattr));
 111   if (xattrs->val == NULL) {
 112     perror ("malloc");
 113     free (xattrs);
 114     return NULL;
 115   }
 116
 117   size_t i;
 118   for (i = 0; i < num; ++i) {
 119     xattrs->val[i].attrname = strdup (first[i].attrname);
 120     xattrs->val[i].attrval_len = first[i].attrval_len;
 121     xattrs->val[i].attrval = malloc (first[i].attrval_len);
 122     memcpy (xattrs->val[i].attrval, first[i].attrval, first[i].attrval_len);
 123   }
 124
 125   return xattrs;
 126 }
 127
 128 static int
 129 fg_readdir (const char *path, void *buf, fuse_fill_dir_t filler,
 130             off_t offset, struct fuse_file_info *fi)
 131 {
 132   time_t now;
 133   time (&now);
 134
 135   dir_cache_remove_all_expired (now);
 136
 137   struct guestfs_dirent_list *ents;
 138
 139   ents = guestfs_readdir (g, path);
 140   if (ents == NULL)
 141     return error ();
 142
 143   size_t i;
 144   for (i = 0; i < ents->len; ++i) {
 145     struct stat stat;
 146     memset (&stat, 0, sizeof stat);
 147
 148     stat.st_ino = ents->val[i].ino;
 149     switch (ents->val[i].ftyp) {
 150     case 'b': stat.st_mode = S_IFBLK; break;
 151     case 'c': stat.st_mode = S_IFCHR; break;
 152     case 'd': stat.st_mode = S_IFDIR; break;
 153     case 'f': stat.st_mode = S_IFIFO; break;
 154     case 'l': stat.st_mode = S_IFLNK; break;
 155     case 'r': stat.st_mode = S_IFREG; break;
 156     case 's': stat.st_mode = S_IFSOCK; break;
 157     case 'u':
 158     case '?':
 159     default:  stat.st_mode = 0;
 160     }
 161
 162     /* Copied from the example, which also ignores 'offset'.  I'm
 163      * not quite sure how this is ever supposed to work on large
 164      * directories. XXX
 165      */
 166     if (filler (buf, ents->val[i].name, &stat, 0))
 167       break;
 168   }
 169
 170   /* Now prepopulate the directory caches.  This step is just an
 171    * optimization, don't worry if it fails.
 172    */
 173   char **names = malloc ((ents->len + 1) * sizeof (char *));
 174   if (names) {
 175     for (i = 0; i < ents->len; ++i)
 176       names[i] = ents->val[i].name;
 177     names[i] = NULL;
 178
 179     struct guestfs_stat_list *ss = guestfs_lstatlist (g, path, names);
 180     if (ss) {
 181       for (i = 0; i < ss->len; ++i) {
 182         if (ss->val[i].ino >= 0) {
 183           struct stat statbuf;
 184
 185           statbuf.st_dev = ss->val[i].dev;
 186           statbuf.st_ino = ss->val[i].ino;
 187           statbuf.st_mode = ss->val[i].mode;
 188           statbuf.st_nlink = ss->val[i].nlink;
 189           statbuf.st_uid = ss->val[i].uid;
 190           statbuf.st_gid = ss->val[i].gid;
 191           statbuf.st_rdev = ss->val[i].rdev;
 192           statbuf.st_size = ss->val[i].size;
 193           statbuf.st_blksize = ss->val[i].blksize;
 194           statbuf.st_blocks = ss->val[i].blocks;
 195           statbuf.st_atime = ss->val[i].atime;
 196           statbuf.st_mtime = ss->val[i].mtime;
 197           statbuf.st_ctime = ss->val[i].ctime;
 198
 199           lsc_insert (path, names[i], now, &statbuf);
 200         }
 201       }
 202       guestfs_free_stat_list (ss);
 203     }
 204
 205     struct guestfs_xattr_list *xattrs = guestfs_lxattrlist (g, path, names);
 206     if (xattrs) {
 207       size_t ni, num;
 208       struct guestfs_xattr *first;
 209       struct guestfs_xattr_list *copy;
 210       for (i = 0, ni = 0; i < xattrs->len; ++i, ++ni) {
 211         assert (strlen (xattrs->val[i].attrname) == 0);
 212         if (xattrs->val[i].attrval_len > 0) {
 213           ++i;
 214           first = &xattrs->val[i];
 215           num = 0;
 216           for (; i < xattrs->len && strlen (xattrs->val[i].attrname) > 0; ++i)
 217             num++;
 218
 219           copy = copy_xattr_list (first, num);
 220           if (copy)
 221             xac_insert (path, names[ni], now, copy);
 222
 223           i--;
 224         }
 225       }
 226       guestfs_free_xattr_list (xattrs);
 227     }
 228
 229     char **links = guestfs_readlinklist (g, path, names);
 230     if (links) {
 231       for (i = 0; names[i] != NULL; ++i) {
 232         if (links[i][0])
 233           /* Note that rlc_insert owns the string links[i] after this, */
 234           rlc_insert (path, names[i], now, links[i]);
 235         else
 236           /* which is why we have to free links[i] here. */
 237           free (links[i]);
 238       }
 239       free (links);             /* free the array, not the strings */
 240     }
 241
 242     free (names);
 243   }
 244
 245   guestfs_free_dirent_list (ents);
 246
 247   return 0;
 248 }
 249
 250 static int
 251 fg_getattr (const char *path, struct stat *statbuf)
 252 {
 253   const struct stat *buf;
 254
 255   buf = lsc_lookup (path);
 256   if (buf) {
 257     memcpy (statbuf, buf, sizeof *statbuf);
 258     return 0;
 259   }
 260
 261   struct guestfs_stat *r;
 262
 263   r = guestfs_lstat (g, path);
 264   if (r == NULL)
 265     return error ();
 266
 267   statbuf->st_dev = r->dev;
 268   statbuf->st_ino = r->ino;
 269   statbuf->st_mode = r->mode;
 270   statbuf->st_nlink = r->nlink;
 271   statbuf->st_uid = r->uid;
 272   statbuf->st_gid = r->gid;
 273   statbuf->st_rdev = r->rdev;
 274   statbuf->st_size = r->size;
 275   statbuf->st_blksize = r->blksize;
 276   statbuf->st_blocks = r->blocks;
 277   statbuf->st_atime = r->atime;
 278   statbuf->st_mtime = r->mtime;
 279   statbuf->st_ctime = r->ctime;
 280
 281   guestfs_free_stat (r);
 282
 283   return 0;
 284 }
 285
 286 /* Nautilus loves to use access(2) to test everything about a file,
 287  * such as whether it's executable.  Therefore treat this a lot like
 288  * fg_getattr.
 289  */
 290 static int
 291 fg_access (const char *path, int mask)
 292 {
 293   struct stat statbuf;
 294   int r;
 295
 296   if (read_only && (mask & W_OK))
 297     return -EROFS;
 298
 299   r = fg_getattr (path, &statbuf);
 300   if (r < 0 || mask == F_OK)
 301     return r;
 302
 303   struct fuse_context *fuse = fuse_get_context ();
 304   int ok = 1;
 305
 306   if (mask & R_OK)
 307     ok = ok &&
 308       (  fuse->uid == statbuf.st_uid ? statbuf.st_mode & S_IRUSR
 309        : fuse->gid == statbuf.st_gid ? statbuf.st_mode & S_IRGRP
 310        : statbuf.st_mode & S_IROTH);
 311   if (mask & W_OK)
 312     ok = ok &&
 313       (  fuse->uid == statbuf.st_uid ? statbuf.st_mode & S_IWUSR
 314        : fuse->gid == statbuf.st_gid ? statbuf.st_mode & S_IWGRP
 315        : statbuf.st_mode & S_IWOTH);
 316   if (mask & X_OK)
 317     ok = ok &&
 318       (  fuse->uid == statbuf.st_uid ? statbuf.st_mode & S_IXUSR
 319        : fuse->gid == statbuf.st_gid ? statbuf.st_mode & S_IXGRP
 320        : statbuf.st_mode & S_IXOTH);
 321
 322   return ok ? 0 : -EACCES;
 323 }
 324
 325 static int
 326 fg_readlink (const char *path, char *buf, size_t size)
 327 {
 328   const char *r;
 329   int free_it = 0;
 330
 331   r = rlc_lookup (path);
 332   if (!r) {
 333     r = guestfs_readlink (g, path);
 334     if (r == NULL)
 335       return error ();
 336     free_it = 1;
 337   }
 338
 339   /* Note this is different from the real readlink(2) syscall.  FUSE wants
 340    * the string to be always nul-terminated, even if truncated.
 341    */
 342   size_t len = strlen (r);
 343   if (len > size - 1)
 344     len = size - 1;
 345
 346   memcpy (buf, r, len);
 347   buf[len] = '\0';
 348
 349   if (free_it) {
 350     char *tmp = (char *) r;
 351     free (tmp);
 352   }
 353
 354   return 0;
 355 }
 356
 357 static int
 358 fg_mknod (const char *path, mode_t mode, dev_t rdev)
 359 {
 360   int r;
 361
 362   if (read_only) return -EROFS;
 363
 364   dir_cache_invalidate (path);
 365
 366   r = guestfs_mknod (g, mode, major (rdev), minor (rdev), path);
 367   if (r == -1)
 368     return error ();
 369
 370   return 0;
 371 }
 372
 373 static int
 374 fg_mkdir (const char *path, mode_t mode)
 375 {
 376   int r;
 377
 378   if (read_only) return -EROFS;
 379
 380   dir_cache_invalidate (path);
 381
 382   r = guestfs_mkdir_mode (g, path, mode);
 383   if (r == -1)
 384     return error ();
 385
 386   return 0;
 387 }
 388
 389 static int
 390 fg_unlink (const char *path)
 391 {
 392   int r;
 393
 394   if (read_only) return -EROFS;
 395
 396   dir_cache_invalidate (path);
 397
 398   r = guestfs_rm (g, path);
 399   if (r == -1)
 400     return error ();
 401
 402   return 0;
 403 }
 404
 405 static int
 406 fg_rmdir (const char *path)
 407 {
 408   int r;
 409
 410   if (read_only) return -EROFS;
 411
 412   dir_cache_invalidate (path);
 413
 414   r = guestfs_rmdir (g, path);
 415   if (r == -1)
 416     return error ();
 417
 418   return 0;
 419 }
 420
 421 static int
 422 fg_symlink (const char *from, const char *to)
 423 {
 424   int r;
 425
 426   if (read_only) return -EROFS;
 427
 428   dir_cache_invalidate (to);
 429
 430   r = guestfs_ln_s (g, from, to);
 431   if (r == -1)
 432     return error ();
 433
 434   return 0;
 435 }
 436
 437 static int
 438 fg_rename (const char *from, const char *to)
 439 {
 440   int r;
 441
 442   if (read_only) return -EROFS;
 443
 444   dir_cache_invalidate (from);
 445   dir_cache_invalidate (to);
 446
 447   /* XXX It's not clear how close the 'mv' command is to the
 448    * rename syscall.  We might need to add the rename syscall
 449    * to the guestfs(3) API.
 450    */
 451   r = guestfs_mv (g, from, to);
 452   if (r == -1)
 453     return error ();
 454
 455   return 0;
 456 }
 457
 458 static int
 459 fg_link (const char *from, const char *to)
 460 {
 461   int r;
 462
 463   if (read_only) return -EROFS;
 464
 465   dir_cache_invalidate (from);
 466   dir_cache_invalidate (to);
 467
 468   r = guestfs_ln (g, from, to);
 469   if (r == -1)
 470     return error ();
 471
 472   return 0;
 473 }
 474
 475 static int
 476 fg_chmod (const char *path, mode_t mode)
 477 {
 478   int r;
 479
 480   if (read_only) return -EROFS;
 481
 482   dir_cache_invalidate (path);
 483
 484   r = guestfs_chmod (g, mode, path);
 485   if (r == -1)
 486     return error ();
 487
 488   return 0;
 489 }
 490
 491 static int
 492 fg_chown (const char *path, uid_t uid, gid_t gid)
 493 {
 494   int r;
 495
 496   if (read_only) return -EROFS;
 497
 498   dir_cache_invalidate (path);
 499
 500   r = guestfs_lchown (g, uid, gid, path);
 501   if (r == -1)
 502     return error ();
 503
 504   return 0;
 505 }
 506
 507 static int
 508 fg_truncate (const char *path, off_t size)
 509 {
 510   int r;
 511
 512   if (read_only) return -EROFS;
 513
 514   dir_cache_invalidate (path);
 515
 516   r = guestfs_truncate_size (g, path, size);
 517   if (r == -1)
 518     return error ();
 519
 520   return 0;
 521 }
 522
 523 static int
 524 fg_utimens (const char *path, const struct timespec ts[2])
 525 {
 526   int r;
 527
 528   if (read_only) return -EROFS;
 529
 530   dir_cache_invalidate (path);
 531
 532   time_t atsecs = ts[0].tv_sec;
 533   long atnsecs = ts[0].tv_nsec;
 534   time_t mtsecs = ts[1].tv_sec;
 535   long mtnsecs = ts[1].tv_nsec;
 536
 537   if (atnsecs == UTIME_NOW)
 538     atnsecs = -1;
 539   if (atnsecs == UTIME_OMIT)
 540     atnsecs = -2;
 541   if (mtnsecs == UTIME_NOW)
 542     mtnsecs = -1;
 543   if (mtnsecs == UTIME_OMIT)
 544     mtnsecs = -2;
 545
 546   r = guestfs_utimens (g, path, atsecs, atnsecs, mtsecs, mtnsecs);
 547   if (r == -1)
 548     return error ();
 549
 550   return 0;
 551 }
 552
 553 /* This call is quite hard to emulate through the guestfs(3) API.  In
 554  * one sense it's a little like access (see above) because it tests
 555  * whether opening a file would succeed given the flags.  But it also
 556  * has side effects such as truncating the file if O_TRUNC is given.
 557  * Therefore we need to emulate it ... painfully.
 558  */
 559 static int
 560 fg_open (const char *path, struct fuse_file_info *fi)
 561 {
 562   int r, exists;
 563
 564   if (fi->flags & O_WRONLY) {
 565     if (read_only)
 566       return -EROFS;
 567   }
 568
 569   exists = guestfs_exists (g, path);
 570   if (exists == -1)
 571     return error ();
 572
 573   if (fi->flags & O_CREAT) {
 574     if (read_only)
 575       return -EROFS;
 576
 577     dir_cache_invalidate (path);
 578
 579     /* Exclusive?  File must not exist already. */
 580     if (fi->flags & O_EXCL) {
 581       if (exists)
 582         return -EEXIST;
 583     }
 584
 585     /* Create?  Touch it and optionally truncate it. */
 586     r = guestfs_touch (g, path);
 587     if (r == -1)
 588       return error ();
 589
 590     if (fi->flags & O_TRUNC) {
 591       r = guestfs_truncate (g, path);
 592       if (r == -1)
 593         return error ();
 594     }
 595   } else {
 596     /* Not create, just check it exists. */
 597     if (!exists)
 598       return -ENOENT;
 599   }
 600
 601   return 0;
 602 }
 603
 604 static int
 605 fg_read (const char *path, char *buf, size_t size, off_t offset,
 606          struct fuse_file_info *fi)
 607 {
 608   char *r;
 609   size_t rsize;
 610
 611   if (verbose)
 612     fprintf (stderr, "fg_read: %s: size %zu offset %ju\n",
 613              path, size, offset);
 614
 615   /* The guestfs protocol limits size to somewhere over 2MB.  We just
 616    * reduce the requested size here accordingly and push the problem
 617    * up to every user.  http://www.jwz.org/doc/worse-is-better.html
 618    */
 619   const size_t limit = 2 * 1024 * 1024;
 620   if (size > limit)
 621     size = limit;
 622
 623   /* Note the correct error handling here is tricky, because in the
 624    * case where the call returns a zero-length buffer, it might return
 625    * NULL.  However it won't adjust rsize along the error path, so we
 626    * can set rsize to something beforehand and use that as a flag.
 627    */
 628   rsize = 1;
 629   r = guestfs_pread (g, path, size, offset, &rsize);
 630   if (rsize == 1 && r == NULL)
 631     return error ();
 632
 633   /* This should never happen, but at least it stops us overflowing
 634    * the output buffer if it does happen.
 635    */
 636   if (rsize > size)
 637     rsize = size;
 638
 639   memcpy (buf, r, rsize);
 640   free (r);
 641
 642   return rsize;
 643 }
 644
 645 static int
 646 fg_write (const char *path, const char *buf, size_t size,
 647           off_t offset, struct fuse_file_info *fi)
 648 {
 649   if (read_only) return -EROFS;
 650
 651   dir_cache_invalidate (path);
 652
 653   return -ENOSYS;               /* XXX */
 654 }
 655
 656 static int
 657 fg_statfs (const char *path, struct statvfs *stbuf)
 658 {
 659   struct guestfs_statvfs *r;
 660
 661   r = guestfs_statvfs (g, path);
 662   if (r == NULL)
 663     return error ();
 664
 665   stbuf->f_bsize = r->bsize;
 666   stbuf->f_frsize = r->frsize;
 667   stbuf->f_blocks = r->blocks;
 668   stbuf->f_bfree = r->bfree;
 669   stbuf->f_bavail = r->bavail;
 670   stbuf->f_files = r->files;
 671   stbuf->f_ffree = r->ffree;
 672   stbuf->f_favail = r->favail;
 673   stbuf->f_fsid = r->fsid;
 674   stbuf->f_flag = r->flag;
 675   stbuf->f_namemax = r->namemax;
 676
 677   guestfs_free_statvfs (r);
 678
 679   return 0;
 680 }
 681
 682 static int
 683 fg_release (const char *path, struct fuse_file_info *fi)
 684 {
 685   /* Just a stub. This method is optional and can safely be left
 686    * unimplemented.
 687    */
 688   return 0;
 689 }
 690
 691 /* Emulate this by calling sync. */
 692 static int fg_fsync(const char *path, int isdatasync,
 693                      struct fuse_file_info *fi)
 694 {
 695   int r;
 696
 697   r = guestfs_sync (g);
 698   if (r == -1)
 699     return error ();
 700
 701   return 0;
 702 }
 703
 704 static int
 705 fg_setxattr (const char *path, const char *name, const char *value,
 706              size_t size, int flags)
 707 {
 708   int r;
 709
 710   if (read_only) return -EROFS;
 711
 712   dir_cache_invalidate (path);
 713
 714   /* XXX Underlying guestfs(3) API doesn't understand the flags. */
 715   r = guestfs_lsetxattr (g, name, value, size, path);
 716   if (r == -1)
 717     return error ();
 718
 719   return 0;
 720 }
 721
 722 /* The guestfs(3) API for getting xattrs is much easier to use
 723  * than the real syscall.  Unfortunately we now have to emulate
 724  * the real syscall using that API :-(
 725  */
 726 static int
 727 fg_getxattr (const char *path, const char *name, char *value,
 728              size_t size)
 729 {
 730   const struct guestfs_xattr_list *xattrs;
 731   int free_attrs = 0;
 732
 733   xattrs = xac_lookup (path);
 734   if (xattrs == NULL) {
 735     xattrs = guestfs_lgetxattrs (g, path);
 736     if (xattrs == NULL)
 737       return error ();
 738     free_attrs = 1;
 739   }
 740
 741   size_t i;
 742   int r = -ENOATTR;
 743   for (i = 0; i < xattrs->len; ++i) {
 744     if (STREQ (xattrs->val[i].attrname, name)) {
 745       size_t sz = xattrs->val[i].attrval_len;
 746       if (sz > size)
 747         sz = size;
 748       memcpy (value, xattrs->val[i].attrval, sz);
 749       r = 0;
 750       break;
 751     }
 752   }
 753
 754   if (free_attrs)
 755     guestfs_free_xattr_list ((struct guestfs_xattr_list *) xattrs);
 756
 757   return r;
 758 }
 759
 760 /* Ditto as above. */
 761 static int
 762 fg_listxattr (const char *path, char *list, size_t size)
 763 {
 764   const struct guestfs_xattr_list *xattrs;
 765   int free_attrs = 0;
 766
 767   xattrs = xac_lookup (path);
 768   if (xattrs == NULL) {
 769     xattrs = guestfs_lgetxattrs (g, path);
 770     if (xattrs == NULL)
 771       return error ();
 772     free_attrs = 1;
 773   }
 774
 775   size_t i;
 776   ssize_t copied = 0;
 777   for (i = 0; i < xattrs->len; ++i) {
 778     size_t len = strlen (xattrs->val[i].attrname) + 1;
 779     if (size >= len) {
 780       memcpy (list, xattrs->val[i].attrname, len);
 781       size -= len;
 782       list += len;
 783       copied += len;
 784     } else {
 785       copied = -ERANGE;
 786       break;
 787     }
 788   }
 789
 790   if (free_attrs)
 791     guestfs_free_xattr_list ((struct guestfs_xattr_list *) xattrs);
 792
 793   return copied;
 794 }
 795
 796 static int
 797 fg_removexattr(const char *path, const char *name)
 798 {
 799   int r;
 800
 801   if (read_only) return -EROFS;
 802
 803   dir_cache_invalidate (path);
 804
 805   r = guestfs_lremovexattr (g, name, path);
 806   if (r == -1)
 807     return error ();
 808
 809   return 0;
 810 }
 811
 812 static struct fuse_operations fg_operations = {
 813   .getattr      = fg_getattr,
 814   .access       = fg_access,
 815   .readlink     = fg_readlink,
 816   .readdir      = fg_readdir,
 817   .mknod        = fg_mknod,
 818   .mkdir        = fg_mkdir,
 819   .symlink      = fg_symlink,
 820   .unlink       = fg_unlink,
 821   .rmdir        = fg_rmdir,
 822   .rename       = fg_rename,
 823   .link         = fg_link,
 824   .chmod        = fg_chmod,
 825   .chown        = fg_chown,
 826   .truncate     = fg_truncate,
 827   .utimens      = fg_utimens,
 828   .open         = fg_open,
 829   .read         = fg_read,
 830   .write        = fg_write,
 831   .statfs       = fg_statfs,
 832   .release      = fg_release,
 833   .fsync        = fg_fsync,
 834   .setxattr     = fg_setxattr,
 835   .getxattr     = fg_getxattr,
 836   .listxattr    = fg_listxattr,
 837   .removexattr  = fg_removexattr,
 838 };
 839
 840 struct drv {
 841   struct drv *next;
 842   char *filename;
 843 };
 844
 845 struct mp {
 846   struct mp *next;
 847   char *device;
 848   char *mountpoint;
 849 };
 850
 851 static void add_drives (struct drv *);
 852 static void mount_mps (struct mp *);
 853
 854 static void __attribute__((noreturn))
 855 fuse_help (void)
 856 {
 857   const char *tmp_argv[] = { program_name, "--help", NULL };
 858   fuse_main (2, (char **) tmp_argv, &fg_operations, NULL);
 859   exit (0);
 860 }
 861
 862 static void __attribute__((noreturn))
 863 usage (int status)
 864 {
 865   if (status != EXIT_SUCCESS)
 866     fprintf (stderr, _("Try `%s --help' for more information.\n"),
 867              program_name);
 868   else {
 869     fprintf (stdout,
 870            _("%s: FUSE module for libguestfs\n"
 871              "%s lets you mount a virtual machine filesystem\n"
 872              "Copyright (C) 2009 Red Hat Inc.\n"
 873              "Usage:\n"
 874              "  %s [--options] [-- [--FUSE-options]] mountpoint\n"
 875              "Options:\n"
 876              "  -a|--add image       Add image\n"
 877              "  --dir-cache-timeout  Set readdir cache timeout (default 5 sec)\n"
 878              "  --fuse-help          Display extra FUSE options\n"
 879              "  --help               Display help message and exit\n"
 880              "  -m|--mount dev[:mnt] Mount dev on mnt (if omitted, /)\n"
 881              "  -n|--no-sync         Don't autosync\n"
 882              "  -o|--option opt      Pass extra option to FUSE\n"
 883              "  -r|--ro              Mount read-only\n"
 884              "  --selinux            Enable SELinux support\n"
 885              "  --trace              Trace guestfs API calls (to stderr)\n"
 886              "  -v|--verbose         Verbose messages\n"
 887              "  -V|--version         Display version and exit\n"
 888              ),
 889              program_name, program_name, program_name);
 890   }
 891   exit (status);
 892 }
 893
 894 int
 895 main (int argc, char *argv[])
 896 {
 897   enum { HELP_OPTION = CHAR_MAX + 1 };
 898
 899   /* The command line arguments are broadly compatible with (a subset
 900    * of) guestfish.  Thus we have to deal mainly with -a, -m and --ro.
 901    */
 902   static const char *options = "a:m:no:rv?V";
 903   static const struct option long_options[] = {
 904     { "add", 1, 0, 'a' },
 905     { "dir-cache-timeout", 1, 0, 0 },
 906     { "fuse-help", 0, 0, 0 },
 907     { "help", 0, 0, HELP_OPTION },
 908     { "mount", 1, 0, 'm' },
 909     { "no-sync", 0, 0, 'n' },
 910     { "option", 1, 0, 'o' },
 911     { "ro", 0, 0, 'r' },
 912     { "selinux", 0, 0, 0 },
 913     { "trace", 0, 0, 0 },
 914     { "verbose", 0, 0, 'v' },
 915     { "version", 0, 0, 'V' },
 916     { 0, 0, 0, 0 }
 917   };
 918
 919   struct drv *drvs = NULL;
 920   struct drv *drv;
 921   struct mp *mps = NULL;
 922   struct mp *mp;
 923   char *p;
 924   int c, i, r;
 925   int option_index;
 926   struct sigaction sa;
 927
 928   int fuse_argc = 0;
 929   const char **fuse_argv = NULL;
 930
 931 #define ADD_FUSE_ARG(str)                                               \
 932   do {                                                                  \
 933     fuse_argc ++;                                                       \
 934     fuse_argv = realloc (fuse_argv, (1+fuse_argc) * sizeof (char *));   \
 935     if (!fuse_argv) {                                                   \
 936       perror ("realloc");                                               \
 937       exit (1);                                                         \
 938     }                                                                   \
 939     fuse_argv[fuse_argc-1] = (str);                                     \
 940     fuse_argv[fuse_argc] = NULL;                                        \
 941   } while (0)
 942
 943   /* LC_ALL=C is required so we can parse error messages. */
 944   setenv ("LC_ALL", "C", 1);
 945
 946   /* Set global program name that is not polluted with libtool artifacts.  */
 947   set_program_name (argv[0]);
 948
 949   memset (&sa, 0, sizeof sa);
 950   sa.sa_handler = SIG_IGN;
 951   sa.sa_flags = SA_RESTART;
 952   sigaction (SIGPIPE, &sa, NULL);
 953
 954   /* Various initialization. */
 955   init_dir_caches ();
 956
 957   g = guestfs_create ();
 958   if (g == NULL) {
 959     fprintf (stderr, _("guestfs_create: failed to create handle\n"));
 960     exit (1);
 961   }
 962
 963   guestfs_set_autosync (g, 1);
 964   guestfs_set_recovery_proc (g, 0);
 965
 966   ADD_FUSE_ARG (program_name);
 967   /* MUST be single-threaded.  You cannot have two threads accessing the
 968    * same libguestfs handle, and opening more than one handle is likely
 969    * to be very expensive.
 970    */
 971   ADD_FUSE_ARG ("-s");
 972
 973   /* If developing, add ./appliance to the path.  Note that libtools
 974    * interferes with this because uninstalled guestfish is a shell
 975    * script that runs the real program with an absolute path.  Detect
 976    * that too.
 977    *
 978    * BUT if LIBGUESTFS_PATH environment variable is already set by
 979    * the user, then don't override it.
 980    */
 981   if (getenv ("LIBGUESTFS_PATH") == NULL &&
 982       argv[0] &&
 983       (argv[0][0] != '/' || strstr (argv[0], "/.libs/lt-") != NULL))
 984     guestfs_set_path (g, "appliance:" GUESTFS_DEFAULT_PATH);
 985
 986   for (;;) {
 987     c = getopt_long (argc, argv, options, long_options, &option_index);
 988     if (c == -1) break;
 989
 990     switch (c) {
 991     case 0:                     /* options which are long only */
 992       if (STREQ (long_options[option_index].name, "dir-cache-timeout"))
 993         dir_cache_timeout = atoi (optarg);
 994       else if (STREQ (long_options[option_index].name, "fuse-help"))
 995         fuse_help ();
 996       else if (STREQ (long_options[option_index].name, "selinux"))
 997         guestfs_set_selinux (g, 1);
 998       else if (STREQ (long_options[option_index].name, "trace")) {
 999         ADD_FUSE_ARG ("-f");
1000         guestfs_set_trace (g, 1);
1001         guestfs_set_recovery_proc (g, 1);
1002       }
1003       else {
1004         fprintf (stderr, _("%s: unknown long option: %s (%d)\n"),
1005                  program_name, long_options[option_index].name, option_index);
1006         exit (1);
1007       }
1008       break;
1009
1010     case 'a':
1011       if (access (optarg, R_OK) != 0) {
1012         perror (optarg);
1013         exit (1);
1014       }
1015       drv = malloc (sizeof (struct drv));
1016       if (!drv) {
1017         perror ("malloc");
1018         exit (1);
1019       }
1020       drv->filename = optarg;
1021       drv->next = drvs;
1022       drvs = drv;
1023       break;
1024
1025     case 'm':
1026       mp = malloc (sizeof (struct mp));
1027       if (!mp) {
1028         perror ("malloc");
1029         exit (1);
1030       }
1031       p = strchr (optarg, ':');
1032       if (p) {
1033         *p = '\0';
1034         mp->mountpoint = p+1;
1035       } else
1036         mp->mountpoint = bad_cast ("/");
1037       mp->device = optarg;
1038       mp->next = mps;
1039       mps = mp;
1040       break;
1041
1042     case 'n':
1043       guestfs_set_autosync (g, 0);
1044       break;
1045
1046     case 'o':
1047       ADD_FUSE_ARG ("-o");
1048       ADD_FUSE_ARG (optarg);
1049       break;
1050
1051     case 'r':
1052       read_only = 1;
1053       break;
1054
1055     case 'v':
1056       verbose++;
1057       guestfs_set_verbose (g, verbose);
1058       break;
1059
1060     case 'V':
1061       printf ("%s %s\n", program_name, PACKAGE_VERSION);
1062       exit (0);
1063
1064     case HELP_OPTION:
1065       usage (0);
1066
1067     default:
1068       usage (1);
1069     }
1070   }
1071
1072   /* We must have at least one -a and at least one -m. */
1073   if (!drvs || !mps) {
1074     fprintf (stderr,
1075              _("%s: must have at least one -a and at least one -m option\n"),
1076              program_name);
1077     exit (1);
1078   }
1079
1080   /* We'd better have a mountpoint. */
1081   if (optind+1 != argc) {
1082     fprintf (stderr,
1083              _("%s: you must specify a mountpoint in the host filesystem\n"),
1084              program_name);
1085     exit (1);
1086   }
1087
1088   /* Do the guest drives and mountpoints. */
1089   add_drives (drvs);
1090   if (guestfs_launch (g) == -1)
1091     exit (1);
1092   mount_mps (mps);
1093
1094   /* FUSE example does this, not clear if it's necessary, but ... */
1095   if (guestfs_umask (g, 0) == -1)
1096     exit (1);
1097
1098   /* At the last minute, remove the libguestfs error handler.  In code
1099    * above this point, the default error handler has been used which
1100    * sends all errors to stderr.  Now before entering FUSE itself we
1101    * want to silence errors so we can convert them (see error()
1102    * function above).
1103    */
1104   guestfs_set_error_handler (g, NULL, NULL);
1105
1106   /* Finish off FUSE args. */
1107   ADD_FUSE_ARG (argv[optind]);
1108
1109   /*
1110     It says about the line containing the for-statement:
1111     error: assuming signed overflow does not occur when simplifying conditional to constant [-Wstrict-overflow]
1112
1113   if (verbose) {
1114     fprintf (stderr, "guestmount: invoking FUSE with args [");
1115     for (i = 0; i < fuse_argc; ++i) {
1116       if (i > 0) fprintf (stderr, ", ");
1117       fprintf (stderr, "%s", fuse_argv[i]);
1118     }
1119     fprintf (stderr, "]\n");
1120   }
1121   */
1122
1123   r = fuse_main (fuse_argc, (char **) fuse_argv, &fg_operations, NULL);
1124
1125   /* Cleanup. */
1126   guestfs_close (g);
1127   free_dir_caches ();
1128
1129   exit (r == -1 ? 1 : 0);
1130 }
1131
1132 /* List is built in reverse order, so add them in reverse order. */
1133 static void
1134 add_drives (struct drv *drv)
1135 {
1136   int r;
1137
1138   if (drv) {
1139     add_drives (drv->next);
1140     if (!read_only)
1141       r = guestfs_add_drive (g, drv->filename);
1142     else
1143       r = guestfs_add_drive_ro (g, drv->filename);
1144     if (r == -1)
1145       exit (1);
1146   }
1147 }
1148
1149 /* List is built in reverse order, so mount them in reverse order. */
1150 static void
1151 mount_mps (struct mp *mp)
1152 {
1153   int r;
1154
1155   if (mp) {
1156     mount_mps (mp->next);
1157     if (!read_only)
1158       r = guestfs_mount (g, mp->device, mp->mountpoint);
1159     else
1160       r = guestfs_mount_ro (g, mp->device, mp->mountpoint);
1161     if (r == -1)
1162       exit (1);
1163   }
1164 }