source: trunk-3.0/examples/libsmbclient/smbwrapper/smbw.c@ 101

Last change on this file since 101 was 1, checked in by Paul Smedley, 18 years ago

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