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 /* NOTE: This file WILL produce compiler warnings. They are unavoidable
  23
  24    Do not try and get rid of them by including other include files or
  25    by including includes.h or proto.h or you will break portability.
  26   */
  27
  28 #include "config.h"
  29 #include <sys/types.h>
  30 #include <errno.h>
  31 #include "realcalls.h"
  32
  33  int open(char *name, int flags, mode_t mode)
  34 {
  35         if (smbw_path(name)) {
  36                 return smbw_open(name, flags, mode);
  37         }
  38
  39         return real_open(name, flags, mode);
  40 }
  41
  42 #ifdef HAVE__OPEN
  43  int _open(char *name, int flags, mode_t mode)
  44 {
  45         return open(name, flags, mode);
  46 }
  47 #elif HAVE___OPEN
  48  int __open(char *name, int flags, mode_t mode)
  49 {
  50         return open(name, flags, mode);
  51 }
  52 #endif
  53
  54
  55 #ifdef HAVE_OPEN64
  56  int open64(char *name, int flags, mode_t mode)
  57 {
  58         if (smbw_path(name)) {
  59                 return smbw_open(name, flags, mode);
  60         }
  61
  62         return real_open64(name, flags, mode);
  63 }
  64 #endif
  65
  66 #ifndef NO_OPEN64_ALIAS
  67 #ifdef HAVE__OPEN64
  68  int _open64(char *name, int flags, mode_t mode)
  69 {
  70         return open64(name, flags, mode);
  71 }
  72 #elif HAVE___OPEN64
  73  int __open64(char *name, int flags, mode_t mode)
  74 {
  75         return open64(name, flags, mode);
  76 }
  77 #endif
  78 #endif
  79
  80 #ifdef HAVE_PREAD
  81  ssize_t pread(int fd, void *buf, size_t size, off_t ofs)
  82 {
  83         if (smbw_fd(fd)) {
  84                 return smbw_pread(fd, buf, size, ofs);
  85         }
  86
  87         return real_pread(fd, buf, size, ofs);
  88 }
  89 #endif
  90
  91 #ifdef HAVE_PREAD64
  92  ssize_t pread64(int fd, void *buf, size_t size, off64_t ofs)
  93 {
  94         if (smbw_fd(fd)) {
  95                 return smbw_pread(fd, buf, size, ofs);
  96         }
  97
  98         return real_pread64(fd, buf, size, ofs);
  99 }
 100 #endif
 101
 102 #ifdef HAVE_PWRITE
 103  ssize_t pwrite(int fd, void *buf, size_t size, off_t ofs)
 104 {
 105         if (smbw_fd(fd)) {
 106                 return smbw_pwrite(fd, buf, size, ofs);
 107         }
 108
 109         return real_pwrite(fd, buf, size, ofs);
 110 }
 111 #endif
 112
 113 #ifdef HAVE_PWRITE64
 114  ssize_t pwrite64(int fd, void *buf, size_t size, off64_t ofs)
 115 {
 116         if (smbw_fd(fd)) {
 117                 return smbw_pwrite(fd, buf, size, ofs);
 118         }
 119
 120         return real_pwrite64(fd, buf, size, ofs);
 121 }
 122 #endif
 123
 124
 125  int chdir(char *name)
 126 {
 127         return smbw_chdir(name);
 128 }
 129
 130 #ifdef HAVE___CHDIR
 131  int __chdir(char *name)
 132 {
 133         return chdir(name);
 134 }
 135 #elif HAVE__CHDIR
 136  int _chdir(char *name)
 137 {
 138         return chdir(name);
 139 }
 140 #endif
 141
 142
 143  int close(int fd)
 144 {
 145         if (smbw_fd(fd)) {
 146                 return smbw_close(fd);
 147         }
 148
 149         return real_close(fd);
 150 }
 151
 152 #ifdef HAVE___CLOSE
 153  int __close(int fd)
 154 {
 155         return close(fd);
 156 }
 157 #elif HAVE__CLOSE
 158  int _close(int fd)
 159 {
 160         return close(fd);
 161 }
 162 #endif
 163
 164
 165  int fchdir(int fd)
 166 {
 167         return smbw_fchdir(fd);
 168 }
 169
 170 #ifdef HAVE___FCHDIR
 171  int __fchdir(int fd)
 172 {
 173         return fchdir(fd);
 174 }
 175 #elif HAVE__FCHDIR
 176  int _fchdir(int fd)
 177 {
 178         return fchdir(fd);
 179 }
 180 #endif
 181
 182
 183  int fcntl(int fd, int cmd, long arg)
 184 {
 185         if (smbw_fd(fd)) {
 186                 return smbw_fcntl(fd, cmd, arg);
 187         }
 188
 189         return real_fcntl(fd, cmd, arg);
 190 }
 191
 192
 193 #ifdef HAVE___FCNTL
 194  int __fcntl(int fd, int cmd, long arg)
 195 {
 196         return fcntl(fd, cmd, arg);
 197 }
 198 #elif HAVE__FCNTL
 199  int _fcntl(int fd, int cmd, long arg)
 200 {
 201         return fcntl(fd, cmd, arg);
 202 }
 203 #endif
 204
 205
 206
 207 #ifdef real_getdents
 208  int getdents(int fd, void *dirp, unsigned int count)
 209 {
 210         if (smbw_fd(fd)) {
 211                 return smbw_getdents(fd, dirp, count);
 212         }
 213
 214         return real_getdents(fd, dirp, count);
 215 }
 216 #endif
 217
 218 #ifdef HAVE___GETDENTS
 219  int __getdents(int fd, void *dirp, unsigned int count)
 220 {
 221         return getdents(fd, dirp, count);
 222 }
 223 #elif HAVE__GETDENTS
 224  int _getdents(int fd, void *dirp, unsigned int count)
 225 {
 226         return getdents(fd, dirp, count);
 227 }
 228 #endif
 229
 230
 231  off_t lseek(int fd, off_t offset, int whence)
 232 {
 233         if (smbw_fd(fd)) {
 234                 return smbw_lseek(fd, offset, whence);
 235         }
 236
 237         return real_lseek(fd, offset, whence);
 238 }
 239
 240 #ifdef HAVE___LSEEK
 241  off_t __lseek(int fd, off_t offset, int whence)
 242 {
 243         return lseek(fd, offset, whence);
 244 }
 245 #elif HAVE__LSEEK
 246  off_t _lseek(int fd, off_t offset, int whence)
 247 {
 248         return lseek(fd, offset, whence);
 249 }
 250 #endif
 251
 252
 253  ssize_t read(int fd, void *buf, size_t count)
 254 {
 255         if (smbw_fd(fd)) {
 256                 return smbw_read(fd, buf, count);
 257         }
 258
 259         return real_read(fd, buf, count);
 260 }
 261
 262 #ifdef HAVE___READ
 263  ssize_t __read(int fd, void *buf, size_t count)
 264 {
 265         return read(fd, buf, count);
 266 }
 267 #elif HAVE__READ
 268  ssize_t _read(int fd, void *buf, size_t count)
 269 {
 270         return read(fd, buf, count);
 271 }
 272 #endif
 273
 274
 275  ssize_t write(int fd, void *buf, size_t count)
 276 {
 277         if (smbw_fd(fd)) {
 278                 return smbw_write(fd, buf, count);
 279         }
 280
 281         return real_write(fd, buf, count);
 282 }
 283
 284 #ifdef HAVE___WRITE
 285  ssize_t __write(int fd, void *buf, size_t count)
 286 {
 287         return write(fd, buf, count);
 288 }
 289 #elif HAVE__WRITE
 290  ssize_t _write(int fd, void *buf, size_t count)
 291 {
 292         return write(fd, buf, count);
 293 }
 294 #endif
 295
 296
 297
 298  int access(char *name, int mode)
 299 {
 300         if (smbw_path(name)) {
 301                 return smbw_access(name, mode);
 302         }
 303
 304         return real_access(name, mode);
 305 }
 306
 307
 308
 309  int chmod(char *name,mode_t mode)
 310 {
 311         if (smbw_path(name)) {
 312                 return smbw_chmod(name, mode);
 313         }
 314
 315         return real_chmod(name, mode);
 316 }
 317
 318
 319
 320  int chown(char *name,uid_t owner, gid_t group)
 321 {
 322         if (smbw_path(name)) {
 323                 return smbw_chown(name, owner, group);
 324         }
 325
 326         return real_chown(name, owner, group);
 327 }
 328
 329
 330  char *getcwd(char *buf, size_t size)
 331 {
 332         return (char *)smbw_getcwd(buf, size);
 333 }
 334
 335
 336
 337
 338  int mkdir(char *name, mode_t mode)
 339 {
 340         if (smbw_path(name)) {
 341                 return smbw_mkdir(name, mode);
 342         }
 343
 344         return real_mkdir(name, mode);
 345 }
 346
 347
 348 #if HAVE___FXSTAT
 349  int __fxstat(int vers, int fd, void *st)
 350 {
 351         double xx[32];
 352         int ret;
 353
 354         if (smbw_fd(fd)) {
 355                 return smbw_fstat(fd, st);
 356         }
 357
 358         ret = real_fstat(fd, xx);
 359         xstat_convert(vers, st, xx);
 360         return ret;
 361 }
 362 #endif
 363
 364 #if HAVE___XSTAT
 365  int __xstat(int vers, char *name, void *st)
 366 {
 367         double xx[32];
 368         int ret;
 369
 370         if (smbw_path(name)) {
 371                 return smbw_stat(name, st);
 372         }
 373
 374         ret = real_stat(name, xx);
 375         xstat_convert(vers, st, xx);
 376         return ret;
 377 }
 378 #endif
 379
 380
 381 #if HAVE___LXSTAT
 382  int __lxstat(int vers, char *name, void *st)
 383 {
 384         double xx[32];
 385         int ret;
 386
 387         if (smbw_path(name)) {
 388                 return smbw_stat(name, st);
 389         }
 390
 391         ret = real_lstat(name, xx);
 392         xstat_convert(vers, st, xx);
 393         return ret;
 394 }
 395 #endif
 396
 397
 398  int stat(char *name, void *st)
 399 {
 400 #if HAVE___XSTAT
 401         return __xstat(0, name, st);
 402 #else
 403         if (smbw_path(name)) {
 404                 return smbw_stat(name, st);
 405         }
 406         return real_stat(name, st);
 407 #endif
 408 }
 409
 410  int lstat(char *name, void *st)
 411 {
 412 #if HAVE___LXSTAT
 413         return __lxstat(0, name, st);
 414 #else
 415         if (smbw_path(name)) {
 416                 return smbw_stat(name, st);
 417         }
 418         return real_lstat(name, st);
 419 #endif
 420 }
 421
 422  int fstat(int fd, void *st)
 423 {
 424 #if HAVE___LXSTAT
 425         return __fxstat(0, fd, st);
 426 #else
 427         if (smbw_fd(fd)) {
 428                 return smbw_fstat(fd, st);
 429         }
 430         return real_fstat(fd, st);
 431 #endif
 432 }
 433
 434
 435  int unlink(char *name)
 436 {
 437         if (smbw_path(name)) {
 438                 return smbw_unlink(name);
 439         }
 440
 441         return real_unlink(name);
 442 }
 443
 444
 445 #ifdef HAVE_UTIME
 446  int utime(char *name,void *tvp)
 447 {
 448         if (smbw_path(name)) {
 449                 return smbw_utime(name, tvp);
 450         }
 451
 452         return real_utime(name, tvp);
 453 }
 454 #endif
 455
 456 #ifdef HAVE_UTIMES
 457  int utimes(char *name,void *tvp)
 458 {
 459         if (smbw_path(name)) {
 460                 return smbw_utimes(name, tvp);
 461         }
 462
 463         return real_utimes(name, tvp);
 464 }
 465 #endif
 466
 467  int readlink(char *path, char *buf, size_t bufsize)
 468 {
 469         if (smbw_path(path)) {
 470                 return smbw_readlink(path, buf, bufsize);
 471         }
 472
 473         return real_readlink(path, buf, bufsize);
 474 }
 475
 476
 477  int rename(char *oldname,char *newname)
 478 {
 479         int p1, p2;
 480         p1 = smbw_path(oldname);
 481         p2 = smbw_path(newname);
 482         if (p1 ^ p2) {
 483                 /* can't cross filesystem boundaries */
 484                 errno = EXDEV;
 485                 return -1;
 486         }
 487         if (p1 && p2) {
 488                 return smbw_rename(oldname, newname);
 489         }
 490
 491         return real_rename(oldname, newname);
 492 }
 493
 494  int rmdir(char *name)
 495 {
 496         if (smbw_path(name)) {
 497                 return smbw_rmdir(name);
 498         }
 499
 500         return real_rmdir(name);
 501 }
 502
 503
 504  int symlink(char *topath,char *frompath)
 505 {
 506         int p1, p2;
 507         p1 = smbw_path(topath);
 508         p2 = smbw_path(frompath);
 509         if (p1 || p2) {
 510                 /* can't handle symlinks */
 511                 errno = EPERM;
 512                 return -1;
 513         }
 514
 515         return real_symlink(topath, frompath);
 516 }
 517
 518  int dup(int fd)
 519 {
 520         if (smbw_fd(fd)) {
 521                 return smbw_dup(fd);
 522         }
 523
 524         return real_dup(fd);
 525 }
 526
 527  int dup2(int oldfd, int newfd)
 528 {
 529         if (smbw_fd(newfd)) {
 530                 close(newfd);
 531         }
 532
 533         if (smbw_fd(oldfd)) {
 534                 return smbw_dup2(oldfd, newfd);
 535         }
 536
 537         return real_dup2(oldfd, newfd);
 538 }
 539
 540 #ifdef real_opendir
 541  void *opendir(char *name)
 542 {
 543         if (smbw_path(name)) {
 544                 return (void *)smbw_opendir(name);
 545         }
 546
 547         return (void *)real_opendir(name);
 548 }
 549 #endif
 550
 551 #ifdef real_readdir
 552  void *readdir(void *dir)
 553 {
 554         if (smbw_dirp(dir)) {
 555                 return (void *)smbw_readdir(dir);
 556         }
 557
 558         return (void *)real_readdir(dir);
 559 }
 560 #endif
 561
 562 #ifdef real_closedir
 563  int closedir(void *dir)
 564 {
 565         if (smbw_dirp(dir)) {
 566                 return smbw_closedir(dir);
 567         }
 568
 569         return real_closedir(dir);
 570 }
 571 #endif
 572
 573 #ifdef real_telldir
 574  off_t telldir(void *dir)
 575 {
 576         if (smbw_dirp(dir)) {
 577                 return smbw_telldir(dir);
 578         }
 579
 580         return real_telldir(dir);
 581 }
 582 #endif
 583
 584 #ifdef real_seekdir
 585  int seekdir(void *dir, off_t offset)
 586 {
 587         if (smbw_dirp(dir)) {
 588                 smbw_seekdir(dir, offset);
 589                 return 0;
 590         }
 591
 592         real_seekdir(dir, offset);
 593         return 0;
 594 }
 595 #endif
 596
 597
 598 #ifndef NO_ACL_WRAPPER
 599  int  acl(char  *pathp,  int  cmd,  int  nentries, void *aclbufp)
 600 {
 601         if (smbw_path(pathp)) {
 602                 return smbw_acl(pathp, cmd, nentries, aclbufp);
 603         }
 604
 605         return real_acl(pathp, cmd, nentries, aclbufp);
 606 }
 607 #endif
 608
 609 #ifndef NO_FACL_WRAPPER
 610  int  facl(int fd,  int  cmd,  int  nentries, void *aclbufp)
 611 {
 612         if (smbw_fd(fd)) {
 613                 return smbw_facl(fd, cmd, nentries, aclbufp);
 614         }
 615
 616         return real_facl(fd, cmd, nentries, aclbufp);
 617 }
 618 #endif
 619
 620  int creat(char *path, mode_t mode)
 621 {
 622         extern int creat_bits;
 623         return open(path, creat_bits, mode);
 624 }
 625
 626 #ifdef HAVE_CREAT64
 627  int creat64(char *path, mode_t mode)
 628 {
 629         extern int creat_bits;
 630         return open64(path, creat_bits, mode);
 631 }
 632 #endif
 633
 634 #ifdef HAVE_STAT64
 635   int stat64(char *name, void *st64)
 636 {
 637         if (smbw_path(name)) {
 638                 double xx[32];
 639                 int ret = stat(name, xx);
 640                 stat64_convert(xx, st64);
 641                 return ret;
 642         }
 643         return real_stat64(name, st64);
 644 }
 645
 646   int fstat64(int fd, void *st64)
 647 {
 648         if (smbw_fd(fd)) {
 649                 double xx[32];
 650                 int ret = fstat(fd, xx);
 651                 stat64_convert(xx, st64);
 652                 return ret;
 653         }
 654         return real_fstat64(fd, st64);
 655 }
 656
 657   int lstat64(char *name, void *st64)
 658 {
 659         if (smbw_path(name)) {
 660                 double xx[32];
 661                 int ret = lstat(name, xx);
 662                 stat64_convert(xx, st64);
 663                 return ret;
 664         }
 665         return real_lstat64(name, st64);
 666 }
 667 #endif
 668
 669 #ifdef HAVE_LLSEEK
 670   offset_t llseek(int fd, offset_t ofs, int whence)
 671 {
 672         if (smbw_fd(fd)) {
 673                 return lseek(fd, ofs, whence);
 674         }
 675         return real_llseek(fd, ofs, whence);
 676 }
 677 #endif
 678
 679 #ifdef HAVE_READDIR64
 680  void *readdir64(void *dir)
 681 {
 682         if (smbw_dirp(dir)) {
 683                 static double xx[70];
 684                 void *d;
 685                 d = (void *)readdir(dir);
 686                 if (!d) return NULL;
 687                 dirent64_convert(d, xx);
 688                 return xx;
 689         }
 690         return (void *)real_readdir64(dir);
 691 }
 692 #endif
 693
 694  int fork(void)
 695 {
 696         return smbw_fork();
 697 }
 698