Released 2.6

This is recommended for forward-compatibility.

.cvsignore

@@ -1,16 +0,0 @@
-.deps
-COPYING
-INSTALL
-Makefile
-Makefile.in
-aclocal.m4
-*.cache
-config.*
-configure
-compile
-depcomp
-install-sh
-missing
-sshfs
-stamp*
-.deps

.gitignore

@@ -0,0 +1,36 @@
+#
+# NOTE! Don't add files that are generated in specific
+# subdirectories here. Add them in the ".gitignore" file
+# in that subdirectory instead.
+#
+# NOTE! Please use 'git ls-files -i --exclude-standard'
+# command after changing this file, to see if there are
+# any tracked files which get ignored after the change.
+.*
+!.gitignore
+*.o
+*.lo
+*.la
+*.gz
+\#*#
+*.orig
+*~
+Makefile.in
+Makefile
+*.m4
+stamp-h*
+config.*
+/sshfs
+/ltmain.sh
+/configure
+/install-sh
+/mkinstalldirs
+/missing
+/*.cache
+/depcomp
+/compile
+/libtool
+/INSTALL
+/.pc
+/patches
+/m4

AUTHORS

@@ -1 +1,22 @@
-Miklos Szeredi     <miklos@szeredi.hu>
+Current Maintainer
+------------------
+
+Nikolaus Rath <Nikolaus@rath.org>
+
+
+Past Maintainers
+----------------
+
+Miklos Szeredi <miklos@szeredi.hu> (until 12/2015)
+
+
+Contributors (autogenerated list)
+---------------------------------
+
+Alan Jenkins <alan.christopher.jenkins@gmail.com>
+Alexander Neumann <alexander@bumpern.de>
+Chris Wolfe <cwolfe@chromium.org>
+Mike Kelly <mike@pair.com>
+Miklos Szeredi <miklos@szeredi.hu>
+Nikolaus Rath <Nikolaus@rath.org>
+Percy Jahn <email@percyjahn.de>

COPYING

@@ -0,0 +1,339 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+                            NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.

ChangeLog

@@ -1,87 +1,139 @@
-2005-08-15  Miklos Szeredi <miklos@szeredi.hu>
+Release 2.7 (2015-01-28)
+------------------------
 
-	* Released 1.2
+* New maintainer (Nikolaus Rath <Nikolaus@rath.org>)
 
-2005-08-13  Miklos Szeredi <miklos@szeredi.hu>
 
-	* Add 'reconnect' option, which tries to reconnect to the server
-	when the connection is broken.  If a password is required for
-	connection, it is recommended that you install ssh-askpass, and
-	set the SSH_ASKPASS environment variable (see 'man ssh' for more
-	details).
+Release 2.6 (2014-01-14)
+------------------------
 
-2005-05-05  Miklos Szeredi <miklos@szeredi.hu>
+* Some performance improvements for large directories.
+* New `disable_hardlink` option.
+* Various small bugfixes.
 
-	* Work around missing truncate() support in some older sftp
-	servers (only works for zero size truncate).  Thanks to Eduard
-	Czimbalmos for the bug report and help with testing
+Release 2.4 (2012-03-08)
+------------------------
 
-2005-04-13  Miklos Szeredi <miklos@szeredi.hu>
+* New `slave` option.
+* New `idmap`, `uidmap` and `gidmap` options.  
+* Various small bugfixes.
 
-	* Fix compilation with gcc-2.95.  Reported by David A. Gershman
+Release 2.3 (2011-07-01)
+------------------------
 
-2005-03-08  Miklos Szeredi <miklos@szeredi.hu>
+* Support hard link creation if server is OpenSSH 5.7 or later
+* Small improvements and bug fixes  
+* Check mount point and options before connecting to ssh server
+* New 'delay_connect' option
 
-	* Make it work on server version 2 (e.g. Sun_SSH_1.0.1).  Report
-	and testing by Pieter J. Kersten
+Release 2.2 (2008-10-20)
+------------------------
 
-2005-03-04  Miklos Szeredi <miklos@szeredi.hu>
+* Handle numerical IPv6 addresses enclosed in square brackets
+* Handle commas in usernames
 
-	* Released 1.1
+Release 2.1 (2008-07-11)
+------------------------
 
-2005-03-03  Miklos Szeredi <miklos@szeredi.hu>
+* Small improvements and bug fixes  
 
-	* Slightly optimize readahead.  Still not clever enough to always
-	keep the pipe filled.
+Release 2.0 (2008-04-23)
+------------------------
 
-	* Add 'sshfs_debug' option
+* Support password authentication with pam_mount
 
-2005-02-17  Miklos Szeredi <miklos@szeredi.hu>
+* Support atomic renames if server is OpenSSH 4.9 or later
 
-	* Parse 'max_read' mount option and if smaller than 65536 forward
-	to FUSE
+* Support getting disk usage if server is OpenSSH 5.1 or later
 
-2005-02-16  Miklos Szeredi <miklos@szeredi.hu>
+* Small enhancements and bug fixes
 
-	* Added simple readahead (big performance gain in case of
-	sequential read pattern).  Can be disabled with '-o no_readahead'
+What is new in 1.9
+------------------
 
-2005-02-14  Miklos Szeredi <miklos@szeredi.hu>
+* Fix a serious bug, that could result in sshfs hanging, crashing, or
+  reporting out-of-memory
 
-	* Added asynchronous writeback (big performance gain) and made
-	this the default.  Can be disabled with '-o sshfs_sync'
- 
-2005-02-09  Miklos Szeredi <miklos@szeredi.hu>
+What is new in 1.8
+------------------
 
-	* Added option to start arbitary command instead of 'ssh'
+* Bug fixes
 
-	* Re-added '-p PORT' as a convenience option, also '-C' works as
-	in ssh.
+What is new in 1.7
+------------------
 
-2005-02-08  Miklos Szeredi <miklos@szeredi.hu>
+* Tolerate servers which print a banner on login
 
-	* Add caching of symlinks
-	
-	* Add support for many ssh options to be passed to ssh
+* Small improvements
 
-	* Port number can now actually be specified with "-o port=PORT",
-	bug spotted by Nadia Maksymiw
+What is new in 1.6
+------------------
 
-2005-02-07  Miklos Szeredi <miklos@szeredi.hu>
+* Workaround for missing truncate operation on old sftp servers
 
-	* Separate attribute caching to a separate layer
+* Bug fixes
 
-	* Add caching of directory contents
+What is new in 1.5
+------------------
 
-2005-02-03  Miklos Szeredi <miklos@szeredi.hu>
+* Improvements to read performance.  Now both read and write
+  throughput should be very close to 'scp'
 
-	Fix PKG_CONFIG_PATH setting in configure.ac (reported by Alpar
-	Juttner)
-	
-2005-01-09  Miklos Szeredi <miklos@szeredi.hu>
+* If used with FUSE 2.6.0 or later, then perform better data caching.
+  This should show dramatic speed improvements when a file is opened
+  more than once
 
-	* Released 1.0
+* Bug fixes
 
-2004-12-04  Miklos Szeredi <miklos@szeredi.hu>
+What is new in 1.4
+------------------
 
-	* Started ChangeLog
+* Updated to version 25 of libfuse API
+
+* This means that the 'cp' of readonly file to sshfs bug is finally
+  solved (as long as using libfuse 2.5.0 or later *and* Linux 2.6.15
+  or later)
+
+* Sshfs now works on FreeBSD
+
+* Added option to "transform" absolute symbolic links
+
+What is new in 1.3
+------------------
+
+* Add workaround for failure to rename to an existing file
+
+* Simple user ID mapping
+
+* Estimate disk usage of files based on size
+
+* Report "infinite" disk space
+
+* Bug fixes
+
+What is new in 1.2
+------------------
+
+* Better compatibility with different sftp servers
+
+* Automatic reconnect (optional)
+
+What is new in 1.1
+------------------
+
+* Performance improvements:
+
+   - directory content caching
+
+   - symlink caching
+
+   - asynchronous writeback
+
+   - readahead
+
+* Fixed '-p' option
+
+What is new in 1.0
+------------------
+
+* Initial release

Makefile.am

@@ -1,5 +1,31 @@
 ## Process this file with automake to produce Makefile.in
 
 bin_PROGRAMS = sshfs
-sshfs_SOURCES = sshfs.c cache.c opts.c cache.h opts.h
-sshfs_CPPFLAGS = -DFUSE_USE_VERSION=22
+
+sshfs_SOURCES = sshfs.c cache.c cache.h
+if FUSE_OPT_COMPAT
+sshfs_SOURCES += compat/fuse_opt.c compat/fuse_opt.h
+endif
+
+sshfs_LDADD = $(SSHFS_LIBS)
+sshfs_CFLAGS = $(SSHFS_CFLAGS)
+sshfs_CPPFLAGS = -D_REENTRANT -DFUSE_USE_VERSION=26 -DLIBDIR=\"$(libdir)\"
+
+EXTRA_DIST = sshnodelay.c
+CLEANFILES = sshnodelay.so
+
+dist_man_MANS = sshfs.1
+
+if SSH_NODELAY_SO
+all-local: sshnodelay.so
+
+install-exec-local: sshnodelay.so
+	test -z "$(libdir)" || $(mkdir_p) "$(DESTDIR)$(libdir)"
+	$(INSTALL) -m 755 sshnodelay.so "$(DESTDIR)$(libdir)/sshnodelay.so"
+
+uninstall-local:
+	rm -f "$(DESTDIR)$(libdir)/sshnodelay.so"
+
+sshnodelay.so:
+	$(CC) -Wall -W -s --shared -fPIC $(sshnodelay_libs) sshnodelay.c -o sshnodelay.so
+endif

NEWS

@@ -1,26 +0,0 @@
-What is new in 1.2
-------------------
-
-* Better compatibility with different sftp servers
-
-* Automatic reconnect (optional)
-
-What is new in 1.1
-------------------
-
-* Performance improvements:
-
-   - directory content caching
-
-   - symlink caching
-
-   - asynchronous writeback
-
-   - readahead
-
-* Fixed '-p' option
-
-What is new in 1.0
-------------------
-
-* Initial release

README.md

@@ -11,7 +11,7 @@ The idea of sshfs was taken from the SSHFS filesystem distributed with
 LUFS, which I found very useful.  There were some limitations of that
 codebase, so I rewrote it.  Features of this implementation are:
 
-  - Based on FUSE (the best userspace filesystem framework for linux ;)
+  - Based on FUSE (the best userspace filesystem framework for Linux ;)
 
   - Multithreading: more than one request can be on it's way to the
     server
@@ -22,13 +22,19 @@ codebase, so I rewrote it.  Features of this implementation are:
 
   - Reconnect on failure
 
+Latest version
+==============
+
+The latest version and more information can be found on
+http://github.com/libfuse/sshfs
+
 
 How to mount a filesystem
 =========================
 
 Once sshfs is installed (see next section) running it is very simple:
 
-  sshfs hostname: mountpoint
+    sshfs hostname: mountpoint
 
 Note, that it's recommended to run it as user, not as root.  For this
 to work the mountpoint must be owned by the user.  If the username is
@@ -40,34 +46,27 @@ is the home directory.
 
 Also many ssh options can be specified (see the manual pages for
 sftp(1) and ssh_config(5)), including the remote port number
-('-oport=PORT')
+(`-oport=PORT`)
 
 To unmount the filesystem:
 
-  fusermount -u moutpoint
+    fusermount -u moutpoint
 
 
 Installing
 ==========
 
-First you need to download FUSE 2.2 or later from:
-
-  http://fuse.sourceforge.net
+First you need to download FUSE 2.2 or later from
+http://github.com/libfuse/libfuse.
 
 You also need to install the devel package for glib2.0.  After
 installing FUSE, compile sshfs the usual way:
 
-  ./configure
-  make
-  make install (as root)
+    ./configure
+    make
+    make install (as root)
 
 And you are ready to go.
 
-
-Bugs and feature requests
-=========================
-
-Send bug reports to <miklos@szeredi.hu>.  
-
-Good luck!
-Miklos Szeredi
+If checking out from git for the first time also do `autoreconf -i`
+before doing `./configure`.

cache.c

@@ -1,9 +1,9 @@
 /*
-    Caching file system proxy
-    Copyright (C) 2004  Miklos Szeredi <miklos@szeredi.hu>
+  Caching file system proxy
+  Copyright (C) 2004  Miklos Szeredi <miklos@szeredi.hu>
 
-    This program can be distributed under the terms of the GNU GPL.
-    See the file COPYING.
+  This program can be distributed under the terms of the GNU GPL.
+  See the file COPYING.
 */
 
 #include "cache.h"
