r23785: use the GPLv3 boilerplate as recommended by the FSF and the license text
[samba.git] / examples / libsmbclient / smbwrapper / smbw.c
1 /* 
2    Unix SMB/Netbios implementation.
3    Version 2.0
4    SMB wrapper functions
5    Copyright (C) Andrew Tridgell 1998
6    Copyright (C) Derrell Lipman 2003-2005
7    
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 3 of the License, or
11    (at your option) any later version.
12    
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17    
18    You should have received a copy of the GNU General Public License
19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
20 */
21
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <unistd.h>
25 #include <stdarg.h>
26 #include <assert.h>
27 #include "smbw.h"
28 #include "bsd-strlfunc.h"
29
30 typedef enum StartupType
31 {
32         StartupType_Fake,
33         StartupType_Real
34 } StartupType;
35
36 int smbw_fd_map[__FD_SETSIZE];
37 int smbw_ref_count[__FD_SETSIZE];
38 char smbw_cwd[PATH_MAX];
39 char smbw_prefix[] = SMBW_PREFIX;
40
41 /* needs to be here because of dumb include files on some systems */
42 int creat_bits = O_WRONLY|O_CREAT|O_TRUNC;
43
44 int smbw_initialized = 0;
45
46 static int debug_level = 0;
47
48 static SMBCCTX *smbw_ctx;
49
50 extern int smbw_debug;
51
52
53 /*****************************************************
54 smbw_ref -- manipulate reference counts
55 ******************************************************/
56 int smbw_ref(int client_fd, Ref_Count_Type type, ...)
57 {
58         va_list ap;
59
60         /* client id values begin at SMBC_BASE_FC. */
61         client_fd -= SMBC_BASE_FD;
62
63         va_start(ap, type);
64         switch(type)
65         {
66         case SMBW_RCT_Increment:
67                 return ++smbw_ref_count[client_fd];
68
69         case SMBW_RCT_Decrement:
70                 return --smbw_ref_count[client_fd];
71
72         case SMBW_RCT_Get:
73                 return smbw_ref_count[client_fd];
74
75         case SMBW_RCT_Set:
76                 return (smbw_ref_count[client_fd] = va_arg(ap, int));
77         }
78         va_end(ap);
79
80         /* never gets here */
81         return -1;
82 }
83
84
85 /*
86  * Return a username and password given a server and share name
87  *
88  * Returns 0 upon success;
89  * non-zero otherwise, and errno is set to indicate the error.
90  */
91 static void get_envvar_auth_data(const char *srv, 
92                                  const char *shr,
93                                  char *wg, int wglen, 
94                                  char *un, int unlen,
95                                  char *pw, int pwlen)
96 {
97         char *u;
98         char *p;
99         char *w;
100
101         /* Fall back to environment variables */
102
103         w = getenv("WORKGROUP");
104         if (w == NULL) w = "";
105
106         u = getenv("USER");
107         if (u == NULL) u = "";
108
109         p = getenv("PASSWORD");
110         if (p == NULL) p = "";
111
112         smbw_strlcpy(wg, w, wglen);
113         smbw_strlcpy(un, u, unlen);
114         smbw_strlcpy(pw, p, pwlen);
115 }
116
117 static smbc_get_auth_data_fn get_auth_data_fn = get_envvar_auth_data;
118
119 /*****************************************************
120 set the get auth data function
121 ******************************************************/
122 void smbw_set_auth_data_fn(smbc_get_auth_data_fn fn)
123 {
124         get_auth_data_fn = fn;
125 }
126
127
128 /*****************************************************
129 ensure that all connections are terminated upon exit
130 ******************************************************/
131 static void do_shutdown(void)
132 {
133         if (smbw_ctx != NULL) {
134                 smbc_free_context(smbw_ctx, 1);
135         }
136 }
137
138
139 /***************************************************** 
140 initialise structures
141 *******************************************************/
142 static void do_init(StartupType startupType)
143 {
144         int i;
145         char *p;
146
147         smbw_initialized = 1;   /* this must be first to avoid recursion! */
148
149         smbw_ctx = NULL;        /* don't free context until it's established */
150
151         /* initially, no file descriptors are mapped */
152         for (i = 0; i < __FD_SETSIZE; i++) {
153                 smbw_fd_map[i] = -1;
154                 smbw_ref_count[i] = 0;
155         }
156
157         /* See if we've been told to start in a particular directory */
158         if ((p=getenv("SMBW_DIR")) != NULL) {
159                 smbw_strlcpy(smbw_cwd, p, PATH_MAX);
160
161                 /* we don't want the old directory to be busy */
162                 (* smbw_libc.chdir)("/");
163                 
164         } else {
165                 *smbw_cwd = '\0';
166         }
167
168         if ((p=getenv("DEBUG"))) {
169                 debug_level = atoi(p);
170         }
171
172         if ((smbw_ctx = smbc_new_context()) == NULL) {
173                 fprintf(stderr, "Could not create a context.\n");
174                 exit(1);
175         }
176         
177         smbw_ctx->debug = debug_level;
178         smbw_ctx->callbacks.auth_fn = get_auth_data_fn;
179         smbw_ctx->options.browse_max_lmb_count = 0;
180         smbw_ctx->options.urlencode_readdir_entries = 1;
181         smbw_ctx->options.one_share_per_server = 1;
182         
183         if (smbc_init_context(smbw_ctx) == NULL) {
184                 fprintf(stderr, "Could not initialize context.\n");
185                 exit(1);
186         }
187                 
188         smbc_set_context(smbw_ctx);
189
190         /* if not real startup, exit handler has already been established */
191         if (startupType == StartupType_Real) {
192             atexit(do_shutdown);
193         }
194 }
195
196 /***************************************************** 
197 initialise structures, real start up vs a fork()
198 *******************************************************/
199 void smbw_init(void)
200 {
201     do_init(StartupType_Real);
202 }
203
204
205 /***************************************************** 
206 determine if a file descriptor is a smb one
207 *******************************************************/
208 int smbw_fd(int smbw_fd)
209 {
210         SMBW_INIT();
211
212         return (smbw_fd >= 0 &&
213                 smbw_fd < __FD_SETSIZE &&
214                 smbw_fd_map[smbw_fd] >= SMBC_BASE_FD); /* minimum smbc_ fd */
215 }
216
217
218 /***************************************************** 
219 determine if a path is a smb one
220 *******************************************************/
221 int smbw_path(const char *name)
222 {
223         int len;
224         int ret;
225         int saved_errno;
226
227         saved_errno = errno;
228
229         SMBW_INIT();
230
231         len = strlen(smbw_prefix);
232
233         ret = ((strncmp(name, smbw_prefix, len) == 0 &&
234                 (name[len] == '\0' || name[len] == '/')) ||
235                (*name != '/' && *smbw_cwd != '\0'));
236
237         errno = saved_errno;
238         return ret;
239 }
240
241
242 /***************************************************** 
243 remove redundent stuff from a filename
244 *******************************************************/
245 void smbw_clean_fname(char *name)
246 {
247         char *p, *p2;
248         int l;
249         int modified = 1;
250
251         if (!name) return;
252
253         DEBUG(10, ("Clean [%s]...\n", name));
254
255         while (modified) {
256                 modified = 0;
257
258                 if ((p=strstr(name,"/./"))) {
259                         modified = 1;
260                         while (*p) {
261                                 p[0] = p[2];
262                                 p++;
263                         }
264                         DEBUG(10, ("\tclean 1 (/./) produced [%s]\n", name));
265                 }
266
267                 if ((p=strstr(name,"//"))) {
268                         modified = 1;
269                         while (*p) {
270                                 p[0] = p[1];
271                                 p++;
272                         }
273                         DEBUG(10, ("\tclean 2 (//) produced [%s]\n", name));
274                 }
275
276                 if (strcmp(name,"/../")==0) {
277                         modified = 1;
278                         name[1] = 0;
279                         DEBUG(10,("\tclean 3 (^/../$) produced [%s]\n", name));
280                 }
281
282                 if ((p=strstr(name,"/../"))) {
283                         modified = 1;
284                         for (p2 = (p > name ? p-1 : p); p2 > name; p2--) {
285                                 if (p2[0] == '/') break;
286                         }
287                         if (p2 > name) p2++;
288                         while (*p2) {
289                                 p2[0] = p[3];
290                                 p2++;
291                                 p++;
292                         }
293                         DEBUG(10, ("\tclean 4 (/../) produced [%s]\n", name));
294                 }
295
296                 if (strcmp(name,"/..")==0) {
297                         modified = 1;
298                         name[1] = 0;
299                         DEBUG(10, ("\tclean 5 (^/..$) produced [%s]\n", name));
300                 }
301
302                 l = strlen(name);
303                 p = l>=3?(name+l-3):name;
304                 if (strcmp(p,"/..")==0) {
305                         modified = 1;
306                         for (p2=p-1;p2>name;p2--) {
307                                 if (p2[0] == '/') break;
308                         }
309                         if (p2==name) {
310                                 p[0] = '/';
311                                 p[1] = 0;
312                         } else {
313                                 p2[0] = 0;
314                         }
315                         DEBUG(10, ("\tclean 6 (/..) produced [%s]\n", name));
316                 }
317
318                 l = strlen(name);
319                 p = l>=2?(name+l-2):name;
320                 if (strcmp(p,"/.")==0) {
321                         modified = 1;
322                         if (p == name) {
323                                 p[1] = 0;
324                         } else {
325                                 p[0] = 0;
326                         }
327                         DEBUG(10, ("\tclean 7 (/.) produced [%s]\n", name));
328                 }
329
330                 if (strncmp(p=name,"./",2) == 0) {      
331                         modified = 1;
332                         do {
333                                 p[0] = p[2];
334                         } while (*p++);
335                         DEBUG(10, ("\tclean 8 (^./) produced [%s]\n", name));
336                 }
337
338                 l = strlen(p=name);
339                 if (l > 1 && p[l-1] == '/') {
340                         modified = 1;
341                         p[l-1] = 0;
342                         DEBUG(10, ("\tclean 9 (/) produced [%s]\n", name));
343                 }
344         }
345 }
346
347 void smbw_fix_path(const char *src, char *dest)
348 {
349         const char *p;
350         int len = strlen(smbw_prefix);
351
352         if (*src == '/') {
353                 for (p = src + len; *p == '/'; p++)
354                         ;
355                 snprintf(dest, PATH_MAX, "smb://%s", p);
356         } else {
357                 snprintf(dest, PATH_MAX, "%s/%s", smbw_cwd, src);
358         }
359
360         smbw_clean_fname(dest + 5);
361
362         DEBUG(10, ("smbw_fix_path(%s) returning [%s]\n", src, dest));
363 }
364
365
366
367 /***************************************************** 
368 a wrapper for open()
369 *******************************************************/
370 int smbw_open(const char *fname, int flags, mode_t mode)
371 {
372         int client_fd;
373         int smbw_fd;
374         char path[PATH_MAX];
375
376         SMBW_INIT();
377
378         if (!fname) {
379                 errno = EINVAL;
380                 return -1;
381         }
382
383         smbw_fd = (smbw_libc.open)(SMBW_DUMMY, O_WRONLY, 0200);
384         if (smbw_fd == -1) {
385                 errno = EMFILE;
386                 return -1;
387         }
388
389         smbw_fix_path(fname, path);
390         if (flags == creat_bits) {
391                 client_fd =  smbc_creat(path, mode);
392         } else {
393                 client_fd = smbc_open(path, flags, mode);
394         }
395
396         if (client_fd < 0) {
397                 (* smbw_libc.close)(smbw_fd);
398                 return -1;
399         }
400
401         smbw_fd_map[smbw_fd] = client_fd;
402         smbw_ref(client_fd, SMBW_RCT_Increment);
403         return smbw_fd;
404 }
405
406
407 /***************************************************** 
408 a wrapper for pread()
409
410 there should really be an smbc_pread() to avoid the two
411 lseek()s required in this kludge.
412 *******************************************************/
413 ssize_t smbw_pread(int smbw_fd, void *buf, size_t count, SMBW_OFF_T ofs)
414 {
415         int client_fd;
416         ssize_t ret;
417         int saved_errno;
418         SMBW_OFF_T old_ofs;
419         
420         if (count == 0) {
421                 return 0;
422         }
423
424         client_fd = smbw_fd_map[smbw_fd];
425
426         if ((old_ofs = smbc_lseek(client_fd, 0, SEEK_CUR)) < 0 ||
427             smbc_lseek(client_fd, ofs, SEEK_SET) < 0) {
428                 return -1;
429         }
430
431         if ((ret = smbc_read(client_fd, buf, count)) < 0) {
432                 saved_errno = errno;
433                 (void) smbc_lseek(client_fd, old_ofs, SEEK_SET);
434                 errno = saved_errno;
435                 return -1;
436         }
437
438         return ret;
439 }
440
441 /***************************************************** 
442 a wrapper for read()
443 *******************************************************/
444 ssize_t smbw_read(int smbw_fd, void *buf, size_t count)
445 {
446         int client_fd;
447         
448         client_fd = smbw_fd_map[smbw_fd];
449
450         return smbc_read(client_fd, buf, count);
451 }
452
453         
454
455 /***************************************************** 
456 a wrapper for write()
457 *******************************************************/
458 ssize_t smbw_write(int smbw_fd, void *buf, size_t count)
459 {
460         int client_fd;
461
462         client_fd = smbw_fd_map[smbw_fd];
463
464         return smbc_write(client_fd, buf, count);
465 }
466
467 /***************************************************** 
468 a wrapper for pwrite()
469 *******************************************************/
470 ssize_t smbw_pwrite(int smbw_fd, void *buf, size_t count, SMBW_OFF_T ofs)
471 {
472         int saved_errno;
473         int client_fd;
474         ssize_t ret;
475         SMBW_OFF_T old_ofs;
476         
477         if (count == 0) {
478                 return 0;
479         }
480
481         client_fd = smbw_fd_map[smbw_fd];
482
483         if ((old_ofs = smbc_lseek(client_fd, 0, SEEK_CUR)) < 0 ||
484             smbc_lseek(client_fd, ofs, SEEK_SET) < 0) {
485                 return -1;
486         }
487
488         if ((ret = smbc_write(client_fd, buf, count)) < 0) {
489                 saved_errno = errno;
490                 (void) smbc_lseek(client_fd, old_ofs, SEEK_SET);
491                 errno = saved_errno;
492                 return -1;
493         }
494
495         return ret;
496 }
497
498 /***************************************************** 
499 a wrapper for close()
500 *******************************************************/
501 int smbw_close(int smbw_fd)
502 {
503         int client_fd;
504
505         client_fd = smbw_fd_map[smbw_fd];
506
507         if (smbw_ref(client_fd, SMBW_RCT_Decrement) > 0) {
508                 return 0;
509         }
510         
511         (* smbw_libc.close)(smbw_fd);
512         smbw_fd_map[smbw_fd] = -1;
513         return smbc_close(client_fd);
514 }
515
516
517 /***************************************************** 
518 a wrapper for fcntl()
519 *******************************************************/
520 int smbw_fcntl(int smbw_fd, int cmd, long arg)
521 {
522         return 0;
523 }
524
525
526 /***************************************************** 
527 a wrapper for access()
528 *******************************************************/
529 int smbw_access(const char *name, int mode)
530 {
531         struct SMBW_stat st;
532
533         SMBW_INIT();
534
535         if (smbw_stat(name, &st)) return -1;
536
537         if (((mode & R_OK) && !(st.s_mode & S_IRUSR)) ||
538             ((mode & W_OK) && !(st.s_mode & S_IWUSR)) ||
539             ((mode & X_OK) && !(st.s_mode & S_IXUSR))) {
540                 errno = EACCES;
541                 return -1;
542         }
543         
544         return 0;
545 }
546
547 /***************************************************** 
548 a wrapper for readlink() - needed for correct errno setting
549 *******************************************************/
550 int smbw_readlink(const char *fname, char *buf, size_t bufsize)
551 {
552         struct SMBW_stat st;
553         int ret;
554
555         SMBW_INIT();
556
557         ret = smbw_stat(fname, &st);
558         if (ret != 0) {
559                 return -1;
560         }
561         
562         /* it exists - say it isn't a link */
563         errno = EINVAL;
564         return -1;
565 }
566
567
568 /***************************************************** 
569 a wrapper for unlink()
570 *******************************************************/
571 int smbw_unlink(const char *fname)
572 {
573         char path[PATH_MAX];
574         
575         SMBW_INIT();
576
577         smbw_fix_path(fname, path);
578         return smbc_unlink(path);
579 }
580
581
582 /***************************************************** 
583 a wrapper for rename()
584 *******************************************************/
585 int smbw_rename(const char *oldname, const char *newname)
586 {
587         char path_old[PATH_MAX];
588         char path_new[PATH_MAX];
589
590         SMBW_INIT();
591
592         smbw_fix_path(oldname, path_old);
593         smbw_fix_path(newname, path_new);
594         return smbc_rename(path_old, path_new);
595 }
596
597
598 /***************************************************** 
599 a wrapper for utimes
600 *******************************************************/
601 int smbw_utimes(const char *fname, void *buf)
602 {
603         char path[PATH_MAX];
604
605         smbw_fix_path(fname, path);
606         return smbc_utimes(path, buf);
607 }
608
609
610 /***************************************************** 
611 a wrapper for utime 
612 *******************************************************/
613 int smbw_utime(const char *fname, void *buf)
614 {
615         char path[PATH_MAX];
616
617         smbw_fix_path(fname, path);
618         return smbc_utime(path, buf);
619 }
620
621 /***************************************************** 
622 a wrapper for chown()
623 *******************************************************/
624 int smbw_chown(const char *fname, uid_t owner, gid_t group)
625 {
626         /* always indiciate that this is not supported. */
627         errno = ENOTSUP;
628         return -1;
629 }
630
631 /***************************************************** 
632 a wrapper for chmod()
633 *******************************************************/
634 int smbw_chmod(const char *fname, mode_t newmode)
635 {
636         char path[PATH_MAX];
637
638         smbw_fix_path(fname, path);
639         return smbc_chmod(path, newmode);
640 }
641
642
643 /***************************************************** 
644 a wrapper for lseek()
645 *******************************************************/
646 SMBW_OFF_T smbw_lseek(int smbw_fd,
647                       SMBW_OFF_T offset,
648                       int whence)
649 {
650         int client_fd;
651         SMBW_OFF_T ret;
652         
653         client_fd = smbw_fd_map[smbw_fd];
654
655         ret = smbc_lseek(client_fd, offset, whence);
656         if (smbw_debug)
657         {
658                 printf("smbw_lseek(%d/%d, 0x%llx) returned 0x%llx\n",
659                        smbw_fd, client_fd,
660                        (unsigned long long) offset,
661                        (unsigned long long) ret);
662         }
663         return ret;
664 }
665
666 /***************************************************** 
667 a wrapper for dup()
668 *******************************************************/
669 int smbw_dup(int smbw_fd)
670 {
671         int fd2;
672
673         fd2 = (smbw_libc.dup)(smbw_fd);
674         if (fd2 == -1) {
675                 return -1;
676         }
677
678         smbw_fd_map[fd2] = smbw_fd_map[smbw_fd];
679         smbw_ref(smbw_fd_map[smbw_fd], SMBW_RCT_Increment);
680         return fd2;
681 }
682
683
684 /***************************************************** 
685 a wrapper for dup2()
686 *******************************************************/
687 int smbw_dup2(int smbw_fd, int fd2)
688 {
689         if ((* smbw_libc.dup2)(smbw_fd, fd2) != fd2) {
690                 return -1;
691         }
692
693         smbw_fd_map[fd2] = smbw_fd_map[smbw_fd];
694         smbw_ref(smbw_fd_map[smbw_fd], SMBW_RCT_Increment);
695         return fd2;
696 }
697
698
699 /***************************************************** 
700 when we fork we have to close all connections and files
701 in the child
702 *******************************************************/
703 int smbw_fork(void)
704 {
705         int i;
706         pid_t child_pid;
707         int p[2];
708         char c = 0;
709
710         SMBW_INIT();
711
712         if (pipe(p)) return (* smbw_libc.fork)();
713
714         child_pid = (* smbw_libc.fork)();
715
716         if (child_pid) {
717                 /* block the parent for a moment until the sockets are
718                    closed */
719                 (* smbw_libc.close)(p[1]);
720                 (* smbw_libc.read)(p[0], &c, 1);
721                 (* smbw_libc.close)(p[0]);
722                 return child_pid;
723         }
724
725         (* smbw_libc.close)(p[0]);
726
727         /* close all server connections and locally-opened files */
728         for (i = 0; i < __FD_SETSIZE; i++) {
729                 if (smbw_fd_map[i] > 0 &&
730                     smbw_ref(smbw_fd_map[i], SMBW_RCT_Get) > 0) {
731                         
732                         smbc_close(smbw_fd_map[i]);
733                         smbw_ref(smbw_fd_map[i], SMBW_RCT_Set, 0);
734                         (* smbw_libc.close)(i);
735                 }
736
737                 smbw_fd_map[i] = -1;
738         }
739
740         /* unblock the parent */
741         write(p[1], &c, 1);
742         (* smbw_libc.close)(p[1]);
743
744         /* specify directory to start in, if it's simulated smb */
745         if (*smbw_cwd != '\0') {
746                 setenv("SMBW_DIR", smbw_cwd, 1);
747         } else {
748                 unsetenv("SMBW_DIR");
749         }
750
751         /* Re-initialize this library for the child */
752         do_init(StartupType_Fake);
753
754         /* and continue in the child */
755         return 0;
756 }
757
758 int smbw_setxattr(const char *fname,
759                   const char *name,
760                   const void *value,
761                   size_t size,
762                   int flags)
763 {
764         char path[PATH_MAX];
765
766         if (strcmp(name, "system.posix_acl_access") == 0)
767         {
768                 name = "system.*";
769         }
770
771         smbw_fix_path(fname, path);
772         return smbc_setxattr(path, name, value, size, flags);
773 }
774
775 int smbw_lsetxattr(const char *fname,
776                    const char *name,
777                    const void *value,
778                    size_t size,
779                    int flags)
780 {
781         char path[PATH_MAX];
782
783         if (strcmp(name, "system.posix_acl_access") == 0)
784         {
785                 name = "system.*";
786         }
787
788         smbw_fix_path(fname, path);
789         return smbc_lsetxattr(path, name, value, size, flags);
790 }
791
792 int smbw_fsetxattr(int smbw_fd,
793                    const char *name,
794                    const void *value,
795                    size_t size,
796                    int flags)
797 {
798         int client_fd;
799         
800         if (strcmp(name, "system.posix_acl_access") == 0)
801         {
802                 name = "system.*";
803         }
804
805         client_fd = smbw_fd_map[smbw_fd];
806         return smbc_fsetxattr(client_fd, name, value, size, flags);
807 }
808
809 int smbw_getxattr(const char *fname,
810                   const char *name,
811                   const void *value,
812                   size_t size)
813 {
814         char path[PATH_MAX];
815
816         if (strcmp(name, "system.posix_acl_access") == 0)
817         {
818                 name = "system.*";
819         }
820
821         smbw_fix_path(fname, path);
822
823         return smbc_getxattr(path, name, value, size);
824 }
825
826 int smbw_lgetxattr(const char *fname,
827                    const char *name,
828                    const void *value,
829                    size_t size)
830 {
831         char path[PATH_MAX];
832
833         if (strcmp(name, "system.posix_acl_access") == 0)
834         {
835                 name = "system.*";
836         }
837
838         smbw_fix_path(fname, path);
839         return smbc_lgetxattr(path, name, value, size);
840 }
841
842 int smbw_fgetxattr(int smbw_fd,
843                    const char *name,
844                    const void *value,
845                    size_t size)
846 {
847         int client_fd;
848         
849         if (strcmp(name, "system.posix_acl_access") == 0)
850         {
851                 name = "system.*";
852         }
853
854         client_fd = smbw_fd_map[smbw_fd];
855         return smbc_fgetxattr(client_fd, name, value, size);
856 }
857
858 int smbw_removexattr(const char *fname,
859                      const char *name)
860 {
861         char path[PATH_MAX];
862
863         if (strcmp(name, "system.posix_acl_access") == 0)
864         {
865                 name = "system.*";
866         }
867
868         smbw_fix_path(fname, path);
869         return smbc_removexattr(path, name);
870 }
871
872 int smbw_lremovexattr(const char *fname,
873                       const char *name)
874 {
875         char path[PATH_MAX];
876
877         if (strcmp(name, "system.posix_acl_access") == 0)
878         {
879                 name = "system.*";
880         }
881
882         smbw_fix_path(fname, path);
883         return smbc_lremovexattr(path, name);
884 }
885
886 int smbw_fremovexattr(int smbw_fd,
887                       const char *name)
888 {
889         int client_fd;
890         
891         if (strcmp(name, "system.posix_acl_access") == 0)
892         {
893                 name = "system.*";
894         }
895
896         client_fd = smbw_fd_map[smbw_fd];
897         return smbc_fremovexattr(client_fd, name);
898 }
899
900 int smbw_listxattr(const char *fname,
901                    char *list,
902                    size_t size)
903 {
904         char path[PATH_MAX];
905
906         smbw_fix_path(fname, path);
907         return smbc_listxattr(path, list, size);
908 }
909
910 int smbw_llistxattr(const char *fname,
911                     char *list,
912                     size_t size)
913 {
914         char path[PATH_MAX];
915
916         smbw_fix_path(fname, path);
917         return smbc_llistxattr(path, list, size);
918 }
919
920 int smbw_flistxattr(int smbw_fd,
921                     char *list,
922                     size_t size)
923 {
924         int client_fd;
925         
926         client_fd = smbw_fd_map[smbw_fd];
927         return smbc_flistxattr(client_fd, list, size);
928 }