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