source/smbd/vfs-wrap.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    Wrap disk only vfs functions to sidestep dodgy compilers.
   4    Copyright (C) Tim Potter 1998
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19 */
  20
  21 #include "includes.h"
  22
  23 #undef DBGC_CLASS
  24 #define DBGC_CLASS DBGC_VFS
  25
  26
  27 /* Check for NULL pointer parameters in vfswrap_* functions */
  28
  29 /* We don't want to have NULL function pointers lying around.  Someone
  30    is sure to try and execute them.  These stubs are used to prevent
  31    this possibility. */
  32
  33 int vfswrap_dummy_connect(vfs_handle_struct *handle, connection_struct *conn, const char *service, const char *user)
  34 {
  35     return 0;    /* Return >= 0 for success */
  36 }
  37
  38 void vfswrap_dummy_disconnect(vfs_handle_struct *handle, connection_struct *conn)
  39 {
  40 }
  41
  42 /* Disk operations */
  43
  44 SMB_BIG_UINT vfswrap_disk_free(vfs_handle_struct *handle, connection_struct *conn, const char *path, BOOL small_query, SMB_BIG_UINT *bsize,
  45                                SMB_BIG_UINT *dfree, SMB_BIG_UINT *dsize)
  46 {
  47         SMB_BIG_UINT result;
  48
  49         result = sys_disk_free(conn, path, small_query, bsize, dfree, dsize);
  50         return result;
  51 }
  52
  53 int vfswrap_get_quota(struct vfs_handle_struct *handle, struct connection_struct *conn, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *qt)
  54 {
  55 #ifdef HAVE_SYS_QUOTAS
  56         int result;
  57
  58         START_PROFILE(syscall_get_quota);
  59         result = sys_get_quota(conn->connectpath, qtype, id, qt);
  60         END_PROFILE(syscall_get_quota);
  61         return result;
  62 #else
  63         errno = ENOSYS;
  64         return -1;
  65 #endif
  66 }
  67
  68 int vfswrap_set_quota(struct vfs_handle_struct *handle, struct connection_struct *conn, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *qt)
  69 {
  70 #ifdef HAVE_SYS_QUOTAS
  71         int result;
  72
  73         START_PROFILE(syscall_set_quota);
  74         result = sys_set_quota(conn->connectpath, qtype, id, qt);
  75         END_PROFILE(syscall_set_quota);
  76         return result;
  77 #else
  78         errno = ENOSYS;
  79         return -1;
  80 #endif
  81 }
  82
  83 int vfswrap_get_shadow_copy_data(struct vfs_handle_struct *handle, struct files_struct *fsp, SHADOW_COPY_DATA *shadow_copy_data, BOOL labels)
  84 {
  85         errno = ENOSYS;
  86         return -1;  /* Not implemented. */
  87 }
  88
  89 int vfswrap_statvfs(struct vfs_handle_struct *handle, struct connection_struct *conn, const char *path, vfs_statvfs_struct *statbuf)
  90 {
  91         return sys_statvfs(path, statbuf);
  92 }
  93
  94 /* Directory operations */
  95
  96 SMB_STRUCT_DIR *vfswrap_opendir(vfs_handle_struct *handle, connection_struct *conn, const char *fname, const char *mask, uint32 attr)
  97 {
  98         SMB_STRUCT_DIR *result;
  99
 100         START_PROFILE(syscall_opendir);
 101         result = sys_opendir(fname);
 102         END_PROFILE(syscall_opendir);
 103         return result;
 104 }
 105
 106 SMB_STRUCT_DIRENT *vfswrap_readdir(vfs_handle_struct *handle, connection_struct *conn, SMB_STRUCT_DIR *dirp)
 107 {
 108         SMB_STRUCT_DIRENT *result;
 109
 110         START_PROFILE(syscall_readdir);
 111         result = sys_readdir(dirp);
 112         END_PROFILE(syscall_readdir);
 113         return result;
 114 }
 115
 116 void vfswrap_seekdir(vfs_handle_struct *handle, connection_struct *conn, SMB_STRUCT_DIR *dirp, long offset)
 117 {
 118         START_PROFILE(syscall_seekdir);
 119         sys_seekdir(dirp, offset);
 120         END_PROFILE(syscall_seekdir);
 121 }
 122
 123 long vfswrap_telldir(vfs_handle_struct *handle, connection_struct *conn, SMB_STRUCT_DIR *dirp)
 124 {
 125         long result;
 126         START_PROFILE(syscall_telldir);
 127         result = sys_telldir(dirp);
 128         END_PROFILE(syscall_telldir);
 129         return result;
 130 }
 131
 132 void vfswrap_rewinddir(vfs_handle_struct *handle, connection_struct *conn, SMB_STRUCT_DIR *dirp)
 133 {
 134         START_PROFILE(syscall_rewinddir);
 135         sys_rewinddir(dirp);
 136         END_PROFILE(syscall_rewinddir);
 137 }
 138
 139 int vfswrap_mkdir(vfs_handle_struct *handle, connection_struct *conn, const char *path, mode_t mode)
 140 {
 141         int result;
 142         BOOL has_dacl = False;
 143
 144         START_PROFILE(syscall_mkdir);
 145
 146         if (lp_inherit_acls(SNUM(conn)) && (has_dacl = directory_has_default_acl(conn, parent_dirname(path))))
 147                 mode = 0777;
 148
 149         result = mkdir(path, mode);
 150
 151         if (result == 0 && !has_dacl) {
 152                 /*
 153                  * We need to do this as the default behavior of POSIX ACLs
 154                  * is to set the mask to be the requested group permission
 155                  * bits, not the group permission bits to be the requested
 156                  * group permission bits. This is not what we want, as it will
 157                  * mess up any inherited ACL bits that were set. JRA.
 158                  */
 159                 int saved_errno = errno; /* We may get ENOSYS */
 160                 if ((SMB_VFS_CHMOD_ACL(conn, path, mode) == -1) && (errno == ENOSYS))
 161                         errno = saved_errno;
 162         }
 163
 164         END_PROFILE(syscall_mkdir);
 165         return result;
 166 }
 167
 168 int vfswrap_rmdir(vfs_handle_struct *handle, connection_struct *conn, const char *path)
 169 {
 170         int result;
 171
 172         START_PROFILE(syscall_rmdir);
 173         result = rmdir(path);
 174         END_PROFILE(syscall_rmdir);
 175         return result;
 176 }
 177
 178 int vfswrap_closedir(vfs_handle_struct *handle, connection_struct *conn, SMB_STRUCT_DIR *dirp)
 179 {
 180         int result;
 181
 182         START_PROFILE(syscall_closedir);
 183         result = sys_closedir(dirp);
 184         END_PROFILE(syscall_closedir);
 185         return result;
 186 }
 187
 188 /* File operations */
 189
 190 int vfswrap_open(vfs_handle_struct *handle, connection_struct *conn, const char *fname, int flags, mode_t mode)
 191 {
 192         int result;
 193
 194         START_PROFILE(syscall_open);
 195         result = sys_open(fname, flags, mode);
 196         END_PROFILE(syscall_open);
 197         return result;
 198 }
 199
 200 int vfswrap_close(vfs_handle_struct *handle, files_struct *fsp, int fd)
 201 {
 202         int result;
 203
 204         START_PROFILE(syscall_close);
 205
 206         result = close(fd);
 207         END_PROFILE(syscall_close);
 208         return result;
 209 }
 210
 211 ssize_t vfswrap_read(vfs_handle_struct *handle, files_struct *fsp, int fd, void *data, size_t n)
 212 {
 213         ssize_t result;
 214
 215         START_PROFILE_BYTES(syscall_read, n);
 216         result = sys_read(fd, data, n);
 217         END_PROFILE(syscall_read);
 218         return result;
 219 }
 220
 221 ssize_t vfswrap_pread(vfs_handle_struct *handle, files_struct *fsp, int fd, void *data,
 222                         size_t n, SMB_OFF_T offset)
 223 {
 224         ssize_t result;
 225
 226 #if defined(HAVE_PREAD) || defined(HAVE_PREAD64)
 227         START_PROFILE_BYTES(syscall_pread, n);
 228         result = sys_pread(fd, data, n, offset);
 229         END_PROFILE(syscall_pread);
 230
 231         if (result == -1 && errno == ESPIPE) {
 232                 /* Maintain the fiction that pipes can be seeked (sought?) on. */
 233                 result = SMB_VFS_READ(fsp, fd, data, n);
 234                 fsp->fh->pos = 0;
 235         }
 236
 237 #else /* HAVE_PREAD */
 238         SMB_OFF_T   curr;
 239         int lerrno;
 240
 241         curr = SMB_VFS_LSEEK(fsp, fd, 0, SEEK_CUR);
 242         if (curr == -1 && errno == ESPIPE) {
 243                 /* Maintain the fiction that pipes can be seeked (sought?) on. */
 244                 result = SMB_VFS_READ(fsp, fd, data, n);
 245                 fsp->fh->pos = 0;
 246                 return result;
 247         }
 248
 249         if (SMB_VFS_LSEEK(fsp, fd, offset, SEEK_SET) == -1) {
 250                 return -1;
 251         }
 252
 253         errno = 0;
 254         result = SMB_VFS_READ(fsp, fd, data, n);
 255         lerrno = errno;
 256
 257         SMB_VFS_LSEEK(fsp, fd, curr, SEEK_SET);
 258         errno = lerrno;
 259
 260 #endif /* HAVE_PREAD */
 261
 262         return result;
 263 }
 264
 265 ssize_t vfswrap_write(vfs_handle_struct *handle, files_struct *fsp, int fd, const void *data, size_t n)
 266 {
 267         ssize_t result;
 268
 269         START_PROFILE_BYTES(syscall_write, n);
 270         result = sys_write(fd, data, n);
 271         END_PROFILE(syscall_write);
 272         return result;
 273 }
 274
 275 ssize_t vfswrap_pwrite(vfs_handle_struct *handle, files_struct *fsp, int fd, const void *data,
 276                         size_t n, SMB_OFF_T offset)
 277 {
 278         ssize_t result;
 279
 280 #if defined(HAVE_PWRITE) || defined(HAVE_PRWITE64)
 281         START_PROFILE_BYTES(syscall_pwrite, n);
 282         result = sys_pwrite(fd, data, n, offset);
 283         END_PROFILE(syscall_pwrite);
 284
 285         if (result == -1 && errno == ESPIPE) {
 286                 /* Maintain the fiction that pipes can be sought on. */
 287                 result = SMB_VFS_WRITE(fsp, fd, data, n);
 288         }
 289
 290 #else /* HAVE_PWRITE */
 291         SMB_OFF_T   curr;
 292         int         lerrno;
 293
 294         curr = SMB_VFS_LSEEK(fsp, fd, 0, SEEK_CUR);
 295         if (curr == -1) {
 296                 return -1;
 297         }
 298
 299         if (SMB_VFS_LSEEK(fsp, fd, offset, SEEK_SET) == -1) {
 300                 return -1;
 301         }
 302
 303         result = SMB_VFS_WRITE(fsp, fd, data, n);
 304         lerrno = errno;
 305
 306         SMB_VFS_LSEEK(fsp, fd, curr, SEEK_SET);
 307         errno = lerrno;
 308
 309 #endif /* HAVE_PWRITE */
 310
 311         return result;
 312 }
 313
 314 SMB_OFF_T vfswrap_lseek(vfs_handle_struct *handle, files_struct *fsp, int filedes, SMB_OFF_T offset, int whence)
 315 {
 316         SMB_OFF_T result = 0;
 317
 318         START_PROFILE(syscall_lseek);
 319
 320         /* Cope with 'stat' file opens. */
 321         if (filedes != -1)
 322                 result = sys_lseek(filedes, offset, whence);
 323
 324         /*
 325          * We want to maintain the fiction that we can seek
 326          * on a fifo for file system purposes. This allows
 327          * people to set up UNIX fifo's that feed data to Windows
 328          * applications. JRA.
 329          */
 330
 331         if((result == -1) && (errno == ESPIPE)) {
 332                 result = 0;
 333                 errno = 0;
 334         }
 335
 336         END_PROFILE(syscall_lseek);
 337         return result;
 338 }
 339
 340 ssize_t vfswrap_sendfile(vfs_handle_struct *handle, int tofd, files_struct *fsp, int fromfd, const DATA_BLOB *hdr,
 341                         SMB_OFF_T offset, size_t n)
 342 {
 343         ssize_t result;
 344
 345         START_PROFILE_BYTES(syscall_sendfile, n);
 346         result = sys_sendfile(tofd, fromfd, hdr, offset, n);
 347         END_PROFILE(syscall_sendfile);
 348         return result;
 349 }
 350
 351 /*********************************************************
 352  For rename across filesystems Patch from Warren Birnbaum
 353  <warrenb@hpcvscdp.cv.hp.com>
 354 **********************************************************/
 355
 356 static int copy_reg(const char *source, const char *dest)
 357 {
 358         SMB_STRUCT_STAT source_stats;
 359         int saved_errno;
 360         int ifd = -1;
 361         int ofd = -1;
 362
 363         if (sys_lstat (source, &source_stats) == -1)
 364                 return -1;
 365
 366         if (!S_ISREG (source_stats.st_mode))
 367                 return -1;
 368
 369         if((ifd = sys_open (source, O_RDONLY, 0)) < 0)
 370                 return -1;
 371
 372         if (unlink (dest) && errno != ENOENT)
 373                 return -1;
 374
 375 #ifdef O_NOFOLLOW
 376         if((ofd = sys_open (dest, O_WRONLY | O_CREAT | O_TRUNC | O_NOFOLLOW, 0600)) < 0 )
 377 #else
 378         if((ofd = sys_open (dest, O_WRONLY | O_CREAT | O_TRUNC , 0600)) < 0 )
 379 #endif
 380                 goto err;
 381
 382         if (transfer_file(ifd, ofd, (size_t)-1) == -1)
 383                 goto err;
 384
 385         /*
 386          * Try to preserve ownership.  For non-root it might fail, but that's ok.
 387          * But root probably wants to know, e.g. if NFS disallows it.
 388          */
 389
 390 #ifdef HAVE_FCHOWN
 391         if ((fchown(ofd, source_stats.st_uid, source_stats.st_gid) == -1) && (errno != EPERM))
 392 #else
 393         if ((chown(dest, source_stats.st_uid, source_stats.st_gid) == -1) && (errno != EPERM))
 394 #endif
 395                 goto err;
 396
 397         /*
 398          * fchown turns off set[ug]id bits for non-root,
 399          * so do the chmod last.
 400          */
 401
 402 #if defined(HAVE_FCHMOD)
 403         if (fchmod (ofd, source_stats.st_mode & 07777))
 404 #else
 405         if (chmod (dest, source_stats.st_mode & 07777))
 406 #endif
 407                 goto err;
 408
 409         if (close (ifd) == -1)
 410                 goto err;
 411
 412         if (close (ofd) == -1)
 413                 return -1;
 414
 415         /* Try to copy the old file's modtime and access time.  */
 416         {
 417                 struct utimbuf tv;
 418
 419                 tv.actime = source_stats.st_atime;
 420                 tv.modtime = source_stats.st_mtime;
 421                 utime(dest, &tv);
 422         }
 423
 424         if (unlink (source) == -1)
 425                 return -1;
 426
 427         return 0;
 428
 429   err:
 430
 431         saved_errno = errno;
 432         if (ifd != -1)
 433                 close(ifd);
 434         if (ofd != -1)
 435                 close(ofd);
 436         errno = saved_errno;
 437         return -1;
 438 }
 439
 440 int vfswrap_rename(vfs_handle_struct *handle, connection_struct *conn, const char *oldname, const char *newname)
 441 {
 442         int result;
 443
 444         START_PROFILE(syscall_rename);
 445         result = rename(oldname, newname);
 446         if (errno == EXDEV) {
 447                 /* Rename across filesystems needed. */
 448                 result = copy_reg(oldname, newname);
 449         }
 450
 451         END_PROFILE(syscall_rename);
 452         return result;
 453 }
 454
 455 int vfswrap_fsync(vfs_handle_struct *handle, files_struct *fsp, int fd)
 456 {
 457 #ifdef HAVE_FSYNC
 458         int result;
 459
 460         START_PROFILE(syscall_fsync);
 461         result = fsync(fd);
 462         END_PROFILE(syscall_fsync);
 463         return result;
 464 #else
 465         return 0;
 466 #endif
 467 }
 468
 469 int vfswrap_stat(vfs_handle_struct *handle, connection_struct *conn, const char *fname, SMB_STRUCT_STAT *sbuf)
 470 {
 471         int result;
 472
 473         START_PROFILE(syscall_stat);
 474         result = sys_stat(fname, sbuf);
 475         END_PROFILE(syscall_stat);
 476         return result;
 477 }
 478
 479 int vfswrap_fstat(vfs_handle_struct *handle, files_struct *fsp, int fd, SMB_STRUCT_STAT *sbuf)
 480 {
 481         int result;
 482
 483         START_PROFILE(syscall_fstat);
 484         result = sys_fstat(fd, sbuf);
 485         END_PROFILE(syscall_fstat);
 486         return result;
 487 }
 488
 489 int vfswrap_lstat(vfs_handle_struct *handle, connection_struct *conn, const char *path, SMB_STRUCT_STAT *sbuf)
 490 {
 491         int result;
 492
 493         START_PROFILE(syscall_lstat);
 494         result = sys_lstat(path, sbuf);
 495         END_PROFILE(syscall_lstat);
 496         return result;
 497 }
 498
 499 int vfswrap_unlink(vfs_handle_struct *handle, connection_struct *conn, const char *path)
 500 {
 501         int result;
 502
 503         START_PROFILE(syscall_unlink);
 504         result = unlink(path);
 505         END_PROFILE(syscall_unlink);
 506         return result;
 507 }
 508
 509 int vfswrap_chmod(vfs_handle_struct *handle, connection_struct *conn, const char *path, mode_t mode)
 510 {
 511         int result;
 512
 513         START_PROFILE(syscall_chmod);
 514
 515         /*
 516          * We need to do this due to the fact that the default POSIX ACL
 517          * chmod modifies the ACL *mask* for the group owner, not the
 518          * group owner bits directly. JRA.
 519          */
 520
 521
 522         {
 523                 int saved_errno = errno; /* We might get ENOSYS */
 524                 if ((result = SMB_VFS_CHMOD_ACL(conn, path, mode)) == 0) {
 525                         END_PROFILE(syscall_chmod);
 526                         return result;
 527                 }
 528                 /* Error - return the old errno. */
 529                 errno = saved_errno;
 530         }
 531
 532         result = chmod(path, mode);
 533         END_PROFILE(syscall_chmod);
 534         return result;
 535 }
 536
 537 int vfswrap_fchmod(vfs_handle_struct *handle, files_struct *fsp, int fd, mode_t mode)
 538 {
 539         int result;
 540
 541         START_PROFILE(syscall_fchmod);
 542
 543         /*
 544          * We need to do this due to the fact that the default POSIX ACL
 545          * chmod modifies the ACL *mask* for the group owner, not the
 546          * group owner bits directly. JRA.
 547          */
 548
 549         {
 550                 int saved_errno = errno; /* We might get ENOSYS */
 551                 if ((result = SMB_VFS_FCHMOD_ACL(fsp, fd, mode)) == 0) {
 552                         END_PROFILE(syscall_fchmod);
 553                         return result;
 554                 }
 555                 /* Error - return the old errno. */
 556                 errno = saved_errno;
 557         }
 558
 559 #if defined(HAVE_FCHMOD)
 560         result = fchmod(fd, mode);
 561 #else
 562         result = -1;
 563         errno = ENOSYS;
 564 #endif
 565
 566         END_PROFILE(syscall_fchmod);
 567         return result;
 568 }
 569
 570 int vfswrap_chown(vfs_handle_struct *handle, connection_struct *conn, const char *path, uid_t uid, gid_t gid)
 571 {
 572         int result;
 573
 574         START_PROFILE(syscall_chown);
 575         result = sys_chown(path, uid, gid);
 576         END_PROFILE(syscall_chown);
 577         return result;
 578 }
 579
 580 int vfswrap_fchown(vfs_handle_struct *handle, files_struct *fsp, int fd, uid_t uid, gid_t gid)
 581 {
 582 #ifdef HAVE_FCHOWN
 583         int result;
 584
 585         START_PROFILE(syscall_fchown);
 586         result = fchown(fd, uid, gid);
 587         END_PROFILE(syscall_fchown);
 588         return result;
 589 #else
 590         errno = ENOSYS;
 591         return -1;
 592 #endif
 593 }
 594
 595 int vfswrap_chdir(vfs_handle_struct *handle, connection_struct *conn, const char *path)
 596 {
 597         int result;
 598
 599         START_PROFILE(syscall_chdir);
 600         result = chdir(path);
 601         END_PROFILE(syscall_chdir);
 602         return result;
 603 }
 604
 605 char *vfswrap_getwd(vfs_handle_struct *handle, connection_struct *conn, char *path)
 606 {
 607         char *result;
 608
 609         START_PROFILE(syscall_getwd);
 610         result = sys_getwd(path);
 611         END_PROFILE(syscall_getwd);
 612         return result;
 613 }
 614
 615 int vfswrap_utime(vfs_handle_struct *handle, connection_struct *conn, const char *path, struct utimbuf *times)
 616 {
 617         int result;
 618
 619         START_PROFILE(syscall_utime);
 620         result = utime(path, times);
 621         END_PROFILE(syscall_utime);
 622         return result;
 623 }
 624
 625 /*********************************************************************
 626  A version of ftruncate that will write the space on disk if strict
 627  allocate is set.
 628 **********************************************************************/
 629
 630 static int strict_allocate_ftruncate(vfs_handle_struct *handle, files_struct *fsp, int fd, SMB_OFF_T len)
 631 {
 632         SMB_STRUCT_STAT st;
 633         SMB_OFF_T currpos = SMB_VFS_LSEEK(fsp, fd, 0, SEEK_CUR);
 634         unsigned char zero_space[4096];
 635         SMB_OFF_T space_to_write;
 636
 637         if (currpos == -1)
 638                 return -1;
 639
 640         if (SMB_VFS_FSTAT(fsp, fd, &st) == -1)
 641                 return -1;
 642
 643         space_to_write = len - st.st_size;
 644
 645 #ifdef S_ISFIFO
 646         if (S_ISFIFO(st.st_mode))
 647                 return 0;
 648 #endif
 649
 650         if (st.st_size == len)
 651                 return 0;
 652
 653         /* Shrink - just ftruncate. */
 654         if (st.st_size > len)
 655                 return sys_ftruncate(fd, len);
 656
 657         /* Write out the real space on disk. */
 658         if (SMB_VFS_LSEEK(fsp, fd, st.st_size, SEEK_SET) != st.st_size)
 659                 return -1;
 660
 661         space_to_write = len - st.st_size;
 662
 663         memset(zero_space, '\0', sizeof(zero_space));
 664         while ( space_to_write > 0) {
 665                 SMB_OFF_T retlen;
 666                 SMB_OFF_T current_len_to_write = MIN(sizeof(zero_space),space_to_write);
 667
 668                 retlen = SMB_VFS_WRITE(fsp,fsp->fh->fd,(char *)zero_space,current_len_to_write);
 669                 if (retlen <= 0)
 670                         return -1;
 671
 672                 space_to_write -= retlen;
 673         }
 674
 675         /* Seek to where we were */
 676         if (SMB_VFS_LSEEK(fsp, fd, currpos, SEEK_SET) != currpos)
 677                 return -1;
 678
 679         return 0;
 680 }
 681
 682 int vfswrap_ftruncate(vfs_handle_struct *handle, files_struct *fsp, int fd, SMB_OFF_T len)
 683 {
 684         int result = -1;
 685         SMB_STRUCT_STAT st;
 686         char c = 0;
 687         SMB_OFF_T currpos;
 688
 689         START_PROFILE(syscall_ftruncate);
 690
 691         if (lp_strict_allocate(SNUM(fsp->conn))) {
 692                 result = strict_allocate_ftruncate(handle, fsp, fd, len);
 693                 END_PROFILE(syscall_ftruncate);
 694                 return result;
 695         }
 696
 697         /* we used to just check HAVE_FTRUNCATE_EXTEND and only use
 698            sys_ftruncate if the system supports it. Then I discovered that
 699            you can have some filesystems that support ftruncate
 700            expansion and some that don't! On Linux fat can't do
 701            ftruncate extend but ext2 can. */
 702
 703         result = sys_ftruncate(fd, len);
 704         if (result == 0)
 705                 goto done;
 706
 707         /* According to W. R. Stevens advanced UNIX prog. Pure 4.3 BSD cannot
 708            extend a file with ftruncate. Provide alternate implementation
 709            for this */
 710         currpos = SMB_VFS_LSEEK(fsp, fd, 0, SEEK_CUR);
 711         if (currpos == -1) {
 712                 goto done;
 713         }
 714
 715         /* Do an fstat to see if the file is longer than the requested
 716            size in which case the ftruncate above should have
 717            succeeded or shorter, in which case seek to len - 1 and
 718            write 1 byte of zero */
 719         if (SMB_VFS_FSTAT(fsp, fd, &st) == -1) {
 720                 goto done;
 721         }
 722
 723 #ifdef S_ISFIFO
 724         if (S_ISFIFO(st.st_mode)) {
 725                 result = 0;
 726                 goto done;
 727         }
 728 #endif
 729
 730         if (st.st_size == len) {
 731                 result = 0;
 732                 goto done;
 733         }
 734
 735         if (st.st_size > len) {
 736                 /* the sys_ftruncate should have worked */
 737                 goto done;
 738         }
 739
 740         if (SMB_VFS_LSEEK(fsp, fd, len-1, SEEK_SET) != len -1)
 741                 goto done;
 742
 743         if (SMB_VFS_WRITE(fsp, fd, &c, 1)!=1)
 744                 goto done;
 745
 746         /* Seek to where we were */
 747         if (SMB_VFS_LSEEK(fsp, fd, currpos, SEEK_SET) != currpos)
 748                 goto done;
 749         result = 0;
 750
 751   done:
 752
 753         END_PROFILE(syscall_ftruncate);
 754         return result;
 755 }
 756
 757 BOOL vfswrap_lock(vfs_handle_struct *handle, files_struct *fsp, int fd, int op, SMB_OFF_T offset, SMB_OFF_T count, int type)
 758 {
 759         BOOL result;
 760
 761         START_PROFILE(syscall_fcntl_lock);
 762         result =  fcntl_lock(fd, op, offset, count, type);
 763         END_PROFILE(syscall_fcntl_lock);
 764         return result;
 765 }
 766
 767 BOOL vfswrap_getlock(vfs_handle_struct *handle, files_struct *fsp, int fd, SMB_OFF_T *poffset, SMB_OFF_T *pcount, int *ptype, pid_t *ppid)
 768 {
 769         BOOL result;
 770
 771         START_PROFILE(syscall_fcntl_getlock);
 772         result =  fcntl_getlock(fd, poffset, pcount, ptype, ppid);
 773         END_PROFILE(syscall_fcntl_getlock);
 774         return result;
 775 }
 776
 777 int vfswrap_symlink(vfs_handle_struct *handle, connection_struct *conn, const char *oldpath, const char *newpath)
 778 {
 779         int result;
 780
 781         START_PROFILE(syscall_symlink);
 782         result = sys_symlink(oldpath, newpath);
 783         END_PROFILE(syscall_symlink);
 784         return result;
 785 }
 786
 787 int vfswrap_readlink(vfs_handle_struct *handle, connection_struct *conn, const char *path, char *buf, size_t bufsiz)
 788 {
 789         int result;
 790
 791         START_PROFILE(syscall_readlink);
 792         result = sys_readlink(path, buf, bufsiz);
 793         END_PROFILE(syscall_readlink);
 794         return result;
 795 }
 796
 797 int vfswrap_link(vfs_handle_struct *handle, connection_struct *conn, const char *oldpath, const char *newpath)
 798 {
 799         int result;
 800
 801         START_PROFILE(syscall_link);
 802         result = sys_link(oldpath, newpath);
 803         END_PROFILE(syscall_link);
 804         return result;
 805 }
 806
 807 int vfswrap_mknod(vfs_handle_struct *handle, connection_struct *conn, const char *pathname, mode_t mode, SMB_DEV_T dev)
 808 {
 809         int result;
 810
 811         START_PROFILE(syscall_mknod);
 812         result = sys_mknod(pathname, mode, dev);
 813         END_PROFILE(syscall_mknod);
 814         return result;
 815 }
 816
 817 char *vfswrap_realpath(vfs_handle_struct *handle, connection_struct *conn, const char *path, char *resolved_path)
 818 {
 819         char *result;
 820
 821         START_PROFILE(syscall_realpath);
 822         result = sys_realpath(path, resolved_path);
 823         END_PROFILE(syscall_realpath);
 824         return result;
 825 }
 826
 827 size_t vfswrap_fget_nt_acl(vfs_handle_struct *handle, files_struct *fsp, int fd, uint32 security_info, SEC_DESC **ppdesc)
 828 {
 829         size_t result;
 830
 831         START_PROFILE(fget_nt_acl);
 832         result = get_nt_acl(fsp, security_info, ppdesc);
 833         END_PROFILE(fget_nt_acl);
 834         return result;
 835 }
 836
 837 size_t vfswrap_get_nt_acl(vfs_handle_struct *handle, files_struct *fsp, const char *name, uint32 security_info, SEC_DESC **ppdesc)
 838 {
 839         size_t result;
 840
 841         START_PROFILE(get_nt_acl);
 842         result = get_nt_acl(fsp, security_info, ppdesc);
 843         END_PROFILE(get_nt_acl);
 844         return result;
 845 }
 846
 847 BOOL vfswrap_fset_nt_acl(vfs_handle_struct *handle, files_struct *fsp, int fd, uint32 security_info_sent, SEC_DESC *psd)
 848 {
 849         BOOL result;
 850
 851         START_PROFILE(fset_nt_acl);
 852         result = set_nt_acl(fsp, security_info_sent, psd);
 853         END_PROFILE(fset_nt_acl);
 854         return result;
 855 }
 856
 857 BOOL vfswrap_set_nt_acl(vfs_handle_struct *handle, files_struct *fsp, const char *name, uint32 security_info_sent, SEC_DESC *psd)
 858 {
 859         BOOL result;
 860
 861         START_PROFILE(set_nt_acl);
 862         result = set_nt_acl(fsp, security_info_sent, psd);
 863         END_PROFILE(set_nt_acl);
 864         return result;
 865 }
 866
 867 int vfswrap_chmod_acl(vfs_handle_struct *handle, connection_struct *conn, const char *name, mode_t mode)
 868 {
 869 #ifdef HAVE_NO_ACL
 870         errno = ENOSYS;
 871         return -1;
 872 #else
 873         int result;
 874
 875         START_PROFILE(chmod_acl);
 876         result = chmod_acl(conn, name, mode);
 877         END_PROFILE(chmod_acl);
 878         return result;
 879 #endif
 880 }
 881
 882 int vfswrap_fchmod_acl(vfs_handle_struct *handle, files_struct *fsp, int fd, mode_t mode)
 883 {
 884 #ifdef HAVE_NO_ACL
 885         errno = ENOSYS;
 886         return -1;
 887 #else
 888         int result;
 889
 890         START_PROFILE(fchmod_acl);
 891         result = fchmod_acl(fsp, fd, mode);
 892         END_PROFILE(fchmod_acl);
 893         return result;
 894 #endif
 895 }
 896
 897 int vfswrap_sys_acl_get_entry(vfs_handle_struct *handle, connection_struct *conn, SMB_ACL_T theacl, int entry_id, SMB_ACL_ENTRY_T *entry_p)
 898 {
 899         return sys_acl_get_entry(theacl, entry_id, entry_p);
 900 }
 901
 902 int vfswrap_sys_acl_get_tag_type(vfs_handle_struct *handle, connection_struct *conn, SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T *tag_type_p)
 903 {
 904         return sys_acl_get_tag_type(entry_d, tag_type_p);
 905 }
 906
 907 int vfswrap_sys_acl_get_permset(vfs_handle_struct *handle, connection_struct *conn, SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T *permset_p)
 908 {
 909         return sys_acl_get_permset(entry_d, permset_p);
 910 }
 911
 912 void * vfswrap_sys_acl_get_qualifier(vfs_handle_struct *handle, connection_struct *conn, SMB_ACL_ENTRY_T entry_d)
 913 {
 914         return sys_acl_get_qualifier(entry_d);
 915 }
 916
 917 SMB_ACL_T vfswrap_sys_acl_get_file(vfs_handle_struct *handle, connection_struct *conn, const char *path_p, SMB_ACL_TYPE_T type)
 918 {
 919         return sys_acl_get_file(path_p, type);
 920 }
 921
 922 SMB_ACL_T vfswrap_sys_acl_get_fd(vfs_handle_struct *handle, files_struct *fsp, int fd)
 923 {
 924         return sys_acl_get_fd(fd);
 925 }
 926
 927 int vfswrap_sys_acl_clear_perms(vfs_handle_struct *handle, connection_struct *conn, SMB_ACL_PERMSET_T permset)
 928 {
 929         return sys_acl_clear_perms(permset);
 930 }
 931
 932 int vfswrap_sys_acl_add_perm(vfs_handle_struct *handle, connection_struct *conn, SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm)
 933 {
 934         return sys_acl_add_perm(permset, perm);
 935 }
 936
 937 char * vfswrap_sys_acl_to_text(vfs_handle_struct *handle, connection_struct *conn, SMB_ACL_T theacl, ssize_t *plen)
 938 {
 939         return sys_acl_to_text(theacl, plen);
 940 }
 941
 942 SMB_ACL_T vfswrap_sys_acl_init(vfs_handle_struct *handle, connection_struct *conn, int count)
 943 {
 944         return sys_acl_init(count);
 945 }
 946
 947 int vfswrap_sys_acl_create_entry(vfs_handle_struct *handle, connection_struct *conn, SMB_ACL_T *pacl, SMB_ACL_ENTRY_T *pentry)
 948 {
 949         return sys_acl_create_entry(pacl, pentry);
 950 }
 951
 952 int vfswrap_sys_acl_set_tag_type(vfs_handle_struct *handle, connection_struct *conn, SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T tagtype)
 953 {
 954         return sys_acl_set_tag_type(entry, tagtype);
 955 }
 956
 957 int vfswrap_sys_acl_set_qualifier(vfs_handle_struct *handle, connection_struct *conn, SMB_ACL_ENTRY_T entry, void *qual)
 958 {
 959         return sys_acl_set_qualifier(entry, qual);
 960 }
 961
 962 int vfswrap_sys_acl_set_permset(vfs_handle_struct *handle, connection_struct *conn, SMB_ACL_ENTRY_T entry, SMB_ACL_PERMSET_T permset)
 963 {
 964         return sys_acl_set_permset(entry, permset);
 965 }
 966
 967 int vfswrap_sys_acl_valid(vfs_handle_struct *handle, connection_struct *conn, SMB_ACL_T theacl )
 968 {
 969         return sys_acl_valid(theacl );
 970 }
 971
 972 int vfswrap_sys_acl_set_file(vfs_handle_struct *handle, connection_struct *conn, const char *name, SMB_ACL_TYPE_T acltype, SMB_ACL_T theacl)
 973 {
 974         return sys_acl_set_file(name, acltype, theacl);
 975 }
 976
 977 int vfswrap_sys_acl_set_fd(vfs_handle_struct *handle, files_struct *fsp, int fd, SMB_ACL_T theacl)
 978 {
 979         return sys_acl_set_fd(fd, theacl);
 980 }
 981
 982 int vfswrap_sys_acl_delete_def_file(vfs_handle_struct *handle, connection_struct *conn, const char *path)
 983 {
 984         return sys_acl_delete_def_file(path);
 985 }
 986
 987 int vfswrap_sys_acl_get_perm(vfs_handle_struct *handle, connection_struct *conn, SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm)
 988 {
 989         return sys_acl_get_perm(permset, perm);
 990 }
 991
 992 int vfswrap_sys_acl_free_text(vfs_handle_struct *handle, connection_struct *conn, char *text)
 993 {
 994         return sys_acl_free_text(text);
 995 }
 996
 997 int vfswrap_sys_acl_free_acl(vfs_handle_struct *handle, connection_struct *conn, SMB_ACL_T posix_acl)
 998 {
 999         return sys_acl_free_acl(posix_acl);
1000 }
1001
1002 int vfswrap_sys_acl_free_qualifier(vfs_handle_struct *handle, connection_struct *conn, void *qualifier, SMB_ACL_TAG_T tagtype)
1003 {
1004         return sys_acl_free_qualifier(qualifier, tagtype);
1005 }
1006
1007 /****************************************************************
1008  Extended attribute operations.
1009 *****************************************************************/
1010
1011 ssize_t vfswrap_getxattr(struct vfs_handle_struct *handle,struct connection_struct *conn,const char *path, const char *name, void *value, size_t size)
1012 {
1013         return sys_getxattr(path, name, value, size);
1014 }
1015
1016 ssize_t vfswrap_lgetxattr(struct vfs_handle_struct *handle,struct connection_struct *conn,const char *path, const char *name, void *value, size_t size)
1017 {
1018         return sys_lgetxattr(path, name, value, size);
1019 }
1020
1021 ssize_t vfswrap_fgetxattr(struct vfs_handle_struct *handle, struct files_struct *fsp,int fd, const char *name, void *value, size_t size)
1022 {
1023         return sys_fgetxattr(fd, name, value, size);
1024 }
1025
1026 ssize_t vfswrap_listxattr(struct vfs_handle_struct *handle, struct connection_struct *conn,const char *path, char *list, size_t size)
1027 {
1028         return sys_listxattr(path, list, size);
1029 }
1030
1031 ssize_t vfswrap_llistxattr(struct vfs_handle_struct *handle, struct connection_struct *conn,const char *path, char *list, size_t size)
1032 {
1033         return sys_llistxattr(path, list, size);
1034 }
1035
1036 ssize_t vfswrap_flistxattr(struct vfs_handle_struct *handle, struct files_struct *fsp,int fd, char *list, size_t size)
1037 {
1038         return sys_flistxattr(fd, list, size);
1039 }
1040
1041 int vfswrap_removexattr(struct vfs_handle_struct *handle, struct connection_struct *conn,const char *path, const char *name)
1042 {
1043         return sys_removexattr(path, name);
1044 }
1045
1046 int vfswrap_lremovexattr(struct vfs_handle_struct *handle, struct connection_struct *conn,const char *path, const char *name)
1047 {
1048         return sys_lremovexattr(path, name);
1049 }
1050
1051 int vfswrap_fremovexattr(struct vfs_handle_struct *handle, struct files_struct *fsp,int fd, const char *name)
1052 {
1053         return sys_fremovexattr(fd, name);
1054 }
1055
1056 int vfswrap_setxattr(struct vfs_handle_struct *handle, struct connection_struct *conn,const char *path, const char *name, const void *value, size_t size, int flags)
1057 {
1058         return sys_setxattr(path, name, value, size, flags);
1059 }
1060
1061 int vfswrap_lsetxattr(struct vfs_handle_struct *handle, struct connection_struct *conn,const char *path, const char *name, const void *value, size_t size, int flags)
1062 {
1063         return sys_lsetxattr(path, name, value, size, flags);
1064 }
1065
1066 int vfswrap_fsetxattr(struct vfs_handle_struct *handle, struct files_struct *fsp,int fd, const char *name, const void *value, size_t size, int flags)
1067 {
1068         return sys_fsetxattr(fd, name, value, size, flags);
1069 }
1070
1071 int vfswrap_aio_read(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
1072 {
1073         return sys_aio_read(aiocb);
1074 }
1075
1076 int vfswrap_aio_write(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
1077 {
1078         return sys_aio_write(aiocb);
1079 }
1080
1081 ssize_t vfswrap_aio_return(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
1082 {
1083         return sys_aio_return(aiocb);
1084 }
1085
1086 int vfswrap_aio_cancel(struct vfs_handle_struct *handle, struct files_struct *fsp, int fd, SMB_STRUCT_AIOCB *aiocb)
1087 {
1088         return sys_aio_cancel(fd, aiocb);
1089 }
1090
1091 int vfswrap_aio_error(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
1092 {
1093         return sys_aio_error(aiocb);
1094 }
1095
1096 int vfswrap_aio_fsync(struct vfs_handle_struct *handle, struct files_struct *fsp, int op, SMB_STRUCT_AIOCB *aiocb)
1097 {
1098         return sys_aio_fsync(op, aiocb);
1099 }
1100
1101 int vfswrap_aio_suspend(struct vfs_handle_struct *handle, struct files_struct *fsp, const SMB_STRUCT_AIOCB * const aiocb[], int n, const struct timespec *timeout)
1102 {
1103         return sys_aio_suspend(aiocb, n, timeout);
1104 }