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         } else {
  63                 /*
  64                  * None were available, so allocate one.  Keep the number of
  65                  * file descriptors determinate.  This allows the application
  66                  * to allocate bitmaps or mapping of file descriptors based on
  67                  * a known maximum number of file descriptors that will ever
  68                  * be returned.
  69                  */
  70                 if (smbc_compat_nextfd >= FD_SETSIZE) {
  71                         errno = EMFILE;
  72                         return -1;
  73                 }
  74
  75                 f = SMB_MALLOC_P(struct smbc_compat_fdlist);
  76                 if (!f) {
  77                         errno = ENOMEM;
  78                         return -1;
  79                 }
  80
  81                 f->fd = SMBC_BASE_FD + smbc_compat_nextfd++;
  82         }
  83
  84         f->file = file;
  85         DLIST_ADD(smbc_compat_fd_in_use, f);
  86
  87         return f->fd;
  88 }
  89
  90
  91
  92 /* Delete an fd, returns 0 on success */
  93 static int
  94 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
 117 smbc_init(smbc_get_auth_data_fn fn,
 118           int debug)
 119 {
 120         if (!smbc_compat_initialized) {
 121                 statcont = smbc_new_context();
 122                 if (!statcont)
 123                         return -1;
 124
 125                 smbc_setDebug(statcont, debug);
 126                 smbc_setFunctionAuthData(statcont, fn);
 127
 128                 if (!smbc_init_context(statcont)) {
 129                         smbc_free_context(statcont, False);
 130                         return -1;
 131                 }
 132
 133                 smbc_compat_initialized = 1;
 134
 135                 return 0;
 136         }
 137         return 0;
 138 }
 139
 140
 141 SMBCCTX *
 142 smbc_set_context(SMBCCTX * context)
 143 {
 144         SMBCCTX *old_context = statcont;
 145
 146         if (context) {
 147                 /* Save provided context.  It must have been initialized! */
 148                 statcont = context;
 149
 150                 /* You'd better know what you're doing.  We won't help you. */
 151                 smbc_compat_initialized = 1;
 152         }
 153
 154         return old_context;
 155 }
 156
 157
 158 int
 159 smbc_open(const char *furl,
 160           int flags,
 161           mode_t mode)
 162 {
 163         SMBCFILE * file;
 164         int fd;
 165
 166         file = smbc_getFunctionOpen(statcont)(statcont, furl, flags, mode);
 167         if (!file)
 168                 return -1;
 169
 170         fd = add_fd(file);
 171         if (fd == -1)
 172                 smbc_getFunctionClose(statcont)(statcont, file);
 173         return fd;
 174 }
 175
 176
 177 int
 178 smbc_creat(const char *furl,
 179            mode_t mode)
 180 {
 181         SMBCFILE * file;
 182         int fd;
 183
 184         file = smbc_getFunctionCreat(statcont)(statcont, furl, mode);
 185         if (!file)
 186                 return -1;
 187
 188         fd = add_fd(file);
 189         if (fd == -1) {
 190                 /* Hmm... should we delete the file too ? I guess we could try */
 191                 smbc_getFunctionClose(statcont)(statcont, file);
 192                 smbc_getFunctionUnlink(statcont)(statcont, furl);
 193         }
 194         return fd;
 195 }
 196
 197
 198 ssize_t
 199 smbc_read(int fd,
 200           void *buf,
 201           size_t bufsize)
 202 {
 203         SMBCFILE * file = find_fd(fd);
 204         return smbc_getFunctionRead(statcont)(statcont, file, buf, bufsize);
 205 }
 206
 207 ssize_t
 208 smbc_write(int fd,
 209            const void *buf,
 210            size_t bufsize)
 211 {
 212         SMBCFILE * file = find_fd(fd);
 213         return smbc_getFunctionWrite(statcont)(statcont, file, buf, bufsize);
 214 }
 215
 216 off_t
 217 smbc_lseek(int fd,
 218            off_t offset,
 219            int whence)
 220 {
 221         SMBCFILE * file = find_fd(fd);
 222         return smbc_getFunctionLseek(statcont)(statcont, file, offset, whence);
 223 }
 224
 225 int
 226 smbc_close(int fd)
 227 {
 228         SMBCFILE * file = find_fd(fd);
 229         del_fd(fd);
 230         return smbc_getFunctionClose(statcont)(statcont, file);
 231 }
 232
 233 int
 234 smbc_unlink(const char *fname)
 235 {
 236         return smbc_getFunctionUnlink(statcont)(statcont, fname);
 237 }
 238
 239 int
 240 smbc_rename(const char *ourl,
 241             const char *nurl)
 242 {
 243         return smbc_getFunctionRename(statcont)(statcont, ourl,
 244                                                 statcont, nurl);
 245 }
 246
 247 int
 248 smbc_opendir(const char *durl)
 249 {
 250         SMBCFILE * file;
 251         int fd;
 252
 253         file = smbc_getFunctionOpendir(statcont)(statcont, durl);
 254         if (!file)
 255                 return -1;
 256
 257         fd = add_fd(file);
 258         if (fd == -1)
 259                 smbc_getFunctionClosedir(statcont)(statcont, file);
 260
 261         return fd;
 262 }
 263
 264 int
 265 smbc_closedir(int dh)
 266 {
 267         SMBCFILE * file = find_fd(dh);
 268         del_fd(dh);
 269         return smbc_getFunctionClosedir(statcont)(statcont, file);
 270 }
 271
 272 int
 273 smbc_getdents(unsigned int dh,
 274               struct smbc_dirent *dirp,
 275               int count)
 276 {
 277         SMBCFILE * file = find_fd(dh);
 278         return smbc_getFunctionGetdents(statcont)(statcont, file, dirp, count);
 279 }
 280
 281 struct smbc_dirent *
 282 smbc_readdir(unsigned int dh)
 283 {
 284         SMBCFILE * file = find_fd(dh);
 285         return smbc_getFunctionReaddir(statcont)(statcont, file);
 286 }
 287
 288 off_t
 289 smbc_telldir(int dh)
 290 {
 291         SMBCFILE * file = find_fd(dh);
 292         return smbc_getFunctionTelldir(statcont)(statcont, file);
 293 }
 294
 295 int
 296 smbc_lseekdir(int fd,
 297               off_t offset)
 298 {
 299         SMBCFILE * file = find_fd(fd);
 300         return smbc_getFunctionLseekdir(statcont)(statcont, file, offset);
 301 }
 302
 303 int
 304 smbc_mkdir(const char *durl,
 305            mode_t mode)
 306 {
 307         return smbc_getFunctionMkdir(statcont)(statcont, durl, mode);
 308 }
 309
 310 int
 311 smbc_rmdir(const char *durl)
 312 {
 313         return smbc_getFunctionRmdir(statcont)(statcont, durl);
 314 }
 315
 316 int
 317 smbc_notify(int dh, smbc_bool recursive, uint32_t completion_filter,
 318             unsigned callback_timeout_ms,
 319             smbc_notify_callback_fn cb, void *private_data)
 320 {
 321         SMBCFILE *dir = find_fd(dh);
 322         return smbc_getFunctionNotify(statcont)(
 323                 statcont, dir, recursive, completion_filter,
 324                 callback_timeout_ms, cb, private_data);
 325 }
 326
 327 int
 328 smbc_stat(const char *url,
 329           struct stat *st)
 330 {
 331         return smbc_getFunctionStat(statcont)(statcont, url, st);
 332 }
 333
 334 int
 335 smbc_fstat(int fd,
 336            struct stat *st)
 337 {
 338         SMBCFILE * file = find_fd(fd);
 339         return smbc_getFunctionFstat(statcont)(statcont, file, st);
 340 }
 341
 342 int
 343 smbc_statvfs(char *path,
 344              struct statvfs *st)
 345 {
 346         return smbc_getFunctionStatVFS(statcont)(statcont, path, st);
 347 }
 348
 349 int
 350 smbc_fstatvfs(int fd,
 351               struct statvfs *st)
 352 {
 353         SMBCFILE * file = find_fd(fd);
 354         return smbc_getFunctionFstatVFS(statcont)(statcont, file, st);
 355 }
 356
 357 int
 358 smbc_ftruncate(int fd,
 359                off_t size)
 360 {
 361         SMBCFILE * file = find_fd(fd);
 362         return smbc_getFunctionFtruncate(statcont)(statcont, file, size);
 363 }
 364
 365 int
 366 smbc_chmod(const char *url,
 367            mode_t mode)
 368 {
 369         return smbc_getFunctionChmod(statcont)(statcont, url, mode);
 370 }
 371
 372 int
 373 smbc_utimes(const char *fname,
 374             struct timeval *tbuf)
 375 {
 376         return smbc_getFunctionUtimes(statcont)(statcont, fname, tbuf);
 377 }
 378
 379 #ifdef HAVE_UTIME_H
 380 int
 381 smbc_utime(const char *fname,
 382            struct utimbuf *utbuf)
 383 {
 384         struct timeval tv[2];
 385
 386         if (utbuf == NULL)
 387                 return smbc_getFunctionUtimes(statcont)(statcont, fname, NULL);
 388
 389         tv[0].tv_sec = utbuf->actime;
 390         tv[1].tv_sec = utbuf->modtime;
 391         tv[0].tv_usec = tv[1].tv_usec = 0;
 392
 393         return smbc_getFunctionUtimes(statcont)(statcont, fname, tv);
 394 }
 395 #endif
 396
 397 int
 398 smbc_setxattr(const char *fname,
 399               const char *name,
 400               const void *value,
 401               size_t size,
 402               int flags)
 403 {
 404         return smbc_getFunctionSetxattr(statcont)(statcont,
 405                                                   fname, name,
 406                                                   value, size, flags);
 407 }
 408
 409 int
 410 smbc_lsetxattr(const char *fname,
 411                const char *name,
 412                const void *value,
 413                size_t size,
 414                int flags)
 415 {
 416         return smbc_getFunctionSetxattr(statcont)(statcont,
 417                                                   fname, name,
 418                                                   value, size, flags);
 419 }
 420
 421 int
 422 smbc_fsetxattr(int fd,
 423                const char *name,
 424                const void *value,
 425                size_t size,
 426                int flags)
 427 {
 428         SMBCFILE * file = find_fd(fd);
 429         if (file == NULL) {
 430                 errno = EBADF;
 431                 return -1;
 432         }
 433         return smbc_getFunctionSetxattr(statcont)(statcont,
 434                                                   file->fname, name,
 435                                                   value, size, flags);
 436 }
 437
 438 int
 439 smbc_getxattr(const char *fname,
 440               const char *name,
 441               const void *value,
 442               size_t size)
 443 {
 444         return smbc_getFunctionGetxattr(statcont)(statcont,
 445                                                   fname, name,
 446                                                   value, size);
 447 }
 448
 449 int
 450 smbc_lgetxattr(const char *fname,
 451                const char *name,
 452                const void *value,
 453                size_t size)
 454 {
 455         return smbc_getFunctionGetxattr(statcont)(statcont,
 456                                                   fname, name,
 457                                                   value, size);
 458 }
 459
 460 int
 461 smbc_fgetxattr(int fd,
 462                const char *name,
 463                const void *value,
 464                size_t size)
 465 {
 466         SMBCFILE * file = find_fd(fd);
 467         if (file == NULL) {
 468                 errno = EBADF;
 469                 return -1;
 470         }
 471         return smbc_getFunctionGetxattr(statcont)(statcont,
 472                                                   file->fname, name,
 473                                                   value, size);
 474 }
 475
 476 int
 477 smbc_removexattr(const char *fname,
 478                  const char *name)
 479 {
 480         return smbc_getFunctionRemovexattr(statcont)(statcont, fname, name);
 481 }
 482
 483 int
 484 smbc_lremovexattr(const char *fname,
 485                   const char *name)
 486 {
 487         return smbc_getFunctionRemovexattr(statcont)(statcont, fname, name);
 488 }
 489
 490 int
 491 smbc_fremovexattr(int fd,
 492                   const char *name)
 493 {
 494         SMBCFILE * file = find_fd(fd);
 495         if (file == NULL) {
 496                 errno = EBADF;
 497                 return -1;
 498         }
 499         return smbc_getFunctionRemovexattr(statcont)(statcont,
 500                                                      file->fname, name);
 501 }
 502
 503 int
 504 smbc_listxattr(const char *fname,
 505                char *list,
 506                size_t size)
 507 {
 508         return smbc_getFunctionListxattr(statcont)(statcont,
 509                                                    fname, list, size);
 510 }
 511
 512 int
 513 smbc_llistxattr(const char *fname,
 514                 char *list,
 515                 size_t size)
 516 {
 517         return smbc_getFunctionListxattr(statcont)(statcont,
 518                                                    fname, list, size);
 519 }
 520
 521 int
 522 smbc_flistxattr(int fd,
 523                 char *list,
 524                 size_t size)
 525 {
 526         SMBCFILE * file = find_fd(fd);
 527         if (file == NULL) {
 528                 errno = EBADF;
 529                 return -1;
 530         }
 531         return smbc_getFunctionListxattr(statcont)(statcont,
 532                                                    file->fname, list, size);
 533 }
 534
 535 int
 536 smbc_print_file(const char *fname,
 537                 const char *printq)
 538 {
 539         return smbc_getFunctionPrintFile(statcont)(statcont, fname,
 540                                                    statcont, printq);
 541 }
 542
 543 int
 544 smbc_open_print_job(const char *fname)
 545 {
 546         SMBCFILE * file;
 547
 548         file = smbc_getFunctionOpenPrintJob(statcont)(statcont, fname);
 549         if (!file) return -1;
 550         return file->cli_fd;
 551 }
 552
 553 int
 554 smbc_list_print_jobs(const char *purl,
 555                      smbc_list_print_job_fn fn)
 556 {
 557         return smbc_getFunctionListPrintJobs(statcont)(statcont, purl, fn);
 558 }
 559
 560 int
 561 smbc_unlink_print_job(const char *purl,
 562                       int id)
 563 {
 564         return smbc_getFunctionUnlinkPrintJob(statcont)(statcont, purl, id);
 565 }
 566
 567