source3/modules/vfs_media_harmony.c

   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* MH_MODULE_NAME = "media_harmony";
  97 static const char* MDB_FILENAME = "msmMMOB.mdb";
  98 static const size_t MDB_FILENAME_LEN = 11;
  99 static const char* PMR_FILENAME = "msmFMID.pmr";
 100 static const size_t PMR_FILENAME_LEN = 11;
 101 static const char* CREATING_DIRNAME = "Creating";
 102 static const size_t CREATING_DIRNAME_LEN = 8;
 103 static const char* AVID_MEDIAFILES_DIRNAME = "Avid MediaFiles";
 104 static const size_t AVID_MEDIAFILES_DIRNAME_LEN = 15;
 105 static const char* OMFI_MEDIAFILES_DIRNAME = "OMFI MediaFiles";
 106 static const size_t OMFI_MEDIAFILES_DIRNAME_LEN = 15;
 107 static const char* APPLE_DOUBLE_PREFIX = "._";
 108 static const size_t APPLE_DOUBLE_PREFIX_LEN = 2;
 109 static const char* AVID_MXF_DIRNAME = "Avid MediaFiles/MXF";
 110 static const size_t AVID_MXF_DIRNAME_LEN = 19;
 111
 112 static int vfs_mh_debug_level = DBGC_VFS;
 113
 114 /* supplements the directory list stream */
 115 typedef struct mh_dirinfo_struct
 116 {
 117         DIR* dirstream;
 118         char *dirpath;
 119         char *clientPath;
 120         bool isInMediaFiles;
 121         char *clientMDBFilename;
 122         char *clientPMRFilename;
 123         char *clientCreatingDirname;
 124 } mh_dirinfo_struct;
 125
 126
 127 /* Add "_<ip address>_<user name>" suffix to path or filename.
 128  *
 129  * Success: return 0
 130  * Failure: set errno, path NULL, return -1
 131  */
 132 static int alloc_append_client_suffix(vfs_handle_struct *handle,
 133                 char **path)
 134 {
 135         DEBUG(MH_INFO_DEBUG, ("Entering with *path '%s'\n", *path));
 136
 137         int status = 0;
 138         char *raddr = NULL;
 139
 140         raddr = tsocket_address_inet_addr_string(
 141                         handle->conn->sconn->remote_address, talloc_tos());
 142         if (raddr == NULL)
 143         {
 144                 errno = ENOMEM;
 145                 status = -1;
 146                 goto err;
 147         }
 148
 149         /* talloc_asprintf_append uses talloc_realloc, which
 150          * frees original 'path' memory so we don't have to.
 151          */
 152         *path = talloc_asprintf_append(*path, "_%s_%s",
 153                 raddr,
 154                 handle->conn->session_info->unix_info->sanitized_username);
 155         if (*path == NULL)
 156         {
 157                 DEBUG(MH_ERR_DEBUG, ("alloc_append_client_suffix "
 158                                         "out of memory\n"));
 159                 errno = ENOMEM;
 160                 status = -1;
 161                 goto err;
 162         }
 163         DEBUG(MH_INFO_DEBUG, ("Leaving with *path '%s'\n", *path));
 164 err:
 165         TALLOC_FREE(raddr);
 166         return status;
 167 }
 168
 169
 170 /* Returns True if the file or directory begins with the appledouble
 171  * prefix.
 172  */
 173 static bool is_apple_double(const char* fname)
 174 {
 175         DEBUG(MH_INFO_DEBUG, ("Entering with fname '%s'\n", fname));
 176
 177         bool ret = False;
 178
 179         if (strncmp(APPLE_DOUBLE_PREFIX, fname, APPLE_DOUBLE_PREFIX_LEN)
 180                         == 0)
 181         {
 182                 ret = True;
 183         }
 184         DEBUG(MH_INFO_DEBUG, ("Leaving with ret '%s'\n",
 185                                 ret == True ? "True" : "False"));
 186         return ret;
 187 }
 188
 189 static bool starts_with_media_dir(const char* media_dirname,
 190                 size_t media_dirname_len, const char* path)
 191 {
 192         DEBUG(MH_INFO_DEBUG, ("Entering with media_dirname '%s' "
 193                                 "path '%s'\n", media_dirname, path));
 194
 195         bool ret = False;
 196         char* path_start;
 197
 198         /* Sometimes Samba gives us "./OMFI MediaFiles". */
 199         if (strncmp(path, "./", 2) == 0)
 200         {
 201                 path_start = &path[2];
 202         }
 203         else {
 204                 path_start = path;
 205         }
 206
 207         if (strncmp(media_dirname, path_start, media_dirname_len) == 0
 208                         &&
 209                 (
 210                         path_start[media_dirname_len] == '\0'
 211                         ||
 212                         path_start[media_dirname_len] == '/'
 213                 )
 214         )
 215         {
 216                 ret = True;
 217         }
 218
 219         DEBUG(MH_INFO_DEBUG, ("Leaving with ret '%s'\n",
 220                                 ret == True ? "True" : "False"));
 221         return ret;
 222 }
 223
 224 /*
 225  * Returns True if the file or directory referenced by the path is below
 226  * the AVID_MEDIAFILES_DIRNAME or OMFI_MEDIAFILES_DIRNAME directory
 227  * The AVID_MEDIAFILES_DIRNAME and OMFI_MEDIAFILES_DIRNAME are assumed to
 228  * be in the root directory, which is generally a safe assumption
 229  * in the fixed-path world of Avid.
 230  */
 231 static bool is_in_media_files(const char* path)
 232 {
 233         DEBUG(MH_INFO_DEBUG, ("Entering with path '%s'\n", path));
 234
 235         bool ret = False;
 236
 237         if (
 238                 starts_with_media_dir(AVID_MEDIAFILES_DIRNAME,
 239                                 AVID_MEDIAFILES_DIRNAME_LEN, path)
 240                 ||
 241                 starts_with_media_dir(OMFI_MEDIAFILES_DIRNAME,
 242                                 OMFI_MEDIAFILES_DIRNAME_LEN, path)
 243         )
 244         {
 245                 ret = True;
 246         }
 247         DEBUG(MH_INFO_DEBUG, ("Leaving with ret '%s'\n",
 248                                 ret == True ? "True" : "False"));
 249         return ret;
 250 }
 251
 252 /*
 253  * Returns depth of path under media directory.  Deals with the
 254  * occasional ..../. and ..../.. paths that get passed to stat.
 255  *
 256  * Assumes is_in_media_files has already been called and has returned
 257  * true for the path; if it hasn't, this function will likely crash
 258  * and burn.
 259  *
 260  * Not foolproof; something like "Avid MediaFiles/MXF/../foo/1"
 261  * would fool it.  Haven't seen paths like that getting to the
 262  * stat function yet, so ignoring that possibility for now.
 263  */
 264 static int depth_from_media_dir(const char* media_dirname,
 265                 size_t media_dirname_len, const char* path)
 266 {
 267         DEBUG(MH_INFO_DEBUG, ("Entering with media_dirname '%s' "
 268                                 "path '%s'\n", media_dirname, path));
 269         int transition_count = 0;
 270         char* path_start;
 271         char* pathPtr;
 272
 273         /* Sometimes Samba gives us "./OMFI MediaFiles". */
 274         if (strncmp(path, "./", 2) == 0)
 275         {
 276                 path_start = &path[2];
 277         }
 278         else {
 279                 path_start = path;
 280         }
 281
 282         if (path_start[media_dirname_len] == '\0')
 283         {
 284                 goto out;
 285         }
 286
 287         pathPtr = &path_start[media_dirname_len + 1];
 288
 289         while(1)
 290         {
 291                 if (*pathPtr == '\0' || *pathPtr == '/')
 292                 {
 293                         if (
 294                                 *(pathPtr - 1) == '.'
 295                                         &&
 296                                 *(pathPtr - 2) == '.'
 297                                         &&
 298                                 *(pathPtr - 3) == '/'
 299                         )
 300                         {
 301                                 transition_count--;
 302                         }
 303                         else if (
 304                                 !
 305                                 (
 306                                         *(pathPtr - 1) == '/'
 307                                         ||
 308                                         (
 309                                                 *(pathPtr - 1) == '.'
 310                                                         &&
 311                                                 *(pathPtr - 2) == '/'
 312                                         )
 313                                 )
 314                         )
 315                         {
 316                                 transition_count++;
 317                         }
 318                 }
 319                 if (*pathPtr == '\0')
 320                 {
 321                         break;
 322                 }
 323                 pathPtr++;
 324         }
 325
 326         DEBUG(MH_INFO_DEBUG, ("Leaving with transition_count '%i'\n",
 327                                 transition_count));
 328 out:
 329         return transition_count;
 330 }
 331
 332 /* Identifies MDB and PMR files at end of path. */
 333 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         DEBUG(MH_INFO_DEBUG, ("Entering with path '%s', "
 340                                 "avid_db_filename '%s', "
 341                                 "path_len '%i', "
 342                                 "avid_db_filename_len '%i'\n",
 343                                 path, avid_db_filename,
 344                                 path_len, avid_db_filename_len));
 345
 346         bool ret = False;
 347
 348         if (
 349                 path_len > avid_db_filename_len
 350                         &&
 351                 strcmp(&path[path_len - avid_db_filename_len],
 352                                 avid_db_filename) == 0
 353                         &&
 354                 (
 355                         path[path_len - avid_db_filename_len - 1] == '/'
 356                         ||
 357                         path_len > avid_db_filename_len
 358                                 + APPLE_DOUBLE_PREFIX_LEN
 359                                 &&
 360                         path[path_len - avid_db_filename_len
 361                                 - APPLE_DOUBLE_PREFIX_LEN - 1] == '/'
 362                                 &&
 363                         is_apple_double(&path[path_len
 364                                 - avid_db_filename_len
 365                                 - APPLE_DOUBLE_PREFIX_LEN])
 366                 )
 367         )
 368         {
 369                 ret = True;
 370         }
 371         DEBUG(MH_INFO_DEBUG, ("Leaving with ret '%s'\n",
 372                                 ret == True ? "True" : "False"));
 373         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 static int alloc_get_client_path(vfs_handle_struct *handle,
 386                 TALLOC_CTX *ctx,
 387                 const char *path,
 388                 char **newPath)
 389 {
 390         DEBUG(MH_INFO_DEBUG, ("Entering with path '%s'\n", path));
 391
 392         /* replace /CREATING_DIRNAME/ or /._CREATING_DIRNAME/
 393          * directory in path - potentially in middle of path
 394          * - with suffixed name.
 395          */
 396         int status = 0;
 397         char* pathPtr;
 398         *newPath = talloc_strdup(ctx, path);
 399         if (*newPath == NULL)
 400         {
 401                 DEBUG(MH_ERR_DEBUG, ("alloc_get_client_path ENOMEM #1\n"));
 402                 errno = ENOMEM;
 403                 status = -1;
 404                 goto out;
 405         }
 406         DEBUG(MH_INFO_DEBUG, ("newPath #1 %s\n", *newPath));
 407         if (
 408                 (pathPtr = strstr(path, CREATING_DIRNAME)) != NULL
 409                         &&
 410                 (
 411                         *(pathPtr + CREATING_DIRNAME_LEN) == '\0'
 412                         ||
 413                         *(pathPtr + CREATING_DIRNAME_LEN) == '/'
 414                 )
 415                         &&
 416                 (
 417                         pathPtr - path > 0
 418                                 &&
 419                         *(pathPtr - 1) == '/'
 420                         ||
 421                         pathPtr - path > APPLE_DOUBLE_PREFIX_LEN
 422                                 &&
 423                         *(pathPtr - APPLE_DOUBLE_PREFIX_LEN - 1) == '/'
 424                                 &&
 425                         is_apple_double(pathPtr - APPLE_DOUBLE_PREFIX_LEN)
 426                 )
 427         )
 428         {
 429                 /* Insert client suffix into path. */
 430                 (*newPath)[pathPtr - path + CREATING_DIRNAME_LEN] = '\0';
 431                 DEBUG(MH_INFO_DEBUG, ("newPath #2 %s\n", *newPath));
 432
 433                 if (status = alloc_append_client_suffix(handle, newPath))
 434                 {
 435                         goto out;
 436                 }
 437
 438                 DEBUG(MH_INFO_DEBUG, ("newPath #3 %s\n", *newPath));
 439                 *newPath = talloc_strdup_append(*newPath,
 440                                 pathPtr + CREATING_DIRNAME_LEN);
 441                 if (*newPath == NULL)
 442                 {
 443                         DEBUG(MH_ERR_DEBUG, ("alloc_get_client_path "
 444                                                 "ENOMEM #2\n"));
 445                         errno = ENOMEM;
 446                         status = -1;
 447                         goto out;
 448                 }
 449                 DEBUG(MH_INFO_DEBUG, ("newPath #4 %s\n", *newPath));
 450         }
 451
 452         /* replace /MDB_FILENAME or /PMR_FILENAME or /._MDB_FILENAME
 453          * or /._PMR_FILENAME at newPath end with suffixed name.
 454          */
 455         size_t intermPathLen = strlen(*newPath);
 456         if (
 457                 is_avid_database(*newPath, intermPathLen,
 458                         MDB_FILENAME, MDB_FILENAME_LEN)
 459                 ||
 460                 is_avid_database(*newPath, intermPathLen,
 461                         PMR_FILENAME, PMR_FILENAME_LEN)
 462         )
 463         {
 464                 DEBUG(MH_INFO_DEBUG, ("newPath #5 %s\n", *newPath));
 465                 if (status = alloc_append_client_suffix(handle, newPath))
 466                 {
 467                         goto out;
 468                 }
 469                 DEBUG(MH_INFO_DEBUG, ("newPath #6 %s\n", *newPath));
 470         }
 471 out:
 472         /* newPath must be freed in caller. */
 473         DEBUG(MH_INFO_DEBUG, ("Leaving with *newPath '%s'\n", *newPath));
 474         return status;
 475 }
 476
 477 /*
 478  * Success: return 0
 479  * Failure: set errno, return -1
 480  */
 481 static int alloc_get_client_smb_fname(struct vfs_handle_struct *handle,
 482                 TALLOC_CTX *ctx,
 483                 const struct smb_filename *smb_fname,
 484                 struct smb_filename **clientFname)
 485 {
 486         DEBUG(MH_INFO_DEBUG, ("Entering with smb_fname->base_name '%s'\n",
 487                                 smb_fname->base_name));
 488
 489         int status = 0;
 490         NTSTATUS copystatus;
 491
 492         copystatus = copy_smb_filename(ctx, smb_fname, clientFname);
 493         if (!NT_STATUS_IS_OK(copystatus))
 494         {
 495                 DEBUG(MH_ERR_DEBUG, ("alloc_get_client_smb_fname "
 496                                         "NTERR\n"));
 497                 errno = map_errno_from_nt_status(copystatus);
 498                 status = -1;
 499                 goto err;
 500         }
 501         if (status = alloc_get_client_path(handle, ctx,
 502                                 smb_fname->base_name,
 503                                 &(*clientFname)->base_name))
 504         {
 505                 goto err;
 506         }
 507         DEBUG(MH_INFO_DEBUG, ("Leaving with (*clientFname)->base_name "
 508                                 "'%s'\n", (*clientFname)->base_name));
 509 err:
 510         return status;
 511 }
 512
 513
 514 /*
 515  * Success: return 0
 516  * Failure: set errno, return -1
 517  */
 518 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         DEBUG(MH_INFO_DEBUG, ("Entering with avid_db_filename '%s'\n",
 524                                 avid_db_filename));
 525
 526         int status = 0;
 527
 528         if ((*path = talloc_strdup(ctx, avid_db_filename)) == NULL)
 529         {
 530                 DEBUG(MH_ERR_DEBUG, ("alloc_set_client_dirinfo_path "
 531                                         "ENOMEM\n"));
 532                 errno = ENOMEM;
 533                 status = -1;
 534                 goto err;
 535         }
 536         if (status = alloc_append_client_suffix(handle, path))
 537         {
 538                 goto err;
 539         }
 540         DEBUG(MH_INFO_DEBUG, ("Leaving with *path '%s'\n", *path));
 541 err:
 542         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 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         DEBUG(MH_INFO_DEBUG, ("Entering with (*clientFname)->base_name "
 558                         "'%s', (*clientFname)->st.st_ex_mtime %s",
 559                         (*clientFname)->base_name,
 560                         ctime(&((*clientFname)->st.st_ex_mtime.tv_sec))));
 561
 562         int status = 0;
 563
 564         if (
 565                 depth_from_media_dir(AVID_MXF_DIRNAME,
 566                                 AVID_MXF_DIRNAME_LEN,
 567                                 (*clientFname)->base_name)
 568                         != 1
 569                         &&
 570                 depth_from_media_dir(OMFI_MEDIAFILES_DIRNAME,
 571                                 OMFI_MEDIAFILES_DIRNAME_LEN,
 572                                 (*clientFname)->base_name)
 573                         != 0
 574         )
 575         {
 576                 goto out;
 577         }
 578
 579         char *statPath;
 580         SMB_STRUCT_STAT fakeStat;
 581         int copy_len = strlen((*clientFname)->base_name);
 582
 583         /* Hack to deal with occasional "Avid MediaFiles/MXF/1/." paths.
 584          * We know we're under a media dir, so paths are at least 2 chars
 585          * long.
 586          */
 587         if ((*clientFname)->base_name[copy_len - 1] == '.' &&
 588                         (*clientFname)->base_name[copy_len - 2] == '/')
 589         {
 590                 copy_len -= 2;
 591         }
 592
 593         if ((statPath = talloc_strndup(ctx,
 594                         (*clientFname)->base_name, copy_len)) == NULL)
 595         {
 596                 errno = ENOMEM;
 597                 status = -1;
 598                 goto err;
 599         }
 600         if (status = alloc_append_client_suffix(handle, &statPath))
 601         {
 602                 goto err;
 603         }
 604
 605         DEBUG(MH_INFO_DEBUG, ("Fake stat'ing '%s'\n", statPath));
 606         if (statFn(statPath, &fakeStat,
 607                         lp_fake_dir_create_times(SNUM(handle->conn))))
 608         {
 609                 /* This can fail for legitimate reasons - i.e. the
 610                  * fakeStat directory doesn't exist, which is okay
 611                  * - so we don't set status.  But if it does fail,
 612                  * we need to skip over the mtime assignment.
 613                  */
 614                 goto err;
 615         }
 616
 617         DEBUG(MH_INFO_DEBUG, ("Setting fake mtime from '%s'\n", statPath));
 618         (*clientFname)->st.st_ex_mtime = fakeStat.st_ex_mtime;
 619 err:
 620         TALLOC_FREE(statPath);
 621 out:
 622         DEBUG(MH_INFO_DEBUG, ("Leaving with (*clientFname)->base_name "
 623                         "'%s', (*clientFname)->st.st_ex_mtime %s",
 624                         (*clientFname)->base_name,
 625                         ctime(&((*clientFname)->st.st_ex_mtime.tv_sec))));
 626         return status;
 627 }
 628
 629 /*
 630  * Success: return 0
 631  * Failure: set errno, return -1
 632  */
 633 static int mh_statvfs(struct vfs_handle_struct *handle,
 634                 const char *path,
 635                 struct vfs_statvfs_struct *statbuf)
 636 {
 637         DEBUG(MH_INFO_DEBUG, ("Entering with path '%s'\n", path));
 638
 639         int status;
 640
 641         if (!is_in_media_files(path))
 642         {
 643                 status = SMB_VFS_NEXT_STATVFS(handle, path, statbuf);
 644                 goto out;
 645         }
 646
 647         char *clientPath = NULL;
 648         TALLOC_CTX *ctx = talloc_tos();
 649
 650         if (status = alloc_get_client_path(handle, ctx,
 651                                 path,
 652                                 &clientPath))
 653         {
 654                 goto err;
 655         }
 656
 657         status = SMB_VFS_NEXT_STATVFS(handle, clientPath, statbuf);
 658 err:
 659         TALLOC_FREE(clientPath);
 660 out:
 661         DEBUG(MH_INFO_DEBUG, ("Leaving with path '%s'\n", path));
 662         return status;
 663 }
 664
 665 static int alloc_set_client_dirinfo(vfs_handle_struct *handle,
 666                 const char *fname,
 667                 struct mh_dirinfo_struct **dirInfo)
 668 {
 669         DEBUG(MH_INFO_DEBUG, ("Entering with fname '%s'\n", fname));
 670
 671         int status = 0;
 672
 673         *dirInfo = talloc(NULL, struct mh_dirinfo_struct);
 674         if (*dirInfo == NULL)
 675         {
 676                 goto err;
 677         }
 678
 679         (*dirInfo)->dirpath = talloc_strdup(*dirInfo, fname);
 680         if ((*dirInfo)->dirpath == NULL)
 681         {
 682                 goto err;
 683         }
 684
 685         if (!is_in_media_files(fname))
 686         {
 687                 (*dirInfo)->clientPath = NULL;
 688                 (*dirInfo)->clientMDBFilename = NULL;
 689                 (*dirInfo)->clientPMRFilename = NULL;
 690                 (*dirInfo)->clientCreatingDirname = NULL;
 691                 (*dirInfo)->isInMediaFiles = False;
 692                 goto out;
 693         }
 694
 695         (*dirInfo)->isInMediaFiles = True;
 696
 697         if (alloc_set_client_dirinfo_path(handle,
 698                                 *dirInfo,
 699                                 &((*dirInfo)->clientMDBFilename),
 700                                 MDB_FILENAME))
 701         {
 702                 goto err;
 703         }
 704
 705         if (alloc_set_client_dirinfo_path(handle,
 706                                 *dirInfo,
 707                                 &((*dirInfo)->clientPMRFilename),
 708                                 PMR_FILENAME))
 709         {
 710                 goto err;
 711         }
 712
 713         if (alloc_set_client_dirinfo_path(handle,
 714                                 *dirInfo,
 715                                 &((*dirInfo)->clientCreatingDirname),
 716                                 CREATING_DIRNAME))
 717         {
 718                 goto err;
 719         }
 720
 721         char *clientPath = NULL;
 722         TALLOC_CTX *ctx = talloc_tos();
 723
 724         if (alloc_get_client_path(handle, ctx,
 725                                 fname,
 726                                 &clientPath))
 727         {
 728                 goto err;
 729         }
 730
 731         (*dirInfo)->clientPath = talloc_strdup(*dirInfo, clientPath);
 732         if ((*dirInfo)->clientPath == NULL)
 733         {
 734                 goto err;
 735         }
 736
 737         TALLOC_FREE(clientPath);
 738
 739 out:
 740         DEBUG(MH_INFO_DEBUG, ("Leaving with (*dirInfo)->dirpath '%s', "
 741                                 "(*dirInfo)->clientPath '%s'\n",
 742                                 (*dirInfo)->dirpath,
 743                                 (*dirInfo)->clientPath));
 744         return status;
 745
 746 err:
 747         DEBUG(MH_ERR_DEBUG, ("Failing with fname '%s'\n", fname));
 748         TALLOC_FREE(*dirInfo);
 749         status = -1;
 750         errno = ENOMEM;
 751         return status;
 752 }
 753
 754 /* Success: return a mh_dirinfo_struct cast as a DIR
 755  * Failure: set errno, return NULL
 756  */
 757 static DIR *mh_opendir(vfs_handle_struct *handle,
 758                 const char *fname,
 759                 const char *mask,
 760                 uint32 attr)
 761 {
 762         DEBUG(MH_INFO_DEBUG, ("Entering with fname '%s'\n", fname));
 763
 764         struct mh_dirinfo_struct *dirInfo;
 765
 766         if (alloc_set_client_dirinfo(handle, fname, &dirInfo))
 767         {
 768                 goto err;
 769         }
 770
 771         if (!dirInfo->isInMediaFiles)
 772         {
 773                 dirInfo->dirstream = SMB_VFS_NEXT_OPENDIR(handle,
 774                         fname, mask, attr);
 775         } else {
 776                 dirInfo->dirstream = SMB_VFS_NEXT_OPENDIR(handle,
 777                         dirInfo->clientPath, mask, attr);
 778         }
 779
 780         if (dirInfo->dirstream == NULL) {
 781                 goto err;
 782         }
 783
 784 out:
 785         /* Success is freed in closedir. */
 786         DEBUG(MH_INFO_DEBUG, ("Leaving with dirInfo->dirpath '%s', "
 787                                 "dirInfo->clientPath '%s'\n",
 788                                 dirInfo->dirpath,
 789                                 dirInfo->clientPath));
 790         return (DIR*)dirInfo;
 791 err:
 792         /* Failure is freed here. */
 793         DEBUG(MH_ERR_DEBUG, ("Failing with fname '%s'\n", fname));
 794         TALLOC_FREE(dirInfo);
 795         return NULL;
 796 }
 797
 798 static DIR *mh_fdopendir(vfs_handle_struct *handle,
 799                 files_struct *fsp,
 800                 const char *mask,
 801                 uint32 attr)
 802 {
 803         DEBUG(MH_INFO_DEBUG, ("Entering with fsp->fsp_name->base_name '%s'\n",
 804                         fsp->fsp_name->base_name));
 805
 806         struct mh_dirinfo_struct *dirInfo;
 807         DIR *dirstream;
 808
 809         dirstream = SMB_VFS_NEXT_FDOPENDIR(handle, fsp, mask, attr);
 810         if (!dirstream)
 811         {
 812                 goto err;
 813         }
 814
 815         if (alloc_set_client_dirinfo(handle, fsp->fsp_name->base_name,
 816                                         &dirInfo))
 817         {
 818                 goto err;
 819         }
 820
 821         dirInfo->dirstream = dirstream;
 822
 823         if (! dirInfo->isInMediaFiles) {
 824                 goto out;
 825         }
 826
 827         if (set_fake_mtime(handle, fsp, &(fsp->fsp_name), sys_stat))
 828         {
 829                 goto err;
 830         }
 831
 832 out:
 833         DEBUG(MH_INFO_DEBUG, ("Leaving with dirInfo->dirpath '%s', "
 834                         "dirInfo->clientPath '%s', "
 835                         "fsp->fsp_name->st.st_ex_mtime %s",
 836                         dirInfo->dirpath,
 837                         dirInfo->clientPath,
 838                         ctime(&(fsp->fsp_name->st.st_ex_mtime.tv_sec))));
 839         /* Success is freed in closedir. */
 840         return (DIR *) dirInfo;
 841 err:
 842         /* Failure is freed here. */
 843         DEBUG(MH_ERR_DEBUG, ("Failing with fsp->fsp_name->base_name '%s'\n",
 844                         fsp->fsp_name->base_name));
 845         TALLOC_FREE(dirInfo);
 846         return NULL;
 847 }
 848
 849 /*
 850  * skip MDB_FILENAME and PMR_FILENAME filenames and CREATING_DIRNAME
 851  * directory, skip other client's suffixed MDB_FILENAME and PMR_FILENAME
 852  * filenames and CREATING_DIRNAME directory, replace this client's
 853  * suffixed MDB_FILENAME and PMR_FILENAME filenames and CREATING_DIRNAME
 854  * directory with non suffixed.
 855  *
 856  * Success: return dirent
 857  * End of data: return NULL
 858  * Failure: set errno, return NULL
 859  */
 860 static struct dirent *mh_readdir(vfs_handle_struct *handle,
 861                 DIR *dirp,
 862                 SMB_STRUCT_STAT *sbuf)
 863 {
 864         DEBUG(MH_INFO_DEBUG, ("Entering mh_readdir\n"));
 865
 866         mh_dirinfo_struct* dirInfo = (mh_dirinfo_struct*)dirp;
 867
 868         DEBUG(MH_INFO_DEBUG, ("dirInfo->dirpath '%s', "
 869                                 "dirInfo->clientPath '%s', "
 870                                 "dirInfo->isInMediaFiles '%s', "
 871                                 "dirInfo->clientMDBFilename '%s', "
 872                                 "dirInfo->clientPMRFilename '%s', "
 873                                 "dirInfo->clientCreatingDirname '%s'\n",
 874                                 dirInfo->dirpath,
 875                                 dirInfo->clientPath,
 876                                 dirInfo->isInMediaFiles ? "True" : "False",
 877                                 dirInfo->clientMDBFilename,
 878                                 dirInfo->clientPMRFilename,
 879                                 dirInfo->clientCreatingDirname));
 880
 881         struct dirent *d = NULL;
 882
 883         if (! dirInfo->isInMediaFiles)
 884         {
 885                 d = SMB_VFS_NEXT_READDIR(handle, dirInfo->dirstream, sbuf);
 886                 goto out;
 887         }
 888
 889         int skip;
 890         do
 891         {
 892                 skip = False;
 893                 d = SMB_VFS_NEXT_READDIR(handle, dirInfo->dirstream, sbuf);
 894
 895                 if (d == NULL)
 896                 {
 897                         break;
 898                 }
 899
 900                 const char* dname;
 901                 bool isAppleDouble;
 902
 903                 /* ignore apple double prefix for logic below */
 904                 if (is_apple_double(d->d_name))
 905                 {
 906                         dname = &d->d_name[APPLE_DOUBLE_PREFIX_LEN];
 907                         isAppleDouble = True;
 908                 }
 909                 else
 910                 {
 911                         dname = d->d_name;
 912                         isAppleDouble = False;
 913                 }
 914
 915                 /* skip Avid-special files with no client suffix */
 916                 if (
 917                         strcmp(dname, MDB_FILENAME) == 0
 918                         ||
 919                         strcmp(dname, PMR_FILENAME) == 0
 920                         ||
 921                         strcmp(dname, CREATING_DIRNAME) == 0
 922                 )
 923                 {
 924                         skip = True;
 925                 }
 926                 /* chop client suffix off this client's suffixed files */
 927                 else if (strcmp(dname, dirInfo->clientMDBFilename) == 0)
 928                 {
 929                         if (isAppleDouble)
 930                         {
 931                                 d->d_name[MDB_FILENAME_LEN
 932                                         + APPLE_DOUBLE_PREFIX_LEN] = '\0';
 933                         }
 934                         else
 935                         {
 936                                 d->d_name[MDB_FILENAME_LEN] = '\0';
 937                         }
 938                 }
 939                 else if (strcmp(dname, dirInfo->clientPMRFilename) == 0)
 940                 {
 941                         if (isAppleDouble)
 942                         {
 943                                 d->d_name[PMR_FILENAME_LEN
 944                                         + APPLE_DOUBLE_PREFIX_LEN] = '\0';
 945                         }
 946                         else
 947                         {
 948                                 d->d_name[PMR_FILENAME_LEN] = '\0';
 949                         }
 950                 }
 951                 else if (strcmp(dname, dirInfo->clientCreatingDirname)
 952                                 == 0)
 953                 {
 954                         if (isAppleDouble)
 955                         {
 956                                 d->d_name[CREATING_DIRNAME_LEN
 957                                         + APPLE_DOUBLE_PREFIX_LEN] = '\0';
 958                         }
 959                         else
 960                         {
 961                                 d->d_name[CREATING_DIRNAME_LEN] = '\0';
 962                         }
 963                 }
 964                 /*
 965                  * Anything that starts as an Avid-special file
 966                  * that's made it this far should be skipped.  This
 967                  * is different from the original behaviour, which
 968                  * only skipped other client's suffixed files.
 969                  */
 970                 else if (
 971                         strncmp(MDB_FILENAME, dname,
 972                                 MDB_FILENAME_LEN) == 0
 973                         ||
 974                         strncmp(PMR_FILENAME, dname,
 975                                 PMR_FILENAME_LEN) == 0
 976                         ||
 977                         strncmp(CREATING_DIRNAME, dname,
 978                                 CREATING_DIRNAME_LEN) == 0
 979                 )
 980                 {
 981                         skip = True;
 982                 }
 983         }
 984         while (skip);
 985
 986 out:
 987         DEBUG(MH_INFO_DEBUG, ("Leaving mh_readdir\n"));
 988         return d;
 989 }
 990
 991 /*
 992  * Success: no success result defined.
 993  * Failure: no failure result defined.
 994  */
 995 static void mh_seekdir(vfs_handle_struct *handle,
 996                 DIR *dirp,
 997                 long offset)
 998 {
 999         DEBUG(MH_INFO_DEBUG, ("Entering and leaving mh_seekdir\n"));
1000         SMB_VFS_NEXT_SEEKDIR(handle,
1001                         ((mh_dirinfo_struct*)dirp)->dirstream, offset);
1002         return;
1003 }
1004
1005 /*
1006  * Success: return long
1007  * Failure: no failure result defined.
1008  */
1009 static long mh_telldir(vfs_handle_struct *handle,
1010                 DIR *dirp)
1011 {
1012         DEBUG(MH_INFO_DEBUG, ("Entering and leaving mh_telldir\n"));
1013         return SMB_VFS_NEXT_TELLDIR(handle,
1014                         ((mh_dirinfo_struct*)dirp)->dirstream);
1015 }
1016
1017 /*
1018  * Success: no success result defined.
1019  * Failure: no failure result defined.
1020  */
1021 static void mh_rewinddir(vfs_handle_struct *handle,
1022                 DIR *dirp)
1023 {
1024         DEBUG(MH_INFO_DEBUG, ("Entering and leaving mh_rewinddir\n"));
1025         SMB_VFS_NEXT_REWINDDIR(handle,
1026                         ((mh_dirinfo_struct*)dirp)->dirstream);
1027         return;
1028 }
1029
1030 /*
1031  * Success: return 0
1032  * Failure: set errno, return -1
1033  */
1034 static int mh_mkdir(vfs_handle_struct *handle,
1035                 const char *path,
1036                 mode_t mode)
1037 {
1038         DEBUG(MH_INFO_DEBUG, ("Entering with path '%s'\n", path));
1039
1040         int status;
1041
1042         if (!is_in_media_files(path))
1043         {
1044                 status = SMB_VFS_NEXT_MKDIR(handle, path, mode);
1045                 goto out;
1046         }
1047
1048         char *clientPath = NULL;
1049         TALLOC_CTX *ctx = talloc_tos();
1050
1051         if (status = alloc_get_client_path(handle, ctx,
1052                                 path,
1053                                 &clientPath))
1054         {
1055                 goto err;
1056         }
1057
1058         status = SMB_VFS_NEXT_MKDIR(handle, clientPath, mode);
1059 err:
1060         TALLOC_FREE(clientPath);
1061 out:
1062         DEBUG(MH_INFO_DEBUG, ("Leaving with path '%s'\n", path));
1063         return status;
1064 }
1065
1066 /*
1067  * Success: return 0
1068  * Failure: set errno, return -1
1069  */
1070 static int mh_rmdir(vfs_handle_struct *handle,
1071                 const char *path)
1072 {
1073         DEBUG(MH_INFO_DEBUG, ("Entering with path '%s'\n", path));
1074
1075         int status;
1076
1077         if (!is_in_media_files(path))
1078         {
1079                 status = SMB_VFS_NEXT_RMDIR(handle, path);
1080                 goto out;
1081         }
1082
1083         char *clientPath = NULL;
1084         TALLOC_CTX *ctx = talloc_tos();
1085
1086         if (status = alloc_get_client_path(handle, ctx,
1087                                 path,
1088                                 &clientPath))
1089         {
1090                 goto err;
1091         }
1092
1093         status = SMB_VFS_NEXT_RMDIR(handle, clientPath);
1094 err:
1095         TALLOC_FREE(clientPath);
1096 out:
1097         DEBUG(MH_INFO_DEBUG, ("Leaving with path '%s'\n", path));
1098         return status;
1099 }
1100
1101 /*
1102  * Success: return 0
1103  * Failure: set errno, return -1
1104  */
1105 static int mh_closedir(vfs_handle_struct *handle,
1106                 DIR *dirp)
1107 {
1108         DEBUG(MH_INFO_DEBUG, ("Entering mh_closedir\n"));
1109         DIR *realdirp = ((mh_dirinfo_struct*)dirp)->dirstream;
1110         // Will this talloc_free destroy realdirp?
1111         TALLOC_FREE(dirp);
1112
1113         DEBUG(MH_INFO_DEBUG, ("Leaving mh_closedir\n"));
1114         return SMB_VFS_NEXT_CLOSEDIR(handle, realdirp);
1115 }
1116
1117 /*
1118  * Success: no success result defined.
1119  * Failure: no failure result defined.
1120  */
1121 static void mh_init_search_op(vfs_handle_struct *handle,
1122                 DIR *dirp)
1123 {
1124         DEBUG(MH_INFO_DEBUG, ("Entering and leaving mh_init_search_op\n"));
1125         SMB_VFS_NEXT_INIT_SEARCH_OP(handle,
1126                         ((mh_dirinfo_struct*)dirp)->dirstream);
1127         return;
1128 }
1129
1130 /*
1131  * Success: return non-negative file descriptor
1132  * Failure: set errno, return -1
1133  */
1134 static int mh_open(vfs_handle_struct *handle,
1135                 struct smb_filename *smb_fname,
1136                 files_struct *fsp,
1137                 int flags,
1138                 mode_t mode)
1139 {
1140         DEBUG(MH_INFO_DEBUG, ("Entering with smb_fname->base_name '%s'\n",
1141                                 smb_fname->base_name));
1142
1143         int ret;
1144
1145         if (!is_in_media_files(smb_fname->base_name))
1146         {
1147                 ret = SMB_VFS_NEXT_OPEN(handle, smb_fname, fsp, flags,
1148                                 mode);
1149                 goto out;
1150         }
1151
1152         struct smb_filename *clientFname = NULL;
1153         TALLOC_CTX *ctx = talloc_tos();
1154
1155         if(alloc_get_client_smb_fname(handle, ctx,
1156                                 smb_fname,
1157                                 &clientFname))
1158         {
1159                 ret = -1;
1160                 goto err;
1161         }
1162
1163         // What about fsp->fsp_name?
1164         // We also have to get correct stat info into fsp and smb_fname
1165         // for DB files, don't we?
1166
1167         DEBUG(MH_INFO_DEBUG, ("Leaving with smb_fname->base_name '%s' "
1168                         "smb_fname->st.st_ex_mtime %s"
1169                         "               fsp->fsp_name->st.st_ex_mtime %s",
1170                         smb_fname->base_name,
1171                         ctime(&(smb_fname->st.st_ex_mtime.tv_sec)),
1172                         ctime(&(fsp->fsp_name->st.st_ex_mtime.tv_sec))));
1173
1174         ret = SMB_VFS_NEXT_OPEN(handle, clientFname, fsp, flags, mode);
1175 err:
1176         TALLOC_FREE(clientFname);
1177 out:
1178         DEBUG(MH_INFO_DEBUG, ("Leaving with smb_fname->base_name '%s'\n",
1179                                 smb_fname->base_name));
1180         return ret;
1181 }
1182
1183 /*
1184  * Success: return non-negative file descriptor
1185  * Failure: set errno, return -1
1186  */
1187 static NTSTATUS mh_create_file(vfs_handle_struct *handle,
1188                 struct smb_request *req,
1189                 uint16_t root_dir_fid,
1190                 struct smb_filename *smb_fname,
1191                 uint32_t access_mask,
1192                 uint32_t share_access,
1193                 uint32_t create_disposition,
1194                 uint32_t create_options,
1195                 uint32_t file_attributes,
1196                 uint32_t oplock_request,
1197                 uint64_t allocation_size,
1198                 uint32_t private_flags,
1199                 struct security_descriptor *sd,
1200                 struct ea_list *ea_list,
1201                 files_struct **result_fsp,
1202                 int *pinfo)
1203 {
1204         NTSTATUS status;
1205
1206         DEBUG(MH_INFO_DEBUG, ("Entering with smb_fname->base_name '%s'\n",
1207                                 smb_fname->base_name));
1208         if (!is_in_media_files(smb_fname->base_name))
1209         {
1210                 status = SMB_VFS_NEXT_CREATE_FILE(
1211                         handle,
1212                         req,
1213                         root_dir_fid,
1214                         smb_fname,
1215                         access_mask,
1216                         share_access,
1217                         create_disposition,
1218                         create_options,
1219                         file_attributes,
1220                         oplock_request,
1221                         allocation_size,
1222                         private_flags,
1223                         sd,
1224                         ea_list,
1225                         result_fsp,
1226                         pinfo);
1227                 goto out;
1228         }
1229
1230         struct smb_filename *clientFname = NULL;
1231         TALLOC_CTX *ctx = talloc_tos();
1232
1233         if (alloc_get_client_smb_fname(handle, ctx,
1234                                 smb_fname,
1235                                 &clientFname))
1236         {
1237                 status = map_nt_error_from_unix(errno);
1238                 goto err;
1239         }
1240
1241         /* This only creates files, so we don't have to worry about
1242          * our fake directory stat'ing here.
1243          */
1244         // But we still need to route stat calls for DB files
1245         // properly, right?
1246         status = SMB_VFS_NEXT_CREATE_FILE(
1247                 handle,
1248                 req,
1249                 root_dir_fid,
1250                 clientFname,
1251                 access_mask,
1252                 share_access,
1253                 create_disposition,
1254                 create_options,
1255                 file_attributes,
1256                 oplock_request,
1257                 allocation_size,
1258                 private_flags,
1259                 sd,
1260                 ea_list,
1261                 result_fsp,
1262                 pinfo);
1263 err:
1264         TALLOC_FREE(clientFname);
1265 out:
1266         DEBUG(MH_INFO_DEBUG, ("Leaving with smb_fname->base_name '%s'"
1267                 "smb_fname->st.st_ex_mtime %s"
1268                 "               fsp->fsp_name->st.st_ex_mtime %s",
1269                 smb_fname->base_name,
1270                 ctime(&(smb_fname->st.st_ex_mtime.tv_sec)),
1271                 (*result_fsp) && VALID_STAT((*result_fsp)->fsp_name->st) ?
1272                 ctime(&((*result_fsp)->fsp_name->st.st_ex_mtime.tv_sec)) :
1273                 "No fsp time\n"));
1274         return status;
1275 }
1276
1277 /*
1278  * Success: return 0
1279  * Failure: set errno, return -1
1280  */
1281 static int mh_rename(vfs_handle_struct *handle,
1282                 const struct smb_filename *smb_fname_src,
1283                 const struct smb_filename *smb_fname_dst)
1284 {
1285         DEBUG(MH_INFO_DEBUG, ("Entering with "
1286                                 "smb_fname_src->base_name '%s', "
1287                                 "smb_fname_dst->base_name '%s'\n",
1288                                 smb_fname_src->base_name,
1289                                 smb_fname_dst->base_name));
1290
1291         int status;
1292
1293         if (!is_in_media_files(smb_fname_src->base_name)
1294                                 &&
1295                         !is_in_media_files(smb_fname_dst->base_name))
1296         {
1297                 status = SMB_VFS_NEXT_RENAME(handle, smb_fname_src,
1298                                 smb_fname_dst);
1299                 goto out;
1300         }
1301
1302         struct smb_filename *srcClientFname = NULL;
1303         struct smb_filename *dstClientFname = NULL;
1304         TALLOC_CTX *ctx = talloc_tos();
1305
1306         if (status = alloc_get_client_smb_fname(handle, ctx,
1307                                 smb_fname_src,
1308                                 &srcClientFname))
1309         {
1310                 goto err;
1311         }
1312
1313         if (status = alloc_get_client_smb_fname(handle, ctx,
1314                                 smb_fname_dst,
1315                                 &dstClientFname))
1316         {
1317                 goto err;
1318         }
1319
1320         status = SMB_VFS_NEXT_RENAME(handle, srcClientFname,
1321                                 dstClientFname);
1322 err:
1323         TALLOC_FREE(dstClientFname);
1324         TALLOC_FREE(srcClientFname);
1325 out:
1326         DEBUG(MH_INFO_DEBUG, ("Leaving with smb_fname_src->base_name '%s',"
1327                                 " smb_fname_dst->base_name '%s'\n",
1328                                 smb_fname_src->base_name,
1329                                 smb_fname_dst->base_name));
1330         return status;
1331 }
1332
1333 /*
1334  * Success: return 0
1335  * Failure: set errno, return -1
1336  */
1337 static int mh_stat(vfs_handle_struct *handle,
1338                 struct smb_filename *smb_fname)
1339 {
1340         DEBUG(MH_INFO_DEBUG, ("Entering with smb_fname->base_name '%s'\n",
1341                                 smb_fname->base_name));
1342
1343         int status = 0;
1344
1345         if (!is_in_media_files(smb_fname->base_name))
1346         {
1347                 status = SMB_VFS_NEXT_STAT(handle, smb_fname);
1348                 goto out;
1349         }
1350
1351         struct smb_filename *clientFname = NULL;
1352         TALLOC_CTX *ctx = talloc_tos();
1353
1354         if (status = alloc_get_client_smb_fname(handle, ctx,
1355                                 smb_fname,
1356                                 &clientFname))
1357         {
1358                 goto err;
1359         }
1360         DEBUG(MH_INFO_DEBUG, ("Stat'ing clientFname->base_name '%s'\n",
1361                                 clientFname->base_name));
1362         if (status = SMB_VFS_NEXT_STAT(handle, clientFname))
1363         {
1364                 goto err;
1365         }
1366         if (status = set_fake_mtime(handle, ctx, &clientFname, sys_stat))
1367         {
1368                 goto err;
1369         }
1370
1371         /* Unlike functions with const smb_filename, we have to
1372          * modify smb_fname itself to pass our info back up.
1373          */
1374         DEBUG(MH_INFO_DEBUG, ("Setting smb_fname '%s' stat "
1375                                 "from clientFname '%s'\n",
1376                                 smb_fname->base_name,
1377                                 clientFname->base_name));
1378         smb_fname->st = clientFname->st;
1379 err:
1380         TALLOC_FREE(clientFname);
1381 out:
1382         DEBUG(MH_INFO_DEBUG, ("Leaving with smb_fname->st.st_ex_mtime %s",
1383                         ctime(&(smb_fname->st.st_ex_mtime.tv_sec))));
1384         return status;
1385 }
1386
1387 /*
1388  * Success: return 0
1389  * Failure: set errno, return -1
1390  */
1391 static int mh_lstat(vfs_handle_struct *handle,
1392                 struct smb_filename *smb_fname)
1393 {
1394         DEBUG(MH_INFO_DEBUG, ("Entering with smb_fname->base_name '%s'\n",
1395                                 smb_fname->base_name));
1396
1397         int status = 0;
1398
1399         if (!is_in_media_files(smb_fname->base_name))
1400         {
1401                 status = SMB_VFS_NEXT_LSTAT(handle, smb_fname);
1402                 goto out;
1403         }
1404
1405         struct smb_filename *clientFname = NULL;
1406         TALLOC_CTX *ctx = talloc_tos();
1407
1408         if (status = alloc_get_client_smb_fname(handle, ctx,
1409                                 smb_fname,
1410                                 &clientFname))
1411         {
1412                 goto err;
1413         }
1414         if (status = SMB_VFS_NEXT_LSTAT(handle, clientFname))
1415         {
1416                 goto err;
1417         }
1418
1419         if (status = set_fake_mtime(handle, ctx, &clientFname, sys_lstat))
1420         {
1421                 goto err;
1422         }
1423         /* Unlike functions with const smb_filename, we have to
1424          * modify smb_fname itself to pass our info back up.
1425          */
1426         smb_fname->st = clientFname->st;
1427 err:
1428         TALLOC_FREE(clientFname);
1429 out:
1430         DEBUG(MH_INFO_DEBUG, ("Leaving with smb_fname->st.st_ex_mtime %s",
1431                         ctime(&(smb_fname->st.st_ex_mtime.tv_sec))));
1432         return status;
1433 }
1434
1435 /*
1436  * Success: return 0
1437  * Failure: set errno, return -1
1438  */
1439 static int mh_fstat(vfs_handle_struct *handle,
1440                 files_struct *fsp, SMB_STRUCT_STAT *sbuf)
1441 {
1442         DEBUG(MH_INFO_DEBUG, ("Entering with fsp->fsp_name->base_name "
1443                                 "'%s'\n", fsp_str_dbg(fsp)));
1444
1445         int status = 0;
1446
1447         if (status = SMB_VFS_NEXT_FSTAT(handle, fsp, sbuf))
1448         {
1449                 goto out;
1450         }
1451
1452         if (fsp->fsp_name == NULL
1453                         || !is_in_media_files(fsp->fsp_name->base_name))
1454         {
1455                 goto out;
1456         }
1457
1458         if (status = mh_stat(handle, fsp->fsp_name))
1459         {
1460                 goto out;
1461         }
1462
1463         *sbuf = fsp->fsp_name->st;
1464 out:
1465         DEBUG(MH_INFO_DEBUG, ("Leaving with fsp->fsp_name->st.st_ex_mtime "
1466                         "%s",
1467                         ctime(&(fsp->fsp_name->st.st_ex_mtime.tv_sec))));
1468         return status;
1469 }
1470
1471 /*
1472  * Success: return 0
1473  * Failure: set errno, return -1
1474  */
1475 static int mh_unlink(vfs_handle_struct *handle,
1476                 const struct smb_filename *smb_fname)
1477 {
1478         int status;
1479
1480         DEBUG(MH_INFO_DEBUG, ("Entering mh_unlink\n"));
1481         if (!is_in_media_files(smb_fname->base_name))
1482         {
1483                 status = SMB_VFS_NEXT_UNLINK(handle, smb_fname);
1484                 goto out;
1485         }
1486
1487         struct smb_filename *clientFname = NULL;
1488         TALLOC_CTX *ctx = talloc_tos();
1489
1490         if (status = alloc_get_client_smb_fname(handle, ctx,
1491                                 smb_fname,
1492                                 &clientFname))
1493         {
1494                 goto err;
1495         }
1496
1497         status = SMB_VFS_NEXT_UNLINK(handle, clientFname);
1498 err:
1499         TALLOC_FREE(clientFname);
1500 out:
1501         return status;
1502 }
1503
1504 /*
1505  * Success: return 0
1506  * Failure: set errno, return -1
1507  */
1508 static int mh_chmod(vfs_handle_struct *handle,
1509                 const char *path,
1510                 mode_t mode)
1511 {
1512         int status;
1513
1514         DEBUG(MH_INFO_DEBUG, ("Entering mh_chmod\n"));
1515         if (!is_in_media_files(path))
1516         {
1517                 status = SMB_VFS_NEXT_CHMOD(handle, path, mode);
1518                 goto out;
1519         }
1520
1521         char *clientPath = NULL;
1522         TALLOC_CTX *ctx = talloc_tos();
1523
1524         if (status = alloc_get_client_path(handle, ctx,
1525                                 path,
1526                                 &clientPath))
1527         {
1528                 goto err;
1529         }
1530
1531         status = SMB_VFS_NEXT_CHMOD(handle, clientPath, mode);
1532 err:
1533         TALLOC_FREE(clientPath);
1534 out:
1535         return status;
1536 }
1537
1538 /*
1539  * Success: return 0
1540  * Failure: set errno, return -1
1541  */
1542 static int mh_chown(vfs_handle_struct *handle,
1543                 const char *path,
1544                 uid_t uid,
1545                 gid_t gid)
1546 {
1547         int status;
1548
1549         DEBUG(MH_INFO_DEBUG, ("Entering mh_chown\n"));
1550         if (!is_in_media_files(path))
1551         {
1552                 status = SMB_VFS_NEXT_CHOWN(handle, path, uid, gid);
1553                 goto out;
1554         }
1555
1556         char *clientPath = NULL;
1557         TALLOC_CTX *ctx = talloc_tos();
1558
1559         if (status = alloc_get_client_path(handle, ctx,
1560                                 path,
1561                                 &clientPath))
1562         {
1563                 goto err;
1564         }
1565
1566         status = SMB_VFS_NEXT_CHOWN(handle, clientPath, uid, gid);
1567 err:
1568         TALLOC_FREE(clientPath);
1569 out:
1570         return status;
1571 }
1572
1573 /*
1574  * Success: return 0
1575  * Failure: set errno, return -1
1576  */
1577 static int mh_lchown(vfs_handle_struct *handle,
1578                 const char *path,
1579                 uid_t uid,
1580                 gid_t gid)
1581 {
1582         int status;
1583
1584         DEBUG(MH_INFO_DEBUG, ("Entering mh_lchown\n"));
1585         if (!is_in_media_files(path))
1586         {
1587                 status = SMB_VFS_NEXT_LCHOWN(handle, path, uid, gid);
1588                 goto out;
1589         }
1590
1591         char *clientPath = NULL;
1592         TALLOC_CTX *ctx = talloc_tos();
1593
1594         if (status = alloc_get_client_path(handle, ctx,
1595                                 path,
1596                                 &clientPath))
1597         {
1598                 goto err;
1599         }
1600
1601         status = SMB_VFS_NEXT_LCHOWN(handle, clientPath, uid, gid);
1602 err:
1603         TALLOC_FREE(clientPath);
1604 out:
1605         return status;
1606 }
1607
1608 /*
1609  * Success: return 0
1610  * Failure: set errno, return -1
1611  */
1612 static int mh_chdir(vfs_handle_struct *handle,
1613                 const char *path)
1614 {
1615         int status;
1616
1617         DEBUG(MH_INFO_DEBUG, ("Entering mh_chdir\n"));
1618         if (!is_in_media_files(path))
1619         {
1620                 status = SMB_VFS_NEXT_CHDIR(handle, path);
1621                 goto out;
1622         }
1623
1624         char *clientPath = NULL;
1625         TALLOC_CTX *ctx = talloc_tos();
1626
1627         if (status = alloc_get_client_path(handle, ctx,
1628                                 path,
1629                                 &clientPath))
1630         {
1631                 goto err;
1632         }
1633
1634         status = SMB_VFS_NEXT_CHDIR(handle, clientPath);
1635 err:
1636         TALLOC_FREE(clientPath);
1637 out:
1638         return status;
1639 }
1640
1641 /*
1642  * Success: return 0
1643  * Failure: set errno, return -1
1644  */
1645 static int mh_ntimes(vfs_handle_struct *handle,
1646                 const struct smb_filename *smb_fname,
1647                 struct smb_file_time *ft)
1648 {
1649         int status;
1650
1651         DEBUG(MH_INFO_DEBUG, ("Entering mh_ntimes\n"));
1652         if (!is_in_media_files(smb_fname->base_name))
1653         {
1654                 status = SMB_VFS_NEXT_NTIMES(handle, smb_fname, ft);
1655                 goto out;
1656         }
1657
1658         struct smb_filename *clientFname = NULL;
1659         TALLOC_CTX *ctx = talloc_tos();
1660
1661         if (status = alloc_get_client_smb_fname(handle, ctx,
1662                                 smb_fname,
1663                                 &clientFname))
1664         {
1665                 goto err;
1666         }
1667
1668         status = SMB_VFS_NEXT_NTIMES(handle, clientFname, ft);
1669 err:
1670         TALLOC_FREE(clientFname);
1671 out:
1672         return status;
1673 }
1674
1675 /*
1676  * Success: return 0
1677  * Failure: set errno, return -1
1678  */
1679 static int mh_symlink(vfs_handle_struct *handle,
1680                 const char *oldpath,
1681                 const char *newpath)
1682 {
1683         int status;
1684
1685         DEBUG(MH_INFO_DEBUG, ("Entering mh_symlink\n"));
1686         if (!is_in_media_files(oldpath) && !is_in_media_files(newpath))
1687         {
1688                 status = SMB_VFS_NEXT_SYMLINK(handle, oldpath, newpath);
1689                 goto out;
1690         }
1691
1692         char *oldClientPath = NULL;
1693         char *newClientPath = NULL;
1694         TALLOC_CTX *ctx = talloc_tos();
1695
1696         if (status = alloc_get_client_path(handle, ctx,
1697                                 oldpath,
1698                                 &oldClientPath))
1699         {
1700                 goto err;
1701         }
1702
1703         if (status = alloc_get_client_path(handle, ctx,
1704                                 newpath,
1705                                 &newClientPath))
1706         {
1707                 goto err;
1708         }
1709
1710         status = SMB_VFS_NEXT_SYMLINK(handle,
1711                         oldClientPath,
1712                         newClientPath);
1713
1714 err:
1715         TALLOC_FREE(newClientPath);
1716         TALLOC_FREE(oldClientPath);
1717 out:
1718         return status;
1719 }
1720
1721 /*
1722  * Success: return byte count
1723  * Failure: set errno, return -1
1724  */
1725 static int mh_readlink(vfs_handle_struct *handle,
1726                 const char *path,
1727                 char *buf,
1728                 size_t bufsiz)
1729 {
1730         int status;
1731
1732         DEBUG(MH_INFO_DEBUG, ("Entering mh_readlink\n"));
1733         if (!is_in_media_files(path))
1734         {
1735                 status = SMB_VFS_NEXT_READLINK(handle, path, buf, bufsiz);
1736                 goto out;
1737         }
1738
1739         char *clientPath = NULL;
1740         TALLOC_CTX *ctx = talloc_tos();
1741
1742         if (status = alloc_get_client_path(handle, ctx,
1743                                 path,
1744                                 &clientPath))
1745         {
1746                 goto err;
1747         }
1748
1749         status = SMB_VFS_NEXT_READLINK(handle, clientPath, buf, bufsiz);
1750 err:
1751         TALLOC_FREE(clientPath);
1752 out:
1753         return status;
1754 }
1755
1756 /*
1757  * Success: return 0
1758  * Failure: set errno, return -1
1759  */
1760 static int mh_link(vfs_handle_struct *handle,
1761                 const char *oldpath,
1762                 const char *newpath)
1763 {
1764         int status;
1765
1766         DEBUG(MH_INFO_DEBUG, ("Entering mh_link\n"));
1767         if (!is_in_media_files(oldpath) && !is_in_media_files(newpath))
1768         {
1769                 status = SMB_VFS_NEXT_LINK(handle, oldpath, newpath);
1770                 goto out;
1771         }
1772
1773         char *oldClientPath = NULL;
1774         char *newClientPath = NULL;
1775         TALLOC_CTX *ctx = talloc_tos();
1776
1777         if (status = alloc_get_client_path(handle, ctx,
1778                                 oldpath,
1779                                 &oldClientPath))
1780         {
1781                 goto err;
1782         }
1783
1784         if (status = alloc_get_client_path(handle, ctx,
1785                                 newpath,
1786                                 &newClientPath))
1787         {
1788                 goto err;
1789         }
1790
1791         status = SMB_VFS_NEXT_LINK(handle, oldClientPath, newClientPath);
1792 err:
1793         TALLOC_FREE(newClientPath);
1794         TALLOC_FREE(oldClientPath);
1795 out:
1796         return status;
1797 }
1798
1799 /*
1800  * Success: return 0
1801  * Failure: set errno, return -1
1802  */
1803 static int mh_mknod(vfs_handle_struct *handle,
1804                 const char *pathname,
1805                 mode_t mode,
1806                 SMB_DEV_T dev)
1807 {
1808         int status;
1809
1810         DEBUG(MH_INFO_DEBUG, ("Entering mh_mknod\n"));
1811         if (!is_in_media_files(pathname))
1812         {
1813                 status = SMB_VFS_NEXT_MKNOD(handle, pathname, mode, dev);
1814                 goto out;
1815         }
1816
1817         char *clientPath = NULL;
1818         TALLOC_CTX *ctx = talloc_tos();
1819
1820         if (status = alloc_get_client_path(handle, ctx,
1821                                 pathname,
1822                                 &clientPath))
1823         {
1824                 goto err;
1825         }
1826
1827         status = SMB_VFS_NEXT_MKNOD(handle, clientPath, mode, dev);
1828 err:
1829         TALLOC_FREE(clientPath);
1830 out:
1831         return status;
1832 }
1833
1834 /*
1835  * Success: return path pointer
1836  * Failure: set errno, return NULL pointer
1837  */
1838 static char *mh_realpath(vfs_handle_struct *handle,
1839                 const char *path)
1840 {
1841         char *buf;
1842
1843         DEBUG(MH_INFO_DEBUG, ("Entering mh_realpath\n"));
1844         if (!is_in_media_files(path))
1845         {
1846                 buf = SMB_VFS_NEXT_REALPATH(handle, path);
1847                 goto out;
1848         }
1849
1850         char *clientPath = NULL;
1851         TALLOC_CTX *ctx = talloc_tos();
1852
1853         if (alloc_get_client_path(handle, ctx,
1854                                 path,
1855                                 &clientPath))
1856         {
1857                 buf = NULL;
1858                 goto err;
1859         }
1860
1861         buf = SMB_VFS_NEXT_REALPATH(handle, clientPath);
1862 err:
1863         TALLOC_FREE(clientPath);
1864 out:
1865         return buf;
1866 }
1867
1868 /*
1869  * Success: return 0
1870  * Failure: set errno, return -1
1871  */
1872 static int mh_chflags(vfs_handle_struct *handle,
1873                 const char *path,
1874                 unsigned int flags)
1875 {
1876         int status;
1877
1878         DEBUG(MH_INFO_DEBUG, ("Entering mh_chflags\n"));
1879         if (!is_in_media_files(path))
1880         {
1881                 status = SMB_VFS_NEXT_CHFLAGS(handle, path, flags);
1882                 goto out;
1883         }
1884
1885         char *clientPath = NULL;
1886         TALLOC_CTX *ctx = talloc_tos();
1887
1888         if (status = alloc_get_client_path(handle, ctx,
1889                                 path,
1890                                 &clientPath))
1891         {
1892                 goto err;
1893         }
1894
1895         status = SMB_VFS_NEXT_CHFLAGS(handle, clientPath, flags);
1896 err:
1897         TALLOC_FREE(clientPath);
1898 out:
1899         return status;
1900 }
1901
1902 /*
1903  * Success: return NT_STATUS_OK
1904  * Failure: return NT status error
1905  */
1906 static NTSTATUS mh_streaminfo(struct vfs_handle_struct *handle,
1907                 struct files_struct *fsp,
1908                 const char *fname,
1909                 TALLOC_CTX *ctx,
1910                 unsigned int *num_streams,
1911                 struct stream_struct **streams)
1912 {
1913         NTSTATUS status;
1914
1915         DEBUG(MH_INFO_DEBUG, ("Entering mh_streaminfo\n"));
1916         if (!is_in_media_files(fname))
1917         {
1918                 status = SMB_VFS_NEXT_STREAMINFO(handle, fsp, fname,
1919                                 ctx, num_streams, streams);
1920                 goto out;
1921         }
1922
1923         char *clientPath = NULL;
1924         TALLOC_CTX *mem_ctx = talloc_tos();
1925
1926         if (alloc_get_client_path(handle, mem_ctx,
1927                                 fname,
1928                                 &clientPath))
1929         {
1930                 status = map_nt_error_from_unix(errno);
1931                 goto err;
1932         }
1933
1934         /* This only works on files, so we don't have to worry about
1935          * our fake directory stat'ing here.
1936          */
1937         // But what does this function do, exactly?  Does it need
1938         // extra modifications for the Avid stuff?
1939         status = SMB_VFS_NEXT_STREAMINFO(handle, fsp, clientPath,
1940                                 ctx, num_streams, streams);
1941 err:
1942         TALLOC_FREE(clientPath);
1943 out:
1944         return status;
1945 }
1946
1947 /* Ignoring get_real_filename function because the default
1948  * doesn't do anything.
1949  */
1950
1951 /*
1952  * Success: return NT_STATUS_OK
1953  * Failure: return NT status error
1954  * In this case, "name" is a path.
1955  */
1956 static NTSTATUS mh_get_nt_acl(vfs_handle_struct *handle,
1957                 const char *name,
1958                 uint32 security_info,
1959                 struct security_descriptor **ppdesc)
1960 {
1961         NTSTATUS status;
1962
1963         DEBUG(MH_INFO_DEBUG, ("Entering mh_get_nt_acl\n"));
1964         if (!is_in_media_files(name))
1965         {
1966                 status = SMB_VFS_NEXT_GET_NT_ACL(handle, name,
1967                                 security_info, ppdesc);
1968                 goto out;
1969         }
1970
1971         char *clientPath = NULL;
1972         TALLOC_CTX *ctx = talloc_tos();
1973
1974         if (alloc_get_client_path(handle, ctx,
1975                                 name,
1976                                 &clientPath))
1977         {
1978                 status = map_nt_error_from_unix(errno);
1979                 goto err;
1980         }
1981
1982         status = SMB_VFS_NEXT_GET_NT_ACL(handle, clientPath,
1983                         security_info, ppdesc);
1984 err:
1985         TALLOC_FREE(clientPath);
1986 out:
1987         return status;
1988 }
1989
1990 /*
1991  * Success: return 0
1992  * Failure: set errno, return -1
1993  */
1994 static int mh_chmod_acl(vfs_handle_struct *handle,
1995                 const char *path,
1996                 mode_t mode)
1997 {
1998         int status;
1999
2000         DEBUG(MH_INFO_DEBUG, ("Entering mh_chmod_acl\n"));
2001         if (!is_in_media_files(path))
2002         {
2003                 status = SMB_VFS_NEXT_CHMOD_ACL(handle, path, mode);
2004                 goto out;
2005         }
2006
2007         char *clientPath = NULL;
2008         TALLOC_CTX *ctx = talloc_tos();
2009
2010         if (status = alloc_get_client_path(handle, ctx,
2011                                 path,
2012                                 &clientPath))
2013         {
2014                 goto err;
2015         }
2016
2017         status = SMB_VFS_NEXT_CHMOD_ACL(handle, clientPath, mode);
2018 err:
2019         TALLOC_FREE(clientPath);
2020 out:
2021         return status;
2022 }
2023
2024 /*
2025  * Success: return acl pointer
2026  * Failure: set errno, return NULL
2027  */
2028 static SMB_ACL_T mh_sys_acl_get_file(vfs_handle_struct *handle,
2029                 const char *path_p,
2030                 SMB_ACL_TYPE_T type)
2031 {
2032         SMB_ACL_T ret;
2033
2034         DEBUG(MH_INFO_DEBUG, ("Entering mh_sys_acl_get_file\n"));
2035         if (!is_in_media_files(path_p))
2036         {
2037                 ret = SMB_VFS_NEXT_SYS_ACL_GET_FILE(handle, path_p, type);
2038                 goto out;
2039         }
2040
2041         char *clientPath = NULL;
2042         TALLOC_CTX *ctx = talloc_tos();
2043
2044         if (alloc_get_client_path(handle, ctx,
2045                                 path_p,
2046                                 &clientPath))
2047         {
2048                 ret = NULL;
2049                 goto err;
2050         }
2051
2052         ret = SMB_VFS_NEXT_SYS_ACL_GET_FILE(handle, clientPath, type);
2053 err:
2054         TALLOC_FREE(clientPath);
2055 out:
2056         return ret;
2057 }
2058
2059 /*
2060  * Success: return 0
2061  * Failure: set errno, return -1
2062  * In this case, "name" is a path.
2063  */
2064 static int mh_sys_acl_set_file(vfs_handle_struct *handle,
2065                 const char *name,
2066                 SMB_ACL_TYPE_T acltype,
2067                 SMB_ACL_T theacl)
2068 {
2069         int status;
2070
2071         DEBUG(MH_INFO_DEBUG, ("Entering mh_sys_acl_set_file\n"));
2072         if (!is_in_media_files(name))
2073         {
2074                 status = SMB_VFS_NEXT_SYS_ACL_SET_FILE(handle, name,
2075                                 acltype, theacl);
2076                 goto out;
2077         }
2078
2079         char *clientPath = NULL;
2080         TALLOC_CTX *ctx = talloc_tos();
2081
2082         if (status = alloc_get_client_path(handle, ctx,
2083                                 name,
2084                                 &clientPath))
2085         {
2086                 goto err;
2087         }
2088
2089         status = SMB_VFS_NEXT_SYS_ACL_SET_FILE(handle, clientPath,
2090                         acltype, theacl);
2091 err:
2092         TALLOC_FREE(clientPath);
2093 out:
2094         return status;
2095 }
2096
2097 /*
2098  * Success: return 0
2099  * Failure: set errno, return -1
2100  */
2101 static int mh_sys_acl_delete_def_file(vfs_handle_struct *handle,
2102                 const char *path)
2103 {
2104         int status;
2105
2106         DEBUG(MH_INFO_DEBUG, ("Entering mh_sys_acl_delete_def_file\n"));
2107         if (!is_in_media_files(path))
2108         {
2109                 status = SMB_VFS_NEXT_SYS_ACL_DELETE_DEF_FILE(handle,
2110                                 path);
2111                 goto out;
2112         }
2113
2114         char *clientPath = NULL;
2115         TALLOC_CTX *ctx = talloc_tos();
2116
2117         if (status = alloc_get_client_path(handle, ctx,
2118                                 path,
2119                                 &clientPath))
2120         {
2121                 goto err;
2122         }
2123
2124         status = SMB_VFS_NEXT_SYS_ACL_DELETE_DEF_FILE(handle, clientPath);
2125 err:
2126         TALLOC_FREE(clientPath);
2127 out:
2128         return status;
2129 }
2130
2131 /*
2132  * Success: return positive number
2133  * Failure: set errno, return -1
2134  * In this case, "name" is an attr name.
2135  */
2136 static ssize_t mh_getxattr(struct vfs_handle_struct *handle,
2137                 const char *path,
2138                 const char *name,
2139                 void *value,
2140                 size_t size)
2141 {
2142         ssize_t ret;
2143
2144         DEBUG(MH_INFO_DEBUG, ("Entering mh_getxattr\n"));
2145         if (!is_in_media_files(path))
2146         {
2147                 ret = SMB_VFS_NEXT_GETXATTR(handle, path, name, value,
2148                                 size);
2149                 goto out;
2150         }
2151
2152         char *clientPath = NULL;
2153         TALLOC_CTX *ctx = talloc_tos();
2154
2155         if (alloc_get_client_path(handle, ctx,
2156                                 path,
2157                                 &clientPath))
2158         {
2159                 ret = -1;
2160                 goto err;
2161         }
2162
2163         ret = SMB_VFS_NEXT_GETXATTR(handle, clientPath, name, value, size);
2164 err:
2165         TALLOC_FREE(clientPath);
2166 out:
2167         return ret;
2168 }
2169
2170 /*
2171  * Success: return positive number
2172  * Failure: set errno, return -1
2173  */
2174 static ssize_t mh_listxattr(struct vfs_handle_struct *handle,
2175                 const char *path,
2176                 char *list,
2177                 size_t size)
2178 {
2179         ssize_t ret;
2180
2181         DEBUG(MH_INFO_DEBUG, ("Entering mh_listxattr\n"));
2182         if (!is_in_media_files(path))
2183         {
2184                 ret = SMB_VFS_NEXT_LISTXATTR(handle, path, list, size);
2185                 goto out;
2186         }
2187
2188         char *clientPath = NULL;
2189         TALLOC_CTX *ctx = talloc_tos();
2190
2191         if (alloc_get_client_path(handle, ctx,
2192                                 path,
2193                                 &clientPath))
2194         {
2195                 ret = -1;
2196                 goto err;
2197         }
2198
2199         ret = SMB_VFS_NEXT_LISTXATTR(handle, clientPath, list, size);
2200 err:
2201         TALLOC_FREE(clientPath);
2202 out:
2203         return ret;
2204 }
2205
2206 /*
2207  * Success: return 0
2208  * Failure: set errno, return -1
2209  * In this case, "name" is an attr name.
2210  */
2211 static int mh_removexattr(struct vfs_handle_struct *handle,
2212                 const char *path,
2213                 const char *name)
2214 {
2215         int status;
2216
2217         DEBUG(MH_INFO_DEBUG, ("Entering mh_removexattr\n"));
2218         if (!is_in_media_files(path))
2219         {
2220                 status = SMB_VFS_NEXT_REMOVEXATTR(handle, path, name);
2221                 goto out;
2222         }
2223
2224         char *clientPath = NULL;
2225         TALLOC_CTX *ctx = talloc_tos();
2226
2227         if (status = alloc_get_client_path(handle, ctx,
2228                                 path,
2229                                 &clientPath))
2230         {
2231                 goto err;
2232         }
2233
2234         status = SMB_VFS_NEXT_REMOVEXATTR(handle, clientPath, name);
2235 err:
2236         TALLOC_FREE(clientPath);
2237 out:
2238         return status;
2239 }
2240
2241 /*
2242  * Success: return 0
2243  * Failure: set errno, return -1
2244  * In this case, "name" is an attr name.
2245  */
2246 static int mh_setxattr(struct vfs_handle_struct *handle,
2247                 const char *path,
2248                 const char *name,
2249                 const void *value,
2250                 size_t size,
2251                 int flags)
2252 {
2253         int status;
2254
2255         DEBUG(MH_INFO_DEBUG, ("Entering mh_setxattr\n"));
2256         if (!is_in_media_files(path))
2257         {
2258                 status = SMB_VFS_NEXT_SETXATTR(handle, path, name, value,
2259                                 size, flags);
2260                 goto out;
2261         }
2262
2263         char *clientPath = NULL;
2264         TALLOC_CTX *ctx = talloc_tos();
2265
2266         if (status = alloc_get_client_path(handle, ctx,
2267                                 path,
2268                                 &clientPath))
2269         {
2270                 goto err;
2271         }
2272
2273         status = SMB_VFS_NEXT_SETXATTR(handle, clientPath, name, value,
2274                         size, flags);
2275 err:
2276         TALLOC_FREE(clientPath);
2277 out:
2278         return status;
2279 }
2280
2281 /*
2282  * Success: return true
2283  * Failure: set errno, return false
2284  */
2285 static bool mh_is_offline(struct vfs_handle_struct *handle,
2286                 const struct smb_filename *fname,
2287                 SMB_STRUCT_STAT *sbuf)
2288 {
2289         // check if sbuf is modified further down the chain.
2290         bool ret;
2291
2292         DEBUG(MH_INFO_DEBUG, ("Entering mh_is_offline\n"));
2293         if (!is_in_media_files(fname->base_name))
2294         {
2295                 ret = SMB_VFS_NEXT_IS_OFFLINE(handle, fname, sbuf);
2296                 goto out;
2297         }
2298
2299         struct smb_filename *clientFname = NULL;
2300         TALLOC_CTX *ctx = talloc_tos();
2301
2302         if(alloc_get_client_smb_fname(handle, ctx,
2303                                 fname,
2304                                 &clientFname))
2305         {
2306                 ret = -1;
2307                 goto err;
2308         }
2309
2310         ret = SMB_VFS_NEXT_IS_OFFLINE(handle, clientFname, sbuf);
2311 err:
2312         TALLOC_FREE(clientFname);
2313 out:
2314         return ret;
2315 }
2316
2317 /*
2318  * Success: return 0 (?)
2319  * Failure: set errno, return -1
2320  */
2321 static int mh_set_offline(struct vfs_handle_struct *handle,
2322                 const struct smb_filename *fname)
2323 {
2324         int status;
2325
2326         DEBUG(MH_INFO_DEBUG, ("Entering mh_set_offline\n"));
2327         if (!is_in_media_files(fname->base_name))
2328         {
2329                 status = SMB_VFS_NEXT_SET_OFFLINE(handle, fname);
2330                 goto out;
2331         }
2332
2333         struct smb_filename *clientFname = NULL;
2334         TALLOC_CTX *ctx = talloc_tos();
2335
2336         if (status = alloc_get_client_smb_fname(handle, ctx,
2337                                 fname,
2338                                 &clientFname))
2339         {
2340                 goto err;
2341         }
2342
2343         status = SMB_VFS_NEXT_SET_OFFLINE(handle, clientFname);
2344 err:
2345         TALLOC_FREE(clientFname);
2346 out:
2347         return status;
2348 }
2349
2350 /* VFS operations structure */
2351
2352 static struct vfs_fn_pointers vfs_mh_fns = {
2353         /* Disk operations */
2354
2355         .statvfs_fn = mh_statvfs,
2356
2357         /* Directory operations */
2358
2359         .opendir_fn = mh_opendir,
2360         .fdopendir_fn = mh_fdopendir,
2361         .readdir_fn = mh_readdir,
2362         .seekdir_fn = mh_seekdir,
2363         .telldir_fn = mh_telldir,
2364         .rewind_dir_fn = mh_rewinddir,
2365         .mkdir_fn = mh_mkdir,
2366         .rmdir_fn = mh_rmdir,
2367         .closedir_fn = mh_closedir,
2368         .init_search_op_fn = mh_init_search_op,
2369
2370         /* File operations */
2371
2372         .open_fn = mh_open,
2373         .create_file_fn = mh_create_file,
2374         .rename_fn = mh_rename,
2375         .stat_fn = mh_stat,
2376         .lstat_fn = mh_lstat,
2377         .fstat_fn = mh_fstat,
2378         .unlink_fn = mh_unlink,
2379         .chmod_fn = mh_chmod,
2380         .chown_fn = mh_chown,
2381         .lchown_fn = mh_lchown,
2382         .chdir_fn = mh_chdir,
2383         .ntimes_fn = mh_ntimes,
2384         .symlink_fn = mh_symlink,
2385         .readlink_fn = mh_readlink,
2386         .link_fn = mh_link,
2387         .mknod_fn = mh_mknod,
2388         .realpath_fn = mh_realpath,
2389         .chflags_fn = mh_chflags,
2390         .streaminfo_fn = mh_streaminfo,
2391
2392         /* NT ACL operations. */
2393
2394         .get_nt_acl_fn = mh_get_nt_acl,
2395
2396         /* POSIX ACL operations. */
2397
2398         .chmod_acl_fn = mh_chmod_acl,
2399
2400         .sys_acl_get_file_fn = mh_sys_acl_get_file,
2401         .sys_acl_set_file_fn = mh_sys_acl_set_file,
2402         .sys_acl_delete_def_file_fn = mh_sys_acl_delete_def_file,
2403
2404         /* EA operations. */
2405         .getxattr_fn = mh_getxattr,
2406         .listxattr_fn = mh_listxattr,
2407         .removexattr_fn = mh_removexattr,
2408         .setxattr_fn = mh_setxattr,
2409
2410         /* aio operations */
2411
2412         /* offline operations */
2413         .is_offline_fn = mh_is_offline,
2414         .set_offline_fn = mh_set_offline
2415 };
2416
2417 NTSTATUS vfs_media_harmony_init(void);
2418 NTSTATUS vfs_media_harmony_init(void)
2419 {
2420         NTSTATUS ret = smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
2421                                 "media_harmony", &vfs_mh_fns);
2422         if (!NT_STATUS_IS_OK(ret))
2423         {
2424                 goto out;
2425         }
2426
2427         vfs_mh_debug_level = debug_add_class("media_harmony");
2428
2429         if (vfs_mh_debug_level == -1) {
2430                 vfs_mh_debug_level = DBGC_VFS;
2431                 DEBUG(1, ("media_harmony_init: Couldn't register custom "
2432                                 "debugging class.\n"));
2433         } else {
2434                 DEBUG(3, ("media_harmony_init: Debug class number of "
2435                                 "'media_harmony': %d\n",
2436                                 vfs_mh_debug_level));
2437         }
2438
2439 out:
2440         return ret;
2441 }