source/smbwrapper/wrapped.c

   1 /*
   2    Unix SMB/Netbios implementation.
   3    Version 2.0
   4    SMB wrapper functions
   5    Copyright (C) Andrew Tridgell 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
  23 #include "wrapper.h"
  24
  25  int open(const char *name, int flags, ...)
  26 {
  27         va_list ap;
  28         mode_t mode;
  29
  30         va_start(ap, flags);
  31         mode = va_arg(ap, mode_t);
  32         va_end(ap);
  33
  34         if (smbw_path(name)) {
  35                 return smbw_open(name, flags, mode);
  36         }
  37
  38         return real_open(name, flags, mode);
  39 }
  40
  41 #ifdef HAVE__OPEN
  42  int _open(const char *name, int flags, ...)
  43 {
  44         va_list ap;
  45         mode_t mode;
  46
  47         va_start(ap, flags);
  48         mode = va_arg(ap, mode_t);
  49         va_end(ap);
  50
  51         return open(name, flags, mode);
  52 }
  53 #elif HAVE___OPEN
  54  int __open(const char *name, int flags, ...)
  55 {
  56         va_list ap;
  57         mode_t mode;
  58
  59         va_start(ap, flags);
  60         mode = va_arg(ap, mode_t);
  61         va_end(ap);
  62
  63         return open(name, flags, mode);
  64 }
  65 #endif
  66
  67
  68 #ifdef HAVE_OPEN64
  69  int open64(const char *name, int flags, mode_t mode)
  70 {
  71         if (smbw_path(name)) {
  72                 return smbw_open(name, flags, mode);
  73         }
  74
  75         return real_open64(name, flags, mode);
  76 }
  77 #endif
  78
  79 #ifdef HAVE__OPEN64
  80  int _open64(const char *name, int flags, mode_t mode)
  81 {
  82    return open64(name, flags, mode);
  83 }
  84 #elif HAVE___OPEN
  85  int __open64(const char *name, int flags, mode_t mode)
  86 {
  87    return open64(name, flags, mode);
  88 }
  89 #endif
  90
  91 #ifdef HAVE_PREAD
  92  ssize_t pread(int fd, void *buf, size_t size, off_t ofs)
  93 {
  94         if (smbw_fd(fd)) {
  95                 return smbw_pread(fd, buf, size, ofs);
  96         }
  97
  98         return real_pread(fd, buf, size, ofs);
  99 }
 100 #endif
 101
 102 #ifdef HAVE_PREAD64
 103  ssize_t pread64(int fd, void *buf, size_t size, off64_t ofs)
 104 {
 105         if (smbw_fd(fd)) {
 106                 return smbw_pread(fd, buf, size, ofs);
 107         }
 108
 109         return real_pread64(fd, buf, size, ofs);
 110 }
 111 #endif
 112
 113 #ifdef HAVE_PWRITE
 114  ssize_t pwrite(int fd, void *buf, size_t size, off_t ofs)
 115 {
 116         if (smbw_fd(fd)) {
 117                 return smbw_pwrite(fd, buf, size, ofs);
 118         }
 119
 120         return real_pwrite(fd, buf, size, ofs);
 121 }
 122 #endif
 123
 124 #ifdef HAVE_PWRITE64
 125  ssize_t pwrite64(int fd, void *buf, size_t size, off64_t ofs)
 126 {
 127         if (smbw_fd(fd)) {
 128                 return smbw_pwrite(fd, buf, size, ofs);
 129         }
 130
 131         return real_pwrite64(fd, buf, size, ofs);
 132 }
 133 #endif
 134
 135
 136  int chdir(const char *name)
 137 {
 138         return smbw_chdir(name);
 139 }
 140
 141 #ifdef HAVE___CHDIR
 142  int __chdir(const char *name)
 143 {
 144         return chdir(name);
 145 }
 146 #elif HAVE__CHDIR
 147  int _chdir(const char *name)
 148 {
 149         return chdir(name);
 150 }
 151 #endif
 152
 153
 154  int close(int fd)
 155 {
 156         if (smbw_fd(fd)) {
 157                 return smbw_close(fd);
 158         }
 159
 160         return real_close(fd);
 161 }
 162
 163 #ifdef HAVE___CLOSE
 164  int __close(int fd)
 165 {
 166         return close(fd);
 167 }
 168 #elif HAVE__CLOSE
 169  int _close(int fd)
 170 {
 171         return close(fd);
 172 }
 173 #endif
 174
 175
 176  int fchdir(int fd)
 177 {
 178         if (smbw_fd(fd)) {
 179                 return smbw_fchdir(fd);
 180         }
 181
 182         return real_fchdir(fd);
 183 }
 184
 185 #ifdef HAVE___FCHDIR
 186  int __fchdir(int fd)
 187 {
 188         return fchdir(fd);
 189 }
 190 #elif HAVE__FCHDIR
 191  int _fchdir(int fd)
 192 {
 193         return fchdir(fd);
 194 }
 195 #endif
 196
 197
 198  int fcntl(int fd, int cmd, ...)
 199 {
 200         va_list ap;
 201         long arg;
 202         va_start(ap, cmd);
 203         arg = va_arg(ap, long);
 204         va_end(ap);
 205
 206         if (smbw_fd(fd)) {
 207                 return smbw_fcntl(fd, cmd, arg);
 208         }
 209
 210         return real_fcntl(fd, cmd, arg);
 211 }
 212
 213
 214 #ifdef HAVE___FCNTL
 215  int __fcntl(int fd, int cmd, ...)
 216 {
 217         va_list ap;
 218         long arg;
 219         va_start(ap, cmd);
 220         arg = va_arg(ap, long);
 221         va_end(ap);
 222
 223         return fcntl(fd, cmd, arg);
 224 }
 225 #elif HAVE__FCNTL
 226  int _fcntl(int fd, int cmd, ...)
 227 {
 228         va_list ap;
 229         long arg;
 230         va_start(ap, cmd);
 231         arg = va_arg(ap, long);
 232         va_end(ap);
 233
 234         return fcntl(fd, cmd, arg);
 235 }
 236 #endif
 237
 238
 239
 240  int getdents(int fd, struct dirent *dirp, unsigned int count)
 241 {
 242         if (smbw_fd(fd)) {
 243                 return smbw_getdents(fd, dirp, count);
 244         }
 245
 246         return real_getdents(fd, dirp, count);
 247 }
 248
 249 #ifdef HAVE___GETDENTS
 250  int __getdents(int fd, struct dirent *dirp, unsigned int count)
 251 {
 252         return getdents(fd, dirp, count);
 253 }
 254 #elif HAVE__GETDENTS
 255  int _getdents(int fd, struct dirent *dirp, unsigned int count)
 256 {
 257         return getdents(fd, dirp, count);
 258 }
 259 #endif
 260
 261
 262  off_t lseek(int fd, off_t offset, int whence)
 263 {
 264         if (smbw_fd(fd)) {
 265                 return smbw_lseek(fd, offset, whence);
 266         }
 267
 268         return real_lseek(fd, offset, whence);
 269 }
 270
 271 #ifdef HAVE___LSEEK
 272  off_t __lseek(int fd, off_t offset, int whence)
 273 {
 274         return lseek(fd, offset, whence);
 275 }
 276 #elif HAVE__LSEEK
 277  off_t _lseek(int fd, off_t offset, int whence)
 278 {
 279         return lseek(fd, offset, whence);
 280 }
 281 #endif
 282
 283
 284  ssize_t read(int fd, void *buf, size_t count)
 285 {
 286         if (smbw_fd(fd)) {
 287                 return smbw_read(fd, buf, count);
 288         }
 289
 290         return real_read(fd, buf, count);
 291 }
 292
 293 #ifdef HAVE___READ
 294  ssize_t __read(int fd, void *buf, size_t count)
 295 {
 296         return read(fd, buf, count);
 297 }
 298 #elif HAVE__READ
 299  ssize_t _read(int fd, void *buf, size_t count)
 300 {
 301         return read(fd, buf, count);
 302 }
 303 #endif
 304
 305
 306  ssize_t write(int fd, void *buf, size_t count)
 307 {
 308         if (smbw_fd(fd)) {
 309                 return smbw_write(fd, buf, count);
 310         }
 311
 312         return real_write(fd, buf, count);
 313 }
 314
 315 #ifdef HAVE___WRITE
 316  ssize_t __write(int fd, void *buf, size_t count)
 317 {
 318         return write(fd, buf, count);
 319 }
 320 #elif HAVE__WRITE
 321  ssize_t _write(int fd, void *buf, size_t count)
 322 {
 323         return write(fd, buf, count);
 324 }
 325 #endif
 326
 327
 328
 329  int access(const char *name, int mode)
 330 {
 331         if (smbw_path(name)) {
 332                 return smbw_access(name, mode);
 333         }
 334
 335         return real_access(name, mode);
 336 }
 337
 338
 339
 340  int chmod(const char *name,mode_t mode)
 341 {
 342         if (smbw_path(name)) {
 343                 return smbw_chmod(name, mode);
 344         }
 345
 346         return real_chmod(name, mode);
 347 }
 348
 349
 350
 351  int chown(const char *name,uid_t owner, gid_t group)
 352 {
 353         if (smbw_path(name)) {
 354                 return smbw_chown(name, owner, group);
 355         }
 356
 357         return real_chown(name, owner, group);
 358 }
 359
 360 #ifdef LINUX
 361  int __fxstat(int vers, int fd, struct stat *st)
 362 {
 363         struct kernel_stat kbuf;
 364         int ret;
 365
 366         if (smbw_fd(fd)) {
 367                 return smbw_fstat(fd, st);
 368         }
 369
 370         switch (vers) {
 371         case _STAT_VER_LINUX_OLD:
 372                 /* Nothing to do.  The struct is in the form the kernel expects
 373                    it to be.  */
 374                 return real_fstat(fd, (struct kernel_stat *)st);
 375                 break;
 376
 377         case _STAT_VER_LINUX:
 378                 /* Do the system call.  */
 379                 ret = real_fstat(fd, &kbuf);
 380
 381                 st->st_dev = kbuf.st_dev;
 382 #ifdef _HAVE___PAD1
 383                 st->__pad1 = 0;
 384 #endif
 385                 st->st_ino = kbuf.st_ino;
 386                 st->st_mode = kbuf.st_mode;
 387                 st->st_nlink = kbuf.st_nlink;
 388                 st->st_uid = kbuf.st_uid;
 389                 st->st_gid = kbuf.st_gid;
 390                 st->st_rdev = kbuf.st_rdev;
 391 #ifdef _HAVE___PAD2
 392                 st->__pad2 = 0;
 393 #endif
 394                 st->st_size = kbuf.st_size;
 395                 st->st_blksize = kbuf.st_blksize;
 396                 st->st_blocks = kbuf.st_blocks;
 397                 st->st_atime = kbuf.st_atime;
 398 #ifdef _HAVE___UNUSED1
 399                 st->__unused1 = 0;
 400 #endif
 401                 st->st_mtime = kbuf.st_mtime;
 402 #ifdef _HAVE___UNUSED2
 403                 st->__unused2 = 0;
 404 #endif
 405                 st->st_ctime = kbuf.st_ctime;
 406 #ifdef _HAVE___UNUSED3
 407                 st->__unused3 = 0;
 408 #endif
 409 #ifdef _HAVE___UNUSED4
 410                 st->__unused4 = 0;
 411 #endif
 412 #ifdef _HAVE___UNUSED5
 413                 st->__unused5 = 0;
 414 #endif
 415                 return ret;
 416
 417         default:
 418                 errno = EINVAL;
 419                 return -1;
 420         }
 421 }
 422 #endif
 423
 424
 425  char *getcwd(char *buf, size_t size)
 426 {
 427         return smbw_getcwd(buf, size);
 428 }
 429
 430
 431 #ifdef LINUX
 432  int __lxstat(int vers, const char *name, struct stat *st)
 433 {
 434         struct kernel_stat kbuf;
 435         int ret;
 436
 437         if (smbw_path(name)) {
 438                 return smbw_stat(name, st);
 439         }
 440
 441         switch (vers) {
 442         case _STAT_VER_LINUX_OLD:
 443                 /* Nothing to do.  The struct is in the form the kernel expects
 444                    it to be.  */
 445                 return real_lstat(name, (struct kernel_stat *)st);
 446                 break;
 447
 448         case _STAT_VER_LINUX:
 449                 /* Do the system call.  */
 450                 ret = real_lstat(name, &kbuf);
 451
 452                 st->st_dev = kbuf.st_dev;
 453 #ifdef _HAVE___PAD1
 454                 st->__pad1 = 0;
 455 #endif
 456                 st->st_ino = kbuf.st_ino;
 457                 st->st_mode = kbuf.st_mode;
 458                 st->st_nlink = kbuf.st_nlink;
 459                 st->st_uid = kbuf.st_uid;
 460                 st->st_gid = kbuf.st_gid;
 461                 st->st_rdev = kbuf.st_rdev;
 462 #ifdef _HAVE___PAD2
 463                 st->__pad2 = 0;
 464 #endif
 465                 st->st_size = kbuf.st_size;
 466                 st->st_blksize = kbuf.st_blksize;
 467                 st->st_blocks = kbuf.st_blocks;
 468                 st->st_atime = kbuf.st_atime;
 469 #ifdef _HAVE___UNUSED1
 470                 st->__unused1 = 0;
 471 #endif
 472                 st->st_mtime = kbuf.st_mtime;
 473 #ifdef _HAVE___UNUSED2
 474                 st->__unused2 = 0;
 475 #endif
 476                 st->st_ctime = kbuf.st_ctime;
 477 #ifdef _HAVE___UNUSED3
 478                 st->__unused3 = 0;
 479 #endif
 480 #ifdef _HAVE___UNUSED4
 481                 st->__unused4 = 0;
 482 #endif
 483 #ifdef _HAVE___UNUSED5
 484                 st->__unused5 = 0;
 485 #endif
 486                 return ret;
 487
 488         default:
 489                 errno = EINVAL;
 490                 return -1;
 491         }
 492 }
 493 #endif
 494
 495
 496  int mkdir(const char *name, mode_t mode)
 497 {
 498         if (smbw_path(name)) {
 499                 return smbw_mkdir(name, mode);
 500         }
 501
 502         return real_mkdir(name, mode);
 503 }
 504
 505
 506 #ifdef LINUX
 507  int __xstat(int vers, const char *name, struct stat *st)
 508 {
 509         struct kernel_stat kbuf;
 510         int ret;
 511
 512         if (smbw_path(name)) {
 513                 return smbw_stat(name, st);
 514         }
 515
 516         switch (vers) {
 517         case _STAT_VER_LINUX_OLD:
 518                 /* Nothing to do.  The struct is in the form the kernel expects
 519                    it to be.  */
 520                 return real_stat(name, (struct kernel_stat *)st);
 521                 break;
 522
 523         case _STAT_VER_LINUX:
 524                 /* Do the system call.  */
 525                 ret = real_stat(name, &kbuf);
 526
 527                 st->st_dev = kbuf.st_dev;
 528 #ifdef _HAVE___PAD1
 529                 st->__pad1 = 0;
 530 #endif
 531                 st->st_ino = kbuf.st_ino;
 532                 st->st_mode = kbuf.st_mode;
 533                 st->st_nlink = kbuf.st_nlink;
 534                 st->st_uid = kbuf.st_uid;
 535                 st->st_gid = kbuf.st_gid;
 536                 st->st_rdev = kbuf.st_rdev;
 537 #ifdef _HAVE___PAD2
 538                 st->__pad2 = 0;
 539 #endif
 540                 st->st_size = kbuf.st_size;
 541                 st->st_blksize = kbuf.st_blksize;
 542                 st->st_blocks = kbuf.st_blocks;
 543                 st->st_atime = kbuf.st_atime;
 544 #ifdef _HAVE___UNUSED1
 545                 st->__unused1 = 0;
 546 #endif
 547                 st->st_mtime = kbuf.st_mtime;
 548 #ifdef _HAVE___UNUSED2
 549                 st->__unused2 = 0;
 550 #endif
 551                 st->st_ctime = kbuf.st_ctime;
 552 #ifdef _HAVE___UNUSED3
 553                 st->__unused3 = 0;
 554 #endif
 555 #ifdef _HAVE___UNUSED4
 556                 st->__unused4 = 0;
 557 #endif
 558 #ifdef _HAVE___UNUSED5
 559                 st->__unused5 = 0;
 560 #endif
 561                 return ret;
 562
 563         default:
 564                 errno = EINVAL;
 565                 return -1;
 566         }
 567 }
 568 #endif
 569
 570  int stat(const char *name, struct stat *st)
 571 {
 572 #if HAVE___XSTAT
 573         return __xstat(_STAT_VER, name, st);
 574 #else
 575         if (smbw_path(name)) {
 576                 return smbw_stat(name, st);
 577         }
 578         return real_stat(name, st);
 579 #endif
 580 }
 581
 582  int lstat(const char *name, struct stat *st)
 583 {
 584 #if HAVE___LXSTAT
 585         return __lxstat(_STAT_VER, name, st);
 586 #else
 587         if (smbw_path(name)) {
 588                 return smbw_stat(name, st);
 589         }
 590         return real_lstat(name, st);
 591 #endif
 592 }
 593
 594  int fstat(int fd, struct stat *st)
 595 {
 596 #if HAVE___LXSTAT
 597         return __fxstat(_STAT_VER, fd, st);
 598 #else
 599         if (smbw_fd(fd)) {
 600                 return smbw_fstat(fd, st);
 601         }
 602         return real_fstat(fd, st);
 603 #endif
 604 }
 605
 606
 607  int unlink(const char *name)
 608 {
 609         if (smbw_path(name)) {
 610                 return smbw_unlink(name);
 611         }
 612
 613         return real_unlink(name);
 614 }
 615
 616
 617 #ifdef HAVE_UTIME
 618  int utime(const char *name,void *tvp)
 619 {
 620         if (smbw_path(name)) {
 621                 return smbw_utime(name, tvp);
 622         }
 623
 624         return real_utime(name, tvp);
 625 }
 626 #endif
 627
 628 #ifdef HAVE_UTIMES
 629  int utimes(const char *name,struct timeval tvp[2])
 630 {
 631         if (smbw_path(name)) {
 632                 return smbw_utimes(name, tvp);
 633         }
 634
 635         return real_utimes(name, tvp);
 636 }
 637 #endif
 638
 639  int readlink(char *path, char *buf, size_t bufsize)
 640 {
 641         if (smbw_path(path)) {
 642                 return smbw_readlink(path, buf, bufsize);
 643         }
 644
 645         return real_readlink(path, buf, bufsize);
 646 }
 647
 648
 649  int rename(const char *oldname,const char *newname)
 650 {
 651         int p1, p2;
 652         p1 = smbw_path(oldname);
 653         p2 = smbw_path(newname);
 654         if (p1 ^ p2) {
 655                 /* can't cross filesystem boundaries */
 656                 errno = EXDEV;
 657                 return -1;
 658         }
 659         if (p1 && p2) {
 660                 return smbw_rename(oldname, newname);
 661         }
 662
 663         return real_rename(oldname, newname);
 664 }
 665
 666  int rmdir(const char *name)
 667 {
 668         if (smbw_path(name)) {
 669                 return smbw_rmdir(name);
 670         }
 671
 672         return real_rmdir(name);
 673 }
 674
 675
 676  int symlink(const char *topath,const char *frompath)
 677 {
 678         int p1, p2;
 679         p1 = smbw_path(topath);
 680         p2 = smbw_path(frompath);
 681         if (p1 || p2) {
 682                 /* can't handle symlinks */
 683                 errno = EPERM;
 684                 return -1;
 685         }
 686
 687         return real_symlink(topath, frompath);
 688 }
 689
 690  int dup(int fd)
 691 {
 692         if (smbw_fd(fd)) {
 693                 return smbw_dup(fd);
 694         }
 695
 696         return real_dup(fd);
 697 }
 698
 699  int dup2(int oldfd, int newfd)
 700 {
 701         if (smbw_fd(newfd)) {
 702                 close(newfd);
 703         }
 704
 705         if (smbw_fd(oldfd)) {
 706                 return smbw_dup2(oldfd, newfd);
 707         }
 708
 709         return real_dup2(oldfd, newfd);
 710 }
 711
 712 #ifdef real_opendir
 713  DIR *opendir(const char *name)
 714 {
 715         DIR *ret;
 716         if (smbw_path(name)) {
 717                 return smbw_opendir(name);
 718         }
 719
 720         return real_opendir(name);
 721 }
 722 #endif
 723
 724 #ifdef real_readdir
 725  struct dirent *readdir(DIR *dir)
 726 {
 727         if (smbw_dirp(dir)) {
 728                 return smbw_readdir(dir);
 729         }
 730
 731         return real_readdir(dir);
 732 }
 733 #endif
 734
 735 #ifdef real_closedir
 736  int closedir(DIR *dir)
 737 {
 738         if (smbw_dirp(dir)) {
 739                 return smbw_closedir(dir);
 740         }
 741
 742         return real_closedir(dir);
 743 }
 744 #endif
 745
 746 #ifdef real_telldir
 747  off_t telldir(DIR *dir)
 748 {
 749         if (smbw_dirp(dir)) {
 750                 return smbw_telldir(dir);
 751         }
 752
 753         return real_telldir(dir);
 754 }
 755 #endif
 756
 757 #ifdef real_seekdir
 758  void seekdir(DIR *dir, off_t offset)
 759 {
 760         if (smbw_dirp(dir)) {
 761                 smbw_seekdir(dir, offset);
 762                 return;
 763         }
 764
 765         real_seekdir(dir, offset);
 766 }
 767 #endif
 768
 769
 770 #ifndef NO_ACL_WRAPPER
 771  int  acl(const char  *pathp,  int  cmd,  int  nentries, aclent_t *aclbufp)
 772 {
 773         if (smbw_path(pathp)) {
 774                 switch (cmd) {
 775                 case GETACL:
 776                 case GETACLCNT:
 777                         return 0;
 778                 default:
 779                         errno = ENOSYS;
 780                         return -1;
 781                 }
 782         }
 783
 784         real_acl(pathp, cmd, nentries, aclbufp);
 785 }
 786 #endif
 787
 788 #ifndef NO_FACL_WRAPPER
 789  int  facl(int fd,  int  cmd,  int  nentries, aclent_t *aclbufp)
 790 {
 791         if (smbw_fd(fd)) {
 792                 switch (cmd) {
 793                 case GETACL:
 794                 case GETACLCNT:
 795                         return 0;
 796                 default:
 797                         errno = ENOSYS;
 798                         return -1;
 799                 }
 800         }
 801
 802         real_facl(fd, cmd, nentries, aclbufp);
 803 }
 804 #endif
 805
 806  int creat(const char *path, mode_t mode)
 807 {
 808         return open(path, O_WRONLY|O_CREAT|O_TRUNC, mode);
 809 }
 810
 811 #ifdef HAVE_CREAT64
 812  int creat64(const char *path, mode_t mode)
 813 {
 814         return open64(path, O_WRONLY|O_CREAT|O_TRUNC, mode);
 815 }
 816 #endif
 817
 818 #ifdef HAVE_STAT64
 819 static void stat64_convert(struct stat *st, struct stat64 *st64)
 820 {
 821         st64->st_size = st->st_size;
 822         st64->st_mode = st->st_mode;
 823         st64->st_ino = st->st_ino;
 824         st64->st_dev = st->st_dev;
 825         st64->st_rdev = st->st_rdev;
 826         st64->st_nlink = st->st_nlink;
 827         st64->st_uid = st->st_uid;
 828         st64->st_gid = st->st_gid;
 829         st64->st_atime = st->st_atime;
 830         st64->st_mtime = st->st_mtime;
 831         st64->st_ctime = st->st_ctime;
 832         st64->st_blksize = st->st_blksize;
 833         st64->st_blocks = st->st_blocks;
 834 }
 835
 836   int stat64(const char *name, struct stat64 *st64)
 837 {
 838         if (smbw_path(name)) {
 839                 struct stat st;
 840                 int ret = stat(name, &st);
 841                 stat64_convert(&st, st64);
 842                 return ret;
 843         }
 844         return real_stat64(name, st64);
 845 }
 846
 847   int fstat64(int fd, struct stat64 *st64)
 848 {
 849         if (smbw_fd(fd)) {
 850                 struct stat st;
 851                 int ret = fstat(fd, &st);
 852                 stat64_convert(&st, st64);
 853                 return ret;
 854         }
 855         return real_fstat64(fd, st64);
 856 }
 857
 858   int lstat64(const char *name, struct stat64 *st64)
 859 {
 860         if (smbw_path(name)) {
 861                 struct stat st;
 862                 int ret = lstat(name, &st);
 863                 stat64_convert(&st, st64);
 864                 return ret;
 865         }
 866         return real_lstat64(name, st64);
 867 }
 868 #endif
 869
 870 #ifdef HAVE_LLSEEK
 871   offset_t llseek(int fd, offset_t ofs, int whence)
 872 {
 873         if (smbw_fd(fd)) {
 874                 return lseek(fd, ofs, whence);
 875         }
 876         return real_llseek(fd, ofs, whence);
 877 }
 878 #endif
 879
 880 #ifdef HAVE_READDIR64
 881 static void dirent64_convert(struct dirent *d, struct dirent64 *d64)
 882 {
 883         d64->d_ino = d->d_ino;
 884         d64->d_off = d->d_off;
 885         d64->d_reclen = d->d_reclen;
 886         strcpy(d64->d_name, d->d_name);
 887 }
 888
 889  struct dirent64 *readdir64(DIR *dir)
 890 {
 891         if (smbw_dirp(dir)) {
 892                 struct dirent *d;
 893                 static union {
 894                         char buf[DIRP_SIZE];
 895                         struct dirent64 d64;
 896                 } dbuf;
 897                 d = readdir(dir);
 898                 if (!d) return NULL;
 899                 dirent64_convert(d, &dbuf.d64);
 900                 return &dbuf.d64;
 901         }
 902         return real_readdir64(dir);
 903 }
 904 #endif