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                                struct smb_filename *smb_fname,
 830                                uint32_t access_mask,
 831                                uint32_t share_access,
 832                                uint32_t create_disposition,
 833                                uint32_t create_options,
 834                                uint32_t file_attributes,
 835                                uint32_t oplock_request,
 836                                const struct smb2_lease *lease,
 837                                uint64_t allocation_size,
 838                                uint32_t private_flags,
 839                                struct security_descriptor *sd,
 840                                struct ea_list *ea_list,
 841                                files_struct **result_fsp,
 842                                int *pinfo,
 843                                const struct smb2_create_blobs *in_context_blobs,
 844                                struct smb2_create_blobs *out_context_blobs)
 845 {
 846         NTSTATUS status;
 847         struct smb_filename *client_fname = NULL;
 848
 849         DEBUG(10, ("Entering with smb_fname->base_name '%s'\n",
 850                    smb_fname->base_name));
 851
 852         if (!is_in_media_files(smb_fname->base_name)) {
 853                 return SMB_VFS_NEXT_CREATE_FILE(
 854                         handle,
 855                         req,
 856                         smb_fname,
 857                         access_mask,
 858                         share_access,
 859                         create_disposition,
 860                         create_options,
 861                         file_attributes,
 862                         oplock_request,
 863                         lease,
 864                         allocation_size,
 865                         private_flags,
 866                         sd,
 867                         ea_list,
 868                         result_fsp,
 869                         pinfo,
 870                         in_context_blobs,
 871                         out_context_blobs);
 872         }
 873
 874         if (alloc_get_client_smb_fname(handle, talloc_tos(),
 875                                        smb_fname,
 876                                        &client_fname)) {
 877                 status = map_nt_error_from_unix(errno);
 878                 goto err;
 879         }
 880
 881         /*
 882          * FIXME:
 883          * This only creates files, so we don't have to worry about
 884          * our fake directory stat'ing here.  But we still need to
 885          * route stat calls for DB files properly, right?
 886          */
 887         status = SMB_VFS_NEXT_CREATE_FILE(
 888                 handle,
 889                 req,
 890                 client_fname,
 891                 access_mask,
 892                 share_access,
 893                 create_disposition,
 894                 create_options,
 895                 file_attributes,
 896                 oplock_request,
 897                 lease,
 898                 allocation_size,
 899                 private_flags,
 900                 sd,
 901                 ea_list,
 902                 result_fsp,
 903                 pinfo,
 904                 in_context_blobs,
 905                 out_context_blobs);
 906 err:
 907         TALLOC_FREE(client_fname);
 908         DEBUG(10, ("Leaving with smb_fname->base_name '%s'"
 909                    "smb_fname->st.st_ex_mtime %s"
 910                    " fsp->fsp_name->st.st_ex_mtime %s",
 911                    smb_fname->base_name,
 912                    ctime(&(smb_fname->st.st_ex_mtime.tv_sec)),
 913                    (*result_fsp) && VALID_STAT((*result_fsp)->fsp_name->st) ?
 914                    ctime(&((*result_fsp)->fsp_name->st.st_ex_mtime.tv_sec)) :
 915                    "No fsp time\n"));
 916         return status;
 917 }
 918
 919 static int um_renameat(vfs_handle_struct *handle,
 920                 files_struct *srcfsp,
 921                 const struct smb_filename *smb_fname_src,
 922                 files_struct *dstfsp,
 923                 const struct smb_filename *smb_fname_dst)
 924 {
 925         int status;
 926         struct smb_filename *src_client_fname = NULL;
 927         struct smb_filename *dst_client_fname = NULL;
 928
 929         DEBUG(10, ("Entering with "
 930                    "smb_fname_src->base_name '%s', "
 931                    "smb_fname_dst->base_name '%s'\n",
 932                    smb_fname_src->base_name,
 933                    smb_fname_dst->base_name));
 934
 935         if (!is_in_media_files(smb_fname_src->base_name)
 936             &&
 937             !is_in_media_files(smb_fname_dst->base_name)) {
 938                 return SMB_VFS_NEXT_RENAMEAT(handle,
 939                                         srcfsp,
 940                                         smb_fname_src,
 941                                         dstfsp,
 942                                         smb_fname_dst);
 943         }
 944
 945         status = alloc_get_client_smb_fname(handle, talloc_tos(),
 946                                             smb_fname_src,
 947                                             &src_client_fname);
 948         if (status != 0) {
 949                 goto err;
 950         }
 951
 952         status = alloc_get_client_smb_fname(handle, talloc_tos(),
 953                                             smb_fname_dst,
 954                                             &dst_client_fname);
 955
 956         if (status != 0) {
 957                 goto err;
 958         }
 959
 960         status = SMB_VFS_NEXT_RENAMEAT(handle,
 961                                 srcfsp,
 962                                 src_client_fname,
 963                                 dstfsp,
 964                                 dst_client_fname);
 965
 966 err:
 967         TALLOC_FREE(dst_client_fname);
 968         TALLOC_FREE(src_client_fname);
 969         DEBUG(10, ("Leaving with smb_fname_src->base_name '%s',"
 970                    " smb_fname_dst->base_name '%s'\n",
 971                    smb_fname_src->base_name,
 972                    smb_fname_dst->base_name));
 973         return status;
 974 }
 975
 976
 977 /*
 978  * Success: return 0
 979  * Failure: set errno, return -1
 980  */
 981 static int um_stat(vfs_handle_struct *handle,
 982                    struct smb_filename *smb_fname)
 983 {
 984         int status = 0;
 985         struct smb_filename *client_fname = NULL;
 986
 987         DEBUG(10, ("Entering with smb_fname->base_name '%s'\n",
 988                    smb_fname->base_name));
 989
 990         if (!is_in_media_files(smb_fname->base_name)) {
 991                 return SMB_VFS_NEXT_STAT(handle, smb_fname);
 992         }
 993
 994         status = alloc_get_client_smb_fname(handle, talloc_tos(),
 995                                             smb_fname,
 996                                             &client_fname);
 997         if (status != 0) {
 998                 goto err;
 999         }
1000         DEBUG(10, ("Stat'ing client_fname->base_name '%s'\n",
1001                    client_fname->base_name));
1002
1003         status = SMB_VFS_NEXT_STAT(handle, client_fname);
1004         if (status != 0) {
1005                 goto err;
1006         }
1007
1008         /*
1009          * Unlike functions with const smb_filename, we have to modify
1010          * smb_fname itself to pass our info back up.
1011          */
1012         DEBUG(10, ("Setting smb_fname '%s' stat from client_fname '%s'\n",
1013                    smb_fname->base_name, client_fname->base_name));
1014         smb_fname->st = client_fname->st;
1015
1016 err:
1017         TALLOC_FREE(client_fname);
1018         DEBUG(10, ("Leaving with smb_fname->st.st_ex_mtime %s",
1019                    ctime(&(smb_fname->st.st_ex_mtime.tv_sec))));
1020         return status;
1021 }
1022
1023 static int um_lstat(vfs_handle_struct *handle,
1024                     struct smb_filename *smb_fname)
1025 {
1026         int status = 0;
1027         struct smb_filename *client_fname = NULL;
1028
1029         DEBUG(10, ("Entering with smb_fname->base_name '%s'\n",
1030                    smb_fname->base_name));
1031
1032         if (!is_in_media_files(smb_fname->base_name)) {
1033                 return SMB_VFS_NEXT_LSTAT(handle, smb_fname);
1034         }
1035
1036         client_fname = NULL;
1037
1038         status = alloc_get_client_smb_fname(handle, talloc_tos(),
1039                                             smb_fname,
1040                                             &client_fname);
1041         if (status != 0) {
1042                 goto err;
1043         }
1044         status = SMB_VFS_NEXT_LSTAT(handle, client_fname);
1045         if (status != 0) {
1046                 goto err;
1047         }
1048
1049         smb_fname->st = client_fname->st;
1050
1051 err:
1052         TALLOC_FREE(client_fname);
1053         DEBUG(10, ("Leaving with smb_fname->st.st_ex_mtime %s",
1054                    ctime(&(smb_fname->st.st_ex_mtime.tv_sec))));
1055         return status;
1056 }
1057
1058 static int um_fstat(vfs_handle_struct *handle,
1059                     files_struct *fsp, SMB_STRUCT_STAT *sbuf)
1060 {
1061         int status = 0;
1062
1063         DEBUG(10, ("Entering with fsp->fsp_name->base_name "
1064                    "'%s'\n", fsp_str_dbg(fsp)));
1065
1066         status = SMB_VFS_NEXT_FSTAT(handle, fsp, sbuf);
1067         if (status != 0) {
1068                 goto out;
1069         }
1070
1071         if ((fsp->fsp_name == NULL) ||
1072             !is_in_media_files(fsp->fsp_name->base_name)) {
1073                 goto out;
1074         }
1075
1076         status = um_stat(handle, fsp->fsp_name);
1077         if (status != 0) {
1078                 goto out;
1079         }
1080
1081         *sbuf = fsp->fsp_name->st;
1082
1083 out:
1084         DEBUG(10, ("Leaving with fsp->fsp_name->st.st_ex_mtime %s\n",
1085                    fsp->fsp_name != NULL ?
1086                    ctime(&(fsp->fsp_name->st.st_ex_mtime.tv_sec)) : "0"));
1087         return status;
1088 }
1089
1090 static int um_unlinkat(vfs_handle_struct *handle,
1091                         struct files_struct *dirfsp,
1092                         const struct smb_filename *smb_fname,
1093                         int flags)
1094 {
1095         int ret;
1096         struct smb_filename *client_fname = NULL;
1097
1098         DEBUG(10, ("Entering um_unlinkat\n"));
1099
1100         if (!is_in_media_files(smb_fname->base_name)) {
1101                 return SMB_VFS_NEXT_UNLINKAT(handle,
1102                                 dirfsp,
1103                                 smb_fname,
1104                                 flags);
1105         }
1106
1107         ret = alloc_get_client_smb_fname(handle, talloc_tos(),
1108                                             smb_fname,
1109                                             &client_fname);
1110         if (ret != 0) {
1111                 goto err;
1112         }
1113
1114         ret = SMB_VFS_NEXT_UNLINKAT(handle,
1115                                 dirfsp,
1116                                 client_fname,
1117                                 flags);
1118
1119 err:
1120         TALLOC_FREE(client_fname);
1121         return ret;
1122 }
1123
1124 static int um_chmod(vfs_handle_struct *handle,
1125                         const struct smb_filename *smb_fname,
1126                         mode_t mode)
1127 {
1128         int status;
1129         struct smb_filename *client_fname = NULL;
1130
1131         DEBUG(10, ("Entering um_chmod\n"));
1132
1133         if (!is_in_media_files(smb_fname->base_name)) {
1134                 return SMB_VFS_NEXT_CHMOD(handle, smb_fname, mode);
1135         }
1136
1137         status = alloc_get_client_smb_fname(handle,
1138                                 talloc_tos(),
1139                                 smb_fname,
1140                                 &client_fname);
1141         if (status != 0) {
1142                 goto err;
1143         }
1144
1145         status = SMB_VFS_NEXT_CHMOD(handle, client_fname, mode);
1146
1147 err:
1148         TALLOC_FREE(client_fname);
1149         return status;
1150 }
1151
1152 static int um_lchown(vfs_handle_struct *handle,
1153                         const struct smb_filename *smb_fname,
1154                         uid_t uid,
1155                         gid_t gid)
1156 {
1157         int status;
1158         struct smb_filename *client_fname = NULL;
1159
1160         DEBUG(10, ("Entering um_lchown\n"));
1161         if (!is_in_media_files(smb_fname->base_name)) {
1162                 return SMB_VFS_NEXT_LCHOWN(handle, smb_fname, uid, gid);
1163         }
1164
1165         status = alloc_get_client_smb_fname(handle,
1166                                 talloc_tos(),
1167                                 smb_fname,
1168                                 &client_fname);
1169         if (status != 0) {
1170                 goto err;
1171         }
1172
1173         status = SMB_VFS_NEXT_LCHOWN(handle, client_fname, uid, gid);
1174
1175 err:
1176         TALLOC_FREE(client_fname);
1177         return status;
1178 }
1179
1180 static int um_chdir(vfs_handle_struct *handle,
1181                         const struct smb_filename *smb_fname)
1182 {
1183         int status;
1184         struct smb_filename *client_fname = NULL;
1185
1186         DEBUG(10, ("Entering um_chdir\n"));
1187
1188         if (!is_in_media_files(smb_fname->base_name)) {
1189                 return SMB_VFS_NEXT_CHDIR(handle, smb_fname);
1190         }
1191
1192         status = alloc_get_client_smb_fname(handle,
1193                                 talloc_tos(),
1194                                 smb_fname,
1195                                 &client_fname);
1196         if (status != 0) {
1197                 goto err;
1198         }
1199
1200         status = SMB_VFS_NEXT_CHDIR(handle, client_fname);
1201
1202 err:
1203         TALLOC_FREE(client_fname);
1204         return status;
1205 }
1206
1207 static int um_ntimes(vfs_handle_struct *handle,
1208                      const struct smb_filename *smb_fname,
1209                      struct smb_file_time *ft)
1210 {
1211         int status;
1212         struct smb_filename *client_fname = NULL;
1213
1214         DEBUG(10, ("Entering um_ntimes\n"));
1215
1216         if (!is_in_media_files(smb_fname->base_name)) {
1217                 return SMB_VFS_NEXT_NTIMES(handle, smb_fname, ft);
1218         }
1219
1220         status = alloc_get_client_smb_fname(handle, talloc_tos(),
1221                                             smb_fname, &client_fname);
1222         if (status != 0) {
1223                 goto err;
1224         }
1225
1226         status = SMB_VFS_NEXT_NTIMES(handle, client_fname, ft);
1227
1228 err:
1229         TALLOC_FREE(client_fname);
1230         return status;
1231 }
1232
1233 static int um_symlinkat(vfs_handle_struct *handle,
1234                         const struct smb_filename *link_contents,
1235                         struct files_struct *dirfsp,
1236                         const struct smb_filename *new_smb_fname)
1237 {
1238         int status;
1239         struct smb_filename *new_link_target = NULL;
1240         struct smb_filename *new_client_fname = NULL;
1241
1242         DEBUG(10, ("Entering um_symlinkat\n"));
1243
1244         if (!is_in_media_files(link_contents->base_name) &&
1245                         !is_in_media_files(new_smb_fname->base_name)) {
1246                 return SMB_VFS_NEXT_SYMLINKAT(handle,
1247                                 link_contents,
1248                                 dirfsp,
1249                                 new_smb_fname);
1250         }
1251
1252         status = alloc_get_client_smb_fname(handle, talloc_tos(),
1253                                 link_contents, &new_link_target);
1254         if (status != 0) {
1255                 goto err;
1256         }
1257         status = alloc_get_client_smb_fname(handle, talloc_tos(),
1258                                             new_smb_fname, &new_client_fname);
1259         if (status != 0) {
1260                 goto err;
1261         }
1262
1263         status = SMB_VFS_NEXT_SYMLINKAT(handle,
1264                                         new_link_target,
1265                                         dirfsp,
1266                                         new_client_fname);
1267
1268 err:
1269         TALLOC_FREE(new_link_target);
1270         TALLOC_FREE(new_client_fname);
1271         return status;
1272 }
1273
1274 static int um_readlinkat(vfs_handle_struct *handle,
1275                         files_struct *dirfsp,
1276                         const struct smb_filename *smb_fname,
1277                         char *buf,
1278                         size_t bufsiz)
1279 {
1280         int status;
1281         struct smb_filename *client_fname = NULL;
1282
1283         DEBUG(10, ("Entering um_readlinkat\n"));
1284
1285         if (!is_in_media_files(smb_fname->base_name)) {
1286                 return SMB_VFS_NEXT_READLINKAT(handle,
1287                                 dirfsp,
1288                                 smb_fname,
1289                                 buf,
1290                                 bufsiz);
1291         }
1292
1293         status = alloc_get_client_smb_fname(handle, talloc_tos(),
1294                                             smb_fname, &client_fname);
1295         if (status != 0) {
1296                 goto err;
1297         }
1298
1299         status = SMB_VFS_NEXT_READLINKAT(handle,
1300                                 dirfsp,
1301                                 client_fname,
1302                                 buf,
1303                                 bufsiz);
1304
1305 err:
1306         TALLOC_FREE(client_fname);
1307         return status;
1308 }
1309
1310 static int um_linkat(vfs_handle_struct *handle,
1311                         files_struct *srcfsp,
1312                         const struct smb_filename *old_smb_fname,
1313                         files_struct *dstfsp,
1314                         const struct smb_filename *new_smb_fname,
1315                         int flags)
1316 {
1317         int status;
1318         struct smb_filename *old_client_fname = NULL;
1319         struct smb_filename *new_client_fname = NULL;
1320
1321         DEBUG(10, ("Entering um_linkat\n"));
1322         if (!is_in_media_files(old_smb_fname->base_name) &&
1323                                 !is_in_media_files(new_smb_fname->base_name)) {
1324                 return SMB_VFS_NEXT_LINKAT(handle,
1325                                 srcfsp,
1326                                 old_smb_fname,
1327                                 dstfsp,
1328                                 new_smb_fname,
1329                                 flags);
1330         }
1331
1332         status = alloc_get_client_smb_fname(handle, talloc_tos(),
1333                                             old_smb_fname, &old_client_fname);
1334         if (status != 0) {
1335                 goto err;
1336         }
1337         status = alloc_get_client_smb_fname(handle, talloc_tos(),
1338                                             new_smb_fname, &new_client_fname);
1339         if (status != 0) {
1340                 goto err;
1341         }
1342
1343         status = SMB_VFS_NEXT_LINKAT(handle,
1344                                 srcfsp,
1345                                 old_client_fname,
1346                                 dstfsp,
1347                                 new_client_fname,
1348                                 flags);
1349
1350 err:
1351         TALLOC_FREE(old_client_fname);
1352         TALLOC_FREE(new_client_fname);
1353         return status;
1354 }
1355
1356 static int um_mknodat(vfs_handle_struct *handle,
1357                 files_struct *dirfsp,
1358                 const struct smb_filename *smb_fname,
1359                 mode_t mode,
1360                 SMB_DEV_T dev)
1361 {
1362         int status;
1363         struct smb_filename *client_fname = NULL;
1364
1365         DEBUG(10, ("Entering um_mknodat\n"));
1366         if (!is_in_media_files(smb_fname->base_name)) {
1367                 return SMB_VFS_NEXT_MKNODAT(handle,
1368                                 dirfsp,
1369                                 smb_fname,
1370                                 mode,
1371                                 dev);
1372         }
1373
1374         status = alloc_get_client_smb_fname(handle, talloc_tos(),
1375                                             smb_fname, &client_fname);
1376         if (status != 0) {
1377                 goto err;
1378         }
1379
1380         status = SMB_VFS_NEXT_MKNODAT(handle,
1381                         dirfsp,
1382                         client_fname,
1383                         mode,
1384                         dev);
1385
1386 err:
1387         TALLOC_FREE(client_fname);
1388         return status;
1389 }
1390
1391 static struct smb_filename *um_realpath(vfs_handle_struct *handle,
1392                                 TALLOC_CTX *ctx,
1393                                 const struct smb_filename *smb_fname)
1394 {
1395         struct smb_filename *client_fname = NULL;
1396         struct smb_filename *result_fname = NULL;
1397         int status;
1398
1399         DEBUG(10, ("Entering um_realpath\n"));
1400
1401         if (!is_in_media_files(smb_fname->base_name)) {
1402                 return SMB_VFS_NEXT_REALPATH(handle, ctx, smb_fname);
1403         }
1404
1405         status = alloc_get_client_smb_fname(handle, talloc_tos(),
1406                                             smb_fname, &client_fname);
1407         if (status != 0) {
1408                 goto err;
1409         }
1410
1411         result_fname = SMB_VFS_NEXT_REALPATH(handle, ctx, client_fname);
1412
1413 err:
1414         TALLOC_FREE(client_fname);
1415         return result_fname;
1416 }
1417
1418 static int um_chflags(vfs_handle_struct *handle,
1419                         const struct smb_filename *smb_fname,
1420                         unsigned int flags)
1421 {
1422         int status;
1423         struct smb_filename *client_fname = NULL;
1424
1425         DEBUG(10, ("Entering um_mknod\n"));
1426         if (!is_in_media_files(smb_fname->base_name)) {
1427                 return SMB_VFS_NEXT_CHFLAGS(handle, smb_fname, flags);
1428         }
1429
1430         status = alloc_get_client_smb_fname(handle, talloc_tos(),
1431                                             smb_fname, &client_fname);
1432         if (status != 0) {
1433                 goto err;
1434         }
1435
1436         status = SMB_VFS_NEXT_CHFLAGS(handle, client_fname, flags);
1437
1438 err:
1439         TALLOC_FREE(client_fname);
1440         return status;
1441 }
1442
1443 static NTSTATUS um_streaminfo(struct vfs_handle_struct *handle,
1444                               struct files_struct *fsp,
1445                               const struct smb_filename *smb_fname,
1446                               TALLOC_CTX *ctx,
1447                               unsigned int *num_streams,
1448                               struct stream_struct **streams)
1449 {
1450         NTSTATUS status;
1451         int ret;
1452         struct smb_filename *client_fname = NULL;
1453
1454         DEBUG(10, ("Entering um_streaminfo\n"));
1455
1456         if (!is_in_media_files(smb_fname->base_name)) {
1457                 return SMB_VFS_NEXT_STREAMINFO(handle, fsp, smb_fname,
1458                                                ctx, num_streams, streams);
1459         }
1460
1461         ret = alloc_get_client_smb_fname(handle,
1462                                 talloc_tos(),
1463                                 smb_fname,
1464                                 &client_fname);
1465         if (ret != 0) {
1466                 status = NT_STATUS_NO_MEMORY;
1467                 goto err;
1468         }
1469
1470         /*
1471          * This only works on files, so we don't have to worry about
1472          * our fake directory stat'ing here.  But what does this
1473          * function do, exactly?  Does it need extra modifications for
1474          * the Avid stuff?
1475          */
1476         status = SMB_VFS_NEXT_STREAMINFO(handle, fsp, client_fname,
1477                                          ctx, num_streams, streams);
1478 err:
1479         TALLOC_FREE(client_fname);
1480         return status;
1481 }
1482
1483 /*
1484  * Ignoring get_real_filename function because the default doesn't do
1485  * anything.
1486  */
1487
1488 static NTSTATUS um_get_nt_acl_at(vfs_handle_struct *handle,
1489                         struct files_struct *dirfsp,
1490                         const struct smb_filename *smb_fname,
1491                         uint32_t security_info,
1492                         TALLOC_CTX *mem_ctx,
1493                         struct security_descriptor **ppdesc)
1494 {
1495         NTSTATUS status;
1496         char *client_path = NULL;
1497         struct smb_filename *client_smb_fname = NULL;
1498         bool ok;
1499         int ret;
1500
1501         DBG_DEBUG("Entering um_get_nt_acl_at\n");
1502
1503         ok = is_in_media_files(smb_fname->base_name);
1504         if (!ok) {
1505                 return SMB_VFS_NEXT_GET_NT_ACL_AT(handle,
1506                                 dirfsp,
1507                                 smb_fname,
1508                                 security_info,
1509                                 mem_ctx,
1510                                 ppdesc);
1511         }
1512
1513         ret = alloc_get_client_path(handle,
1514                                 talloc_tos(),
1515                                 smb_fname->base_name,
1516                                 &client_path);
1517         if (ret != 0) {
1518                 status = map_nt_error_from_unix(errno);
1519                 goto err;
1520         }
1521
1522         client_smb_fname = synthetic_smb_fname(talloc_tos(),
1523                                         client_path,
1524                                         NULL,
1525                                         NULL,
1526                                         smb_fname->twrp,
1527                                         smb_fname->flags);
1528         if (client_smb_fname == NULL) {
1529                 TALLOC_FREE(client_path);
1530                 return NT_STATUS_NO_MEMORY;
1531         }
1532
1533         status = SMB_VFS_NEXT_GET_NT_ACL_AT(handle,
1534                                 dirfsp,
1535                                 client_smb_fname,
1536                                 security_info,
1537                                 mem_ctx,
1538                                 ppdesc);
1539 err:
1540         TALLOC_FREE(client_smb_fname);
1541         TALLOC_FREE(client_path);
1542         return status;
1543 }
1544
1545 static SMB_ACL_T um_sys_acl_get_file(vfs_handle_struct *handle,
1546                                 const struct smb_filename *smb_fname,
1547                                 SMB_ACL_TYPE_T type,
1548                                 TALLOC_CTX *mem_ctx)
1549 {
1550         SMB_ACL_T ret;
1551         int saved_errno = 0;
1552         struct smb_filename *client_fname = NULL;
1553         int status;
1554
1555         DEBUG(10, ("Entering um_sys_acl_get_file\n"));
1556
1557         if (!is_in_media_files(smb_fname->base_name)) {
1558                 return SMB_VFS_NEXT_SYS_ACL_GET_FILE(handle, smb_fname,
1559                                                      type, mem_ctx);
1560         }
1561
1562         status = alloc_get_client_smb_fname(handle,
1563                                 talloc_tos(),
1564                                 smb_fname,
1565                                 &client_fname);
1566         if (status != 0) {
1567                 ret = (SMB_ACL_T)NULL;
1568                 goto err;
1569         }
1570
1571         ret = SMB_VFS_NEXT_SYS_ACL_GET_FILE(handle, client_fname,
1572                                 type, mem_ctx);
1573
1574 err:
1575         if (ret == (SMB_ACL_T)NULL) {
1576                 saved_errno = errno;
1577         }
1578         TALLOC_FREE(client_fname);
1579         if (saved_errno != 0) {
1580                 errno = saved_errno;
1581         }
1582         return ret;
1583 }
1584
1585 static int um_sys_acl_set_file(vfs_handle_struct *handle,
1586                                const struct smb_filename *smb_fname,
1587                                SMB_ACL_TYPE_T acltype,
1588                                SMB_ACL_T theacl)
1589 {
1590         int status;
1591         int saved_errno = 0;
1592         struct smb_filename *client_fname = NULL;
1593
1594         DEBUG(10, ("Entering um_sys_acl_set_file\n"));
1595
1596         if (!is_in_media_files(smb_fname->base_name)) {
1597                 return SMB_VFS_NEXT_SYS_ACL_SET_FILE(handle, smb_fname,
1598                                                      acltype, theacl);
1599         }
1600
1601         status = alloc_get_client_smb_fname(handle,
1602                                 talloc_tos(),
1603                                 smb_fname,
1604                                 &client_fname);
1605         if (status != 0) {
1606                 goto err;
1607         }
1608
1609         status = SMB_VFS_NEXT_SYS_ACL_SET_FILE(handle, client_fname,
1610                                                acltype, theacl);
1611
1612 err:
1613         if (status == -1) {
1614                 saved_errno = errno;
1615         }
1616         TALLOC_FREE(client_fname);
1617         if (saved_errno != 0) {
1618                 errno = saved_errno;
1619         }
1620         return status;
1621 }
1622
1623 static int um_sys_acl_delete_def_file(vfs_handle_struct *handle,
1624                                 const struct smb_filename *smb_fname)
1625 {
1626         int status;
1627         int saved_errno = 0;
1628         struct smb_filename *client_fname = NULL;
1629
1630         DEBUG(10, ("Entering um_sys_acl_delete_def_file\n"));
1631
1632         if (!is_in_media_files(smb_fname->base_name)) {
1633                 return SMB_VFS_NEXT_SYS_ACL_DELETE_DEF_FILE(handle,
1634                                 smb_fname);
1635         }
1636
1637         status = alloc_get_client_smb_fname(handle,
1638                                 talloc_tos(),
1639                                 smb_fname,
1640                                 &client_fname);
1641         if (status != 0) {
1642                 goto err;
1643         }
1644
1645         status = SMB_VFS_NEXT_SYS_ACL_DELETE_DEF_FILE(handle, client_fname);
1646
1647 err:
1648         if (status == -1) {
1649                 saved_errno = errno;
1650         }
1651         TALLOC_FREE(client_fname);
1652         if (saved_errno != 0) {
1653                 errno = saved_errno;
1654         }
1655         return status;
1656 }
1657
1658 static ssize_t um_getxattr(struct vfs_handle_struct *handle,
1659                            const struct smb_filename *smb_fname,
1660                            const char *name,
1661                            void *value,
1662                            size_t size)
1663 {
1664         ssize_t ret;
1665         struct smb_filename *client_fname = NULL;
1666         int status;
1667
1668         DEBUG(10, ("Entering um_getxattr\n"));
1669         if (!is_in_media_files(smb_fname->base_name)) {
1670                 return SMB_VFS_NEXT_GETXATTR(handle, smb_fname,
1671                                 name, value, size);
1672         }
1673
1674         status = alloc_get_client_smb_fname(handle,
1675                                 talloc_tos(),
1676                                 smb_fname,
1677                                 &client_fname);
1678         if (status != 0) {
1679                 ret = -1;
1680                 goto err;
1681         }
1682
1683         ret = SMB_VFS_NEXT_GETXATTR(handle, client_fname, name, value, size);
1684 err:
1685         TALLOC_FREE(client_fname);
1686         return ret;
1687 }
1688
1689 static ssize_t um_listxattr(struct vfs_handle_struct *handle,
1690                             const struct smb_filename *smb_fname,
1691                             char *list,
1692                             size_t size)
1693 {
1694         ssize_t ret;
1695         struct smb_filename *client_fname = NULL;
1696         int status;
1697
1698         DEBUG(10, ("Entering um_listxattr\n"));
1699
1700         if (!is_in_media_files(smb_fname->base_name)) {
1701                 return SMB_VFS_NEXT_LISTXATTR(handle, smb_fname, list, size);
1702         }
1703
1704         status = alloc_get_client_smb_fname(handle,
1705                                 talloc_tos(),
1706                                 smb_fname,
1707                                 &client_fname);
1708         if (status != 0) {
1709                 ret = -1;
1710                 goto err;
1711         }
1712
1713         ret = SMB_VFS_NEXT_LISTXATTR(handle, client_fname, list, size);
1714
1715 err:
1716         TALLOC_FREE(client_fname);
1717         return ret;
1718 }
1719
1720 static int um_removexattr(struct vfs_handle_struct *handle,
1721                           const struct smb_filename *smb_fname,
1722                           const char *name)
1723 {
1724         int status;
1725         struct smb_filename *client_fname = NULL;
1726
1727         DEBUG(10, ("Entering um_removexattr\n"));
1728
1729         if (!is_in_media_files(smb_fname->base_name)) {
1730                 return SMB_VFS_NEXT_REMOVEXATTR(handle, smb_fname, name);
1731         }
1732
1733         status = alloc_get_client_smb_fname(handle,
1734                                 talloc_tos(),
1735                                 smb_fname,
1736                                 &client_fname);
1737         if (status != 0) {
1738                 goto err;
1739         }
1740
1741         status = SMB_VFS_NEXT_REMOVEXATTR(handle, client_fname, name);
1742
1743 err:
1744         TALLOC_FREE(client_fname);
1745         return status;
1746 }
1747
1748 static int um_setxattr(struct vfs_handle_struct *handle,
1749                        const struct smb_filename *smb_fname,
1750                        const char *name,
1751                        const void *value,
1752                        size_t size,
1753                        int flags)
1754 {
1755         int status;
1756         struct smb_filename *client_fname = NULL;
1757
1758         DEBUG(10, ("Entering um_setxattr\n"));
1759
1760         if (!is_in_media_files(smb_fname->base_name)) {
1761                 return SMB_VFS_NEXT_SETXATTR(handle, smb_fname, name, value,
1762                                              size, flags);
1763         }
1764
1765         status = alloc_get_client_smb_fname(handle,
1766                                 talloc_tos(),
1767                                 smb_fname,
1768                                 &client_fname);
1769         if (status != 0) {
1770                 goto err;
1771         }
1772
1773         status = SMB_VFS_NEXT_SETXATTR(handle, client_fname, name, value,
1774                                        size, flags);
1775
1776 err:
1777         TALLOC_FREE(client_fname);
1778         return status;
1779 }
1780
1781 static int um_connect(vfs_handle_struct *handle,
1782                          const char *service,
1783                          const char *user)
1784 {
1785         int rc;
1786         struct um_config_data *config;
1787         int enumval;
1788
1789         rc = SMB_VFS_NEXT_CONNECT(handle, service, user);
1790         if (rc != 0) {
1791                 return rc;
1792         }
1793
1794         config = talloc_zero(handle->conn, struct um_config_data);
1795         if (!config) {
1796                 DEBUG(1, ("talloc_zero() failed\n"));
1797                 errno = ENOMEM;
1798                 return -1;
1799         }
1800
1801         enumval = lp_parm_enum(SNUM(handle->conn), UM_PARAM_TYPE_NAME,
1802                                "clientid", um_clientid, UM_CLIENTID_NAME);
1803         if (enumval == -1) {
1804                 DEBUG(1, ("value for %s: type unknown\n",
1805                           UM_PARAM_TYPE_NAME));
1806                 return -1;
1807         }
1808         config->clientid = (enum um_clientid)enumval;
1809
1810         SMB_VFS_HANDLE_SET_DATA(handle, config,
1811                                 NULL, struct um_config_data,
1812                                 return -1);
1813
1814         return 0;
1815 }
1816
1817 /* VFS operations structure */
1818
1819 static struct vfs_fn_pointers vfs_um_fns = {
1820         .connect_fn = um_connect,
1821
1822         /* Disk operations */
1823
1824         .statvfs_fn = um_statvfs,
1825
1826         /* Directory operations */
1827
1828         .fdopendir_fn = um_fdopendir,
1829         .readdir_fn = um_readdir,
1830         .seekdir_fn = um_seekdir,
1831         .telldir_fn = um_telldir,
1832         .rewind_dir_fn = um_rewinddir,
1833         .mkdirat_fn = um_mkdirat,
1834         .closedir_fn = um_closedir,
1835
1836         /* File operations */
1837
1838         .open_fn = um_open,
1839         .create_file_fn = um_create_file,
1840         .renameat_fn = um_renameat,
1841         .stat_fn = um_stat,
1842         .lstat_fn = um_lstat,
1843         .fstat_fn = um_fstat,
1844         .unlinkat_fn = um_unlinkat,
1845         .chmod_fn = um_chmod,
1846         .lchown_fn = um_lchown,
1847         .chdir_fn = um_chdir,
1848         .ntimes_fn = um_ntimes,
1849         .symlinkat_fn = um_symlinkat,
1850         .readlinkat_fn = um_readlinkat,
1851         .linkat_fn = um_linkat,
1852         .mknodat_fn = um_mknodat,
1853         .realpath_fn = um_realpath,
1854         .chflags_fn = um_chflags,
1855         .streaminfo_fn = um_streaminfo,
1856
1857         /* NT ACL operations. */
1858
1859         .get_nt_acl_at_fn = um_get_nt_acl_at,
1860
1861         /* POSIX ACL operations. */
1862
1863         .sys_acl_get_file_fn = um_sys_acl_get_file,
1864         .sys_acl_set_file_fn = um_sys_acl_set_file,
1865         .sys_acl_delete_def_file_fn = um_sys_acl_delete_def_file,
1866
1867         /* EA operations. */
1868         .getxattr_fn = um_getxattr,
1869         .getxattrat_send_fn = vfs_not_implemented_getxattrat_send,
1870         .getxattrat_recv_fn = vfs_not_implemented_getxattrat_recv,
1871         .listxattr_fn = um_listxattr,
1872         .removexattr_fn = um_removexattr,
1873         .setxattr_fn = um_setxattr,
1874 };
1875
1876 static_decl_vfs;
1877 NTSTATUS vfs_unityed_media_init(TALLOC_CTX *ctx)
1878 {
1879         NTSTATUS ret = smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
1880                                         "unityed_media", &vfs_um_fns);
1881         if (!NT_STATUS_IS_OK(ret)) {
1882                 return ret;
1883         }
1884
1885         vfs_um_debug_level = debug_add_class("unityed_media");
1886
1887         if (vfs_um_debug_level == -1) {
1888                 vfs_um_debug_level = DBGC_VFS;
1889                 DEBUG(1, ("unityed_media_init: Couldn't register custom "
1890                           "debugging class.\n"));
1891         }
1892
1893         return ret;
1894 }