@@ -14,516 +14,577 @@
 #include <glib.h>
 #include <pthread.h>
 
-#include "opts.h"
-
 #define DEFAULT_CACHE_TIMEOUT 20
 #define MAX_CACHE_SIZE 10000
 #define MIN_CACHE_CLEAN_INTERVAL 5
 #define CACHE_CLEAN_INTERVAL 60
 
-static int cache_on = 1;
-static unsigned cache_stat_timeout = DEFAULT_CACHE_TIMEOUT;
-static unsigned cache_dir_timeout = DEFAULT_CACHE_TIMEOUT;
-static unsigned cache_link_timeout = DEFAULT_CACHE_TIMEOUT;
+struct cache {
+	int on;
+	unsigned stat_timeout;
+	unsigned dir_timeout;
+	unsigned link_timeout;
+	struct fuse_cache_operations *next_oper;
+	GHashTable *table;
+	pthread_mutex_t lock;
+	time_t last_cleaned;
+	uint64_t write_ctr;
+};
+
+static struct cache cache;
 
 struct node {
-    struct stat stat;
-    time_t stat_valid;
-    char **dir;
-    time_t dir_valid;
-    char *link;
-    time_t link_valid;
-    time_t valid;
+	struct stat stat;
+	time_t stat_valid;
+	char **dir;
+	time_t dir_valid;
+	char *link;
+	time_t link_valid;
+	time_t valid;
 };
 
 struct fuse_cache_dirhandle {
-    const char *path;
-    fuse_dirh_t h;
-    fuse_dirfil_t filler;
-    GPtrArray *dir;
+	const char *path;
+	fuse_dirh_t h;
+	fuse_dirfil_t filler;
+	GPtrArray *dir;
+	uint64_t wrctr;
 };
 
-static struct fuse_cache_operations *next_oper;
-static GHashTable *cache;
-static pthread_mutex_t cache_lock;
-static time_t last_cleaned;
-
 static void free_node(gpointer node_)
 {
-    struct node *node = (struct node *) node_;
-    g_strfreev(node->dir);
-    g_free(node);
+	struct node *node = (struct node *) node_;
+	g_strfreev(node->dir);
+	g_free(node);
 }
 
 static int cache_clean_entry(void *key_, struct node *node, time_t *now)
 {
-    (void) key_;
-    if (*now > node->valid)
-        return TRUE;
-    else
-        return FALSE;
+	(void) key_;
+	if (*now > node->valid)
+		return TRUE;
+	else
+		return FALSE;
 }
 
 static void cache_clean(void)
 {
-    time_t now = time(NULL);
-    if (now > last_cleaned + MIN_CACHE_CLEAN_INTERVAL &&
-         (g_hash_table_size(cache) > MAX_CACHE_SIZE ||
-          now > last_cleaned + CACHE_CLEAN_INTERVAL)) {
-        g_hash_table_foreach_remove(cache, (GHRFunc) cache_clean_entry, &now);
-        last_cleaned = now;
-    }
+	time_t now = time(NULL);
+	if (now > cache.last_cleaned + MIN_CACHE_CLEAN_INTERVAL &&
+	    (g_hash_table_size(cache.table) > MAX_CACHE_SIZE ||
+	     now > cache.last_cleaned + CACHE_CLEAN_INTERVAL)) {
+		g_hash_table_foreach_remove(cache.table,
+					    (GHRFunc) cache_clean_entry, &now);
+		cache.last_cleaned = now;
+	}
 }
 
 static struct node *cache_lookup(const char *path)
 {
-    return (struct node *) g_hash_table_lookup(cache, path);
+	return (struct node *) g_hash_table_lookup(cache.table, path);
 }
 
 static void cache_purge(const char *path)
 {
-    g_hash_table_remove(cache, path);
+	g_hash_table_remove(cache.table, path);
 }
 
 static void cache_purge_parent(const char *path)
 {
-    const char *s = strrchr(path, '/');
-    if (s) {
-        if (s == path)
-            g_hash_table_remove(cache, "/");
-        else {
-            char *parent = g_strndup(path, s - path);
-            cache_purge(parent);
-            g_free(parent);
-        }
-    }
+	const char *s = strrchr(path, '/');
+	if (s) {
+		if (s == path)
+			g_hash_table_remove(cache.table, "/");
+		else {
+			char *parent = g_strndup(path, s - path);
+			cache_purge(parent);
+			g_free(parent);
+		}
+	}
 }
 
-static void cache_invalidate(const char *path)
+void cache_invalidate(const char *path)
 {
-    pthread_mutex_lock(&cache_lock);
-    cache_purge(path);
-    pthread_mutex_unlock(&cache_lock);
+	if (!cache.on)
+		return;
+
+	pthread_mutex_lock(&cache.lock);
+	cache_purge(path);
+	pthread_mutex_unlock(&cache.lock);
+}
+
+void cache_invalidate_write(const char *path)
+{
+	pthread_mutex_lock(&cache.lock);
+	cache_purge(path);
+	cache.write_ctr++;
+	pthread_mutex_unlock(&cache.lock);
 }
 
 static void cache_invalidate_dir(const char *path)
 {
-    pthread_mutex_lock(&cache_lock);
-    cache_purge(path);
-    cache_purge_parent(path);
-    pthread_mutex_unlock(&cache_lock);
+	pthread_mutex_lock(&cache.lock);
+	cache_purge(path);
+	cache_purge_parent(path);
+	pthread_mutex_unlock(&cache.lock);
+}
+
+static int cache_del_children(const char *key, void *val_, const char *path)
+{
+	(void) val_;
+	if (strncmp(key, path, strlen(path)) == 0)
+		return TRUE;
+	else
+		return FALSE;
 }
 
 static void cache_do_rename(const char *from, const char *to)
 {
-    pthread_mutex_lock(&cache_lock);
-    cache_purge(from);
-    cache_purge(to);
-    cache_purge_parent(from);
-    cache_purge_parent(to);
-    pthread_mutex_unlock(&cache_lock);
+	pthread_mutex_lock(&cache.lock);
+	g_hash_table_foreach_remove(cache.table, (GHRFunc) cache_del_children,
+				    (char *) from);
+	cache_purge(from);
+	cache_purge(to);
+	cache_purge_parent(from);
+	cache_purge_parent(to);
+	pthread_mutex_unlock(&cache.lock);
 }
 
 static struct node *cache_get(const char *path)
 {
-    struct node *node = cache_lookup(path);
-    if (node == NULL) {
-        char *pathcopy = g_strdup(path);
-        node = g_new0(struct node, 1);
-        g_hash_table_insert(cache, pathcopy, node);
-    }
-    return node;
+	struct node *node = cache_lookup(path);
+	if (node == NULL) {
+		char *pathcopy = g_strdup(path);
+		node = g_new0(struct node, 1);
+		g_hash_table_insert(cache.table, pathcopy, node);
+	}
+	return node;
 }
 
