source/libsmb/libsmbclient.c

   1 /*
   2    Unix SMB/Netbios implementation.
   3    Version 2.0
   4    SMB client library implementation
   5    Copyright (C) Andrew Tridgell 1998
   6    Copyright (C) Richard Sharpe 2000
   7    Copyright (C) John Terpstra 2000
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 2 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22 */
  23
  24 #include "includes.h"
  25 #include "libsmbclient.h"
  26
  27 /* Structure for servers ... Held here so we don't need an include ...
  28  * May be better to put in an include file
  29  */
  30
  31 struct smbc_server {
  32   struct smbc_server *next, *prev;
  33   struct cli_state cli;
  34   dev_t dev;
  35   char *server_name;
  36   char *share_name;
  37   char *workgroup;
  38   char *username;
  39   BOOL no_pathinfo2;
  40 };
  41
  42 /* Keep directory entries in a list */
  43 struct smbc_dir_list {
  44   struct smbc_dir_list *next;
  45   struct smbc_dirent *dirent;
  46 };
  47
  48 struct smbc_file {
  49   int cli_fd;
  50   int smbc_fd;
  51   char *fname;
  52   off_t offset;
  53   struct smbc_server *srv;
  54   BOOL file;
  55   struct smbc_dir_list *dir_list, *dir_end, *dir_next;
  56   int dir_type, dir_error;
  57 };
  58
  59 extern BOOL in_client;
  60 static int smbc_initialized = 0;
  61 static smbc_get_auth_data_fn smbc_auth_fn = NULL;
  62 static int smbc_debug;
  63 static int smbc_start_fd;
  64 static int smbc_max_fd = 10000;
  65 static struct smbc_file **smbc_file_table;
  66 static struct smbc_server *smbc_srvs;
  67 static pstring  my_netbios_name;
  68 static pstring smbc_user;
  69
  70 /*
  71  * Clean up a filename by removing redundent stuff
  72  */
  73
  74 static void
  75 smbc_clean_fname(char *name)
  76 {
  77   char *p, *p2;
  78   int l;
  79   int modified = 1;
  80
  81   if (!name) return;
  82
  83   while (modified) {
  84     modified = 0;
  85
  86     DEBUG(5,("cleaning %s\n", name));
  87
  88     if ((p=strstr(name,"/./"))) {
  89       modified = 1;
  90       while (*p) {
  91         p[0] = p[2];
  92         p++;
  93       }
  94     }
  95
  96     if ((p=strstr(name,"//"))) {
  97       modified = 1;
  98       while (*p) {
  99         p[0] = p[1];
 100         p++;
 101       }
 102     }
 103
 104     if (strcmp(name,"/../")==0) {
 105       modified = 1;
 106       name[1] = 0;
 107     }
 108
 109     if ((p=strstr(name,"/../"))) {
 110       modified = 1;
 111       for (p2=(p>name?p-1:p);p2>name;p2--) {
 112         if (p2[0] == '/') break;
 113       }
 114       while (*p2) {
 115         p2[0] = p2[3];
 116         p2++;
 117       }
 118     }
 119
 120     if (strcmp(name,"/..")==0) {
 121       modified = 1;
 122       name[1] = 0;
 123     }
 124
 125     l = strlen(name);
 126     p = l>=3?(name+l-3):name;
 127     if (strcmp(p,"/..")==0) {
 128       modified = 1;
 129       for (p2=p-1;p2>name;p2--) {
 130         if (p2[0] == '/') break;
 131       }
 132       if (p2==name) {
 133         p[0] = '/';
 134         p[1] = 0;
 135       } else {
 136         p2[0] = 0;
 137       }
 138     }
 139
 140     l = strlen(name);
 141     p = l>=2?(name+l-2):name;
 142     if (strcmp(p,"/.")==0) {
 143       if (p == name) {
 144         p[1] = 0;
 145       } else {
 146         p[0] = 0;
 147       }
 148     }
 149
 150     if (strncmp(p=name,"./",2) == 0) {
 151       modified = 1;
 152       do {
 153         p[0] = p[2];
 154       } while (*p++);
 155     }
 156
 157     l = strlen(p=name);
 158     if (l > 1 && p[l-1] == '/') {
 159       modified = 1;
 160       p[l-1] = 0;
 161     }
 162   }
 163 }
 164
 165 /*
 166  * Function to parse a path and turn it into components
 167  *
 168  * We accept smb://[[[domain;]user[:password@]]server[/share[/path[/file]]]]
 169  *
 170  * smb://       means show all the workgroups
 171  * smb://name/  means, if name<1D> exists, list servers in workgroup,
 172  *              else, if name<20> exists, list all shares for server ...
 173  */
 174
 175 static const char *smbc_prefix = "smb:";
 176
 177 static int
 178 smbc_parse_path(const char *fname, char *server, char *share, char *path,
 179                 char *user, char *password) /* FIXME, lengths of strings */
 180 {
 181   static pstring s;
 182   char *p;
 183   int len;
 184   fstring workgroup;
 185
 186   server[0] = share[0] = path[0] = user[0] = password[0] = (char)0;
 187   pstrcpy(s, fname);
 188
 189   /*  clean_fname(s);  causing problems ... */
 190
 191   /* see if it has the right prefix */
 192   len = strlen(smbc_prefix);
 193   if (strncmp(s,smbc_prefix,len) ||
 194       (s[len] != '/' && s[len] != 0)) return -1; /* What about no smb: ? */
 195
 196   p = s + len;
 197
 198   /* Watch the test below, we are testing to see if we should exit */
 199
 200   if (strncmp(p, "//", 2) && strncmp(p, "\\\\", 2)) {
 201
 202     return -1;
 203
 204   }
 205
 206   p += 2;  /* Skip the // or \\  */
 207
 208   if (*p == (char)0)
 209     return 0;
 210
 211   if (*p == '/') {
 212
 213     strncpy(server, lp_workgroup(), 16); /* FIXME: Danger here */
 214     return 0;
 215
 216   }
 217
 218   /* ok, its for us. Now parse out the server, share etc. */
 219
 220   if (!next_token(&p, server, "/", sizeof(fstring))) {
 221
 222     return -1;
 223
 224   }
 225
 226   if (*p == (char)0) return 0;  /* That's it ... */
 227
 228   if (!next_token(&p, share, "/", sizeof(fstring))) {
 229
 230     return -1;
 231
 232   }
 233
 234   pstrcpy(path, p);
 235
 236   all_string_sub(path, "/", "\\", 0);
 237
 238   return 0;
 239 }
 240
 241 /*
 242  * Convert an SMB error into a UNIX error ...
 243  */
 244
 245 int smbc_errno(struct cli_state *c)
 246 {
 247         uint8 eclass;
 248         uint32 ecode;
 249         int ret;
 250
 251         ret = cli_error(c, &eclass, &ecode, NULL);
 252
 253         if (ret) {
 254                 DEBUG(3,("smbc_error %d %d (0x%x) -> %d\n",
 255                          (int)eclass, (int)ecode, (int)ecode, ret));
 256         }
 257         return ret;
 258 }
 259
 260 /*
 261  * Connect to a server, possibly on an existing connection
 262  *
 263  * Here, what we want to do is: If the server and username
 264  * match an existing connection, reuse that, otherwise, establish a
 265  * new connection.
 266  *
 267  * If we have to create a new connection, call the auth_fn to get the
 268  * info we need, unless the username and password were passed in.
 269  */
 270
 271 struct smbc_server *smbc_server(char *server, char *share,
 272                                 char *workgroup, char *username,
 273                                 char *password)
 274 {
 275   struct smbc_server *srv=NULL;
 276   struct cli_state c;
 277   struct nmb_name called, calling;
 278   char *p, *server_n = server;
 279   fstring group;
 280   pstring ipenv;
 281   struct in_addr ip;
 282   extern struct in_addr ipzero;
 283
 284   ip = ipzero;
 285   ZERO_STRUCT(c);
 286
 287   /* try to use an existing connection */
 288   for (srv=smbc_srvs;srv;srv=srv->next) {
 289     if (strcmp(server,srv->server_name)==0 &&
 290         strcmp(share,srv->share_name)==0 &&
 291         strcmp(workgroup,srv->workgroup)==0 &&
 292         strcmp(username, srv->username) == 0)
 293       return srv;
 294   }
 295
 296   if (server[0] == 0) {
 297     errno = EPERM;
 298     return NULL;
 299   }
 300
 301   /* Pick up the auth info here, once we know we need to connect */
 302
 303   smbc_auth_fn(server, share, workgroup, sizeof(fstring),
 304                username, sizeof(fstring), password, sizeof(fstring));
 305
 306   /*
 307    * However, smbc_auth_fn may have picked up info relating to an
 308    * existing connection, so try for and existing connection again ...
 309    */
 310
 311   for (srv=smbc_srvs;srv;srv=srv->next) {
 312     if (strcmp(server,srv->server_name)==0 &&
 313         strcmp(share,srv->share_name)==0 &&
 314         strcmp(workgroup,srv->workgroup)==0 &&
 315         strcmp(username, srv->username) == 0)
 316       return srv;
 317   }
 318
 319   make_nmb_name(&calling, my_netbios_name, 0x0);
 320   make_nmb_name(&called , server, 0x20);
 321
 322   DEBUG(4,("server_n=[%s] server=[%s]\n", server_n, server));
 323
 324   if ((p=strchr(server_n,'#')) &&
 325       (strcmp(p+1,"1D")==0 || strcmp(p+1,"01")==0)) {
 326     struct in_addr sip;
 327     pstring s;
 328
 329     fstrcpy(group, server_n);
 330     p = strchr(group,'#');
 331     *p = 0;
 332
 333   }
 334
 335   DEBUG(4,(" -> server_n=[%s] server=[%s]\n", server_n, server));
 336
 337  again:
 338   slprintf(ipenv,sizeof(ipenv)-1,"HOST_%s", server_n);
 339
 340   ip = ipzero;
 341
 342   /* have to open a new connection */
 343   if (!cli_initialise(&c) || !cli_connect(&c, server_n, &ip)) {
 344     errno = ENOENT;
 345     return NULL;
 346   }
 347
 348   if (!cli_session_request(&c, &calling, &called)) {
 349     cli_shutdown(&c);
 350     if (strcmp(called.name, "*SMBSERVER")) {
 351       make_nmb_name(&called , "*SMBSERVER", 0x20);
 352       goto again;
 353     }
 354     errno = ENOENT;
 355     return NULL;
 356   }
 357
 358   DEBUG(4,(" session request ok\n"));
 359
 360   if (!cli_negprot(&c)) {
 361     cli_shutdown(&c);
 362     errno = ENOENT;
 363     return NULL;
 364   }
 365
 366   if (!cli_session_setup(&c, username,
 367                          password, strlen(password),
 368                          password, strlen(password),
 369                          workgroup) &&
 370       /* try an anonymous login if it failed */
 371       !cli_session_setup(&c, "", "", 1,"", 0, workgroup)) {
 372     cli_shutdown(&c);
 373     errno = EPERM;
 374     return NULL;
 375   }
 376
 377   DEBUG(4,(" session setup ok\n"));
 378
 379   if (!cli_send_tconX(&c, share, "?????",
 380                       password, strlen(password)+1)) {
 381     errno = smbc_errno(&c);
 382     cli_shutdown(&c);
 383     return NULL;
 384   }
 385
 386   DEBUG(4,(" tconx ok\n"));
 387
 388   srv = (struct smbc_server *)malloc(sizeof(*srv));
 389   if (!srv) {
 390     errno = ENOMEM;
 391     goto failed;
 392   }
 393
 394   ZERO_STRUCTP(srv);
 395
 396   srv->cli = c;
 397
 398   srv->dev = (dev_t)(str_checksum(server) ^ str_checksum(share));
 399
 400   srv->server_name = strdup(server);
 401   if (!srv->server_name) {
 402     errno = ENOMEM;
 403     goto failed;
 404   }
 405
 406   srv->share_name = strdup(share);
 407   if (!srv->share_name) {
 408     errno = ENOMEM;
 409     goto failed;
 410   }
 411
 412   srv->workgroup = strdup(workgroup);
 413   if (!srv->workgroup) {
 414     errno = ENOMEM;
 415     goto failed;
 416   }
 417
 418   srv->username = strdup(username);
 419   if (!srv->username) {
 420     errno = ENOMEM;
 421     goto failed;
 422   }
 423
 424   DLIST_ADD(smbc_srvs, srv);
 425
 426   return srv;
 427
 428  failed:
 429   cli_shutdown(&c);
 430   if (!srv) return NULL;
 431
 432   if (srv->server_name) free(srv->server_name);
 433   if (srv->share_name) free(srv->share_name);
 434   free(srv);
 435   return NULL;
 436 }
 437
 438 /*
 439  *Initialise the library etc
 440  */
 441
 442 int smbc_init(smbc_get_auth_data_fn fn, const char *wgroup, int debug)
 443 {
 444   static pstring workgroup;
 445   pstring conf;
 446   int p, pid;
 447   char *user = NULL, *host = NULL, *home = NULL, *pname="libsmbclient";
 448
 449   smbc_initialized = 1;
 450   smbc_auth_fn = fn;
 451   smbc_debug = debug;
 452
 453   DEBUGLEVEL = -1;
 454
 455   setup_logging(pname, False);
 456
 457   /*
 458    * We try to construct our netbios name from our hostname etc
 459    */
 460
 461   user = getenv("USER");
 462   if (!user) user = "";  /* FIXME: What to do about this? */
 463
 464   /*
 465    * FIXME: Is this the best way to get the user info? */
 466
 467   pstrcpy(smbc_user, user); /* Save for use elsewhere */
 468
 469   pid = getpid();
 470
 471   /*
 472    * Hmmm, I want to get hostname as well, but I am too lazy for the moment
 473    */
 474
 475   slprintf(my_netbios_name, 16, "smbc%s%d", user, pid);
 476   pstrcpy(workgroup, wgroup);
 477
 478   charset_initialise();
 479
 480   /* Here we would open the smb.conf file if needed ... */
 481
 482   home = getenv("HOME");
 483
 484   slprintf(conf, sizeof(conf), "%s/.smb/smb.conf", home);
 485
 486   load_interfaces();  /* Load the list of interfaces ... */
 487
 488   in_client = True; /* FIXME, make a param */
 489
 490
 491
 492   if (!lp_load(conf, True, False, False)) {
 493
 494     /*
 495      * Hmmm, what the hell do we do here ... we could not parse the
 496      * config file ... We must return an error ... and keep info around
 497      * about why we failed
 498      */
 499     /*
 500     errno = ENOENT; /* Hmmm, what error resp does lp_load return ? */
 501     return -1;
 502
 503   }
 504
 505   codepage_initialise(lp_client_code_page()); /* Get a codepage */
 506
 507   reopen_logs();  /* Get logging working ... */
 508
 509   /*
 510    * Now initialize the file descriptor array and figure out what the
 511    * max open files is, so we can return FD's that are above the max
 512    * open file, and separated by a guard band
 513    */
 514
 515 #if (defined(HAVE_GETRLIMIT) && defined(RLIMIT_NOFILE))
 516   do {
 517     struct rlimit rlp;
 518
 519     if (getrlimit(RLIMIT_NOFILE, &rlp)) {
 520
 521       DEBUG(0, ("smbc_init: getrlimit(1) for RLIMIT_NOFILE failed with error %s\n", strerror(errno)));
 522
 523       smbc_start_fd = 1000000;
 524       smbc_max_fd = 10000;     /* FIXME, should be a define ... */
 525
 526     }
 527     else {
 528
 529       smbc_start_fd = rlp.rlim_max + 10000; /* Leave a guard space of 10,000 */
 530       smbc_max_fd = 10000;
 531
 532     }
 533   } while ( 0 );
 534 #else /* !defined(HAVE_GETRLIMIT) || !defined(RLIMIT_NOFILE) */
 535
 536   smbc_start_fd = 1000000;
 537   smbc_max_fd = 10000;     /* FIXME, should be a define ... */
 538
 539 #endif
 540
 541   smbc_file_table = malloc(smbc_max_fd * sizeof(struct smbc_file *));
 542
 543   for (p = 0; p < smbc_max_fd; p++)
 544     smbc_file_table[p] = NULL;
 545
 546   if (!smbc_file_table)
 547     return ENOMEM;
 548
 549   return 0;  /* Success */
 550
 551 }
 552
 553 /*
 554  * Routine to open() a file ...
 555  */
 556
 557 int smbc_open(const char *fname, int flags, mode_t mode)
 558 {
 559   fstring server, share, user, password;
 560   pstring path;
 561   struct smbc_server *srv = NULL;
 562   struct smbc_file *file = NULL;
 563   int fd;
 564
 565   if (!smbc_initialized) {
 566
 567     errno = EUCLEAN;  /* Best I can think of ... */
 568     return -1;
 569
 570   }
 571
 572   if (!fname) {
 573
 574     errno = EINVAL;
 575     return -1;
 576
 577   }
 578
 579   smbc_parse_path(fname, server, share, path, user, password); /* FIXME, check errors */
 580
 581   if (user[0] == (char)0) pstrcpy(user, smbc_user);
 582
 583   srv = smbc_server(server, share, lp_workgroup(), user, password);
 584
 585   if (!srv) {
 586
 587     return -1;  /* smbc_server sets errno */
 588
 589   }
 590
 591   if (path[strlen(path) - 1] == '\\') {
 592
 593     fd = -1;
 594
 595   }
 596   else {
 597
 598     int slot = 0;
 599
 600     /* Find a free slot first */
 601
 602     while (smbc_file_table[slot])
 603       slot++;
 604
 605     if (slot > smbc_max_fd) {
 606
 607       errno = ENOMEM; /* FIXME, is this best? */
 608       return -1;
 609
 610     }
 611
 612     smbc_file_table[slot] = malloc(sizeof(struct smbc_file));
 613
 614     if (!smbc_file_table[slot]) {
 615
 616       errno = ENOMEM;
 617       return -1;
 618
 619     }
 620
 621     if ((fd = cli_open(&srv->cli, path, flags, DENY_NONE)) < 0) {
 622
 623       /* Handle the error ... */
 624
 625       free(smbc_file_table[slot]);
 626       smbc_file_table[slot] = NULL;
 627       errno = smbc_errno(&srv->cli);
 628       return -1;
 629
 630     }
 631
 632     /* Fill in file struct */
 633
 634     smbc_file_table[slot]->cli_fd  = fd;
 635     smbc_file_table[slot]->smbc_fd = slot + smbc_start_fd;
 636     smbc_file_table[slot]->fname   = strdup(fname);
 637     smbc_file_table[slot]->srv     = srv;
 638     smbc_file_table[slot]->offset  = 0;
 639     smbc_file_table[slot]->file    = True;
 640
 641     return smbc_file_table[slot]->smbc_fd;
 642
 643   }
 644
 645   /* Check if opendir needed ... */
 646
 647   if (fd == -1) {
 648     int eno = 0;
 649
 650     eno = smbc_errno(&srv->cli);
 651     fd = smbc_opendir(fname);
 652     if (fd < 0) errno = eno;
 653     return fd;
 654
 655   }
 656
 657   return 1;  /* Success, with fd ... */
 658
 659  failed:
 660
 661   /*FIXME, clean up things ... */
 662   return -1;
 663
 664 }
 665
 666 /*
 667  * Routine to create a file
 668  */
 669
 670 static int creat_bits = O_WRONLY | O_CREAT | O_TRUNC; /* FIXME: Do we need this */
 671
 672 int smbc_creat(const char *path, mode_t mode)
 673 {
 674
 675   if (!smbc_initialized) {
 676
 677     errno = EUCLEAN;
 678     return -1;
 679
 680   }
 681
 682   return smbc_open(path, creat_bits, mode);
 683 }
 684
 685 /*
 686  * Routine to read() a file ...
 687  */
 688
 689 ssize_t smbc_read(int fd, void *buf, size_t count)
 690 {
 691   struct smbc_file *fe;
 692   int ret;
 693
 694   if (!smbc_initialized) {
 695
 696     errno = EUCLEAN;
 697     return -1;
 698
 699   }
 700
 701   DEBUG(4, ("smbc_read(%d, %d)\n", fd, (int)count));
 702
 703   if (fd < smbc_start_fd || fd >= (smbc_start_fd + smbc_max_fd)) {
 704
 705     errno = EBADF;
 706     return -1;
 707
 708   }
 709
 710   fe = smbc_file_table[fd - smbc_start_fd];
 711
 712   if (!fe->file) {
 713
 714     errno = EBADF;
 715     return -1;
 716
 717   }
 718
 719   ret = cli_read(&fe->srv->cli, fe->cli_fd, buf, fe->offset, count);
 720
 721   if (ret < 0) {
 722
 723     errno = smbc_errno(&fe->srv->cli);
 724     return -1;
 725
 726   }
 727
 728   fe->offset += ret;
 729
 730   DEBUG(4, ("  --> %d\n", ret));
 731
 732   return ret;  /* Success, ret bytes of data ... */
 733
 734 }
 735
 736 /*
 737  * Routine to write() a file ...
 738  */
 739
 740 ssize_t smbc_write(int fd, void *buf, size_t count)
 741 {
 742   int ret;
 743   struct smbc_file *fe;
 744
 745   if (!smbc_initialized) {
 746
 747     errno = EUCLEAN;
 748     return -1;
 749
 750   }
 751
 752   if (fd < smbc_start_fd || fd >= (smbc_start_fd + smbc_max_fd)) {
 753
 754     errno = EBADF;
 755     return -1;
 756
 757   }
 758
 759   fe = smbc_file_table[fd - smbc_start_fd];
 760
 761   ret = cli_write(&fe->srv->cli, fe->cli_fd, 0, buf, fe->offset, count);
 762
 763   if (ret < 0) {
 764
 765     errno = smbc_errno(&fe->srv->cli);
 766     return -1;
 767
 768   }
 769
 770   fe->offset += ret;
 771
 772   return ret;  /* Success, 0 bytes of data ... */
 773 }
 774
 775 /*
 776  * Routine to close() a file ...
 777  */
 778
 779 int smbc_close(int fd)
 780 {
 781   struct smbc_file *fe;
 782
 783   if (!smbc_initialized) {
 784
 785     errno = EUCLEAN;
 786     return -1;
 787
 788   }
 789
 790   if (fd < smbc_start_fd || fd >= (smbc_start_fd + smbc_max_fd)) {
 791
 792     errno = EBADF;
 793     return -1;
 794
 795   }
 796
 797   fe = smbc_file_table[fd - smbc_start_fd];
 798
 799   if (!fe->file) {
 800
 801     return smbc_closedir(fd);
 802
 803   }
 804
 805   if (!cli_close(&fe->srv->cli, fe->cli_fd)) {
 806
 807     errno = smbc_errno(&fe->srv->cli);  /* FIXME, should we deallocate slot? */
 808     return -1;
 809
 810   }
 811
 812   free(fe);
 813   smbc_file_table[fd - smbc_start_fd] = NULL;
 814
 815   return 0;
 816 }
 817
 818 /*
 819  * Routine to unlink() a file
 820  */
 821
 822 int smbc_unlink(const char *fname)
 823 {
 824   fstring server, share, user, password;
 825   pstring path;
 826   struct smbc_server *srv = NULL;
 827
 828   if (!smbc_initialized) {
 829
 830     errno = EUCLEAN;  /* Best I can think of ... */
 831     return -1;
 832
 833   }
 834
 835   if (!fname) {
 836
 837     errno = EINVAL;
 838     return -1;
 839
 840   }
 841
 842   smbc_parse_path(fname, server, share, path, user, password); /* FIXME, check errors */
 843
 844   if (user[0] == (char)0) pstrcpy(user, smbc_user);
 845
 846   srv = smbc_server(server, share, lp_workgroup(), user, password);
 847
 848   if (!srv) {
 849
 850     return -1;  /* smbc_server sets errno */
 851
 852   }
 853
 854   /*  if (strncmp(srv->cli.dev, "LPT", 3) == 0) {
 855
 856     int job = smbc_stat_printjob(srv, path, NULL, NULL);
 857     if (job == -1) {
 858
 859       return -1;
 860
 861     }
 862     if (cli_printjob_del(&srv->cli, job) != 0) {
 863
 864       return -1;
 865
 866     }
 867     } else */
 868
 869   if (!cli_unlink(&srv->cli, path)) {
 870
 871     errno = smbc_errno(&srv->cli);
 872
 873     if (errno == EACCES) { /* Check if the file is a directory */
 874
 875       int err, saverr = errno;
 876       struct stat st;
 877       size_t size = 0;
 878       uint16 mode = 0;
 879       time_t m_time = 0, a_time = 0, c_time = 0;
 880       SMB_INO_T ino = 0;
 881
 882       if (!smbc_getatr(srv, path, &mode, &size,
 883                        &c_time, &a_time, &m_time, &ino)) {
 884
 885         /* Hmmm, bad error ... What? */
 886
 887         errno = smbc_errno(&srv->cli);
 888         return -1;
 889
 890       }
 891       else {
 892
 893         if (IS_DOS_DIR(mode))
 894           errno = EPERM;
 895         else
 896           errno = saverr;  /* Restore this */
 897
 898       }
 899     }
 900
 901     return -1;
 902
 903   }
 904
 905   return 0;  /* Success ... */
 906
 907 }
 908
 909 /*
 910  * Routine to rename() a file
 911  */
 912
 913 int smbc_rename(const char *oname, const char *nname)
 914 {
 915   fstring server1, share1, server2, share2, user1, user2, password1, password2;
 916   pstring path1, path2;
 917   struct smbc_server *srv = NULL;
 918
 919   if (!smbc_initialized) {
 920
 921     errno = EUCLEAN;  /* Best I can think of ... */
 922     return -1;
 923
 924   }
 925
 926   if (!oname || !nname) {
 927
 928     errno = EINVAL;
 929     return -1;
 930
 931   }
 932
 933   DEBUG(4, ("smbc_rename(%s,%s)\n", oname, nname));
 934
 935   smbc_parse_path(oname, server1, share1, path1, user1, password1);
 936
 937   if (user1[0] == (char)0) pstrcpy(user1, smbc_user);
 938
 939   smbc_parse_path(nname, server2, share2, path2, user2, password2);
 940
 941   if (user2[0] == (char)0) pstrcpy(user2, smbc_user);
 942
 943   if (strcmp(server1, server2) || strcmp(share1, share2) ||
 944       strcmp(user1, user2)) {
 945
 946     /* Can't rename across file systems, or users?? */
 947
 948     errno = EXDEV;
 949     return -1;
 950
 951   }
 952
 953   srv = smbc_server(server1, share1, lp_workgroup(), user1, password1);
 954   if (!srv) {
 955
 956     return -1;
 957
 958   }
 959
 960   if (!cli_rename(&srv->cli, path1, path2)) {
 961     int eno = smbc_errno(&srv->cli);
 962
 963     if (eno != EEXIST ||
 964         !cli_unlink(&srv->cli, path2) ||
 965         !cli_rename(&srv->cli, path1, path2)) {
 966
 967       errno = eno;
 968       return -1;
 969
 970     }
 971   }
 972
 973   return 0; /* Success */
 974
 975 }
 976
 977 /*
 978  * A routine to lseek() a file
 979  */
 980
 981 off_t smbc_lseek(int fd, off_t offset, int whence)
 982 {
 983   struct smbc_file *fe;
 984   size_t size;
 985
 986   if (!smbc_initialized) {
 987
 988     errno = EUCLEAN;
 989     return -1;
 990
 991   }
 992
 993   if (fd < smbc_start_fd || fd >= (smbc_start_fd + smbc_max_fd)) {
 994
 995     errno = EBADF;
 996     return -1;
 997
 998   }
 999
1000   fe = smbc_file_table[fd - smbc_start_fd];
1001
1002   if (!fe->file) {
1003
1004     return smbc_lseekdir(fd, offset, whence);
1005
1006   }
1007
1008   switch (whence) {
1009   case SEEK_SET:
1010     fe->offset = offset;
1011     break;
1012
1013   case SEEK_CUR:
1014     fe->offset += offset;
1015     break;
1016
1017   case SEEK_END:
1018     if (!cli_qfileinfo(&fe->srv->cli, fe->cli_fd, NULL, &size, NULL, NULL,
1019                        NULL, NULL, NULL) &&
1020         !cli_getattrE(&fe->srv->cli, fe->cli_fd, NULL, &size, NULL, NULL,
1021                       NULL)) {
1022
1023       errno = EINVAL;
1024       return -1;
1025     }
1026     fe->offset = size + offset;
1027     break;
1028
1029   default:
1030     errno = EINVAL;
1031     break;
1032
1033   }
1034
1035   return fe->offset;
1036
1037 }
1038
1039 /*
1040  * Generate an inode number from file name for those things that need it
1041  */
1042
1043 static
1044 ino_t smbc_inode(const char *name)
1045 {
1046
1047   if (!*name) return 2; /* FIXME, why 2 ??? */
1048   return (ino_t)str_checksum(name);
1049
1050 }
1051
1052 /*
1053  * Routine to put basic stat info into a stat structure ... Used by stat and
1054  * fstat below.
1055  */
1056
1057 static
1058 int smbc_setup_stat(struct stat *st, char *fname, size_t size, int mode)
1059 {
1060
1061   st->st_mode = 0;
1062
1063   if (IS_DOS_DIR(mode)) {
1064     st->st_mode = SMBC_DIR_MODE;
1065   } else {
1066     st->st_mode = SMBC_FILE_MODE;
1067   }
1068
1069   if (IS_DOS_ARCHIVE(mode)) st->st_mode |= S_IXUSR;
1070   if (IS_DOS_SYSTEM(mode)) st->st_mode |= S_IXGRP;
1071   if (IS_DOS_HIDDEN(mode)) st->st_mode |= S_IXOTH;
1072   if (!IS_DOS_READONLY(mode)) st->st_mode |= S_IWUSR;
1073
1074   st->st_size = size;
1075   st->st_blksize = 512;
1076   st->st_blocks = (size+511)/512;
1077   st->st_uid = getuid();
1078   st->st_gid = getgid();
1079
1080   if (IS_DOS_DIR(mode)) {
1081     st->st_nlink = 2;
1082   } else {
1083     st->st_nlink = 1;
1084   }
1085
1086   if (st->st_ino == 0) {
1087     st->st_ino = smbc_inode(fname);
1088   }
1089 }
1090
1091 /*
1092  * Get info from an SMB server on a file. Use a qpathinfo call first
1093  * and if that fails, use getatr, as Win95 sometimes refuses qpathinfo
1094  */
1095
1096 BOOL smbc_getatr(struct smbc_server *srv, char *path,
1097                  uint16 *mode, size_t *size,
1098                  time_t *c_time, time_t *a_time, time_t *m_time,
1099                  SMB_INO_T *ino)
1100 {
1101
1102   if (!smbc_initialized) {
1103
1104     errno = EUCLEAN;
1105     return -1;
1106
1107   }
1108
1109   DEBUG(4,("sending qpathinfo\n"));
1110
1111   if (!srv->no_pathinfo2 &&
1112       cli_qpathinfo2(&srv->cli, path, c_time, a_time, m_time, NULL,
1113                      size, mode, ino)) return True;
1114
1115   /* if this is NT then don't bother with the getatr */
1116   if (srv->cli.capabilities & CAP_NT_SMBS) return False;
1117
1118   if (cli_getatr(&srv->cli, path, mode, size, m_time)) {
1119     a_time = c_time = m_time;
1120     srv->no_pathinfo2 = True;
1121     return True;
1122   }
1123   return False;
1124 }
1125
1126 /*
1127  * Routine to stat a file given a name
1128  */
1129
1130 int smbc_stat(const char *fname, struct stat *st)
1131 {
1132   struct smbc_server *srv;
1133   fstring server, share, user, password;
1134   pstring path;
1135   time_t m_time = 0, a_time = 0, c_time = 0;
1136   size_t size = 0;
1137   uint16 mode = 0;
1138   SMB_INO_T ino = 0;
1139
1140   if (!smbc_initialized) {
1141
1142     errno = EUCLEAN;  /* Best I can think of ... */
1143     return -1;
1144
1145   }
1146
1147   if (!fname) {
1148
1149     errno = EINVAL;
1150     return -1;
1151
1152   }
1153
1154   DEBUG(4, ("stat(%s)\n", fname));
1155
1156   smbc_parse_path(fname, server, share, path, user, password); /*FIXME, errors*/
1157
1158   if (user[0] == (char)0) pstrcpy(user, smbc_user);
1159
1160   srv = smbc_server(server, share, lp_workgroup(), user, password);
1161
1162   if (!srv) {
1163
1164     return -1;  /* errno set by smbc_server */
1165
1166   }
1167
1168   /* if (strncmp(srv->cli.dev, "IPC", 3) == 0) {
1169
1170      mode = aDIR | aRONLY;
1171
1172      }
1173      else if (strncmp(srv->cli.dev, "LPT", 3) == 0) {
1174
1175        if (strcmp(path, "\\") == 0) {
1176
1177           mode = aDIR | aRONLY;
1178
1179        }
1180        else {
1181
1182          mode = aRONLY;
1183          smbc_stat_printjob(srv, path, &size, &m_time);
1184          c_time = a_time = m_time;
1185
1186        }
1187        else { */
1188
1189   if (!smbc_getatr(srv, path, &mode, &size,
1190                    &c_time, &a_time, &m_time, &ino)) {
1191
1192     errno = smbc_errno(&srv->cli);
1193     return -1;
1194
1195   }
1196
1197   /* } */
1198
1199   st->st_ino = ino;
1200
1201   smbc_setup_stat(st, path, size, mode);
1202
1203   st->st_atime = a_time;
1204   st->st_ctime = c_time;
1205   st->st_mtime = m_time;
1206   st->st_dev   = srv->dev;
1207
1208   return 0;
1209
1210 }
1211
1212 /*
1213  * Routine to stat a file given an fd
1214  */
1215
1216 int smbc_fstat(int fd, struct stat *st)
1217 {
1218   struct smbc_file *fe;
1219   time_t c_time, a_time, m_time;
1220   size_t size;
1221   uint16 mode;
1222   SMB_INO_T ino = 0;
1223
1224   if (!smbc_initialized) {
1225
1226     errno = EUCLEAN;
1227     return -1;
1228
1229   }
1230
1231   if (fd < smbc_start_fd || fd >= (smbc_start_fd + smbc_max_fd)) {
1232
1233     errno = EBADF;
1234     return -1;
1235
1236   }
1237
1238   fe = smbc_file_table[fd - smbc_start_fd];
1239
1240   if (!fe->file) {
1241
1242     return smbc_fstatdir(fd, st);
1243
1244   }
1245
1246   if (!cli_qfileinfo(&fe->srv->cli, fe->cli_fd,
1247                      &mode, &size, &c_time, &a_time, &m_time, NULL, &ino) &&
1248       !cli_getattrE(&fe->srv->cli, fe->cli_fd,
1249                     &mode, &size, &c_time, &a_time, &m_time)) {
1250
1251     errno = EINVAL;
1252     return -1;
1253
1254   }
1255
1256   st->st_ino = ino;
1257
1258   smbc_setup_stat(st, fe->fname, size, mode);
1259
1260   st->st_atime = a_time;
1261   st->st_ctime = c_time;
1262   st->st_mtime = m_time;
1263   st->st_dev = fe->srv->dev;
1264
1265   return 0;
1266
1267 }
1268
1269 /*
1270  * Routine to open a directory
1271  *
1272  * We want to allow:
1273  *
1274  * smb: which should list all the workgroups available
1275  * smb:workgroup
1276  * smb:workgroup//server
1277  * smb://server
1278  * smb://server/share
1279  */
1280
1281 static void smbc_remove_dir(struct smbc_file *dir)
1282 {
1283   struct smbc_dir_list *d,*f;
1284
1285   d = dir->dir_list;
1286   while (d) {
1287
1288     f = d; d = d->next;
1289
1290     if (f->dirent) free(f->dirent);
1291     free(f);
1292
1293   }
1294
1295   dir->dir_list = dir->dir_end = dir->dir_next = NULL;
1296
1297 }
1298
1299 static int add_dirent(struct smbc_file *dir, const char *name, const char *comment, uint32 type)
1300 {
1301   struct smbc_dirent *dirent;
1302   int size;
1303
1304   /*
1305    * Allocate space for the dirent, which must be increased by the
1306    * size of the name and the comment and 1 for the null on the comment.
1307    * The null on the name is already accounted for.
1308    */
1309
1310   size = sizeof(struct smbc_dirent) + (name?strlen(name):0) +
1311     (comment?strlen(comment):0) + 1;
1312
1313   dirent = malloc(size);
1314
1315   if (!dirent) {
1316
1317     dir->dir_error = ENOMEM;
1318     return -1;
1319
1320   }
1321
1322   if (dir->dir_list == NULL) {
1323
1324     dir->dir_list = malloc(sizeof(struct smbc_dir_list));
1325     if (!dir->dir_list) {
1326
1327       free(dirent);
1328       dir->dir_error = ENOMEM;
1329       return -1;
1330
1331     }
1332
1333     dir->dir_end = dir->dir_next = dir->dir_list;
1334
1335   }
1336   else {
1337
1338     dir->dir_end->next = malloc(sizeof(struct smbc_dir_list));
1339
1340     if (!dir->dir_end) {
1341
1342       free(dirent);
1343       dir->dir_error = ENOMEM;
1344       return -1;
1345
1346     }
1347
1348     dir->dir_end = dir->dir_end->next;
1349
1350   }
1351
1352   dir->dir_end->next = NULL;
1353   dir->dir_end->dirent = dirent;
1354
1355   dirent->smbc_type = type;
1356   dirent->namelen = (name?strlen(name):0);
1357   dirent->commentlen = (comment?strlen(comment):0);
1358   dirent->dirlen = size;
1359
1360   strncpy(dirent->name, (name?name:""), dirent->namelen + 1);
1361
1362   dirent->comment = (char *)(&dirent->name + dirent->namelen + 1);
1363   strncpy(dirent->comment, (comment?comment:""), dirent->commentlen + 1);
1364
1365   return 0;
1366
1367 }
1368
1369 static void
1370 list_fn(const char *name, uint32 type, const char *comment, void *state)
1371 {
1372   struct smbc_file *dir = (struct smbc_file *)state;
1373   int dirent_type;
1374
1375   /* We need to process the type a little ... */
1376
1377   if (dir->dir_type == SMBC_FILE_SHARE) {
1378
1379     switch (type) {
1380     case 0: /* Directory tree */
1381       dirent_type = SMBC_FILE_SHARE;
1382       break;
1383
1384     case 1:
1385       dirent_type = SMBC_PRINTER_SHARE;
1386       break;
1387
1388     case 2:
1389       dirent_type = SMBC_COMMS_SHARE;
1390       break;
1391
1392     case 3:
1393       dirent_type = SMBC_IPC_SHARE;
1394       break;
1395
1396     default:
1397       dirent_type = SMBC_FILE_SHARE; /* FIXME, error? */
1398       break;
1399     }
1400
1401   }
1402   else dirent_type = dir->dir_type;
1403
1404   if (add_dirent(dir, name, comment, dirent_type) < 0) {
1405
1406     /* An error occurred, what do we do? */
1407
1408   }
1409
1410 }
1411
1412 static void
1413 dir_list_fn(file_info *finfo, const char *mask, void *state)
1414 {
1415
1416   fprintf(stderr, "Finfo->name=%s, mask=%s\n", finfo->name, mask);
1417   if (add_dirent((struct smbc_file *)state, finfo->name, "",
1418                  (finfo->mode&aDIR?SMBC_DIR:SMBC_FILE)) < 0) {
1419
1420     /* Handle an error ... */
1421
1422   }
1423
1424 }
1425
1426 int smbc_opendir(const char *fname)
1427 {
1428   struct in_addr addr;
1429   fstring server, share, user, password;
1430   pstring path;
1431   struct smbc_server *srv = NULL;
1432   struct in_addr rem_ip;
1433   int slot = 0;
1434   uint8 eclass;
1435   uint32 ecode;
1436
1437   if (!smbc_initialized) {
1438
1439     errno = EUCLEAN;
1440     return -1;
1441
1442   }
1443
1444   if (!fname) {
1445
1446     errno = EINVAL;
1447     return -1;
1448
1449   }
1450
1451   if (smbc_parse_path(fname, server, share, path, user, password)) {
1452
1453     errno = EINVAL;
1454     return -1;
1455
1456   }
1457
1458   if (user[0] == (char)0) pstrcpy(user, smbc_user);
1459
1460   /* Get a file entry ... */
1461
1462   slot = 0;
1463
1464   while (smbc_file_table[slot])
1465     slot++;
1466
1467   if (slot > smbc_max_fd) {
1468
1469     errno = ENOMEM;
1470     return -1; /* FIXME, ... move into a func */
1471
1472   }
1473
1474   smbc_file_table[slot] = malloc(sizeof(struct smbc_file));
1475
1476   if (!smbc_file_table[slot]) {
1477
1478     errno = ENOMEM;
1479     return -1;
1480
1481   }
1482
1483   smbc_file_table[slot]->cli_fd   = 0;
1484   smbc_file_table[slot]->smbc_fd  = slot + smbc_start_fd;
1485   smbc_file_table[slot]->fname    = strdup(fname);
1486   smbc_file_table[slot]->srv      = NULL;
1487   smbc_file_table[slot]->offset   = 0;
1488   smbc_file_table[slot]->file     = False;
1489   smbc_file_table[slot]->dir_list =
1490     smbc_file_table[slot]->dir_next =
1491     smbc_file_table[slot]->dir_end = NULL;
1492
1493   if (server[0] == (char)0) {
1494
1495     if (share[0] != (char)0 || path[0] != (char)0) {
1496
1497       errno = EINVAL;
1498       if (smbc_file_table[slot]) free(smbc_file_table[slot]);
1499       smbc_file_table[slot] = NULL;
1500       return -1;
1501
1502     }
1503
1504     /* We have server and share and path empty ... so list the workgroups */
1505
1506     /*    fprintf(stderr, "Workgroup is: %s\n", lp_workgroup()); */
1507     cli_get_backup_server(my_netbios_name, lp_workgroup(), server, sizeof(server));
1508
1509     smbc_file_table[slot]->dir_type = SMBC_WORKGROUP;
1510
1511   /*
1512    * Get a connection to IPC$ on the server if we do not already have one
1513    */
1514
1515     srv = smbc_server(server, "IPC$", lp_workgroup(), user, password);
1516
1517     if (!srv) {
1518
1519       if (smbc_file_table[slot]) free(smbc_file_table[slot]);
1520       smbc_file_table[slot] = NULL;
1521       return -1;
1522
1523     }
1524
1525     smbc_file_table[slot]->srv = srv;
1526
1527     /* Now, list the stuff ... */
1528
1529     if (!cli_NetServerEnum(&srv->cli, lp_workgroup(), 0x80000000, list_fn,
1530                            (void *)smbc_file_table[slot])) {
1531
1532       if (smbc_file_table[slot]) free(smbc_file_table[slot]);
1533       smbc_file_table[slot] = NULL;
1534       errno = cli_error(&srv->cli, &eclass, &ecode, NULL);
1535       return -1;
1536
1537     }
1538   }
1539   else { /* Server not an empty string ... Check the rest and see what gives */
1540
1541     if (share[0] == (char)0) {
1542
1543       if (path[0] != (char)0) { /* Should not have empty share with path */
1544
1545         errno = EINVAL;
1546         if (smbc_file_table[slot]) free(smbc_file_table[slot]);
1547         smbc_file_table[slot] = NULL;
1548         return -1;
1549
1550       }
1551
1552       /* Check to see if <server><1D> translates, or <server><20> translates */
1553
1554       if (resolve_name(server, &rem_ip, 0x1d)) { /* Found LMB */
1555         pstring buserver;
1556
1557         smbc_file_table[slot]->dir_type = SMBC_SERVER;
1558
1559         /*
1560          * Get the backup list ...
1561          */
1562
1563         cli_get_backup_server(my_netbios_name, server, buserver, sizeof(buserver));
1564
1565         /*
1566          * Get a connection to IPC$ on the server if we do not already have one
1567          */
1568
1569         srv = smbc_server(buserver, "IPC$", lp_workgroup(), user, password);
1570
1571         if (!srv) {
1572
1573           if (smbc_file_table[slot]) free(smbc_file_table[slot]);
1574           smbc_file_table[slot] = NULL;  /* FIXME: Memory leaks ... */
1575           return -1;
1576
1577         }
1578
1579         smbc_file_table[slot]->srv = srv;
1580
1581         /* Now, list the servers ... */
1582
1583         if (!cli_NetServerEnum(&srv->cli, server, 0x0000FFFE, list_fn,
1584                                (void *)smbc_file_table[slot])) {
1585
1586           if (smbc_file_table[slot]) free(smbc_file_table[slot]);
1587           smbc_file_table[slot] = NULL;
1588           errno = cli_error(&srv->cli, &eclass, &ecode, NULL);
1589           return -1;
1590
1591         }
1592
1593       }
1594       else {
1595
1596         if (resolve_name(server, &rem_ip, 0x20)) {
1597
1598           /* Now, list the shares ... */
1599
1600           smbc_file_table[slot]->dir_type = SMBC_FILE_SHARE;
1601
1602           srv = smbc_server(server, "IPC$", lp_workgroup(), user, password);
1603
1604           if (!srv) {
1605
1606             if (smbc_file_table[slot]) free(smbc_file_table[slot]);
1607             smbc_file_table[slot] = NULL;
1608             return -1;
1609
1610           }
1611
1612           smbc_file_table[slot]->srv = srv;
1613
1614           /* Now, list the servers ... */
1615
1616           if (cli_RNetShareEnum(&srv->cli, list_fn,
1617                                 (void *)smbc_file_table[slot]) < 0) {
1618
1619             errno = cli_error(&srv->cli, &eclass, &ecode, NULL);
1620             if (smbc_file_table[slot]) free(smbc_file_table[slot]);
1621             smbc_file_table[slot] = NULL;
1622             return -1;
1623
1624           }
1625
1626         }
1627         else {
1628
1629           errno = EINVAL;
1630           if (smbc_file_table[slot]) free(smbc_file_table[slot]);
1631           smbc_file_table[slot] = NULL;
1632           return -1;
1633
1634         }
1635
1636       }
1637
1638     }
1639     else { /* The server and share are specified ... work from there ... */
1640
1641       /* Well, we connect to the server and list the directory */
1642
1643       smbc_file_table[slot]->dir_type = SMBC_FILE_SHARE;
1644
1645       srv = smbc_server(server, share, lp_workgroup(), user, password);
1646
1647       if (!srv) {
1648
1649         if (smbc_file_table[slot]) free(smbc_file_table[slot]);
1650         smbc_file_table[slot] = NULL;
1651         return -1;
1652
1653       }
1654
1655       smbc_file_table[slot]->srv = srv;
1656
1657       /* Now, list the files ... */
1658
1659       pstrcat(path, "\\*");
1660
1661       if (!cli_list(&srv->cli, path, aDIR | aSYSTEM | aHIDDEN, dir_list_fn,
1662                     (void *)smbc_file_table[slot])) {
1663
1664         if (smbc_file_table[slot]) free(smbc_file_table[slot]);
1665         smbc_file_table[slot] = NULL;
1666         errno = smbc_errno(&srv->cli);
1667         return -1;
1668
1669       }
1670     }
1671
1672   }
1673
1674   return smbc_file_table[slot]->smbc_fd;
1675
1676 }
1677
1678 /*
1679  * Routine to close a directory
1680  */
1681
1682 int smbc_closedir(int fd)
1683 {
1684   struct smbc_file *fe;
1685
1686   if (!smbc_initialized) {
1687
1688     errno = EUCLEAN;
1689     return -1;
1690
1691   }
1692
1693   if (fd < smbc_start_fd || fd >= (smbc_start_fd + smbc_max_fd)) {
1694
1695     errno = EBADF;
1696     return -1;
1697
1698   }
1699
1700   fe = smbc_file_table[fd - smbc_start_fd];
1701
1702   if (!fe) {
1703
1704     errno = ENOENT;  /* FIXME: Is this correct */
1705     return -1;
1706
1707   }
1708
1709   smbc_remove_dir(fe); /* Clean it up */
1710
1711   if (fe) free(fe);    /* Free the space too */
1712
1713   smbc_file_table[fd - smbc_start_fd] = NULL;
1714
1715   return 0;
1716
1717 }
1718
1719 /*
1720  * Routine to get a directory entry
1721  */
1722
1723 static char smbc_local_dirent[512];  /* Make big enough */
1724
1725 struct smbc_dirent *smbc_readdir(unsigned int fd)
1726 {
1727   struct smbc_file *fe;
1728   struct smbc_dirent *dirp, *dirent;
1729
1730   /* Check that all is ok first ... */
1731
1732   if (!smbc_initialized) {
1733
1734     errno = EUCLEAN;
1735     return NULL;
1736
1737   }
1738
1739   if (fd < smbc_start_fd || fd >= (smbc_start_fd + smbc_max_fd)) {
1740
1741     errno = EBADF;
1742     return NULL;
1743
1744   }
1745
1746   fe = smbc_file_table[fd - smbc_start_fd];
1747
1748   if (fe->file != False) { /* FIXME, should be dir, perhaps */
1749
1750     errno = ENOTDIR;
1751     return NULL;
1752
1753   }
1754
1755   if (!fe->dir_next)
1756     return NULL;
1757   else {
1758
1759     dirent = fe->dir_next->dirent;
1760
1761     if (!dirent) {
1762
1763       errno = ENOENT;
1764       return NULL;
1765
1766     }
1767
1768     /* Hmmm, do I even need to copy it? */
1769
1770     bcopy(dirent, smbc_local_dirent, dirent->dirlen); /* Copy the dirent */
1771
1772     dirp = (struct smbc_dirent *)smbc_local_dirent;
1773
1774     dirp->comment = (char *)(&dirp->name + dirent->namelen + 1);
1775
1776     fe->dir_next = fe->dir_next->next;
1777
1778     return (struct smbc_dirent *)smbc_local_dirent;
1779   }
1780
1781 }
1782
1783 /*
1784  * Routine to get directory entries
1785  */
1786
1787 int smbc_getdents(unsigned int fd, struct smbc_dirent *dirp, int count)
1788 {
1789   struct smbc_file *fe;
1790   struct smbc_dir_list *dir;
1791   int rem = count, reqd;
1792
1793   /* Check that all is ok first ... */
1794
1795   if (!smbc_initialized) {
1796
1797     errno = EUCLEAN;
1798     return -1;
1799
1800   }
1801
1802   if (fd < smbc_start_fd || fd >= (smbc_start_fd + smbc_max_fd)) {
1803
1804     errno = EBADF;
1805     return -1;
1806
1807   }
1808
1809   fe = smbc_file_table[fd - smbc_start_fd];
1810
1811   if (fe->file != False) { /* FIXME, should be dir, perhaps */
1812
1813     errno = ENOTDIR;
1814     return -1;
1815
1816   }
1817
1818   /*
1819    * Now, retrieve the number of entries that will fit in what was passed
1820    * We have to figure out if the info is in the list, or we need to
1821    * send a request to the server to get the info.
1822    */
1823
1824   while ((dir = fe->dir_next)) {
1825     struct smbc_dirent *dirent;
1826
1827     if (!dir->dirent) {
1828
1829       errno = ENOENT;  /* Bad error */
1830       return -1;
1831
1832     }
1833
1834     if (rem < (reqd = (sizeof(struct smbc_dirent) + dir->dirent->namelen +
1835                          dir->dirent->commentlen + 1))) {
1836
1837       if (rem < count) { /* We managed to copy something */
1838
1839         errno = 0;
1840         return count - rem;
1841
1842       }
1843       else { /* Nothing copied ... */
1844
1845         errno = EINVAL;  /* Not enough space ... */
1846         return -1;
1847
1848       }
1849
1850     }
1851
1852     dirent = dir->dirent;
1853
1854     bcopy(dirent, dirp, reqd); /* Copy the data in ... */
1855
1856     dirp->comment = (char *)(&dirp->name + dirent->namelen + 1);
1857
1858     (char *)dirp += reqd;
1859
1860     rem -= reqd;
1861
1862     fe->dir_next = dir = dir -> next;
1863   }
1864
1865   if (rem == count)
1866     return 0;
1867   else
1868     return count - rem;
1869
1870 }
1871
1872 /*
1873  * Routine to create a directory ...
1874  */
1875
1876 int smbc_mkdir(const char *fname, mode_t mode)
1877 {
1878   struct smbc_server *srv;
1879   fstring server, share, user, password;
1880   pstring path;
1881
1882   if (!smbc_initialized) {
1883
1884     errno = EUCLEAN;
1885     return -1;
1886
1887   }
1888
1889   if (!fname) {
1890
1891     errno = EINVAL;
1892     return -1;
1893
1894   }
1895
1896   DEBUG(4, ("stat(%s)\n", fname));
1897
1898   smbc_parse_path(fname, server, share, path, user, password); /*FIXME, errors*/
1899
1900   if (user[0] == (char)0) pstrcpy(user, smbc_user);
1901
1902   srv = smbc_server(server, share, lp_workgroup(), user, password);
1903
1904   if (!srv) {
1905
1906     return -1;  /* errno set by smbc_server */
1907
1908   }
1909
1910   /* if (strncmp(srv->cli.dev, "IPC", 3) == 0) {
1911
1912      mode = aDIR | aRONLY;
1913
1914      }
1915      else if (strncmp(srv->cli.dev, "LPT", 3) == 0) {
1916
1917        if (strcmp(path, "\\") == 0) {
1918
1919           mode = aDIR | aRONLY;
1920
1921        }
1922        else {
1923
1924          mode = aRONLY;
1925          smbc_stat_printjob(srv, path, &size, &m_time);
1926          c_time = a_time = m_time;
1927
1928        }
1929        else { */
1930
1931   if (!cli_mkdir(&srv->cli, path)) {
1932
1933     errno = smbc_errno(&srv->cli);
1934     return -1;
1935
1936   }
1937
1938   return 0;
1939
1940 }
1941
1942 /*
1943  * Routine to remove a directory
1944  */
1945
1946 int smbc_rmdir(const char *fname)
1947 {
1948   struct smbc_server *srv;
1949   fstring server, share, user, password;
1950   pstring path;
1951
1952   if (!smbc_initialized) {
1953
1954     errno = EUCLEAN;
1955     return -1;
1956
1957   }
1958
1959   if (!fname) {
1960
1961     errno = EINVAL;
1962     return -1;
1963
1964   }
1965
1966   DEBUG(4, ("stat(%s)\n", fname));
1967
1968   smbc_parse_path(fname, server, share, path, user, password); /*FIXME, errors*/
1969
1970   if (user[0] == (char)0) pstrcpy(user, smbc_user);
1971
1972   srv = smbc_server(server, share, lp_workgroup(), user, password);
1973
1974   if (!srv) {
1975
1976     return -1;  /* errno set by smbc_server */
1977
1978   }
1979
1980   /* if (strncmp(srv->cli.dev, "IPC", 3) == 0) {
1981
1982      mode = aDIR | aRONLY;
1983
1984      }
1985      else if (strncmp(srv->cli.dev, "LPT", 3) == 0) {
1986
1987        if (strcmp(path, "\\") == 0) {
1988
1989           mode = aDIR | aRONLY;
1990
1991        }
1992        else {
1993
1994          mode = aRONLY;
1995          smbc_stat_printjob(srv, path, &size, &m_time);
1996          c_time = a_time = m_time;
1997
1998        }
1999        else { */
2000
2001   if (!cli_rmdir(&srv->cli, path)) {
2002
2003     errno = smbc_errno(&srv->cli);
2004     return -1;
2005
2006   }
2007
2008   return 0;
2009
2010 }
2011
2012 /*
2013  * Routine to return the current directory position
2014  */
2015
2016 off_t smbc_telldir(int fd)
2017 {
2018   struct smbc_file *fe;
2019
2020   if (!smbc_initialized) {
2021
2022     errno = EUCLEAN;
2023     return -1;
2024
2025   }
2026
2027   if (fd < smbc_start_fd || fd >= (smbc_start_fd + smbc_max_fd)) {
2028
2029     errno = EBADF;
2030     return -1;
2031
2032   }
2033
2034   fe = smbc_file_table[fd - smbc_start_fd];
2035
2036   if (fe->file != False) { /* FIXME, should be dir, perhaps */
2037
2038     errno = ENOTDIR;
2039     return -1;
2040
2041   }
2042
2043   return (off_t) fe->dir_next;
2044
2045 }
2046
2047 /*
2048  * Routine to seek on a directory
2049  */
2050
2051 int smbc_lseekdir(int fd, off_t offset, int whence)
2052 {
2053
2054   if (!smbc_initialized) {
2055
2056     errno = EUCLEAN;
2057     return -1;
2058
2059   }
2060
2061   return 0;
2062
2063 }
2064
2065 /*
2066  * Routine to fstat a dir
2067  */
2068
2069 int smbc_fstatdir(int fd, struct stat *st)
2070 {
2071
2072   if (!smbc_initialized) {
2073
2074     errno = EUCLEAN;
2075     return -1;
2076
2077   }
2078
2079   return 0;
2080
2081 }