← Back to branch summary

~zulcss/samba/server-dailies-3.4

« back to all changes in this revision

Viewing changes to source3/libsmb/libsmb_compat.c

  • Committer: Chuck Short
  • Date: 2010-09-28 20:38:39 UTC
  • Revision ID: zulcss@ubuntu.com-20100928203839-pgjulytsi9ue63x1
Initial version

Show diffs side-by-side

added added

removed removed

Lines of Context:
source3/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, 2008
 
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 3 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, see <http://www.gnu.org/licenses/>.
 
22
*/
 
23
 
 
24
 
 
25
#include "includes.h"
 
26
#include "libsmb_internal.h"
 
27
 
 
28
struct smbc_compat_fdlist {
 
29
        SMBCFILE * file;
 
30
        int fd;
 
31
        struct smbc_compat_fdlist *next, *prev;
 
32
};
 
33
 
 
34
static SMBCCTX * statcont = NULL;
 
35
static int smbc_compat_initialized = 0;
 
36
static int smbc_compat_nextfd = 0;
 
37
static struct smbc_compat_fdlist * smbc_compat_fd_in_use = NULL;
 
38
static struct smbc_compat_fdlist * smbc_compat_fd_avail = NULL;
 
39
 
 
40
/* Find an fd and return the SMBCFILE * or NULL on failure */
 
41
static SMBCFILE *
 
42
find_fd(int fd)
 
43
{
 
44
        struct smbc_compat_fdlist * f = smbc_compat_fd_in_use;
 
45
        while (f) {
 
46
                if (f->fd == fd) 
 
47
                        return f->file;
 
48
                f = f->next;
 
49
        }
 
50
        return NULL;
 
51
}
 
52
 
 
53
/* Add an fd, returns 0 on success, -1 on error with errno set */
 
54
static int
 
