LCOV - code coverage report
Current view: top level - source3/modules - vfs_media_harmony.c (source / functions) Hit Total Coverage
Test: coverage report for abartlet/fix-coverage dd10fb34 Lines: 8 664 1.2 %
Date: 2021-09-23 10:06:22 Functions: 1 34 2.9 %

          Line data    Source code
       1             : /*
       2             :  * $Id: media_harmony.c,v 1.1 2007/11/06 10:07:22 stuart_hc Exp $
       3             :  *
       4             :  * Samba VFS module supporting multiple AVID clients sharing media.
       5             :  *
       6             :  * Copyright (C) 2005  Philip de Nier <philipn@users.sourceforge.net>
       7             :  * Copyright (C) 2012  Andrew Klaassen <clawsoon@yahoo.com>
       8             :  *
       9             :  * This program is free software; you can redistribute it and/or
      10             :  * modify it under the terms of the GNU General Public License
      11             :  * as published by the Free Software Foundation; either version 2
      12             :  * of the License, or (at your option) any later version.
      13             :  *
      14             :  * This program is distributed in the hope that it will be useful,
      15             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      16             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      17             :  * GNU General Public License for more details.
      18             :  *
      19             :  * You should have received a copy of the GNU General Public License
      20             :  * along with this program; if not, write to the Free Software
      21             :  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
      22             :  * 02110-1301, USA.
      23             :  */
      24             : 
      25             : 
      26             : /*
      27             :  * Media Harmony is a Samba VFS module that allows multiple AVID
      28             :  * clients to share media. Each client sees their own copy of the
      29             :  * AVID msmMMOB.mdb and msmFMID.pmr files and Creating directories.
      30             :  *
      31             :  * Add this module to the vfs objects option in your Samba share
      32             :  * configuration.
      33             :  * eg.
      34             :  *
      35             :  *   [avid_win]
      36             :  *      path = /video
      37             :  *      vfs objects = media_harmony
      38             :  *      ...
      39             :  *
      40             :  * It is recommended that you separate out Samba shares for Mac
      41             :  * and Windows clients, and add the following options to the shares
      42             :  * for Windows clients  (NOTE: replace @ with *):
      43             :  *
      44             :  *      veto files = /.DS_Store/._@/.Trash@/.Spotlight@/.hidden/.hotfiles@/.vol/
      45             :  *      delete veto files = yes
      46             :  *
      47             :  * This prevents hidden files from Mac clients interfering with Windows
      48             :  * clients. If you find any more problem hidden files then add them to
      49             :  * the list.
      50             :  *
      51             :  *
      52             :  * Andrew Klaassen, 2012-03-14
      53             :  * To prevent Avid clients from interrupting each other (via Avid's habit
      54             :  * of launching a database refresh whenever it notices an mtime update
      55             :  * on media directories, i.e. whenever one editor adds new material to a
      56             :  * shared share), I've added code that causes stat information for anything
      57             :  * directly under "Avid MediaFile/MXF" to be taken from
      58             :  * dirname_clientaddr_clientuser if it exists.  These files ~aren't~
      59             :  * hidden, unlike the client-suffixed database files.
      60             :  *
      61             :  * For example, stat information for
      62             :  *      Avid MediaFiles/MXF/1
      63             :  * will come from
      64             :  *      Avid MediaFiles/MXF/1_192.168.1.10_dave
      65             :  * for dave working on 192.168.1.10, but will come from
      66             :  *      Avid MediaFile/MXF/1_192.168.1.11_susan
      67             :  * for susan working on 192.168.1.11.  If those alternate
      68             :  * directories don't exist, the user will get the actual directory's stat
      69             :  * info.  When an editor wants to force a database refresh, they update
      70             :  * the mtime on "their" file.  This will cause Avid
      71             :  * on that client to see an updated mtime for "Avid MediaFiles/MXF/1",
      72             :  * which will trigger an Avid database refresh just for that editor.
      73             :  *
      74             :  *
      75             :  * Notes:
      76             :  * - This module is designed to work with AVID editing applications that
      77             :  * look in the Avid MediaFiles or OMFI MediaFiles directory for media.
      78             :  * It is not designed to work as expected in all circumstances for
      79             :  * general use. For example: it is possibly to open client specific
      80             :  * files such as msmMMOB.mdb_192.168.1.10_userx even though is doesn't
      81             :  * show up in a directory listing.
      82             :  *
      83             :  */
      84             : 
      85             : 
      86             : #include "includes.h"
      87             : #include "system/filesys.h"
      88             : #include "smbd/smbd.h"
      89             : #include "../smbd/globals.h"
      90             : #include "auth.h"
      91             : #include "../lib/tsocket/tsocket.h"
      92             : 
      93             : #define MH_INFO_DEBUG 10
      94             : #define MH_ERR_DEBUG 0
      95             : 
      96             : static const char* MDB_FILENAME = "msmMMOB.mdb";
      97             : static const size_t MDB_FILENAME_LEN = 11;
      98             : static const char* PMR_FILENAME = "msmFMID.pmr";
      99             : static const size_t PMR_FILENAME_LEN = 11;
     100             : static const char* CREATING_DIRNAME = "Creating";
     101             : static const size_t CREATING_DIRNAME_LEN = 8;
     102             : static const char* AVID_MEDIAFILES_DIRNAME = "Avid MediaFiles";
     103             : static const size_t AVID_MEDIAFILES_DIRNAME_LEN = 15;
     104             : static const char* OMFI_MEDIAFILES_DIRNAME = "OMFI MediaFiles";
     105             : static const size_t OMFI_MEDIAFILES_DIRNAME_LEN = 15;
     106             : static const char* APPLE_DOUBLE_PREFIX = "._";
     107             : static const size_t APPLE_DOUBLE_PREFIX_LEN = 2;
     108             : static const char* AVID_MXF_DIRNAME = "Avid MediaFiles/MXF";
     109             : static const size_t AVID_MXF_DIRNAME_LEN = 19;
     110             : 
     111             : static int vfs_mh_debug_level = DBGC_VFS;
     112             : 
     113             : /* supplements the directory list stream */
     114             : typedef struct mh_dirinfo_struct
     115             : {
     116             :         DIR* dirstream;
     117             :         char *dirpath;
     118             :         char *clientPath;
     119             :         bool isInMediaFiles;
     120             :         char *clientMDBFilename;
     121             :         char *clientPMRFilename;
     122             :         char *clientCreatingDirname;
     123             : } mh_dirinfo_struct;
     124             : 
     125             : 
     126             : /* Add "_<ip address>_<user name>" suffix to path or filename.
     127             :  *
     128             :  * Success: return 0
     129             :  * Failure: set errno, path NULL, return -1
     130             :  */
     131           0 : static int alloc_append_client_suffix(vfs_handle_struct *handle,
     132             :                 char **path)
     133             : {
     134           0 :         int status = 0;
     135           0 :         char *raddr = NULL;
     136             : 
     137           0 :         DEBUG(MH_INFO_DEBUG, ("Entering with *path '%s'\n", *path));
     138             : 
     139           0 :         raddr = tsocket_address_inet_addr_string(
     140           0 :                         handle->conn->sconn->remote_address, talloc_tos());
     141           0 :         if (raddr == NULL)
     142             :         {
     143           0 :                 errno = ENOMEM;
     144           0 :                 status = -1;
     145           0 :                 goto err;
     146             :         }
     147             : 
     148             :         /* talloc_asprintf_append uses talloc_realloc, which
     149             :          * frees original 'path' memory so we don't have to.
     150             :          */
     151           0 :         *path = talloc_asprintf_append(*path, "_%s_%s",
     152             :                 raddr,
     153           0 :                 handle->conn->session_info->unix_info->sanitized_username);
     154           0 :         if (*path == NULL)
     155             :         {
     156           0 :                 DEBUG(MH_ERR_DEBUG, ("alloc_append_client_suffix "
     157             :                                         "out of memory\n"));
     158           0 :                 errno = ENOMEM;
     159           0 :                 status = -1;
     160           0 :                 goto err;
     161             :         }
     162           0 :         DEBUG(MH_INFO_DEBUG, ("Leaving with *path '%s'\n", *path));
     163           0 : err:
     164           0 :         TALLOC_FREE(raddr);
     165           0 :         return status;
     166             : }
     167             : 
     168             : 
     169             : /* Returns True if the file or directory begins with the appledouble
     170             :  * prefix.
     171             :  */
     172           0 : static bool is_apple_double(const char* fname)
     173             : {
     174           0 :         bool ret = False;
     175             : 
     176           0 :         DEBUG(MH_INFO_DEBUG, ("Entering with fname '%s'\n", fname));
     177             : 
     178           0 :         if (strncmp(APPLE_DOUBLE_PREFIX, fname, APPLE_DOUBLE_PREFIX_LEN)
     179             :                         == 0)
     180             :         {
     181           0 :                 ret = True;
     182             :         }
     183           0 :         DEBUG(MH_INFO_DEBUG, ("Leaving with ret '%s'\n",
     184             :                                 ret == True ? "True" : "False"));
     185           0 :         return ret;
     186             : }
     187             : 
     188           0 : static bool starts_with_media_dir(const char* media_dirname,
     189             :                 size_t media_dirname_len, const char* path)
     190             : {
     191           0 :         bool ret = False;
     192             :         const char *path_start;
     193             : 
     194           0 :         DEBUG(MH_INFO_DEBUG, ("Entering with media_dirname '%s' "
     195             :                               "path '%s'\n", media_dirname, path));
     196             : 
     197             :         /* Sometimes Samba gives us "./OMFI MediaFiles". */
     198           0 :         if (strncmp(path, "./", 2) == 0)
     199             :         {
     200           0 :                 path_start = &path[2];
     201             :         }
     202             :         else {
     203           0 :                 path_start = path;
     204             :         }
     205             : 
     206           0 :         if (strncmp(media_dirname, path_start, media_dirname_len) == 0
     207           0 :                         &&
     208             :                 (
     209           0 :                         path_start[media_dirname_len] == '\0'
     210           0 :                         ||
     211           0 :                         path_start[media_dirname_len] == '/'
     212             :                 )
     213             :         )
     214             :         {
     215           0 :                 ret = True;
     216             :         }
     217             : 
     218           0 :         DEBUG(MH_INFO_DEBUG, ("Leaving with ret '%s'\n",
     219             :                                 ret == True ? "True" : "False"));
     220           0 :         return ret;
     221             : }
     222             : 
     223             : /*
     224             :  * Returns True if the file or directory referenced by the path is below
     225             :  * the AVID_MEDIAFILES_DIRNAME or OMFI_MEDIAFILES_DIRNAME directory
     226             :  * The AVID_MEDIAFILES_DIRNAME and OMFI_MEDIAFILES_DIRNAME are assumed to
     227             :  * be in the root directory, which is generally a safe assumption
     228             :  * in the fixed-path world of Avid.
     229             :  */
     230           0 : static bool is_in_media_files(const char* path)
     231             : {
     232           0 :         bool ret = False;
     233             : 
     234           0 :         DEBUG(MH_INFO_DEBUG, ("Entering with path '%s'\n", path));
     235             : 
     236           0 :         if (
     237           0 :                 starts_with_media_dir(AVID_MEDIAFILES_DIRNAME,
     238             :                                 AVID_MEDIAFILES_DIRNAME_LEN, path)
     239           0 :                 ||
     240           0 :                 starts_with_media_dir(OMFI_MEDIAFILES_DIRNAME,
     241             :                                 OMFI_MEDIAFILES_DIRNAME_LEN, path)
     242             :         )
     243             :         {
     244           0 :                 ret = True;
     245             :         }
     246           0 :         DEBUG(MH_INFO_DEBUG, ("Leaving with ret '%s'\n",
     247             :                                 ret == True ? "True" : "False"));
     248           0 :         return ret;
     249             : }
     250             : 
     251             : /*
     252             :  * Returns depth of path under media directory.  Deals with the
     253             :  * occasional ..../. and ..../.. paths that get passed to stat.
     254             :  *
     255             :  * Assumes is_in_media_files has already been called and has returned
     256             :  * true for the path; if it hasn't, this function will likely crash
     257             :  * and burn.
     258             :  *
     259             :  * Not foolproof; something like "Avid MediaFiles/MXF/../foo/1"
     260             :  * would fool it.  Haven't seen paths like that getting to the
     261             :  * stat function yet, so ignoring that possibility for now.
     262             :  */
     263           0 : static int depth_from_media_dir(const char* media_dirname,
     264             :                 size_t media_dirname_len, const char* path)
     265             : {
     266           0 :         int transition_count = 0;
     267             :         const char *path_start;
     268             :         const char *pathPtr;
     269             : 
     270           0 :         DEBUG(MH_INFO_DEBUG, ("Entering with media_dirname '%s' "
     271             :                               "path '%s'\n", media_dirname, path));
     272             : 
     273             :         /* Sometimes Samba gives us "./OMFI MediaFiles". */
     274           0 :         if (strncmp(path, "./", 2) == 0)
     275             :         {
     276           0 :                 path_start = &path[2];
     277             :         }
     278             :         else {
     279           0 :                 path_start = path;
     280             :         }
     281             : 
     282           0 :         if (path_start[media_dirname_len] == '\0')
     283             :         {
     284           0 :                 goto out;
     285             :         }
     286             : 
     287           0 :         pathPtr = &path_start[media_dirname_len + 1];
     288             : 
     289             :         while(1)
     290             :         {
     291           0 :                 if (*pathPtr == '\0' || *pathPtr == '/')
     292             :                 {
     293           0 :                         if (
     294           0 :                                 *(pathPtr - 1) == '.'
     295           0 :                                         &&
     296           0 :                                 *(pathPtr - 2) == '.'
     297           0 :                                         &&
     298           0 :                                 *(pathPtr - 3) == '/'
     299             :                         )
     300             :                         {
     301           0 :                                 transition_count--;
     302             :                         }
     303           0 :                         else if (
     304           0 :                                 !
     305             :                                 (
     306           0 :                                         *(pathPtr - 1) == '/'
     307             :                                         ||
     308             :                                         (
     309           0 :                                                 *(pathPtr - 1) == '.'
     310           0 :                                                         &&
     311           0 :                                                 *(pathPtr - 2) == '/'
     312             :                                         )
     313             :                                 )
     314             :                         )
     315             :                         {
     316           0 :                                 transition_count++;
     317             :                         }
     318             :                 }
     319           0 :                 if (*pathPtr == '\0')
     320             :                 {
     321           0 :                         break;
     322             :                 }
     323           0 :                 pathPtr++;
     324             :         }
     325             : 
     326           0 :         DEBUG(MH_INFO_DEBUG, ("Leaving with transition_count '%i'\n",
     327             :                                 transition_count));
     328           0 : out:
     329           0 :         return transition_count;
     330             : }
     331             : 
     332             : /* Identifies MDB and PMR files at end of path. */
     333           0 : static bool is_avid_database(
     334             :                 char *path,
     335             :                 size_t path_len,
     336             :                 const char *avid_db_filename,
     337             :                 const size_t avid_db_filename_len)
     338             : {
     339           0 :         bool ret = False;
     340             : 
     341           0 :         DEBUG(MH_INFO_DEBUG, ("Entering with path '%s', "
     342             :                               "avid_db_filename '%s', "
     343             :                               "path_len '%i', "
     344             :                               "avid_db_filename_len '%i'\n",
     345             :                               path, avid_db_filename,
     346             :                               (int)path_len, (int)avid_db_filename_len));
     347             : 
     348           0 :         if (
     349             :                 path_len > avid_db_filename_len
     350           0 :                         &&
     351           0 :                 strcmp(&path[path_len - avid_db_filename_len],
     352             :                                 avid_db_filename) == 0
     353           0 :                         &&
     354             :                 (
     355           0 :                         path[path_len - avid_db_filename_len - 1] == '/'
     356           0 :                         ||
     357             :                         (path_len > avid_db_filename_len
     358           0 :                                 + APPLE_DOUBLE_PREFIX_LEN
     359           0 :                                 &&
     360           0 :                         path[path_len - avid_db_filename_len
     361           0 :                                 - APPLE_DOUBLE_PREFIX_LEN - 1] == '/'
     362           0 :                                 &&
     363           0 :                         is_apple_double(&path[path_len
     364           0 :                                 - avid_db_filename_len
     365           0 :                                 - APPLE_DOUBLE_PREFIX_LEN]))
     366             :                 )
     367             :         )
     368             :         {
     369           0 :                 ret = True;
     370             :         }
     371           0 :         DEBUG(MH_INFO_DEBUG, ("Leaving with ret '%s'\n",
     372             :                                 ret == True ? "True" : "False"));
     373           0 :         return ret;
     374             : }
     375             : 
     376             : 
     377             : /* Add client suffix to paths to MDB_FILENAME, PMR_FILENAME and
     378             :  * CREATING_SUBDIRNAME.
     379             :  *
     380             :  * Caller must free newPath.
     381             :  *
     382             :  * Success: return 0
     383             :  * Failure: set errno, newPath NULL, return -1
     384             :  */
     385           0 : static int alloc_get_client_path(vfs_handle_struct *handle,
     386             :                 TALLOC_CTX *ctx,
     387             :                 const char *path,
     388             :                 char **newPath)
     389             : {
     390             :         /* replace /CREATING_DIRNAME/ or /._CREATING_DIRNAME/
     391             :          * directory in path - potentially in middle of path
     392             :          * - with suffixed name.
     393             :          */
     394           0 :         int status = 0;
     395             :         char* pathPtr;
     396             :         size_t intermPathLen;
     397             : 
     398           0 :         DEBUG(MH_INFO_DEBUG, ("Entering with path '%s'\n", path));
     399             : 
     400           0 :         *newPath = talloc_strdup(ctx, path);
     401           0 :         if (*newPath == NULL)
     402             :         {
     403           0 :                 DEBUG(MH_ERR_DEBUG, ("alloc_get_client_path ENOMEM #1\n"));
     404           0 :                 errno = ENOMEM;
     405           0 :                 status = -1;
     406           0 :                 goto out;
     407             :         }
     408           0 :         DEBUG(MH_INFO_DEBUG, ("newPath #1 %s\n", *newPath));
     409           0 :         if (
     410           0 :                 (pathPtr = strstr(path, CREATING_DIRNAME)) != NULL
     411           0 :                         &&
     412             :                 (
     413           0 :                         *(pathPtr + CREATING_DIRNAME_LEN) == '\0'
     414           0 :                         ||
     415           0 :                         *(pathPtr + CREATING_DIRNAME_LEN) == '/'
     416             :                 )
     417           0 :                         &&
     418             :                 (
     419           0 :                         (pathPtr - path > 0
     420           0 :                                 &&
     421           0 :                          *(pathPtr - 1) == '/')
     422           0 :                         ||
     423           0 :                         (pathPtr - path > APPLE_DOUBLE_PREFIX_LEN
     424           0 :                                 &&
     425           0 :                         *(pathPtr - APPLE_DOUBLE_PREFIX_LEN - 1) == '/'
     426           0 :                                 &&
     427           0 :                          is_apple_double(pathPtr - APPLE_DOUBLE_PREFIX_LEN))
     428             :                 )
     429             :         )
     430             :         {
     431             :                 /* Insert client suffix into path. */
     432           0 :                 (*newPath)[pathPtr - path + CREATING_DIRNAME_LEN] = '\0';
     433           0 :                 DEBUG(MH_INFO_DEBUG, ("newPath #2 %s\n", *newPath));
     434             : 
     435           0 :                 if ((status = alloc_append_client_suffix(handle, newPath)))
     436             :                 {
     437           0 :                         goto out;
     438             :                 }
     439             : 
     440           0 :                 DEBUG(MH_INFO_DEBUG, ("newPath #3 %s\n", *newPath));
     441           0 :                 *newPath = talloc_strdup_append(*newPath,
     442           0 :                                 pathPtr + CREATING_DIRNAME_LEN);
     443           0 :                 if (*newPath == NULL)
     444             :                 {
     445           0 :                         DEBUG(MH_ERR_DEBUG, ("alloc_get_client_path "
     446             :                                                 "ENOMEM #2\n"));
     447           0 :                         errno = ENOMEM;
     448           0 :                         status = -1;
     449           0 :                         goto out;
     450             :                 }
     451           0 :                 DEBUG(MH_INFO_DEBUG, ("newPath #4 %s\n", *newPath));
     452             :         }
     453             : 
     454             :         /* replace /MDB_FILENAME or /PMR_FILENAME or /._MDB_FILENAME
     455             :          * or /._PMR_FILENAME at newPath end with suffixed name.
     456             :          */
     457           0 :         intermPathLen = strlen(*newPath);
     458           0 :         if (
     459           0 :                 is_avid_database(*newPath, intermPathLen,
     460             :                         MDB_FILENAME, MDB_FILENAME_LEN)
     461           0 :                 ||
     462           0 :                 is_avid_database(*newPath, intermPathLen,
     463             :                         PMR_FILENAME, PMR_FILENAME_LEN)
     464             :         )
     465             :         {
     466           0 :                 DEBUG(MH_INFO_DEBUG, ("newPath #5 %s\n", *newPath));
     467           0 :                 if ((status = alloc_append_client_suffix(handle, newPath)))
     468             :                 {
     469           0 :                         goto out;
     470             :                 }
     471           0 :                 DEBUG(MH_INFO_DEBUG, ("newPath #6 %s\n", *newPath));
     472             :         }
     473           0 : out:
     474             :         /* newPath must be freed in caller. */
     475           0 :         DEBUG(MH_INFO_DEBUG, ("Leaving with *newPath '%s'\n", *newPath));
     476           0 :         return status;
     477             : }
     478             : 
     479             : /*
     480             :  * Success: return 0
     481             :  * Failure: set errno, return -1
     482             :  */
     483           0 : static int alloc_get_client_smb_fname(struct vfs_handle_struct *handle,
     484             :                 TALLOC_CTX *ctx,
     485             :                 const struct smb_filename *smb_fname,
     486             :                 struct smb_filename **clientFname)
     487             : {
     488           0 :         int status = 0;
     489             : 
     490           0 :         DEBUG(MH_INFO_DEBUG, ("Entering with smb_fname->base_name '%s'\n",
     491             :                               smb_fname->base_name));
     492             : 
     493           0 :         *clientFname = cp_smb_filename(ctx, smb_fname);
     494           0 :         if ((*clientFname) == NULL) {
     495           0 :                 DEBUG(MH_ERR_DEBUG, ("alloc_get_client_smb_fname "
     496             :                                         "NTERR\n"));
     497           0 :                 errno = ENOMEM;
     498           0 :                 status = -1;
     499           0 :                 goto err;
     500             :         }
     501           0 :         if ((status = alloc_get_client_path(handle, ctx,
     502           0 :                                 smb_fname->base_name,
     503           0 :                                 &(*clientFname)->base_name)))
     504             :         {
     505           0 :                 goto err;
     506             :         }
     507           0 :         DEBUG(MH_INFO_DEBUG, ("Leaving with (*clientFname)->base_name "
     508             :                                 "'%s'\n", (*clientFname)->base_name));
     509           0 : err:
     510           0 :         return status;
     511             : }
     512             : 
     513             : 
     514             : /*
     515             :  * Success: return 0
     516             :  * Failure: set errno, return -1
     517             :  */
     518           0 : static int alloc_set_client_dirinfo_path(struct vfs_handle_struct *handle,
     519             :                 TALLOC_CTX *ctx,
     520             :                 char **path,
     521             :                 const char *avid_db_filename)
     522             : {
     523           0 :         int status = 0;
     524             : 
     525           0 :         DEBUG(MH_INFO_DEBUG, ("Entering with avid_db_filename '%s'\n",
     526             :                               avid_db_filename));
     527             : 
     528           0 :         if ((*path = talloc_strdup(ctx, avid_db_filename)) == NULL)
     529             :         {
     530           0 :                 DEBUG(MH_ERR_DEBUG, ("alloc_set_client_dirinfo_path "
     531             :                                         "ENOMEM\n"));
     532           0 :                 errno = ENOMEM;
     533           0 :                 status = -1;
     534           0 :                 goto err;
     535             :         }
     536           0 :         if ((status = alloc_append_client_suffix(handle, path)))
     537             :         {
     538           0 :                 goto err;
     539             :         }
     540           0 :         DEBUG(MH_INFO_DEBUG, ("Leaving with *path '%s'\n", *path));
     541           0 : err:
     542           0 :         return status;
     543             : }
     544             : 
     545             : /*
     546             :  * Replace mtime on clientFname with mtime from client-suffixed
     547             :  * equivalent, if it exists.
     548             :  *
     549             :  * Success: return 0
     550             :  * Failure: set errno, return -1
     551             :  */
     552           0 : static int set_fake_mtime(vfs_handle_struct *handle,
     553             :                 TALLOC_CTX *ctx,
     554             :                 struct smb_filename **clientFname,
     555             :                 int (*statFn)(const char *, SMB_STRUCT_STAT *, bool))
     556             : {
     557           0 :         int status = 0;
     558             :         char *statPath;
     559             :         SMB_STRUCT_STAT fakeStat;
     560             :         int copy_len;
     561             : 
     562           0 :         DEBUG(MH_INFO_DEBUG, ("Entering with (*clientFname)->base_name "
     563             :                               "'%s', (*clientFname)->st.st_ex_mtime %s",
     564             :                               (*clientFname)->base_name,
     565             :                               ctime(&((*clientFname)->st.st_ex_mtime.tv_sec))));
     566             : 
     567           0 :         if (
     568           0 :                 depth_from_media_dir(AVID_MXF_DIRNAME,
     569             :                                 AVID_MXF_DIRNAME_LEN,
     570           0 :                                 (*clientFname)->base_name)
     571             :                         != 1
     572           0 :                         &&
     573           0 :                 depth_from_media_dir(OMFI_MEDIAFILES_DIRNAME,
     574             :                                 OMFI_MEDIAFILES_DIRNAME_LEN,
     575           0 :                                 (*clientFname)->base_name)
     576             :                         != 0
     577             :         )
     578             :         {
     579           0 :                 goto out;
     580             :         }
     581             : 
     582           0 :         copy_len = strlen((*clientFname)->base_name);
     583             : 
     584             :         /* Hack to deal with occasional "Avid MediaFiles/MXF/1/." paths.
     585             :          * We know we're under a media dir, so paths are at least 2 chars
     586             :          * long.
     587             :          */
     588           0 :         if ((*clientFname)->base_name[copy_len - 1] == '.' &&
     589           0 :                         (*clientFname)->base_name[copy_len - 2] == '/')
     590             :         {
     591           0 :                 copy_len -= 2;
     592             :         }
     593             : 
     594           0 :         if (((statPath = talloc_strndup(ctx,
     595           0 :                         (*clientFname)->base_name, copy_len)) == NULL))
     596             :         {
     597           0 :                 errno = ENOMEM;
     598           0 :                 status = -1;
     599           0 :                 goto err;
     600             :         }
     601           0 :         if ((status = alloc_append_client_suffix(handle, &statPath)))
     602             :         {
     603           0 :                 goto err;
     604             :         }
     605             : 
     606           0 :         DEBUG(MH_INFO_DEBUG, ("Fake stat'ing '%s'\n", statPath));
     607           0 :         if (statFn(statPath, &fakeStat,
     608           0 :                         lp_fake_directory_create_times(SNUM(handle->conn))))
     609             :         {
     610             :                 /* This can fail for legitimate reasons - i.e. the
     611             :                  * fakeStat directory doesn't exist, which is okay
     612             :                  * - so we don't set status.  But if it does fail,
     613             :                  * we need to skip over the mtime assignment.
     614             :                  */
     615           0 :                 goto err;
     616             :         }
     617             : 
     618           0 :         DEBUG(MH_INFO_DEBUG, ("Setting fake mtime from '%s'\n", statPath));
     619           0 :         (*clientFname)->st.st_ex_mtime = fakeStat.st_ex_mtime;
     620           0 : err:
     621           0 :         TALLOC_FREE(statPath);
     622           0 : out:
     623           0 :         DEBUG(MH_INFO_DEBUG, ("Leaving with (*clientFname)->base_name "
     624             :                         "'%s', (*clientFname)->st.st_ex_mtime %s",
     625             :                         (*clientFname)->base_name,
     626             :                         ctime(&((*clientFname)->st.st_ex_mtime.tv_sec))));
     627           0 :         return status;
     628             : }
     629             : 
     630             : /*
     631             :  * Success: return 0
     632             :  * Failure: set errno, return -1
     633             :  */
     634           0 : static int mh_statvfs(struct vfs_handle_struct *handle,
     635             :                 const struct smb_filename *smb_fname,
     636             :                 struct vfs_statvfs_struct *statbuf)
     637             : {
     638             :         int status;
     639           0 :         struct smb_filename *clientFname = NULL;
     640             : 
     641           0 :         DEBUG(MH_INFO_DEBUG, ("Entering with path '%s'\n",
     642             :                         smb_fname->base_name));
     643             : 
     644           0 :         if (!is_in_media_files(smb_fname->base_name))
     645             :         {
     646           0 :                 status = SMB_VFS_NEXT_STATVFS(handle, smb_fname, statbuf);
     647           0 :                 goto out;
     648             :         }
     649             : 
     650           0 :         status = alloc_get_client_smb_fname(handle,
     651             :                                 talloc_tos(),
     652             :                                 smb_fname,
     653             :                                 &clientFname);
     654           0 :         if (status != 0) {
     655           0 :                 goto err;
     656             :         }
     657             : 
     658           0 :         status = SMB_VFS_NEXT_STATVFS(handle, clientFname, statbuf);
     659           0 : err:
     660           0 :         TALLOC_FREE(clientFname);
     661           0 : out:
     662           0 :         DEBUG(MH_INFO_DEBUG, ("Leaving with path '%s'\n",
     663             :                         smb_fname->base_name));
     664           0 :         return status;
     665             : }
     666             : 
     667           0 : static int alloc_set_client_dirinfo(vfs_handle_struct *handle,
     668             :                 const char *fname,
     669             :                 struct mh_dirinfo_struct **dirInfo)
     670             : {
     671           0 :         int status = 0;
     672             :         char *clientPath;
     673             :         TALLOC_CTX *ctx;
     674             : 
     675           0 :         DEBUG(MH_INFO_DEBUG, ("Entering with fname '%s'\n", fname));
     676             : 
     677           0 :         *dirInfo = talloc(NULL, struct mh_dirinfo_struct);
     678           0 :         if (*dirInfo == NULL)
     679             :         {
     680           0 :                 goto err;
     681             :         }
     682             : 
     683           0 :         (*dirInfo)->dirpath = talloc_strdup(*dirInfo, fname);
     684           0 :         if ((*dirInfo)->dirpath == NULL)
     685             :         {
     686           0 :                 goto err;
     687             :         }
     688             : 
     689           0 :         if (!is_in_media_files(fname))
     690             :         {
     691           0 :                 (*dirInfo)->clientPath = NULL;
     692           0 :                 (*dirInfo)->clientMDBFilename = NULL;
     693           0 :                 (*dirInfo)->clientPMRFilename = NULL;
     694           0 :                 (*dirInfo)->clientCreatingDirname = NULL;
     695           0 :                 (*dirInfo)->isInMediaFiles = False;
     696           0 :                 goto out;
     697             :         }
     698             : 
     699           0 :         (*dirInfo)->isInMediaFiles = True;
     700             : 
     701           0 :         if (alloc_set_client_dirinfo_path(handle,
     702             :                                 *dirInfo,
     703           0 :                                 &((*dirInfo)->clientMDBFilename),
     704             :                                 MDB_FILENAME))
     705             :         {
     706           0 :                 goto err;
     707             :         }
     708             : 
     709           0 :         if (alloc_set_client_dirinfo_path(handle,
     710             :                                 *dirInfo,
     711           0 :                                 &((*dirInfo)->clientPMRFilename),
     712             :                                 PMR_FILENAME))
     713             :         {
     714           0 :                 goto err;
     715             :         }
     716             : 
     717           0 :         if (alloc_set_client_dirinfo_path(handle,
     718             :                                 *dirInfo,
     719           0 :                                 &((*dirInfo)->clientCreatingDirname),
     720             :                                 CREATING_DIRNAME))
     721             :         {
     722           0 :                 goto err;
     723             :         }
     724             : 
     725           0 :         clientPath = NULL;
     726           0 :         ctx = talloc_tos();
     727             : 
     728           0 :         if (alloc_get_client_path(handle, ctx,
     729             :                                 fname,
     730             :                                 &clientPath))
     731             :         {
     732           0 :                 goto err;
     733             :         }
     734             : 
     735           0 :         (*dirInfo)->clientPath = talloc_strdup(*dirInfo, clientPath);
     736           0 :         if ((*dirInfo)->clientPath == NULL)
     737             :         {
     738           0 :                 goto err;
     739             :         }
     740             : 
     741           0 :         TALLOC_FREE(clientPath);
     742             : 
     743           0 : out:
     744           0 :         DEBUG(MH_INFO_DEBUG, ("Leaving with (*dirInfo)->dirpath '%s', "
     745             :                                 "(*dirInfo)->clientPath '%s'\n",
     746             :                                 (*dirInfo)->dirpath,
     747             :                                 (*dirInfo)->clientPath));
     748           0 :         return status;
     749             : 
     750           0 : err:
     751           0 :         DEBUG(MH_ERR_DEBUG, ("Failing with fname '%s'\n", fname));
     752           0 :         TALLOC_FREE(*dirInfo);
     753           0 :         status = -1;
     754           0 :         errno = ENOMEM;
     755           0 :         return status;
     756             : }
     757             : 
     758           0 : static DIR *mh_fdopendir(vfs_handle_struct *handle,
     759             :                 files_struct *fsp,
     760             :                 const char *mask,
     761             :                 uint32_t attr)
     762             : {
     763           0 :         struct mh_dirinfo_struct *dirInfo = NULL;
     764             :         DIR *dirstream;
     765             : 
     766           0 :         DEBUG(MH_INFO_DEBUG, ("Entering with fsp->fsp_name->base_name '%s'\n",
     767             :                               fsp->fsp_name->base_name));
     768             : 
     769           0 :         dirstream = SMB_VFS_NEXT_FDOPENDIR(handle, fsp, mask, attr);
     770           0 :         if (!dirstream)
     771             :         {
     772           0 :                 goto err;
     773             :         }
     774             : 
     775           0 :         if (alloc_set_client_dirinfo(handle, fsp->fsp_name->base_name,
     776             :                                         &dirInfo))
     777             :         {
     778           0 :                 goto err;
     779             :         }
     780             : 
     781           0 :         dirInfo->dirstream = dirstream;
     782             : 
     783           0 :         if (! dirInfo->isInMediaFiles) {
     784           0 :                 goto out;
     785             :         }
     786             : 
     787           0 :         if (set_fake_mtime(handle, fsp, &(fsp->fsp_name), sys_stat))
     788             :         {
     789           0 :                 goto err;
     790             :         }
     791             : 
     792           0 : out:
     793           0 :         DEBUG(MH_INFO_DEBUG, ("Leaving with dirInfo->dirpath '%s', "
     794             :                         "dirInfo->clientPath '%s', "
     795             :                         "fsp->fsp_name->st.st_ex_mtime %s",
     796             :                         dirInfo->dirpath,
     797             :                         dirInfo->clientPath,
     798             :                         ctime(&(fsp->fsp_name->st.st_ex_mtime.tv_sec))));
     799             :         /* Success is freed in closedir. */
     800           0 :         return (DIR *) dirInfo;
     801           0 : err:
     802             :         /* Failure is freed here. */
     803           0 :         DEBUG(MH_ERR_DEBUG, ("Failing with fsp->fsp_name->base_name '%s'\n",
     804             :                         fsp->fsp_name->base_name));
     805           0 :         TALLOC_FREE(dirInfo);
     806           0 :         return NULL;
     807             : }
     808             : 
     809             : /*
     810             :  * skip MDB_FILENAME and PMR_FILENAME filenames and CREATING_DIRNAME
     811             :  * directory, skip other client's suffixed MDB_FILENAME and PMR_FILENAME
     812             :  * filenames and CREATING_DIRNAME directory, replace this client's
     813             :  * suffixed MDB_FILENAME and PMR_FILENAME filenames and CREATING_DIRNAME
     814             :  * directory with non suffixed.
     815             :  *
     816             :  * Success: return dirent
     817             :  * End of data: return NULL
     818             :  * Failure: set errno, return NULL
     819             :  */
     820           0 : static struct dirent *mh_readdir(vfs_handle_struct *handle,
     821             :                                  struct files_struct *dirfsp,
     822             :                                  DIR *dirp,
     823             :                                  SMB_STRUCT_STAT *sbuf)
     824             : {
     825           0 :         mh_dirinfo_struct* dirInfo = (mh_dirinfo_struct*)dirp;
     826           0 :         struct dirent *d = NULL;
     827             :         int skip;
     828             : 
     829           0 :         DEBUG(MH_INFO_DEBUG, ("Entering mh_readdir\n"));
     830             : 
     831           0 :         DEBUG(MH_INFO_DEBUG, ("dirInfo->dirpath '%s', "
     832             :                               "dirInfo->clientPath '%s', "
     833             :                               "dirInfo->isInMediaFiles '%s', "
     834             :                               "dirInfo->clientMDBFilename '%s', "
     835             :                               "dirInfo->clientPMRFilename '%s', "
     836             :                               "dirInfo->clientCreatingDirname '%s'\n",
     837             :                               dirInfo->dirpath,
     838             :                               dirInfo->clientPath,
     839             :                               dirInfo->isInMediaFiles ? "True" : "False",
     840             :                               dirInfo->clientMDBFilename,
     841             :                               dirInfo->clientPMRFilename,
     842             :                               dirInfo->clientCreatingDirname));
     843             : 
     844           0 :         if (! dirInfo->isInMediaFiles)
     845             :         {
     846           0 :                 d = SMB_VFS_NEXT_READDIR(handle, dirfsp, dirInfo->dirstream, sbuf);
     847           0 :                 goto out;
     848             :         }
     849             : 
     850             :         do
     851             :         {
     852             :                 const char* dname;
     853             :                 bool isAppleDouble;
     854             : 
     855           0 :                 skip = False;
     856           0 :                 d = SMB_VFS_NEXT_READDIR(handle, dirfsp, dirInfo->dirstream, sbuf);
     857             : 
     858           0 :                 if (d == NULL)
     859             :                 {
     860           0 :                         break;
     861             :                 }
     862             : 
     863             :                 /* ignore apple double prefix for logic below */
     864           0 :                 if (is_apple_double(d->d_name))
     865             :                 {
     866           0 :                         dname = &d->d_name[APPLE_DOUBLE_PREFIX_LEN];
     867           0 :                         isAppleDouble = True;
     868             :                 }
     869             :                 else
     870             :                 {
     871           0 :                         dname = d->d_name;
     872           0 :                         isAppleDouble = False;
     873             :                 }
     874             : 
     875             :                 /* skip Avid-special files with no client suffix */
     876           0 :                 if (
     877           0 :                         strcmp(dname, MDB_FILENAME) == 0
     878           0 :                         ||
     879           0 :                         strcmp(dname, PMR_FILENAME) == 0
     880           0 :                         ||
     881           0 :                         strcmp(dname, CREATING_DIRNAME) == 0
     882             :                 )
     883             :                 {
     884           0 :                         skip = True;
     885             :                 }
     886             :                 /* chop client suffix off this client's suffixed files */
     887           0 :                 else if (strcmp(dname, dirInfo->clientMDBFilename) == 0)
     888             :                 {
     889           0 :                         if (isAppleDouble)
     890             :                         {
     891             :                                 d->d_name[MDB_FILENAME_LEN
     892           0 :                                         + APPLE_DOUBLE_PREFIX_LEN] = '\0';
     893             :                         }
     894             :                         else
     895             :                         {
     896           0 :                                 d->d_name[MDB_FILENAME_LEN] = '\0';
     897             :                         }
     898             :                 }
     899           0 :                 else if (strcmp(dname, dirInfo->clientPMRFilename) == 0)
     900             :                 {
     901           0 :                         if (isAppleDouble)
     902             :                         {
     903             :                                 d->d_name[PMR_FILENAME_LEN
     904           0 :                                         + APPLE_DOUBLE_PREFIX_LEN] = '\0';
     905             :                         }
     906             :                         else
     907             :                         {
     908           0 :                                 d->d_name[PMR_FILENAME_LEN] = '\0';
     909             :                         }
     910             :                 }
     911           0 :                 else if (strcmp(dname, dirInfo->clientCreatingDirname)
     912             :                                 == 0)
     913             :                 {
     914           0 :                         if (isAppleDouble)
     915             :                         {
     916             :                                 d->d_name[CREATING_DIRNAME_LEN
     917           0 :                                         + APPLE_DOUBLE_PREFIX_LEN] = '\0';
     918             :                         }
     919             :                         else
     920             :                         {
     921           0 :                                 d->d_name[CREATING_DIRNAME_LEN] = '\0';
     922             :                         }
     923             :                 }
     924             :                 /*
     925             :                  * Anything that starts as an Avid-special file
     926             :                  * that's made it this far should be skipped.  This
     927             :                  * is different from the original behaviour, which
     928             :                  * only skipped other client's suffixed files.
     929             :                  */
     930           0 :                 else if (
     931           0 :                         strncmp(MDB_FILENAME, dname,
     932             :                                 MDB_FILENAME_LEN) == 0
     933           0 :                         ||
     934           0 :                         strncmp(PMR_FILENAME, dname,
     935             :                                 PMR_FILENAME_LEN) == 0
     936           0 :                         ||
     937           0 :                         strncmp(CREATING_DIRNAME, dname,
     938             :                                 CREATING_DIRNAME_LEN) == 0
     939             :                 )
     940             :                 {
     941           0 :                         skip = True;
     942             :                 }
     943             :         }
     944           0 :         while (skip);
     945             : 
     946           0 : out:
     947           0 :         DEBUG(MH_INFO_DEBUG, ("Leaving mh_readdir\n"));
     948           0 :         return d;
     949             : }
     950             : 
     951             : /*
     952             :  * Success: no success result defined.
     953             :  * Failure: no failure result defined.
     954             :  */
     955           0 : static void mh_seekdir(vfs_handle_struct *handle,
     956             :                 DIR *dirp,
     957             :                 long offset)
     958             : {
     959           0 :         DEBUG(MH_INFO_DEBUG, ("Entering and leaving mh_seekdir\n"));
     960           0 :         SMB_VFS_NEXT_SEEKDIR(handle,
     961             :                         ((mh_dirinfo_struct*)dirp)->dirstream, offset);
     962           0 : }
     963             : 
     964             : /*
     965             :  * Success: return long
     966             :  * Failure: no failure result defined.
     967             :  */
     968           0 : static long mh_telldir(vfs_handle_struct *handle,
     969             :                 DIR *dirp)
     970             : {
     971           0 :         DEBUG(MH_INFO_DEBUG, ("Entering and leaving mh_telldir\n"));
     972           0 :         return SMB_VFS_NEXT_TELLDIR(handle,
     973             :                         ((mh_dirinfo_struct*)dirp)->dirstream);
     974             : }
     975             : 
     976             : /*
     977             :  * Success: no success result defined.
     978             :  * Failure: no failure result defined.
     979             :  */
     980           0 : static void mh_rewinddir(vfs_handle_struct *handle,
     981             :                 DIR *dirp)
     982             : {
     983           0 :         DEBUG(MH_INFO_DEBUG, ("Entering and leaving mh_rewinddir\n"));
     984           0 :         SMB_VFS_NEXT_REWINDDIR(handle,
     985             :                         ((mh_dirinfo_struct*)dirp)->dirstream);
     986           0 : }
     987             : 
     988             : /*
     989             :  * Success: return 0
     990             :  * Failure: set errno, return -1
     991             :  */
     992           0 : static int mh_mkdirat(vfs_handle_struct *handle,
     993             :                 struct files_struct *dirfsp,
     994             :                 const struct smb_filename *smb_fname,
     995             :                 mode_t mode)
     996             : {
     997             :         int status;
     998           0 :         struct smb_filename *clientFname = NULL;
     999           0 :         const char *path = smb_fname->base_name;
    1000           0 :         struct smb_filename *full_fname = NULL;
    1001             : 
    1002           0 :         DEBUG(MH_INFO_DEBUG, ("Entering with path '%s'\n", path));
    1003             : 
    1004           0 :         if (!is_in_media_files(path)) {
    1005           0 :                 status = SMB_VFS_NEXT_MKDIRAT(handle,
    1006             :                                 dirfsp,
    1007             :                                 smb_fname,
    1008             :                                 mode);
    1009           0 :                 goto out;
    1010             :         }
    1011             : 
    1012           0 :         full_fname = full_path_from_dirfsp_atname(talloc_tos(),
    1013             :                                                   dirfsp,
    1014             :                                                   smb_fname);
    1015           0 :         if (full_fname == NULL) {
    1016           0 :                 return -1;
    1017             :         }
    1018             : 
    1019           0 :         status = alloc_get_client_smb_fname(handle,
    1020             :                                 talloc_tos(),
    1021             :                                 full_fname,
    1022             :                                 &clientFname);
    1023           0 :         if (status != 0) {
    1024           0 :                 goto err;
    1025             :         }
    1026             : 
    1027           0 :         status = SMB_VFS_NEXT_MKDIRAT(handle,
    1028             :                         handle->conn->cwd_fsp,
    1029             :                         clientFname,
    1030             :                         mode);
    1031           0 : err:
    1032           0 :         TALLOC_FREE(full_fname);
    1033           0 :         TALLOC_FREE(clientFname);
    1034           0 : out:
    1035           0 :         DEBUG(MH_INFO_DEBUG, ("Leaving with path '%s'\n", path));
    1036           0 :         return status;
    1037             : }
    1038             : 
    1039             : /*
    1040             :  * Success: return 0
    1041             :  * Failure: set errno, return -1
    1042             :  */
    1043           0 : static int mh_closedir(vfs_handle_struct *handle,
    1044             :                 DIR *dirp)
    1045             : {
    1046           0 :         DIR *realdirp = ((mh_dirinfo_struct*)dirp)->dirstream;
    1047             : 
    1048           0 :         DEBUG(MH_INFO_DEBUG, ("Entering mh_closedir\n"));
    1049             :         // Will this talloc_free destroy realdirp?
    1050           0 :         TALLOC_FREE(dirp);
    1051             : 
    1052           0 :         DEBUG(MH_INFO_DEBUG, ("Leaving mh_closedir\n"));
    1053           0 :         return SMB_VFS_NEXT_CLOSEDIR(handle, realdirp);
    1054             : }
    1055             : 
    1056             : /*
    1057             :  * Success: return non-negative file descriptor
    1058             :  * Failure: set errno, return -1
    1059             :  */
    1060           0 : static int mh_openat(struct vfs_handle_struct *handle,
    1061             :                      const struct files_struct *dirfsp,
    1062             :                      const struct smb_filename *smb_fname,
    1063             :                      files_struct *fsp,
    1064             :                      int flags,
    1065             :                      mode_t mode)
    1066             : {
    1067             :         int ret;
    1068             :         struct smb_filename *clientFname;
    1069             :         TALLOC_CTX *ctx;
    1070             : 
    1071           0 :         DEBUG(MH_INFO_DEBUG, ("Entering with smb_fname->base_name '%s'\n",
    1072             :                               smb_fname->base_name));
    1073             : 
    1074           0 :         if (!is_in_media_files(smb_fname->base_name)) {
    1075           0 :                 ret = SMB_VFS_NEXT_OPENAT(handle,
    1076             :                                           dirfsp,
    1077             :                                           smb_fname,
    1078             :                                           fsp,
    1079             :                                           flags,
    1080             :                                           mode);
    1081           0 :                 goto out;
    1082             :         }
    1083             : 
    1084           0 :         clientFname = NULL;
    1085           0 :         ctx = talloc_tos();
    1086             : 
    1087           0 :         if (alloc_get_client_smb_fname(handle, ctx, smb_fname, &clientFname)) {
    1088           0 :                 ret = -1;
    1089           0 :                 goto err;
    1090             :         }
    1091             : 
    1092             :         /*
    1093             :          * What about fsp->fsp_name? We also have to get correct stat info into
    1094             :          * fsp and smb_fname for DB files, don't we?
    1095             :          */
    1096             : 
    1097           0 :         DEBUG(MH_INFO_DEBUG, ("Leaving with smb_fname->base_name '%s' "
    1098             :                               "smb_fname->st.st_ex_mtime %s"
    1099             :                               " fsp->fsp_name->st.st_ex_mtime %s",
    1100             :                               smb_fname->base_name,
    1101             :                               ctime(&(smb_fname->st.st_ex_mtime.tv_sec)),
    1102             :                               ctime(&(fsp->fsp_name->st.st_ex_mtime.tv_sec))));
    1103             : 
    1104           0 :         ret = SMB_VFS_NEXT_OPENAT(handle, dirfsp, clientFname, fsp, flags, mode);
    1105           0 : err:
    1106           0 :         TALLOC_FREE(clientFname);
    1107           0 : out:
    1108           0 :         DEBUG(MH_INFO_DEBUG, ("Leaving with smb_fname->base_name '%s'\n",
    1109             :                                 smb_fname->base_name));
    1110           0 :         return ret;
    1111             : }
    1112             : 
    1113             : /*
    1114             :  * Success: return non-negative file descriptor
    1115             :  * Failure: set errno, return -1
    1116             :  */
    1117           0 : static NTSTATUS mh_create_file(vfs_handle_struct *handle,
    1118             :                 struct smb_request *req,
    1119             :                 struct smb_filename *smb_fname,
    1120             :                 uint32_t access_mask,
    1121             :                 uint32_t share_access,
    1122             :                 uint32_t create_disposition,
    1123             :                 uint32_t create_options,
    1124             :                 uint32_t file_attributes,
    1125             :                 uint32_t oplock_request,
    1126             :                 const struct smb2_lease *lease,
    1127             :                 uint64_t allocation_size,
    1128             :                 uint32_t private_flags,
    1129             :                 struct security_descriptor *sd,
    1130             :                 struct ea_list *ea_list,
    1131             :                 files_struct **result_fsp,
    1132             :                 int *pinfo,
    1133             :                 const struct smb2_create_blobs *in_context_blobs,
    1134             :                 struct smb2_create_blobs *out_context_blobs)
    1135             : {
    1136             :         NTSTATUS status;
    1137             :         struct smb_filename *clientFname;
    1138             :         TALLOC_CTX *ctx;
    1139             : 
    1140             : 
    1141           0 :         DEBUG(MH_INFO_DEBUG, ("Entering with smb_fname->base_name '%s'\n",
    1142             :                                 smb_fname->base_name));
    1143           0 :         if (!is_in_media_files(smb_fname->base_name))
    1144             :         {
    1145           0 :                 status = SMB_VFS_NEXT_CREATE_FILE(
    1146             :                         handle,
    1147             :                         req,
    1148             :                         smb_fname,
    1149             :                         access_mask,
    1150             :                         share_access,
    1151             :                         create_disposition,
    1152             :                         create_options,
    1153             :                         file_attributes,
    1154             :                         oplock_request,
    1155             :                         lease,
    1156             :                         allocation_size,
    1157             :                         private_flags,
    1158             :                         sd,
    1159             :                         ea_list,
    1160             :                         result_fsp,
    1161             :                         pinfo,
    1162             :                         in_context_blobs,
    1163             :                         out_context_blobs);
    1164           0 :                 goto out;
    1165             :         }
    1166             : 
    1167           0 :         clientFname = NULL;
    1168           0 :         ctx = talloc_tos();
    1169             : 
    1170           0 :         if (alloc_get_client_smb_fname(handle, ctx,
    1171             :                                 smb_fname,
    1172             :                                 &clientFname))
    1173             :         {
    1174           0 :                 status = map_nt_error_from_unix(errno);
    1175           0 :                 goto err;
    1176             :         }
    1177             : 
    1178             :         /* This only creates files, so we don't have to worry about
    1179             :          * our fake directory stat'ing here.
    1180             :          */
    1181             :         // But we still need to route stat calls for DB files
    1182             :         // properly, right?
    1183           0 :         status = SMB_VFS_NEXT_CREATE_FILE(
    1184             :                 handle,
    1185             :                 req,
    1186             :                 clientFname,
    1187             :                 access_mask,
    1188             :                 share_access,
    1189             :                 create_disposition,
    1190             :                 create_options,
    1191             :                 file_attributes,
    1192             :                 oplock_request,
    1193             :                 lease,
    1194             :                 allocation_size,
    1195             :                 private_flags,
    1196             :                 sd,
    1197             :                 ea_list,
    1198             :                 result_fsp,
    1199             :                 pinfo,
    1200             :                 in_context_blobs,
    1201             :                 out_context_blobs);
    1202           0 : err:
    1203           0 :         TALLOC_FREE(clientFname);
    1204           0 : out:
    1205           0 :         DEBUG(MH_INFO_DEBUG, ("Leaving with smb_fname->base_name '%s'"
    1206             :                 "smb_fname->st.st_ex_mtime %s"
    1207             :                 "          fsp->fsp_name->st.st_ex_mtime %s",
    1208             :                 smb_fname->base_name,
    1209             :                 ctime(&(smb_fname->st.st_ex_mtime.tv_sec)),
    1210             :                 (*result_fsp) && VALID_STAT((*result_fsp)->fsp_name->st) ?
    1211             :                 ctime(&((*result_fsp)->fsp_name->st.st_ex_mtime.tv_sec)) :
    1212             :                 "No fsp time\n"));
    1213           0 :         return status;
    1214             : }
    1215             : 
    1216             : /*
    1217             :  * Success: return 0
    1218             :  * Failure: set errno, return -1
    1219             :  */
    1220           0 : static int mh_renameat(vfs_handle_struct *handle,
    1221             :                 files_struct *srcfsp,
    1222             :                 const struct smb_filename *smb_fname_src,
    1223             :                 files_struct *dstfsp,
    1224             :                 const struct smb_filename *smb_fname_dst)
    1225             : {
    1226           0 :         int status = -1;
    1227           0 :         struct smb_filename *full_fname_src = NULL;
    1228           0 :         struct smb_filename *full_fname_dst = NULL;
    1229           0 :         struct smb_filename *srcClientFname = NULL;
    1230           0 :         struct smb_filename *dstClientFname = NULL;
    1231             : 
    1232           0 :         DEBUG(MH_INFO_DEBUG, ("Entering with "
    1233             :                               "smb_fname_src->base_name '%s', "
    1234             :                               "smb_fname_dst->base_name '%s'\n",
    1235             :                               smb_fname_src->base_name,
    1236             :                               smb_fname_dst->base_name));
    1237             : 
    1238           0 :         if (!is_in_media_files(smb_fname_src->base_name)
    1239           0 :                                 &&
    1240           0 :                         !is_in_media_files(smb_fname_dst->base_name))
    1241             :         {
    1242           0 :                 status = SMB_VFS_NEXT_RENAMEAT(handle,
    1243             :                                 srcfsp,
    1244             :                                 smb_fname_src,
    1245             :                                 dstfsp,
    1246             :                                 smb_fname_dst);
    1247           0 :                 goto out;
    1248             :         }
    1249             : 
    1250           0 :         full_fname_src = full_path_from_dirfsp_atname(talloc_tos(),
    1251             :                                                       srcfsp,
    1252             :                                                       smb_fname_src);
    1253           0 :         if (full_fname_src == NULL) {
    1254           0 :                 errno = ENOMEM;
    1255           0 :                 goto out;
    1256             :         }
    1257           0 :         full_fname_dst = full_path_from_dirfsp_atname(talloc_tos(),
    1258             :                                                       dstfsp,
    1259             :                                                       smb_fname_dst);
    1260           0 :         if (full_fname_dst == NULL) {
    1261           0 :                 errno = ENOMEM;
    1262           0 :                 goto out;
    1263             :         }
    1264             : 
    1265           0 :         if ((status = alloc_get_client_smb_fname(handle,
    1266             :                                 talloc_tos(),
    1267             :                                 full_fname_src,
    1268             :                                 &srcClientFname)))
    1269             :         {
    1270           0 :                 goto err;
    1271             :         }
    1272             : 
    1273           0 :         if ((status = alloc_get_client_smb_fname(handle,
    1274             :                                 talloc_tos(),
    1275             :                                 full_fname_dst,
    1276             :                                 &dstClientFname)))
    1277             :         {
    1278           0 :                 goto err;
    1279             :         }
    1280             : 
    1281           0 :         status = SMB_VFS_NEXT_RENAMEAT(handle,
    1282             :                                 srcfsp->conn->cwd_fsp,
    1283             :                                 srcClientFname,
    1284             :                                 dstfsp->conn->cwd_fsp,
    1285             :                                 dstClientFname);
    1286           0 : err:
    1287           0 :         TALLOC_FREE(full_fname_src);
    1288           0 :         TALLOC_FREE(full_fname_dst);
    1289           0 :         TALLOC_FREE(dstClientFname);
    1290           0 :         TALLOC_FREE(srcClientFname);
    1291           0 : out:
    1292           0 :         DEBUG(MH_INFO_DEBUG, ("Leaving with smb_fname_src->base_name '%s',"
    1293             :                                 " smb_fname_dst->base_name '%s'\n",
    1294             :                                 smb_fname_src->base_name,
    1295             :                                 smb_fname_dst->base_name));
    1296           0 :         return status;
    1297             : }
    1298             : 
    1299             : /*
    1300             :  * Success: return 0
    1301             :  * Failure: set errno, return -1
    1302             :  */
    1303           0 : static int mh_stat(vfs_handle_struct *handle,
    1304             :                 struct smb_filename *smb_fname)
    1305             : {
    1306           0 :         int status = 0;
    1307             :         struct smb_filename *clientFname;
    1308             :         TALLOC_CTX *ctx;
    1309             : 
    1310             : 
    1311           0 :         DEBUG(MH_INFO_DEBUG, ("Entering with smb_fname->base_name '%s'\n",
    1312             :                               smb_fname->base_name));
    1313             : 
    1314           0 :         if (!is_in_media_files(smb_fname->base_name))
    1315             :         {
    1316           0 :                 status = SMB_VFS_NEXT_STAT(handle, smb_fname);
    1317           0 :                 goto out;
    1318             :         }
    1319             : 
    1320           0 :         clientFname = NULL;
    1321           0 :         ctx = talloc_tos();
    1322             : 
    1323           0 :         if ((status = alloc_get_client_smb_fname(handle, ctx,
    1324             :                                 smb_fname,
    1325             :                                 &clientFname)))
    1326             :         {
    1327           0 :                 goto err;
    1328             :         }
    1329           0 :         DEBUG(MH_INFO_DEBUG, ("Stat'ing clientFname->base_name '%s'\n",
    1330             :                                 clientFname->base_name));
    1331           0 :         if ((status = SMB_VFS_NEXT_STAT(handle, clientFname)))
    1332             :         {
    1333           0 :                 goto err;
    1334             :         }
    1335           0 :         if ((status = set_fake_mtime(handle, ctx, &clientFname, sys_stat)))
    1336             :         {
    1337           0 :                 goto err;
    1338             :         }
    1339             : 
    1340             :         /* Unlike functions with const smb_filename, we have to
    1341             :          * modify smb_fname itself to pass our info back up.
    1342             :          */
    1343           0 :         DEBUG(MH_INFO_DEBUG, ("Setting smb_fname '%s' stat "
    1344             :                                 "from clientFname '%s'\n",
    1345             :                                 smb_fname->base_name,
    1346             :                                 clientFname->base_name));
    1347           0 :         smb_fname->st = clientFname->st;
    1348           0 : err:
    1349           0 :         TALLOC_FREE(clientFname);
    1350           0 : out:
    1351           0 :         DEBUG(MH_INFO_DEBUG, ("Leaving with smb_fname->st.st_ex_mtime %s",
    1352             :                         ctime(&(smb_fname->st.st_ex_mtime.tv_sec))));
    1353           0 :         return status;
    1354             : }
    1355             : 
    1356             : /*
    1357             :  * Success: return 0
    1358             :  * Failure: set errno, return -1
    1359             :  */
    1360           0 : static int mh_lstat(vfs_handle_struct *handle,
    1361             :                 struct smb_filename *smb_fname)
    1362             : {
    1363           0 :         int status = 0;
    1364             :         struct smb_filename *clientFname;
    1365             :         TALLOC_CTX *ctx;
    1366             : 
    1367           0 :         DEBUG(MH_INFO_DEBUG, ("Entering with smb_fname->base_name '%s'\n",
    1368             :                               smb_fname->base_name));
    1369             : 
    1370           0 :         if (!is_in_media_files(smb_fname->base_name))
    1371             :         {
    1372           0 :                 status = SMB_VFS_NEXT_LSTAT(handle, smb_fname);
    1373           0 :                 goto out;
    1374             :         }
    1375             : 
    1376           0 :         clientFname = NULL;
    1377           0 :         ctx = talloc_tos();
    1378             : 
    1379           0 :         if ((status = alloc_get_client_smb_fname(handle, ctx,
    1380             :                                 smb_fname,
    1381             :                                 &clientFname)))
    1382             :         {
    1383           0 :                 goto err;
    1384             :         }
    1385           0 :         if ((status = SMB_VFS_NEXT_LSTAT(handle, clientFname)))
    1386             :         {
    1387           0 :                 goto err;
    1388             :         }
    1389             : 
    1390           0 :         if ((status = set_fake_mtime(handle, ctx, &clientFname, sys_lstat)))
    1391             :         {
    1392           0 :                 goto err;
    1393             :         }
    1394             :         /* Unlike functions with const smb_filename, we have to
    1395             :          * modify smb_fname itself to pass our info back up.
    1396             :          */
    1397           0 :         smb_fname->st = clientFname->st;
    1398           0 : err:
    1399           0 :         TALLOC_FREE(clientFname);
    1400           0 : out:
    1401           0 :         DEBUG(MH_INFO_DEBUG, ("Leaving with smb_fname->st.st_ex_mtime %s",
    1402             :                         ctime(&(smb_fname->st.st_ex_mtime.tv_sec))));
    1403           0 :         return status;
    1404             : }
    1405             : 
    1406             : /*
    1407             :  * Success: return 0
    1408             :  * Failure: set errno, return -1
    1409             :  */
    1410           0 : static int mh_fstat(vfs_handle_struct *handle,
    1411             :                 files_struct *fsp, SMB_STRUCT_STAT *sbuf)
    1412             : {
    1413           0 :         int status = 0;
    1414             : 
    1415           0 :         DEBUG(MH_INFO_DEBUG, ("Entering with fsp->fsp_name->base_name "
    1416             :                                 "'%s'\n", fsp_str_dbg(fsp)));
    1417             : 
    1418           0 :         if ((status = SMB_VFS_NEXT_FSTAT(handle, fsp, sbuf)))
    1419             :         {
    1420           0 :                 goto out;
    1421             :         }
    1422             : 
    1423           0 :         if (fsp->fsp_name == NULL
    1424           0 :                         || !is_in_media_files(fsp->fsp_name->base_name))
    1425             :         {
    1426             :                 goto out;
    1427             :         }
    1428             : 
    1429           0 :         if ((status = mh_stat(handle, fsp->fsp_name)))
    1430             :         {
    1431           0 :                 goto out;
    1432             :         }
    1433             : 
    1434           0 :         *sbuf = fsp->fsp_name->st;
    1435           0 : out:
    1436           0 :         DEBUG(MH_INFO_DEBUG, ("Leaving with fsp->fsp_name->st.st_ex_mtime "
    1437             :                         "%s",
    1438             :                         fsp->fsp_name != NULL ?
    1439             :                                 ctime(&(fsp->fsp_name->st.st_ex_mtime.tv_sec)) :
    1440             :                                 "0"));
    1441           0 :         return status;
    1442             : }
    1443             : 
    1444             : /*
    1445             :  * Success: return 0
    1446             :  * Failure: set errno, return -1
    1447             :  */
    1448           0 : static int mh_unlinkat(vfs_handle_struct *handle,
    1449             :                 struct files_struct *dirfsp,
    1450             :                 const struct smb_filename *smb_fname,
    1451             :                 int flags)
    1452             : {
    1453             :         int status;
    1454           0 :         struct smb_filename *full_fname = NULL;
    1455             :         struct smb_filename *clientFname;
    1456             :         TALLOC_CTX *ctx;
    1457             : 
    1458           0 :         DEBUG(MH_INFO_DEBUG, ("Entering mh_unlinkat\n"));
    1459           0 :         if (!is_in_media_files(smb_fname->base_name)) {
    1460           0 :                 status = SMB_VFS_NEXT_UNLINKAT(handle,
    1461             :                                 dirfsp,
    1462             :                                 smb_fname,
    1463             :                                 flags);
    1464           0 :                 goto out;
    1465             :         }
    1466             : 
    1467           0 :         clientFname = NULL;
    1468           0 :         ctx = talloc_tos();
    1469             : 
    1470           0 :         full_fname = full_path_from_dirfsp_atname(talloc_tos(),
    1471             :                                                   dirfsp,
    1472             :                                                   smb_fname);
    1473           0 :         if (full_fname == NULL) {
    1474           0 :                 return -1;
    1475             :         }
    1476             : 
    1477           0 :         if ((status = alloc_get_client_smb_fname(handle, ctx,
    1478             :                                 full_fname,
    1479             :                                 &clientFname))) {
    1480           0 :                 goto err;
    1481             :         }
    1482             : 
    1483           0 :         status = SMB_VFS_NEXT_UNLINKAT(handle,
    1484             :                                 dirfsp->conn->cwd_fsp,
    1485             :                                 clientFname,
    1486             :                                 flags);
    1487           0 : err:
    1488           0 :         TALLOC_FREE(full_fname);
    1489           0 :         TALLOC_FREE(clientFname);
    1490           0 : out:
    1491           0 :         return status;
    1492             : }
    1493             : 
    1494             : /*
    1495             :  * Success: return 0
    1496             :  * Failure: set errno, return -1
    1497             :  */
    1498           0 : static int mh_lchown(vfs_handle_struct *handle,
    1499             :                 const struct smb_filename *smb_fname,
    1500             :                 uid_t uid,
    1501             :                 gid_t gid)
    1502             : {
    1503             :         int status;
    1504           0 :         struct smb_filename *clientFname = NULL;
    1505             : 
    1506           0 :         DEBUG(MH_INFO_DEBUG, ("Entering mh_lchown\n"));
    1507           0 :         if (!is_in_media_files(smb_fname->base_name))
    1508             :         {
    1509           0 :                 status = SMB_VFS_NEXT_LCHOWN(handle, smb_fname, uid, gid);
    1510           0 :                 goto out;
    1511             :         }
    1512             : 
    1513           0 :         status = alloc_get_client_smb_fname(handle,
    1514             :                                 talloc_tos(),
    1515             :                                 smb_fname,
    1516             :                                 &clientFname);
    1517           0 :         if (status != 0) {
    1518           0 :                 goto err;
    1519             :         }
    1520             : 
    1521           0 :         status = SMB_VFS_NEXT_LCHOWN(handle, clientFname, uid, gid);
    1522           0 : err:
    1523           0 :         TALLOC_FREE(clientFname);
    1524           0 : out:
    1525           0 :         return status;
    1526             : }
    1527             : 
    1528             : /*
    1529             :  * Success: return 0
    1530             :  * Failure: set errno, return -1
    1531             :  */
    1532           0 : static int mh_chdir(vfs_handle_struct *handle,
    1533             :                 const struct smb_filename *smb_fname)
    1534             : {
    1535             :         int status;
    1536           0 :         struct smb_filename *clientFname = NULL;
    1537             : 
    1538           0 :         DEBUG(MH_INFO_DEBUG, ("Entering mh_chdir\n"));
    1539           0 :         if (!is_in_media_files(smb_fname->base_name)) {
    1540           0 :                 status = SMB_VFS_NEXT_CHDIR(handle, smb_fname);
    1541           0 :                 goto out;
    1542             :         }
    1543             : 
    1544           0 :         status = alloc_get_client_smb_fname(handle,
    1545             :                                 talloc_tos(),
    1546             :                                 smb_fname,
    1547             :                                 &clientFname);
    1548           0 :         if (status != 0) {
    1549           0 :                 goto err;
    1550             :         }
    1551             : 
    1552           0 :         status = SMB_VFS_NEXT_CHDIR(handle, clientFname);
    1553           0 : err:
    1554           0 :         TALLOC_FREE(clientFname);
    1555           0 : out:
    1556           0 :         return status;
    1557             : }
    1558             : 
    1559             : /*
    1560             :  * Success: return 0
    1561             :  * Failure: set errno, return -1
    1562             :  */
    1563             : 
    1564           0 : static int mh_symlinkat(vfs_handle_struct *handle,
    1565             :                 const struct smb_filename *link_contents,
    1566             :                 struct files_struct *dirfsp,
    1567             :                 const struct smb_filename *new_smb_fname)
    1568             : {
    1569           0 :         int status = -1;
    1570           0 :         struct smb_filename *full_fname = NULL;
    1571           0 :         struct smb_filename *new_link_target = NULL;
    1572           0 :         struct smb_filename *newclientFname = NULL;
    1573             : 
    1574           0 :         DEBUG(MH_INFO_DEBUG, ("Entering mh_symlinkat\n"));
    1575             : 
    1576           0 :         full_fname = full_path_from_dirfsp_atname(talloc_tos(),
    1577             :                                                 dirfsp,
    1578             :                                                 new_smb_fname);
    1579           0 :         if (full_fname == NULL) {
    1580           0 :                 status = -1;
    1581           0 :                 goto err;
    1582             :         }
    1583             : 
    1584           0 :         if (!is_in_media_files(link_contents->base_name) &&
    1585           0 :                         !is_in_media_files(full_fname->base_name)) {
    1586           0 :                 status = SMB_VFS_NEXT_SYMLINKAT(handle,
    1587             :                                 link_contents,
    1588             :                                 dirfsp,
    1589             :                                 new_smb_fname);
    1590           0 :                 goto out;
    1591             :         }
    1592             : 
    1593           0 :         if ((status = alloc_get_client_smb_fname(handle, talloc_tos(),
    1594             :                                 link_contents,
    1595             :                                 &new_link_target))) {
    1596           0 :                 goto err;
    1597             :         }
    1598           0 :         if ((status = alloc_get_client_smb_fname(handle, talloc_tos(),
    1599             :                                 full_fname,
    1600             :                                 &newclientFname))) {
    1601           0 :                 goto err;
    1602             :         }
    1603             : 
    1604           0 :         status = SMB_VFS_NEXT_SYMLINKAT(handle,
    1605             :                                 new_link_target,
    1606             :                                 handle->conn->cwd_fsp,
    1607             :                                 newclientFname);
    1608           0 : err:
    1609           0 :         TALLOC_FREE(new_link_target);
    1610           0 :         TALLOC_FREE(newclientFname);
    1611           0 : out:
    1612           0 :         TALLOC_FREE(full_fname);
    1613           0 :         return status;
    1614             : }
    1615             : 
    1616             : /*
    1617             :  * Success: return byte count
    1618             :  * Failure: set errno, return -1
    1619             :  */
    1620           0 : static int mh_readlinkat(vfs_handle_struct *handle,
    1621             :                 const struct files_struct *dirfsp,
    1622             :                 const struct smb_filename *smb_fname,
    1623             :                 char *buf,
    1624             :                 size_t bufsiz)
    1625             : {
    1626             :         int status;
    1627           0 :         struct smb_filename *full_fname = NULL;
    1628           0 :         struct smb_filename *clientFname = NULL;
    1629             : 
    1630           0 :         DEBUG(MH_INFO_DEBUG, ("Entering mh_readlinkat\n"));
    1631           0 :         full_fname = full_path_from_dirfsp_atname(talloc_tos(),
    1632             :                                                 dirfsp,
    1633             :                                                 smb_fname);
    1634           0 :         if (full_fname == NULL) {
    1635           0 :                 status = -1;
    1636           0 :                 goto err;
    1637             :         }
    1638             : 
    1639           0 :         if (!is_in_media_files(full_fname->base_name)) {
    1640           0 :                 status = SMB_VFS_NEXT_READLINKAT(handle,
    1641             :                                 dirfsp,
    1642             :                                 smb_fname,
    1643             :                                 buf,
    1644             :                                 bufsiz);
    1645           0 :                 goto out;
    1646             :         }
    1647             : 
    1648           0 :         if ((status = alloc_get_client_smb_fname(handle, talloc_tos(),
    1649             :                                 full_fname,
    1650             :                                 &clientFname))) {
    1651           0 :                 goto err;
    1652             :         }
    1653             : 
    1654           0 :         status = SMB_VFS_NEXT_READLINKAT(handle,
    1655             :                                 handle->conn->cwd_fsp,
    1656             :                                 clientFname,
    1657             :                                 buf,
    1658             :                                 bufsiz);
    1659             : 
    1660           0 : err:
    1661           0 :         TALLOC_FREE(clientFname);
    1662           0 : out:
    1663           0 :         TALLOC_FREE(full_fname);
    1664           0 :         return status;
    1665             : }
    1666             : 
    1667             : /*
    1668             :  * Success: return 0
    1669             :  * Failure: set errno, return -1
    1670             :  */
    1671           0 : static int mh_linkat(vfs_handle_struct *handle,
    1672             :                 files_struct *srcfsp,
    1673             :                 const struct smb_filename *old_smb_fname,
    1674             :                 files_struct *dstfsp,
    1675             :                 const struct smb_filename *new_smb_fname,
    1676             :                 int flags)
    1677             : {
    1678             :         int status;
    1679           0 :         struct smb_filename *old_full_fname = NULL;
    1680           0 :         struct smb_filename *oldclientFname = NULL;
    1681           0 :         struct smb_filename *new_full_fname = NULL;
    1682           0 :         struct smb_filename *newclientFname = NULL;
    1683             : 
    1684           0 :         DEBUG(MH_INFO_DEBUG, ("Entering mh_linkat\n"));
    1685             : 
    1686           0 :         old_full_fname = full_path_from_dirfsp_atname(talloc_tos(),
    1687             :                                                 srcfsp,
    1688             :                                                 old_smb_fname);
    1689           0 :         if (old_full_fname == NULL) {
    1690           0 :                 status = -1;
    1691           0 :                 goto err;
    1692             :         }
    1693             : 
    1694           0 :         new_full_fname = full_path_from_dirfsp_atname(talloc_tos(),
    1695             :                                                 dstfsp,
    1696             :                                                 new_smb_fname);
    1697           0 :         if (new_full_fname == NULL) {
    1698           0 :                 status = -1;
    1699           0 :                 goto err;
    1700             :         }
    1701             : 
    1702           0 :         if (!is_in_media_files(old_full_fname->base_name) &&
    1703           0 :                         !is_in_media_files(new_full_fname->base_name)) {
    1704           0 :                 TALLOC_FREE(old_full_fname);
    1705           0 :                 TALLOC_FREE(new_full_fname);
    1706             : 
    1707           0 :                 status = SMB_VFS_NEXT_LINKAT(handle,
    1708             :                                 srcfsp,
    1709             :                                 old_smb_fname,
    1710             :                                 dstfsp,
    1711             :                                 new_smb_fname,
    1712             :                                 flags);
    1713           0 :                 goto out;
    1714             :         }
    1715             : 
    1716           0 :         if ((status = alloc_get_client_smb_fname(handle, talloc_tos(),
    1717             :                                 old_full_fname,
    1718             :                                 &oldclientFname))) {
    1719           0 :                 goto err;
    1720             :         }
    1721           0 :         if ((status = alloc_get_client_smb_fname(handle, talloc_tos(),
    1722             :                                 new_full_fname,
    1723             :                                 &newclientFname))) {
    1724           0 :                 goto err;
    1725             :         }
    1726             : 
    1727           0 :         status = SMB_VFS_NEXT_LINKAT(handle,
    1728             :                                 handle->conn->cwd_fsp,
    1729             :                                 oldclientFname,
    1730             :                                 handle->conn->cwd_fsp,
    1731             :                                 newclientFname,
    1732             :                                 flags);
    1733             : 
    1734           0 : err:
    1735           0 :         TALLOC_FREE(old_full_fname);
    1736           0 :         TALLOC_FREE(new_full_fname);
    1737           0 :         TALLOC_FREE(newclientFname);
    1738           0 :         TALLOC_FREE(oldclientFname);
    1739           0 : out:
    1740           0 :         return status;
    1741             : }
    1742             : 
    1743             : /*
    1744             :  * Success: return 0
    1745             :  * Failure: set errno, return -1
    1746             :  */
    1747           0 : static int mh_mknodat(vfs_handle_struct *handle,
    1748             :                 files_struct *dirfsp,
    1749             :                 const struct smb_filename *smb_fname,
    1750             :                 mode_t mode,
    1751             :                 SMB_DEV_T dev)
    1752             : {
    1753             :         int status;
    1754           0 :         struct smb_filename *full_fname = NULL;
    1755           0 :         struct smb_filename *clientFname = NULL;
    1756             :         TALLOC_CTX *ctx;
    1757             : 
    1758           0 :         DEBUG(MH_INFO_DEBUG, ("Entering mh_mknodat\n"));
    1759             : 
    1760           0 :         full_fname = full_path_from_dirfsp_atname(talloc_tos(),
    1761             :                                                 dirfsp,
    1762             :                                                 smb_fname);
    1763           0 :         if (full_fname == NULL) {
    1764           0 :                 status = -1;
    1765           0 :                 goto err;
    1766             :         }
    1767             : 
    1768           0 :         if (!is_in_media_files(full_fname->base_name)) {
    1769           0 :                 status = SMB_VFS_NEXT_MKNODAT(handle,
    1770             :                                 dirfsp,
    1771             :                                 smb_fname,
    1772             :                                 mode,
    1773             :                                 dev);
    1774           0 :                 goto out;
    1775             :         }
    1776             : 
    1777           0 :         ctx = talloc_tos();
    1778             : 
    1779           0 :         if ((status = alloc_get_client_smb_fname(handle, ctx,
    1780             :                                 full_fname,
    1781             :                                 &clientFname))) {
    1782           0 :                 goto err;
    1783             :         }
    1784             : 
    1785           0 :         status = SMB_VFS_NEXT_MKNODAT(handle,
    1786             :                         handle->conn->cwd_fsp,
    1787             :                         clientFname,
    1788             :                         mode,
    1789             :                         dev);
    1790             : 
    1791           0 : err:
    1792           0 :         TALLOC_FREE(clientFname);
    1793           0 : out:
    1794           0 :         TALLOC_FREE(full_fname);
    1795           0 :         return status;
    1796             : }
    1797             : 
    1798             : /*
    1799             :  * Success: return path pointer
    1800             :  * Failure: set errno, return NULL pointer
    1801             :  */
    1802           0 : static struct smb_filename *mh_realpath(vfs_handle_struct *handle,
    1803             :                                 TALLOC_CTX *ctx,
    1804             :                                 const struct smb_filename *smb_fname)
    1805             : {
    1806           0 :         struct smb_filename *result_fname = NULL;
    1807           0 :         struct smb_filename *clientFname = NULL;
    1808             : 
    1809           0 :         DEBUG(MH_INFO_DEBUG, ("Entering mh_realpath\n"));
    1810           0 :         if (!is_in_media_files(smb_fname->base_name)) {
    1811           0 :                 return SMB_VFS_NEXT_REALPATH(handle, ctx, smb_fname);
    1812             :         }
    1813             : 
    1814           0 :         if (alloc_get_client_smb_fname(handle, ctx,
    1815             :                                 smb_fname,
    1816             :                                 &clientFname) != 0) {
    1817           0 :                 goto err;
    1818             :         }
    1819             : 
    1820           0 :         result_fname = SMB_VFS_NEXT_REALPATH(handle, ctx, clientFname);
    1821           0 : err:
    1822           0 :         TALLOC_FREE(clientFname);
    1823           0 :         return result_fname;
    1824             : }
    1825             : 
    1826             : /* Ignoring get_real_filename function because the default
    1827             :  * doesn't do anything.
    1828             :  */
    1829             : 
    1830             : /*
    1831             :  * Success: return 0
    1832             :  * Failure: set errno, return -1
    1833             :  * In this case, "name" is an attr name.
    1834             :  */
    1835             : 
    1836             : /* VFS operations structure */
    1837             : 
    1838             : static struct vfs_fn_pointers vfs_mh_fns = {
    1839             :         /* Disk operations */
    1840             : 
    1841             :         .statvfs_fn = mh_statvfs,
    1842             : 
    1843             :         /* Directory operations */
    1844             : 
    1845             :         .fdopendir_fn = mh_fdopendir,
    1846             :         .readdir_fn = mh_readdir,
    1847             :         .seekdir_fn = mh_seekdir,
    1848             :         .telldir_fn = mh_telldir,
    1849             :         .rewind_dir_fn = mh_rewinddir,
    1850             :         .mkdirat_fn = mh_mkdirat,
    1851             :         .closedir_fn = mh_closedir,
    1852             : 
    1853             :         /* File operations */
    1854             : 
    1855             :         .openat_fn = mh_openat,
    1856             :         .create_file_fn = mh_create_file,
    1857             :         .renameat_fn = mh_renameat,
    1858             :         .stat_fn = mh_stat,
    1859             :         .lstat_fn = mh_lstat,
    1860             :         .fstat_fn = mh_fstat,
    1861             :         .unlinkat_fn = mh_unlinkat,
    1862             :         .lchown_fn = mh_lchown,
    1863             :         .chdir_fn = mh_chdir,
    1864             :         .symlinkat_fn = mh_symlinkat,
    1865             :         .readlinkat_fn = mh_readlinkat,
    1866             :         .linkat_fn = mh_linkat,
    1867             :         .mknodat_fn = mh_mknodat,
    1868             :         .realpath_fn = mh_realpath,
    1869             : 
    1870             :         /* EA operations. */
    1871             :         .getxattrat_send_fn = vfs_not_implemented_getxattrat_send,
    1872             :         .getxattrat_recv_fn = vfs_not_implemented_getxattrat_recv,
    1873             : 
    1874             :         /* aio operations */
    1875             : };
    1876             : 
    1877             : static_decl_vfs;
    1878          20 : NTSTATUS vfs_media_harmony_init(TALLOC_CTX *ctx)
    1879             : {
    1880          20 :         NTSTATUS ret = smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
    1881             :                                 "media_harmony", &vfs_mh_fns);
    1882          20 :         if (!NT_STATUS_IS_OK(ret))
    1883             :         {
    1884           0 :                 goto out;
    1885             :         }
    1886             : 
    1887          20 :         vfs_mh_debug_level = debug_add_class("media_harmony");
    1888             : 
    1889          20 :         if (vfs_mh_debug_level == -1) {
    1890           0 :                 vfs_mh_debug_level = DBGC_VFS;
    1891           0 :                 DEBUG(1, ("media_harmony_init: Couldn't register custom "
    1892             :                                 "debugging class.\n"));
    1893             :         } else {
    1894          20 :                 DEBUG(3, ("media_harmony_init: Debug class number of "
    1895             :                                 "'media_harmony': %d\n",
    1896             :                                 vfs_mh_debug_level));
    1897             :         }
    1898             : 
    1899          20 : out:
    1900          20 :         return ret;
    1901             : }

Generated by: LCOV version 1.13