Ticket #10191: 0001-Converted-UserlandFS-and-NetFS-to-hpkg-and-made-nece.patch

build/jam/HaikuPackages

@@ -6 +6 @@
     HaikuUserguide
     HaikuWelcome
     MakefileEngine
+    UserlandFS
+    NetFS
     ;
 
 if $(HAIKU_BUILD_TYPE) = bootstrap {

build/jam/OptionalPackages

@@ -184 +184 @@
 
 # NetFS network file system
 if [ IsOptionalHaikuImagePackageAdded NetFS ] {
-# TODO: Make this an actual package!
-#   # userlandfs module
-#   AddFilesToHaikuImage home config add-ons userlandfs
-#       : netfs ;
-#
-#   # servers
-#   AddFilesToHaikuImage system servers : netfs_server ;
-#   AddFilesToHaikuImage system servers
-#       : authentication_server ;
-#
-#   # tools
-#   AddFilesToHaikuImage system bin : netfs_config ;
-#   AddFilesToHaikuImage system bin : netfs_server_prefs ;
-#
-#   #example settings for netfs_server
-#   local netfsServerSettingsFiles = <driver-settings>netfs-server ;
-#   SEARCH on $(netfsServerSettingsFiles)
-#       = [ FDirName $(HAIKU_TOP) src add-ons kernel file_systems netfs ] ;
-#   AddFilesToHaikuImage home config settings kernel drivers
-#   : $(netfsServerSettingsFiles) ;
-#
-#   #userlandfs settings are needed for netfs_config to work (ioctls)
-#   local userlandfsServerSettingsFiles = <driver-settings>userlandfs ;
-#   SEARCH on $(userlandfsServerSettingsFiles)
-#       = [ FDirName $(HAIKU_TOP) src add-ons kernel file_systems userlandfs ] ;
-#   AddFilesToHaikuImage home config settings kernel drivers
-#       : $(userlandfsServerSettingsFiles) ;
+    AddPackageFilesToHaikuImage system : netfs.hpkg ;
 }
 
 
 # UserlandFS
 if [ IsOptionalHaikuImagePackageAdded UserlandFS ] {
-# TODO: Make this an actual package!
-#   local arch = $(TARGET_ARCH) ;
-#   local abi = gcc$(TARGET_GCC_VERSION_$(TARGET_PACKAGING_ARCH)[1]) ;
-#
-#   # kernel module
-#   AddFilesToHaikuImage system add-ons kernel file_systems
-#       : userlandfs ;
-#
-#   # server
-#   AddFilesToHaikuImage system servers : userlandfs_server ;
-#
-#   # libs
-#   local userlandfsLibs =
-#       libuserlandfs_beos_kernel.so
-#       libuserlandfs_haiku_kernel.so
-#       libuserlandfs_fuse.so
-#   ;
-#   AddFilesToHaikuImage system lib : $(userlandfsLibs) ;
-#
-#   # development goodies
-#   if [ IsOptionalHaikuImagePackageAdded DevelopmentMin ] {
-#       if ! ( $(TARGET_GCC_VERSION_$(TARGET_PACKAGING_ARCH)[1]) in 2 4 ) {
-#           Exit "Optional package UserlandFS: Unsupported GCC version:"
-#               $(TARGET_GCC_VERSION_$(TARGET_PACKAGING_ARCH)[1]) ;
-#       }
-#
-#       # library symlinks
-#       local lib ;
-#       for lib in $(userlandfsLibs) {
-#           AddSymlinkToHaikuImage develop abi $(arch) $(abi) lib
-#               : /system/lib/$(lib:BS) ;
-#       }
-#
-#       # FUSE headers
-#       local fuseHeaders =
-#           fuse_common_compat.h
-#           fuse_common.h
-#           fuse_compat.h
-#           fuse.h
-#           fuse_lowlevel_compat.h
-#           fuse_lowlevel.h
-#           fuse_opt.h
-#       ;
-#       fuseHeaders = $(fuseHeaders:G=userlandfs!fuse) ;
-#       SEARCH on $(fuseHeaders)
-#           = [ FDirName $(HAIKU_TOP) headers private userlandfs fuse ] ;
-#       AddFilesToHaikuImage develop headers userlandfs fuse : $(fuseHeaders) ;
-#   }
+    AddPackageFilesToHaikuImage system : userlandfs.hpkg ;
+
+    # development package
+    if [ IsOptionalHaikuImagePackageAdded DevelopmentMin ] {
+        if ! ( $(TARGET_GCC_VERSION_$(TARGET_PACKAGING_ARCH)[1]) in 2 4 ) {
+            Exit "Optional package UserlandFS: Unsupported GCC version:"
+                $(TARGET_GCC_VERSION_$(TARGET_PACKAGING_ARCH)[1]) ;
+        }
+
+        AddPackageFilesToHaikuImage system : userlandfs_devel.hpkg ;
+    }
 }
 
 

new file uild/jam/packages/NetFS

@@ +1 @@
+local netfsPackage = netfs.hpkg ;
+HaikuPackage $(netfsPackage) ;
+
+# userlandfs module
+AddFilesToPackage add-ons userlandfs : netfs ;
+
+# servers
+AddFilesToPackage servers : netfs_server ;
+AddFilesToPackage servers : authentication_server ;
+
+# tools
+AddFilesToPackage bin : netfs_config ;
+AddFilesToPackage bin : netfs_server_prefs ;
+AddFilesToPackage bin
+    : [ FDirName $(HAIKU_TOP) src add-ons kernel file_systems netfs netfs_mount ] ;
+
+# interface definition
+AddFilesToPackage data userlandfs file_systems
+    : [ FDirName $(HAIKU_TOP) src add-ons kernel file_systems netfs netfs-interface-definition ]
+    : netfs ;
+
+# docs
+AddFilesToPackage documentation add-ons :
+    [ FDirName $(HAIKU_TOP) docs add-ons NetFS.html ] : NetFS.html ;
+
+BuildHaikuPackage $(netfsPackage) : netfs ;

new file uild/jam/packages/UserlandFS

@@ +1 @@
+local arch = $(TARGET_ARCH) ;
+local abi = gcc$(TARGET_GCC_VERSION_$(TARGET_PACKAGING_ARCH)[1]) ;
+
+#
+# main package
+#
+
+local userlandfsPackage = userlandfs.hpkg ;
+HaikuPackage $(userlandfsPackage) ;
+
+# kernel module
+AddFilesToPackage add-ons kernel file_systems  : userlandfs ;
+
+# server
+AddFilesToPackage servers : userlandfs_server ;
+
+# libs
+local userlandfsLibs =
+    libuserlandfs_beos_kernel.so
+    libuserlandfs_haiku_kernel.so
+    libuserlandfs_fuse.so
+;
+AddFilesToPackage lib : $(userlandfsLibs) ;
+
+BuildHaikuPackage $(userlandfsPackage) : userlandfs ;
+
+#
+# development package
+#
+
+local userlandfsDevelPackage = userlandfs_devel.hpkg ;
+HaikuPackage $(userlandfsDevelPackage) ;
+
+# library symlinks
+local lib ;
+for lib in $(userlandfsLibs) {
+    AddSymlinkToPackage develop abi $(arch) $(abi) lib : /system/lib/$(lib:BS) ;
+}
+
+# FUSE headers
+local fuseHeaders =
+    fuse_common_compat.h
+    fuse_common.h
+    fuse_compat.h
+    fuse.h
+    fuse_lowlevel_compat.h
+    fuse_lowlevel.h
+    fuse_opt.h
+ ;
+fuseHeaders = $(fuseHeaders:G=userlandfs!fuse) ;
+SEARCH on $(fuseHeaders)
+    = [ FDirName $(HAIKU_TOP) headers private userlandfs fuse ] ;
+AddFilesToPackage develop headers userlandfs fuse : $(fuseHeaders) ;
+
+BuildHaikuPackage $(userlandfsDevelPackage) : userlandfs_devel ;

build/jam/repositories/Haiku

@@ -15 +15 @@
     haiku_userguide
     haiku_welcome
     makefile_engine
+    userlandfs
+    userlandfs_devel
+    netfs
 
     haiku_$(secondaryArchs)
     haiku_$(secondaryArchs)_devel

new file docs/add-ons/NetFS.html

@@ +1 @@
+<!--
+If you move this file, you must update the package rules file at
+build/jam/packages/NetFS to reflect the new location. Otherwise the package will
+not build.
+-->
+<html>
+<head>
+<title>NetFS</title>
+<style>
+.code {
+    font-family: monospace;
+    background: #eee;
+    border: 1px solid black;
+    whitespace: pre;
+    padding: 1em;
+}
+span.code {
+    padding: 0;
+    border: 0;
+}
+</style>
+</head>
+<body>
+
+<h1 align="center">NetFS</h1>
+
+<hr />
+
+<h2 align="center">Client</h2>
+
+<p>To run the client, execute the following at the command line:</p>
+
+<pre class="code">
+$ netfs_mount
+</pre>
+
+<p>A "Network" icon will appear on your desktop, containing remote servers
+identified by host name. Inside the folder for each server are the shares on
+that server.</p>
+
+<p>You can also run the steps individually:</p>
+
+<pre class="code">
+$ /system/servers/authentication_server &
+$ mkdir /network
+$ mount -t userlandfs -p "netfs" /network
+</pre>
+
+<hr />
+
+<h2 align="center">Server</h2>
+
+<p>To run the server:</p>
+
+<pre class="code">
+$ netfs_server_prefs launch
+</pre>
+
+<p>You can also start the server directly if you prefer.</p>
+
+<pre class="code">
+$ /system/servers/netfs_server &
+</pre>
+
+<p>The server will then run until you shut down your computer, but it is also
+possible to stop it manually.</p>
+
+<pre class="code">
+$ netfs_server_prefs terminate
+</pre>
+
+<p>Once the server is running, you can define shared folders. The first step is
+to create a user who can access those folders, optionally with a password.</p>
+
+<pre class="code">
+$ netfs_server_prefs add user &lt;name&gt; [&lt;password&gt;]
+</pre>
+
+<p>Next create a shared folder and assign a user some permissions on it.</p>
+
+<pre class="code">
+$ netfs_server_prefs add share &lt;name&gt; &lt;path&gt;
+$ netfs_server_prefs permissions &lt;user&gt; &lt;share&gt; <flags>
+</pre>
+
+<p><span class="code">name</span> is the name that will appear to clients when
+they connect to your server.  <span class="code">flags</span> is one or more of:
+<span class="code">m</span> = mount, <span class="code">r</span> = read, <span
+class="code">w</span> = write, <span class="code">q</span> = query.</p>
+
+<p>Don't forget to save your settings.</p>
+
+<pre class="code">
+$ netfs_server_prefs save
+</pre>
+
+<p>The <span class="code">netfs_server_prefs</span> tool can also list and
+remove users and shares. See the help for details.</p>
+
+<pre class="code">
+$ netfs_server_prefs --help
+</pre>
+
+<hr />
+
+<h2 align="center">Fallback Settings File</h2>
+
+<p>The settings file is stored in a binary format, but if it is missing or
+damaged, the server will use a fallback settings file, which has a text-based
+format. This file must be located at <span
+class="code">/boot/home/config/settings/netfs/netfs_server_fallback</span>. (If
+neither the main settings file nor the fallback settings file can be loaded, the
+server will have no users or shares defined.)
+
+<p>Here is an example of a fallback settings file.</p>
+
+<pre class="code">
+# users
+user bonefish {
+    password    password
+}
+
+# user without a password
+user anonymous
+
+# shares
+share ttttt {
+    path /boot/home/Desktop/ttttt
+    user bonefish {
+        permissions mount query read write
+    }
+}
+
+share sub-ttttt {
+    path /boot/home/Desktop/ttttt/rmessage
+    user bonefish {
+        permissions mount query read write
+    }
+    user anonymous {
+        permissions mount query read
+    }
+}
+</pre>
+
+</body>

src/add-ons/kernel/file_systems/netfs/client/ServerManager.cpp

@@ -138 +138 @@
     ServerManager*      fServerManager;
     ExtendedServerInfo* fOldServerInfo;
     ExtendedServerInfo* fServerInfo;
-    vint32              fFD;
+    int32               fFD;
     bool                fUpdate;
     bool                fSuccess;
 };

