source3/modules/vfs_unityed_media.c

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