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