src/add-ons/kernel/file_systems/netfs/client/ServerManager.h

@@ -48 +48 @@
             Locker              fLock;
             ServerInfoMap*      fServerInfos;
             thread_id           fBroadcastListener;
-            vint32              fBroadcastListenerSocket;
+            int32               fBroadcastListenerSocket;
             Listener*           fListener;
             volatile bool       fTerminating;
 };

src/add-ons/kernel/file_systems/netfs/headers/shared/InsecureChannel.h

@@ -20 +20 @@
             status_t            GetPeerAddress(NetAddress *address) const;
 
 private:
-            vint32              fSocket;
+            int32               fSocket;
             bool                fClosed;
 };
 

src/add-ons/kernel/file_systems/netfs/headers/shared/NetAddress.h

@@ -66 +66 @@
             Resolver*           fResolver;
 
     static  Resolver* volatile  sResolver;
-    static  vint32              sLockCounter;
+    static  int32               sLockCounter;
 };
 
 #endif  // NET_FS_NET_ADDRESS_H

src/add-ons/kernel/file_systems/netfs/headers/shared/RequestConnection.h

@@ -41 +41 @@
             bool                fOwnsRequestHandler;
             DownStreamThread*   fThreads;
             int32               fThreadCount;
-            vint32              fTerminationCount;
+            int32               fTerminationCount;
 };
 
 #endif  // NET_FS_REQUEST_CONNECTION_H

