more solaris 2.5 fixups. It now seems to be working pretty well.
[ira/wip.git] / source3 / 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 #ifdef HAVE__OPEN
26 __asm__(".globl _open; _open = open");
27 #elif HAVE___OPEN
28 __asm__(".globl __open; __open = open");
29 #endif
30
31  int open(const char *name, int flags, mode_t mode)
32 {
33         if (smbw_path(name)) {
34                 return smbw_open(name, flags, mode);
35         }
36
37         return real_open(name, flags, mode);
38 }
39
40
41 #ifdef HAVE___CHDIR
42 __asm__(".globl __chdir; __chdir = chdir");
43 #elif HAVE__CHDIR
44 __asm__(".globl _chdir; _chdir = chdir");
45 #endif
46
47  int chdir(const char *name)
48 {
49         return smbw_chdir(name);
50 }
51
52
53
54 #ifdef HAVE___CLOSE
55 __asm__(".globl __close; __close = close");
56 #elif HAVE__CLOSE
57 __asm__(".globl _close; _close = close");
58 #endif
59
60  ssize_t close(int fd)
61 {
62         if (smbw_fd(fd)) {
63                 return smbw_close(fd);
64         }
65
66         return real_close(fd);
67 }
68
69
70 #ifdef HAVE___FCHDIR
71 __asm__(".globl __fchdir; __fchdir = fchdir");
72 #elif HAVE__FCHDIR
73 __asm__(".globl _fchdir; _fchdir = fchdir");
74 #endif
75
76  int fchdir(int fd)
77 {
78         if (smbw_fd(fd)) {
79                 return smbw_fchdir(fd);
80         }
81
82         return real_fchdir(fd);
83 }
84
85
86 #ifdef HAVE___FCNTL
87 __asm__(".globl __fcntl; __fcntl = fcntl");
88 #elif HAVE__FCNTL
89 __asm__(".globl _fcntl; _fcntl = fcntl");
90 #endif
91
92  int fcntl(int fd, int cmd, long arg)
93 {
94         if (smbw_fd(fd)) {
95                 return smbw_fcntl(fd, cmd, arg);
96         }
97
98         return real_fcntl(fd, cmd, arg);
99 }
100
101
102
103 #ifdef HAVE___GETDENTS
104 __asm__(".globl __getdents; __getdents = getdents");
105 #elif HAVE__GETDENTS
106 __asm__(".globl _getdents; _getdents = getdents");
107 #endif
108
109  int getdents(int fd, struct dirent *dirp, unsigned int count)
110 {
111         if (smbw_fd(fd)) {
112                 return smbw_getdents(fd, dirp, count);
113         }
114
115         return real_getdents(fd, dirp, count);
116 }
117
118
119 #ifdef HAVE___LSEEK
120 __asm__(".globl __lseek; __lseek = lseek");
121 #elif HAVE__LSEEK
122 __asm__(".globl _lseek; _lseek = lseek");
123 #endif
124
125  ssize_t lseek(int fd, off_t offset, int whence)
126 {
127         if (smbw_fd(fd)) {
128                 return smbw_lseek(fd, offset, whence);
129         }
130
131         return real_lseek(fd, offset, whence);
132 }
133
134
135
136 #ifdef HAVE___READ
137 __asm__(".globl __read; __read = read");
138 #elif HAVE__READ
139 __asm__(".globl _read; _read = read");
140 #endif
141
142  ssize_t read(int fd, void *buf, size_t count)
143 {
144         if (smbw_fd(fd)) {
145                 return smbw_read(fd, buf, count);
146         }
147
148         return real_read(fd, buf, count);
149 }
150
151
152 #ifdef HAVE___WRITE
153 __asm__(".globl __write; __write = write");
154 #elif HAVE__WRITE
155 __asm__(".globl _write; _write = write");
156 #endif
157
158  ssize_t write(int fd, void *buf, size_t count)
159 {
160         if (smbw_fd(fd)) {
161                 return smbw_write(fd, buf, count);
162         }
163
164         return real_write(fd, buf, count);
165 }
166
167
168  int access(const char *name, int mode)
169 {
170         if (smbw_path(name)) {
171                 return smbw_access(name, mode);
172         }
173
174         return real_access(name, mode);
175 }
176
177
178
179  int chmod(const char *name,mode_t mode)
180 {
181         if (smbw_path(name)) {
182                 return smbw_chmod(name, mode);
183         }
184
185         return real_chmod(name, mode);
186 }
187
188
189
190  int chown(const char *name,uid_t owner, gid_t group)
191 {
192         if (smbw_path(name)) {
193                 return smbw_chown(name, owner, group);
194         }
195
196         return real_chown(name, owner, group);
197 }
198
199 #ifdef LINUX
200  int __fxstat(int vers, int fd, struct stat *st)
201 {
202         struct kernel_stat kbuf;
203         int ret;
204
205         if (smbw_fd(fd)) {
206                 return smbw_fstat(fd, st);
207         }
208
209         switch (vers) {
210         case _STAT_VER_LINUX_OLD:
211                 /* Nothing to do.  The struct is in the form the kernel expects
212                    it to be.  */
213                 return real_fstat(fd, (struct kernel_stat *)st);
214                 break;
215
216         case _STAT_VER_LINUX:
217                 /* Do the system call.  */
218                 ret = real_fstat(fd, &kbuf);
219
220                 st->st_dev = kbuf.st_dev;
221 #ifdef _HAVE___PAD1
222                 st->__pad1 = 0;
223 #endif
224                 st->st_ino = kbuf.st_ino;
225                 st->st_mode = kbuf.st_mode;
226                 st->st_nlink = kbuf.st_nlink;
227                 st->st_uid = kbuf.st_uid;
228                 st->st_gid = kbuf.st_gid;
229                 st->st_rdev = kbuf.st_rdev;
230 #ifdef _HAVE___PAD2
231                 st->__pad2 = 0;
232 #endif
233                 st->st_size = kbuf.st_size;
234                 st->st_blksize = kbuf.st_blksize;
235                 st->st_blocks = kbuf.st_blocks;
236                 st->st_atime = kbuf.st_atime;
237 #ifdef _HAVE___UNUSED1
238                 st->__unused1 = 0;
239 #endif
240                 st->st_mtime = kbuf.st_mtime;
241 #ifdef _HAVE___UNUSED2
242                 st->__unused2 = 0;
243 #endif
244                 st->st_ctime = kbuf.st_ctime;
245 #ifdef _HAVE___UNUSED3
246                 st->__unused3 = 0;
247 #endif
248 #ifdef _HAVE___UNUSED4
249                 st->__unused4 = 0;
250 #endif
251 #ifdef _HAVE___UNUSED5
252                 st->__unused5 = 0;
253 #endif
254                 return ret;
255
256         default:
257                 errno = EINVAL;
258                 return -1;
259         }
260 }
261 #endif
262
263
264  char *getcwd(char *buf, size_t size)
265 {
266         return smbw_getcwd(buf, size);
267 }
268
269
270 #ifdef LINUX
271  int __lxstat(int vers, const char *name, struct stat *st)
272 {
273         struct kernel_stat kbuf;
274         int ret;
275
276         if (smbw_path(name)) {
277                 return smbw_stat(name, st);
278         }
279
280         switch (vers) {
281         case _STAT_VER_LINUX_OLD:
282                 /* Nothing to do.  The struct is in the form the kernel expects
283                    it to be.  */
284                 return real_lstat(name, (struct kernel_stat *)st);
285                 break;
286
287         case _STAT_VER_LINUX:
288                 /* Do the system call.  */
289                 ret = real_lstat(name, &kbuf);
290
291                 st->st_dev = kbuf.st_dev;
292 #ifdef _HAVE___PAD1
293                 st->__pad1 = 0;
294 #endif
295                 st->st_ino = kbuf.st_ino;
296                 st->st_mode = kbuf.st_mode;
297                 st->st_nlink = kbuf.st_nlink;
298                 st->st_uid = kbuf.st_uid;
299                 st->st_gid = kbuf.st_gid;
300                 st->st_rdev = kbuf.st_rdev;
301 #ifdef _HAVE___PAD2
302                 st->__pad2 = 0;
303 #endif
304                 st->st_size = kbuf.st_size;
305                 st->st_blksize = kbuf.st_blksize;
306                 st->st_blocks = kbuf.st_blocks;
307                 st->st_atime = kbuf.st_atime;
308 #ifdef _HAVE___UNUSED1
309                 st->__unused1 = 0;
310 #endif
311                 st->st_mtime = kbuf.st_mtime;
312 #ifdef _HAVE___UNUSED2
313                 st->__unused2 = 0;
314 #endif
315                 st->st_ctime = kbuf.st_ctime;
316 #ifdef _HAVE___UNUSED3
317                 st->__unused3 = 0;
318 #endif
319 #ifdef _HAVE___UNUSED4
320                 st->__unused4 = 0;
321 #endif
322 #ifdef _HAVE___UNUSED5
323                 st->__unused5 = 0;
324 #endif
325                 return ret;
326
327         default:
328                 errno = EINVAL;
329                 return -1;
330         }
331 }
332 #endif
333
334
335  int mkdir(const char *name, mode_t mode)
336 {
337         if (smbw_path(name)) {
338                 return smbw_mkdir(name, mode);
339         }
340
341         return real_mkdir(name, mode);
342 }
343
344
345 #ifdef LINUX
346  int __xstat(int vers, const char *name, struct stat *st)
347 {
348         struct kernel_stat kbuf;
349         int ret;
350
351         if (smbw_path(name)) {
352                 return smbw_stat(name, st);
353         }
354
355         switch (vers) {
356         case _STAT_VER_LINUX_OLD:
357                 /* Nothing to do.  The struct is in the form the kernel expects
358                    it to be.  */
359                 return real_stat(name, (struct kernel_stat *)st);
360                 break;
361
362         case _STAT_VER_LINUX:
363                 /* Do the system call.  */
364                 ret = real_stat(name, &kbuf);
365
366                 st->st_dev = kbuf.st_dev;
367 #ifdef _HAVE___PAD1
368                 st->__pad1 = 0;
369 #endif
370                 st->st_ino = kbuf.st_ino;
371                 st->st_mode = kbuf.st_mode;
372                 st->st_nlink = kbuf.st_nlink;
373                 st->st_uid = kbuf.st_uid;
374                 st->st_gid = kbuf.st_gid;
375                 st->st_rdev = kbuf.st_rdev;
376 #ifdef _HAVE___PAD2
377                 st->__pad2 = 0;
378 #endif
379                 st->st_size = kbuf.st_size;
380                 st->st_blksize = kbuf.st_blksize;
381                 st->st_blocks = kbuf.st_blocks;
382                 st->st_atime = kbuf.st_atime;
383 #ifdef _HAVE___UNUSED1
384                 st->__unused1 = 0;
385 #endif
386                 st->st_mtime = kbuf.st_mtime;
387 #ifdef _HAVE___UNUSED2
388                 st->__unused2 = 0;
389 #endif
390                 st->st_ctime = kbuf.st_ctime;
391 #ifdef _HAVE___UNUSED3
392                 st->__unused3 = 0;
393 #endif
394 #ifdef _HAVE___UNUSED4
395                 st->__unused4 = 0;
396 #endif
397 #ifdef _HAVE___UNUSED5
398                 st->__unused5 = 0;
399 #endif
400                 return ret;
401
402         default:
403                 errno = EINVAL;
404                 return -1;
405         }
406 }
407 #endif
408
409  int stat(const char *name, struct stat *st)
410 {
411 #if HAVE___XSTAT
412         return __xstat(_STAT_VER, name, st);
413 #else
414         if (smbw_path(name)) {
415                 return smbw_stat(name, st);
416         }
417         return real_stat(name, st);
418 #endif
419 }
420
421  int lstat(const char *name, struct stat *st)
422 {
423 #if HAVE___LXSTAT
424         return __lxstat(_STAT_VER, name, st);
425 #else
426         if (smbw_path(name)) {
427                 return smbw_stat(name, st);
428         }
429         return real_lstat(name, st);
430 #endif
431 }
432
433  int fstat(int fd, struct stat *st)
434 {
435 #if HAVE___LXSTAT
436         return __fxstat(_STAT_VER, fd, st);
437 #else
438         if (smbw_fd(fd)) {
439                 return smbw_fstat(fd, st);
440         }
441         return real_fstat(fd, st);
442 #endif
443 }
444
445
446  int unlink(const char *name)
447 {
448         if (smbw_path(name)) {
449                 return smbw_unlink(name);
450         }
451
452         return real_unlink(name);
453 }
454
455
456  int utime(const char *name,void *tvp)
457 {
458         if (smbw_path(name)) {
459                 return smbw_utime(name, tvp);
460         }
461
462         return real_utime(name, tvp);
463 }
464
465  int readlink(char *path, char *buf, size_t bufsize)
466 {
467         if (smbw_path(path)) {
468                 return smbw_readlink(path, buf, bufsize);
469         }
470
471         return real_readlink(path, buf, bufsize);
472 }
473
474
475  int rename(const char *oldname,const char *newname)
476 {
477         int p1, p2;
478         p1 = smbw_path(oldname); 
479         p2 = smbw_path(newname); 
480         if (p1 ^ p2) {
481                 /* can't cross filesystem boundaries */
482                 errno = EXDEV;
483                 return -1;
484         }
485         if (p1 && p2) {
486                 return smbw_rename(oldname, newname);
487         }
488
489         return real_rename(oldname, newname);
490 }
491
492  int rmdir(const char *name)
493 {
494         if (smbw_path(name)) {
495                 return smbw_rmdir(name);
496         }
497
498         return real_rmdir(name);
499 }
500
501
502  int symlink(const char *topath,const char *frompath)
503 {
504         int p1, p2;
505         p1 = smbw_path(topath); 
506         p2 = smbw_path(frompath); 
507         if (p1 || p2) {
508                 /* can't handle symlinks */
509                 errno = EPERM;
510                 return -1;
511         }
512
513         return real_symlink(topath, frompath);
514 }
515
516  int dup(int fd)
517 {
518         if (smbw_fd(fd)) {
519                 return smbw_dup(fd);
520         }
521
522         return real_dup(fd);
523 }
524
525  int dup2(int oldfd, int newfd)
526 {
527         if (smbw_fd(newfd)) {
528                 close(newfd);
529         }
530
531         if (smbw_fd(oldfd)) {
532                 return smbw_dup2(oldfd, newfd);
533         }
534
535         return real_dup2(oldfd, newfd);
536 }
537
538  DIR *opendir(const char *name)
539 {
540         if (smbw_path(name)) {
541                 return smbw_opendir(name);
542         }
543
544         return real_opendir(name);
545 }
546
547
548  struct dirent *readdir(DIR *dir)
549 {
550         if (smbw_dirp(dir)) {
551                 return smbw_readdir(dir);
552         }
553
554         return real_readdir(dir);
555 }
556
557  int closedir(DIR *dir)
558 {
559         if (smbw_dirp(dir)) {
560                 return smbw_closedir(dir);
561         }
562
563         return real_closedir(dir);
564 }
565
566 #ifndef NO_TELLDIR_WRAPPER
567  off_t telldir(DIR *dir)
568 {
569         if (smbw_dirp(dir)) {
570                 return smbw_telldir(dir);
571         }
572
573         return real_telldir(dir);
574 }
575 #endif
576
577 #ifndef NO_SEEKDIR_WRAPPER
578  void seekdir(DIR *dir, off_t offset)
579 {
580         if (smbw_dirp(dir)) {
581                 smbw_seekdir(dir, offset);
582                 return;
583         }
584
585         real_seekdir(dir, offset);
586 }
587 #endif
588
589
590 #ifndef NO_ACL_WRAPPER
591  int  acl(const char  *pathp,  int  cmd,  int  nentries, aclent_t *aclbufp)
592 {
593         if (smbw_path(pathp)) {
594                 switch (cmd) {
595                 case GETACL:
596                 case GETACLCNT:
597                         return 0;
598                 default:
599                         errno = ENOSYS;
600                         return -1;
601                 }
602         }
603
604         real_acl(pathp, cmd, nentries, aclbufp);
605 }
606 #endif
607
608 #ifndef NO_FACL_WRAPPER
609  int  facl(int fd,  int  cmd,  int  nentries, aclent_t *aclbufp)
610 {
611         if (smbw_fd(fd)) {
612                 switch (cmd) {
613                 case GETACL:
614                 case GETACLCNT:
615                         return 0;
616                 default:
617                         errno = ENOSYS;
618                         return -1;
619                 }
620         }
621
622         real_facl(fd, cmd, nentries, aclbufp);
623 }
624 #endif
625
626  int creat(const char *path, mode_t mode)
627 {
628         return open(path, O_WRONLY | O_CREAT | O_TRUNC, mode);
629 }