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