src/add-ons/kernel/file_systems/netfs/headers/shared/Utils.h

@@ -24 +24 @@
 */
 static inline
 void
-safe_closesocket(vint32& socketVar)
+safe_closesocket(int32& socketVar)
 {
     int32 socket = atomic_or(&socketVar, -1);
 #ifdef __HAIKU__

new file src/add-ons/kernel/file_systems/netfs/netfs-interface-definition

@@ +1 @@
+# NetFS interface definition for UserlandFS
+#
+# Lives in PACKAGE/data/userlandfs/file_systems
+
+file_system netfs {
+    # NET_FS_IOCTL_ADD_SERVER
+    ioctl 11000 {
+        buffer_size         256
+        write_buffer_size   0
+        is_buffer           true
+    }
+
+    # NET_FS_IOCTL_REMOVE_SERVER
+    ioctl 11001 {
+        buffer_size         256
+        write_buffer_size   0
+        is_buffer           true
+    }
+}

new file src/add-ons/kernel/file_systems/netfs/netfs_mount

@@ +1 @@
+/system/servers/authentication_server &
+mkdir /network
+mount -t userlandfs -p "netfs" /network

src/add-ons/kernel/file_systems/netfs/server/ClientConnection.h

@@ -193 +193 @@
             thread_id           fNodeMonitoringProcessor;
             Locker              fLock;
             int32               fReferenceCount;
-            vint32              fInitialized;
+            int32               fInitialized;
             bool                fClosed;
             bool                fError;
             bool                fInverseClientEndianess;

src/add-ons/kernel/file_systems/netfs/server/ClientVolume.cpp

@@ -520 +520 @@
 }
 
 // sNextVolumeID
