source/smbd/vfs-wrap.c

   1 /*
   2    Unix SMB/Netbios implementation.
   3    Version 1.9.
   4    Wrap disk only vfs functions to sidestep dodgy compilers.
   5    Copyright (C) Tim Potter 1998
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20 */
  21
  22 #include "includes.h"
  23
  24 /* We don't want to have NULL function pointers lying around.  Someone
  25    is sure to try and execute them.  These stubs are used to prevent
  26    this possibility. */
  27
  28 int vfswrap_dummy_connect(connection_struct *conn, const char *service, const char *user)
  29 {
  30     return 0;    /* Return >= 0 for success */
  31 }
  32
  33 void vfswrap_dummy_disconnect(connection_struct *conn)
  34 {
  35 }
  36
  37 /* Disk operations */
  38
  39 SMB_BIG_UINT vfswrap_disk_free(connection_struct *conn, const char *path, BOOL small_query, SMB_BIG_UINT *bsize,
  40                                SMB_BIG_UINT *dfree, SMB_BIG_UINT *dsize)
  41 {
  42     SMB_BIG_UINT result;
  43
  44     result = sys_disk_free(path, small_query, bsize, dfree, dsize);
  45     return result;
  46 }
  47
  48 /* Directory operations */
  49
  50 DIR *vfswrap_opendir(connection_struct *conn, const char *fname)
  51 {
  52     DIR *result;
  53
  54     START_PROFILE(syscall_opendir);
  55
  56     result = opendir(fname);
  57     END_PROFILE(syscall_opendir);
  58     return result;
  59 }
  60
  61 struct dirent *vfswrap_readdir(connection_struct *conn, DIR *dirp)
  62 {
  63     struct dirent *result;
  64
  65     START_PROFILE(syscall_readdir);
  66
  67     result = readdir(dirp);
  68     END_PROFILE(syscall_readdir);
  69     return result;
  70 }
  71
  72 int vfswrap_mkdir(connection_struct *conn, const char *path, mode_t mode)
  73 {
  74         int result;
  75         BOOL has_dacl = False;
  76
  77         START_PROFILE(syscall_mkdir);
  78
  79         if (lp_inherit_acls(SNUM(conn)) && (has_dacl = directory_has_default_acl(conn, parent_dirname(path))))
  80                 mode = 0777;
  81
  82         result = mkdir(path, mode);
  83
  84         if (result == 0 && !has_dacl) {
  85                 /*
  86                  * We need to do this as the default behavior of POSIX ACLs
  87                  * is to set the mask to be the requested group permission
  88                  * bits, not the group permission bits to be the requested
  89                  * group permission bits. This is not what we want, as it will
  90                  * mess up any inherited ACL bits that were set. JRA.
  91                  */
  92                 int saved_errno = errno; /* We may get ENOSYS */
  93                 if (conn->vfs_ops.chmod_acl != NULL) {
  94                         if ((conn->vfs_ops.chmod_acl(conn, path, mode) == -1) && (errno == ENOSYS))
  95                                 errno = saved_errno;
  96                 }
  97         }
  98
  99         END_PROFILE(syscall_mkdir);
 100         return result;
 101 }
 102
 103 int vfswrap_rmdir(connection_struct *conn, const char *path)
 104 {
 105     int result;
 106
 107     START_PROFILE(syscall_rmdir);
 108
 109     result = rmdir(path);
 110     END_PROFILE(syscall_rmdir);
 111     return result;
 112 }
 113
 114 int vfswrap_closedir(connection_struct *conn, DIR *dirp)
 115 {
 116     int result;
 117
 118     START_PROFILE(syscall_closedir);
 119
 120     result = closedir(dirp);
 121     END_PROFILE(syscall_closedir);
 122     return result;
 123 }
 124
 125 /* File operations */
 126
 127 int vfswrap_open(connection_struct *conn, const char *fname, int flags, mode_t mode)
 128 {
 129         int result;
 130
 131         START_PROFILE(syscall_open);
 132
 133         result = sys_open(fname, flags, mode);
 134         END_PROFILE(syscall_open);
 135         return result;
 136 }
 137
 138 int vfswrap_close(files_struct *fsp, int fd)
 139 {
 140     int result;
 141
 142     START_PROFILE(syscall_close);
 143
 144     result = close(fd);
 145     END_PROFILE(syscall_close);
 146     return result;
 147 }
 148
 149 ssize_t vfswrap_read(files_struct *fsp, int fd, void *data, size_t n)
 150 {
 151     ssize_t result;
 152
 153     START_PROFILE_BYTES(syscall_read, n);
 154
 155     result = sys_read(fd, data, n);
 156     END_PROFILE(syscall_read);
 157     return result;
 158 }
 159
 160 ssize_t vfswrap_write(files_struct *fsp, int fd, const void *data, size_t n)
 161 {
 162     ssize_t result;
 163
 164     START_PROFILE_BYTES(syscall_write, n);
 165
 166     result = sys_write(fd, data, n);
 167     END_PROFILE(syscall_write);
 168     return result;
 169 }
 170
 171 ssize_t vfswrap_sendfile(int tofd, struct files_struct *fsp, int fromfd, const DATA_BLOB *hdr,
 172                         SMB_OFF_T offset, size_t n)
 173 {
 174         ssize_t result;
 175
 176         START_PROFILE_BYTES(syscall_sendfile, n);
 177         result = sys_sendfile(tofd, fromfd, hdr, offset, n);
 178         END_PROFILE(syscall_sendfile);
 179         return result;
 180 }
 181
 182 SMB_OFF_T vfswrap_lseek(files_struct *fsp, int filedes, SMB_OFF_T offset, int whence)
 183 {
 184         SMB_OFF_T result = 0;
 185
 186         START_PROFILE(syscall_lseek);
 187
 188         /* Cope with 'stat' file opens. */
 189         if (filedes != -1)
 190                 result = sys_lseek(filedes, offset, whence);
 191
 192         /*
 193          * We want to maintain the fiction that we can seek
 194          * on a fifo for file system purposes. This allows
 195          * people to set up UNIX fifo's that feed data to Windows
 196          * applications. JRA.
 197          */
 198
 199         if((result == -1) && (errno == ESPIPE)) {
 200                 result = 0;
 201                 errno = 0;
 202         }
 203
 204         END_PROFILE(syscall_lseek);
 205         return result;
 206 }
 207
 208 /*********************************************************
 209  For rename across filesystems Patch from Warren Birnbaum
 210  <warrenb@hpcvscdp.cv.hp.com>
 211 **********************************************************/
 212
 213 static int copy_reg(const char *source, const char *dest)
 214 {
 215         SMB_STRUCT_STAT source_stats;
 216         int ifd;
 217         int ofd;
 218
 219         if (sys_lstat (source, &source_stats) == -1)
 220                 return -1;
 221
 222         if (!S_ISREG (source_stats.st_mode))
 223                 return -1;
 224
 225         if (unlink (dest) && errno != ENOENT)
 226                 return -1;
 227
 228         if((ifd = sys_open (source, O_RDONLY, 0)) < 0)
 229                 return -1;
 230
 231         if((ofd = sys_open (dest, O_WRONLY | O_CREAT | O_TRUNC, 0600)) < 0 ) {
 232                 int saved_errno = errno;
 233                 close (ifd);
 234                 errno = saved_errno;
 235                 return -1;
 236         }
 237
 238         if (transfer_file(ifd, ofd, (size_t)-1) == -1) {
 239                 int saved_errno = errno;
 240                 close (ifd);
 241                 close (ofd);
 242                 unlink (dest);
 243                 errno = saved_errno;
 244                 return -1;
 245         }
 246
 247         if (close (ifd) == -1) {
 248                 int saved_errno = errno;
 249                 close (ofd);
 250                 errno = saved_errno;
 251                 return -1;
 252         }
 253         if (close (ofd) == -1)
 254                 return -1;
 255
 256         /*
 257          * chown turns off set[ug]id bits for non-root,
 258          * so do the chmod last.
 259          */
 260
 261         /* Try to copy the old file's modtime and access time.  */
 262         {
 263                 struct utimbuf tv;
 264
 265                 tv.actime = source_stats.st_atime;
 266                 tv.modtime = source_stats.st_mtime;
 267                 utime (dest, &tv);
 268         }
 269
 270         /*
 271          * Try to preserve ownership.  For non-root it might fail, but that's ok.
 272          * But root probably wants to know, e.g. if NFS disallows it.
 273          */
 274
 275         if ((chown(dest, source_stats.st_uid, source_stats.st_gid) == -1) && (errno != EPERM))
 276                 return -1;
 277
 278         if (chmod (dest, source_stats.st_mode & 07777))
 279                 return -1;
 280
 281         if (unlink (source) == -1)
 282                 return -1;
 283
 284         return 0;
 285 }
 286
 287 int vfswrap_rename(connection_struct *conn, const char *oldname, const char *newname)
 288 {
 289         int result;
 290
 291         START_PROFILE(syscall_rename);
 292         result = rename(oldname, newname);
 293         if (errno == EXDEV) {
 294                 /* Rename across filesystems needed. */
 295                 result = copy_reg(oldname, newname);
 296         }
 297         END_PROFILE(syscall_rename);
 298         return result;
 299 }
 300
 301 int vfswrap_fsync(files_struct *fsp, int fd)
 302 {
 303 #ifdef HAVE_FSYNC
 304     int result;
 305
 306     START_PROFILE(syscall_fsync);
 307     result = fsync(fd);
 308     END_PROFILE(syscall_fsync);
 309     return result;
 310 #else
 311         return 0;
 312 #endif
 313 }
 314
 315 int vfswrap_stat(connection_struct *conn, const char *fname, SMB_STRUCT_STAT *sbuf)
 316 {
 317     int result;
 318
 319     START_PROFILE(syscall_stat);
 320     result = sys_stat(fname, sbuf);
 321     END_PROFILE(syscall_stat);
 322     return result;
 323 }
 324
 325 int vfswrap_fstat(files_struct *fsp, int fd, SMB_STRUCT_STAT *sbuf)
 326 {
 327     int result;
 328
 329     START_PROFILE(syscall_fstat);
 330     result = sys_fstat(fd, sbuf);
 331     END_PROFILE(syscall_fstat);
 332     return result;
 333 }
 334
 335 int vfswrap_lstat(connection_struct *conn, const char *path, SMB_STRUCT_STAT *sbuf)
 336 {
 337     int result;
 338
 339     START_PROFILE(syscall_lstat);
 340     result = sys_lstat(path, sbuf);
 341     END_PROFILE(syscall_lstat);
 342     return result;
 343 }
 344
 345 int vfswrap_unlink(connection_struct *conn, const char *path)
 346 {
 347     int result;
 348
 349     START_PROFILE(syscall_unlink);
 350     result = unlink(path);
 351     END_PROFILE(syscall_unlink);
 352     return result;
 353 }
 354
 355 int vfswrap_chmod(connection_struct *conn, const char *path, mode_t mode)
 356 {
 357     int result;
 358
 359     START_PROFILE(syscall_chmod);
 360
 361         /*
 362          * We need to do this due to the fact that the default POSIX ACL
 363          * chmod modifies the ACL *mask* for the group owner, not the
 364          * group owner bits directly. JRA.
 365          */
 366
 367
 368         if (conn->vfs_ops.chmod_acl != NULL) {
 369                 int saved_errno = errno; /* We might get ENOSYS */
 370                 if ((result = conn->vfs_ops.chmod_acl(conn, path, mode)) == 0) {
 371                         END_PROFILE(syscall_chmod);
 372                         return result;
 373                 }
 374                 /* Error - return the old errno. */
 375                 errno = saved_errno;
 376         }
 377
 378     result = chmod(path, mode);
 379     END_PROFILE(syscall_chmod);
 380     return result;
 381 }
 382
 383 int vfswrap_fchmod(files_struct *fsp, int fd, mode_t mode)
 384 {
 385         int result;
 386         struct vfs_ops *vfs_ops = &fsp->conn->vfs_ops;
 387
 388         START_PROFILE(syscall_fchmod);
 389
 390         /*
 391          * We need to do this due to the fact that the default POSIX ACL
 392          * chmod modifies the ACL *mask* for the group owner, not the
 393          * group owner bits directly. JRA.
 394          */
 395
 396         if (vfs_ops->fchmod_acl != NULL) {
 397                 int saved_errno = errno; /* We might get ENOSYS */
 398                 if ((result = vfs_ops->fchmod_acl(fsp, fd, mode)) == 0) {
 399                         END_PROFILE(syscall_chmod);
 400                         return result;
 401                 }
 402                 /* Error - return the old errno. */
 403                 errno = saved_errno;
 404         }
 405
 406         result = fchmod(fd, mode);
 407         END_PROFILE(syscall_fchmod);
 408         return result;
 409 }
 410
 411 int vfswrap_chown(connection_struct *conn, const char *path, uid_t uid, gid_t gid)
 412 {
 413     int result;
 414
 415     START_PROFILE(syscall_chown);
 416     result = sys_chown(path, uid, gid);
 417     END_PROFILE(syscall_chown);
 418     return result;
 419 }
 420
 421 int vfswrap_fchown(files_struct *fsp, int fd, uid_t uid, gid_t gid)
 422 {
 423 #ifdef HAVE_FCHOWN
 424     int result;
 425
 426     START_PROFILE(syscall_fchown);
 427
 428     result = fchown(fd, uid, gid);
 429     END_PROFILE(syscall_fchown);
 430     return result;
 431 #else
 432     errno = ENOSYS;
 433     return -1;
 434 #endif
 435 }
 436
 437 int vfswrap_chdir(connection_struct *conn, const char *path)
 438 {
 439     int result;
 440
 441     START_PROFILE(syscall_chdir);
 442     result = chdir(path);
 443     END_PROFILE(syscall_chdir);
 444     return result;
 445 }
 446
 447 char *vfswrap_getwd(connection_struct *conn, char *path)
 448 {
 449     char *result;
 450
 451     START_PROFILE(syscall_getwd);
 452     result = sys_getwd(path);
 453     END_PROFILE(syscall_getwd);
 454     return result;
 455 }
 456
 457 int vfswrap_utime(connection_struct *conn, const char *path, struct utimbuf *times)
 458 {
 459     int result;
 460
 461     START_PROFILE(syscall_utime);
 462     result = utime(path, times);
 463     END_PROFILE(syscall_utime);
 464     return result;
 465 }
 466
 467 /*********************************************************************
 468  A version of ftruncate that will write the space on disk if strict
 469  allocate is set.
 470 **********************************************************************/
 471
 472 static int strict_allocate_ftruncate(files_struct *fsp, int fd, SMB_OFF_T len)
 473 {
 474         struct vfs_ops *vfs_ops = &fsp->conn->vfs_ops;
 475         SMB_STRUCT_STAT st;
 476         SMB_OFF_T currpos = vfs_ops->lseek(fsp, fd, 0, SEEK_CUR);
 477         unsigned char zero_space[4096];
 478         SMB_OFF_T space_to_write;
 479
 480         if (currpos == -1)
 481                 return -1;
 482
 483         if (vfs_ops->fstat(fsp, fd, &st) == -1)
 484                 return -1;
 485
 486 #ifdef S_ISFIFO
 487         if (S_ISFIFO(st.st_mode))
 488                 return 0;
 489 #endif
 490
 491         if (st.st_size == len)
 492                 return 0;
 493
 494         /* Shrink - just ftruncate. */
 495         if (st.st_size > len)
 496                 return sys_ftruncate(fd, len);
 497
 498         /* Write out the real space on disk. */
 499         if (vfs_ops->lseek(fsp, fd, st.st_size, SEEK_SET) != st.st_size)
 500                 return -1;
 501
 502         space_to_write = len - st.st_size;
 503
 504         memset(zero_space, '\0', sizeof(zero_space));
 505         while ( space_to_write > 0) {
 506                 SMB_OFF_T retlen;
 507                 SMB_OFF_T current_len_to_write = MIN(sizeof(zero_space),space_to_write);
 508
 509                 retlen = vfs_ops->write(fsp,fsp->fd,(char *)zero_space,current_len_to_write);
 510                 if (retlen <= 0)
 511                         return -1;
 512
 513                 space_to_write -= retlen;
 514         }
 515
 516         /* Seek to where we were */
 517         if (vfs_ops->lseek(fsp, fd, currpos, SEEK_SET) != currpos)
 518                 return -1;
 519
 520         return 0;
 521 }
 522
 523 int vfswrap_ftruncate(files_struct *fsp, int fd, SMB_OFF_T len)
 524 {
 525         int result = -1;
 526         struct vfs_ops *vfs_ops = &fsp->conn->vfs_ops;
 527         SMB_STRUCT_STAT st;
 528         char c = 0;
 529         SMB_OFF_T currpos;
 530
 531         START_PROFILE(syscall_ftruncate);
 532
 533         if (lp_strict_allocate(SNUM(fsp->conn))) {
 534                 result = strict_allocate_ftruncate(fsp, fd, len);
 535                 END_PROFILE(syscall_ftruncate);
 536                 return result;
 537         }
 538
 539         /* we used to just check HAVE_FTRUNCATE_EXTEND and only use
 540            sys_ftruncate if the system supports it. Then I discovered that
 541            you can have some filesystems that support ftruncate
 542            expansion and some that don't! On Linux fat can't do
 543            ftruncate extend but ext2 can. */
 544
 545         result = sys_ftruncate(fd, len);
 546         if (result == 0)
 547                 goto done;
 548
 549         /* According to W. R. Stevens advanced UNIX prog. Pure 4.3 BSD cannot
 550            extend a file with ftruncate. Provide alternate implementation
 551            for this */
 552         currpos = vfs_ops->lseek(fsp, fd, 0, SEEK_CUR);
 553         if (currpos == -1) {
 554                 goto done;
 555         }
 556
 557         /* Do an fstat to see if the file is longer than the requested
 558            size in which case the ftruncate above should have
 559            succeeded or shorter, in which case seek to len - 1 and
 560            write 1 byte of zero */
 561         if (vfs_ops->fstat(fsp, fd, &st) == -1) {
 562                 goto done;
 563         }
 564
 565 #ifdef S_ISFIFO
 566         if (S_ISFIFO(st.st_mode)) {
 567                 result = 0;
 568                 goto done;
 569         }
 570 #endif
 571
 572         if (st.st_size == len) {
 573                 result = 0;
 574                 goto done;
 575         }
 576
 577         if (st.st_size > len) {
 578                 /* the sys_ftruncate should have worked */
 579                 goto done;
 580         }
 581
 582         if (vfs_ops->lseek(fsp, fd, len-1, SEEK_SET) != len -1)
 583                 goto done;
 584
 585         if (vfs_ops->write(fsp, fd, &c, 1)!=1)
 586                 goto done;
 587
 588         /* Seek to where we were */
 589         if (vfs_ops->lseek(fsp, fd, currpos, SEEK_SET) != currpos)
 590                 goto done;
 591         result = 0;
 592
 593   done:
 594
 595         END_PROFILE(syscall_ftruncate);
 596         return result;
 597 }
 598
 599 BOOL vfswrap_lock(files_struct *fsp, int fd, int op, SMB_OFF_T offset, SMB_OFF_T count, int type)
 600 {
 601     BOOL result;
 602
 603     START_PROFILE(syscall_fcntl_lock);
 604     result =  fcntl_lock(fd, op, offset, count,type);
 605     END_PROFILE(syscall_fcntl_lock);
 606     return result;
 607 }
 608
 609 int vfswrap_symlink(connection_struct *conn, const char *oldpath, const char *newpath)
 610 {
 611     int result;
 612
 613     START_PROFILE(syscall_symlink);
 614     result = sys_symlink(oldpath, newpath);
 615     END_PROFILE(syscall_symlink);
 616     return result;
 617 }
 618
 619 int vfswrap_readlink(connection_struct *conn, const char *path, char *buf, size_t bufsiz)
 620 {
 621     int result;
 622
 623     START_PROFILE(syscall_readlink);
 624     result = sys_readlink(path, buf, bufsiz);
 625     END_PROFILE(syscall_readlink);
 626     return result;
 627 }
 628
 629 int vfswrap_link(connection_struct *conn, const char *oldpath, const char *newpath)
 630 {
 631         int result;
 632
 633         START_PROFILE(syscall_link);
 634         result = sys_link(oldpath, newpath);
 635         END_PROFILE(syscall_link);
 636         return result;
 637 }
 638
 639 int vfswrap_mknod(connection_struct *conn, const char *pathname, mode_t mode, SMB_DEV_T dev)
 640 {
 641         int result;
 642
 643         START_PROFILE(syscall_mknod);
 644         result = sys_mknod(pathname, mode, dev);
 645         END_PROFILE(syscall_mknod);
 646         return result;
 647 }
 648
 649 char *vfswrap_realpath(connection_struct *conn, const char *path, char *resolved_path)
 650 {
 651         char *result;
 652
 653         START_PROFILE(syscall_realpath);
 654         result = sys_realpath(path, resolved_path);
 655         END_PROFILE(syscall_realpath);
 656         return result;
 657 }
 658
 659 size_t vfswrap_fget_nt_acl(files_struct *fsp, int fd, SEC_DESC **ppdesc)
 660 {
 661         size_t result;
 662
 663         START_PROFILE(fget_nt_acl);
 664         result = get_nt_acl(fsp, ppdesc);
 665         END_PROFILE(fget_nt_acl);
 666         return result;
 667 }
 668
 669 size_t vfswrap_get_nt_acl(files_struct *fsp, const char *name, SEC_DESC **ppdesc)
 670 {
 671         size_t result;
 672
 673         START_PROFILE(get_nt_acl);
 674         result = get_nt_acl(fsp, ppdesc);
 675         END_PROFILE(get_nt_acl);
 676         return result;
 677 }
 678
 679 BOOL vfswrap_fset_nt_acl(files_struct *fsp, int fd, uint32 security_info_sent, SEC_DESC *psd)
 680 {
 681         BOOL result;
 682
 683         START_PROFILE(fset_nt_acl);
 684         result = set_nt_acl(fsp, security_info_sent, psd);
 685         END_PROFILE(fset_nt_acl);
 686         return result;
 687 }
 688
 689 BOOL vfswrap_set_nt_acl(files_struct *fsp, const char *name, uint32 security_info_sent, SEC_DESC *psd)
 690 {
 691         BOOL result;
 692
 693         START_PROFILE(set_nt_acl);
 694         result = set_nt_acl(fsp, security_info_sent, psd);
 695         END_PROFILE(set_nt_acl);
 696         return result;
 697 }
 698
 699 int vfswrap_chmod_acl(connection_struct *conn, const char *name, mode_t mode)
 700 {
 701         int result;
 702
 703         START_PROFILE(chmod_acl);
 704         result = chmod_acl(conn, name, mode);
 705         END_PROFILE(chmod_acl);
 706         return result;
 707 }
 708
 709 int vfswrap_fchmod_acl(files_struct *fsp, int fd, mode_t mode)
 710 {
 711         int result;
 712
 713         START_PROFILE(fchmod_acl);
 714         result = fchmod_acl(fsp, fd, mode);
 715         END_PROFILE(fchmod_acl);
 716         return result;
 717 }
 718
 719 int vfswrap_sys_acl_get_entry(struct connection_struct *conn, SMB_ACL_T theacl, int entry_id, SMB_ACL_ENTRY_T *entry_p)
 720 {
 721         return sys_acl_get_entry(theacl, entry_id, entry_p);
 722 }
 723
 724 int vfswrap_sys_acl_get_tag_type(struct connection_struct *conn, SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T *tag_type_p)
 725 {
 726         return sys_acl_get_tag_type(entry_d, tag_type_p);
 727 }
 728
 729 int vfswrap_sys_acl_get_permset(struct connection_struct *conn, SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T *permset_p)
 730 {
 731         return sys_acl_get_permset(entry_d, permset_p);
 732 }
 733
 734 void * vfswrap_sys_acl_get_qualifier(struct connection_struct *conn, SMB_ACL_ENTRY_T entry_d)
 735 {
 736         return sys_acl_get_qualifier(entry_d);
 737 }
 738
 739 SMB_ACL_T vfswrap_sys_acl_get_file(struct connection_struct *conn, const char *path_p, SMB_ACL_TYPE_T type)
 740 {
 741         return sys_acl_get_file(path_p, type);
 742 }
 743
 744 SMB_ACL_T vfswrap_sys_acl_get_fd(struct files_struct *fsp, int fd)
 745 {
 746         return sys_acl_get_fd(fd);
 747 }
 748
 749 int vfswrap_sys_acl_clear_perms(struct connection_struct *conn, SMB_ACL_PERMSET_T permset)
 750 {
 751         return sys_acl_clear_perms(permset);
 752 }
 753
 754 int vfswrap_sys_acl_add_perm(struct connection_struct *conn, SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm)
 755 {
 756         return sys_acl_add_perm(permset, perm);
 757 }
 758
 759 char * vfswrap_sys_acl_to_text(struct connection_struct *conn, SMB_ACL_T theacl, ssize_t *plen)
 760 {
 761         return sys_acl_to_text(theacl, plen);
 762 }
 763
 764 SMB_ACL_T vfswrap_sys_acl_init(struct connection_struct *conn, int count)
 765 {
 766         return sys_acl_init(count);
 767 }
 768
 769 int vfswrap_sys_acl_create_entry(struct connection_struct *conn, SMB_ACL_T *pacl, SMB_ACL_ENTRY_T *pentry)
 770 {
 771         return sys_acl_create_entry(pacl, pentry);
 772 }
 773
 774 int vfswrap_sys_acl_set_tag_type(struct connection_struct *conn, SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T tagtype)
 775 {
 776         return sys_acl_set_tag_type(entry, tagtype);
 777 }
 778
 779 int vfswrap_sys_acl_set_qualifier(struct connection_struct *conn, SMB_ACL_ENTRY_T entry, void *qual)
 780 {
 781         return sys_acl_set_qualifier(entry, qual);
 782 }
 783
 784 int vfswrap_sys_acl_set_permset(struct connection_struct *conn, SMB_ACL_ENTRY_T entry, SMB_ACL_PERMSET_T permset)
 785 {
 786         return sys_acl_set_permset(entry, permset);
 787 }
 788
 789 int vfswrap_sys_acl_valid(struct connection_struct *conn, SMB_ACL_T theacl )
 790 {
 791         return sys_acl_valid(theacl );
 792 }
 793
 794 int vfswrap_sys_acl_set_file(struct connection_struct *conn, const char *name, SMB_ACL_TYPE_T acltype, SMB_ACL_T theacl)
 795 {
 796         return sys_acl_set_file(name, acltype, theacl);
 797 }
 798
 799 int vfswrap_sys_acl_set_fd(struct files_struct *fsp, int fd, SMB_ACL_T theacl)
 800 {
 801         return sys_acl_set_fd(fd, theacl);
 802 }
 803
 804 int vfswrap_sys_acl_delete_def_file(struct connection_struct *conn, const char *path)
 805 {
 806         return sys_acl_delete_def_file(path);
 807 }
 808
 809 int vfswrap_sys_acl_get_perm(struct connection_struct *conn, SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm)
 810 {
 811         return sys_acl_get_perm(permset, perm);
 812 }
 813
 814 int vfswrap_sys_acl_free_text(struct connection_struct *conn, char *text)
 815 {
 816         return sys_acl_free_text(text);
 817 }
 818
 819 int vfswrap_sys_acl_free_acl(struct connection_struct *conn, SMB_ACL_T posix_acl)
 820 {
 821         return sys_acl_free_acl(posix_acl);
 822 }
 823
 824 int vfswrap_sys_acl_free_qualifier(struct connection_struct *conn, void *qualifier, SMB_ACL_TAG_T tagtype)
 825 {
 826         return sys_acl_free_qualifier(qualifier, tagtype);
 827 }