-static void cache_add_attr(const char *path, const struct stat *stbuf)
+void cache_add_attr(const char *path, const struct stat *stbuf, uint64_t wrctr)
 {
-    struct node *node;
-    time_t now;
+	struct node *node;
 
-    pthread_mutex_lock(&cache_lock);
-    node = cache_get(path);
-    now = time(NULL);
-    node->stat = *stbuf;
-    node->stat_valid = time(NULL) + cache_stat_timeout;
-    if (node->stat_valid > node->valid)
-        node->valid = node->stat_valid;
-    cache_clean();
-    pthread_mutex_unlock(&cache_lock);
+	if (!cache.on)
+		return;
+
+	pthread_mutex_lock(&cache.lock);
+	if (wrctr == cache.write_ctr) {
+		node = cache_get(path);
+		node->stat = *stbuf;
+		node->stat_valid = time(NULL) + cache.stat_timeout;
+		if (node->stat_valid > node->valid)
+			node->valid = node->stat_valid;
+		cache_clean();
+	}
+	pthread_mutex_unlock(&cache.lock);
 }
 
 static void cache_add_dir(const char *path, char **dir)
 {
-    struct node *node;
-    time_t now;
+	struct node *node;
 
-    pthread_mutex_lock(&cache_lock);
-    node = cache_get(path);
-    now = time(NULL);
-    g_strfreev(node->dir);
-    node->dir = dir;
-    node->dir_valid = time(NULL) + cache_dir_timeout;
-    if (node->dir_valid > node->valid)
-        node->valid = node->dir_valid;
-    cache_clean();
-    pthread_mutex_unlock(&cache_lock);
+	pthread_mutex_lock(&cache.lock);
+	node = cache_get(path);
+	g_strfreev(node->dir);
+	node->dir = dir;
+	node->dir_valid = time(NULL) + cache.dir_timeout;
+	if (node->dir_valid > node->valid)
+		node->valid = node->dir_valid;
+	cache_clean();
+	pthread_mutex_unlock(&cache.lock);
 }
 
 static size_t my_strnlen(const char *s, size_t maxsize)
 {
-    const char *p;
-    for (p = s; maxsize && *p; maxsize--, p++);
-    return p - s;
+	const char *p;
+	for (p = s; maxsize && *p; maxsize--, p++);
+	return p - s;
 }
 
 static void cache_add_link(const char *path, const char *link, size_t size)
 {
-    struct node *node;
-    time_t now;
+	struct node *node;
 
-    pthread_mutex_lock(&cache_lock);
-    node = cache_get(path);
-    now = time(NULL);
-    g_free(node->link);
-    node->link = g_strndup(link, my_strnlen(link, size-1));
-    node->link_valid = time(NULL) + cache_link_timeout;
-    if (node->link_valid > node->valid)
-        node->valid = node->link_valid;
-    cache_clean();
-    pthread_mutex_unlock(&cache_lock);
+	pthread_mutex_lock(&cache.lock);
+	node = cache_get(path);
+	g_free(node->link);
+	node->link = g_strndup(link, my_strnlen(link, size-1));
+	node->link_valid = time(NULL) + cache.link_timeout;
+	if (node->link_valid > node->valid)
+		node->valid = node->link_valid;
+	cache_clean();
+	pthread_mutex_unlock(&cache.lock);
+}
+
+static int cache_get_attr(const char *path, struct stat *stbuf)
+{
+	struct node *node;
+	int err = -EAGAIN;
+	pthread_mutex_lock(&cache.lock);
+	node = cache_lookup(path);
+	if (node != NULL) {
+		time_t now = time(NULL);
+		if (node->stat_valid - now >= 0) {
+			*stbuf = node->stat;
+			err = 0;
+		}
+	}
+	pthread_mutex_unlock(&cache.lock);
+	return err;
+}
+
+uint64_t cache_get_write_ctr(void)
+{
+	uint64_t res;
+
+	pthread_mutex_lock(&cache.lock);
+	res = cache.write_ctr;
+	pthread_mutex_unlock(&cache.lock);
+
+	return res;
 }
 
 static int cache_getattr(const char *path, struct stat *stbuf)
 {
-    struct node *node;
-    int err;
-
-    pthread_mutex_lock(&cache_lock);
-    node = cache_lookup(path);
-    if (node != NULL) {
-        time_t now = time(NULL);
-        if (node->stat_valid - now >= 0) {
-            *stbuf = node->stat;
-            pthread_mutex_unlock(&cache_lock);
-            return 0;
-        }
-    }
-    pthread_mutex_unlock(&cache_lock);
-    err = next_oper->oper.getattr(path, stbuf);
-    if (!err)
-        cache_add_attr(path, stbuf);
-
-    return err;
+	int err = cache_get_attr(path, stbuf);
+	if (err) {
+		uint64_t wrctr = cache_get_write_ctr();
+		err = cache.next_oper->oper.getattr(path, stbuf);
+		if (!err)
+			cache_add_attr(path, stbuf, wrctr);
+	}
+	return err;
 }
 
 static int cache_readlink(const char *path, char *buf, size_t size)
 {
-    struct node *node;
-    int err;
+	struct node *node;
+	int err;
 
-    pthread_mutex_lock(&cache_lock);
-    node = cache_lookup(path);
-    if (node != NULL) {
-        time_t now = time(NULL);
-        if (node->link_valid - now >= 0) {
-            strncpy(buf, node->link, size-1);
-            buf[size-1] = '\0';
-            pthread_mutex_unlock(&cache_lock);
-            return 0;
-        }
-    }
-    pthread_mutex_unlock(&cache_lock);
-    err = next_oper->oper.readlink(path, buf, size);
-    if (!err)
-        cache_add_link(path, buf, size);
+	pthread_mutex_lock(&cache.lock);
+	node = cache_lookup(path);
+	if (node != NULL) {
+		time_t now = time(NULL);
+		if (node->link_valid - now >= 0) {
+			strncpy(buf, node->link, size-1);
+			buf[size-1] = '\0';
+			pthread_mutex_unlock(&cache.lock);
+			return 0;
+		}
+	}
+	pthread_mutex_unlock(&cache.lock);
+	err = cache.next_oper->oper.readlink(path, buf, size);
+	if (!err)
+		cache_add_link(path, buf, size);
 
-    return err;
+	return err;
 }
 
 static int cache_dirfill(fuse_cache_dirh_t ch, const char *name,
                          const struct stat *stbuf)
 {
-    int err = ch->filler(ch->h, name, 0, 0);
-    if (!err) {
-        char *fullpath;
-        g_ptr_array_add(ch->dir, g_strdup(name));
-        fullpath = g_strdup_printf("%s/%s", !ch->path[1] ? "" : ch->path, name);
-        cache_add_attr(fullpath, stbuf);
-        g_free(fullpath);
-    }
-    return err;
+	int err = ch->filler(ch->h, name, 0, 0);
+	if (!err) {
+		g_ptr_array_add(ch->dir, g_strdup(name));
+		if (stbuf->st_mode & S_IFMT) {
+			char *fullpath;
+			const char *basepath = !ch->path[1] ? "" : ch->path;
+
+			fullpath = g_strdup_printf("%s/%s", basepath, name);
+			cache_add_attr(fullpath, stbuf, ch->wrctr);
+			g_free(fullpath);
+		}
+	}
+	return err;
 }
 
 static int cache_getdir(const char *path, fuse_dirh_t h, fuse_dirfil_t filler)
 {
-    struct fuse_cache_dirhandle ch;
-    int err;
-    char **dir;
-    struct node *node;
+	struct fuse_cache_dirhandle ch;
+	int err;
+	char **dir;
+	struct node *node;
 
-    pthread_mutex_lock(&cache_lock);
-    node = cache_lookup(path);
-    if (node != NULL && node->dir != NULL) {
-        time_t now = time(NULL);
-        if (node->dir_valid - now >= 0) {
-            for(dir = node->dir; *dir != NULL; dir++)
-                filler(h, *dir, 0, 0);
-            pthread_mutex_unlock(&cache_lock);
-            return 0;
-        }
-    }
-    pthread_mutex_unlock(&cache_lock);
+	pthread_mutex_lock(&cache.lock);
+	node = cache_lookup(path);
+	if (node != NULL && node->dir != NULL) {
+		time_t now = time(NULL);
+		if (node->dir_valid - now >= 0) {
+			for(dir = node->dir; *dir != NULL; dir++)
+				filler(h, *dir, 0, 0);
+			pthread_mutex_unlock(&cache.lock);
+			return 0;
+		}
+	}
+	pthread_mutex_unlock(&cache.lock);
 
-    ch.path = path;
-    ch.h = h;
-    ch.filler = filler;
-    ch.dir = g_ptr_array_new();
-    err = next_oper->cache_getdir(path, &ch, cache_dirfill);
-    g_ptr_array_add(ch.dir, NULL);
-    dir = (char **) ch.dir->pdata;
-    if (!err)
-        cache_add_dir(path, dir);
-    else
-        g_strfreev(dir);
-    g_ptr_array_free(ch.dir, FALSE);
-    return err;
+	ch.path = path;
+	ch.h = h;
+	ch.filler = filler;
+	ch.dir = g_ptr_array_new();
+	ch.wrctr = cache_get_write_ctr();
+	err = cache.next_oper->cache_getdir(path, &ch, cache_dirfill);
+	g_ptr_array_add(ch.dir, NULL);
+	dir = (char **) ch.dir->pdata;
+	if (!err)
+		cache_add_dir(path, dir);
+	else
+		g_strfreev(dir);
+	g_ptr_array_free(ch.dir, FALSE);
+	return err;
 }
 
 static int cache_unity_dirfill(fuse_cache_dirh_t ch, const char *name,
                                const struct stat *stbuf)
 {
-    (void) stbuf;
-    return ch->filler(ch->h, name, 0, 0);
+	(void) stbuf;
+	return ch->filler(ch->h, name, 0, 0);
 }
 
 static int cache_unity_getdir(const char *path, fuse_dirh_t h,
                               fuse_dirfil_t filler)
 {
-    struct fuse_cache_dirhandle ch;
-    ch.h = h;
-    ch.filler = filler;
-    return next_oper->cache_getdir(path, &ch, cache_unity_dirfill);
+	struct fuse_cache_dirhandle ch;
+	ch.h = h;
+	ch.filler = filler;
+	return cache.next_oper->cache_getdir(path, &ch, cache_unity_dirfill);
 }
 
 static int cache_mknod(const char *path, mode_t mode, dev_t rdev)
 {
-    int err = next_oper->oper.mknod(path, mode, rdev);
-    if (!err)
-        cache_invalidate_dir(path);
-    return err;
+	int err = cache.next_oper->oper.mknod(path, mode, rdev);
+	if (!err)
+		cache_invalidate_dir(path);
+	return err;
 }
 
 static int cache_mkdir(const char *path, mode_t mode)
 {
-    int err = next_oper->oper.mkdir(path, mode);
-    if (!err)
-        cache_invalidate_dir(path);
-    return err;
+	int err = cache.next_oper->oper.mkdir(path, mode);
+	if (!err)
+		cache_invalidate_dir(path);
+	return err;
 }
 
 static int cache_unlink(const char *path)
 {
-    int err = next_oper->oper.unlink(path);
-    if (!err)
-        cache_invalidate_dir(path);
-    return err;
+	int err = cache.next_oper->oper.unlink(path);
+	if (!err)
+		cache_invalidate_dir(path);
+	return err;
 }
 
 static int cache_rmdir(const char *path)
 {
-    int err = next_oper->oper.rmdir(path);
-    if (!err)
-        cache_invalidate_dir(path);
-    return err;
+	int err = cache.next_oper->oper.rmdir(path);
+	if (!err)
+		cache_invalidate_dir(path);
+	return err;
 }
 
 static int cache_symlink(const char *from, const char *to)
 {
-    int err = next_oper->oper.symlink(from, to);
-    if (!err)
-        cache_invalidate_dir(to);
-    return err;
+	int err = cache.next_oper->oper.symlink(from, to);
+	if (!err)
+		cache_invalidate_dir(to);
+	return err;
 }
 
 static int cache_rename(const char *from, const char *to)
 {
-    int err = next_oper->oper.rename(from, to);
-    if (!err)
-        cache_do_rename(from, to);
-    return err;
+	int err = cache.next_oper->oper.rename(from, to);
+	if (!err)
+		cache_do_rename(from, to);
+	return err;
 }
 
 static int cache_link(const char *from, const char *to)
 {
-    int err = next_oper->oper.link(from, to);
-    if (!err) {
-        cache_invalidate(from);
-        cache_invalidate_dir(to);
-    }
-    return err;
+	int err = cache.next_oper->oper.link(from, to);
+	if (!err) {
+		cache_invalidate(from);
+		cache_invalidate_dir(to);
+	}
+	return err;
 }
 
 static int cache_chmod(const char *path, mode_t mode)
 {
-    int err = next_oper->oper.chmod(path, mode);
-    if (!err)
-        cache_invalidate(path);
-    return err;
+	int err = cache.next_oper->oper.chmod(path, mode);
+	if (!err)
+		cache_invalidate(path);
+	return err;
 }
 
 static int cache_chown(const char *path, uid_t uid, gid_t gid)
 {
-    int err = next_oper->oper.chown(path, uid, gid);
-    if (!err)
-        cache_invalidate(path);
-    return err;
+	int err = cache.next_oper->oper.chown(path, uid, gid);
+	if (!err)
+		cache_invalidate(path);
+	return err;
 }
 
 static int cache_truncate(const char *path, off_t size)
 {
-    int err = next_oper->oper.truncate(path, size);
-    if (!err)
-        cache_invalidate(path);
-    return err;
+	int err = cache.next_oper->oper.truncate(path, size);
+	if (!err)
+		cache_invalidate(path);
+	return err;
 }
 
 static int cache_utime(const char *path, struct utimbuf *buf)
 {
-    int err = next_oper->oper.utime(path, buf);
-    if (!err)
-        cache_invalidate(path);
-    return err;
+	int err = cache.next_oper->oper.utime(path, buf);
+	if (!err)
+		cache_invalidate(path);
+	return err;
 }
 
 static int cache_write(const char *path, const char *buf, size_t size,
                        off_t offset, struct fuse_file_info *fi)
 {
-    int res = next_oper->oper.write(path, buf, size, offset, fi);
-    if (res >= 0)
-        cache_invalidate(path);
-    return res;
+	int res = cache.next_oper->oper.write(path, buf, size, offset, fi);
+	if (res >= 0)
+		cache_invalidate_write(path);
+	return res;
 }
 