-vint32 ClientVolume::sNextVolumeID = 0;
+int32 ClientVolume::sNextVolumeID = 0;
 
 
 // #pragma -

src/add-ons/kernel/file_systems/netfs/server/ClientVolume.h

@@ -109 +109 @@
             Permissions         fSharePermissions;
             bool                fMounted;
 
-    static  vint32              sNextVolumeID;
+    static  int32               sNextVolumeID;
 };
 
 // NodeMonitoringProcessor

src/add-ons/kernel/file_systems/netfs/server/InsecureConnectionListener.h

@@ -27 +27 @@
                                     User** user);
 
 private:
-            vint32              fSocket;
+            int32               fSocket;
 };
 
 #endif  // NET_FS_INSECURE_CONNECTION_LISTENER_H

src/add-ons/kernel/file_systems/netfs/server/NetFSServer.cpp

@@ -40 +40 @@
 #include "Utils.h"
 #include "VolumeManager.h"
 
-static const char* kSettingsDirName     = "netfs";
-static const char* kSettingsFileName    = "netfs_server";
+static const char* kSettingsDirName             = "netfs";
+static const char* kSettingsFileName            = "netfs_server";
+static const char* kFallbackSettingsFileName    = "netfs_server_fallback";
 
 // usage
 static const char* kUsage =
