import HEAD into svn+ssh://svn.samba.org/home/svn/samba/trunk
[metze/old/v3-2-winbind-ndr.git] / source / libsmb / libsmb_compat.c
1 /* 
2    Unix SMB/CIFS implementation.
3    SMB client library implementation (Old interface compatibility)
4    Copyright (C) Andrew Tridgell 1998
5    Copyright (C) Richard Sharpe 2000
6    Copyright (C) John Terpstra 2000
7    Copyright (C) Tom Jansen (Ninja ISD) 2002 
8    Copyright (C) Derrell Lipman 2003
9    
10    This program is free software; you can redistribute it and/or modify
11    it under the terms of the GNU General Public License as published by
12    the Free Software Foundation; either version 2 of the License, or
13    (at your option) any later version.
14    
15    This program is distributed in the hope that it will be useful,
16    but WITHOUT ANY WARRANTY; without even the implied warranty of
17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18    GNU General Public License for more details.
19    
20    You should have received a copy of the GNU General Public License
21    along with this program; if not, write to the Free Software
22    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23 */
24
25
26 #include "includes.h"
27
28 #include "../include/libsmb_internal.h"
29
30 struct smbc_compat_fdlist {
31         SMBCFILE * file;
32         int fd;
33         struct smbc_compat_fdlist *next, *prev;
34 };
35
36 static SMBCCTX * statcont = NULL;
37 static int smbc_compat_initialized = 0;
38 static int smbc_compat_nextfd = 0;
39 static struct smbc_compat_fdlist * smbc_compat_fd_in_use = NULL;
40 static struct smbc_compat_fdlist * smbc_compat_fd_avail = NULL;
41
42 /* Find an fd and return the SMBCFILE * or NULL on failure */
43 static SMBCFILE * find_fd(int fd)
44 {
45         struct smbc_compat_fdlist * f = smbc_compat_fd_in_use;
46         while (f) {
47                 if (f->fd == fd) 
48                         return f->file;
49                 f = f->next;
50         }
51         return NULL;
52 }
53
54 /* Add an fd, returns 0 on success, -1 on error with errno set */
55 static int add_fd(SMBCFILE * file)
56 {
57         struct smbc_compat_fdlist * f = smbc_compat_fd_avail;
58
59         if (f) {
60                 /* We found one that's available */
61                 DLIST_REMOVE(smbc_compat_fd_avail, f);
62
63         } else {
64                 /*
65                  * None were available, so allocate one.  Keep the number of
66                  * file descriptors determinate.  This allows the application
67                  * to allocate bitmaps or mapping of file descriptors based on
68                  * a known maximum number of file descriptors that will ever
69                  * be returned.
70                  */
71                 if (smbc_compat_nextfd >= FD_SETSIZE) {
72                         errno = EMFILE;
73                         return -1;
74                 }
75
76                 f = malloc(sizeof(struct smbc_compat_fdlist));
77                 if (!f) {
78                         errno = ENOMEM;
79                         return -1;
80                 }
81         
82                 f->fd = SMBC_BASE_FD + smbc_compat_nextfd++;
83         }
84
85         f->file = file;
86         DLIST_ADD(smbc_compat_fd_in_use, f);
87
88         return f->fd;
89 }
90
91
92
93 /* Delete an fd, returns 0 on success */
94 static int del_fd(int fd)
95 {
96         struct smbc_compat_fdlist * f = smbc_compat_fd_in_use;
97
98         while (f) {
99                 if (f->fd == fd) 
100                         break;
101                 f = f->next;
102         }
103
104         if (f) {
105                 /* found */
106                 DLIST_REMOVE(smbc_compat_fd_in_use, f);
107                 f->file = NULL;
108                 DLIST_ADD(smbc_compat_fd_avail, f);
109                 return 0;
110         }
111         return 1;
112 }
113  
114
115
116 int smbc_init(smbc_get_auth_data_fn fn, int debug)
117 {
118         if (!smbc_compat_initialized) {
119                 statcont = smbc_new_context();
120                 if (!statcont) 
121                         return -1;
122
123                 statcont->debug = debug;
124                 statcont->callbacks.auth_fn = fn;
125                 
126                 if (!smbc_init_context(statcont)) {
127                         smbc_free_context(statcont, False);
128                         return -1;
129                 }
130
131                 smbc_compat_initialized = 1;
132
133                 return 0;
134         }
135         return 0;
136 }
137
138
139 SMBCCTX *smbc_set_context(SMBCCTX * context)
140 {
141         SMBCCTX *old_context = statcont;
142
143         if (context) {
144                 /* Save provided context.  It must have been initialized! */
145                 statcont = context;
146
147                 /* You'd better know what you're doing.  We won't help you. */
148                 smbc_compat_initialized = 1;
149         }
150         
151         return old_context;
152 }
153
154
155 int smbc_open(const char *furl, int flags, mode_t mode)
156 {
157         SMBCFILE * file;
158         int fd;
159
160         file = statcont->open(statcont, furl, flags, mode);
161         if (!file)
162                 return -1;
163
164         fd = add_fd(file);
165         if (fd == -1) 
166                 statcont->close(statcont, file);
167         return fd;
168 }
169
170
171 int smbc_creat(const char *furl, mode_t mode)
172 {
173         SMBCFILE * file;
174         int fd;
175
176         file = statcont->creat(statcont, furl, mode);
177         if (!file)
178                 return -1;
179
180         fd = add_fd(file);
181         if (fd == -1) {
182                 /* Hmm... should we delete the file too ? I guess we could try */
183                 statcont->close(statcont, file);
184                 statcont->unlink(statcont, furl);
185         }
186         return fd;
187 }
188
189
190 ssize_t smbc_read(int fd, void *buf, size_t bufsize)
191 {
192         SMBCFILE * file = find_fd(fd);
193         return statcont->read(statcont, file, buf, bufsize);
194 }
195
196 ssize_t smbc_write(int fd, void *buf, size_t bufsize)
197 {
198         SMBCFILE * file = find_fd(fd);
199         return statcont->write(statcont, file, buf, bufsize);
200 }
201
202 off_t smbc_lseek(int fd, off_t offset, int whence)
203 {
204         SMBCFILE * file = find_fd(fd);
205         return statcont->lseek(statcont, file, offset, whence);
206 }
207
208 int smbc_close(int fd)
209 {
210         SMBCFILE * file = find_fd(fd);
211         del_fd(fd);
212         return statcont->close(statcont, file);
213 }
214
215 int smbc_unlink(const char *fname)
216 {
217         return statcont->unlink(statcont, fname);
218 }
219
220 int smbc_rename(const char *ourl, const char *nurl)
221 {
222         return statcont->rename(statcont, ourl, statcont, nurl);
223 }
224
225 int smbc_opendir(const char *durl)
226 {
227         SMBCFILE * file;
228         int fd;
229
230         file = statcont->opendir(statcont, durl);
231         if (!file)
232                 return -1;
233
234         fd = add_fd(file);
235         if (fd == -1) 
236                 statcont->closedir(statcont, file);
237
238         return fd;
239 }
240
241 int smbc_closedir(int dh) 
242 {
243         SMBCFILE * file = find_fd(dh);
244         del_fd(dh);
245         return statcont->closedir(statcont, file);
246 }
247
248 int smbc_getdents(unsigned int dh, struct smbc_dirent *dirp, int count)
249 {
250         SMBCFILE * file = find_fd(dh);
251         return statcont->getdents(statcont, file,dirp, count);
252 }
253
254 struct smbc_dirent* smbc_readdir(unsigned int dh)
255 {
256         SMBCFILE * file = find_fd(dh);
257         return statcont->readdir(statcont, file);
258 }
259
260 off_t smbc_telldir(int dh)
261 {
262         SMBCFILE * file = find_fd(dh);
263         return statcont->telldir(statcont, file);
264 }
265
266 int smbc_lseekdir(int fd, off_t offset)
267 {
268         SMBCFILE * file = find_fd(fd);
269         return statcont->lseekdir(statcont, file, offset);
270 }
271
272 int smbc_mkdir(const char *durl, mode_t mode)
273 {
274         return statcont->mkdir(statcont, durl, mode);
275 }
276
277 int smbc_rmdir(const char *durl)
278 {
279         return statcont->rmdir(statcont, durl);
280 }
281
282 int smbc_stat(const char *url, struct stat *st)
283 {
284         return statcont->stat(statcont, url, st);
285 }
286
287 int smbc_fstat(int fd, struct stat *st)
288 {
289         SMBCFILE * file = find_fd(fd);
290         return statcont->fstat(statcont, file, st);
291 }
292
293 int smbc_chmod(const char *url, mode_t mode)
294 {
295         return statcont->chmod(statcont, url, mode);
296 }
297
298 int smbc_utimes(const char *fname, struct timeval *tbuf)
299 {
300         return statcont->utimes(statcont, fname, tbuf);
301 }
302
303 #ifdef HAVE_UTIME_H
304 int smbc_utime(const char *fname, struct utimbuf *utbuf)
305 {
306         struct timeval tv;
307
308         if (utbuf == NULL)
309                 return statcont->utimes(statcont, fname, NULL);
310
311         tv.tv_sec = utbuf->modtime;
312         tv.tv_usec = 0;
313         return statcont->utimes(statcont, fname, &tv);
314 }
315 #endif
316
317 int smbc_setxattr(const char *fname,
318                   const char *name,
319                   const void *value,
320                   size_t size,
321                   int flags)
322 {
323         return statcont->setxattr(statcont, fname, name, value, size, flags);
324 }
325
326 int smbc_lsetxattr(const char *fname,
327                    const char *name,
328                    const void *value,
329                    size_t size,
330                    int flags)
331 {
332         return statcont->setxattr(statcont, fname, name, value, size, flags);
333 }
334
335 int smbc_fsetxattr(int fd,
336                    const char *name,
337                    const void *value,
338                    size_t size,
339                    int flags)
340 {
341         SMBCFILE * file = find_fd(fd);
342         return statcont->setxattr(statcont, file->fname,
343                                   name, value, size, flags);
344 }
345
346 int smbc_getxattr(const char *fname,
347                   const char *name,
348                   const void *value,
349                   size_t size)
350 {
351         return statcont->getxattr(statcont, fname, name, value, size);
352 }
353
354 int smbc_lgetxattr(const char *fname,
355                    const char *name,
356                    const void *value,
357                    size_t size)
358 {
359         return statcont->getxattr(statcont, fname, name, value, size);
360 }
361
362 int smbc_fgetxattr(int fd,
363                    const char *name,
364                    const void *value,
365                    size_t size)
366 {
367         SMBCFILE * file = find_fd(fd);
368         return statcont->getxattr(statcont, file->fname, name, value, size);
369 }
370
371 int smbc_removexattr(const char *fname,
372                      const char *name)
373 {
374         return statcont->removexattr(statcont, fname, name);
375 }
376
377 int smbc_lremovexattr(const char *fname,
378                       const char *name)
379 {
380         return statcont->removexattr(statcont, fname, name);
381 }
382
383 int smbc_fremovexattr(int fd,
384                       const char *name)
385 {
386         SMBCFILE * file = find_fd(fd);
387         return statcont->removexattr(statcont, file->fname, name);
388 }
389
390 int smbc_listxattr(const char *fname,
391                    char *list,
392                    size_t size)
393 {
394         return statcont->listxattr(statcont, fname, list, size);
395 }
396
397 int smbc_llistxattr(const char *fname,
398                     char *list,
399                     size_t size)
400 {
401         return statcont->listxattr(statcont, fname, list, size);
402 }
403
404 int smbc_flistxattr(int fd,
405                     char *list,
406                     size_t size)
407 {
408         SMBCFILE * file = find_fd(fd);
409         return statcont->listxattr(statcont, file->fname, list, size);
410 }
411
412 int smbc_print_file(const char *fname, const char *printq)
413 {
414         return statcont->print_file(statcont, fname, statcont, printq);
415 }
416
417 int smbc_open_print_job(const char *fname)
418 {
419         SMBCFILE * file = statcont->open_print_job(statcont, fname);
420         if (!file) return -1;
421         return (int) file;
422 }
423
424 int smbc_list_print_jobs(const char *purl, smbc_list_print_job_fn fn)
425 {
426         return statcont->list_print_jobs(statcont, purl, fn);
427 }
428
429 int smbc_unlink_print_job(const char *purl, int id)
430 {
431         return statcont->unlink_print_job(statcont, purl, id);
432 }
433
434