+#if FUSE_VERSION >= 25
+static int cache_create(const char *path, mode_t mode,
+                        struct fuse_file_info *fi)
+{
+	int err = cache.next_oper->oper.create(path, mode, fi);
+	if (!err)
+		cache_invalidate_dir(path);
+	return err;
+}
+
+static int cache_ftruncate(const char *path, off_t size,
+                           struct fuse_file_info *fi)
+{
+	int err = cache.next_oper->oper.ftruncate(path, size, fi);
+	if (!err)
+		cache_invalidate(path);
+	return err;
+}
+
+static int cache_fgetattr(const char *path, struct stat *stbuf,
+                          struct fuse_file_info *fi)
+{
+	int err = cache_get_attr(path, stbuf);
+	if (err) {
+		uint64_t wrctr = cache_get_write_ctr();
+		err = cache.next_oper->oper.fgetattr(path, stbuf, fi);
+		if (!err)
+			cache_add_attr(path, stbuf, wrctr);
+	}
+	return err;
+}
+#endif
+
 static void cache_unity_fill(struct fuse_cache_operations *oper,
                              struct fuse_operations *cache_oper)
 {
 #if FUSE_VERSION >= 23
-    cache_oper->init        = oper->oper.init;
+	cache_oper->init        = oper->oper.init;
 #endif
-    cache_oper->getattr     = oper->oper.getattr;
-    cache_oper->readlink    = oper->oper.readlink;
-    cache_oper->getdir      = cache_unity_getdir;
-    cache_oper->mknod       = oper->oper.mknod;
-    cache_oper->mkdir       = oper->oper.mkdir;
-    cache_oper->symlink     = oper->oper.symlink;
-    cache_oper->unlink      = oper->oper.unlink;
-    cache_oper->rmdir       = oper->oper.rmdir;
-    cache_oper->rename      = oper->oper.rename;
-    cache_oper->link        = oper->oper.link;
-    cache_oper->chmod       = oper->oper.chmod;
-    cache_oper->chown       = oper->oper.chown;
-    cache_oper->truncate    = oper->oper.truncate;
-    cache_oper->utime       = oper->oper.utime;
-    cache_oper->open        = oper->oper.open;
-    cache_oper->read        = oper->oper.read;
-    cache_oper->write       = oper->oper.write;
-    cache_oper->flush       = oper->oper.flush;
-    cache_oper->release     = oper->oper.release;
-    cache_oper->fsync       = oper->oper.fsync;
-    cache_oper->statfs      = oper->oper.statfs;
-    cache_oper->setxattr    = oper->oper.setxattr;
-    cache_oper->getxattr    = oper->oper.getxattr;
-    cache_oper->listxattr   = oper->oper.listxattr;
-    cache_oper->removexattr = oper->oper.removexattr;
+	cache_oper->getattr     = oper->oper.getattr;
+	cache_oper->access	= oper->oper.access;
+	cache_oper->readlink    = oper->oper.readlink;
+	cache_oper->getdir      = cache_unity_getdir;
+	cache_oper->mknod       = oper->oper.mknod;
+	cache_oper->mkdir       = oper->oper.mkdir;
+	cache_oper->symlink     = oper->oper.symlink;
+	cache_oper->unlink      = oper->oper.unlink;
+	cache_oper->rmdir       = oper->oper.rmdir;
+	cache_oper->rename      = oper->oper.rename;
+	cache_oper->link        = oper->oper.link;
+	cache_oper->chmod       = oper->oper.chmod;
+	cache_oper->chown       = oper->oper.chown;
+	cache_oper->truncate    = oper->oper.truncate;
+	cache_oper->utime       = oper->oper.utime;
+	cache_oper->open        = oper->oper.open;
+	cache_oper->read        = oper->oper.read;
+	cache_oper->write       = oper->oper.write;
+	cache_oper->flush       = oper->oper.flush;
+	cache_oper->release     = oper->oper.release;
+	cache_oper->fsync       = oper->oper.fsync;
+	cache_oper->statfs      = oper->oper.statfs;
+	cache_oper->setxattr    = oper->oper.setxattr;
+	cache_oper->getxattr    = oper->oper.getxattr;
+	cache_oper->listxattr   = oper->oper.listxattr;
+	cache_oper->removexattr = oper->oper.removexattr;
+#if FUSE_VERSION >= 25
+	cache_oper->create      = oper->oper.create;
+	cache_oper->ftruncate   = oper->oper.ftruncate;
+	cache_oper->fgetattr    = oper->oper.fgetattr;
+#endif
+}
+
+static void cache_fill(struct fuse_cache_operations *oper,
+		       struct fuse_operations *cache_oper)
+{
+	cache_oper->getattr  = oper->oper.getattr ? cache_getattr : NULL;
+	cache_oper->readlink = oper->oper.readlink ? cache_readlink : NULL;
+	cache_oper->getdir   = oper->cache_getdir ? cache_getdir : NULL;
+	cache_oper->mknod    = oper->oper.mknod ? cache_mknod : NULL;
+	cache_oper->mkdir    = oper->oper.mkdir ? cache_mkdir : NULL;
+	cache_oper->symlink  = oper->oper.symlink ? cache_symlink : NULL;
+	cache_oper->unlink   = oper->oper.unlink ? cache_unlink : NULL;
+	cache_oper->rmdir    = oper->oper.rmdir ? cache_rmdir : NULL;
+	cache_oper->rename   = oper->oper.rename ? cache_rename : NULL;
+	cache_oper->link     = oper->oper.link ? cache_link : NULL;
+	cache_oper->chmod    = oper->oper.chmod ? cache_chmod : NULL;
+	cache_oper->chown    = oper->oper.chown ? cache_chown : NULL;
+	cache_oper->truncate = oper->oper.truncate ? cache_truncate : NULL;
+	cache_oper->utime    = oper->oper.utime ? cache_utime : NULL;
+	cache_oper->write    = oper->oper.write ? cache_write : NULL;
+#if FUSE_VERSION >= 25
+	cache_oper->create   = oper->oper.create ? cache_create : NULL;
+	cache_oper->ftruncate = oper->oper.ftruncate ? cache_ftruncate : NULL;
+	cache_oper->fgetattr = oper->oper.fgetattr ? cache_fgetattr : NULL;
+#endif
+
 }
 
 struct fuse_operations *cache_init(struct fuse_cache_operations *oper)
 {
-    static struct fuse_operations cache_oper;
-    next_oper = oper;
+	static struct fuse_operations cache_oper;
+	cache.next_oper = oper;
 
-    cache_unity_fill(oper, &cache_oper);
-    if (cache_on) {
-        cache_oper.getattr  = oper->oper.getattr ? cache_getattr : NULL;
-        cache_oper.readlink = oper->oper.readlink ? cache_readlink : NULL;
-        cache_oper.getdir   = oper->cache_getdir ? cache_getdir : NULL;
-        cache_oper.mknod    = oper->oper.mknod ? cache_mknod : NULL;
-        cache_oper.mkdir    = oper->oper.mkdir ? cache_mkdir : NULL;
-        cache_oper.symlink  = oper->oper.symlink ? cache_symlink : NULL;
-        cache_oper.unlink   = oper->oper.unlink ? cache_unlink : NULL;
-        cache_oper.rmdir    = oper->oper.rmdir ? cache_rmdir : NULL;
-        cache_oper.rename   = oper->oper.rename ? cache_rename : NULL;
-        cache_oper.link     = oper->oper.link ? cache_link : NULL;
-        cache_oper.chmod    = oper->oper.chmod ? cache_chmod : NULL;
-        cache_oper.chown    = oper->oper.chown ? cache_chown : NULL;
-        cache_oper.truncate = oper->oper.truncate ? cache_truncate : NULL;
-        cache_oper.utime    = oper->oper.utime ? cache_utime : NULL;
-        cache_oper.write    = oper->oper.write ? cache_write : NULL;
-        pthread_mutex_init(&cache_lock, NULL);
-        cache = g_hash_table_new_full(g_str_hash, g_str_equal, g_free,
-                                      free_node);
-        if (cache == NULL) {
-            fprintf(stderr, "failed to create cache\n");
-            return NULL;
-        }
-    }
-    return &cache_oper;
+	cache_unity_fill(oper, &cache_oper);
+	if (cache.on) {
+		cache_fill(oper, &cache_oper);
+		pthread_mutex_init(&cache.lock, NULL);
+		cache.table = g_hash_table_new_full(g_str_hash, g_str_equal,
+						    g_free, free_node);
+		if (cache.table == NULL) {
+			fprintf(stderr, "failed to create cache\n");
+			return NULL;
+		}
+	}
+	return &cache_oper;
 }
 
