source3/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, 2002
   7    Copyright (C) John Terpstra 2000
   8    Copyright (C) Tom Jansen (Ninja ISD) 2002
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 2 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program; if not, write to the Free Software
  22    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  23 */
  24
  25 #include "includes.h"
  26
  27 /*
  28  * Define this to get the real SMBCFILE and SMBCSRV structures
  29  */
  30 #define _SMBC_INTERNAL
  31
  32 #include "libsmbclient.h"
  33
  34 /*
  35  * Functions exported by libsmb_cache.c that we need here
  36  */
  37 int smbc_default_cache_functions(SMBCCTX * context);
  38
  39 /*
  40  * check if an element is part of the list.
  41  * FIXME: Does not belong here !
  42  * Can anyone put this in a macro in dlinklist.h ?
  43  * -- Tom
  44  */
  45 static int DLIST_CONTAINS(SMBCFILE * list, SMBCFILE *p) {
  46         if (!p || !list) return False;
  47         do {
  48                 if (p == list) return True;
  49                 list = list->next;
  50         } while (list);
  51         return False;
  52 }
  53
  54 extern BOOL in_client;
  55 extern pstring global_myname;
  56
  57 /*
  58  * Is the logging working / configfile read ?
  59  */
  60 static int smbc_initialized = 0;
  61
  62 /*
  63  * Function to parse a path and turn it into components
  64  *
  65  * We accept smb://[[[domain;]user[:password@]]server[/share[/path[/file]]]]
  66  *
  67  * smb://       means show all the workgroups
  68  * smb://name/  means, if name<1D> or name<1B> exists, list servers in workgroup,
  69  *              else, if name<20> exists, list all shares for server ...
  70  */
  71
  72 static const char *smbc_prefix = "smb:";
  73
  74 static int
  75 smbc_parse_path(SMBCCTX *context, const char *fname, char *server, char *share, char *path,
  76                 char *user, char *password) /* FIXME, lengths of strings */
  77 {
  78         static pstring s;
  79         pstring userinfo;
  80         char *p;
  81         char *q, *r;
  82         int len;
  83
  84         server[0] = share[0] = path[0] = user[0] = password[0] = (char)0;
  85         pstrcpy(s, fname);
  86
  87         /*  clean_fname(s);  causing problems ... */
  88
  89         /* see if it has the right prefix */
  90         len = strlen(smbc_prefix);
  91         if (strncmp(s,smbc_prefix,len) ||
  92             (s[len] != '/' && s[len] != 0)) return -1; /* What about no smb: ? */
  93
  94         p = s + len;
  95
  96         /* Watch the test below, we are testing to see if we should exit */
  97
  98         if (strncmp(p, "//", 2) && strncmp(p, "\\\\", 2)) {
  99
 100                 return -1;
 101
 102         }
 103
 104         p += 2;  /* Skip the // or \\  */
 105
 106         if (*p == (char)0)
 107                 return 0;
 108
 109         if (*p == '/') {
 110
 111                 strncpy(server, context->workgroup,
 112                         (strlen(context->workgroup) < 16)?strlen(context->workgroup):16);
 113                 return 0;
 114
 115         }
 116
 117         /*
 118          * ok, its for us. Now parse out the server, share etc.
 119          *
 120          * However, we want to parse out [[domain;]user[:password]@] if it
 121          * exists ...
 122          */
 123
 124         /* check that '@' occurs before '/', if '/' exists at all */
 125         q = strchr_m(p, '@');
 126         r = strchr_m(p, '/');
 127         if (q && (!r || q < r)) {
 128                 pstring username, passwd, domain;
 129                 char *u = userinfo;
 130
 131                 next_token(&p, userinfo, "@", sizeof(fstring));
 132
 133                 username[0] = passwd[0] = domain[0] = 0;
 134
 135                 if (strchr_m(u, ';')) {
 136
 137                         next_token(&u, domain, ";", sizeof(fstring));
 138
 139                 }
 140
 141                 if (strchr_m(u, ':')) {
 142
 143                         next_token(&u, username, ":", sizeof(fstring));
 144
 145                         pstrcpy(passwd, u);
 146
 147                 }
 148                 else {
 149
 150                         pstrcpy(username, u);
 151
 152                 }
 153
 154                 if (username[0])
 155                         strncpy(user, username, sizeof(fstring));  /* FIXME, size and domain */
 156
 157                 if (passwd[0])
 158                         strncpy(password, passwd, sizeof(fstring)); /* FIXME, size */
 159
 160         }
 161
 162         if (!next_token(&p, server, "/", sizeof(fstring))) {
 163
 164                 return -1;
 165
 166         }
 167
 168         if (*p == (char)0) return 0;  /* That's it ... */
 169
 170         if (!next_token(&p, share, "/", sizeof(fstring))) {
 171
 172                 return -1;
 173
 174         }
 175
 176         pstrcpy(path, p);
 177
 178         all_string_sub(path, "/", "\\", 0);
 179
 180         return 0;
 181 }
 182
 183 /*
 184  * Convert an SMB error into a UNIX error ...
 185  */
 186
 187 static int smbc_errno(SMBCCTX *context, struct cli_state *c)
 188 {
 189         int ret;
 190
 191         if (cli_is_dos_error(c)) {
 192                 uint8 eclass;
 193                 uint32 ecode;
 194
 195                 cli_dos_error(c, &eclass, &ecode);
 196                 ret = cli_errno_from_dos(eclass, ecode);
 197
 198                 DEBUG(3,("smbc_error %d %d (0x%x) -> %d\n",
 199                          (int)eclass, (int)ecode, (int)ecode, ret));
 200         } else {
 201                 NTSTATUS status;
 202
 203                 status = cli_nt_error(c);
 204                 ret = cli_errno_from_nt(status);
 205
 206                 DEBUG(3,("smbc errno %s -> %d\n",
 207                          get_nt_error_msg(status), ret));
 208         }
 209
 210         return ret;
 211 }
 212
 213 /*
 214  * Check a server_fd.
 215  * returns 0 if the server is in shape. Returns 1 on error
 216  *
 217  * Also useable outside libsmbclient to enable external cache
 218  * to do some checks too.
 219  */
 220 int smbc_check_server(SMBCCTX * context, SMBCSRV * server)
 221 {
 222         if ( cli_send_keepalive(&server->cli) == False )
 223                 return 1;
 224
 225         /* connection is ok */
 226         return 0;
 227 }
 228
 229 /*
 230  * Remove a server from the list server_table if it's unused.
 231  * On success, 0 is returned. 1 is returned if the server could not be removed.
 232  *
 233  * Also useable outside libsmbclient
 234  */
 235 int smbc_remove_unused_server(SMBCCTX * context, SMBCSRV * srv)
 236 {
 237         SMBCFILE * file;
 238
 239         /* are we being fooled ? */
 240         if (!context || !context->_initialized || !srv) return 1;
 241
 242
 243         /* Check all open files/directories for a relation with this server */
 244         for (file = context->_files; file; file=file->next) {
 245                 if (file->srv == srv) {
 246                         /* Still used */
 247                         DEBUG(3, ("smbc_remove_usused_server: %p still used by %p.\n",
 248                                   srv, file));
 249                         return 1;
 250                 }
 251         }
 252
 253         DLIST_REMOVE(context->_servers, srv);
 254
 255         cli_shutdown(&srv->cli);
 256
 257         DEBUG(3, ("smbc_remove_usused_server: %p removed.\n", srv));
 258
 259         context->callbacks.remove_cached_srv_fn(context, srv);
 260
 261         SAFE_FREE(srv);
 262
 263         return 0;
 264 }
 265
 266 /*
 267  * Connect to a server, possibly on an existing connection
 268  *
 269  * Here, what we want to do is: If the server and username
 270  * match an existing connection, reuse that, otherwise, establish a
 271  * new connection.
 272  *
 273  * If we have to create a new connection, call the auth_fn to get the
 274  * info we need, unless the username and password were passed in.
 275  */
 276
 277 SMBCSRV *smbc_server(SMBCCTX *context,
 278                      char *server, char *share,
 279                      char *workgroup, char *username,
 280                      char *password)
 281 {
 282         SMBCSRV *srv=NULL;
 283         int auth_called = 0;
 284         struct cli_state c;
 285         struct nmb_name called, calling;
 286         char *p, *server_n = server;
 287         fstring group;
 288         pstring ipenv;
 289         struct in_addr ip;
 290         int tried_reverse = 0;
 291
 292         zero_ip(&ip);
 293         ZERO_STRUCT(c);
 294
 295         if (server[0] == 0) {
 296                 errno = EPERM;
 297                 return NULL;
 298         }
 299
 300  check_server_cache:
 301
 302         srv = context->callbacks.get_cached_srv_fn(context, server, share,
 303                                                    workgroup, username);
 304
 305         if (!auth_called && !srv && (!username[0] || !password[0])) {
 306                 context->callbacks.auth_fn(server, share, workgroup, sizeof(fstring),
 307                              username, sizeof(fstring), password, sizeof(fstring));
 308                 /*
 309                  * However, smbc_auth_fn may have picked up info relating to an
 310                  * existing connection, so try for an existing connection again ...
 311                  */
 312                 auth_called = 1;
 313                 goto check_server_cache;
 314
 315         }
 316
 317         if (srv) {
 318                 if (context->callbacks.check_server_fn(context, srv)) {
 319                         /*
 320                          * This server is no good anymore
 321                          * Try to remove it and check for more possible servers in the cache
 322                          */
 323                         if (context->callbacks.remove_unused_server_fn(context, srv)) {
 324                                 /*
 325                                  * We could not remove the server completely, remove it from the cache
 326                                  * so we will not get it again. It will be removed when the last file/dir
 327                                  * is closed.
 328                                  */
 329                                 context->callbacks.remove_cached_srv_fn(context, srv);
 330                         }
 331
 332                         /*
 333                          * Maybe there are more cached connections to this server
 334                          */
 335                         goto check_server_cache;
 336                 }
 337                 return srv;
 338         }
 339
 340         make_nmb_name(&calling, context->netbios_name, 0x0);
 341         make_nmb_name(&called , server, 0x20);
 342
 343         DEBUG(4,("smbc_server: server_n=[%s] server=[%s]\n", server_n, server));
 344
 345         if ((p=strchr_m(server_n,'#')) &&
 346             (strcmp(p+1,"1D")==0 || strcmp(p+1,"01")==0)) {
 347
 348                 fstrcpy(group, server_n);
 349                 p = strchr_m(group,'#');
 350                 *p = 0;
 351
 352         }
 353
 354         DEBUG(4,(" -> server_n=[%s] server=[%s]\n", server_n, server));
 355
 356  again:
 357         slprintf(ipenv,sizeof(ipenv)-1,"HOST_%s", server_n);
 358
 359         zero_ip(&ip);
 360
 361         /* have to open a new connection */
 362         if (!cli_initialise(&c)) {
 363                 errno = ENOENT;
 364                 return NULL;
 365         }
 366
 367         c.timeout = context->timeout;
 368
 369         if (!cli_connect(&c, server_n, &ip)) {
 370                 cli_shutdown(&c);
 371                 errno = ENOENT;
 372                 return NULL;
 373         }
 374
 375         if (!cli_session_request(&c, &calling, &called)) {
 376                 cli_shutdown(&c);
 377                 if (strcmp(called.name, "*SMBSERVER")) {
 378                         make_nmb_name(&called , "*SMBSERVER", 0x20);
 379                         goto again;
 380                 }
 381                 else {  /* Try one more time, but ensure we don't loop */
 382
 383                   /* Only try this if server is an IP address ... */
 384
 385                   if (is_ipaddress(server) && !tried_reverse) {
 386                     fstring remote_name;
 387                     struct in_addr rem_ip;
 388
 389                     if (!inet_aton(server, &rem_ip)) {
 390                       DEBUG(4, ("Could not convert IP address %s to struct in_addr\n", server));
 391                       errno = ENOENT;
 392                       return NULL;
 393                     }
 394
 395                     tried_reverse++; /* Yuck */
 396
 397                     if (name_status_find("*", 0, 0, rem_ip, remote_name)) {
 398                       make_nmb_name(&called, remote_name, 0x20);
 399                       goto again;
 400                     }
 401
 402
 403                   }
 404                 }
 405                 errno = ENOENT;
 406                 return NULL;
 407         }
 408
 409         DEBUG(4,(" session request ok\n"));
 410
 411         if (!cli_negprot(&c)) {
 412                 cli_shutdown(&c);
 413                 errno = ENOENT;
 414                 return NULL;
 415         }
 416
 417         if (!cli_session_setup(&c, username,
 418                                password, strlen(password),
 419                                password, strlen(password),
 420                                workgroup) &&
 421             /* try an anonymous login if it failed */
 422             !cli_session_setup(&c, "", "", 1,"", 0, workgroup)) {
 423                 cli_shutdown(&c);
 424                 errno = EPERM;
 425                 return NULL;
 426         }
 427
 428         DEBUG(4,(" session setup ok\n"));
 429
 430         if (!cli_send_tconX(&c, share, "?????",
 431                             password, strlen(password)+1)) {
 432                 errno = smbc_errno(context, &c);
 433                 cli_shutdown(&c);
 434                 return NULL;
 435         }
 436
 437         DEBUG(4,(" tconx ok\n"));
 438
 439         /*
 440          * Ok, we have got a nice connection
 441          * Let's find a free server_fd
 442          */
 443
 444         srv = (SMBCSRV *)malloc(sizeof(*srv));
 445         if (!srv) {
 446                 errno = ENOMEM;
 447                 goto failed;
 448         }
 449
 450         ZERO_STRUCTP(srv);
 451         srv->cli = c;
 452         srv->dev = (dev_t)(str_checksum(server) ^ str_checksum(share));
 453
 454         /* now add it to the cache (internal or external) */
 455         if (context->callbacks.add_cached_srv_fn(context, srv, server, share, workgroup, username)) {
 456                 DEBUG(3, (" Failed to add server to cache\n"));
 457                 goto failed;
 458         }
 459
 460
 461         DEBUG(2, ("Server connect ok: //%s/%s: %p\n",
 462                   server, share, srv));
 463
 464         return srv;
 465
 466  failed:
 467         cli_shutdown(&c);
 468         if (!srv) return NULL;
 469
 470         SAFE_FREE(srv);
 471         return NULL;
 472 }
 473
 474 /*
 475  * Routine to open() a file ...
 476  */
 477
 478 static SMBCFILE *smbc_open_ctx(SMBCCTX *context, const char *fname, int flags, mode_t mode)
 479 {
 480         fstring server, share, user, password, workgroup;
 481         pstring path;
 482         SMBCSRV *srv   = NULL;
 483         SMBCFILE *file = NULL;
 484         int fd;
 485
 486         if (!context || !context->_initialized) {
 487
 488                 errno = EINVAL;  /* Best I can think of ... */
 489                 return NULL;
 490
 491         }
 492
 493         if (!fname) {
 494
 495                 errno = EINVAL;
 496                 return NULL;
 497
 498         }
 499
 500         smbc_parse_path(context, fname, server, share, path, user, password); /* FIXME, check errors */
 501
 502         if (user[0] == (char)0) pstrcpy(user, context->user);
 503
 504         pstrcpy(workgroup, context->workgroup);
 505
 506         srv = smbc_server(context, server, share, workgroup, user, password);
 507
 508         if (!srv) {
 509
 510                 if (errno == EPERM) errno = EACCES;
 511                 return NULL;  /* smbc_server sets errno */
 512
 513         }
 514
 515         /* Hmmm, the test for a directory is suspect here ... FIXME */
 516
 517         if (strlen(path) > 0 && path[strlen(path) - 1] == '\\') {
 518
 519                 fd = -1;
 520
 521         }
 522         else {
 523
 524                 file = malloc(sizeof(SMBCFILE));
 525
 526                 if (!file) {
 527
 528                         errno = ENOMEM;
 529                         return NULL;
 530
 531                 }
 532
 533                 ZERO_STRUCTP(file);
 534
 535                 if ((fd = cli_open(&srv->cli, path, flags, DENY_NONE)) < 0) {
 536
 537                         /* Handle the error ... */
 538
 539                         SAFE_FREE(file);
 540                         errno = smbc_errno(context, &srv->cli);
 541                         return NULL;
 542
 543                 }
 544
 545                 /* Fill in file struct */
 546
 547                 file->cli_fd  = fd;
 548                 file->fname   = strdup(fname);
 549                 file->srv     = srv;
 550                 file->offset  = 0;
 551                 file->file    = True;
 552
 553                 DLIST_ADD(context->_files, file);
 554                 return file;
 555
 556         }
 557
 558         /* Check if opendir needed ... */
 559
 560         if (fd == -1) {
 561                 int eno = 0;
 562
 563                 eno = smbc_errno(context, &srv->cli);
 564                 file = context->opendir(context, fname);
 565                 if (!file) errno = eno;
 566                 return file;
 567
 568         }
 569
 570         errno = EINVAL; /* FIXME, correct errno ? */
 571         return NULL;
 572
 573 }
 574
 575 /*
 576  * Routine to create a file
 577  */
 578
 579 static int creat_bits = O_WRONLY | O_CREAT | O_TRUNC; /* FIXME: Do we need this */
 580
 581 static SMBCFILE *smbc_creat_ctx(SMBCCTX *context, const char *path, mode_t mode)
 582 {
 583
 584         if (!context || !context->_initialized) {
 585
 586                 errno = EINVAL;
 587                 return NULL;
 588
 589         }
 590
 591         return smbc_open_ctx(context, path, creat_bits, mode);
 592 }
 593
 594 /*
 595  * Routine to read() a file ...
 596  */
 597
 598 static ssize_t smbc_read_ctx(SMBCCTX *context, SMBCFILE *file, void *buf, size_t count)
 599 {
 600         int ret;
 601
 602         if (!context || !context->_initialized) {
 603
 604                 errno = EINVAL;
 605                 return -1;
 606
 607         }
 608
 609         DEBUG(4, ("smbc_read(%p, %d)\n", file, (int)count));
 610
 611         if (!file || !DLIST_CONTAINS(context->_files, file)) {
 612
 613                 errno = EBADF;
 614                 return -1;
 615
 616         }
 617
 618         /* Check that the buffer exists ... */
 619
 620         if (buf == NULL) {
 621
 622                 errno = EINVAL;
 623                 return -1;
 624
 625         }
 626
 627         ret = cli_read(&file->srv->cli, file->cli_fd, buf, file->offset, count);
 628
 629         if (ret < 0) {
 630
 631                 errno = smbc_errno(context, &file->srv->cli);
 632                 return -1;
 633
 634         }
 635
 636         file->offset += ret;
 637
 638         DEBUG(4, ("  --> %d\n", ret));
 639
 640         return ret;  /* Success, ret bytes of data ... */
 641
 642 }
 643
 644 /*
 645  * Routine to write() a file ...
 646  */
 647
 648 static ssize_t smbc_write_ctx(SMBCCTX *context, SMBCFILE *file, void *buf, size_t count)
 649 {
 650         int ret;
 651
 652         if (!context || context->_initialized) {
 653
 654                 errno = EINVAL;
 655                 return -1;
 656
 657         }
 658
 659         if (!file || !DLIST_CONTAINS(context->_files, file)) {
 660
 661                 errno = EBADF;
 662                 return -1;
 663
 664         }
 665
 666         /* Check that the buffer exists ... */
 667
 668         if (buf == NULL) {
 669
 670                 errno = EINVAL;
 671                 return -1;
 672
 673         }
 674
 675         ret = cli_write(&file->srv->cli, file->cli_fd, 0, buf, file->offset, count);
 676
 677         if (ret <= 0) {
 678
 679                 errno = smbc_errno(context, &file->srv->cli);
 680                 return -1;
 681
 682         }
 683
 684         file->offset += ret;
 685
 686         return ret;  /* Success, 0 bytes of data ... */
 687 }
 688
 689 /*
 690  * Routine to close() a file ...
 691  */
 692
 693 static int smbc_close_ctx(SMBCCTX *context, SMBCFILE *file)
 694 {
 695         SMBCSRV *srv;
 696
 697         if (!context || !context->_initialized) {
 698
 699                 errno = EINVAL;
 700                 return -1;
 701
 702         }
 703
 704         if (!file || !DLIST_CONTAINS(context->_files, file)) {
 705
 706                 errno = EBADF;
 707                 return -1;
 708
 709         }
 710
 711         /* IS a dir ... */
 712         if (!file->file) {
 713
 714                 return context->closedir(context, file);
 715
 716         }
 717
 718         if (!cli_close(&file->srv->cli, file->cli_fd)) {
 719
 720                 DEBUG(3, ("cli_close failed on %s. purging server.\n",
 721                           file->fname));
 722                 /* Deallocate slot and remove the server
 723                  * from the server cache if unused */
 724                 errno = smbc_errno(context, &file->srv->cli);
 725                 srv = file->srv;
 726                 DLIST_REMOVE(context->_files, file);
 727                 SAFE_FREE(file->fname);
 728                 SAFE_FREE(file);
 729                 context->callbacks.remove_unused_server_fn(context, srv);
 730
 731                 return -1;
 732
 733         }
 734
 735         if (!file->file) {
 736
 737                 return context->closedir(context, file);
 738
 739         }
 740
 741         if (!cli_close(&file->srv->cli, file->cli_fd)) {
 742                 DEBUG(3, ("cli_close failed on %s. purging server.\n",
 743                           file->fname));
 744                 /* Deallocate slot and remove the server
 745                  * from the server cache if unused */
 746                 errno = smbc_errno(context, &file->srv->cli);
 747                 srv = file->srv;
 748                 DLIST_REMOVE(context->_files, file);
 749                 SAFE_FREE(file->fname);
 750                 SAFE_FREE(file);
 751                 context->callbacks.remove_unused_server_fn(context, srv);
 752
 753                 return -1;
 754         }
 755
 756         DLIST_REMOVE(context->_files, file);
 757         SAFE_FREE(file->fname);
 758         SAFE_FREE(file);
 759
 760         return 0;
 761 }
 762
 763 /*
 764  * Get info from an SMB server on a file. Use a qpathinfo call first
 765  * and if that fails, use getatr, as Win95 sometimes refuses qpathinfo
 766  */
 767 static BOOL smbc_getatr(SMBCCTX * context, SMBCSRV *srv, char *path,
 768                  uint16 *mode, size_t *size,
 769                  time_t *c_time, time_t *a_time, time_t *m_time,
 770                  SMB_INO_T *ino)
 771 {
 772
 773         if (!context || !context->_initialized) {
 774
 775                 errno = EINVAL;
 776                 return -1;
 777
 778         }
 779
 780         DEBUG(4,("smbc_getatr: sending qpathinfo\n"));
 781
 782         if (!srv->no_pathinfo2 &&
 783             cli_qpathinfo2(&srv->cli, path, c_time, a_time, m_time, NULL,
 784                            size, mode, ino)) return True;
 785
 786         /* if this is NT then don't bother with the getatr */
 787         if (srv->cli.capabilities & CAP_NT_SMBS) return False;
 788
 789         if (cli_getatr(&srv->cli, path, mode, size, m_time)) {
 790                 a_time = c_time = m_time;
 791                 srv->no_pathinfo2 = True;
 792                 return True;
 793         }
 794
 795         return False;
 796
 797 }
 798
 799 /*
 800  * Routine to unlink() a file
 801  */
 802
 803 static int smbc_unlink_ctx(SMBCCTX *context, const char *fname)
 804 {
 805         fstring server, share, user, password, workgroup;
 806         pstring path;
 807         SMBCSRV *srv = NULL;
 808
 809         if (!context || context->_initialized) {
 810
 811                 errno = EINVAL;  /* Best I can think of ... */
 812                 return -1;
 813
 814         }
 815
 816         if (!fname) {
 817
 818                 errno = EINVAL;
 819                 return -1;
 820
 821         }
 822
 823         smbc_parse_path(context, fname, server, share, path, user, password); /* FIXME, check errors */
 824
 825         if (user[0] == (char)0) pstrcpy(user, context->user);
 826
 827         pstrcpy(workgroup, context->workgroup);
 828
 829         srv = smbc_server(context, server, share, workgroup, user, password);
 830
 831         if (!srv) {
 832
 833                 return -1;  /* smbc_server sets errno */
 834
 835         }
 836
 837         /*  if (strncmp(srv->cli.dev, "LPT", 3) == 0) {
 838
 839     int job = smbc_stat_printjob(srv, path, NULL, NULL);
 840     if (job == -1) {
 841
 842       return -1;
 843
 844     }
 845     if ((err = cli_printjob_del(&srv->cli, job)) != 0) {
 846
 847
 848       return -1;
 849
 850     }
 851     } else */
 852
 853         if (!cli_unlink(&srv->cli, path)) {
 854
 855                 errno = smbc_errno(context, &srv->cli);
 856
 857                 if (errno == EACCES) { /* Check if the file is a directory */
 858
 859                         int saverr = errno;
 860                         size_t size = 0;
 861                         uint16 mode = 0;
 862                         time_t m_time = 0, a_time = 0, c_time = 0;
 863                         SMB_INO_T ino = 0;
 864
 865                         if (!smbc_getatr(context, srv, path, &mode, &size,
 866                                          &c_time, &a_time, &m_time, &ino)) {
 867
 868                                 /* Hmmm, bad error ... What? */
 869
 870                                 errno = smbc_errno(context, &srv->cli);
 871                                 return -1;
 872
 873                         }
 874                         else {
 875
 876                                 if (IS_DOS_DIR(mode))
 877                                         errno = EISDIR;
 878                                 else
 879                                         errno = saverr;  /* Restore this */
 880
 881                         }
 882                 }
 883
 884                 return -1;
 885
 886         }
 887
 888         return 0;  /* Success ... */
 889
 890 }
 891
 892 /*
 893  * Routine to rename() a file
 894  */
 895
 896 static int smbc_rename_ctx(SMBCCTX *ocontext, const char *oname,
 897                            SMBCCTX *ncontext, const char *nname)
 898 {
 899         fstring server1, share1, server2, share2, user1, user2, password1, password2, workgroup;
 900         pstring path1, path2;
 901         SMBCSRV *srv = NULL;
 902
 903         if (!ocontext || !ncontext ||
 904             !ocontext->_initialized || !ncontext->_initialized) {
 905
 906                 errno = EINVAL;  /* Best I can think of ... */
 907                 return -1;
 908
 909         }
 910
 911         if (!oname || !nname) {
 912
 913                 errno = EINVAL;
 914                 return -1;
 915
 916         }
 917
 918         DEBUG(4, ("smbc_rename(%s,%s)\n", oname, nname));
 919
 920         smbc_parse_path(ocontext, oname, server1, share1, path1, user1, password1);
 921
 922         if (user1[0] == (char)0) pstrcpy(user1, ocontext->user);
 923
 924         smbc_parse_path(ncontext, nname, server2, share2, path2, user2, password2);
 925
 926         if (user2[0] == (char)0) pstrcpy(user2, ncontext->user);
 927
 928         if (strcmp(server1, server2) || strcmp(share1, share2) ||
 929             strcmp(user1, user2)) {
 930
 931                 /* Can't rename across file systems, or users?? */
 932
 933                 errno = EXDEV;
 934                 return -1;
 935
 936         }
 937
 938         pstrcpy(workgroup, ocontext->workgroup);
 939         /* HELP !!! Which workgroup should I use ? Or are they always the same -- Tom */
 940         srv = smbc_server(ocontext, server1, share1, workgroup, user1, password1);
 941         if (!srv) {
 942
 943                 return -1;
 944
 945         }
 946
 947         if (!cli_rename(&srv->cli, path1, path2)) {
 948                 int eno = smbc_errno(ocontext, &srv->cli);
 949
 950                 if (eno != EEXIST ||
 951                     !cli_unlink(&srv->cli, path2) ||
 952                     !cli_rename(&srv->cli, path1, path2)) {
 953
 954                         errno = eno;
 955                         return -1;
 956
 957                 }
 958         }
 959
 960         return 0; /* Success */
 961
 962 }
 963
 964 /*
 965  * A routine to lseek() a file
 966  */
 967
 968 static off_t smbc_lseek_ctx(SMBCCTX *context, SMBCFILE *file, off_t offset, int whence)
 969 {
 970         size_t size;
 971
 972         if (!context || !context->_initialized) {
 973
 974                 errno = EINVAL;
 975                 return -1;
 976
 977         }
 978
 979         if (!file || !DLIST_CONTAINS(context->_files, file)) {
 980
 981                 errno = EBADF;
 982                 return -1;
 983
 984         }
 985
 986         if (!file->file) {
 987
 988                 errno = EINVAL;
 989                 return -1;      /* Can't lseek a dir ... */
 990
 991         }
 992
 993         switch (whence) {
 994         case SEEK_SET:
 995                 file->offset = offset;
 996                 break;
 997
 998         case SEEK_CUR:
 999                 file->offset += offset;
1000                 break;
1001
1002         case SEEK_END:
1003                 if (!cli_qfileinfo(&file->srv->cli, file->cli_fd, NULL, &size, NULL, NULL,
1004                                    NULL, NULL, NULL) &&
1005                     !cli_getattrE(&file->srv->cli, file->cli_fd, NULL, &size, NULL, NULL,
1006                                   NULL)) {
1007
1008                         errno = EINVAL;
1009                         return -1;
1010                 }
1011                 file->offset = size + offset;
1012                 break;
1013
1014         default:
1015                 errno = EINVAL;
1016                 break;
1017
1018         }
1019
1020         return file->offset;
1021
1022 }
1023
1024 /*
1025  * Generate an inode number from file name for those things that need it
1026  */
1027
1028 static
1029 ino_t smbc_inode(SMBCCTX *context, const char *name)
1030 {
1031
1032         if (!context || !context->_initialized) {
1033
1034                 errno = EINVAL;
1035                 return -1;
1036
1037         }
1038
1039         if (!*name) return 2; /* FIXME, why 2 ??? */
1040         return (ino_t)str_checksum(name);
1041
1042 }
1043
1044 /*
1045  * Routine to put basic stat info into a stat structure ... Used by stat and
1046  * fstat below.
1047  */
1048
1049 static
1050 int smbc_setup_stat(SMBCCTX *context, struct stat *st, char *fname, size_t size, int mode)
1051 {
1052
1053         st->st_mode = 0;
1054
1055         if (IS_DOS_DIR(mode)) {
1056                 st->st_mode = SMBC_DIR_MODE;
1057         } else {
1058                 st->st_mode = SMBC_FILE_MODE;
1059         }
1060
1061         if (IS_DOS_ARCHIVE(mode)) st->st_mode |= S_IXUSR;
1062         if (IS_DOS_SYSTEM(mode)) st->st_mode |= S_IXGRP;
1063         if (IS_DOS_HIDDEN(mode)) st->st_mode |= S_IXOTH;
1064         if (!IS_DOS_READONLY(mode)) st->st_mode |= S_IWUSR;
1065
1066         st->st_size = size;
1067         st->st_blksize = 512;
1068         st->st_blocks = (size+511)/512;
1069         st->st_uid = getuid();
1070         st->st_gid = getgid();
1071
1072         if (IS_DOS_DIR(mode)) {
1073                 st->st_nlink = 2;
1074         } else {
1075                 st->st_nlink = 1;
1076         }
1077
1078         if (st->st_ino == 0) {
1079                 st->st_ino = smbc_inode(context, fname);
1080         }
1081
1082         return True;  /* FIXME: Is this needed ? */
1083
1084 }
1085
1086 /*
1087  * Routine to stat a file given a name
1088  */
1089
1090 static int smbc_stat_ctx(SMBCCTX *context, const char *fname, struct stat *st)
1091 {
1092         SMBCSRV *srv;
1093         fstring server, share, user, password, workgroup;
1094         pstring path;
1095         time_t m_time = 0, a_time = 0, c_time = 0;
1096         size_t size = 0;
1097         uint16 mode = 0;
1098         SMB_INO_T ino = 0;
1099
1100         if (!context || !context->_initialized) {
1101
1102                 errno = EINVAL;  /* Best I can think of ... */
1103                 return -1;
1104
1105         }
1106
1107         if (!fname) {
1108
1109                 errno = EINVAL;
1110                 return -1;
1111
1112         }
1113
1114         DEBUG(4, ("smbc_stat(%s)\n", fname));
1115
1116         smbc_parse_path(context, fname, server, share, path, user, password); /*FIXME, errors*/
1117
1118         if (user[0] == (char)0) pstrcpy(user, context->user);
1119
1120         pstrcpy(workgroup, context->workgroup);
1121
1122         srv = smbc_server(context, server, share, workgroup, user, password);
1123
1124         if (!srv) {
1125
1126                 return -1;  /* errno set by smbc_server */
1127
1128         }
1129
1130         /* if (strncmp(srv->cli.dev, "IPC", 3) == 0) {
1131
1132            mode = aDIR | aRONLY;
1133
1134            }
1135            else if (strncmp(srv->cli.dev, "LPT", 3) == 0) {
1136
1137            if (strcmp(path, "\\") == 0) {
1138
1139            mode = aDIR | aRONLY;
1140
1141            }
1142            else {
1143
1144            mode = aRONLY;
1145            smbc_stat_printjob(srv, path, &size, &m_time);
1146            c_time = a_time = m_time;
1147
1148            }
1149            else { */
1150
1151         if (!smbc_getatr(context, srv, path, &mode, &size,
1152                          &c_time, &a_time, &m_time, &ino)) {
1153
1154                 errno = smbc_errno(context, &srv->cli);
1155                 return -1;
1156
1157         }
1158
1159         st->st_ino = ino;
1160
1161         smbc_setup_stat(context, st, path, size, mode);
1162
1163         st->st_atime = a_time;
1164         st->st_ctime = c_time;
1165         st->st_mtime = m_time;
1166         st->st_dev   = srv->dev;
1167
1168         return 0;
1169
1170 }
1171
1172 /*
1173  * Routine to stat a file given an fd
1174  */
1175
1176 static int smbc_fstat_ctx(SMBCCTX *context, SMBCFILE *file, struct stat *st)
1177 {
1178         time_t c_time, a_time, m_time;
1179         size_t size;
1180         uint16 mode;
1181         SMB_INO_T ino = 0;
1182
1183         if (!context || !context->_initialized) {
1184
1185                 errno = EINVAL;
1186                 return -1;
1187
1188         }
1189
1190         if (!file || !DLIST_CONTAINS(context->_files, file)) {
1191
1192                 errno = EBADF;
1193                 return -1;
1194
1195         }
1196
1197         if (!file->file) {
1198
1199                 return context->fstatdir(context, file, st);
1200
1201         }
1202
1203         if (!cli_qfileinfo(&file->srv->cli, file->cli_fd,
1204                            &mode, &size, &c_time, &a_time, &m_time, NULL, &ino) &&
1205             !cli_getattrE(&file->srv->cli, file->cli_fd,
1206                           &mode, &size, &c_time, &a_time, &m_time)) {
1207
1208                 errno = EINVAL;
1209                 return -1;
1210
1211         }
1212
1213         st->st_ino = ino;
1214
1215         smbc_setup_stat(context, st, file->fname, size, mode);
1216
1217         st->st_atime = a_time;
1218         st->st_ctime = c_time;
1219         st->st_mtime = m_time;
1220         st->st_dev = file->srv->dev;
1221
1222         return 0;
1223
1224 }
1225
1226 /*
1227  * Routine to open a directory
1228  *
1229  * We want to allow:
1230  *
1231  * smb: which should list all the workgroups available
1232  * smb:workgroup
1233  * smb:workgroup//server
1234  * smb://server
1235  * smb://server/share
1236  * smb://<IP-addr> which should list shares on server
1237  * smb://<IP-addr>/share which should list files on share
1238  */
1239
1240 static void smbc_remove_dir(SMBCFILE *dir)
1241 {
1242         struct smbc_dir_list *d,*f;
1243
1244         d = dir->dir_list;
1245         while (d) {
1246
1247                 f = d; d = d->next;
1248
1249                 SAFE_FREE(f->dirent);
1250                 SAFE_FREE(f);
1251
1252         }
1253
1254         dir->dir_list = dir->dir_end = dir->dir_next = NULL;
1255
1256 }
1257
1258 static int add_dirent(SMBCFILE *dir, const char *name, const char *comment, uint32 type)
1259 {
1260         struct smbc_dirent *dirent;
1261         int size;
1262
1263         /*
1264          * Allocate space for the dirent, which must be increased by the
1265          * size of the name and the comment and 1 for the null on the comment.
1266          * The null on the name is already accounted for.
1267          */
1268
1269         size = sizeof(struct smbc_dirent) + (name?strlen(name):0) +
1270                 (comment?strlen(comment):0) + 1;
1271
1272         dirent = malloc(size);
1273
1274         if (!dirent) {
1275
1276                 dir->dir_error = ENOMEM;
1277                 return -1;
1278
1279         }
1280
1281         ZERO_STRUCTP(dirent);
1282
1283         ZERO_STRUCTP(dirent);
1284
1285
1286         if (dir->dir_list == NULL) {
1287
1288                 dir->dir_list = malloc(sizeof(struct smbc_dir_list));
1289                 if (!dir->dir_list) {
1290
1291                         SAFE_FREE(dirent);
1292                         dir->dir_error = ENOMEM;
1293                         return -1;
1294
1295                 }
1296                 ZERO_STRUCTP(dir->dir_list);
1297
1298                 dir->dir_end = dir->dir_next = dir->dir_list;
1299
1300         }
1301         else {
1302
1303                 dir->dir_end->next = malloc(sizeof(struct smbc_dir_list));
1304
1305                 if (!dir->dir_end->next) {
1306
1307                         SAFE_FREE(dirent);
1308                         dir->dir_error = ENOMEM;
1309                         return -1;
1310
1311                 }
1312                 ZERO_STRUCTP(dir->dir_end->next);
1313
1314                 dir->dir_end = dir->dir_end->next;
1315
1316         }
1317
1318         dir->dir_end->next = NULL;
1319         dir->dir_end->dirent = dirent;
1320
1321         dirent->smbc_type = type;
1322         dirent->namelen = (name?strlen(name):0);
1323         dirent->commentlen = (comment?strlen(comment):0);
1324         dirent->dirlen = size;
1325
1326         strncpy(dirent->name, (name?name:""), dirent->namelen + 1);
1327
1328         dirent->comment = (char *)(&dirent->name + dirent->namelen + 1);
1329         strncpy(dirent->comment, (comment?comment:""), dirent->commentlen + 1);
1330
1331         return 0;
1332
1333 }
1334
1335 static void
1336 list_fn(const char *name, uint32 type, const char *comment, void *state)
1337 {
1338         SMBCFILE *dir = (SMBCFILE *)state;
1339         int dirent_type;
1340
1341         /* We need to process the type a little ... */
1342
1343         if (dir->dir_type == SMBC_FILE_SHARE) {
1344
1345                 switch (type) {
1346                 case 0: /* Directory tree */
1347                         dirent_type = SMBC_FILE_SHARE;
1348                         break;
1349
1350                 case 1:
1351                         dirent_type = SMBC_PRINTER_SHARE;
1352                         break;
1353
1354                 case 2:
1355                         dirent_type = SMBC_COMMS_SHARE;
1356                         break;
1357
1358                 case 3:
1359                         dirent_type = SMBC_IPC_SHARE;
1360                         break;
1361
1362                 default:
1363                         dirent_type = SMBC_FILE_SHARE; /* FIXME, error? */
1364                         break;
1365                 }
1366                 ZERO_STRUCTP(dir->dir_list);
1367
1368         }
1369         else dirent_type = dir->dir_type;
1370
1371         if (add_dirent(dir, name, comment, dirent_type) < 0) {
1372
1373                 /* An error occurred, what do we do? */
1374                 /* FIXME: Add some code here */
1375
1376         }
1377
1378 }
1379
1380 static void
1381 dir_list_fn(file_info *finfo, const char *mask, void *state)
1382 {
1383
1384         if (add_dirent((SMBCFILE *)state, finfo->name, "",
1385                        (finfo->mode&aDIR?SMBC_DIR:SMBC_FILE)) < 0) {
1386
1387                 /* Handle an error ... */
1388
1389                 /* FIXME: Add some code ... */
1390
1391         }
1392
1393 }
1394
1395 static SMBCFILE *smbc_opendir_ctx(SMBCCTX *context, const char *fname)
1396 {
1397         fstring server, share, user, password, workgroup;
1398         pstring path;
1399         SMBCSRV *srv  = NULL;
1400         SMBCFILE *dir = NULL;
1401         struct in_addr rem_ip;
1402         int slot = 0;
1403
1404         if (!context || !context->_initialized) {
1405
1406                 errno = EINVAL;
1407                 return NULL;
1408
1409         }
1410
1411         if (!fname) {
1412
1413                 errno = EINVAL;
1414                 return NULL;
1415
1416         }
1417
1418         if (smbc_parse_path(context, fname, server, share, path, user, password)) {
1419
1420                 errno = EINVAL;
1421                 return NULL;
1422
1423         }
1424
1425         if (user[0] == (char)0) pstrcpy(user, context->user);
1426
1427         pstrcpy(workgroup, context->workgroup);
1428
1429         dir = malloc(sizeof(*dir));
1430
1431         if (!dir) {
1432
1433                 errno = ENOMEM;
1434                 return NULL;
1435
1436         }
1437
1438         ZERO_STRUCTP(dir);
1439
1440         dir->cli_fd   = 0;
1441         dir->fname    = strdup(fname);
1442         dir->srv      = NULL;
1443         dir->offset   = 0;
1444         dir->file     = False;
1445         dir->dir_list = dir->dir_next = dir->dir_end = NULL;
1446
1447         if (server[0] == (char)0) {
1448
1449                 if (share[0] != (char)0 || path[0] != (char)0) {
1450
1451                         errno = EINVAL;
1452                         if (dir) {
1453                                 SAFE_FREE(dir->fname);
1454                                 SAFE_FREE(dir);
1455                         }
1456                         return NULL;
1457
1458                 }
1459
1460                 /* We have server and share and path empty ... so list the workgroups */
1461                 /* first try to get the LMB for our workgroup, and if that fails,     */
1462                 /* try the DMB                                                        */
1463
1464                 if (!(resolve_name(context->workgroup, &rem_ip, 0x1d) ||
1465                       resolve_name(context->workgroup, &rem_ip, 0x1b))) {
1466
1467                         errno = EINVAL;  /* Something wrong with smb.conf? */
1468                         return NULL;
1469
1470                 }
1471
1472                 dir->dir_type = SMBC_WORKGROUP;
1473
1474                 /* find the name of the server ... */
1475
1476                 if (!name_status_find("*", 0, 0, rem_ip, server)) {
1477
1478                         DEBUG(0,("Could not get the name of local/domain master browser for server %s\n", server));
1479                         errno = EINVAL;
1480                         return NULL;
1481
1482                 }
1483
1484                 /*
1485                  * Get a connection to IPC$ on the server if we do not already have one
1486                  */
1487
1488                 srv = smbc_server(context, server, "IPC$", workgroup, user, password);
1489
1490                 if (!srv) {
1491
1492                         if (dir) {
1493                                 SAFE_FREE(dir->fname);
1494                                 SAFE_FREE(dir);
1495                         }
1496
1497                         return NULL;
1498
1499                 }
1500                 ZERO_STRUCTP(dir->dir_end);
1501
1502                 dir->srv = srv;
1503
1504                 /* Now, list the stuff ... */
1505
1506                 if (!cli_NetServerEnum(&srv->cli, workgroup, 0x80000000, list_fn,
1507                                        (void *)dir)) {
1508
1509                         if (dir) {
1510                                 SAFE_FREE(dir->fname);
1511                                 SAFE_FREE(dir);
1512                         }
1513                         errno = cli_errno(&srv->cli);
1514
1515                         return NULL;
1516
1517                 }
1518         }
1519         else { /* Server not an empty string ... Check the rest and see what gives */
1520
1521                 if (share[0] == (char)0) {
1522
1523                         if (path[0] != (char)0) { /* Should not have empty share with path */
1524
1525                                 errno = EINVAL;
1526                                 if (dir) {
1527                                         SAFE_FREE(dir->fname);
1528                                         SAFE_FREE(dir);
1529                                 }
1530                                 return NULL;
1531
1532                         }
1533
1534                         /* Check to see if <server><1D>, <server><1B>, or <server><20> translates */
1535                         /* However, we check to see if <server> is an IP address first */
1536
1537                         if (!is_ipaddress(server) &&  /* Not an IP addr so check next */
1538                             (resolve_name(server, &rem_ip, 0x1d) ||   /* Found LMB */
1539                                     resolve_name(server, &rem_ip, 0x1b) )) { /* Found DMB */
1540                                 pstring buserver;
1541
1542                                 dir->dir_type = SMBC_SERVER;
1543
1544                                 /*
1545                                  * Get the backup list ...
1546                                  */
1547
1548
1549                                 if (!name_status_find("*", 0, 0, rem_ip, buserver)) {
1550
1551                                         DEBUG(0, ("Could not get name of local/domain master browser for server %s\n", server));
1552                                         errno = EPERM;  /* FIXME, is this correct */
1553                                         return NULL;
1554
1555                                 }
1556
1557                                 /*
1558                                  * Get a connection to IPC$ on the server if we do not already have one
1559                                  */
1560
1561                                 srv = smbc_server(context, buserver, "IPC$", workgroup, user, password);
1562
1563                                 if (!srv) {
1564
1565                                         if (dir) {
1566                                                 SAFE_FREE(dir->fname);
1567                                                 SAFE_FREE(dir);
1568                                         }
1569                                         return NULL;
1570
1571                                 }
1572
1573                                 dir->srv = srv;
1574
1575                                 /* Now, list the servers ... */
1576
1577                                 if (!cli_NetServerEnum(&srv->cli, server, 0x0000FFFE, list_fn,
1578                                                        (void *)dir)) {
1579
1580                                         if (dir) {
1581                                                 SAFE_FREE(dir->fname);
1582                                                 SAFE_FREE(dir);
1583                                         }
1584                                         errno = cli_errno(&srv->cli);
1585                                         return NULL;
1586
1587                                 }
1588
1589                         }
1590                         else {
1591
1592                                 if (resolve_name(server, &rem_ip, 0x20)) {
1593
1594                                         /* Now, list the shares ... */
1595
1596                                         dir->dir_type = SMBC_FILE_SHARE;
1597
1598                                         srv = smbc_server(context, server, "IPC$", workgroup, user, password);
1599
1600                                         if (!srv) {
1601
1602                                                 if (dir) {
1603                                                         SAFE_FREE(dir->fname);
1604                                                         SAFE_FREE(dir);
1605                                                 }
1606                                                 return NULL;
1607
1608                                         }
1609
1610                                         dir->srv = srv;
1611
1612                                         /* Now, list the servers ... */
1613
1614                                         if (cli_RNetShareEnum(&srv->cli, list_fn,
1615                                                               (void *)dir) < 0) {
1616
1617                                                 errno = cli_errno(&srv->cli);
1618                                                 if (dir) {
1619                                                         SAFE_FREE(dir->fname);
1620                                                         SAFE_FREE(dir);
1621                                                 }
1622                                                 return NULL;
1623
1624                                         }
1625
1626                                 }
1627                                 else {
1628
1629                                         errno = ENODEV;   /* Neither the workgroup nor server exists */
1630                                         if (dir) {
1631                                                 SAFE_FREE(dir->fname);
1632                                                 SAFE_FREE(dir);
1633                                         }
1634                                         return NULL;
1635
1636                                 }
1637
1638                         }
1639
1640                 }
1641                 else { /* The server and share are specified ... work from there ... */
1642
1643                         /* Well, we connect to the server and list the directory */
1644
1645                         dir->dir_type = SMBC_FILE_SHARE;
1646
1647                         srv = smbc_server(context, server, share, workgroup, user, password);
1648
1649                         if (!srv) {
1650
1651                                 if (dir) {
1652                                         SAFE_FREE(dir->fname);
1653                                         SAFE_FREE(dir);
1654                                 }
1655                                 return NULL;
1656
1657                         }
1658
1659                         dir->srv = srv;
1660
1661                         /* Now, list the files ... */
1662
1663                         pstrcat(path, "\\*");
1664
1665                         if (cli_list(&srv->cli, path, aDIR | aSYSTEM | aHIDDEN, dir_list_fn,
1666                                      (void *)dir) < 0) {
1667
1668                                 if (dir) {
1669                                         SAFE_FREE(dir->fname);
1670                                         SAFE_FREE(dir);
1671                                 }
1672                                 errno = smbc_errno(context, &srv->cli);
1673                                 return NULL;
1674
1675                         }
1676                 }
1677
1678         }
1679
1680         DLIST_ADD(context->_files, dir);
1681         return dir;
1682
1683 }
1684
1685 /*
1686  * Routine to close a directory
1687  */
1688
1689 static int smbc_closedir_ctx(SMBCCTX *context, SMBCFILE *dir)
1690 {
1691
1692         if (!context || !context->_initialized) {
1693
1694                 errno = EINVAL;
1695                 return -1;
1696
1697         }
1698
1699         if (!dir || !DLIST_CONTAINS(context->_files, dir)) {
1700
1701                 errno = EBADF;
1702                 return -1;
1703
1704         }
1705
1706         smbc_remove_dir(dir); /* Clean it up */
1707
1708         DLIST_REMOVE(context->_files, dir);
1709
1710         if (dir) {
1711
1712                 SAFE_FREE(dir->fname);
1713                 SAFE_FREE(dir);    /* Free the space too */
1714
1715         }
1716
1717         return 0;
1718
1719 }
1720
1721 /*
1722  * Routine to get a directory entry
1723  */
1724
1725 struct smbc_dirent *smbc_readdir_ctx(SMBCCTX *context, SMBCFILE *dir)
1726 {
1727         struct smbc_dirent *dirp, *dirent;
1728
1729         /* Check that all is ok first ... */
1730
1731         if (!context || !context->_initialized) {
1732
1733                 errno = EINVAL;
1734                 return NULL;
1735
1736         }
1737
1738         if (!dir || !DLIST_CONTAINS(context->_files, dir)) {
1739
1740                 errno = EBADF;
1741                 return NULL;
1742
1743         }
1744
1745         if (dir->file != False) { /* FIXME, should be dir, perhaps */
1746
1747                 errno = ENOTDIR;
1748                 return NULL;
1749
1750         }
1751
1752         if (!dir->dir_next)
1753                 return NULL;
1754         else {
1755
1756                 dirent = dir->dir_next->dirent;
1757
1758                 if (!dirent) {
1759
1760                         errno = ENOENT;
1761                         return NULL;
1762
1763                 }
1764
1765                 /* Hmmm, do I even need to copy it? */
1766
1767                 memcpy(context->_dirent, dirent, dirent->dirlen); /* Copy the dirent */
1768                 dirp = (struct smbc_dirent *)context->_dirent;
1769                 dirp->comment = (char *)(&dirp->name + dirent->namelen + 1);
1770                 dir->dir_next = dir->dir_next->next;
1771
1772                 return (struct smbc_dirent *)context->_dirent;
1773         }
1774
1775 }
1776
1777 /*
1778  * Routine to get directory entries
1779  */
1780
1781 static int smbc_getdents_ctx(SMBCCTX *context, SMBCFILE *dir, struct smbc_dirent *dirp, int count)
1782 {
1783         struct smbc_dir_list *dirlist;
1784         int rem = count, reqd;
1785         char *ndir = (char *)dirp;
1786
1787         /* Check that all is ok first ... */
1788
1789         if (!context || !context->_initialized) {
1790
1791                 errno = EINVAL;
1792                 return -1;
1793
1794         }
1795
1796         if (!dir || !DLIST_CONTAINS(context->_files, dir)) {
1797
1798                 errno = EBADF;
1799                 return -1;
1800
1801         }
1802
1803         if (dir->file != False) { /* FIXME, should be dir, perhaps */
1804
1805                 errno = ENOTDIR;
1806                 return -1;
1807
1808         }
1809
1810         /*
1811          * Now, retrieve the number of entries that will fit in what was passed
1812          * We have to figure out if the info is in the list, or we need to
1813          * send a request to the server to get the info.
1814          */
1815
1816         while ((dirlist = dir->dir_next)) {
1817                 struct smbc_dirent *dirent;
1818
1819                 if (!dirlist->dirent) {
1820
1821                         errno = ENOENT;  /* Bad error */
1822                         return -1;
1823
1824                 }
1825
1826                 if (rem < (reqd = (sizeof(struct smbc_dirent) + dirlist->dirent->namelen +
1827                                    dirlist->dirent->commentlen + 1))) {
1828
1829                         if (rem < count) { /* We managed to copy something */
1830
1831                                 errno = 0;
1832                                 return count - rem;
1833
1834                         }
1835                         else { /* Nothing copied ... */
1836
1837                                 errno = EINVAL;  /* Not enough space ... */
1838                                 return -1;
1839
1840                         }
1841
1842                 }
1843
1844                 dirent = dirlist->dirent;
1845
1846                 memcpy(ndir, dirent, reqd); /* Copy the data in ... */
1847
1848                 ((struct smbc_dirent *)ndir)->comment =
1849                         (char *)(&((struct smbc_dirent *)ndir)->name + dirent->namelen + 1);
1850
1851                 ndir += reqd;
1852
1853                 rem -= reqd;
1854
1855                 dir->dir_next = dirlist = dirlist -> next;
1856         }
1857
1858         if (rem == count)
1859                 return 0;
1860         else
1861                 return count - rem;
1862
1863 }
1864
1865 /*
1866  * Routine to create a directory ...
1867  */
1868
1869 static int smbc_mkdir_ctx(SMBCCTX *context, const char *fname, mode_t mode)
1870 {
1871         SMBCSRV *srv;
1872         fstring server, share, user, password, workgroup;
1873         pstring path;
1874
1875         if (!context || !context->_initialized) {
1876
1877                 errno = EINVAL;
1878                 return -1;
1879
1880         }
1881
1882         if (!fname) {
1883
1884                 errno = EINVAL;
1885                 return -1;
1886
1887         }
1888
1889         DEBUG(4, ("smbc_mkdir(%s)\n", fname));
1890
1891         smbc_parse_path(context, fname, server, share, path, user, password); /*FIXME, errors*/
1892
1893         if (user[0] == (char)0) pstrcpy(user, context->user);
1894
1895         pstrcpy(workgroup, context->workgroup);
1896
1897         srv = smbc_server(context, server, share, workgroup, user, password);
1898
1899         if (!srv) {
1900
1901                 return -1;  /* errno set by smbc_server */
1902
1903         }
1904
1905         /* if (strncmp(srv->cli.dev, "IPC", 3) == 0) {
1906
1907            mode = aDIR | aRONLY;
1908
1909            }
1910            else if (strncmp(srv->cli.dev, "LPT", 3) == 0) {
1911
1912            if (strcmp(path, "\\") == 0) {
1913
1914            mode = aDIR | aRONLY;
1915
1916            }
1917            else {
1918
1919            mode = aRONLY;
1920            smbc_stat_printjob(srv, path, &size, &m_time);
1921            c_time = a_time = m_time;
1922
1923            }
1924            else { */
1925
1926         if (!cli_mkdir(&srv->cli, path)) {
1927
1928                 errno = smbc_errno(context, &srv->cli);
1929                 return -1;
1930
1931         }
1932
1933         return 0;
1934
1935 }
1936
1937 /*
1938  * Our list function simply checks to see if a directory is not empty
1939  */
1940
1941 static int smbc_rmdir_dirempty = True;
1942
1943 static void rmdir_list_fn(file_info *finfo, const char *mask, void *state)
1944 {
1945
1946         if (strncmp(finfo->name, ".", 1) != 0 && strncmp(finfo->name, "..", 2) != 0)
1947                 smbc_rmdir_dirempty = False;
1948
1949 }
1950
1951 /*
1952  * Routine to remove a directory
1953  */
1954
1955 static int smbc_rmdir_ctx(SMBCCTX *context, const char *fname)
1956 {
1957         SMBCSRV *srv;
1958         fstring server, share, user, password, workgroup;
1959         pstring path;
1960
1961         if (!context || !context->_initialized) {
1962
1963                 errno = EINVAL;
1964                 return -1;
1965
1966         }
1967
1968         if (!fname) {
1969
1970                 errno = EINVAL;
1971                 return -1;
1972
1973         }
1974
1975         DEBUG(4, ("smbc_rmdir(%s)\n", fname));
1976
1977         smbc_parse_path(context, fname, server, share, path, user, password); /*FIXME, errors*/
1978
1979         if (user[0] == (char)0) pstrcpy(user, context->user);
1980
1981         pstrcpy(workgroup, context->workgroup);
1982
1983         srv = smbc_server(context, server, share, workgroup, user, password);
1984
1985         if (!srv) {
1986
1987                 return -1;  /* errno set by smbc_server */
1988
1989         }
1990
1991         /* if (strncmp(srv->cli.dev, "IPC", 3) == 0) {
1992
1993            mode = aDIR | aRONLY;
1994
1995            }
1996            else if (strncmp(srv->cli.dev, "LPT", 3) == 0) {
1997
1998            if (strcmp(path, "\\") == 0) {
1999
2000            mode = aDIR | aRONLY;
2001
2002            }
2003            else {
2004
2005            mode = aRONLY;
2006            smbc_stat_printjob(srv, path, &size, &m_time);
2007            c_time = a_time = m_time;
2008
2009            }
2010            else { */
2011
2012         if (!cli_rmdir(&srv->cli, path)) {
2013
2014                 errno = smbc_errno(context, &srv->cli);
2015
2016                 if (errno == EACCES) {  /* Check if the dir empty or not */
2017
2018                         pstring lpath; /* Local storage to avoid buffer overflows */
2019
2020                         smbc_rmdir_dirempty = True;  /* Make this so ... */
2021
2022                         pstrcpy(lpath, path);
2023                         pstrcat(lpath, "\\*");
2024
2025                         if (cli_list(&srv->cli, lpath, aDIR | aSYSTEM | aHIDDEN, rmdir_list_fn,
2026                                      NULL) < 0) {
2027
2028                                 /* Fix errno to ignore latest error ... */
2029
2030                                 DEBUG(5, ("smbc_rmdir: cli_list returned an error: %d\n",
2031                                           smbc_errno(context, &srv->cli)));
2032                                 errno = EACCES;
2033
2034                         }
2035
2036                         if (smbc_rmdir_dirempty)
2037                                 errno = EACCES;
2038                         else
2039                                 errno = ENOTEMPTY;
2040
2041                 }
2042
2043                 return -1;
2044
2045         }
2046
2047         return 0;
2048
2049 }
2050
2051 /*
2052  * Routine to return the current directory position
2053  */
2054
2055 static off_t smbc_telldir_ctx(SMBCCTX *context, SMBCFILE *dir)
2056 {
2057
2058         if (!context || !context->_initialized) {
2059
2060                 errno = EINVAL;
2061                 return -1;
2062
2063         }
2064
2065         if (!dir || !DLIST_CONTAINS(context->_files, dir)) {
2066
2067                 errno = EBADF;
2068                 return -1;
2069
2070         }
2071
2072         if (dir->file != False) { /* FIXME, should be dir, perhaps */
2073
2074                 errno = ENOTDIR;
2075                 return -1;
2076
2077         }
2078
2079         return (off_t) dir->dir_next;
2080
2081 }
2082
2083 /*
2084  * A routine to run down the list and see if the entry is OK
2085  */
2086
2087 struct smbc_dir_list *smbc_check_dir_ent(struct smbc_dir_list *list,
2088                                          struct smbc_dirent *dirent)
2089 {
2090
2091         /* Run down the list looking for what we want */
2092
2093         if (dirent) {
2094
2095                 struct smbc_dir_list *tmp = list;
2096
2097                 while (tmp) {
2098
2099                         if (tmp->dirent == dirent)
2100                                 return tmp;
2101
2102                         tmp = tmp->next;
2103
2104                 }
2105
2106         }
2107
2108         return NULL;  /* Not found, or an error */
2109
2110 }
2111
2112
2113 /*
2114  * Routine to seek on a directory
2115  */
2116
2117 static int smbc_lseekdir_ctx(SMBCCTX *context, SMBCFILE *dir, off_t offset)
2118 {
2119         struct smbc_dirent *dirent = (struct smbc_dirent *)offset;
2120         struct smbc_dir_list *list_ent = NULL;
2121
2122         if (!context || !context->_initialized) {
2123
2124                 errno = EINVAL;
2125                 return -1;
2126
2127         }
2128
2129         if (dir->file != False) { /* FIXME, should be dir, perhaps */
2130
2131                 errno = ENOTDIR;
2132                 return -1;
2133
2134         }
2135
2136         /* Now, check what we were passed and see if it is OK ... */
2137
2138         if (dirent == NULL) {  /* Seek to the begining of the list */
2139
2140                 dir->dir_next = dir->dir_list;
2141                 return 0;
2142
2143         }
2144
2145         /* Now, run down the list and make sure that the entry is OK       */
2146         /* This may need to be changed if we change the format of the list */
2147
2148         if ((list_ent = smbc_check_dir_ent(dir->dir_list, dirent)) == NULL) {
2149
2150                 errno = EINVAL;   /* Bad entry */
2151                 return -1;
2152
2153         }
2154
2155         dir->dir_next = list_ent;
2156
2157         return 0;
2158
2159 }
2160
2161 /*
2162  * Routine to fstat a dir
2163  */
2164
2165 static int smbc_fstatdir_ctx(SMBCCTX *context, SMBCFILE *dir, struct stat *st)
2166 {
2167
2168         if (context || !context->_initialized) {
2169
2170                 errno = EINVAL;
2171                 return -1;
2172
2173         }
2174
2175         /* No code yet ... */
2176
2177         return 0;
2178
2179 }
2180
2181 /*
2182  * Open a print file to be written to by other calls
2183  */
2184
2185 static SMBCFILE *smbc_open_print_job_ctx(SMBCCTX *context, const char *fname)
2186 {
2187         fstring server, share, user, password;
2188         pstring path;
2189
2190         if (!context || context->_initialized) {
2191
2192                 errno = EINVAL;
2193                 return NULL;
2194
2195         }
2196
2197         if (!fname) {
2198
2199                 errno = EINVAL;
2200                 return NULL;
2201
2202         }
2203
2204         DEBUG(4, ("smbc_open_print_job_ctx(%s)\n", fname));
2205
2206         smbc_parse_path(context, fname, server, share, path, user, password); /*FIXME, errors*/
2207
2208         /* What if the path is empty, or the file exists? */
2209
2210         return context->open(context, fname, O_WRONLY, 666);
2211
2212 }
2213
2214 /*
2215  * Routine to print a file on a remote server ...
2216  *
2217  * We open the file, which we assume to be on a remote server, and then
2218  * copy it to a print file on the share specified by printq.
2219  */
2220
2221 static int smbc_print_file_ctx(SMBCCTX *c_file, const char *fname, SMBCCTX *c_print, const char *printq)
2222 {
2223         SMBCFILE *fid1, *fid2;
2224         int bytes, saverr, tot_bytes = 0;
2225         char buf[4096];
2226
2227         if (!c_file || !c_file->_initialized || !c_print ||
2228             !c_print->_initialized) {
2229
2230                 errno = EINVAL;
2231                 return -1;
2232
2233         }
2234
2235         if (!fname && !printq) {
2236
2237                 errno = EINVAL;
2238                 return -1;
2239
2240         }
2241
2242         /* Try to open the file for reading ... */
2243
2244         if ((fid1 = c_file->open(c_file, fname, O_RDONLY, 0666)) < 0) {
2245
2246                 DEBUG(3, ("Error, fname=%s, errno=%i\n", fname, errno));
2247                 return -1;  /* smbc_open sets errno */
2248
2249         }
2250
2251         /* Now, try to open the printer file for writing */
2252
2253         if ((fid2 = c_print->open_print_job(c_print, printq)) < 0) {
2254
2255                 saverr = errno;  /* Save errno */
2256                 c_file->close(c_file, fid1);
2257                 errno = saverr;
2258                 return -1;
2259
2260         }
2261
2262         while ((bytes = c_file->read(c_file, fid1, buf, sizeof(buf))) > 0) {
2263
2264                 tot_bytes += bytes;
2265
2266                 if ((c_print->write(c_print, fid2, buf, bytes)) < 0) {
2267
2268                         saverr = errno;
2269                         c_file->close(c_file, fid1);
2270                         c_print->close(c_print, fid2);
2271                         errno = saverr;
2272
2273                 }
2274
2275         }
2276
2277         saverr = errno;
2278
2279         c_file->close(c_file, fid1);  /* We have to close these anyway */
2280         c_print->close(c_print, fid2);
2281
2282         if (bytes < 0) {
2283
2284                 errno = saverr;
2285                 return -1;
2286
2287         }
2288
2289         return tot_bytes;
2290
2291 }
2292
2293 /*
2294  * Routine to list print jobs on a printer share ...
2295  */
2296
2297 static int smbc_list_print_jobs_ctx(SMBCCTX *context, const char *fname, void (*fn)(struct print_job_info *))
2298 {
2299         SMBCSRV *srv;
2300         fstring server, share, user, password, workgroup;
2301         pstring path;
2302
2303         if (!context || !context->_initialized) {
2304
2305                 errno = EINVAL;
2306                 return -1;
2307
2308         }
2309
2310         if (!fname) {
2311
2312                 errno = EINVAL;
2313                 return -1;
2314
2315         }
2316
2317         DEBUG(4, ("smbc_list_print_jobs(%s)\n", fname));
2318
2319         smbc_parse_path(context, fname, server, share, path, user, password); /*FIXME, errors*/
2320
2321         if (user[0] == (char)0) pstrcpy(user, context->user);
2322
2323         pstrcpy(workgroup, context->workgroup);
2324
2325         srv = smbc_server(context, server, share, workgroup, user, password);
2326
2327         if (!srv) {
2328
2329                 return -1;  /* errno set by smbc_server */
2330
2331         }
2332
2333         if (cli_print_queue(&srv->cli, fn) < 0) {
2334
2335                 errno = smbc_errno(context, &srv->cli);
2336                 return -1;
2337
2338         }
2339
2340         return 0;
2341
2342 }
2343
2344 /*
2345  * Delete a print job from a remote printer share
2346  */
2347
2348 static int smbc_unlink_print_job_ctx(SMBCCTX *context, const char *fname, int id)
2349 {
2350         SMBCSRV *srv;
2351         fstring server, share, user, password, workgroup;
2352         pstring path;
2353         int err;
2354
2355         if (!context || !context->_initialized) {
2356
2357                 errno = EINVAL;
2358                 return -1;
2359
2360         }
2361
2362         if (!fname) {
2363
2364                 errno = EINVAL;
2365                 return -1;
2366
2367         }
2368
2369         DEBUG(4, ("smbc_unlink_print_job(%s)\n", fname));
2370
2371         smbc_parse_path(context, fname, server, share, path, user, password); /*FIXME, errors*/
2372
2373         if (user[0] == (char)0) pstrcpy(user, context->user);
2374
2375         pstrcpy(workgroup, context->workgroup);
2376
2377         srv = smbc_server(context, server, share, workgroup, user, password);
2378
2379         if (!srv) {
2380
2381                 return -1;  /* errno set by smbc_server */
2382
2383         }
2384
2385         if ((err = cli_printjob_del(&srv->cli, id)) != 0) {
2386
2387                 if (err < 0)
2388                         errno = smbc_errno(context, &srv->cli);
2389                 else if (err == ERRnosuchprintjob)
2390                         errno = EINVAL;
2391                 return -1;
2392
2393         }
2394
2395         return 0;
2396
2397 }
2398
2399 /*
2400  * Get a new empty handle to fill in with your own info
2401  */
2402 SMBCCTX * smbc_new_context(void)
2403 {
2404         SMBCCTX * context;
2405
2406         context = malloc(sizeof(*context));
2407         if (!context) {
2408                 errno = ENOMEM;
2409                 return NULL;
2410         }
2411
2412         ZERO_STRUCTP(context);
2413
2414         /* ADD REASONABLE DEFAULTS */
2415         context->debug            = 0;
2416         context->timeout          = 20000; /* 20 seconds */
2417
2418         context->open             = smbc_open_ctx;
2419         context->creat            = smbc_creat_ctx;
2420         context->read             = smbc_read_ctx;
2421         context->write            = smbc_write_ctx;
2422         context->close            = smbc_close_ctx;
2423         context->unlink           = smbc_unlink_ctx;
2424         context->rename           = smbc_rename_ctx;
2425         context->lseek            = smbc_lseek_ctx;
2426         context->stat             = smbc_stat_ctx;
2427         context->fstat            = smbc_fstat_ctx;
2428         context->opendir          = smbc_opendir_ctx;
2429         context->closedir         = smbc_closedir_ctx;
2430         context->readdir          = smbc_readdir_ctx;
2431         context->getdents         = smbc_getdents_ctx;
2432         context->mkdir            = smbc_mkdir_ctx;
2433         context->rmdir            = smbc_rmdir_ctx;
2434         context->telldir          = smbc_telldir_ctx;
2435         context->lseekdir         = smbc_lseekdir_ctx;
2436         context->fstatdir         = smbc_fstatdir_ctx;
2437         context->open_print_job   = smbc_open_print_job_ctx;
2438         context->print_file       = smbc_print_file_ctx;
2439         context->list_print_jobs  = smbc_list_print_jobs_ctx;
2440         context->unlink_print_job = smbc_unlink_print_job_ctx;
2441
2442         context->callbacks.check_server_fn      = smbc_check_server;
2443         context->callbacks.remove_unused_server_fn = smbc_remove_unused_server;
2444
2445         smbc_default_cache_functions(context);
2446
2447         return context;
2448 }
2449
2450 /*
2451  * Free a context
2452  *
2453  * Returns 0 on success. Otherwise returns 1, the SMBCCTX is _not_ freed
2454  * and thus you'll be leaking memory if not handled properly.
2455  *
2456  */
2457 int smbc_free_context(SMBCCTX * context, int shutdown_ctx)
2458 {
2459         if (!context) {
2460                 errno = EBADF;
2461                 return 1;
2462         }
2463
2464         if (shutdown_ctx) {
2465                 SMBCFILE * f;
2466                 DEBUG(1,("Performing aggressive shutdown.\n"));
2467
2468                 f = context->_files;
2469                 while (f) {
2470                         context->close(context, f);
2471                         f = f->next;
2472                 }
2473                 context->_files = NULL;
2474
2475                 /* First try to remove the servers the nice way. */
2476                 if (context->callbacks.purge_cached_fn(context)) {
2477                         SMBCSRV * s;
2478                         DEBUG(1, ("Could not purge all servers, Nice way shutdown failed.\n"));
2479                         s = context->_servers;
2480                         while (s) {
2481                                 cli_shutdown(&s->cli);
2482                                 context->callbacks.remove_cached_srv_fn(context, s);
2483                                 SAFE_FREE(s);
2484                                 s = s->next;
2485                         }
2486                         context->_servers = NULL;
2487                 }
2488         }
2489         else {
2490                 /* This is the polite way */
2491                 if (context->callbacks.purge_cached_fn(context)) {
2492                         DEBUG(1, ("Could not purge all servers, free_context failed.\n"));
2493                         errno = EBUSY;
2494                         return 1;
2495                 }
2496                 if (context->_servers) {
2497                         DEBUG(1, ("Active servers in context, free_context failed.\n"));
2498                         errno = EBUSY;
2499                         return 1;
2500                 }
2501                 if (context->_files) {
2502                         DEBUG(1, ("Active files in context, free_context failed.\n"));
2503                         errno = EBUSY;
2504                         return 1;
2505                 }
2506         }
2507
2508         /* Things we have to clean up */
2509         SAFE_FREE(context->workgroup);
2510         SAFE_FREE(context->netbios_name);
2511         SAFE_FREE(context->user);
2512
2513         DEBUG(3, ("Context %p succesfully freed\n", context));
2514         SAFE_FREE(context);
2515         return 0;
2516 }
2517
2518
2519 /*
2520  * Initialise the library etc
2521  *
2522  * We accept a struct containing handle information.
2523  * valid values for info->debug from 0 to 100,
2524  * and insist that info->fn must be non-null.
2525  */
2526 SMBCCTX * smbc_init_context(SMBCCTX * context)
2527 {
2528         pstring conf;
2529         int pid;
2530         char *user = NULL, *home = NULL;
2531
2532         if (!context) {
2533                 errno = EBADF;
2534                 return NULL;
2535         }
2536
2537         /* Do not initialise the same client twice */
2538         if (context->_initialized) {
2539                 return 0;
2540         }
2541
2542         if (!context->callbacks.auth_fn || context->debug < 0 || context->debug > 100) {
2543
2544                 errno = EINVAL;
2545                 return NULL;
2546
2547         }
2548
2549         if (!smbc_initialized) {
2550                 /* Do some library wide intialisations the first time we get called */
2551
2552                 /* Do we still need this ? */
2553                 DEBUGLEVEL = 10;
2554
2555                 setup_logging( "libsmbclient", False);
2556
2557                 /* Here we would open the smb.conf file if needed ... */
2558
2559                 home = getenv("HOME");
2560
2561                 slprintf(conf, sizeof(conf), "%s/.smb/smb.conf", home);
2562
2563                 load_interfaces();  /* Load the list of interfaces ... */
2564
2565                 in_client = True; /* FIXME, make a param */
2566
2567                 if (!lp_load(conf, True, False, False)) {
2568
2569                         /*
2570                          * Hmmm, what the hell do we do here ... we could not parse the
2571                          * config file ... We must return an error ... and keep info around
2572                          * about why we failed
2573                          */
2574
2575                         errno = ENOENT; /* FIXME: Figure out the correct error response */
2576                         return NULL;
2577                 }
2578
2579                 reopen_logs();  /* Get logging working ... */
2580
2581                 /*
2582                  * Block SIGPIPE (from lib/util_sock.c: write())
2583                  * It is not needed and should not stop execution
2584                  */
2585                 BlockSignals(True, SIGPIPE);
2586
2587                 /* Done with one-time initialisation */
2588                 smbc_initialized = 1;
2589
2590         }
2591
2592         if (!context->user) {
2593                 /*
2594                  * FIXME: Is this the best way to get the user info?
2595                  */
2596                 user = getenv("USER");
2597                 /* walk around as "guest" if no username can be found */
2598                 if (!user) context->user = strdup("guest");
2599                 else context->user = strdup(user);
2600         }
2601
2602         if (!context->netbios_name) {
2603                 /*
2604                  * We try to get our netbios name from the config. If that fails we fall
2605                  * back on constructing our netbios name from our hostname etc
2606                  */
2607                 if (global_myname) {
2608                         context->netbios_name = strdup(global_myname);
2609                 }
2610                 else {
2611                         /*
2612                          * Hmmm, I want to get hostname as well, but I am too lazy for the moment
2613                          */
2614                         pid = sys_getpid();
2615                         context->netbios_name = malloc(17);
2616                         if (!context->netbios_name) {
2617                                 errno = ENOMEM;
2618                                 return NULL;
2619                         }
2620                         slprintf(context->netbios_name, 16, "smbc%s%d", context->user, pid);
2621                 }
2622         }
2623         DEBUG(0,("Using netbios name %s.\n", context->netbios_name));
2624
2625
2626         if (!context->workgroup) {
2627                 if (lp_workgroup()) {
2628                         context->workgroup = strdup(lp_workgroup());
2629                 }
2630                 else {
2631                         /* TODO: Think about a decent default workgroup */
2632                         context->workgroup = strdup("samba");
2633                 }
2634         }
2635         DEBUG(0,("Using workgroup %s.\n", context->workgroup));
2636
2637
2638         /*
2639          * I think we can do this more than once for the same name without
2640          * being shot but who am I? -- Tom
2641          * Actually, we probably don't want to register a name,
2642          * but one day the user might want to be able to do so. RJS
2643          */
2644         if (0) {
2645                 name_register_wins(context->netbios_name, 0);
2646         }
2647
2648         /* shortest timeout is 1 second */
2649         if (context->timeout > 0 && context->timeout < 1000)
2650                 context->timeout = 1000;
2651
2652         /*
2653          * FIXME: Should we check the function pointers here?
2654          */
2655
2656         context->_initialized = 1;
2657
2658         return context;
2659 }