@@ -796 +797 @@
     }
     ObjectDeleter<SecurityContext> securityContextDeleter(securityContext);
 
-    // load from driver settings for the time being
+    // load the fallback settings, if present
+    BPath path;
     DriverSettings settings;
-    error = settings.Load("netfs-server");
-    if (error != B_OK)
-        return error;
-
-    // load users
-    DriverParameter parameter;
-    for (DriverParameterIterator it = settings.GetParameterIterator("user");
-         it.GetNext(&parameter);) {
-        const char* userName = parameter.ValueAt(0);
-        const char* password = parameter.GetParameterValue("password");
-        if (!userName) {
-            WARN("Skipping nameless user settings entry.\n");
-            continue;
-        }
-//      PRINT(("user: %s, password: %s\n", parameter.ValueAt(0),
-//          parameter.GetParameterValue("password")));
-        error = securityContext->AddUser(userName, password);
-        if (error != B_OK)
-            ERROR("ERROR: Failed to add user `%s'\n", userName);
-    }
-
-    // load shares
-    for (DriverParameterIterator it = settings.GetParameterIterator("share");
-         it.GetNext(&parameter);) {
-        const char* shareName = parameter.ValueAt(0);
-        const char* path = parameter.GetParameterValue("path");
-        if (!shareName || !path) {
-            WARN("settings: Skipping invalid share settings entry (no name"
-                " or no path).\n");
-            continue;
-        }
-//      PRINT(("share: %s, path: %s\n", parameter.ValueAt(0),
-//          parameter.GetParameterValue("path")));
-        Share* share;
-        error = securityContext->AddShare(shareName, path, &share);
-        if (error != B_OK) {
-            ERROR("ERROR: Failed to add share `%s'\n", shareName);
-            continue;
+    if (_GetSettingsDirPath(&path, false) == B_OK
+            && path.Append(kFallbackSettingsFileName) == B_OK
+            && settings.Load(path.Path()) == B_OK) {
+        // load users
+        DriverParameter parameter;
+        for (DriverParameterIterator it = settings.GetParameterIterator("user");
+             it.GetNext(&parameter);) {
+            const char* userName = parameter.ValueAt(0);
+            const char* password = parameter.GetParameterValue("password");
+            if (!userName) {
+                WARN("Skipping nameless user settings entry.\n");
+                continue;
+            }
+//          PRINT(("user: %s, password: %s\n", parameter.ValueAt(0),
+//              parameter.GetParameterValue("password")));
+            error = securityContext->AddUser(userName, password);
+            if (error != B_OK)
+                ERROR("ERROR: Failed to add user `%s'\n", userName);
         }
-        BReference<Share> shareReference(share, true);
-        DriverParameter userParameter;
-        // iterate through the share users
-        for (DriverParameterIterator userIt
-                = parameter.GetParameterIterator("user");
-             userIt.GetNext(&userParameter);) {
-            const char* userName = userParameter.ValueAt(0);
-//          PRINT(("  user: %s\n", userName));
-            User* user = securityContext->FindUser(userName);
-            if (!user) {
-                ERROR("ERROR: Undefined user `%s'.\n", userName);
+    
+        // load shares
+        for (DriverParameterIterator it = settings.GetParameterIterator("share");
+             it.GetNext(&parameter);) {
+            const char* shareName = parameter.ValueAt(0);
+            const char* path = parameter.GetParameterValue("path");
+            if (!shareName || !path) {
+                WARN("settings: Skipping invalid share settings entry (no name"
+                    " or no path).\n");
                 continue;
             }
-            BReference<User> userReference(user, true);
-            DriverParameter permissionsParameter;
-            if (!userParameter.FindParameter("permissions",
-                    &permissionsParameter)) {
+//          PRINT(("share: %s, path: %s\n", parameter.ValueAt(0),
+//              parameter.GetParameterValue("path")));
+            Share* share;
+            error = securityContext->AddShare(shareName, path, &share);
+            if (error != B_OK) {
+                ERROR("ERROR: Failed to add share `%s'\n", shareName);
                 continue;
             }
-            Permissions permissions;
-            for (int32 i = 0; i < permissionsParameter.CountValues(); i++) {
-                const char* permission = permissionsParameter.ValueAt(i);
-//              PRINT(("    permission: %s\n", permission));
-                if (strcmp(permission, "mount") == 0) {
-                    permissions.AddPermissions(MOUNT_SHARE_PERMISSION);
-                } else if (strcmp(permission, "query") == 0) {
-                    permissions.AddPermissions(QUERY_SHARE_PERMISSION);
-                } else if (strcmp(permission, "read") == 0) {
-                    permissions.AddPermissions(READ_PERMISSION
-                        | READ_DIR_PERMISSION | RESOLVE_DIR_ENTRY_PERMISSION);
-                } else if (strcmp(permission, "write") == 0) {
-                    permissions.AddPermissions(WRITE_PERMISSION
-                        | WRITE_DIR_PERMISSION);
-                } else if (strcmp(permission, "all") == 0) {
-                    permissions.AddPermissions(ALL_PERMISSIONS);
+            BReference<Share> shareReference(share, true);
+            DriverParameter userParameter;
+            // iterate through the share users
+            for (DriverParameterIterator userIt
+                    = parameter.GetParameterIterator("user");
+                 userIt.GetNext(&userParameter);) {
+                const char* userName = userParameter.ValueAt(0);
+//              PRINT(("  user: %s\n", userName));
+                User* user = securityContext->FindUser(userName);
+                if (!user) {
+                    ERROR("ERROR: Undefined user `%s'.\n", userName);
+                    continue;
+                }
+                BReference<User> userReference(user, true);
+                DriverParameter permissionsParameter;
+                if (!userParameter.FindParameter("permissions",
+                        &permissionsParameter)) {
+                    continue;
+                }
+                Permissions permissions;
+                for (int32 i = 0; i < permissionsParameter.CountValues(); i++) {
+                    const char* permission = permissionsParameter.ValueAt(i);
+//                  PRINT(("    permission: %s\n", permission));
+                    if (strcmp(permission, "mount") == 0) {
+                        permissions.AddPermissions(MOUNT_SHARE_PERMISSION);
+                    } else if (strcmp(permission, "query") == 0) {
+                        permissions.AddPermissions(QUERY_SHARE_PERMISSION);
+                    } else if (strcmp(permission, "read") == 0) {
+                        permissions.AddPermissions(READ_PERMISSION
+                            | READ_DIR_PERMISSION | RESOLVE_DIR_ENTRY_PERMISSION);
+                    } else if (strcmp(permission, "write") == 0) {
+                        permissions.AddPermissions(WRITE_PERMISSION
+                            | WRITE_DIR_PERMISSION);
+                    } else if (strcmp(permission, "all") == 0) {
+                        permissions.AddPermissions(ALL_PERMISSIONS);
+                    }
+                }
+                error = securityContext->SetNodePermissions(share->GetPath(), user,
+                    permissions);
+                if (error != B_OK) {
+                    ERROR("ERROR: Failed to set permissions for share `%s'\n",
+                        share->GetName());
                 }
-            }
-            error = securityContext->SetNodePermissions(share->GetPath(), user,
-                permissions);
-            if (error != B_OK) {
-                ERROR("ERROR: Failed to set permissions for share `%s'\n",
-                    share->GetName());
             }
         }
     }
@@ -929 +931 @@
 
     // if existing load the settings
     BEntry bEntry;
-    if (FDManager::SetEntry(&bEntry, filePath.Path()) == B_OK
-        && bEntry.Exists()) {
+    if (FDManager::SetEntry(&bEntry, filePath.Path()) != B_OK
+        || !bEntry.Exists()) {
         return B_ENTRY_NOT_FOUND;
     }
 

src/add-ons/kernel/file_systems/netfs/server/NetFSServer.h

@@ -87 +87 @@
             thread_id           fConnectionListenerThread;
             thread_id           fConnectionDeleter;
             thread_id           fBroadcaster;
-            vint32              fBroadcastingSocket;
+            int32               fBroadcastingSocket;
             sem_id              fBroadcasterSemaphore;
             thread_id           fServerInfoConnectionListener;
-            vint32              fServerInfoConnectionListenerSocket;
-            vint32              fServerInfoUpdated;
+            int32               fServerInfoConnectionListenerSocket;
+            int32               fServerInfoUpdated;
             bool                fUseBroadcasting;
             volatile bool       fTerminating;
 };

src/add-ons/kernel/file_systems/netfs/shared/NetAddress.cpp

@@ -301 +301 @@
 NetAddressResolver::Resolver* volatile NetAddressResolver::sResolver = NULL;
 
 // sLockCounter
-vint32 NetAddressResolver::sLockCounter = 0;
+int32 NetAddressResolver::sLockCounter = 0;

src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/Settings.cpp

@@ -4 +4 @@
 
 #include <stdlib.h>
 
+#include <FindDirectory.h>
 #include <driver_settings.h>
 
 #include "Debug.h"
@@ -13 +14 @@
 
 using std::nothrow;
 
-static const char *kFSName = "userlandfs";
+#include <stdio.h>
+// since only one instance of each fs wil be installed
+// (under ordinary conditions, anyway)
+// it probably doesn't matter what order we search in
+static const directory_which kDirectories[] = {
+    B_USER_NONPACKAGED_DATA_DIRECTORY,
+    B_USER_DATA_DIRECTORY,
+    B_SYSTEM_NONPACKAGED_DATA_DIRECTORY,
+    B_SYSTEM_DATA_DIRECTORY
+};
+static const char *kFSSubpath = "/userlandfs/file_systems/";
 
 // IOCtlInfoMap
 struct Settings::IOCtlInfoMap : public HashMap<HashKey32<int>, IOCtlInfo*> {
@@ -163 +174 @@
     fIOCtlInfos = new(nothrow) IOCtlInfoMap;
     if (!fIOCtlInfos)
         RETURN_ERROR(B_NO_MEMORY);
-    // load the driver settings and find the entry for the FS
-    void *settings = load_driver_settings(kFSName);
-    const driver_parameter *fsParameter = NULL;
-    const driver_settings *ds = get_driver_settings(settings);
-    if (!ds)
-        RETURN_ERROR(B_ENTRY_NOT_FOUND);
-    fsParameter = _FindFSParameter(ds, fsName);
-    // init the object and unload the settings
-    status_t error = B_OK;
-    if (fsParameter)
-        _Init(ds, fsParameter);
-    else
-        error = B_ENTRY_NOT_FOUND;
-    unload_driver_settings(settings);
-    return B_OK;
+    
+    // load the driver settings for the FS
+    char path[B_PATH_NAME_LENGTH];
+    for (size_t i = 0; i < sizeof(kDirectories) / sizeof(kDirectories[0]);
+            i++) {
+        if (find_directory(kDirectories[i], -1, false, (char*)&path,
+                B_PATH_NAME_LENGTH) != B_OK) {
+            continue;
+        }
+        
+        // construct the path within the directory
+        strcpy((char*)&path + strlen((char*)&path), kFSSubpath);
+        strcpy((char*)&path + strlen((char*)&path), fsName);
+
+        // load the file at the constructed path
+        void *settings = load_driver_settings((char*)&path);
+        if (!settings)
+            continue;
+        
+        // get the settings from the loaded file
+        const driver_settings *ds = get_driver_settings(settings);
+        if (!ds) {
+            unload_driver_settings(settings);
+            continue;
+        }
+        
+        // get the parameter from the settings
+        const driver_parameter *fsParameter = NULL;
+        fsParameter = _FindFSParameter(ds, fsName);
+        
+        //  init the object and unload the settings
+        if (fsParameter)
+            _Init(ds, fsParameter);
+        unload_driver_settings(settings);
+        
+        // if we found the parameter, we're done
+        if (fsParameter)
+            return B_OK;
+    }
+
+    // if we get here, we did not find the parameter
+    return B_ENTRY_NOT_FOUND;
 }
 
 // Unset

new file src/data/package_infos/generic/netfs

@@ +1 @@
+name            netfs
+version         %HAIKU_VERSION%
+architecture    %HAIKU_PACKAGING_ARCH%
+summary         "NetFS"
+
+description     "The package contains the NetFS add-on and servers."
+
+packager        "The Haiku build system"
+vendor          "Haiku Project"
+
+copyrights      "2001-2014 Haiku, Inc. et al"
+licenses        "MIT"
+
+provides {
+    netfs = %HAIKU_VERSION% compat >= R1~alpha1
+}
+
+requires {
+    userlandfs
+}

new file src/data/package_infos/generic/userlandfs

@@ +1 @@
+name            userlandfs
+version         %HAIKU_VERSION%
+architecture    %HAIKU_PACKAGING_ARCH%
+summary         "UserlandFS"
+
+description     "The package contains the UserlandFS add-on and server."
+
+packager        "The Haiku build system"
+vendor          "Haiku Project"
+
+copyrights      "2001-2014 Haiku, Inc. et al"
+licenses        "MIT"
+
+provides {
+    userlandfs = %HAIKU_VERSION% compat >= R1~alpha1
+}

new file src/data/package_infos/generic/userlandfs_devel

@@ +1 @@
+name            userlandfs_devel
+version         %HAIKU_VERSION%
+architecture    %HAIKU_PACKAGING_ARCH%
+summary         "UserlandFS development files"
+
+description     "The package contains all files associated with UserlandFS
+needed for development, like static libraries, library symlinks,
+header files, etc."
+
+packager        "The Haiku build system"
+vendor          "Haiku Project"
+
+copyrights      "2001-2014 Haiku, Inc. et al"
+licenses        "MIT"
+
+provides {
+    userlandfs_devel = %HAIKU_VERSION% compat >= R1~alpha1
+}
+
+requires {
+    userlandfs == %HAIKU_VERSION% base
+    haiku_devel
+}