-enum {
-    COPT_CACHE,
-    COPT_TIMEOUT,
-    COPT_STAT_TIMEOUT,
-    COPT_DIR_TIMEOUT,
-    COPT_LINK_TIMEOUT,
-    COPT_LAST /* Last entry in this list! */
+static const struct fuse_opt cache_opts[] = {
+	{ "cache=yes", offsetof(struct cache, on), 1 },
+	{ "cache=no", offsetof(struct cache, on), 0 },
+	{ "cache_timeout=%u", offsetof(struct cache, stat_timeout), 0 },
+	{ "cache_timeout=%u", offsetof(struct cache, dir_timeout), 0 },
+	{ "cache_timeout=%u", offsetof(struct cache, link_timeout), 0 },
+	{ "cache_stat_timeout=%u", offsetof(struct cache, stat_timeout), 0 },
+	{ "cache_dir_timeout=%u", offsetof(struct cache, dir_timeout), 0 },
+	{ "cache_link_timeout=%u", offsetof(struct cache, link_timeout), 0 },
+	FUSE_OPT_END
 };
 
-static struct opt cache_opts[] = {
-    [COPT_CACHE] =        { .optname = "cache" },
-    [COPT_TIMEOUT] =      { .optname = "cache_timeout" },
-    [COPT_STAT_TIMEOUT] = { .optname = "cache_stat_timeout" },
-    [COPT_DIR_TIMEOUT]  = { .optname = "cache_dir_timeout" },
-    [COPT_LINK_TIMEOUT] = { .optname = "cache_link_timeout" },
-    [COPT_LAST] =         { .optname = NULL }
-};
-
-static int get_timeout(int sel, unsigned *timeoutp)
+int cache_parse_options(struct fuse_args *args)
 {
-    struct opt *o = &cache_opts[sel];
-    if (!o->present)
-        return 0;
-    if (opt_get_unsigned(o, timeoutp) == -1)
-        return -1;
-    return 1;
-}
+	cache.stat_timeout = DEFAULT_CACHE_TIMEOUT;
+	cache.dir_timeout = DEFAULT_CACHE_TIMEOUT;
+	cache.link_timeout = DEFAULT_CACHE_TIMEOUT;
+	cache.on = 1;
 
-int cache_parse_options(int *argcp, char *argv[])
-{
-    unsigned timeout;
-    int res;
-    process_options(argcp, argv, cache_opts, 1);
-    if (cache_opts[COPT_CACHE].present) {
-        char *val = cache_opts[COPT_CACHE].value;
-        if (!val || !val[0] ||
-            (strcmp(val, "yes") != 0 && strcmp(val, "no") != 0)) {
-            fprintf(stderr, "Invalid or missing value for 'cache' option\n");
-            return -1;
-        }
-        if (strcmp(val, "yes") == 0)
-            cache_on = 1;
-        else
-            cache_on = 0;
-    }
-    if ((res = get_timeout(COPT_TIMEOUT, &timeout)) == -1)
-        return -1;
-    if (res == 1) {
-        cache_stat_timeout = timeout;
-        cache_dir_timeout = timeout;
-        cache_link_timeout = timeout;
-    }
-    if(get_timeout(COPT_STAT_TIMEOUT, &cache_stat_timeout) == -1 ||
-       get_timeout(COPT_DIR_TIMEOUT, &cache_dir_timeout) == -1 ||
-       get_timeout(COPT_LINK_TIMEOUT, &cache_link_timeout) == -1)
-        return -1;
-    return 0;
+	return fuse_opt_parse(args, &cache, cache_opts, NULL);
 }

cache.h

@@ -7,6 +7,7 @@
 */
 
 #include <fuse.h>
+#include <fuse_opt.h>
 
 #ifndef FUSE_VERSION
 #define FUSE_VERSION (FUSE_MAJOR_VERSION * 10 + FUSE_MINOR_VERSION)
@@ -19,8 +20,10 @@ typedef int (*fuse_cache_dirfil_t) (fuse_cache_dirh_t h, const char *name,
 struct fuse_cache_operations {
     struct fuse_operations oper;
     int (*cache_getdir) (const char *, fuse_cache_dirh_t, fuse_cache_dirfil_t);
-    
 };
 
 struct fuse_operations *cache_init(struct fuse_cache_operations *oper);
-int cache_parse_options(int *argcp, char *argv[]);
+int cache_parse_options(struct fuse_args *args);
+void cache_add_attr(const char *path, const struct stat *stbuf, uint64_t wrctr);
+void cache_invalidate(const char *path);
+uint64_t cache_get_write_ctr(void);

compat/fuse_opt.c

@@ -0,0 +1,364 @@
+/*
+    FUSE: Filesystem in Userspace
+    Copyright (C) 2001-2006  Miklos Szeredi <miklos@szeredi.hu>
+
+    This program can be distributed under the terms of the GNU LGPL.
+    See the file COPYING.LIB
+*/
+
+#include "fuse_opt.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+
+struct fuse_opt_context {
+    void *data;
+    const struct fuse_opt *opt;
+    fuse_opt_proc_t proc;
+    int argctr;
+    int argc;
+    char **argv;
+    struct fuse_args outargs;
+    char *opts;
+    int nonopt;
+};
+
+void fuse_opt_free_args(struct fuse_args *args)
+{
+    if (args && args->argv && args->allocated) {
+        int i;
+        for (i = 0; i < args->argc; i++)
+            free(args->argv[i]);
+        free(args->argv);
+        args->argv = NULL;
+        args->allocated = 0;
+    }
+}
+
+static int alloc_failed(void)
+{
+    fprintf(stderr, "fuse: memory allocation failed\n");
+    return -1;
+}
+
+int fuse_opt_add_arg(struct fuse_args *args, const char *arg)
+{
+    char **newargv;
+    char *newarg;
+
+    assert(!args->argv || args->allocated);
+
+    newargv = realloc(args->argv, (args->argc + 2) * sizeof(char *));
+    newarg = newargv ? strdup(arg) : NULL;
+    if (!newargv || !newarg)
+        return alloc_failed();
+
+    args->argv = newargv;
+    args->allocated = 1;
+    args->argv[args->argc++] = newarg;
+    args->argv[args->argc] = NULL;
+    return 0;
+}
+
+int fuse_opt_insert_arg(struct fuse_args *args, int pos, const char *arg)
+{
+    assert(pos <= args->argc);
+    if (fuse_opt_add_arg(args, arg) == -1)
+        return -1;
+
+    if (pos != args->argc - 1) {
+        char *newarg = args->argv[args->argc - 1];
+        memmove(&args->argv[pos + 1], &args->argv[pos],
+                sizeof(char *) * (args->argc - pos - 1));
+        args->argv[pos] = newarg;
+    }
+    return 0;
+}
+
+static int next_arg(struct fuse_opt_context *ctx, const char *opt)
+{
+    if (ctx->argctr + 1 >= ctx->argc) {
+        fprintf(stderr, "fuse: missing argument after `%s'\n", opt);
+        return -1;
+    }
+    ctx->argctr++;
+    return 0;
+}
+
+static int add_arg(struct fuse_opt_context *ctx, const char *arg)
+{
+    return fuse_opt_add_arg(&ctx->outargs, arg);
+}
+
+int fuse_opt_add_opt(char **opts, const char *opt)
+{
+    char *newopts;
+    if (!*opts)
+        newopts = strdup(opt);
+    else {
+        unsigned oldlen = strlen(*opts);
+        newopts = realloc(*opts, oldlen + 1 + strlen(opt) + 1);
+        if (newopts) {
+            newopts[oldlen] = ',';
+            strcpy(newopts + oldlen + 1, opt);
+        }
+    }
+    if (!newopts)
+        return alloc_failed();
+
+    *opts = newopts;
+    return 0;
+}
+
+static int add_opt(struct fuse_opt_context *ctx, const char *opt)
+{
+    return fuse_opt_add_opt(&ctx->opts, opt);
+}
+
+static int call_proc(struct fuse_opt_context *ctx, const char *arg, int key,
+                     int iso)
+{
+    if (key == FUSE_OPT_KEY_DISCARD)
+        return 0;
+
+    if (key != FUSE_OPT_KEY_KEEP && ctx->proc) {
+        int res = ctx->proc(ctx->data, arg, key, &ctx->outargs);
+        if (res == -1 || !res)
+            return res;
+    }
+    if (iso)
+        return add_opt(ctx, arg);
+    else
+        return add_arg(ctx, arg);
+}
+
+static int match_template(const char *t, const char *arg, unsigned *sepp)
+{
+    int arglen = strlen(arg);
+    const char *sep = strchr(t, '=');
+    sep = sep ? sep : strchr(t, ' ');
+    if (sep && (!sep[1] || sep[1] == '%')) {
+        int tlen = sep - t;
+        if (sep[0] == '=')
+            tlen ++;
+        if (arglen >= tlen && strncmp(arg, t, tlen) == 0) {
+            *sepp = sep - t;
+            return 1;
+        }
+    }
+    if (strcmp(t, arg) == 0) {
+        *sepp = 0;
+        return 1;
+    }
+    return 0;
+}
+
+static const struct fuse_opt *find_opt(const struct fuse_opt *opt,
+                                       const char *arg, unsigned *sepp)
+{
+    for (; opt && opt->templ; opt++)
+        if (match_template(opt->templ, arg, sepp))
+            return opt;
+    return NULL;
+}
+
+int fuse_opt_match(const struct fuse_opt *opts, const char *opt)
+{
+    unsigned dummy;
+    return find_opt(opts, opt, &dummy) ? 1 : 0;
+}
+
+static int process_opt_param(void *var, const char *format, const char *param,
+                             const char *arg)
+{
+    assert(format[0] == '%');
+    if (format[1] == 's') {
+        char *copy = strdup(param);
+        if (!copy)
+            return alloc_failed();
+
+        *(char **) var = copy;
+    } else {
+        if (sscanf(param, format, var) != 1) {
+            fprintf(stderr, "fuse: invalid parameter in option `%s'\n", arg);
+            return -1;
+        }
+    }
+    return 0;
+}
+
+static int process_opt(struct fuse_opt_context *ctx,
+                       const struct fuse_opt *opt, unsigned sep,
+                       const char *arg, int iso)
+{
+    if (opt->offset == -1U) {
+        if (call_proc(ctx, arg, opt->value, iso) == -1)
+            return -1;
+    } else {
+        void *var = ctx->data + opt->offset;
+        if (sep && opt->templ[sep + 1]) {
+            const char *param = arg + sep;
+            if (opt->templ[sep] == '=')
+                param ++;
+            if (process_opt_param(var, opt->templ + sep + 1,
+                                  param, arg) == -1)
+                return -1;
+        } else
+            *(int *)var = opt->value;
+    }
+    return 0;
+}
+
+static int process_opt_sep_arg(struct fuse_opt_context *ctx,
+                               const struct fuse_opt *opt, unsigned sep,
+                               const char *arg, int iso)
+{
+    int res;
+    char *newarg;
+    char *param;
+
+    if (next_arg(ctx, arg) == -1)
+        return -1;
+
+    param = ctx->argv[ctx->argctr];
+    newarg = malloc(sep + strlen(param) + 1);
+    if (!newarg)
+        return alloc_failed();
+
+    memcpy(newarg, arg, sep);
+    strcpy(newarg + sep, param);
+    res = process_opt(ctx, opt, sep, newarg, iso);
+    free(newarg);
+
+    return res;
+}
+
+static int process_gopt(struct fuse_opt_context *ctx, const char *arg, int iso)
+{
+    unsigned sep;
+    const struct fuse_opt *opt = find_opt(ctx->opt, arg, &sep);
+    if (opt) {
+        for (; opt; opt = find_opt(opt + 1, arg, &sep)) {
+            int res;
+            if (sep && opt->templ[sep] == ' ' && !arg[sep])
+                res = process_opt_sep_arg(ctx, opt, sep, arg, iso);
+            else
+                res = process_opt(ctx, opt, sep, arg, iso);
+            if (res == -1)
+                return -1;
+        }
+        return 0;
+    } else
+        return call_proc(ctx, arg, FUSE_OPT_KEY_OPT, iso);
+}
+
+static int process_real_option_group(struct fuse_opt_context *ctx, char *opts)
+{
+    char *sep;
+
+    do {
+        int res;
+        sep = strchr(opts, ',');
+        if (sep)
+            *sep = '\0';
+        res = process_gopt(ctx, opts, 1);
+        if (res == -1)
+            return -1;
+        opts = sep + 1;
+    } while (sep);
+
+    return 0;
+}
+
+static int process_option_group(struct fuse_opt_context *ctx, const char *opts)
+{
+    int res;
+    char *copy;
+    const char *sep = strchr(opts, ',');
+    if (!sep)
+        return process_gopt(ctx, opts, 1);
+
+    copy = strdup(opts);
+    if (!copy) {
+        fprintf(stderr, "fuse: memory allocation failed\n");
+        return -1;
+    }
+    res = process_real_option_group(ctx, copy);
+    free(copy);
+    return res;
+}
+
+static int process_one(struct fuse_opt_context *ctx, const char *arg)
+{
+    if (ctx->nonopt || arg[0] != '-')
+        return call_proc(ctx, arg, FUSE_OPT_KEY_NONOPT, 0);
+    else if (arg[1] == 'o') {
+        if (arg[2])
+            return process_option_group(ctx, arg + 2);
+        else {
+            if (next_arg(ctx, arg) == -1)
+                return -1;
+
+            return process_option_group(ctx, ctx->argv[ctx->argctr]);
+        }
+    } else if (arg[1] == '-' && !arg[2]) {
+        if (add_arg(ctx, arg) == -1)
+            return -1;
+        ctx->nonopt = ctx->outargs.argc;
+        return 0;
+    } else
+        return process_gopt(ctx, arg, 0);
+}
+
+static int opt_parse(struct fuse_opt_context *ctx)
+{
+    if (ctx->argc) {
+        if (add_arg(ctx, ctx->argv[0]) == -1)
+            return -1;
+    }
+
+    for (ctx->argctr = 1; ctx->argctr < ctx->argc; ctx->argctr++)
+        if (process_one(ctx, ctx->argv[ctx->argctr]) == -1)
+            return -1;
+
+    if (ctx->opts) {
+        if (fuse_opt_insert_arg(&ctx->outargs, 1, "-o") == -1 ||
+            fuse_opt_insert_arg(&ctx->outargs, 2, ctx->opts) == -1)
+            return -1;
+    }
+    if (ctx->nonopt && ctx->nonopt == ctx->outargs.argc) {
+        free(ctx->outargs.argv[ctx->outargs.argc - 1]);
+        ctx->outargs.argv[--ctx->outargs.argc] = NULL;
+    }
+
+    return 0;
+}
+
+int fuse_opt_parse(struct fuse_args *args, void *data,
+                   const struct fuse_opt opts[], fuse_opt_proc_t proc)
+{
+    int res;
+    struct fuse_opt_context ctx = {
+        .data = data,
+        .opt = opts,
+        .proc = proc,
+    };
+
+    if (!args || !args->argv || !args->argc)
+        return 0;
+
+    ctx.argc = args->argc;
+    ctx.argv = args->argv;
+
+    res = opt_parse(&ctx);
+    if (res != -1) {
+        struct fuse_args tmp = *args;
+        *args = ctx.outargs;
+        ctx.outargs = tmp;
+    }
+    free(ctx.opts);
+    fuse_opt_free_args(&ctx.outargs);
+    return res;
+}

compat/fuse_opt.h

@@ -0,0 +1,258 @@
+/*
+    FUSE: Filesystem in Userspace
+    Copyright (C) 2001-2006  Miklos Szeredi <miklos@szeredi.hu>
+
+    This program can be distributed under the terms of the GNU GPL.
+    See the file COPYING.
+*/
+
+#ifndef _FUSE_OPT_H_
+#define _FUSE_OPT_H_
+
+/* This file defines the option parsing interface of FUSE */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Option description
+ *
+ * This structure describes a single option, and and action associated
+ * with it, in case it matches.
+ *
+ * More than one such match may occur, in which case the action for
+ * each match is executed.
+ *
+ * There are three possible actions in case of a match:
+ *
+ * i) An integer (int or unsigned) variable determined by 'offset' is
+ *    set to 'value'
+ *
+ * ii) The processing function is called, with 'value' as the key
+ *
+ * iii) An integer (any) or string (char *) variable determined by
+ *    'offset' is set to the value of an option parameter
+ *
+ * 'offset' should normally be either set to
+ *
+ *  - 'offsetof(struct foo, member)'  actions i) and iii)
+ *
+ *  - -1                              action ii)
+ *
+ * The 'offsetof()' macro is defined in the <stddef.h> header.
+ *
+ * The template determines which options match, and also have an
+ * effect on the action.  Normally the action is either i) or ii), but
+ * if a format is present in the template, then action iii) is
+ * performed.
+ *
+ * The types of templates are:
+ *
+ * 1) "-x", "-foo", "--foo", "--foo-bar", etc.  These match only
+ *   themselves.  Invalid values are "--" and anything beginning
+ *   with "-o"
+ *
+ * 2) "foo", "foo-bar", etc.  These match "-ofoo", "-ofoo-bar" or
+ *    the relevant option in a comma separated option list
+ *
+ * 3) "bar=", "--foo=", etc.  These are variations of 1) and 2)
+ *    which have a parameter
+ *
+ * 4) "bar=%s", "--foo=%lu", etc.  Same matching as above but perform
+ *    action iii).
+ *
+ * 5) "-x ", etc.  Matches either "-xparam" or "-x param" as
+ *    two separate arguments
+ *
+ * 6) "-x %s", etc.  Combination of 4) and 5)
+ *
+ * If the format is "%s", memory is allocated for the string unlike
+ * with scanf().
+ */
+struct fuse_opt {
+    /** Matching template and optional parameter formatting */
+    const char *templ;
+
+    /**
+     * Offset of variable within 'data' parameter of fuse_opt_parse()
+     * or -1
+     */
+    unsigned long offset;
+
+    /**
+     * Value to set the variable to, or to be passed as 'key' to the
+     * processing function.  Ignored if template has a format
+     */
+    int value;
+};
+
+/**
+ * Key option.  In case of a match, the processing function will be
+ * called with the specified key.
+ */
+#define FUSE_OPT_KEY(templ, key) { templ, -1U, key }
+
+/**
+ * Last option.  An array of 'struct fuse_opt' must end with a NULL
+ * template value
+ */
+#define FUSE_OPT_END { .templ = NULL }
+
+/**
+ * Argument list
+ */
+struct fuse_args {
+    /** Argument count */
+    int argc;
+
+    /** Argument vector.  NULL terminated */
+    char **argv;
+
+    /** Is 'argv' allocated? */
+    int allocated;
+};
+
+/**
+ * Initializer for 'struct fuse_args'
+ */
+#define FUSE_ARGS_INIT(argc, argv) { argc, argv, 0 }
+
+/**
+ * Key value passed to the processing function if an option did not
+ * match any template
+ */
+#define FUSE_OPT_KEY_OPT     -1
+
+/**
+ * Key value passed to the processing function for all non-options
+ *
+ * Non-options are the arguments beginning with a charater other than
+ * '-' or all arguments after the special '--' option
+ */
+#define FUSE_OPT_KEY_NONOPT  -2
+
+/**
+ * Special key value for options to keep
+ *
+ * Argument is not passed to processing function, but behave as if the
+ * processing function returned 1
+ */
+#define FUSE_OPT_KEY_KEEP -3
+
+/**
+ * Special key value for options to discard
+ *
+ * Argument is not passed to processing function, but behave as if the
+ * processing function returned zero
+ */
+#define FUSE_OPT_KEY_DISCARD -4
+
+/**
+ * Processing function
+ *
+ * This function is called if
+ *    - option did not match any 'struct fuse_opt'
+ *    - argument is a non-option
+ *    - option did match and offset was set to -1
+ *
+ * The 'arg' parameter will always contain the whole argument or
+ * option including the parameter if exists.  A two-argument option
+ * ("-x foo") is always converted to single arguemnt option of the
+ * form "-xfoo" before this function is called.
+ *
+ * Options of the form '-ofoo' are passed to this function without the
+ * '-o' prefix.
+ *
+ * The return value of this function determines whether this argument
+ * is to be inserted into the output argument vector, or discarded.
+ *
+ * @param data is the user data passed to the fuse_opt_parse() function
+ * @param arg is the whole argument or option
+ * @param key determines why the processing function was called
+ * @param outargs the current output argument list
+ * @return -1 on error, 0 if arg is to be discarded, 1 if arg should be kept
+ */
+typedef int (*fuse_opt_proc_t)(void *data, const char *arg, int key,
+                               struct fuse_args *outargs);
+
+/**
+ * Option parsing function
+ *
+ * If 'args' was returned from a previous call to fuse_opt_parse() or
+ * it was constructed from
+ *
+ * A NULL 'args' is equivalent to an empty argument vector
+ *
+ * A NULL 'opts' is equivalent to an 'opts' array containing a single
+ * end marker
+ *
+ * A NULL 'proc' is equivalent to a processing function always
+ * returning '1'
+ *
+ * @param args is the input and output argument list
+ * @param data is the user data
+ * @param opts is the option description array
+ * @param proc is the processing function
+ * @return -1 on error, 0 on success
+ */
+int fuse_opt_parse(struct fuse_args *args, void *data,
+                   const struct fuse_opt opts[], fuse_opt_proc_t proc);
+
+/**
+ * Add an option to a comma separated option list
+ *
+ * @param opts is a pointer to an option list, may point to a NULL value
+ * @param opt is the option to add
+ * @return -1 on allocation error, 0 on success
+ */
+int fuse_opt_add_opt(char **opts, const char *opt);
+
+/**
+ * Add an argument to a NULL terminated argument vector
+ *
+ * @param args is the structure containing the current argument list
+ * @param arg is the new argument to add
+ * @return -1 on allocation error, 0 on success
+ */
+int fuse_opt_add_arg(struct fuse_args *args, const char *arg);
+
+/**
+ * Add an argument at the specified position in a NULL terminated
+ * argument vector
+ *
+ * Adds the argument to the N-th position.  This is useful for adding
+ * options at the beggining of the array which must not come after the
+ * special '--' option.
+ *
+ * @param args is the structure containing the current argument list
+ * @param pos is the position at which to add the argument
+ * @param arg is the new argument to add
+ * @return -1 on allocation error, 0 on success
+ */
+int fuse_opt_insert_arg(struct fuse_args *args, int pos, const char *arg);
+
+/**
+ * Free the contents of argument list
+ *
+ * The structure itself is not freed
+ *
+ * @param args is the structure containing the argument list
+ */
+void fuse_opt_free_args(struct fuse_args *args);
+
+
+/**
+ * Check if an option matches
+ *
+ * @param opts is the option description array
+ * @param opt is the option to match
+ * @return 1 if a match is found, 0 if not
+ */
+int fuse_opt_match(const struct fuse_opt opts[], const char *opt);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _FUSE_OPT_H_ */

