source3/modules/vfs_catia.c

   1 /*
   2  * Catia VFS module
   3  *
   4  * Implement a fixed mapping of forbidden NT characters in filenames that are
   5  * used a lot by the CAD package Catia.
   6  *
   7  * Yes, this a BAD BAD UGLY INCOMPLETE hack, but it helps quite some people
   8  * out there. Catia V4 on AIX uses characters like "<*$ a *lot*, all forbidden
   9  * under Windows...
  10  *
  11  * Copyright (C) Volker Lendecke, 2005
  12  * Copyright (C) Aravind Srinivasan, 2009
  13  * Copyright (C) Guenter Kukkukk, 2013
  14  *
  15  * This program is free software; you can redistribute it and/or modify
  16  * it under the terms of the GNU General Public License as published by
  17  * the Free Software Foundation; either version 3 of the License, or
  18  * (at your option) any later version.
  19  *
  20  * This program is distributed in the hope that it will be useful,
  21  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  22  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  23  * GNU General Public License for more details.
  24  *
  25  * You should have received a copy of the GNU General Public License
  26  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  27  */
  28
  29
  30 #include "includes.h"
  31 #include "smbd/smbd.h"
  32
  33 static int vfs_catia_debug_level = DBGC_VFS;
  34
  35 #undef DBGC_CLASS
  36 #define DBGC_CLASS vfs_catia_debug_level
  37
  38 #define GLOBAL_SNUM     0xFFFFFFF
  39 #define MAP_SIZE        0xFF
  40 #define MAP_NUM         0x101 /* max unicode charval / MAP_SIZE */
  41 #define T_OFFSET(_v_)   ((_v_ % MAP_SIZE))
  42 #define T_START(_v_)    (((_v_ / MAP_SIZE) * MAP_SIZE))
  43 #define T_PICK(_v_)     ((_v_ / MAP_SIZE))
  44
  45 struct char_mappings {
  46         smb_ucs2_t entry[MAP_SIZE][2];
  47 };
  48
  49 struct share_mapping_entry {
  50         int snum;
  51         struct share_mapping_entry *next;
  52         struct char_mappings **mappings;
  53 };
  54
  55 struct share_mapping_entry *srt_head = NULL;
  56
  57 static bool build_table(struct char_mappings **cmaps, int value)
  58 {
  59         int i;
  60         int start = T_START(value);
  61
  62         (*cmaps) = talloc_zero(NULL, struct char_mappings);
  63
  64         if (!*cmaps)
  65                 return False;
  66
  67         for (i = 0; i < MAP_SIZE;i++) {
  68                 (*cmaps)->entry[i][vfs_translate_to_unix] = start + i;
  69                 (*cmaps)->entry[i][vfs_translate_to_windows] = start + i;
  70         }
  71
  72         return True;
  73 }
  74
  75 static void set_tables(struct char_mappings **cmaps,
  76                        long unix_map,
  77                        long windows_map)
  78 {
  79         int i;
  80
  81         /* set unix -> windows */
  82         i = T_OFFSET(unix_map);
  83         cmaps[T_PICK(unix_map)]->entry[i][vfs_translate_to_windows] = windows_map;
  84
  85         /* set windows -> unix */
  86         i = T_OFFSET(windows_map);
  87         cmaps[T_PICK(windows_map)]->entry[i][vfs_translate_to_unix] = unix_map;
  88 }
  89
  90 static bool build_ranges(struct char_mappings **cmaps,
  91                          long unix_map,
  92                          long windows_map)
  93 {
  94
  95         if (!cmaps[T_PICK(unix_map)]) {
  96                 if (!build_table(&cmaps[T_PICK(unix_map)], unix_map))
  97                         return False;
  98         }
  99
 100         if (!cmaps[T_PICK(windows_map)]) {
 101                 if (!build_table(&cmaps[T_PICK(windows_map)], windows_map))
 102                         return False;
 103         }
 104
 105         set_tables(cmaps, unix_map, windows_map);
 106
 107         return True;
 108 }
 109
 110 static struct share_mapping_entry *get_srt(connection_struct *conn,
 111                                            struct share_mapping_entry **global)
 112 {
 113         struct share_mapping_entry *share;
 114
 115         for (share = srt_head; share != NULL; share = share->next) {
 116                 if (share->snum == GLOBAL_SNUM)
 117                         (*global) = share;
 118
 119                 if (share->snum == SNUM(conn))
 120                         return share;
 121         }
 122
 123         return share;
 124 }
 125
 126 static struct share_mapping_entry *add_srt(int snum, const char **mappings)
 127 {
 128
 129         char *tmp;
 130         fstring mapping;
 131         int i;
 132         long unix_map, windows_map;
 133         struct share_mapping_entry *ret = NULL;
 134
 135         ret = (struct share_mapping_entry *)
 136                 TALLOC_ZERO(NULL, sizeof(struct share_mapping_entry) +
 137                 (mappings ? (MAP_NUM * sizeof(struct char_mappings *)) : 0));
 138
 139         if (!ret)
 140                 return ret;
 141
 142         ret->snum = snum;
 143
 144         if (mappings) {
 145                 ret->mappings = (struct char_mappings**) ((unsigned char*) ret +
 146                     sizeof(struct share_mapping_entry));
 147                 memset(ret->mappings, 0,
 148                     MAP_NUM * sizeof(struct char_mappings *));
 149         } else {
 150                 ret->mappings = NULL;
 151                 return ret;
 152         }
 153
 154         /*
 155          * catia mappings are of the form :
 156          * UNIX char (in 0xnn hex) : WINDOWS char (in 0xnn hex)
 157          *
 158          * multiple mappings are comma separated in smb.conf
 159          */
 160         for (i=0;mappings[i];i++) {
 161                 fstrcpy(mapping, mappings[i]);
 162                 unix_map = strtol(mapping, &tmp, 16);
 163                 if (unix_map == 0 && errno == EINVAL) {
 164                         DEBUG(0, ("INVALID CATIA MAPPINGS - %s\n", mapping));
 165                         continue;
 166                 }
 167                 windows_map = strtol(++tmp, NULL, 16);
 168                 if (windows_map == 0 && errno == EINVAL) {
 169                         DEBUG(0, ("INVALID CATIA MAPPINGS - %s\n", mapping));
 170                         continue;
 171                 }
 172
 173                 if (!build_ranges(ret->mappings, unix_map, windows_map)) {
 174                         DEBUG(0, ("TABLE ERROR - CATIA MAPPINGS - %s\n", mapping));
 175                         continue;
 176                 }
 177         }
 178
 179         ret->next = srt_head;
 180         srt_head = ret;
 181
 182         return ret;
 183 }
 184
 185 static bool init_mappings(connection_struct *conn,
 186                           struct share_mapping_entry **selected_out)
 187 {
 188         const char **mappings = NULL;
 189         struct share_mapping_entry *share_level = NULL;
 190         struct share_mapping_entry *global = NULL;
 191
 192         /* check srt cache */
 193         share_level = get_srt(conn, &global);
 194         if (share_level) {
 195                 *selected_out = share_level;
 196                 return (share_level->mappings != NULL);
 197         }
 198
 199         /* see if we have a global setting */
 200         if (!global) {
 201                 /* global setting */
 202                 mappings = lp_parm_string_list(-1, "catia", "mappings", NULL);
 203                 global = add_srt(GLOBAL_SNUM, mappings);
 204         }
 205
 206         /* no global setting - what about share level ? */
 207         mappings = lp_parm_string_list(SNUM(conn), "catia", "mappings", NULL);
 208         share_level = add_srt(SNUM(conn), mappings);
 209
 210         if (share_level->mappings) {
 211                 (*selected_out) = share_level;
 212                 return True;
 213         } else if (global->mappings) {
 214                 share_level->mappings = global->mappings;
 215                 (*selected_out) = share_level;
 216                 return True;
 217         }
 218
 219         return False;
 220 }
 221
 222 static NTSTATUS catia_string_replace_allocate(connection_struct *conn,
 223                                               const char *name_in,
 224                                               char **mapped_name,
 225                                         enum vfs_translate_direction direction)
 226 {
 227         static smb_ucs2_t *tmpbuf = NULL;
 228         smb_ucs2_t *ptr;
 229         struct share_mapping_entry *selected;
 230         struct char_mappings *map = NULL;
 231         size_t converted_size;
 232         TALLOC_CTX *ctx = talloc_tos();
 233
 234         if (!init_mappings(conn, &selected)) {
 235                 /* No mappings found. Just use the old name */
 236                 *mapped_name = talloc_strdup(NULL, name_in);
 237                 if (!*mapped_name) {
 238                         errno = ENOMEM;
 239                         return NT_STATUS_NO_MEMORY;
 240                 }
 241                 return NT_STATUS_OK;
 242         }
 243
 244         if ((push_ucs2_talloc(ctx, &tmpbuf, name_in,
 245                               &converted_size)) == false) {
 246                 return map_nt_error_from_unix(errno);
 247         }
 248         ptr = tmpbuf;
 249         for(;*ptr;ptr++) {
 250                 if (*ptr == 0)
 251                         break;
 252                 map = selected->mappings[T_PICK((*ptr))];
 253
 254                 /* nothing to do */
 255                 if (!map)
 256                         continue;
 257
 258                 *ptr = map->entry[T_OFFSET((*ptr))][direction];
 259         }
 260
 261         if ((pull_ucs2_talloc(ctx, mapped_name, tmpbuf,
 262                               &converted_size)) == false) {
 263                 TALLOC_FREE(tmpbuf);
 264                 return map_nt_error_from_unix(errno);
 265         }
 266         TALLOC_FREE(tmpbuf);
 267         return NT_STATUS_OK;
 268 }
 269
 270 static DIR *catia_opendir(vfs_handle_struct *handle,
 271                                      const char *fname,
 272                                      const char *mask,
 273                                      uint32 attr)
 274 {
 275         char *name_mapped = NULL;
 276         NTSTATUS status;
 277         DIR *ret;
 278
 279         status = catia_string_replace_allocate(handle->conn, fname,
 280                                         &name_mapped, vfs_translate_to_unix);
 281         if (!NT_STATUS_IS_OK(status)) {
 282                 errno = map_errno_from_nt_status(status);
 283                 return NULL;
 284         }
 285
 286         ret = SMB_VFS_NEXT_OPENDIR(handle, name_mapped, mask, attr);
 287         TALLOC_FREE(name_mapped);
 288
 289         return ret;
 290 }
 291
 292 /*
 293  * TRANSLATE_NAME call which converts the given name to
 294  * "WINDOWS displayable" name
 295  */
 296 static NTSTATUS catia_translate_name(struct vfs_handle_struct *handle,
 297                                      const char *orig_name,
 298                                      enum vfs_translate_direction direction,
 299                                      TALLOC_CTX *mem_ctx,
 300                                      char **pmapped_name)
 301 {
 302         char *name = NULL;
 303         char *mapped_name;
 304         NTSTATUS status, ret;
 305
 306         /*
 307          * Copy the supplied name and free the memory for mapped_name,
 308          * already allocated by the caller.
 309          * We will be allocating new memory for mapped_name in
 310          * catia_string_replace_allocate
 311          */
 312         name = talloc_strdup(talloc_tos(), orig_name);
 313         if (!name) {
 314                 errno = ENOMEM;
 315                 return NT_STATUS_NO_MEMORY;
 316         }
 317         status = catia_string_replace_allocate(handle->conn, name,
 318                         &mapped_name, direction);
 319
 320         TALLOC_FREE(name);
 321         if (!NT_STATUS_IS_OK(status)) {
 322                 return status;
 323         }
 324
 325         ret = SMB_VFS_NEXT_TRANSLATE_NAME(handle, mapped_name, direction,
 326                                           mem_ctx, pmapped_name);
 327
 328         if (NT_STATUS_EQUAL(ret, NT_STATUS_NONE_MAPPED)) {
 329                 *pmapped_name = talloc_move(mem_ctx, &mapped_name);
 330                 /* we need to return the former translation result here */
 331                 ret = status;
 332         } else {
 333                 TALLOC_FREE(mapped_name);
 334         }
 335
 336         return ret;
 337 }
 338
 339 static int catia_open(vfs_handle_struct *handle,
 340                       struct smb_filename *smb_fname,
 341                       files_struct *fsp,
 342                       int flags,
 343                       mode_t mode)
 344 {
 345         char *name_mapped = NULL;
 346         char *tmp_base_name;
 347         int ret;
 348         NTSTATUS status;
 349
 350         tmp_base_name = smb_fname->base_name;
 351         status = catia_string_replace_allocate(handle->conn,
 352                                         smb_fname->base_name,
 353                                         &name_mapped, vfs_translate_to_unix);
 354         if (!NT_STATUS_IS_OK(status)) {
 355                 errno = map_errno_from_nt_status(status);
 356                 return -1;
 357         }
 358
 359         smb_fname->base_name = name_mapped;
 360         ret = SMB_VFS_NEXT_OPEN(handle, smb_fname, fsp, flags, mode);
 361         smb_fname->base_name = tmp_base_name;
 362         TALLOC_FREE(name_mapped);
 363
 364         return ret;
 365 }
 366
 367 static int catia_rename(vfs_handle_struct *handle,
 368                         const struct smb_filename *smb_fname_src,
 369                         const struct smb_filename *smb_fname_dst)
 370 {
 371         TALLOC_CTX *ctx = talloc_tos();
 372         struct smb_filename *smb_fname_src_tmp = NULL;
 373         struct smb_filename *smb_fname_dst_tmp = NULL;
 374         char *src_name_mapped = NULL;
 375         char *dst_name_mapped = NULL;
 376         NTSTATUS status;
 377         int ret = -1;
 378
 379         status = catia_string_replace_allocate(handle->conn,
 380                                 smb_fname_src->base_name,
 381                                 &src_name_mapped, vfs_translate_to_unix);
 382         if (!NT_STATUS_IS_OK(status)) {
 383                 errno = map_errno_from_nt_status(status);
 384                 return -1;
 385         }
 386
 387         status = catia_string_replace_allocate(handle->conn,
 388                                 smb_fname_dst->base_name,
 389                                 &dst_name_mapped, vfs_translate_to_unix);
 390         if (!NT_STATUS_IS_OK(status)) {
 391                 errno = map_errno_from_nt_status(status);
 392                 return -1;
 393         }
 394
 395         /* Setup temporary smb_filename structs. */
 396         smb_fname_src_tmp = cp_smb_filename(ctx, smb_fname_src);
 397         if (smb_fname_src_tmp == NULL) {
 398                 errno = ENOMEM;
 399                 goto out;
 400         }
 401
 402         smb_fname_dst_tmp = cp_smb_filename(ctx, smb_fname_dst);
 403         if (smb_fname_dst_tmp == NULL) {
 404                 errno = ENOMEM;
 405                 goto out;
 406         }
 407
 408         smb_fname_src_tmp->base_name = src_name_mapped;
 409         smb_fname_dst_tmp->base_name = dst_name_mapped;
 410         DEBUG(10, ("converted old name: %s\n",
 411                                 smb_fname_str_dbg(smb_fname_src_tmp)));
 412         DEBUG(10, ("converted new name: %s\n",
 413                                 smb_fname_str_dbg(smb_fname_dst_tmp)));
 414
 415         ret = SMB_VFS_NEXT_RENAME(handle, smb_fname_src_tmp,
 416                         smb_fname_dst_tmp);
 417 out:
 418         TALLOC_FREE(src_name_mapped);
 419         TALLOC_FREE(dst_name_mapped);
 420         TALLOC_FREE(smb_fname_src_tmp);
 421         TALLOC_FREE(smb_fname_dst_tmp);
 422         return ret;
 423 }
 424
 425 static int catia_stat(vfs_handle_struct *handle,
 426                       struct smb_filename *smb_fname)
 427 {
 428         char *name = NULL;
 429         char *tmp_base_name;
 430         int ret;
 431         NTSTATUS status;
 432
 433         status = catia_string_replace_allocate(handle->conn,
 434                                 smb_fname->base_name,
 435                                 &name, vfs_translate_to_unix);
 436         if (!NT_STATUS_IS_OK(status)) {
 437                 errno = map_errno_from_nt_status(status);
 438                 return -1;
 439         }
 440
 441         tmp_base_name = smb_fname->base_name;
 442         smb_fname->base_name = name;
 443
 444         ret = SMB_VFS_NEXT_STAT(handle, smb_fname);
 445         smb_fname->base_name = tmp_base_name;
 446
 447         TALLOC_FREE(name);
 448         return ret;
 449 }
 450
 451 static int catia_lstat(vfs_handle_struct *handle,
 452                        struct smb_filename *smb_fname)
 453 {
 454         char *name = NULL;
 455         char *tmp_base_name;
 456         int ret;
 457         NTSTATUS status;
 458
 459         status = catia_string_replace_allocate(handle->conn,
 460                                 smb_fname->base_name,
 461                                 &name, vfs_translate_to_unix);
 462         if (!NT_STATUS_IS_OK(status)) {
 463                 errno = map_errno_from_nt_status(status);
 464                 return -1;
 465         }
 466
 467         tmp_base_name = smb_fname->base_name;
 468         smb_fname->base_name = name;
 469
 470         ret = SMB_VFS_NEXT_LSTAT(handle, smb_fname);
 471         smb_fname->base_name = tmp_base_name;
 472         TALLOC_FREE(name);
 473
 474         return ret;
 475 }
 476
 477 static int catia_unlink(vfs_handle_struct *handle,
 478                         const struct smb_filename *smb_fname)
 479 {
 480         struct smb_filename *smb_fname_tmp = NULL;
 481         char *name = NULL;
 482         NTSTATUS status;
 483         int ret;
 484
 485         status = catia_string_replace_allocate(handle->conn,
 486                                         smb_fname->base_name,
 487                                         &name, vfs_translate_to_unix);
 488         if (!NT_STATUS_IS_OK(status)) {
 489                 errno = map_errno_from_nt_status(status);
 490                 return -1;
 491         }
 492
 493         /* Setup temporary smb_filename structs. */
 494         smb_fname_tmp = cp_smb_filename(talloc_tos(), smb_fname);
 495         if (smb_fname_tmp == NULL) {
 496                 errno = ENOMEM;
 497                 return -1;
 498         }
 499
 500         smb_fname_tmp->base_name = name;
 501         ret = SMB_VFS_NEXT_UNLINK(handle, smb_fname_tmp);
 502         TALLOC_FREE(smb_fname_tmp);
 503         TALLOC_FREE(name);
 504
 505         return ret;
 506 }
 507
 508 static int catia_chown(vfs_handle_struct *handle,
 509                        const char *path,
 510                        uid_t uid,
 511                        gid_t gid)
 512 {
 513         char *name = NULL;
 514         NTSTATUS status;
 515         int ret;
 516
 517         status = catia_string_replace_allocate(handle->conn, path,
 518                                         &name, vfs_translate_to_unix);
 519         if (!NT_STATUS_IS_OK(status)) {
 520                 errno = map_errno_from_nt_status(status);
 521                 return -1;
 522         }
 523
 524         ret = SMB_VFS_NEXT_CHOWN(handle, name, uid, gid);
 525         TALLOC_FREE(name);
 526
 527         return ret;
 528 }
 529
 530 static int catia_lchown(vfs_handle_struct *handle,
 531                         const char *path,
 532                         uid_t uid,
 533                         gid_t gid)
 534 {
 535         char *name = NULL;
 536         NTSTATUS status;
 537         int ret;
 538
 539         status = catia_string_replace_allocate(handle->conn, path,
 540                                         &name, vfs_translate_to_unix);
 541         if (!NT_STATUS_IS_OK(status)) {
 542                 errno = map_errno_from_nt_status(status);
 543                 return -1;
 544         }
 545
 546         ret = SMB_VFS_NEXT_LCHOWN(handle, name, uid, gid);
 547         TALLOC_FREE(name);
 548
 549         return ret;
 550 }
 551
 552 static int catia_chmod(vfs_handle_struct *handle, const char *path, mode_t mode)
 553 {
 554         char *name = NULL;
 555         NTSTATUS status;
 556         int ret;
 557
 558         status = catia_string_replace_allocate(handle->conn, path,
 559                                         &name, vfs_translate_to_unix);
 560         if (!NT_STATUS_IS_OK(status)) {
 561                 errno = map_errno_from_nt_status(status);
 562                 return -1;
 563         }
 564
 565         ret = SMB_VFS_NEXT_CHMOD(handle, name, mode);
 566         TALLOC_FREE(name);
 567
 568         return ret;
 569 }
 570
 571 static int catia_rmdir(vfs_handle_struct *handle,
 572                        const char *path)
 573 {
 574         char *name = NULL;
 575         NTSTATUS status;
 576         int ret;
 577
 578         status = catia_string_replace_allocate(handle->conn, path,
 579                                         &name, vfs_translate_to_unix);
 580         if (!NT_STATUS_IS_OK(status)) {
 581                 errno = map_errno_from_nt_status(status);
 582                 return -1;
 583         }
 584
 585         ret = SMB_VFS_NEXT_RMDIR(handle, name);
 586         TALLOC_FREE(name);
 587
 588         return ret;
 589 }
 590
 591 static int catia_mkdir(vfs_handle_struct *handle,
 592                        const char *path,
 593                        mode_t mode)
 594 {
 595         char *name = NULL;
 596         NTSTATUS status;
 597         int ret;
 598
 599         status = catia_string_replace_allocate(handle->conn, path,
 600                                          &name, vfs_translate_to_unix);
 601         if (!NT_STATUS_IS_OK(status)) {
 602                 errno = map_errno_from_nt_status(status);
 603                 return -1;
 604         }
 605
 606         ret = SMB_VFS_NEXT_MKDIR(handle, name, mode);
 607         TALLOC_FREE(name);
 608
 609         return ret;
 610 }
 611
 612 static int catia_chdir(vfs_handle_struct *handle,
 613                        const char *path)
 614 {
 615         char *name = NULL;
 616         NTSTATUS status;
 617         int ret;
 618
 619         status = catia_string_replace_allocate(handle->conn, path,
 620                                         &name, vfs_translate_to_unix);
 621         if (!NT_STATUS_IS_OK(status)) {
 622                 errno = map_errno_from_nt_status(status);
 623                 return -1;
 624         }
 625
 626         ret = SMB_VFS_NEXT_CHDIR(handle, name);
 627         TALLOC_FREE(name);
 628
 629         return ret;
 630 }
 631
 632 static int catia_ntimes(vfs_handle_struct *handle,
 633                         const struct smb_filename *smb_fname,
 634                         struct smb_file_time *ft)
 635 {
 636         struct smb_filename *smb_fname_tmp = NULL;
 637         char *name = NULL;
 638         NTSTATUS status;
 639         int ret;
 640
 641         status = catia_string_replace_allocate(handle->conn,
 642                                 smb_fname->base_name,
 643                                 &name, vfs_translate_to_unix);
 644         if (!NT_STATUS_IS_OK(status)) {
 645                 errno = map_errno_from_nt_status(status);
 646                 return -1;
 647         }
 648
 649         smb_fname_tmp = cp_smb_filename(talloc_tos(), smb_fname);
 650         if (smb_fname_tmp == NULL) {
 651                 errno = ENOMEM;
 652                 return -1;
 653         }
 654
 655         smb_fname_tmp->base_name = name;
 656         ret = SMB_VFS_NEXT_NTIMES(handle, smb_fname_tmp, ft);
 657         TALLOC_FREE(name);
 658         TALLOC_FREE(smb_fname_tmp);
 659
 660         return ret;
 661 }
 662
 663 static char *
 664 catia_realpath(vfs_handle_struct *handle, const char *path)
 665 {
 666         char *mapped_name = NULL;
 667         NTSTATUS status;
 668         char *ret = NULL;
 669
 670         status = catia_string_replace_allocate(handle->conn, path,
 671                                         &mapped_name, vfs_translate_to_unix);
 672         if (!NT_STATUS_IS_OK(status)) {
 673                 errno = map_errno_from_nt_status(status);
 674                 return NULL;
 675         }
 676
 677         ret = SMB_VFS_NEXT_REALPATH(handle, mapped_name);
 678         TALLOC_FREE(mapped_name);
 679
 680         return ret;
 681 }
 682
 683 static int catia_chflags(struct vfs_handle_struct *handle,
 684                          const char *path, unsigned int flags)
 685 {
 686         char *mapped_name = NULL;
 687         NTSTATUS status;
 688         int ret;
 689
 690         status = catia_string_replace_allocate(handle->conn, path,
 691                                         &mapped_name, vfs_translate_to_unix);
 692         if (!NT_STATUS_IS_OK(status)) {
 693                 errno = map_errno_from_nt_status(status);
 694                 return -1;
 695         }
 696
 697         ret = SMB_VFS_NEXT_CHFLAGS(handle, mapped_name, flags);
 698         TALLOC_FREE(mapped_name);
 699
 700         return ret;
 701 }
 702
 703 static NTSTATUS
 704 catia_streaminfo(struct vfs_handle_struct *handle,
 705                  struct files_struct *fsp,
 706                  const char *path,
 707                  TALLOC_CTX *mem_ctx,
 708                  unsigned int *num_streams,
 709                  struct stream_struct **streams)
 710 {
 711         char *mapped_name = NULL;
 712         NTSTATUS status;
 713
 714         status = catia_string_replace_allocate(handle->conn, path,
 715                                         &mapped_name, vfs_translate_to_unix);
 716         if (!NT_STATUS_IS_OK(status)) {
 717                 errno = map_errno_from_nt_status(status);
 718                 return status;
 719         }
 720
 721         status = SMB_VFS_NEXT_STREAMINFO(handle, fsp, mapped_name,
 722                                          mem_ctx, num_streams,streams);
 723         TALLOC_FREE(mapped_name);
 724
 725         return status;
 726 }
 727
 728 static NTSTATUS
 729 catia_get_nt_acl(struct vfs_handle_struct *handle,
 730                  const char *path,
 731                  uint32 security_info,
 732                  TALLOC_CTX *mem_ctx,
 733                  struct security_descriptor **ppdesc)
 734 {
 735         char *mapped_name = NULL;
 736         NTSTATUS status;
 737
 738         status = catia_string_replace_allocate(handle->conn,
 739                                 path, &mapped_name, vfs_translate_to_unix);
 740         if (!NT_STATUS_IS_OK(status)) {
 741                 errno = map_errno_from_nt_status(status);
 742                 return status;
 743         }
 744         status = SMB_VFS_NEXT_GET_NT_ACL(handle, mapped_name,
 745                                          security_info, mem_ctx, ppdesc);
 746         TALLOC_FREE(mapped_name);
 747
 748         return status;
 749 }
 750
 751 static int
 752 catia_chmod_acl(vfs_handle_struct *handle,
 753                 const char *path,
 754                 mode_t mode)
 755 {
 756         char *mapped_name = NULL;
 757         NTSTATUS status;
 758         int ret;
 759
 760         status = catia_string_replace_allocate(handle->conn,
 761                                 path, &mapped_name, vfs_translate_to_unix);
 762         if (!NT_STATUS_IS_OK(status)) {
 763                 errno = map_errno_from_nt_status(status);
 764                 return -1;
 765         }
 766
 767         ret = SMB_VFS_NEXT_CHMOD_ACL(handle, mapped_name, mode);
 768         TALLOC_FREE(mapped_name);
 769         return ret;
 770 }
 771
 772 static SMB_ACL_T
 773 catia_sys_acl_get_file(vfs_handle_struct *handle,
 774                        const char *path,
 775                        SMB_ACL_TYPE_T type,
 776                        TALLOC_CTX *mem_ctx)
 777 {
 778         char *mapped_name = NULL;
 779         NTSTATUS status;
 780         SMB_ACL_T ret;
 781
 782         status = catia_string_replace_allocate(handle->conn,
 783                                 path, &mapped_name, vfs_translate_to_unix);
 784         if (!NT_STATUS_IS_OK(status)) {
 785                 errno = map_errno_from_nt_status(status);
 786                 return NULL;
 787         }
 788
 789         ret = SMB_VFS_NEXT_SYS_ACL_GET_FILE(handle, mapped_name, type, mem_ctx);
 790         TALLOC_FREE(mapped_name);
 791
 792         return ret;
 793 }
 794
 795 static int
 796 catia_sys_acl_set_file(vfs_handle_struct *handle,
 797                        const char *path,
 798                        SMB_ACL_TYPE_T type,
 799                        SMB_ACL_T theacl)
 800 {
 801         char *mapped_name = NULL;
 802         NTSTATUS status;
 803         int ret;
 804
 805         status = catia_string_replace_allocate(handle->conn,
 806                                 path, &mapped_name, vfs_translate_to_unix);
 807         if (!NT_STATUS_IS_OK(status)) {
 808                 errno = map_errno_from_nt_status(status);
 809                 return -1;
 810         }
 811
 812         ret = SMB_VFS_NEXT_SYS_ACL_SET_FILE(handle, mapped_name, type, theacl);
 813         TALLOC_FREE(mapped_name);
 814
 815         return ret;
 816 }
 817
 818 static int
 819 catia_sys_acl_delete_def_file(vfs_handle_struct *handle,
 820                               const char *path)
 821 {
 822         char *mapped_name = NULL;
 823         NTSTATUS status;
 824         int ret;
 825
 826         status = catia_string_replace_allocate(handle->conn,
 827                                 path, &mapped_name, vfs_translate_to_unix);
 828         if (!NT_STATUS_IS_OK(status)) {
 829                 errno = map_errno_from_nt_status(status);
 830                 return -1;
 831         }
 832
 833         ret = SMB_VFS_NEXT_SYS_ACL_DELETE_DEF_FILE(handle, mapped_name);
 834         TALLOC_FREE(mapped_name);
 835
 836         return ret;
 837 }
 838
 839 static ssize_t
 840 catia_getxattr(vfs_handle_struct *handle, const char *path,
 841                const char *name, void *value, size_t size)
 842 {
 843         char *mapped_name = NULL;
 844         NTSTATUS status;
 845         ssize_t ret;
 846
 847         status = catia_string_replace_allocate(handle->conn,
 848                                 name, &mapped_name, vfs_translate_to_unix);
 849         if (!NT_STATUS_IS_OK(status)) {
 850                 errno = map_errno_from_nt_status(status);
 851                 return -1;
 852         }
 853
 854
 855         ret = SMB_VFS_NEXT_GETXATTR(handle, path, mapped_name, value, size);
 856         TALLOC_FREE(mapped_name);
 857
 858         return ret;
 859 }
 860
 861 static ssize_t
 862 catia_listxattr(vfs_handle_struct *handle, const char *path,
 863                 char *list, size_t size)
 864 {
 865         char *mapped_name = NULL;
 866         NTSTATUS status;
 867         ssize_t ret;
 868
 869         status = catia_string_replace_allocate(handle->conn,
 870                                 path, &mapped_name, vfs_translate_to_unix);
 871         if (!NT_STATUS_IS_OK(status)) {
 872                 errno = map_errno_from_nt_status(status);
 873                 return -1;
 874         }
 875
 876
 877         ret = SMB_VFS_NEXT_LISTXATTR(handle, mapped_name, list, size);
 878         TALLOC_FREE(mapped_name);
 879
 880         return ret;
 881 }
 882
 883 static int
 884 catia_removexattr(vfs_handle_struct *handle, const char *path,
 885                   const char *name)
 886 {
 887         char *mapped_name = NULL;
 888         NTSTATUS status;
 889         ssize_t ret;
 890
 891         status = catia_string_replace_allocate(handle->conn,
 892                                 name, &mapped_name, vfs_translate_to_unix);
 893         if (!NT_STATUS_IS_OK(status)) {
 894                 errno = map_errno_from_nt_status(status);
 895                 return -1;
 896         }
 897
 898
 899         ret = SMB_VFS_NEXT_REMOVEXATTR(handle, path, mapped_name);
 900         TALLOC_FREE(mapped_name);
 901
 902         return ret;
 903 }
 904
 905 static int
 906 catia_setxattr(vfs_handle_struct *handle, const char *path,
 907                const char *name, const void *value, size_t size,
 908                int flags)
 909 {
 910         char *mapped_name = NULL;
 911         NTSTATUS status;
 912         ssize_t ret;
 913
 914         status = catia_string_replace_allocate(handle->conn,
 915                                 name, &mapped_name, vfs_translate_to_unix);
 916         if (!NT_STATUS_IS_OK(status)) {
 917                 errno = map_errno_from_nt_status(status);
 918                 return -1;
 919         }
 920
 921
 922         ret = SMB_VFS_NEXT_SETXATTR(handle, path, mapped_name, value, size, flags);
 923         TALLOC_FREE(mapped_name);
 924
 925         return ret;
 926 }
 927
 928 static struct vfs_fn_pointers vfs_catia_fns = {
 929         .mkdir_fn = catia_mkdir,
 930         .rmdir_fn = catia_rmdir,
 931         .opendir_fn = catia_opendir,
 932         .open_fn = catia_open,
 933         .rename_fn = catia_rename,
 934         .stat_fn = catia_stat,
 935         .lstat_fn = catia_lstat,
 936         .unlink_fn = catia_unlink,
 937         .chown_fn = catia_chown,
 938         .lchown_fn = catia_lchown,
 939         .chmod_fn = catia_chmod,
 940         .chdir_fn = catia_chdir,
 941         .ntimes_fn = catia_ntimes,
 942         .realpath_fn = catia_realpath,
 943         .chflags_fn = catia_chflags,
 944         .streaminfo_fn = catia_streaminfo,
 945         .translate_name_fn = catia_translate_name,
 946         .get_nt_acl_fn = catia_get_nt_acl,
 947         .chmod_acl_fn = catia_chmod_acl,
 948         .sys_acl_get_file_fn = catia_sys_acl_get_file,
 949         .sys_acl_set_file_fn = catia_sys_acl_set_file,
 950         .sys_acl_delete_def_file_fn = catia_sys_acl_delete_def_file,
 951         .getxattr_fn = catia_getxattr,
 952         .listxattr_fn = catia_listxattr,
 953         .removexattr_fn = catia_removexattr,
 954         .setxattr_fn = catia_setxattr,
 955 };
 956
 957 NTSTATUS vfs_catia_init(void)
 958 {
 959         NTSTATUS ret;
 960
 961         ret = smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "catia",
 962                                 &vfs_catia_fns);
 963         if (!NT_STATUS_IS_OK(ret))
 964                 return ret;
 965
 966         vfs_catia_debug_level = debug_add_class("catia");
 967         if (vfs_catia_debug_level == -1) {
 968                 vfs_catia_debug_level = DBGC_VFS;
 969                 DEBUG(0, ("vfs_catia: Couldn't register custom debugging "
 970                           "class!\n"));
 971         } else {
 972                 DEBUG(10, ("vfs_catia: Debug class number of "
 973                            "'catia': %d\n", vfs_catia_debug_level));
 974         }
 975
 976         return ret;
 977
 978 }