55
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 = SMB_MALLOC_P(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
 
95
del_fd(int fd)
 
96
{
 
97
        struct smbc_compat_fdlist * f = smbc_compat_fd_in_use;
 
98
        
 
99
        while (f) {
 
100
                if (f->fd == fd) 
 
101
                        break;
 
102
                f = f->next;
 
103
        }
 
104
        
 
105
        if (f) {
 
106
                /* found */
 
107
                DLIST_REMOVE(smbc_compat_fd_in_use, f);
 
108
                f->file = NULL;
 
109
                DLIST_ADD(smbc_compat_fd_avail, f);
 
110
                return 0;
 
111
        }
 
112
        return 1;
 
113
}
 
114
 
 
115
 
 
116
 
 
117
int
 
118
smbc_init(smbc_get_auth_data_fn fn,
 
119
          int debug)
 
120
{
 
121
        if (!smbc_compat_initialized) {
 
122
                statcont = smbc_new_context();
 
123
                if (!statcont) 
 
124
                        return -1;
 
125
                
 
126
                smbc_setDebug(statcont, debug);
 
127
                smbc_setFunctionAuthData(statcont, fn);
 
128
                
 
129
                if (!smbc_init_context(statcont)) {
 
130
                        smbc_free_context(statcont, False);
 
131
                        return -1;
 
132
                }
 
133
                
 
134
                smbc_compat_initialized = 1;
 
135
                
 
136
                return 0;
 
137
        }
 
138
        return 0;
 
139
}
 
140
 
 
141
 
 
142
SMBCCTX *
 
143
smbc_set_context(SMBCCTX * context)
 
144
{
 
145
        SMBCCTX *old_context = statcont;
 
146
        
 
147
        if (context) {
 
148
                /* Save provided context.  It must have been initialized! */
 
149
                statcont = context;
 
150
                
 
151
                /* You'd better know what you're doing.  We won't help you. */
 
152
                smbc_compat_initialized = 1;
 
153
        }
 
154
        
 
155
        return old_context;
 
156
}
 
157
 
 
158
 
 
159
int
 
160
smbc_open(const char *furl,
 
161
          int flags,
 
162
          mode_t mode)
 
163
{
 
164
        SMBCFILE * file;
 
165
        int fd;
 
166
        
 
167
        file = smbc_getFunctionOpen(statcont)(statcont, furl, flags, mode);
 
168
        if (!file)
 
169
                return -1;
 
170
        
 
171
        fd = add_fd(file);
 
172
        if (fd == -1) 
 
173
                smbc_getFunctionClose(statcont)(statcont, file);
 
174
        return fd;
 
175
}
 
176
 
 
177
 
 
178
int
 
179
smbc_creat(const char *furl,
 
180
           mode_t mode)
 
181
{
 
182
        SMBCFILE * file;
 
183
        int fd;
 
184
        
 
185
        file = smbc_getFunctionCreat(statcont)(statcont, furl, mode);
 
186
        if (!file)
 
187
                return -1;
 
188
        
 
189
        fd = add_fd(file);
 
190
        if (fd == -1) {
 
191
                /* Hmm... should we delete the file too ? I guess we could try */
 
192
                smbc_getFunctionClose(statcont)(statcont, file);
 
193
                smbc_getFunctionUnlink(statcont)(statcont, furl);
 
194
        }
 
195
        return fd;
 
196
}
 
197
 
 
198
 
 
199
ssize_t
 
200
smbc_read(int fd,
 
201
          void *buf,
 
202
          size_t bufsize)
 
203
{
 
204
        SMBCFILE * file = find_fd(fd);
 
205
        return smbc_getFunctionRead(statcont)(statcont, file, buf, bufsize);
 
206
}
 
207
 
 
208
ssize_t
 
209
smbc_write(int fd,
 
210
           const void *buf,
 
211
           size_t bufsize)
 
212
{
 
213
        SMBCFILE * file = find_fd(fd);
 
214
        return smbc_getFunctionWrite(statcont)(statcont, file, buf, bufsize);
 
215
}
 
216
 
 
217
off_t
 
218
smbc_lseek(int fd,
 
219
           off_t offset,
 
220
           int whence)
 
221
{
 
222
        SMBCFILE * file = find_fd(fd);
 
223
        return smbc_getFunctionLseek(statcont)(statcont, file, offset, whence);
 
224
}
 
225
 
 
226
int
 
227
smbc_close(int fd)
 
228
{
 
229
        SMBCFILE * file = find_fd(fd);
 
230
        del_fd(fd);
 
231
        return smbc_getFunctionClose(statcont)(statcont, file);
 
232
}
 
233
 
 
234
int
 
235
smbc_unlink(const char *fname)
 
236
{
 
237
        return smbc_getFunctionUnlink(statcont)(statcont, fname);
 
238
}
 
239
 
 
240
int
 
241
smbc_rename(const char *ourl,
 
242
            const char *nurl)
 
243
{
 
244
        return smbc_getFunctionRename(statcont)(statcont, ourl,
 
245
                                                statcont, nurl);
 
246
}
 
247
 
 
248
int
 
249
smbc_opendir(const char *durl)
 
250
{
 
251
        SMBCFILE * file;
 
252
        int fd;
 
253
        
 
254
        file = smbc_getFunctionOpendir(statcont)(statcont, durl);
 
255
        if (!file)
 
256
                return -1;
 
257
        
 
258
        fd = add_fd(file);
 
259
        if (fd == -1) 
 
260
                smbc_getFunctionClosedir(statcont)(statcont, file);
 
261
        
 
262
        return fd;
 
263
}
 
264
 
 
265
int
 
266
smbc_closedir(int dh) 
 
267
{
 
268
        SMBCFILE * file = find_fd(dh);
 
269
        del_fd(dh);
 
270
        return smbc_getFunctionClosedir(statcont)(statcont, file);
 
271
}
 
272
 
 
273
int
 
274
smbc_getdents(unsigned int dh,
 
275
              struct smbc_dirent *dirp,
 
276
              int count)
 
277
{
 
278
        SMBCFILE * file = find_fd(dh);
 
279
        return smbc_getFunctionGetdents(statcont)(statcont, file, dirp, count);
 
280
}
 
281
 
 
282
struct smbc_dirent *
 
283
smbc_readdir(unsigned int dh)
 
284
{
 
285
        SMBCFILE * file = find_fd(dh);
 
286
        return smbc_getFunctionReaddir(statcont)(statcont, file);
 
287
}
 
288
 
 
289
off_t
 
290
smbc_telldir(int dh)
 
291
{
 
292
        SMBCFILE * file = find_fd(dh);
 
293
        return smbc_getFunctionTelldir(statcont)(statcont, file);
 
294
}
 
295
 
 
296
int
 
297
smbc_lseekdir(int fd,
 
298
              off_t offset)
 
299
{
 
300
        SMBCFILE * file = find_fd(fd);
 
301
        return smbc_getFunctionLseekdir(statcont)(statcont, file, offset);
 
302
}
 
303
 
 
304
int
 
305
smbc_mkdir(const char *durl,
 
306
           mode_t mode)
 
307
{
 
308
        return smbc_getFunctionMkdir(statcont)(statcont, durl, mode);
 
309
}
 
310
 
 
311
int
 
312
smbc_rmdir(const char *durl)
 
313
{
 
314
        return smbc_getFunctionRmdir(statcont)(statcont, durl);
 
315
}
 
316
 
 
317
int
 
318
smbc_stat(const char *url,
 
319
          struct stat *st)
 
320
{
 
321
        return smbc_getFunctionStat(statcont)(statcont, url, st);
 
322
}
 
323
 
 
324
int
 
325
smbc_fstat(int fd,
 
326
           struct stat *st)
 
327
{
 
328
        SMBCFILE * file = find_fd(fd);
 
329
        return smbc_getFunctionFstat(statcont)(statcont, file, st);
 
330
}
 
331
 
 
332
int
 
333
smbc_statvfs(char *path,
 
334
             struct statvfs *st)
 
335
{
 
336
        return smbc_getFunctionStatVFS(statcont)(statcont, path, st);
 
337
}
 
338
 
 
339
int
 
340
smbc_fstatvfs(int fd,
 
341
              struct statvfs *st)
 
342
{
 
343
        SMBCFILE * file = find_fd(fd);
 
344
        return smbc_getFunctionFstatVFS(statcont)(statcont, file, st);
 
345
}
 
346
 
 
347
int
 
348
smbc_ftruncate(int fd,
 
349
               off_t size)
 
350
{
 
351
        SMBCFILE * file = find_fd(fd);
 
352
        return smbc_getFunctionFtruncate(statcont)(statcont, file, size);
 
353
}
 
354
 
 
355
int
 
356
smbc_chmod(const char *url,
 
357
           mode_t mode)
 
358
{
 
359
        return smbc_getFunctionChmod(statcont)(statcont, url, mode);
 
360
}
 
361
 
 
362
int
 
363
smbc_utimes(const char *fname,
 
364
            struct timeval *tbuf)
 
365
{
 
366
        return smbc_getFunctionUtimes(statcont)(statcont, fname, tbuf);
 
367
}
 
368
 
 
369
#ifdef HAVE_UTIME_H
 
370
int
 
371
smbc_utime(const char *fname,
 
372
           struct utimbuf *utbuf)
 
373
{
 
374
        struct timeval tv[2];
 
375
        
 
376
        if (utbuf == NULL)
 
377
                return smbc_getFunctionUtimes(statcont)(statcont, fname, NULL);
 
378
        
 
379
        tv[0].tv_sec = utbuf->actime;
 
380
        tv[1].tv_sec = utbuf->modtime;
 
381
        tv[0].tv_usec = tv[1].tv_usec = 0;
 
382
        
 
383
        return smbc_getFunctionUtimes(statcont)(statcont, fname, tv);
 
384
}
 
385
#endif
 
386
 
 
387
int
 
388
smbc_setxattr(const char *fname,
 
389
              const char *name,
 
390
              const void *value,
 
391
              size_t size,
 
392
              int flags)
 
393
{
 
394
        return smbc_getFunctionSetxattr(statcont)(statcont,
 
395
                                                  fname, name,
 
396
                                                  value, size, flags);
 
397
}
 
398
 
 
399
int
 
400
smbc_lsetxattr(const char *fname,
 
401
               const char *name,
 
402
               const void *value,
 
403
               size_t size,
 
404
               int flags)
 
405
{
 
406
        return smbc_getFunctionSetxattr(statcont)(statcont,
 
407
                                                  fname, name,
 
408
                                                  value, size, flags);
 
409
}
 
410
 
 
411
int
 
412
smbc_fsetxattr(int fd,
 
413
               const char *name,
 
414
               const void *value,
 
415
               size_t size,
 
416
               int flags)
 
417
{
 
418
        SMBCFILE * file = find_fd(fd);
 
419
        if (file == NULL) {
 
420
                errno = EBADF;
 
421
                return -1;
 
422
        }
 
423
        return smbc_getFunctionSetxattr(statcont)(statcont,
 
424
                                                  file->fname, name,
 
425
                                                  value, size, flags);
 
426
}
 
427
 
 
428
int
 
429
smbc_getxattr(const char *fname,
 
430
              const char *name,
 
431
              const void *value,
 
432
              size_t size)
 
433
{
 
434
        return smbc_getFunctionGetxattr(statcont)(statcont,
 
435
                                                  fname, name,
 
436
                                                  value, size);
 
437
}
 
438
 
 
439
int
 
440
smbc_lgetxattr(const char *fname,
 
441
               const char *name,
 
442
               const void *value,
 
443
               size_t size)
 
444
{
 
445
        return smbc_getFunctionGetxattr(statcont)(statcont,
 
446
                                                  fname, name,
 
447
                                                  value, size);
 
448
}
 
449
 
 
450
int
 
451
smbc_fgetxattr(int fd,
 
452
               const char *name,
 
453
               const void *value,
 
454
               size_t size)
 
455
{
 
456
        SMBCFILE * file = find_fd(fd);
 
457
        if (file == NULL) {
 
458
                errno = EBADF;
 
459
                return -1;
 
460
        }
 
461
        return smbc_getFunctionGetxattr(statcont)(statcont,
 
462
                                                  file->fname, name,
 
463
                                                  value, size);
 
464
}
 
465
 
 
466
int
 
467
smbc_removexattr(const char *fname,
 
468
                 const char *name)
 
469
{
 
470
        return smbc_getFunctionRemovexattr(statcont)(statcont, fname, name);
 
471
}
 
472
 
 
473
int
 
474
smbc_lremovexattr(const char *fname,
 
475
                  const char *name)
 
476
{
 
477
        return smbc_getFunctionRemovexattr(statcont)(statcont, fname, name);
 
478
}
 
479
 
 
480
int
 
481
smbc_fremovexattr(int fd,
 
482
                  const char *name)
 
483
{
 
484
        SMBCFILE * file = find_fd(fd);
 
485
        if (file == NULL) {
 
486
                errno = EBADF;
 
487
                return -1;
 
488
        }
 
489
        return smbc_getFunctionRemovexattr(statcont)(statcont,
 
490
                                                     file->fname, name);
 
491
}
 
492
 
 
493
int
 
494
smbc_listxattr(const char *fname,
 
495
               char *list,
 
496
               size_t size)
 
497
{
 
498
        return smbc_getFunctionListxattr(statcont)(statcont,
 
499
                                                   fname, list, size);
 
500
}
 
501
 
 
502
int
 
503
smbc_llistxattr(const char *fname,
 
504
                char *list,
 
505
                size_t size)
 
506
{
 
507
        return smbc_getFunctionListxattr(statcont)(statcont,
 
508
                                                   fname, list, size);
 
509
}
 
510
 
 
511
int
 
512
smbc_flistxattr(int fd,
 
513
                char *list,
 
514
                size_t size)
 
515
{
 
516
        SMBCFILE * file = find_fd(fd);
 
517
        if (file == NULL) {
 
518
                errno = EBADF;
 
519
                return -1;
 
520
        }
 
521
        return smbc_getFunctionListxattr(statcont)(statcont,
 
522
                                                   file->fname, list, size);
 
523
}
 
524
 
 
525
int
 
526
smbc_print_file(const char *fname,
 
527
                const char *printq)
 
528
{
 
529
        return smbc_getFunctionPrintFile(statcont)(statcont, fname,
 
530
                                                   statcont, printq);
 
531
}
 
532
 
 
533
int
 
534
smbc_open_print_job(const char *fname)
 
535
{
 
536
        SMBCFILE * file;
 
537
        
 
538
        file = smbc_getFunctionOpenPrintJob(statcont)(statcont, fname);
 
539
        if (!file) return -1;
 
540
        return file->cli_fd;
 
541
}
 
542
 
 
543
int
 
544
smbc_list_print_jobs(const char *purl,
 
545
                     smbc_list_print_job_fn fn)
 
546
{
 
547
        return smbc_getFunctionListPrintJobs(statcont)(statcont, purl, fn);
 
548
}
 
549
 
 
550
int
 
551
smbc_unlink_print_job(const char *purl,
 
552
                      int id)
 
553
{
 
554
        return smbc_getFunctionUnlinkPrintJob(statcont)(statcont, purl, id);
 
555
}
 
556
 
 
557