configure.ac

@@ -1,12 +1,52 @@
-AC_INIT(sshfs-fuse, 1.2)
-AM_INIT_AUTOMAKE
+AC_INIT(sshfs, 2.6)
+AM_INIT_AUTOMAKE([foreign subdir-objects])
 AM_CONFIG_HEADER(config.h)
 
 AC_PROG_CC
+AM_PROG_CC_C_O
+CFLAGS="$CFLAGS -Wall -W"
+LIBS=
+AC_SEARCH_LIBS(dlsym, [dl])
+sshnodelay_libs=$LIBS
+AC_SUBST(sshnodelay_libs)
+LIBS=
+
+AC_ARG_ENABLE(sshnodelay,
+	[  --disable-sshnodelay    Don't compile NODELAY workaround for ssh])
+
+if test -z "$enable_sshnodelay"; then
+	AC_MSG_CHECKING([OpenSSH version])
+	[eval `ssh -V 2>&1 | sed -n 's/^OpenSSH_\([1-9][0-9]*\)\.\([0-9][0-9]*\).*/ssh_major=\1 ssh_minor=\2/p'`]
+	if test "x$ssh_major" != x -a "x$ssh_minor" != x; then
+		if test $ssh_major -gt 4 -o \( $ssh_major = 4 -a $ssh_minor -ge 4 \); then
+			AC_MSG_RESULT([$ssh_major.$ssh_minor >= 4.4, disabling NODELAY workaround])
+			enable_sshnodelay=no
+		else
+			AC_MSG_RESULT([$ssh_major.$ssh_minor < 4.4, enabling NODELAY workaround])
+			enable_sshnodelay=yes
+		fi
+	else
+		AC_MSG_RESULT([not found])
+	fi
+fi
+
+if test "$enable_sshnodelay" = "yes"; then
+	AC_DEFINE(SSH_NODELAY_WORKAROUND, 1, [Compile ssh NODELAY workaround])
+fi
+
+AM_CONDITIONAL(SSH_NODELAY_SO, test "$enable_sshnodelay" = "yes")
+
 export PKG_CONFIG_PATH=/usr/local/lib/pkgconfig:$PKG_CONFIG_PATH
-PKG_CHECK_MODULES(SSHFS, [fuse >= 2.2 glib-2.0])
-CFLAGS="$CFLAGS -Wall -W -D_REENTRANT $SSHFS_CFLAGS"
-LIBS="$SSHFS_LIBS"
+PKG_CHECK_MODULES(SSHFS, [fuse >= 2.3 glib-2.0 gthread-2.0])
+have_fuse_opt_parse=no
+oldlibs="$LIBS"
+LIBS="$LIBS $SSHFS_LIBS"
+AC_CHECK_FUNC([fuse_opt_parse], [have_fuse_opt_parse=yes])
+LIBS="$oldlibs"
+if test "$have_fuse_opt_parse" = no; then
+	CFLAGS="$CFLAGS -Icompat"
+fi
+AM_CONDITIONAL(FUSE_OPT_COMPAT, test "$have_fuse_opt_parse" = no)
 
 AC_CONFIG_FILES([Makefile])
 AC_OUTPUT

opts.c

@@ -1,121 +0,0 @@
-/*
-    Mount option parsing
-    Copyright (C) 2004  Miklos Szeredi <miklos@szeredi.hu>
-
-    This program can be distributed under the terms of the GNU GPL.
-    See the file COPYING.
-*/
-
-#include "opts.h"
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-#include <glib.h>
-
-static int process_option(char *arg, struct opt opts[], int case_sensitive)
-{
-    int i;
-    char *eq = strchr(arg, '=');
-    if (eq)
-        *eq = '\0';
-
-    for (i = 0; opts[i].optname != NULL; i++) {
-        if (case_sensitive) {
-            if (strcmp(opts[i].optname, arg) == 0)
-                break;
-        } else if (strcasecmp(opts[i].optname, arg) == 0)
-            break;
-    }
-    if (opts[i].optname == NULL) {
-        if (eq)
-            *eq = '=';
-        return 0;
-    }
-    opts[i].present = 1;
-    if (eq) {
-        if (opts[i].value)
-            g_free(opts[i].value);
-        opts[i].value = g_strdup(eq+1);
-    }
-    return 1;
-}
-
-static int process_option_group(char *arg, struct opt opts[],
-                                int case_sensitive)
-{
-    int remove = 1;
-    char *prevcomma = NULL;
-    while (1) {
-        int remove_one;
-        char *comma = strchr(arg, ',');
-        if (comma)
-            *comma = '\0';
-        remove_one = process_option(arg, opts, case_sensitive);
-        if (remove_one) {
-            if (comma)
-                memmove(arg, comma + 1, strlen(comma + 1) + 1);
-        } else {
-            remove = 0;
-            if (comma)
-                arg = comma + 1;
-        }
-        if (!remove_one && prevcomma)
-            *prevcomma = ',';
-        if (!comma)
-            break;
-        prevcomma = comma;
-    }
-    return remove;
-}
-
-void process_options(int *argcp, char *argv[], struct opt opts[],
-                     int case_sensitive)
-{
-    int argctr;
-    int newargctr;
-
-    for (argctr = 1, newargctr = 1; argctr < *argcp; argctr++) {
-        char *arg = argv[argctr];
-        int removed = 0;
-        if (arg[0] == '-' && arg[1] == 'o') {
-            if (arg[2])
-                removed = process_option_group(arg+2, opts, case_sensitive);
-            else {
-                if (argctr + 1 < *argcp) {
-                    argctr++;
-                    arg = argv[argctr];
-                    removed = process_option_group(arg, opts, case_sensitive);
-                    if (removed)
-                        g_free(argv[argctr-1]);
-                    else if (argctr != newargctr)
-                        argv[newargctr++] = argv[argctr-1];
-                }
-            }
-        }
-        if (removed)
-            g_free(arg);
-        else {
-            if(argctr != newargctr)
-                argv[newargctr] = arg;
-            newargctr++;
-        }
-    }
-    *argcp = newargctr;
-}
-
-int opt_get_unsigned(const struct opt *o, unsigned *valp)
-{
-    char *end;
-    unsigned val;
-    if (!o->value || !o->value[0]) {
-        fprintf(stderr, "Missing value for '%s' option\n", o->optname);
-        return -1;
-    }
-    val = strtoul(o->value, &end, 0);
-    if (end[0]) {
-        fprintf(stderr, "Invalid value for '%s' option\n", o->optname);
-        return -1;
-    }
-    *valp = val;
-    return 0;
-}

opts.h

@@ -1,18 +0,0 @@
-/*
-    Mount option parsing
-    Copyright (C) 2004  Miklos Szeredi <miklos@szeredi.hu>
-
-    This program can be distributed under the terms of the GNU GPL.
-    See the file COPYING.
-*/
-
-struct opt {
-    const char *optname;
-    int present;
-    char *value;
-};
-
-void process_options(int *argcp, char *argv[], struct opt opts[], 
-                     int case_sensitive);
-
-int opt_get_unsigned(const struct opt *o, unsigned *valp);

sshfs.1

@@ -0,0 +1,286 @@
+.TH SSHFS "1" "April 2008" "SSHFS version 2.0" "User Commands"
+.SH NAME
+SSHFS \- filesystem client based on ssh
+.SH SYNOPSIS
+.SS mounting
+.TP
+\fBsshfs\fP [\fIuser\fP@]\fBhost\fP:[\fIdir\fP] \fBmountpoint\fP [\fIoptions\fP]
+.SS unmounting
+.TP
+\fBfusermount -u mountpoint\fP
+.SH DESCRIPTION
+SSHFS (Secure SHell FileSystem) is a file system for Linux (and other
+operating systems with a FUSE implementation, such as Mac OS X or FreeBSD)
+capable of operating on files on a remote computer using just a secure
+shell login on the remote computer. On the local computer where the SSHFS
+is mounted, the implementation makes use of the FUSE (Filesystem in
+Userspace) kernel module. The practical effect of this is that the end user
+can seamlessly interact with remote files being securely served over SSH
+just as if they were local files on his/her computer. On the remote
+computer the SFTP subsystem of SSH is used.
+.PP
+If \fIhost\fP is a numeric IPv6 address, it needs to be enclosed in
+square brackets.
+.SH OPTIONS
+.SS "general options:"
+.TP
+\fB\-o\fR opt,[opt...]
+mount options
+.TP
+\fB\-h\fR   \fB\-\-help\fR
+print help
+.TP
+\fB\-V\fR   \fB\-\-version\fR
+print version
+.SS "SSHFS options:"
+.TP
+\fB\-p\fR PORT
+equivalent to '\-o port=PORT'
+.TP
+\fB\-C\fR
+equivalent to '\-o compression=yes'
+.TP
+\fB\-F\fR ssh_configfile
+specifies alternative ssh configuration file
+.TP
+\fB\-1\fR
+equivalent to '\-o ssh_protocol=1'
+.TP
+\fB\-o\fR reconnect
+reconnect to server
+.TP
+\fB\-o\fR delay_connect
+delay connection to server
+.TP
+\fB\-o\fR sshfs_sync
+synchronous writes
+.TP
+\fB\-o\fR no_readahead
+synchronous reads (no speculative readahead)
+.TP
+\fB\-o\fR sync_readdir
+synchronous readdir
+.TP
+\fB\-o\fR sshfs_debug
+print some debugging information
+.TP
+\fB\-o\fR cache=BOOL
+enable caching {yes,no} (default: yes)
+.TP
+\fB\-o\fR cache_timeout=N
+sets timeout for caches in seconds (default: 20)
+.TP
+\fB\-o\fR cache_X_timeout=N
+sets timeout for {stat,dir,link} cache
+.TP
+\fB\-o\fR workaround=LIST
+colon separated list of workarounds
+.RS 8
+.TP
+none
+no workarounds enabled
+.TP
+all
+all workarounds enabled
+.TP
+[no]rename
+fix renaming to existing file (default: off)
+.TP
+[no]nodelaysrv
+set nodelay tcp flag in ssh (default: off)
+.TP
+[no]truncate
+fix truncate for old servers (default: off)
+.TP
+[no]buflimit
+fix buffer fillup bug in server (default: on)
+.RE
+.TP
+\fB\-o\fR idmap=TYPE
+user/group ID mapping, possible types are:
+.RS 8
+.TP
+none
+no translation of the ID space (default)
+.TP
+user
+only translate UID of connecting user
+.TP
+file
+translate UIDs/GIDs based upon the contents of \fBuidfile \fR and
+\fBgidfile\fR
+.RE
+.TP
+\fB\-o\fR uidfile=FILE
+file containing username:uid mappings for \fBidmap=file\fR
+.RE
+.TP
+\fB\-o\fR gidfile=FILE
+file containing groupname:gid mappings for \fBidmap=file\fR
+.RE
+.TP
+\fB\-o\fR nomap=TYPE
+with idmap=file, how to handle missing mappings
+.RS 8
+.TP
+ignore
+don't do any re-mapping
+.TP
+error
+return an error (default)
+.RE
+.TP
+\fB\-o\fR ssh_command=CMD
+execute CMD instead of 'ssh'
+.TP
+\fB\-o\fR ssh_protocol=N
+ssh protocol to use (default: 2)
+.TP
+\fB\-o\fR sftp_server=SERV
+path to sftp server or subsystem (default: sftp)
+.TP
+\fB\-o\fR directport=PORT
+directly connect to PORT bypassing ssh
+.TP
+\fB\-o\fR slave
+communicate over stdin and stdout bypassing network
+.TP
+\fB\-o\fR disable_hardlink
+link(2) will return with errno set to ENOSYS.  Hard links don't currently work
+perfectly on sshfs, and this confuses some programs.  If that happens try
+disabling hard links with this option.
+.TP
+\fB\-o\fR transform_symlinks
+transform absolute symlinks to relative
+.TP
+\fB\-o\fR follow_symlinks
+follow symlinks on the server
+.TP
+\fB\-o\fR no_check_root
+don't check for existence of 'dir' on server
+.TP
+\fB\-o\fR password_stdin
+read password from stdin (only for pam_mount!)
+.TP
+\fB\-o\fR SSHOPT=VAL
+ssh options (see man ssh_config)
+.SS "FUSE options:"
+.TP
+\fB\-d\fR   \fB\-o\fR debug
+enable debug output (implies \fB\-f\fR)
+.TP
+\fB\-f\fR
+foreground operation
+.TP
+\fB\-s\fR
+disable multi\-threaded operation
+.TP
+\fB\-o\fR allow_other
+allow access to other users
+.TP
+\fB\-o\fR allow_root
+allow access to root
+.TP
+\fB\-o\fR nonempty
+allow mounts over non\-empty file/dir
+.HP
+\fB\-o\fR default_permissions
+enable permission checking by kernel
+.TP
+\fB\-o\fR fsname=NAME
+set filesystem name
+.TP
+\fB\-o\fR subtype=NAME
+set filesystem type
+.TP
+\fB\-o\fR large_read
+issue large read requests (2.4 only)
+.TP
+\fB\-o\fR max_read=N
+set maximum size of read requests
+.TP
+\fB\-o\fR hard_remove
+immediate removal (don't hide files)
+.TP
+\fB\-o\fR use_ino
+let filesystem set inode numbers
+.TP
+\fB\-o\fR readdir_ino
+try to fill in d_ino in readdir
+.TP
+\fB\-o\fR direct_io
+use direct I/O
+.TP
+\fB\-o\fR kernel_cache
+cache files in kernel
+.TP
+\fB\-o\fR [no]auto_cache
+enable caching based on modification times
+.TP
+\fB\-o\fR umask=M
+set file permissions (octal)
+.TP
+\fB\-o\fR uid=N
+set file owner
+.TP
+\fB\-o\fR gid=N
+set file group
+.TP
+\fB\-o\fR entry_timeout=T
+cache timeout for names (1.0s)
+.TP
+\fB\-o\fR negative_timeout=T
+cache timeout for deleted names (0.0s)
+.TP
+\fB\-o\fR attr_timeout=T
+cache timeout for attributes (1.0s)
+.TP
+\fB\-o\fR ac_attr_timeout=T
+auto cache timeout for attributes (attr_timeout)
+.TP
+\fB\-o\fR intr
+allow requests to be interrupted
+.TP
+\fB\-o\fR intr_signal=NUM
+signal to send on interrupt (10)
+.TP
+\fB\-o\fR modules=M1[:M2...]
+names of modules to push onto filesystem stack
+.TP
+\fB\-o\fR max_write=N
+set maximum size of write requests
+.TP
+\fB\-o\fR max_readahead=N
+set maximum readahead
+.TP
+\fB\-o\fR async_read
+perform reads asynchronously (default)
+.TP
+\fB\-o\fR sync_read
+perform reads synchronously
+.SS "Module options:"
+.TP
+[subdir]
+.TP
+\fB\-o\fR subdir=DIR
+prepend this directory to all paths (mandatory)
+.TP
+\fB\-o\fR [no]rellinks
+transform absolute symlinks to relative
+.TP
+[iconv]
+.TP
+\fB\-o\fR from_code=CHARSET
+original encoding of file names (default: UTF-8)
+.TP
+\fB\-o\fR to_code=CHARSET
+new encoding of the file names (default: ISO-8859-2)
+.PD
+.SH "AUTHORS"
+.LP
+SSHFS has been written by Miklos Szeredi <miklos@szeredi.hu>.
+.LP
+This man page was written by Bartosz Fenski <fenio@debian.org> for the
+Debian GNU/Linux distribution (but it may be used by others).
+
+

sshnodelay.c

@@ -0,0 +1,18 @@
+#define _GNU_SOURCE
+#include <dlfcn.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <netinet/tcp.h>
+
+int connect(int sock, const struct sockaddr *addr, socklen_t addrlen)
+{
+	int (*next_connect)(int, const struct sockaddr *, socklen_t) =
+		dlsym(RTLD_NEXT, "connect");
+	int res = next_connect(sock, addr, addrlen);
+	if (!res && addr->sa_family == AF_INET) {
+		int opt = 1;
+		setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, &opt, sizeof(opt));
+	}
+	return res;
+}