source/smbwrapper/smbw.c

   1 /*
   2    Unix SMB/Netbios implementation.
   3    Version 2.0
   4    SMB wrapper functions
   5    Copyright (C) Andrew Tridgell 1998
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20 */
  21
  22 #include "includes.h"
  23 #include "smbw.h"
  24 #include "wrapper.h"
  25
  26 static pstring smb_cwd;
  27
  28 struct smbw_server {
  29         struct smbw_server *next, *prev;
  30         struct cli_state cli;
  31         char *server_name;
  32         char *share_name;
  33 };
  34
  35 struct smbw_file {
  36         struct smbw_file *next, *prev;
  37         int cli_fd, fd;
  38         char *fname;
  39         off_t offset;
  40         struct smbw_server *srv;
  41 };
  42
  43 struct smbw_dir {
  44         struct smbw_dir *next, *prev;
  45         int fd;
  46         int offset, count, malloced;
  47         struct smbw_server *srv;
  48         struct file_info *list;
  49 };
  50
  51 static struct smbw_file *smbw_files;
  52 static struct smbw_dir *smbw_dirs;
  53 static struct smbw_server *smbw_srvs;
  54
  55 static struct bitmap *file_bmap;
  56 static pstring local_machine;
  57 extern int DEBUGLEVEL;
  58
  59 static int smbw_busy;
  60
  61 /*****************************************************
  62 initialise structures
  63 *******************************************************/
  64 void smbw_init(void)
  65 {
  66         extern BOOL in_client;
  67         static int initialised;
  68         static pstring servicesf = CONFIGFILE;
  69         extern FILE *dbf;
  70         char *p;
  71
  72         if (initialised) return;
  73         initialised = 1;
  74
  75         smbw_busy++;
  76
  77         DEBUGLEVEL = 0;
  78         setup_logging("smbw",True);
  79
  80         dbf = stderr;
  81
  82         if ((p=getenv("SMBW_LOGFILE"))) {
  83                 dbf = fopen(p, "a");
  84         }
  85
  86         file_bmap = bitmap_allocate(SMBW_MAX_OPEN);
  87         if (!file_bmap) {
  88                 exit(1);
  89         }
  90
  91         charset_initialise();
  92
  93         in_client = True;
  94
  95         if (!lp_load(servicesf,True,False,False)) {
  96                 exit(1);
  97         }
  98
  99         get_myname(local_machine,NULL);
 100
 101         if ((p=getenv("SMBW_DEBUG"))) {
 102                 DEBUGLEVEL = atoi(p);
 103         }
 104
 105         if ((p=getenv(SMBW_PWD_ENV))) {
 106                 pstrcpy(smb_cwd, p);
 107                 DEBUG(4,("Initial cwd from smb_cwd is %s\n", smb_cwd));
 108         } else {
 109                 sys_getwd(smb_cwd);
 110                 DEBUG(4,("Initial cwd from getwd is %s\n", smb_cwd));
 111         }
 112         smbw_busy--;
 113 }
 114
 115 /*****************************************************
 116 determine if a file descriptor is a smb one
 117 *******************************************************/
 118 BOOL smbw_fd(int fd)
 119 {
 120         if (smbw_busy) return False;
 121         return (fd >= SMBW_FD_OFFSET);
 122 }
 123
 124
 125 /*****************************************************
 126 remove redundent stuff from a filename
 127 *******************************************************/
 128 void clean_fname(char *name)
 129 {
 130         char *p, *p2;
 131         int l;
 132         int modified = 1;
 133
 134         if (!name) return;
 135
 136         while (modified) {
 137                 modified = 0;
 138
 139                 DEBUG(5,("cleaning %s\n", name));
 140
 141                 if ((p=strstr(name,"/./"))) {
 142                         modified = 1;
 143                         while (*p) {
 144                                 p[0] = p[2];
 145                                 p++;
 146                         }
 147                 }
 148
 149                 if ((p=strstr(name,"//"))) {
 150                         modified = 1;
 151                         while (*p) {
 152                                 p[0] = p[1];
 153                                 p++;
 154                         }
 155                 }
 156
 157                 if (strcmp(name,"/../")==0) {
 158                         modified = 1;
 159                         name[1] = 0;
 160                 }
 161
 162                 if ((p=strstr(name,"/../"))) {
 163                         modified = 1;
 164                         for (p2=(p>name?p-1:p);p2>name;p2--) {
 165                                 if (p2[0] == '/') break;
 166                         }
 167                         while (*p2) {
 168                                 p2[0] = p2[3];
 169                                 p2++;
 170                         }
 171                 }
 172
 173                 if (strcmp(name,"/..")==0) {
 174                         modified = 1;
 175                         name[1] = 0;
 176                 }
 177
 178                 l = strlen(name);
 179                 p = l>=3?(name+l-3):name;
 180                 if (strcmp(p,"/..")==0) {
 181                         modified = 1;
 182                         for (p2=p-1;p2>name;p2--) {
 183                                 if (p2[0] == '/') break;
 184                         }
 185                         if (p2==name) {
 186                                 p[0] = '/';
 187                                 p[1] = 0;
 188                         } else {
 189                                 p2[0] = 0;
 190                         }
 191                 }
 192
 193                 l = strlen(name);
 194                 p = l>=2?(name+l-2):name;
 195                 if (strcmp(p,"/.")==0) {
 196                         if (p == name) {
 197                                 p[1] = 0;
 198                         } else {
 199                                 p[0] = 0;
 200                         }
 201                 }
 202
 203                 if (strncmp(p=name,"./",2) == 0) {
 204                         modified = 1;
 205                         do {
 206                                 p[0] = p[2];
 207                         } while (*p++);
 208                 }
 209
 210                 l = strlen(p=name);
 211                 if (l > 1 && p[l-1] == '/') {
 212                         modified = 1;
 213                         p[l-1] = 0;
 214                 }
 215         }
 216 }
 217
 218
 219 /*****************************************************
 220 parse a smb path into its components.
 221 *******************************************************/
 222 char *smbw_parse_path(const char *fname, char *server, char *share, char *path)
 223 {
 224         static pstring s;
 225         char *p, *p2;
 226         int len;
 227
 228         *server = *share = *path = 0;
 229
 230         if (fname[0] == '/') {
 231                 pstrcpy(s, fname);
 232         } else {
 233                 slprintf(s,sizeof(s)-1, "%s/%s", smb_cwd, fname);
 234         }
 235         clean_fname(s);
 236
 237         DEBUG(5,("cleaned %s (fname=%s cwd=%s)\n",
 238                  s, fname, smb_cwd));
 239
 240         if (strncmp(s,SMBW_PREFIX,strlen(SMBW_PREFIX))) return s;
 241
 242         p = s + strlen(SMBW_PREFIX);
 243         p2 = strchr(p,'/');
 244
 245         if (p2) {
 246                 len = (int)(p2-p);
 247         } else {
 248                 len = strlen(p);
 249         }
 250
 251         len = MIN(len,sizeof(fstring)-1);
 252
 253         strncpy(server, p, len);
 254         server[len] = 0;
 255
 256         p = p2;
 257         if (!p) {
 258                 fstrcpy(share,"IPC$");
 259                 pstrcpy(path,"");
 260                 goto ok;
 261         }
 262
 263         p++;
 264         p2 = strchr(p,'/');
 265
 266         if (p2) {
 267                 len = (int)(p2-p);
 268         } else {
 269                 len = strlen(p);
 270         }
 271
 272         len = MIN(len,sizeof(fstring)-1);
 273
 274         strncpy(share, p, len);
 275         share[len] = 0;
 276
 277         p = p2;
 278         if (!p) {
 279                 pstrcpy(path,"\\");
 280                 goto ok;
 281         }
 282
 283         pstrcpy(path,p);
 284
 285         string_sub(path, "/", "\\");
 286
 287  ok:
 288         DEBUG(5,("parsed path name=%s cwd=%s [%s] [%s] [%s]\n",
 289                  fname, smb_cwd,
 290                  server, share, path));
 291
 292         return s;
 293 }
 294
 295 /*****************************************************
 296 determine if a path name (possibly relative) is in the
 297 smb name space
 298 *******************************************************/
 299 BOOL smbw_path(const char *path)
 300 {
 301         fstring server, share;
 302         pstring s;
 303         char *cwd;
 304         int l=strlen(SMBW_PREFIX)-1;
 305
 306         if (path[0] == '/' && strncmp(path,SMBW_PREFIX,l)) {
 307                 return False;
 308         }
 309
 310         if (smbw_busy) return False;
 311
 312         smbw_init();
 313
 314         DEBUG(3,("smbw_path(%s)\n", path));
 315
 316         cwd = smbw_parse_path(path, server, share, s);
 317
 318         if (strncmp(cwd,SMBW_PREFIX,l) == 0 &&
 319             (cwd[l] == '/' || cwd[l] == 0)) {
 320                 return True;
 321         }
 322
 323         return False;
 324 }
 325
 326 /*****************************************************
 327 return a unix errno from a SMB error pair
 328 *******************************************************/
 329 int smbw_errno(struct cli_state *c)
 330 {
 331         uint8 eclass;
 332         uint32 ecode;
 333         int ret;
 334
 335         ret = cli_error(c, &eclass, &ecode);
 336
 337         if (ret) {
 338                 DEBUG(3,("smbw_error %d %d (0x%x)\n",
 339                          (int)eclass, (int)ecode, (int)ecode));
 340         }
 341         return ret;
 342 }
 343
 344 /*****************************************************
 345 return a connection to a server (existing or new)
 346 *******************************************************/
 347 struct smbw_server *smbw_server(char *server, char *share)
 348 {
 349         struct smbw_server *srv=NULL;
 350         static struct cli_state c;
 351         char *username;
 352         char *password;
 353         char *workgroup;
 354         struct nmb_name called, calling;
 355
 356         username = getenv("SMBW_USER");
 357         if (!username) username = getenv("USER");
 358         if (!username) username = "guest";
 359
 360         workgroup = getenv("SMBW_WORKGROUP");
 361         if (!workgroup) workgroup = lp_workgroup();
 362
 363         password = getenv("SMBW_PASSWORD");
 364         if (!password) password = "";
 365
 366         /* try to use an existing connection */
 367         for (srv=smbw_srvs;srv;srv=srv->next) {
 368                 if (strcmp(server,srv->server_name)==0 &&
 369                     strcmp(share,srv->share_name)==0) return srv;
 370         }
 371
 372         if (server[0] == 0) {
 373                 errno = EPERM;
 374                 return NULL;
 375         }
 376
 377         /* have to open a new connection */
 378         if (!cli_initialise(&c) || !cli_connect(&c, server, NULL)) {
 379                 errno = ENOENT;
 380                 return NULL;
 381         }
 382
 383         make_nmb_name(&calling, local_machine, 0x0, "");
 384         make_nmb_name(&called , server, 0x20, "");
 385
 386         if (!cli_session_request(&c, &calling, &called)) {
 387                 cli_shutdown(&c);
 388                 errno = ENOENT;
 389                 return NULL;
 390         }
 391
 392         if (!cli_negprot(&c)) {
 393                 cli_shutdown(&c);
 394                 errno = ENOENT;
 395                 return NULL;
 396         }
 397
 398         if (!cli_session_setup(&c, username,
 399                                password, strlen(password),
 400                                password, strlen(password),
 401                                workgroup)) {
 402                 cli_shutdown(&c);
 403                 errno = EPERM;
 404                 return NULL;
 405         }
 406
 407         if (!cli_send_tconX(&c, share,
 408                             strstr(share,"IPC$")?"IPC":"A:",
 409                             password, strlen(password)+1)) {
 410                 errno = smbw_errno(&c);
 411                 cli_shutdown(&c);
 412                 return NULL;
 413         }
 414
 415         srv = (struct smbw_server *)malloc(sizeof(*srv));
 416         if (!srv) {
 417                 errno = ENOMEM;
 418                 goto failed;
 419         }
 420
 421         ZERO_STRUCTP(srv);
 422
 423         srv->cli = c;
 424
 425         srv->server_name = strdup(server);
 426         if (!srv->server_name) {
 427                 errno = ENOMEM;
 428                 goto failed;
 429         }
 430
 431         srv->share_name = strdup(share);
 432         if (!srv->share_name) {
 433                 errno = ENOMEM;
 434                 goto failed;
 435         }
 436
 437         /* some programs play with file descriptors fairly intimately. We
 438            try to get out of the way by duping to a high fd number */
 439         if (fcntl(SMBW_CLI_FD + srv->cli.fd, F_GETFD) && errno == EBADF) {
 440                 if (dup2(srv->cli.fd,SMBW_CLI_FD+srv->cli.fd) ==
 441                     srv->cli.fd+SMBW_CLI_FD) {
 442                         close(srv->cli.fd);
 443                         srv->cli.fd += SMBW_CLI_FD;
 444                 }
 445         }
 446
 447         DLIST_ADD(smbw_srvs, srv);
 448
 449         return srv;
 450
 451  failed:
 452         cli_shutdown(&c);
 453         if (!srv) return NULL;
 454
 455         if (srv->server_name) free(srv->server_name);
 456         if (srv->share_name) free(srv->share_name);
 457         free(srv);
 458         return NULL;
 459 }
 460
 461
 462 /*****************************************************
 463 map a fd to a smbw_file structure
 464 *******************************************************/
 465 struct smbw_file *smbw_file(int fd)
 466 {
 467         struct smbw_file *file;
 468
 469         for (file=smbw_files;file;file=file->next) {
 470                 if (file->fd == fd) return file;
 471         }
 472         return NULL;
 473 }
 474
 475 /*****************************************************
 476 map a fd to a smbw_dir structure
 477 *******************************************************/
 478 struct smbw_dir *smbw_dir(int fd)
 479 {
 480         struct smbw_dir *dir;
 481
 482         for (dir=smbw_dirs;dir;dir=dir->next) {
 483                 if (dir->fd == fd) return dir;
 484         }
 485         return NULL;
 486 }
 487
 488 /*****************************************************
 489 setup basic info in a stat structure
 490 *******************************************************/
 491 void smbw_setup_stat(struct stat *st, char *fname, size_t size, int mode)
 492 {
 493         ZERO_STRUCTP(st);
 494
 495         if (IS_DOS_DIR(mode)) {
 496                 st->st_mode = SMBW_DIR_MODE;
 497         } else {
 498                 st->st_mode = SMBW_FILE_MODE;
 499         }
 500
 501         st->st_size = size;
 502         st->st_blksize = 512;
 503         st->st_blocks = (size+511)/512;
 504         st->st_uid = getuid();
 505         st->st_gid = getgid();
 506 }
 507
 508
 509 /*****************************************************
 510 try to do a QPATHINFO and if that fails then do a getatr
 511 this is needed because win95 sometimes refuses the qpathinfo
 512 *******************************************************/
 513 static BOOL smbw_getatr(struct smbw_server *srv, char *path,
 514                         uint32 *mode, size_t *size,
 515                         time_t *c_time, time_t *a_time, time_t *m_time)
 516 {
 517         if (cli_qpathinfo(&srv->cli, path, c_time, a_time, m_time,
 518                           size, mode)) return True;
 519
 520         /* if this is NT then don't bother with the getatr */
 521         if (srv->cli.capabilities & CAP_NT_SMBS) return False;
 522
 523         if (cli_getatr(&srv->cli, path, mode, size, m_time)) {
 524                 a_time = c_time = m_time;
 525                 return True;
 526         }
 527         return False;
 528 }
 529
 530 /*****************************************************
 531 free a smbw_dir structure and all entries
 532 *******************************************************/
 533 static void free_dir(struct smbw_dir *dir)
 534 {
 535         if (dir->list) {
 536                 free(dir->list);
 537         }
 538         ZERO_STRUCTP(dir);
 539         free(dir);
 540 }
 541
 542
 543 static struct smbw_dir *cur_dir;
 544
 545 /*****************************************************
 546 add a entry to a directory listing
 547 *******************************************************/
 548 void smbw_dir_add(struct file_info *finfo)
 549 {
 550         DEBUG(5,("%s\n", finfo->name));
 551
 552         if (cur_dir->malloced == cur_dir->count) {
 553                 cur_dir->list = (struct file_info *)Realloc(cur_dir->list,
 554                                                             sizeof(cur_dir->list[0])*
 555                                                             (cur_dir->count+100));
 556                 if (!cur_dir->list) {
 557                         /* oops */
 558                         return;
 559                 }
 560                 cur_dir->malloced += 100;
 561         }
 562
 563         cur_dir->list[cur_dir->count] = *finfo;
 564         cur_dir->count++;
 565 }
 566
 567 /*****************************************************
 568 add a entry to a directory listing
 569 *******************************************************/
 570 void smbw_share_add(const char *share, uint32 type, const char *comment)
 571 {
 572         struct file_info finfo;
 573
 574         ZERO_STRUCT(finfo);
 575
 576         pstrcpy(finfo.name, share);
 577         finfo.mode = aRONLY | aDIR;
 578
 579         smbw_dir_add(&finfo);
 580 }
 581
 582
 583 /*****************************************************
 584 open a directory on the server
 585 *******************************************************/
 586 int smbw_dir_open(const char *fname, int flags)
 587 {
 588         fstring server, share;
 589         pstring path;
 590         struct smbw_server *srv=NULL;
 591         struct smbw_dir *dir=NULL;
 592         pstring mask;
 593         int fd;
 594
 595         DEBUG(4,("%s\n", __FUNCTION__));
 596
 597         if (!fname) {
 598                 errno = EINVAL;
 599                 return -1;
 600         }
 601
 602         smbw_init();
 603
 604         /* work out what server they are after */
 605         smbw_parse_path(fname, server, share, path);
 606
 607         DEBUG(4,("dir_open share=%s\n", share));
 608
 609         /* get a connection to the server */
 610         srv = smbw_server(server, share);
 611         if (!srv) {
 612                 /* smbw_server sets errno */
 613                 goto failed;
 614         }
 615
 616         dir = (struct smbw_dir *)malloc(sizeof(*dir));
 617         if (!dir) {
 618                 errno = ENOMEM;
 619                 goto failed;
 620         }
 621
 622         ZERO_STRUCTP(dir);
 623
 624         cur_dir = dir;
 625
 626         slprintf(mask, sizeof(mask)-1, "%s\\*", path);
 627         string_sub(mask,"\\\\","\\");
 628
 629         if (strcmp(share,"IPC$") == 0) {
 630                 DEBUG(4,("doing NetShareEnum\n"));
 631                 if (cli_RNetShareEnum(&srv->cli, smbw_share_add) <= 0) {
 632                         errno = smbw_errno(&srv->cli);
 633                         goto failed;
 634                 }
 635         } else {
 636                 if (cli_list(&srv->cli, mask, aHIDDEN|aSYSTEM|aDIR,
 637                              smbw_dir_add) <= 0) {
 638                         errno = smbw_errno(&srv->cli);
 639                         goto failed;
 640                 }
 641         }
 642
 643         cur_dir = NULL;
 644
 645         fd = bitmap_find(file_bmap, 0);
 646         if (fd == -1) {
 647                 errno = EMFILE;
 648                 goto failed;
 649         }
 650
 651         DLIST_ADD(smbw_dirs, dir);
 652
 653         bitmap_set(file_bmap, fd);
 654
 655         dir->fd = fd + SMBW_FD_OFFSET;
 656
 657         return dir->fd;
 658
 659  failed:
 660         if (dir) {
 661                 free_dir(dir);
 662         }
 663
 664         return -1;
 665 }
 666
 667
 668 /*****************************************************
 669 a wrapper for open()
 670 *******************************************************/
 671 int smbw_open(const char *fname, int flags, mode_t mode)
 672 {
 673         fstring server, share;
 674         pstring path;
 675         struct smbw_server *srv=NULL;
 676         int eno, fd = -1;
 677         struct smbw_file *file=NULL;
 678
 679         DEBUG(4,("%s\n", __FUNCTION__));
 680
 681         smbw_init();
 682
 683         if (!fname) {
 684                 errno = EINVAL;
 685                 return -1;
 686         }
 687
 688         smbw_busy++;
 689
 690         /* work out what server they are after */
 691         smbw_parse_path(fname, server, share, path);
 692
 693         /* get a connection to the server */
 694         srv = smbw_server(server, share);
 695         if (!srv) {
 696                 /* smbw_server sets errno */
 697                 goto failed;
 698         }
 699
 700         if (path[strlen(path)-1] == '\\') {
 701                 fd = -1;
 702         } else {
 703                 fd = cli_open(&srv->cli, path, flags, DENY_NONE);
 704         }
 705         if (fd == -1) {
 706                 /* it might be a directory. Maybe we should use chkpath? */
 707                 fd = smbw_dir_open(fname, flags);
 708                 smbw_busy--;
 709                 return fd;
 710         }
 711         if (fd == -1) {
 712                 errno = eno;
 713                 goto failed;
 714         }
 715
 716         file = (struct smbw_file *)malloc(sizeof(*file));
 717         if (!file) {
 718                 errno = ENOMEM;
 719                 goto failed;
 720         }
 721
 722         ZERO_STRUCTP(file);
 723
 724         file->cli_fd = fd;
 725         file->fname = strdup(path);
 726         if (!file->fname) {
 727                 errno = ENOMEM;
 728                 goto failed;
 729         }
 730         file->srv = srv;
 731         file->fd = bitmap_find(file_bmap, 0);
 732
 733         if (file->fd == -1) {
 734                 errno = EMFILE;
 735                 goto failed;
 736         }
 737
 738         bitmap_set(file_bmap, file->fd);
 739
 740         file->fd += SMBW_FD_OFFSET;
 741
 742         DLIST_ADD(smbw_files, file);
 743
 744         DEBUG(4,("opened %s\n", fname));
 745
 746         smbw_busy--;
 747         return file->fd;
 748
 749  failed:
 750         if (fd != -1) {
 751                 cli_close(&srv->cli, fd);
 752         }
 753         if (file) {
 754                 if (file->fname) {
 755                         free(file->fname);
 756                 }
 757                 free(file);
 758         }
 759         smbw_busy--;
 760         return -1;
 761 }
 762
 763
 764 /*****************************************************
 765 a wrapper for fstat() on a directory
 766 *******************************************************/
 767 int smbw_dir_fstat(int fd, struct stat *st)
 768 {
 769         struct smbw_dir *dir;
 770
 771         DEBUG(4,("%s\n", __FUNCTION__));
 772
 773         dir = smbw_dir(fd);
 774         if (!dir) {
 775                 errno = EBADF;
 776                 return -1;
 777         }
 778
 779         ZERO_STRUCTP(st);
 780
 781         smbw_setup_stat(st, "", dir->count*sizeof(struct dirent), aDIR);
 782
 783         return 0;
 784 }
 785
 786 /*****************************************************
 787 a wrapper for fstat()
 788 *******************************************************/
 789 int smbw_fstat(int fd, struct stat *st)
 790 {
 791         struct smbw_file *file;
 792         time_t c_time, a_time, m_time;
 793         uint32 size;
 794         int mode;
 795
 796         DEBUG(4,("%s\n", __FUNCTION__));
 797
 798         smbw_busy++;
 799
 800         file = smbw_file(fd);
 801         if (!file) {
 802                 int ret = smbw_dir_fstat(fd, st);
 803                 smbw_busy--;
 804                 return ret;
 805         }
 806
 807         if (!cli_qfileinfo(&file->srv->cli, file->cli_fd,
 808                           &mode, &size, &c_time, &a_time, &m_time) &&
 809             !cli_getattrE(&file->srv->cli, file->cli_fd,
 810                           &mode, &size, &c_time, &a_time, &m_time)) {
 811                 errno = EINVAL;
 812                 smbw_busy--;
 813                 return -1;
 814         }
 815
 816         smbw_setup_stat(st, file->fname, size, mode);
 817
 818         st->st_atime = a_time;
 819         st->st_ctime = c_time;
 820         st->st_mtime = m_time;
 821
 822         DEBUG(4,("%s - OK\n", __FUNCTION__));
 823
 824         smbw_busy--;
 825         return 0;
 826 }
 827
 828
 829 /*****************************************************
 830 a wrapper for stat()
 831 *******************************************************/
 832 int smbw_stat(const char *fname, struct stat *st)
 833 {
 834         struct smbw_server *srv;
 835         fstring server, share;
 836         pstring path;
 837         time_t m_time=0, a_time=0, c_time=0;
 838         size_t size=0;
 839         uint32 mode=0;
 840
 841         DEBUG(4,("%s (%s)\n", __FUNCTION__, fname));
 842
 843         if (!fname) {
 844                 errno = EINVAL;
 845                 return -1;
 846         }
 847
 848         smbw_init();
 849
 850         smbw_busy++;
 851
 852         /* work out what server they are after */
 853         smbw_parse_path(fname, server, share, path);
 854
 855         /* get a connection to the server */
 856         srv = smbw_server(server, share);
 857         if (!srv) {
 858                 /* smbw_server sets errno */
 859                 goto failed;
 860         }
 861
 862         if (strcmp(share,"IPC$") == 0) {
 863                 mode = aDIR | aRONLY;
 864         } else {
 865                 if (!smbw_getatr(srv, path,
 866                                  &mode, &size, &c_time, &a_time, &m_time)) {
 867                         errno = smbw_errno(&srv->cli);
 868                         goto failed;
 869                 }
 870         }
 871
 872         smbw_setup_stat(st, path, size, mode);
 873
 874         st->st_atime = time(NULL);
 875         st->st_ctime = m_time;
 876         st->st_mtime = m_time;
 877
 878         smbw_busy--;
 879         return 0;
 880
 881  failed:
 882         smbw_busy--;
 883         return -1;
 884 }
 885
 886 /*****************************************************
 887 a wrapper for read()
 888 *******************************************************/
 889 ssize_t smbw_read(int fd, void *buf, size_t count)
 890 {
 891         struct smbw_file *file;
 892         int ret;
 893
 894         DEBUG(4,("%s\n", __FUNCTION__));
 895
 896         smbw_busy++;
 897
 898         file = smbw_file(fd);
 899         if (!file) {
 900                 errno = EBADF;
 901                 smbw_busy--;
 902                 return -1;
 903         }
 904
 905         ret = cli_read(&file->srv->cli, file->cli_fd, buf, file->offset, count);
 906
 907         if (ret == -1) {
 908                 errno = smbw_errno(&file->srv->cli);
 909                 smbw_busy--;
 910                 return -1;
 911         }
 912
 913         file->offset += ret;
 914
 915         smbw_busy--;
 916         return ret;
 917 }
 918
 919 /*****************************************************
 920 a wrapper for write()
 921 *******************************************************/
 922 ssize_t smbw_write(int fd, void *buf, size_t count)
 923 {
 924         struct smbw_file *file;
 925         int ret;
 926
 927         DEBUG(4,("%s\n", __FUNCTION__));
 928
 929         smbw_busy++;
 930
 931         file = smbw_file(fd);
 932         if (!file) {
 933                 DEBUG(3,("bad fd in read\n"));
 934                 errno = EBADF;
 935                 smbw_busy--;
 936                 return -1;
 937         }
 938
 939         ret = cli_write(&file->srv->cli, file->cli_fd, buf, file->offset, count);
 940
 941         if (ret == -1) {
 942                 errno = smbw_errno(&file->srv->cli);
 943                 smbw_busy--;
 944                 return -1;
 945         }
 946
 947         file->offset += ret;
 948
 949         smbw_busy--;
 950         return ret;
 951 }
 952
 953 /*****************************************************
 954 close a directory handle
 955 *******************************************************/
 956 int smbw_dir_close(int fd)
 957 {
 958         struct smbw_dir *dir;
 959
 960         DEBUG(4,("%s\n", __FUNCTION__));
 961
 962         dir = smbw_dir(fd);
 963         if (!dir) {
 964                 DEBUG(4,("%s(%d)\n", __FUNCTION__, __LINE__));
 965                 errno = EBADF;
 966                 return -1;
 967         }
 968
 969         bitmap_clear(file_bmap, dir->fd - SMBW_FD_OFFSET);
 970
 971         DLIST_REMOVE(smbw_dirs, dir);
 972
 973         free_dir(dir);
 974
 975         return 0;
 976 }
 977
 978 /*****************************************************
 979 a wrapper for close()
 980 *******************************************************/
 981 int smbw_close(int fd)
 982 {
 983         struct smbw_file *file;
 984
 985         DEBUG(4,("%s\n", __FUNCTION__));
 986
 987         smbw_busy++;
 988
 989         file = smbw_file(fd);
 990         if (!file) {
 991                 int ret = smbw_dir_close(fd);
 992                 smbw_busy--;
 993                 return ret;
 994         }
 995
 996         if (!cli_close(&file->srv->cli, file->cli_fd)) {
 997                 errno = smbw_errno(&file->srv->cli);
 998                 smbw_busy--;
 999                 return -1;
1000         }
1001
1002
1003         bitmap_clear(file_bmap, file->fd - SMBW_FD_OFFSET);
1004
1005         DLIST_REMOVE(smbw_files, file);
1006
1007         free(file->fname);
1008         ZERO_STRUCTP(file);
1009         free(file);
1010
1011         smbw_busy--;
1012
1013         return 0;
1014 }
1015
1016
1017 /*****************************************************
1018 a wrapper for fcntl()
1019 *******************************************************/
1020 int smbw_fcntl(int fd, int cmd, long arg)
1021 {
1022         DEBUG(4,("%s\n", __FUNCTION__));
1023         return 0;
1024 }
1025
1026
1027 /*****************************************************
1028 a wrapper for getdents()
1029 *******************************************************/
1030 int smbw_getdents(unsigned int fd, struct dirent *dirp, int count)
1031 {
1032         struct smbw_dir *dir;
1033         int n=0;
1034
1035         DEBUG(4,("%s\n", __FUNCTION__));
1036
1037         smbw_busy++;
1038
1039         dir = smbw_dir(fd);
1040         if (!dir) {
1041                 errno = EBADF;
1042                 smbw_busy--;
1043                 return -1;
1044         }
1045
1046         while (count>=sizeof(*dirp) && (dir->offset < dir->count)) {
1047                 dirp->d_ino = dir->offset + 0x10000;
1048                 dirp->d_off = (dir->offset+1)*sizeof(*dirp);
1049                 dirp->d_reclen = sizeof(*dirp);
1050                 /* what's going on with the -1 here? maybe d_type
1051                    isn't really there? */
1052                 safe_strcpy(&dirp->d_name[-1], dir->list[dir->offset].name,
1053                             sizeof(dirp->d_name)-1);
1054                 dir->offset++;
1055                 count -= dirp->d_reclen;
1056                 dirp++;
1057                 n++;
1058         }
1059
1060         smbw_busy--;
1061         return n*sizeof(*dirp);
1062 }
1063
1064
1065 /*****************************************************
1066 a wrapper for access()
1067 *******************************************************/
1068 int smbw_access(const char *name, int mode)
1069 {
1070         struct stat st;
1071         /* how do we map this properly ?? */
1072         return smbw_stat(name, &st) == 0;
1073 }
1074
1075 /*****************************************************
1076 a wrapper for realink() - needed for correct errno setting
1077 *******************************************************/
1078 int smbw_readlink(const char *path, char *buf, size_t bufsize)
1079 {
1080         struct stat st;
1081         int ret;
1082
1083         ret = smbw_stat(path, &st);
1084         if (ret != 0) {
1085                 DEBUG(4,("readlink(%s) failed\n", path));
1086                 return -1;
1087         }
1088
1089         /* it exists - say it isn't a link */
1090         DEBUG(4,("readlink(%s) not a link\n", path));
1091
1092         errno = EINVAL;
1093         return -1;
1094 }
1095
1096
1097 /*****************************************************
1098 a wrapper for chdir()
1099 *******************************************************/
1100 int smbw_chdir(const char *name)
1101 {
1102         struct smbw_server *srv;
1103         fstring server, share;
1104         pstring path;
1105         uint32 mode = aDIR;
1106         char *cwd;
1107
1108         smbw_init();
1109
1110         if (smbw_busy) return real_chdir(cwd);
1111
1112         smbw_busy++;
1113
1114         if (!name) {
1115                 errno = EINVAL;
1116                 goto failed;
1117         }
1118
1119         DEBUG(4,("%s (%s)\n", __FUNCTION__, name));
1120
1121         /* work out what server they are after */
1122         cwd = smbw_parse_path(name, server, share, path);
1123
1124         if (strncmp(cwd,SMBW_PREFIX,strlen(SMBW_PREFIX))) {
1125                 if (real_chdir(cwd) == 0) {
1126                         DEBUG(4,("set SMBW_CWD to %s\n", cwd));
1127                         pstrcpy(smb_cwd, cwd);
1128                         if (setenv(SMBW_PWD_ENV, smb_cwd, 1)) {
1129                                 DEBUG(4,("setenv failed\n"));
1130                         }
1131                         goto success;
1132                 }
1133                 errno = ENOENT;
1134                 goto failed;
1135         }
1136
1137         /* get a connection to the server */
1138         srv = smbw_server(server, share);
1139         if (!srv) {
1140                 /* smbw_server sets errno */
1141                 goto failed;
1142         }
1143
1144         if (strcmp(share,"IPC$") &&
1145             !smbw_getatr(srv, path,
1146                          &mode, NULL, NULL, NULL, NULL)) {
1147                 errno = smbw_errno(&srv->cli);
1148                 goto failed;
1149         }
1150
1151         if (!(mode & aDIR)) {
1152                 errno = ENOTDIR;
1153                 goto failed;
1154         }
1155
1156         DEBUG(4,("set SMBW_CWD2 to %s\n", cwd));
1157         pstrcpy(smb_cwd, cwd);
1158         if (setenv(SMBW_PWD_ENV, smb_cwd, 1)) {
1159                 DEBUG(4,("setenv failed\n"));
1160         }
1161
1162         /* we don't want the old directory to be busy */
1163         real_chdir("/");
1164
1165  success:
1166         smbw_busy--;
1167         return 0;
1168
1169  failed:
1170         smbw_busy--;
1171         return -1;
1172 }
1173
1174
1175 /*****************************************************
1176 a wrapper for unlink()
1177 *******************************************************/
1178 int smbw_unlink(const char *fname)
1179 {
1180         struct smbw_server *srv;
1181         fstring server, share;
1182         pstring path;
1183
1184         DEBUG(4,("%s (%s)\n", __FUNCTION__, fname));
1185
1186         if (!fname) {
1187                 errno = EINVAL;
1188                 return -1;
1189         }
1190
1191         smbw_init();
1192
1193         smbw_busy++;
1194
1195         /* work out what server they are after */
1196         smbw_parse_path(fname, server, share, path);
1197
1198         /* get a connection to the server */
1199         srv = smbw_server(server, share);
1200         if (!srv) {
1201                 /* smbw_server sets errno */
1202                 goto failed;
1203         }
1204
1205         if (!cli_unlink(&srv->cli, path)) {
1206                 errno = smbw_errno(&srv->cli);
1207                 goto failed;
1208         }
1209
1210         smbw_busy--;
1211         return 0;
1212
1213  failed:
1214         smbw_busy--;
1215         return -1;
1216 }
1217
1218
1219 /*****************************************************
1220 a wrapper for rename()
1221 *******************************************************/
1222 int smbw_rename(const char *oldname, const char *newname)
1223 {
1224         struct smbw_server *srv;
1225         fstring server1, share1;
1226         pstring path1;
1227         fstring server2, share2;
1228         pstring path2;
1229
1230         DEBUG(4,("%s (%s, %s)\n", __FUNCTION__, oldname, newname));
1231
1232         if (!oldname || !newname) {
1233                 errno = EINVAL;
1234                 return -1;
1235         }
1236
1237         smbw_init();
1238
1239         smbw_busy++;
1240
1241         /* work out what server they are after */
1242         smbw_parse_path(oldname, server1, share1, path1);
1243         smbw_parse_path(newname, server2, share2, path2);
1244
1245         if (strcmp(server1, server2) || strcmp(share1, share2)) {
1246                 /* can't cross filesystems */
1247                 errno = EXDEV;
1248                 return -1;
1249         }
1250
1251         /* get a connection to the server */
1252         srv = smbw_server(server1, share1);
1253         if (!srv) {
1254                 /* smbw_server sets errno */
1255                 goto failed;
1256         }
1257
1258         if (!cli_rename(&srv->cli, path1, path2)) {
1259                 errno = smbw_errno(&srv->cli);
1260                 goto failed;
1261         }
1262
1263         smbw_busy--;
1264         return 0;
1265
1266  failed:
1267         smbw_busy--;
1268         return -1;
1269 }
1270
1271
1272 /*****************************************************
1273 a wrapper for utime()
1274 *******************************************************/
1275 int smbw_utime(const char *fname, struct utimbuf *buf)
1276 {
1277         struct smbw_server *srv;
1278         fstring server, share;
1279         pstring path;
1280         uint32 mode;
1281
1282         DEBUG(4,("%s (%s)\n", __FUNCTION__, fname));
1283
1284         if (!fname) {
1285                 errno = EINVAL;
1286                 return -1;
1287         }
1288
1289         smbw_init();
1290
1291         smbw_busy++;
1292
1293         /* work out what server they are after */
1294         smbw_parse_path(fname, server, share, path);
1295
1296         /* get a connection to the server */
1297         srv = smbw_server(server, share);
1298         if (!srv) {
1299                 /* smbw_server sets errno */
1300                 goto failed;
1301         }
1302
1303         if (!cli_getatr(&srv->cli, path, &mode, NULL, NULL)) {
1304                 errno = smbw_errno(&srv->cli);
1305                 goto failed;
1306         }
1307
1308         if (!cli_setatr(&srv->cli, path, mode, buf->modtime)) {
1309                 errno = smbw_errno(&srv->cli);
1310                 goto failed;
1311         }
1312
1313         smbw_busy--;
1314         return 0;
1315
1316  failed:
1317         smbw_busy--;
1318         return -1;
1319 }
1320
1321 /*****************************************************
1322 a wrapper for chown()
1323 *******************************************************/
1324 int smbw_chown(const char *fname, uid_t owner, gid_t group)
1325 {
1326         struct smbw_server *srv;
1327         fstring server, share;
1328         pstring path;
1329         uint32 mode;
1330
1331         DEBUG(4,("%s (%s)\n", __FUNCTION__, fname));
1332
1333         if (!fname) {
1334                 errno = EINVAL;
1335                 return -1;
1336         }
1337
1338         smbw_init();
1339
1340         smbw_busy++;
1341
1342         /* work out what server they are after */
1343         smbw_parse_path(fname, server, share, path);
1344
1345         /* get a connection to the server */
1346         srv = smbw_server(server, share);
1347         if (!srv) {
1348                 /* smbw_server sets errno */
1349                 goto failed;
1350         }
1351
1352         if (!cli_getatr(&srv->cli, path, &mode, NULL, NULL)) {
1353                 errno = smbw_errno(&srv->cli);
1354                 goto failed;
1355         }
1356
1357         /* assume success */
1358
1359         smbw_busy--;
1360         return 0;
1361
1362  failed:
1363         smbw_busy--;
1364         return -1;
1365 }
1366
1367 /*****************************************************
1368 a wrapper for chmod()
1369 *******************************************************/
1370 int smbw_chmod(const char *fname, mode_t newmode)
1371 {
1372         struct smbw_server *srv;
1373         fstring server, share;
1374         pstring path;
1375         uint32 mode;
1376
1377         DEBUG(4,("%s (%s)\n", __FUNCTION__, fname));
1378
1379         if (!fname) {
1380                 errno = EINVAL;
1381                 return -1;
1382         }
1383
1384         smbw_init();
1385
1386         smbw_busy++;
1387
1388         /* work out what server they are after */
1389         smbw_parse_path(fname, server, share, path);
1390
1391         /* get a connection to the server */
1392         srv = smbw_server(server, share);
1393         if (!srv) {
1394                 /* smbw_server sets errno */
1395                 goto failed;
1396         }
1397
1398         if (!cli_getatr(&srv->cli, path, &mode, NULL, NULL)) {
1399                 errno = smbw_errno(&srv->cli);
1400                 goto failed;
1401         }
1402
1403         /* assume success for the moment - need to add attribute mapping */
1404
1405         smbw_busy--;
1406         return 0;
1407
1408  failed:
1409         smbw_busy--;
1410         return -1;
1411 }
1412
1413 /*****************************************************
1414 a wrapper for lseek()
1415 *******************************************************/
1416 ssize_t smbw_lseek(int fd, off_t offset, int whence)
1417 {
1418         struct smbw_file *file;
1419         uint32 size;
1420
1421         DEBUG(4,("%s\n", __FUNCTION__));
1422
1423         smbw_busy++;
1424
1425         file = smbw_file(fd);
1426         if (!file) {
1427                 errno = EBADF;
1428                 smbw_busy--;
1429                 return -1;
1430         }
1431
1432         switch (whence) {
1433         case SEEK_SET:
1434                 file->offset = offset;
1435                 break;
1436         case SEEK_CUR:
1437                 file->offset += offset;
1438                 break;
1439         case SEEK_END:
1440                 if (!cli_qfileinfo(&file->srv->cli, file->cli_fd,
1441                                    NULL, &size, NULL, NULL, NULL) &&
1442                     !cli_getattrE(&file->srv->cli, file->cli_fd,
1443                                   NULL, &size, NULL, NULL, NULL)) {
1444                         errno = EINVAL;
1445                         smbw_busy--;
1446                         return -1;
1447                 }
1448                 file->offset = size + offset;
1449                 break;
1450         }
1451
1452         smbw_busy--;
1453         return file->offset;
1454 }