source3/libsmb/libsmbclient.c

   1 /*
   2    Unix SMB/Netbios implementation.
   3    SMB client library implementation
   4    Copyright (C) Andrew Tridgell 1998
   5    Copyright (C) Richard Sharpe 2000, 2002
   6    Copyright (C) John Terpstra 2000
   7    Copyright (C) Tom Jansen (Ninja ISD) 2002
   8    Copyright (C) Derrell Lipman 2003, 2004
   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 #include "include/libsmb_internal.h"
  28
  29
  30 /*
  31  * DOS Attribute values (used internally)
  32  */
  33 typedef struct DOS_ATTR_DESC {
  34         int mode;
  35         SMB_OFF_T size;
  36         time_t a_time;
  37         time_t c_time;
  38         time_t m_time;
  39         SMB_INO_T inode;
  40 } DOS_ATTR_DESC;
  41
  42
  43 /*
  44  * Internal flags for extended attributes
  45  */
  46
  47 /* internal mode values */
  48 #define SMBC_XATTR_MODE_ADD          1
  49 #define SMBC_XATTR_MODE_REMOVE       2
  50 #define SMBC_XATTR_MODE_REMOVE_ALL   3
  51 #define SMBC_XATTR_MODE_SET          4
  52 #define SMBC_XATTR_MODE_CHOWN        5
  53 #define SMBC_XATTR_MODE_CHGRP        6
  54
  55 #define CREATE_ACCESS_READ      READ_CONTROL_ACCESS
  56
  57 /*We should test for this in configure ... */
  58 #ifndef ENOTSUP
  59 #define ENOTSUP EOPNOTSUPP
  60 #endif
  61
  62 /*
  63  * Functions exported by libsmb_cache.c that we need here
  64  */
  65 int smbc_default_cache_functions(SMBCCTX *context);
  66
  67 /*
  68  * check if an element is part of the list.
  69  * FIXME: Does not belong here !
  70  * Can anyone put this in a macro in dlinklist.h ?
  71  * -- Tom
  72  */
  73 static int DLIST_CONTAINS(SMBCFILE * list, SMBCFILE *p) {
  74         if (!p || !list) return False;
  75         do {
  76                 if (p == list) return True;
  77                 list = list->next;
  78         } while (list);
  79         return False;
  80 }
  81
  82 /*
  83  * Find an lsa pipe handle associated with a cli struct.
  84  */
  85 static struct rpc_pipe_client *
  86 find_lsa_pipe_hnd(struct cli_state *ipc_cli)
  87 {
  88         struct rpc_pipe_client *pipe_hnd;
  89
  90         for (pipe_hnd = ipc_cli->pipe_list;
  91              pipe_hnd;
  92              pipe_hnd = pipe_hnd->next) {
  93
  94                 if (pipe_hnd->pipe_idx == PI_LSARPC) {
  95                         return pipe_hnd;
  96                 }
  97         }
  98
  99         return NULL;
 100 }
 101
 102 static int
 103 smbc_close_ctx(SMBCCTX *context,
 104                SMBCFILE *file);
 105 static off_t
 106 smbc_lseek_ctx(SMBCCTX *context,
 107                SMBCFILE *file,
 108                off_t offset,
 109                int whence);
 110
 111 extern BOOL in_client;
 112
 113 /*
 114  * Is the logging working / configfile read ?
 115  */
 116 static int smbc_initialized = 0;
 117
 118 static int
 119 hex2int( unsigned int _char )
 120 {
 121     if ( _char >= 'A' && _char <='F')
 122         return _char - 'A' + 10;
 123     if ( _char >= 'a' && _char <='f')
 124         return _char - 'a' + 10;
 125     if ( _char >= '0' && _char <='9')
 126         return _char - '0';
 127     return -1;
 128 }
 129
 130 /*
 131  * smbc_urldecode()
 132  *
 133  * Convert strings of %xx to their single character equivalent.  Each 'x' must
 134  * be a valid hexadecimal digit, or that % sequence is left undecoded.
 135  *
 136  * dest may, but need not be, the same pointer as src.
 137  *
 138  * Returns the number of % sequences which could not be converted due to lack
 139  * of two following hexadecimal digits.
 140  */
 141 int
 142 smbc_urldecode(char *dest, char * src, size_t max_dest_len)
 143 {
 144         int old_length = strlen(src);
 145         int i = 0;
 146         int err_count = 0;
 147         pstring temp;
 148         char * p;
 149
 150         if ( old_length == 0 ) {
 151                 return 0;
 152         }
 153
 154         p = temp;
 155         while ( i < old_length ) {
 156                 unsigned char character = src[ i++ ];
 157
 158                 if (character == '%') {
 159                         int a = i+1 < old_length ? hex2int( src[i] ) : -1;
 160                         int b = i+1 < old_length ? hex2int( src[i+1] ) : -1;
 161
 162                         /* Replace valid sequence */
 163                         if (a != -1 && b != -1) {
 164
 165                                 /* Replace valid %xx sequence with %dd */
 166                                 character = (a * 16) + b;
 167
 168                                 if (character == '\0') {
 169                                         break; /* Stop at %00 */
 170                                 }
 171
 172                                 i += 2;
 173                         } else {
 174
 175                                 err_count++;
 176                         }
 177                 }
 178
 179                 *p++ = character;
 180         }
 181
 182         *p = '\0';
 183
 184         strncpy(dest, temp, max_dest_len - 1);
 185         dest[max_dest_len - 1] = '\0';
 186
 187         return err_count;
 188 }
 189
 190 /*
 191  * smbc_urlencode()
 192  *
 193  * Convert any characters not specifically allowed in a URL into their %xx
 194  * equivalent.
 195  *
 196  * Returns the remaining buffer length.
 197  */
 198 int
 199 smbc_urlencode(char * dest, char * src, int max_dest_len)
 200 {
 201         char hex[] = "0123456789ABCDEF";
 202
 203         for (; *src != '\0' && max_dest_len >= 3; src++) {
 204
 205                 if ((*src < '0' &&
 206                      *src != '-' &&
 207                      *src != '.') ||
 208                     (*src > '9' &&
 209                      *src < 'A') ||
 210                     (*src > 'Z' &&
 211                      *src < 'a' &&
 212                      *src != '_') ||
 213                     (*src > 'z')) {
 214                         *dest++ = '%';
 215                         *dest++ = hex[(*src >> 4) & 0x0f];
 216                         *dest++ = hex[*src & 0x0f];
 217                         max_dest_len -= 3;
 218                 } else {
 219                         *dest++ = *src;
 220                         max_dest_len--;
 221                 }
 222         }
 223
 224         *dest++ = '\0';
 225         max_dest_len--;
 226
 227         return max_dest_len;
 228 }
 229
 230 /*
 231  * Function to parse a path and turn it into components
 232  *
 233  * The general format of an SMB URI is explain in Christopher Hertel's CIFS
 234  * book, at http://ubiqx.org/cifs/Appendix-D.html.  We accept a subset of the
 235  * general format ("smb:" only; we do not look for "cifs:").
 236  *
 237  *
 238  * We accept:
 239  *  smb://[[[domain;]user[:password@]]server[/share[/path[/file]]]][?options]
 240  *
 241  * Meaning of URLs:
 242  *
 243  * smb://           Show all workgroups.
 244  *
 245  *                  The method of locating the list of workgroups varies
 246  *                  depending upon the setting of the context variable
 247  *                  context->options.browse_max_lmb_count.  This value
 248  *                  determine the maximum number of local master browsers to
 249  *                  query for the list of workgroups.  In order to ensure that
 250  *                  a complete list of workgroups is obtained, all master
 251  *                  browsers must be queried, but if there are many
 252  *                  workgroups, the time spent querying can begin to add up.
 253  *                  For small networks (not many workgroups), it is suggested
 254  *                  that this variable be set to 0, indicating query all local
 255  *                  master browsers.  When the network has many workgroups, a
 256  *                  reasonable setting for this variable might be around 3.
 257  *
 258  * smb://name/      if name<1D> or name<1B> exists, list servers in
 259  *                  workgroup, else, if name<20> exists, list all shares
 260  *                  for server ...
 261  *
 262  * If "options" are provided, this function returns the entire option list as a
 263  * string, for later parsing by the caller.  Note that currently, no options
 264  * are supported.
 265  */
 266
 267 static const char *smbc_prefix = "smb:";
 268
 269 static int
 270 smbc_parse_path(SMBCCTX *context,
 271                 const char *fname,
 272                 char *workgroup, int workgroup_len,
 273                 char *server, int server_len,
 274                 char *share, int share_len,
 275                 char *path, int path_len,
 276                 char *user, int user_len,
 277                 char *password, int password_len,
 278                 char *options, int options_len)
 279 {
 280         static pstring s;
 281         pstring userinfo;
 282         const char *p;
 283         char *q, *r;
 284         int len;
 285
 286         server[0] = share[0] = path[0] = user[0] = password[0] = (char)0;
 287
 288         /*
 289          * Assume we wont find an authentication domain to parse, so default
 290          * to the workgroup in the provided context.
 291          */
 292         if (workgroup != NULL) {
 293                 strncpy(workgroup, context->workgroup, workgroup_len - 1);
 294                 workgroup[workgroup_len - 1] = '\0';
 295         }
 296
 297         if (options != NULL && options_len > 0) {
 298                 options[0] = (char)0;
 299         }
 300         pstrcpy(s, fname);
 301
 302         /* see if it has the right prefix */
 303         len = strlen(smbc_prefix);
 304         if (strncmp(s,smbc_prefix,len) || (s[len] != '/' && s[len] != 0)) {
 305                 return -1; /* What about no smb: ? */
 306         }
 307
 308         p = s + len;
 309
 310         /* Watch the test below, we are testing to see if we should exit */
 311
 312         if (strncmp(p, "//", 2) && strncmp(p, "\\\\", 2)) {
 313
 314                 DEBUG(1, ("Invalid path (does not begin with smb://"));
 315                 return -1;
 316
 317         }
 318
 319         p += 2;  /* Skip the double slash */
 320
 321         /* See if any options were specified */
 322         if ((q = strrchr(p, '?')) != NULL ) {
 323                 /* There are options.  Null terminate here and point to them */
 324                 *q++ = '\0';
 325
 326                 DEBUG(4, ("Found options '%s'", q));
 327
 328                 /* Copy the options */
 329                 if (options != NULL && options_len > 0) {
 330                         safe_strcpy(options, q, options_len - 1);
 331                 }
 332         }
 333
 334         if (*p == (char)0)
 335             goto decoding;
 336
 337         if (*p == '/') {
 338
 339                 strncpy(server, context->workgroup,
 340                         ((strlen(context->workgroup) < 16)
 341                          ? strlen(context->workgroup)
 342                          : 16));
 343                 server[server_len - 1] = '\0';
 344                 return 0;
 345
 346         }
 347
 348         /*
 349          * ok, its for us. Now parse out the server, share etc.
 350          *
 351          * However, we want to parse out [[domain;]user[:password]@] if it
 352          * exists ...
 353          */
 354
 355         /* check that '@' occurs before '/', if '/' exists at all */
 356         q = strchr_m(p, '@');
 357         r = strchr_m(p, '/');
 358         if (q && (!r || q < r)) {
 359                 pstring username, passwd, domain;
 360                 const char *u = userinfo;
 361
 362                 next_token(&p, userinfo, "@", sizeof(fstring));
 363
 364                 username[0] = passwd[0] = domain[0] = 0;
 365
 366                 if (strchr_m(u, ';')) {
 367
 368                         next_token(&u, domain, ";", sizeof(fstring));
 369
 370                 }
 371
 372                 if (strchr_m(u, ':')) {
 373
 374                         next_token(&u, username, ":", sizeof(fstring));
 375
 376                         pstrcpy(passwd, u);
 377
 378                 }
 379                 else {
 380
 381                         pstrcpy(username, u);
 382
 383                 }
 384
 385                 if (domain[0] && workgroup) {
 386                         strncpy(workgroup, domain, workgroup_len - 1);
 387                         workgroup[workgroup_len - 1] = '\0';
 388                 }
 389
 390                 if (username[0]) {
 391                         strncpy(user, username, user_len - 1);
 392                         user[user_len - 1] = '\0';
 393                 }
 394
 395                 if (passwd[0]) {
 396                         strncpy(password, passwd, password_len - 1);
 397                         password[password_len - 1] = '\0';
 398                 }
 399
 400         }
 401
 402         if (!next_token(&p, server, "/", sizeof(fstring))) {
 403
 404                 return -1;
 405
 406         }
 407
 408         if (*p == (char)0) goto decoding;  /* That's it ... */
 409
 410         if (!next_token(&p, share, "/", sizeof(fstring))) {
 411
 412                 return -1;
 413
 414         }
 415
 416         safe_strcpy(path, p, path_len - 1);
 417
 418         all_string_sub(path, "/", "\\", 0);
 419
 420  decoding:
 421         (void) smbc_urldecode(path, path, path_len);
 422         (void) smbc_urldecode(server, server, server_len);
 423         (void) smbc_urldecode(share, share, share_len);
 424         (void) smbc_urldecode(user, user, user_len);
 425         (void) smbc_urldecode(password, password, password_len);
 426
 427         return 0;
 428 }
 429
 430 /*
 431  * Verify that the options specified in a URL are valid
 432  */
 433 static int
 434 smbc_check_options(char *server,
 435                    char *share,
 436                    char *path,
 437                    char *options)
 438 {
 439         DEBUG(4, ("smbc_check_options(): server='%s' share='%s' "
 440                   "path='%s' options='%s'\n",
 441                   server, share, path, options));
 442
 443         /* No options at all is always ok */
 444         if (! *options) return 0;
 445
 446         /* Currently, we don't support any options. */
 447         return -1;
 448 }
 449
 450 /*
 451  * Convert an SMB error into a UNIX error ...
 452  */
 453 static int
 454 smbc_errno(SMBCCTX *context,
 455            struct cli_state *c)
 456 {
 457         int ret = cli_errno(c);
 458
 459         if (cli_is_dos_error(c)) {
 460                 uint8 eclass;
 461                 uint32 ecode;
 462
 463                 cli_dos_error(c, &eclass, &ecode);
 464
 465                 DEBUG(3,("smbc_error %d %d (0x%x) -> %d\n",
 466                          (int)eclass, (int)ecode, (int)ecode, ret));
 467         } else {
 468                 NTSTATUS status;
 469
 470                 status = cli_nt_error(c);
 471
 472                 DEBUG(3,("smbc errno %s -> %d\n",
 473                          nt_errstr(status), ret));
 474         }
 475
 476         return ret;
 477 }
 478
 479 /*
 480  * Check a server for being alive and well.
 481  * returns 0 if the server is in shape. Returns 1 on error
 482  *
 483  * Also useable outside libsmbclient to enable external cache
 484  * to do some checks too.
 485  */
 486 static int
 487 smbc_check_server(SMBCCTX * context,
 488                   SMBCSRV * server)
 489 {
 490         if ( send_keepalive(server->cli.fd) == False )
 491                 return 1;
 492
 493         /* connection is ok */
 494         return 0;
 495 }
 496
 497 /*
 498  * Remove a server from the cached server list it's unused.
 499  * On success, 0 is returned. 1 is returned if the server could not be removed.
 500  *
 501  * Also useable outside libsmbclient
 502  */
 503 int
 504 smbc_remove_unused_server(SMBCCTX * context,
 505                           SMBCSRV * srv)
 506 {
 507         SMBCFILE * file;
 508
 509         /* are we being fooled ? */
 510         if (!context || !context->internal ||
 511             !context->internal->_initialized || !srv) return 1;
 512
 513
 514         /* Check all open files/directories for a relation with this server */
 515         for (file = context->internal->_files; file; file=file->next) {
 516                 if (file->srv == srv) {
 517                         /* Still used */
 518                         DEBUG(3, ("smbc_remove_usused_server: "
 519                                   "%p still used by %p.\n",
 520                                   srv, file));
 521                         return 1;
 522                 }
 523         }
 524
 525         DLIST_REMOVE(context->internal->_servers, srv);
 526
 527         cli_shutdown(&srv->cli);
 528
 529         DEBUG(3, ("smbc_remove_usused_server: %p removed.\n", srv));
 530
 531         context->callbacks.remove_cached_srv_fn(context, srv);
 532
 533         SAFE_FREE(srv);
 534
 535         return 0;
 536 }
 537
 538 static SMBCSRV *
 539 find_server(SMBCCTX *context,
 540             const char *server,
 541             const char *share,
 542             fstring workgroup,
 543             fstring username,
 544             fstring password)
 545 {
 546         SMBCSRV *srv;
 547         int auth_called = 0;
 548
 549  check_server_cache:
 550
 551         srv = context->callbacks.get_cached_srv_fn(context, server, share,
 552                                                    workgroup, username);
 553
 554         if (!auth_called && !srv && (!username[0] || !password[0])) {
 555                 context->callbacks.auth_fn(server, share,
 556                                            workgroup, sizeof(fstring),
 557                                            username, sizeof(fstring),
 558                                            password, sizeof(fstring));
 559                 /*
 560                  * However, smbc_auth_fn may have picked up info relating to
 561                  * an existing connection, so try for an existing connection
 562                  * again ...
 563                  */
 564                 auth_called = 1;
 565                 goto check_server_cache;
 566
 567         }
 568
 569         if (srv) {
 570                 if (context->callbacks.check_server_fn(context, srv)) {
 571                         /*
 572                          * This server is no good anymore
 573                          * Try to remove it and check for more possible
 574                          * servers in the cache
 575                          */
 576                         if (context->callbacks.remove_unused_server_fn(context,
 577                                                                        srv)) {
 578                                 /*
 579                                  * We could not remove the server completely,
 580                                  * remove it from the cache so we will not get
 581                                  * it again. It will be removed when the last
 582                                  * file/dir is closed.
 583                                  */
 584                                 context->callbacks.remove_cached_srv_fn(context,
 585                                                                         srv);
 586                         }
 587
 588                         /*
 589                          * Maybe there are more cached connections to this
 590                          * server
 591                          */
 592                         goto check_server_cache;
 593                 }
 594
 595                 return srv;
 596         }
 597
 598         return NULL;
 599 }
 600
 601 /*
 602  * Connect to a server, possibly on an existing connection
 603  *
 604  * Here, what we want to do is: If the server and username
 605  * match an existing connection, reuse that, otherwise, establish a
 606  * new connection.
 607  *
 608  * If we have to create a new connection, call the auth_fn to get the
 609  * info we need, unless the username and password were passed in.
 610  */
 611
 612 static SMBCSRV *
 613 smbc_server(SMBCCTX *context,
 614             BOOL connect_if_not_found,
 615             const char *server,
 616             const char *share,
 617             fstring workgroup,
 618             fstring username,
 619             fstring password)
 620 {
 621         SMBCSRV *srv=NULL;
 622         struct cli_state c;
 623         struct nmb_name called, calling;
 624         const char *server_n = server;
 625         pstring ipenv;
 626         struct in_addr ip;
 627         int tried_reverse = 0;
 628         int port_try_first;
 629         int port_try_next;
 630         const char *username_used;
 631
 632         zero_ip(&ip);
 633         ZERO_STRUCT(c);
 634
 635         if (server[0] == 0) {
 636                 errno = EPERM;
 637                 return NULL;
 638         }
 639
 640         /* Look for a cached connection */
 641         srv = find_server(context, server, share,
 642                           workgroup, username, password);
 643
 644         /*
 645          * If we found a connection and we're only allowed one share per
 646          * server...
 647          */
 648         if (srv && *share != '\0' && context->options.one_share_per_server) {
 649
 650                 /*
 651                  * ... then if there's no current connection to the share,
 652                  * connect to it.  find_server(), or rather the function
 653                  * pointed to by context->callbacks.get_cached_srv_fn which
 654                  * was called by find_server(), will have issued a tree
 655                  * disconnect if the requested share is not the same as the
 656                  * one that was already connected.
 657                  */
 658                 if (srv->cli.cnum == (uint16) -1) {
 659                         /* Ensure we have accurate auth info */
 660                         context->callbacks.auth_fn(server, share,
 661                                                    workgroup, sizeof(fstring),
 662                                                    username, sizeof(fstring),
 663                                                    password, sizeof(fstring));
 664
 665                         if (! cli_send_tconX(&srv->cli, share, "?????",
 666                                              password, strlen(password)+1)) {
 667
 668                                 errno = smbc_errno(context, &srv->cli);
 669                                 cli_shutdown(&srv->cli);
 670                                 context->callbacks.remove_cached_srv_fn(context,
 671                                                                         srv);
 672                                 srv = NULL;
 673                         }
 674
 675                         /*
 676                          * Regenerate the dev value since it's based on both
 677                          * server and share
 678                          */
 679                         if (srv) {
 680                                 srv->dev = (dev_t)(str_checksum(server) ^
 681                                                    str_checksum(share));
 682                         }
 683                 }
 684         }
 685
 686         /* If we have a connection... */
 687         if (srv) {
 688
 689                 /* ... then we're done here.  Give 'em what they came for. */
 690                 return srv;
 691         }
 692
 693         /* If we're not asked to connect when a connection doesn't exist... */
 694         if (! connect_if_not_found) {
 695                 /* ... then we're done here. */
 696                 return NULL;
 697         }
 698
 699         make_nmb_name(&calling, context->netbios_name, 0x0);
 700         make_nmb_name(&called , server, 0x20);
 701
 702         DEBUG(4,("smbc_server: server_n=[%s] server=[%s]\n", server_n, server));
 703
 704         DEBUG(4,(" -> server_n=[%s] server=[%s]\n", server_n, server));
 705
 706  again:
 707         slprintf(ipenv,sizeof(ipenv)-1,"HOST_%s", server_n);
 708
 709         zero_ip(&ip);
 710
 711         /* have to open a new connection */
 712         if (!cli_initialise(&c)) {
 713                 errno = ENOMEM;
 714                 return NULL;
 715         }
 716
 717         if (context->flags & SMB_CTX_FLAG_USE_KERBEROS) {
 718                 c.use_kerberos = True;
 719         }
 720         if (context->flags & SMB_CTX_FLAG_FALLBACK_AFTER_KERBEROS) {
 721                 c.fallback_after_kerberos = True;
 722         }
 723
 724         c.timeout = context->timeout;
 725
 726         /*
 727          * Force use of port 139 for first try if share is $IPC, empty, or
 728          * null, so browse lists can work
 729          */
 730         if (share == NULL || *share == '\0' || strcmp(share, "IPC$") == 0) {
 731                 port_try_first = 139;
 732                 port_try_next = 445;
 733         } else {
 734                 port_try_first = 445;
 735                 port_try_next = 139;
 736         }
 737
 738         c.port = port_try_first;
 739
 740         if (!cli_connect(&c, server_n, &ip)) {
 741
 742                 /* First connection attempt failed.  Try alternate port. */
 743                 c.port = port_try_next;
 744
 745                 if (!cli_connect(&c, server_n, &ip)) {
 746                         cli_shutdown(&c);
 747                         errno = ETIMEDOUT;
 748                         return NULL;
 749                 }
 750         }
 751
 752         if (!cli_session_request(&c, &calling, &called)) {
 753                 cli_shutdown(&c);
 754                 if (strcmp(called.name, "*SMBSERVER")) {
 755                         make_nmb_name(&called , "*SMBSERVER", 0x20);
 756                         goto again;
 757                 }
 758                 else {  /* Try one more time, but ensure we don't loop */
 759
 760                   /* Only try this if server is an IP address ... */
 761
 762                   if (is_ipaddress(server) && !tried_reverse) {
 763                     fstring remote_name;
 764                     struct in_addr rem_ip;
 765
 766                     if ((rem_ip.s_addr=inet_addr(server)) == INADDR_NONE) {
 767                       DEBUG(4, ("Could not convert IP address %s to struct in_addr\n", server));
 768                       errno = ETIMEDOUT;
 769                       return NULL;
 770                     }
 771
 772                     tried_reverse++; /* Yuck */
 773
 774                     if (name_status_find("*", 0, 0, rem_ip, remote_name)) {
 775                       make_nmb_name(&called, remote_name, 0x20);
 776                       goto again;
 777                     }
 778
 779
 780                   }
 781                 }
 782                 errno = ETIMEDOUT;
 783                 return NULL;
 784         }
 785
 786         DEBUG(4,(" session request ok\n"));
 787
 788         if (!cli_negprot(&c)) {
 789                 cli_shutdown(&c);
 790                 errno = ETIMEDOUT;
 791                 return NULL;
 792         }
 793
 794         username_used = username;
 795
 796         if (!cli_session_setup(&c, username_used,
 797                                password, strlen(password),
 798                                password, strlen(password),
 799                                workgroup)) {
 800
 801                 /* Failed.  Try an anonymous login, if allowed by flags. */
 802                 username_used = "";
 803
 804                 if ((context->flags & SMBCCTX_FLAG_NO_AUTO_ANONYMOUS_LOGON) ||
 805                      !cli_session_setup(&c, username_used,
 806                                         password, 1,
 807                                         password, 0,
 808                                         workgroup)) {
 809
 810                         cli_shutdown(&c);
 811                         errno = EPERM;
 812                         return NULL;
 813                 }
 814         }
 815
 816         DEBUG(4,(" session setup ok\n"));
 817
 818         if (!cli_send_tconX(&c, share, "?????",
 819                             password, strlen(password)+1)) {
 820                 errno = smbc_errno(context, &c);
 821                 cli_shutdown(&c);
 822                 return NULL;
 823         }
 824
 825         DEBUG(4,(" tconx ok\n"));
 826
 827         /*
 828          * Ok, we have got a nice connection
 829          * Let's allocate a server structure.
 830          */
 831
 832         srv = SMB_MALLOC_P(SMBCSRV);
 833         if (!srv) {
 834                 errno = ENOMEM;
 835                 goto failed;
 836         }
 837
 838         ZERO_STRUCTP(srv);
 839         srv->cli = c;
 840         srv->cli.allocated = False;
 841         srv->dev = (dev_t)(str_checksum(server) ^ str_checksum(share));
 842         srv->no_pathinfo = False;
 843         srv->no_pathinfo2 = False;
 844         srv->no_nt_session = False;
 845
 846         /* now add it to the cache (internal or external)  */
 847         /* Let the cache function set errno if it wants to */
 848         errno = 0;
 849         if (context->callbacks.add_cached_srv_fn(context, srv, server, share, workgroup, username)) {
 850                 int saved_errno = errno;
 851                 DEBUG(3, (" Failed to add server to cache\n"));
 852                 errno = saved_errno;
 853                 if (errno == 0) {
 854                         errno = ENOMEM;
 855                 }
 856                 goto failed;
 857         }
 858
 859         DEBUG(2, ("Server connect ok: //%s/%s: %p\n",
 860                   server, share, srv));
 861
 862         DLIST_ADD(context->internal->_servers, srv);
 863         return srv;
 864
 865  failed:
 866         cli_shutdown(&c);
 867         if (!srv) return NULL;
 868
 869         SAFE_FREE(srv);
 870         return NULL;
 871 }
 872
 873 /*
 874  * Connect to a server for getting/setting attributes, possibly on an existing
 875  * connection.  This works similarly to smbc_server().
 876  */
 877 static SMBCSRV *
 878 smbc_attr_server(SMBCCTX *context,
 879                  const char *server,
 880                  const char *share,
 881                  fstring workgroup,
 882                  fstring username,
 883                  fstring password,
 884                  POLICY_HND *pol)
 885 {
 886         struct in_addr ip;
 887         struct cli_state *ipc_cli;
 888         struct rpc_pipe_client *pipe_hnd;
 889         NTSTATUS nt_status;
 890         SMBCSRV *ipc_srv=NULL;
 891
 892         /*
 893          * See if we've already created this special connection.  Reference
 894          * our "special" share name '*IPC$', which is an impossible real share
 895          * name due to the leading asterisk.
 896          */
 897         ipc_srv = find_server(context, server, "*IPC$",
 898                               workgroup, username, password);
 899         if (!ipc_srv) {
 900
 901                 /* We didn't find a cached connection.  Get the password */
 902                 if (*password == '\0') {
 903                         /* ... then retrieve it now. */
 904                         context->callbacks.auth_fn(server, share,
 905                                                    workgroup, sizeof(fstring),
 906                                                    username, sizeof(fstring),
 907                                                    password, sizeof(fstring));
 908                 }
 909
 910                 zero_ip(&ip);
 911                 nt_status = cli_full_connection(&ipc_cli,
 912                                                 global_myname(), server,
 913                                                 &ip, 0, "IPC$", "?????",
 914                                                 username, workgroup,
 915                                                 password, 0,
 916                                                 Undefined, NULL);
 917                 if (! NT_STATUS_IS_OK(nt_status)) {
 918                         DEBUG(1,("cli_full_connection failed! (%s)\n",
 919                                  nt_errstr(nt_status)));
 920                         errno = ENOTSUP;
 921                         return NULL;
 922                 }
 923
 924                 ipc_srv = SMB_MALLOC_P(SMBCSRV);
 925                 if (!ipc_srv) {
 926                         errno = ENOMEM;
 927                         cli_shutdown(ipc_cli);
 928                         return NULL;
 929                 }
 930
 931                 ZERO_STRUCTP(ipc_srv);
 932                 ipc_srv->cli = *ipc_cli;
 933                 ipc_srv->cli.allocated = False;
 934
 935                 free(ipc_cli);
 936
 937                 if (pol) {
 938                         pipe_hnd = cli_rpc_pipe_open_noauth(&ipc_srv->cli,
 939                                                             PI_LSARPC,
 940                                                             &nt_status);
 941                         if (!pipe_hnd) {
 942                                 DEBUG(1, ("cli_nt_session_open fail!\n"));
 943                                 errno = ENOTSUP;
 944                                 cli_shutdown(&ipc_srv->cli);
 945                                 free(ipc_srv);
 946                                 return NULL;
 947                         }
 948
 949                         /*
 950                          * Some systems don't support
 951                          * SEC_RIGHTS_MAXIMUM_ALLOWED, but NT sends 0x2000000
 952                          * so we might as well do it too.
 953                          */
 954
 955                         nt_status = rpccli_lsa_open_policy(
 956                                 pipe_hnd,
 957                                 ipc_srv->cli.mem_ctx,
 958                                 True,
 959                                 GENERIC_EXECUTE_ACCESS,
 960                                 pol);
 961
 962                         if (!NT_STATUS_IS_OK(nt_status)) {
 963                                 errno = smbc_errno(context, &ipc_srv->cli);
 964                                 cli_shutdown(&ipc_srv->cli);
 965                                 return NULL;
 966                         }
 967                 }
 968
 969                 /* now add it to the cache (internal or external) */
 970
 971                 errno = 0;      /* let cache function set errno if it likes */
 972                 if (context->callbacks.add_cached_srv_fn(context, ipc_srv,
 973                                                          server,
 974                                                          "*IPC$",
 975                                                          workgroup,
 976                                                          username)) {
 977                         DEBUG(3, (" Failed to add server to cache\n"));
 978                         if (errno == 0) {
 979                                 errno = ENOMEM;
 980                         }
 981                         cli_shutdown(&ipc_srv->cli);
 982                         free(ipc_srv);
 983                         return NULL;
 984                 }
 985
 986                 DLIST_ADD(context->internal->_servers, ipc_srv);
 987         }
 988
 989         return ipc_srv;
 990 }
 991
 992 /*
 993  * Routine to open() a file ...
 994  */
 995
 996 static SMBCFILE *
 997 smbc_open_ctx(SMBCCTX *context,
 998               const char *fname,
 999               int flags,
1000               mode_t mode)
1001 {
1002         fstring server, share, user, password, workgroup;
1003         pstring path;
1004         pstring targetpath;
1005         struct cli_state *targetcli;
1006         SMBCSRV *srv   = NULL;
1007         SMBCFILE *file = NULL;
1008         int fd;
1009
1010         if (!context || !context->internal ||
1011             !context->internal->_initialized) {
1012
1013                 errno = EINVAL;  /* Best I can think of ... */
1014                 return NULL;
1015
1016         }
1017
1018         if (!fname) {
1019
1020                 errno = EINVAL;
1021                 return NULL;
1022
1023         }
1024
1025         if (smbc_parse_path(context, fname,
1026                             workgroup, sizeof(workgroup),
1027                             server, sizeof(server),
1028                             share, sizeof(share),
1029                             path, sizeof(path),
1030                             user, sizeof(user),
1031                             password, sizeof(password),
1032                             NULL, 0)) {
1033                 errno = EINVAL;
1034                 return NULL;
1035         }
1036
1037         if (user[0] == (char)0) fstrcpy(user, context->user);
1038
1039         srv = smbc_server(context, True,
1040                           server, share, workgroup, user, password);
1041
1042         if (!srv) {
1043
1044                 if (errno == EPERM) errno = EACCES;
1045                 return NULL;  /* smbc_server sets errno */
1046
1047         }
1048
1049         /* Hmmm, the test for a directory is suspect here ... FIXME */
1050
1051         if (strlen(path) > 0 && path[strlen(path) - 1] == '\\') {
1052
1053                 fd = -1;
1054
1055         }
1056         else {
1057
1058                 file = SMB_MALLOC_P(SMBCFILE);
1059
1060                 if (!file) {
1061
1062                         errno = ENOMEM;
1063                         return NULL;
1064
1065                 }
1066
1067                 ZERO_STRUCTP(file);
1068
1069                 /*d_printf(">>>open: resolving %s\n", path);*/
1070                 if (!cli_resolve_path( "", &srv->cli, path, &targetcli, targetpath))
1071                 {
1072                         d_printf("Could not resolve %s\n", path);
1073                         SAFE_FREE(file);
1074                         return NULL;
1075                 }
1076                 /*d_printf(">>>open: resolved %s as %s\n", path, targetpath);*/
1077
1078                 if ( targetcli->dfsroot )
1079                 {
1080                         pstring temppath;
1081                         pstrcpy(temppath, targetpath);
1082                         cli_dfs_make_full_path( targetpath, targetcli->desthost, targetcli->share, temppath);
1083                 }
1084
1085                 if ((fd = cli_open(targetcli, targetpath, flags, DENY_NONE)) < 0) {
1086
1087                         /* Handle the error ... */
1088
1089                         SAFE_FREE(file);
1090                         errno = smbc_errno(context, targetcli);
1091                         return NULL;
1092
1093                 }
1094
1095                 /* Fill in file struct */
1096
1097                 file->cli_fd  = fd;
1098                 file->fname   = SMB_STRDUP(fname);
1099                 file->srv     = srv;
1100                 file->offset  = 0;
1101                 file->file    = True;
1102
1103                 DLIST_ADD(context->internal->_files, file);
1104
1105                 /*
1106                  * If the file was opened in O_APPEND mode, all write
1107                  * operations should be appended to the file.  To do that,
1108                  * though, using this protocol, would require a getattrE()
1109                  * call for each and every write, to determine where the end
1110                  * of the file is. (There does not appear to be an append flag
1111                  * in the protocol.)  Rather than add all of that overhead of
1112                  * retrieving the current end-of-file offset prior to each
1113                  * write operation, we'll assume that most append operations
1114                  * will continuously write, so we'll just set the offset to
1115                  * the end of the file now and hope that's adequate.
1116                  *
1117                  * Note to self: If this proves inadequate, and O_APPEND
1118                  * should, in some cases, be forced for each write, add a
1119                  * field in the context options structure, for
1120                  * "strict_append_mode" which would select between the current
1121                  * behavior (if FALSE) or issuing a getattrE() prior to each
1122                  * write and forcing the write to the end of the file (if
1123                  * TRUE).  Adding that capability will likely require adding
1124                  * an "append" flag into the _SMBCFILE structure to track
1125                  * whether a file was opened in O_APPEND mode.  -- djl
1126                  */
1127                 if (flags & O_APPEND) {
1128                         if (smbc_lseek_ctx(context, file, 0, SEEK_END) < 0) {
1129                                 (void) smbc_close_ctx(context, file);
1130                                 errno = ENXIO;
1131                                 return NULL;
1132                         }
1133                 }
1134
1135                 return file;
1136
1137         }
1138
1139         /* Check if opendir needed ... */
1140
1141         if (fd == -1) {
1142                 int eno = 0;
1143
1144                 eno = smbc_errno(context, &srv->cli);
1145                 file = context->opendir(context, fname);
1146                 if (!file) errno = eno;
1147                 return file;
1148
1149         }
1150
1151         errno = EINVAL; /* FIXME, correct errno ? */
1152         return NULL;
1153
1154 }
1155
1156 /*
1157  * Routine to create a file
1158  */
1159
1160 static int creat_bits = O_WRONLY | O_CREAT | O_TRUNC; /* FIXME: Do we need this */
1161
1162 static SMBCFILE *
1163 smbc_creat_ctx(SMBCCTX *context,
1164                const char *path,
1165                mode_t mode)
1166 {
1167
1168         if (!context || !context->internal ||
1169             !context->internal->_initialized) {
1170
1171                 errno = EINVAL;
1172                 return NULL;
1173
1174         }
1175
1176         return smbc_open_ctx(context, path, creat_bits, mode);
1177 }
1178
1179 /*
1180  * Routine to read() a file ...
1181  */
1182
1183 static ssize_t
1184 smbc_read_ctx(SMBCCTX *context,
1185               SMBCFILE *file,
1186               void *buf,
1187               size_t count)
1188 {
1189         int ret;
1190         fstring server, share, user, password;
1191         pstring path, targetpath;
1192         struct cli_state *targetcli;
1193
1194         /*
1195          * offset:
1196          *
1197          * Compiler bug (possibly) -- gcc (GCC) 3.3.5 (Debian 1:3.3.5-2) --
1198          * appears to pass file->offset (which is type off_t) differently than
1199          * a local variable of type off_t.  Using local variable "offset" in
1200          * the call to cli_read() instead of file->offset fixes a problem
1201          * retrieving data at an offset greater than 4GB.
1202          */
1203         off_t offset = file->offset;
1204
1205         if (!context || !context->internal ||
1206             !context->internal->_initialized) {
1207
1208                 errno = EINVAL;
1209                 return -1;
1210
1211         }
1212
1213         DEBUG(4, ("smbc_read(%p, %d)\n", file, (int)count));
1214
1215         if (!file || !DLIST_CONTAINS(context->internal->_files, file)) {
1216
1217                 errno = EBADF;
1218                 return -1;
1219
1220         }
1221
1222         /* Check that the buffer exists ... */
1223
1224         if (buf == NULL) {
1225
1226                 errno = EINVAL;
1227                 return -1;
1228
1229         }
1230
1231         /*d_printf(">>>read: parsing %s\n", file->fname);*/
1232         if (smbc_parse_path(context, file->fname,
1233                             NULL, 0,
1234                             server, sizeof(server),
1235                             share, sizeof(share),
1236                             path, sizeof(path),
1237                             user, sizeof(user),
1238                             password, sizeof(password),
1239                             NULL, 0)) {
1240                 errno = EINVAL;
1241                 return -1;
1242         }
1243
1244         /*d_printf(">>>read: resolving %s\n", path);*/
1245         if (!cli_resolve_path("", &file->srv->cli, path,
1246                               &targetcli, targetpath))
1247         {
1248                 d_printf("Could not resolve %s\n", path);
1249                 return -1;
1250         }
1251         /*d_printf(">>>fstat: resolved path as %s\n", targetpath);*/
1252
1253         ret = cli_read(targetcli, file->cli_fd, buf, offset, count);
1254
1255         if (ret < 0) {
1256
1257                 errno = smbc_errno(context, targetcli);
1258                 return -1;
1259
1260         }
1261
1262         file->offset += ret;
1263
1264         DEBUG(4, ("  --> %d\n", ret));
1265
1266         return ret;  /* Success, ret bytes of data ... */
1267
1268 }
1269
1270 /*
1271  * Routine to write() a file ...
1272  */
1273
1274 static ssize_t
1275 smbc_write_ctx(SMBCCTX *context,
1276                SMBCFILE *file,
1277                void *buf,
1278                size_t count)
1279 {
1280         int ret;
1281         off_t offset;
1282         fstring server, share, user, password;
1283         pstring path, targetpath;
1284         struct cli_state *targetcli;
1285
1286         /* First check all pointers before dereferencing them */
1287
1288         if (!context || !context->internal ||
1289             !context->internal->_initialized) {
1290
1291                 errno = EINVAL;
1292                 return -1;
1293
1294         }
1295
1296         if (!file || !DLIST_CONTAINS(context->internal->_files, file)) {
1297
1298                 errno = EBADF;
1299                 return -1;
1300
1301         }
1302
1303         /* Check that the buffer exists ... */
1304
1305         if (buf == NULL) {
1306
1307                 errno = EINVAL;
1308                 return -1;
1309
1310         }
1311
1312         offset = file->offset; /* See "offset" comment in smbc_read_ctx() */
1313
1314         /*d_printf(">>>write: parsing %s\n", file->fname);*/
1315         if (smbc_parse_path(context, file->fname,
1316                             NULL, 0,
1317                             server, sizeof(server),
1318                             share, sizeof(share),
1319                             path, sizeof(path),
1320                             user, sizeof(user),
1321                             password, sizeof(password),
1322                             NULL, 0)) {
1323                 errno = EINVAL;
1324                 return -1;
1325         }
1326
1327         /*d_printf(">>>write: resolving %s\n", path);*/
1328         if (!cli_resolve_path("", &file->srv->cli, path,
1329                               &targetcli, targetpath))
1330         {
1331                 d_printf("Could not resolve %s\n", path);
1332                 return -1;
1333         }
1334         /*d_printf(">>>write: resolved path as %s\n", targetpath);*/
1335
1336
1337         ret = cli_write(targetcli, file->cli_fd, 0, buf, offset, count);
1338
1339         if (ret <= 0) {
1340
1341                 errno = smbc_errno(context, targetcli);
1342                 return -1;
1343
1344         }
1345
1346         file->offset += ret;
1347
1348         return ret;  /* Success, 0 bytes of data ... */
1349 }
1350
1351 /*
1352  * Routine to close() a file ...
1353  */
1354
1355 static int
1356 smbc_close_ctx(SMBCCTX *context,
1357                SMBCFILE *file)
1358 {
1359         SMBCSRV *srv;
1360         fstring server, share, user, password;
1361         pstring path, targetpath;
1362         struct cli_state *targetcli;
1363
1364         if (!context || !context->internal ||
1365             !context->internal->_initialized) {
1366
1367                 errno = EINVAL;
1368                 return -1;
1369
1370         }
1371
1372         if (!file || !DLIST_CONTAINS(context->internal->_files, file)) {
1373
1374                 errno = EBADF;
1375                 return -1;
1376
1377         }
1378
1379         /* IS a dir ... */
1380         if (!file->file) {
1381
1382                 return context->closedir(context, file);
1383
1384         }
1385
1386         /*d_printf(">>>close: parsing %s\n", file->fname);*/
1387         if (smbc_parse_path(context, file->fname,
1388                             NULL, 0,
1389                             server, sizeof(server),
1390                             share, sizeof(share),
1391                             path, sizeof(path),
1392                             user, sizeof(user),
1393                             password, sizeof(password),
1394                             NULL, 0)) {
1395                 errno = EINVAL;
1396                 return -1;
1397         }
1398
1399         /*d_printf(">>>close: resolving %s\n", path);*/
1400         if (!cli_resolve_path("", &file->srv->cli, path,
1401                               &targetcli, targetpath))
1402         {
1403                 d_printf("Could not resolve %s\n", path);
1404                 return -1;
1405         }
1406         /*d_printf(">>>close: resolved path as %s\n", targetpath);*/
1407
1408         if (!cli_close(targetcli, file->cli_fd)) {
1409
1410                 DEBUG(3, ("cli_close failed on %s. purging server.\n",
1411                           file->fname));
1412                 /* Deallocate slot and remove the server
1413                  * from the server cache if unused */
1414                 errno = smbc_errno(context, targetcli);
1415                 srv = file->srv;
1416                 DLIST_REMOVE(context->internal->_files, file);
1417                 SAFE_FREE(file->fname);
1418                 SAFE_FREE(file);
1419                 context->callbacks.remove_unused_server_fn(context, srv);
1420
1421                 return -1;
1422
1423         }
1424
1425         DLIST_REMOVE(context->internal->_files, file);
1426         SAFE_FREE(file->fname);
1427         SAFE_FREE(file);
1428
1429         return 0;
1430 }
1431
1432 /*
1433  * Get info from an SMB server on a file. Use a qpathinfo call first
1434  * and if that fails, use getatr, as Win95 sometimes refuses qpathinfo
1435  */
1436 static BOOL
1437 smbc_getatr(SMBCCTX * context,
1438             SMBCSRV *srv,
1439             char *path,
1440             uint16 *mode,
1441             SMB_OFF_T *size,
1442             time_t *c_time,
1443             time_t *a_time,
1444             time_t *m_time,
1445             SMB_INO_T *ino)
1446 {
1447         pstring fixedpath;
1448         pstring targetpath;
1449         struct cli_state *targetcli;
1450
1451         if (!context || !context->internal ||
1452             !context->internal->_initialized) {
1453
1454                 errno = EINVAL;
1455                 return -1;
1456
1457         }
1458
1459         /* path fixup for . and .. */
1460         if (strequal(path, ".") || strequal(path, ".."))
1461                 pstrcpy(fixedpath, "\\");
1462         else
1463         {
1464                 pstrcpy(fixedpath, path);
1465                 trim_string(fixedpath, NULL, "\\..");
1466                 trim_string(fixedpath, NULL, "\\.");
1467         }
1468         DEBUG(4,("smbc_getatr: sending qpathinfo\n"));
1469
1470         if (!cli_resolve_path( "", &srv->cli, fixedpath, &targetcli, targetpath))
1471         {
1472                 d_printf("Couldn't resolve %s\n", path);
1473                 return False;
1474         }
1475
1476         if ( targetcli->dfsroot )
1477         {
1478                 pstring temppath;
1479                 pstrcpy(temppath, targetpath);
1480                 cli_dfs_make_full_path(targetpath, targetcli->desthost,
1481                                        targetcli->share, temppath);
1482         }
1483
1484         if (!srv->no_pathinfo2 &&
1485             cli_qpathinfo2(targetcli, targetpath,
1486                            c_time, a_time, m_time, NULL, size, mode, ino)) {
1487             return True;
1488         }
1489
1490         /* if this is NT then don't bother with the getatr */
1491         if (targetcli->capabilities & CAP_NT_SMBS) {
1492                 errno = EPERM;
1493                 return False;
1494         }
1495
1496         if (cli_getatr(targetcli, targetpath, mode, size, m_time)) {
1497                 if (m_time != NULL) {
1498                         if (a_time != NULL) *a_time = *m_time;
1499                         if (c_time != NULL) *c_time = *m_time;
1500                 }
1501                 srv->no_pathinfo2 = True;
1502                 return True;
1503         }
1504
1505         errno = EPERM;
1506         return False;
1507
1508 }
1509
1510 /*
1511  * Set file info on an SMB server.  Use setpathinfo call first.  If that
1512  * fails, use setattrE..
1513  *
1514  * Access and modification time parameters are always used and must be
1515  * provided.  Create time, if zero, will be determined from the actual create
1516  * time of the file.  If non-zero, the create time will be set as well.
1517  *
1518  * "mode" (attributes) parameter may be set to -1 if it is not to be set.
1519  */
1520 static BOOL
1521 smbc_setatr(SMBCCTX * context, SMBCSRV *srv, char *path,
1522             time_t c_time, time_t a_time, time_t m_time,
1523             uint16 mode)
1524 {
1525         int fd;
1526         int ret;
1527
1528         /*
1529          * First, try setpathinfo (if qpathinfo succeeded), for it is the
1530          * modern function for "new code" to be using, and it works given a
1531          * filename rather than requiring that the file be opened to have its
1532          * attributes manipulated.
1533          */
1534         if (srv->no_pathinfo ||
1535             ! cli_setpathinfo(&srv->cli, path, c_time, a_time, m_time, mode)) {
1536
1537                 /*
1538                  * setpathinfo is not supported; go to plan B.
1539                  *
1540                  * cli_setatr() does not work on win98, and it also doesn't
1541                  * support setting the access time (only the modification
1542                  * time), so in all cases, we open the specified file and use
1543                  * cli_setattrE() which should work on all OS versions, and
1544                  * supports both times.
1545                  */
1546
1547                 /* Don't try {q,set}pathinfo() again, with this server */
1548                 srv->no_pathinfo = True;
1549
1550                 /* Open the file */
1551                 if ((fd = cli_open(&srv->cli, path, O_RDWR, DENY_NONE)) < 0) {
1552
1553                         errno = smbc_errno(context, &srv->cli);
1554                         return -1;
1555                 }
1556
1557                 /*
1558                  * Get the creat time of the file (if it wasn't provided).
1559                  * We'll need it in the set call
1560                  */
1561                 if (c_time == 0) {
1562                         ret = cli_getattrE(&srv->cli, fd,
1563                                            NULL, NULL,
1564                                            &c_time, NULL, NULL);
1565                 } else {
1566                         ret = True;
1567                 }
1568
1569                 /* If we got create time, set times */
1570                 if (ret) {
1571                         /* Some OS versions don't support create time */
1572                         if (c_time == 0 || c_time == -1) {
1573                                 c_time = time(NULL);
1574                         }
1575
1576                         /*
1577                          * For sanity sake, since there is no POSIX function
1578                          * to set the create time of a file, if the existing
1579                          * create time is greater than either of access time
1580                          * or modification time, set create time to the
1581                          * smallest of those.  This ensure that the create
1582                          * time of a file is never greater than its last
1583                          * access or modification time.
1584                          */
1585                         if (c_time > a_time) c_time = a_time;
1586                         if (c_time > m_time) c_time = m_time;
1587
1588                         /* Set the new attributes */
1589                         ret = cli_setattrE(&srv->cli, fd,
1590                                            c_time, a_time, m_time);
1591                         cli_close(&srv->cli, fd);
1592                 }
1593
1594                 /*
1595                  * Unfortunately, setattrE() doesn't have a provision for
1596                  * setting the access mode (attributes).  We'll have to try
1597                  * cli_setatr() for that, and with only this parameter, it
1598                  * seems to work on win98.
1599                  */
1600                 if (ret && mode != (uint16) -1) {
1601                         ret = cli_setatr(&srv->cli, path, mode, 0);
1602                 }
1603
1604                 if (! ret) {
1605                         errno = smbc_errno(context, &srv->cli);
1606                         return False;
1607                 }
1608         }
1609
1610         return True;
1611 }
1612
1613  /*
1614   * Routine to unlink() a file
1615   */
1616
1617 static int
1618 smbc_unlink_ctx(SMBCCTX *context,
1619                 const char *fname)
1620 {
1621         fstring server, share, user, password, workgroup;
1622         pstring path, targetpath;
1623         struct cli_state *targetcli;
1624         SMBCSRV *srv = NULL;
1625
1626         if (!context || !context->internal ||
1627             !context->internal->_initialized) {
1628
1629                 errno = EINVAL;  /* Best I can think of ... */
1630                 return -1;
1631
1632         }
1633
1634         if (!fname) {
1635
1636                 errno = EINVAL;
1637                 return -1;
1638
1639         }
1640
1641         if (smbc_parse_path(context, fname,
1642                             workgroup, sizeof(workgroup),
1643                             server, sizeof(server),
1644                             share, sizeof(share),
1645                             path, sizeof(path),
1646                             user, sizeof(user),
1647                             password, sizeof(password),
1648                             NULL, 0)) {
1649                 errno = EINVAL;
1650                 return -1;
1651         }
1652
1653         if (user[0] == (char)0) fstrcpy(user, context->user);
1654
1655         srv = smbc_server(context, True,
1656                           server, share, workgroup, user, password);
1657
1658         if (!srv) {
1659
1660                 return -1;  /* smbc_server sets errno */
1661
1662         }
1663
1664         /*d_printf(">>>unlink: resolving %s\n", path);*/
1665         if (!cli_resolve_path( "", &srv->cli, path, &targetcli, targetpath))
1666         {
1667                 d_printf("Could not resolve %s\n", path);
1668                 return -1;
1669         }
1670         /*d_printf(">>>unlink: resolved path as %s\n", targetpath);*/
1671
1672         if (!cli_unlink(targetcli, targetpath)) {
1673
1674                 errno = smbc_errno(context, targetcli);
1675
1676                 if (errno == EACCES) { /* Check if the file is a directory */
1677
1678                         int saverr = errno;
1679                         SMB_OFF_T size = 0;
1680                         uint16 mode = 0;
1681                         time_t m_time = 0, a_time = 0, c_time = 0;
1682                         SMB_INO_T ino = 0;
1683
1684                         if (!smbc_getatr(context, srv, path, &mode, &size,
1685                                          &c_time, &a_time, &m_time, &ino)) {
1686
1687                                 /* Hmmm, bad error ... What? */
1688
1689                                 errno = smbc_errno(context, targetcli);
1690                                 return -1;
1691
1692                         }
1693                         else {
1694
1695                                 if (IS_DOS_DIR(mode))
1696                                         errno = EISDIR;
1697                                 else
1698                                         errno = saverr;  /* Restore this */
1699
1700                         }
1701                 }
1702
1703                 return -1;
1704
1705         }
1706
1707         return 0;  /* Success ... */
1708
1709 }
1710
1711 /*
1712  * Routine to rename() a file
1713  */
1714
1715 static int
1716 smbc_rename_ctx(SMBCCTX *ocontext,
1717                 const char *oname,
1718                 SMBCCTX *ncontext,
1719                 const char *nname)
1720 {
1721         fstring server1;
1722         fstring share1;
1723         fstring server2;
1724         fstring share2;
1725         fstring user1;
1726         fstring user2;
1727         fstring password1;
1728         fstring password2;
1729         fstring workgroup;
1730         pstring path1;
1731         pstring path2;
1732         pstring targetpath1;
1733         pstring targetpath2;
1734         struct cli_state *targetcli1;
1735         struct cli_state *targetcli2;
1736         SMBCSRV *srv = NULL;
1737
1738         if (!ocontext || !ncontext ||
1739             !ocontext->internal || !ncontext->internal ||
1740             !ocontext->internal->_initialized ||
1741             !ncontext->internal->_initialized) {
1742
1743                 errno = EINVAL;  /* Best I can think of ... */
1744                 return -1;
1745
1746         }
1747
1748         if (!oname || !nname) {
1749
1750                 errno = EINVAL;
1751                 return -1;
1752
1753         }
1754
1755         DEBUG(4, ("smbc_rename(%s,%s)\n", oname, nname));
1756
1757         smbc_parse_path(ocontext, oname,
1758                         workgroup, sizeof(workgroup),
1759                         server1, sizeof(server1),
1760                         share1, sizeof(share1),
1761                         path1, sizeof(path1),
1762                         user1, sizeof(user1),
1763                         password1, sizeof(password1),
1764                         NULL, 0);
1765
1766         if (user1[0] == (char)0) fstrcpy(user1, ocontext->user);
1767
1768         smbc_parse_path(ncontext, nname,
1769                         NULL, 0,
1770                         server2, sizeof(server2),
1771                         share2, sizeof(share2),
1772                         path2, sizeof(path2),
1773                         user2, sizeof(user2),
1774                         password2, sizeof(password2),
1775                         NULL, 0);
1776
1777         if (user2[0] == (char)0) fstrcpy(user2, ncontext->user);
1778
1779         if (strcmp(server1, server2) || strcmp(share1, share2) ||
1780             strcmp(user1, user2)) {
1781
1782                 /* Can't rename across file systems, or users?? */
1783
1784                 errno = EXDEV;
1785                 return -1;
1786
1787         }
1788
1789         srv = smbc_server(ocontext, True,
1790                           server1, share1, workgroup, user1, password1);
1791         if (!srv) {
1792
1793                 return -1;
1794
1795         }
1796
1797         /*d_printf(">>>rename: resolving %s\n", path1);*/
1798         if (!cli_resolve_path( "", &srv->cli, path1, &targetcli1, targetpath1))
1799         {
1800                 d_printf("Could not resolve %s\n", path1);
1801                 return -1;
1802         }
1803         /*d_printf(">>>rename: resolved path as %s\n", targetpath1);*/
1804         /*d_printf(">>>rename: resolving %s\n", path2);*/
1805         if (!cli_resolve_path( "", &srv->cli, path2, &targetcli2, targetpath2))
1806         {
1807                 d_printf("Could not resolve %s\n", path2);
1808                 return -1;
1809         }
1810         /*d_printf(">>>rename: resolved path as %s\n", targetpath2);*/
1811
1812         if (strcmp(targetcli1->desthost, targetcli2->desthost) ||
1813             strcmp(targetcli1->share, targetcli2->share))
1814         {
1815                 /* can't rename across file systems */
1816
1817                 errno = EXDEV;
1818                 return -1;
1819         }
1820
1821         if (!cli_rename(targetcli1, targetpath1, targetpath2)) {
1822                 int eno = smbc_errno(ocontext, targetcli1);
1823
1824                 if (eno != EEXIST ||
1825                     !cli_unlink(targetcli1, targetpath2) ||
1826                     !cli_rename(targetcli1, targetpath1, targetpath2)) {
1827
1828                         errno = eno;
1829                         return -1;
1830
1831                 }
1832         }
1833
1834         return 0; /* Success */
1835
1836 }
1837
1838 /*
1839  * A routine to lseek() a file
1840  */
1841
1842 static off_t
1843 smbc_lseek_ctx(SMBCCTX *context,
1844                SMBCFILE *file,
1845                off_t offset,
1846                int whence)
1847 {
1848         SMB_OFF_T size;
1849         fstring server, share, user, password;
1850         pstring path, targetpath;
1851         struct cli_state *targetcli;
1852
1853         if (!context || !context->internal ||
1854             !context->internal->_initialized) {
1855
1856                 errno = EINVAL;
1857                 return -1;
1858
1859         }
1860
1861         if (!file || !DLIST_CONTAINS(context->internal->_files, file)) {
1862
1863                 errno = EBADF;
1864                 return -1;
1865
1866         }
1867
1868         if (!file->file) {
1869
1870                 errno = EINVAL;
1871                 return -1;      /* Can't lseek a dir ... */
1872
1873         }
1874
1875         switch (whence) {
1876         case SEEK_SET:
1877                 file->offset = offset;
1878                 break;
1879
1880         case SEEK_CUR:
1881                 file->offset += offset;
1882                 break;
1883
1884         case SEEK_END:
1885                 /*d_printf(">>>lseek: parsing %s\n", file->fname);*/
1886                 if (smbc_parse_path(context, file->fname,
1887                                     NULL, 0,
1888                                     server, sizeof(server),
1889                                     share, sizeof(share),
1890                                     path, sizeof(path),
1891                                     user, sizeof(user),
1892                                     password, sizeof(password),
1893                                     NULL, 0)) {
1894
1895                                         errno = EINVAL;
1896                                         return -1;
1897                         }
1898
1899                 /*d_printf(">>>lseek: resolving %s\n", path);*/
1900                 if (!cli_resolve_path("", &file->srv->cli, path,
1901                                       &targetcli, targetpath))
1902                 {
1903                         d_printf("Could not resolve %s\n", path);
1904                         return -1;
1905                 }
1906                 /*d_printf(">>>lseek: resolved path as %s\n", targetpath);*/
1907
1908                 if (!cli_qfileinfo(targetcli, file->cli_fd, NULL,
1909                                    &size, NULL, NULL, NULL, NULL, NULL))
1910                 {
1911                     SMB_OFF_T b_size = size;
1912                         if (!cli_getattrE(targetcli, file->cli_fd,
1913                                           NULL, &b_size, NULL, NULL, NULL))
1914                     {
1915                         errno = EINVAL;
1916                         return -1;
1917                     } else
1918                         size = b_size;
1919                 }
1920                 file->offset = size + offset;
1921                 break;
1922
1923         default:
1924                 errno = EINVAL;
1925                 break;
1926
1927         }
1928
1929         return file->offset;
1930
1931 }
1932
1933 /*
1934  * Generate an inode number from file name for those things that need it
1935  */
1936
1937 static ino_t
1938 smbc_inode(SMBCCTX *context,
1939            const char *name)
1940 {
1941
1942         if (!context || !context->internal ||
1943             !context->internal->_initialized) {
1944
1945                 errno = EINVAL;
1946                 return -1;
1947
1948         }
1949
1950         if (!*name) return 2; /* FIXME, why 2 ??? */
1951         return (ino_t)str_checksum(name);
1952
1953 }
1954
1955 /*
1956  * Routine to put basic stat info into a stat structure ... Used by stat and
1957  * fstat below.
1958  */
1959
1960 static int
1961 smbc_setup_stat(SMBCCTX *context,
1962                 struct stat *st,
1963                 char *fname,
1964                 SMB_OFF_T size,
1965                 int mode)
1966 {
1967
1968         st->st_mode = 0;
1969
1970         if (IS_DOS_DIR(mode)) {
1971                 st->st_mode = SMBC_DIR_MODE;
1972         } else {
1973                 st->st_mode = SMBC_FILE_MODE;
1974         }
1975
1976         if (IS_DOS_ARCHIVE(mode)) st->st_mode |= S_IXUSR;
1977         if (IS_DOS_SYSTEM(mode)) st->st_mode |= S_IXGRP;
1978         if (IS_DOS_HIDDEN(mode)) st->st_mode |= S_IXOTH;
1979         if (!IS_DOS_READONLY(mode)) st->st_mode |= S_IWUSR;
1980
1981         st->st_size = size;
1982 #ifdef HAVE_STAT_ST_BLKSIZE
1983         st->st_blksize = 512;
1984 #endif
1985 #ifdef HAVE_STAT_ST_BLOCKS
1986         st->st_blocks = (size+511)/512;
1987 #endif
1988         st->st_uid = getuid();
1989         st->st_gid = getgid();
1990
1991         if (IS_DOS_DIR(mode)) {
1992                 st->st_nlink = 2;
1993         } else {
1994                 st->st_nlink = 1;
1995         }
1996
1997         if (st->st_ino == 0) {
1998                 st->st_ino = smbc_inode(context, fname);
1999         }
2000
2001         return True;  /* FIXME: Is this needed ? */
2002
2003 }
2004
2005 /*
2006  * Routine to stat a file given a name
2007  */
2008
2009 static int
2010 smbc_stat_ctx(SMBCCTX *context,
2011               const char *fname,
2012               struct stat *st)
2013 {
2014         SMBCSRV *srv;
2015         fstring server;
2016         fstring share;
2017         fstring user;
2018         fstring password;
2019         fstring workgroup;
2020         pstring path;
2021         time_t m_time = 0;
2022         time_t a_time = 0;
2023         time_t c_time = 0;
2024         SMB_OFF_T size = 0;
2025         uint16 mode = 0;
2026         SMB_INO_T ino = 0;
2027
2028         if (!context || !context->internal ||
2029             !context->internal->_initialized) {
2030
2031                 errno = EINVAL;  /* Best I can think of ... */
2032                 return -1;
2033
2034         }
2035
2036         if (!fname) {
2037
2038                 errno = EINVAL;
2039                 return -1;
2040
2041         }
2042
2043         DEBUG(4, ("smbc_stat(%s)\n", fname));
2044
2045         if (smbc_parse_path(context, fname,
2046                             workgroup, sizeof(workgroup),
2047                             server, sizeof(server),
2048                             share, sizeof(share),
2049                             path, sizeof(path),
2050                             user, sizeof(user),
2051                             password, sizeof(password),
2052                             NULL, 0)) {
2053                 errno = EINVAL;
2054                 return -1;
2055         }
2056
2057         if (user[0] == (char)0) fstrcpy(user, context->user);
2058
2059         srv = smbc_server(context, True,
2060                           server, share, workgroup, user, password);
2061
2062         if (!srv) {
2063                 return -1;  /* errno set by smbc_server */
2064         }
2065
2066         if (!smbc_getatr(context, srv, path, &mode, &size,
2067                          &c_time, &a_time, &m_time, &ino)) {
2068
2069                 errno = smbc_errno(context, &srv->cli);
2070                 return -1;
2071
2072         }
2073
2074         st->st_ino = ino;
2075
2076         smbc_setup_stat(context, st, path, size, mode);
2077
2078         st->st_atime = a_time;
2079         st->st_ctime = c_time;
2080         st->st_mtime = m_time;
2081         st->st_dev   = srv->dev;
2082
2083         return 0;
2084
2085 }
2086
2087 /*
2088  * Routine to stat a file given an fd
2089  */
2090
2091 static int
2092 smbc_fstat_ctx(SMBCCTX *context,
2093                SMBCFILE *file,
2094                struct stat *st)
2095 {
2096         time_t c_time;
2097         time_t a_time;
2098         time_t m_time;
2099         SMB_OFF_T size;
2100         uint16 mode;
2101         fstring server;
2102         fstring share;
2103         fstring user;
2104         fstring password;
2105         pstring path;
2106         pstring targetpath;
2107         struct cli_state *targetcli;
2108         SMB_INO_T ino = 0;
2109
2110         if (!context || !context->internal ||
2111             !context->internal->_initialized) {
2112
2113                 errno = EINVAL;
2114                 return -1;
2115
2116         }
2117
2118         if (!file || !DLIST_CONTAINS(context->internal->_files, file)) {
2119
2120                 errno = EBADF;
2121                 return -1;
2122
2123         }
2124
2125         if (!file->file) {
2126
2127                 return context->fstatdir(context, file, st);
2128
2129         }
2130
2131         /*d_printf(">>>fstat: parsing %s\n", file->fname);*/
2132         if (smbc_parse_path(context, file->fname,
2133                             NULL, 0,
2134                             server, sizeof(server),
2135                             share, sizeof(share),
2136                             path, sizeof(path),
2137                             user, sizeof(user),
2138                             password, sizeof(password),
2139                             NULL, 0)) {
2140                 errno = EINVAL;
2141                 return -1;
2142         }
2143
2144         /*d_printf(">>>fstat: resolving %s\n", path);*/
2145         if (!cli_resolve_path("", &file->srv->cli, path,
2146                               &targetcli, targetpath))
2147         {
2148                 d_printf("Could not resolve %s\n", path);
2149                 return -1;
2150         }
2151         /*d_printf(">>>fstat: resolved path as %s\n", targetpath);*/
2152
2153         if (!cli_qfileinfo(targetcli, file->cli_fd, &mode, &size,
2154                            &c_time, &a_time, &m_time, NULL, &ino)) {
2155             if (!cli_getattrE(targetcli, file->cli_fd, &mode, &size,
2156                               &c_time, &a_time, &m_time)) {
2157
2158                 errno = EINVAL;
2159                 return -1;
2160             }
2161         }
2162
2163         st->st_ino = ino;
2164
2165         smbc_setup_stat(context, st, file->fname, size, mode);
2166
2167         st->st_atime = a_time;
2168         st->st_ctime = c_time;
2169         st->st_mtime = m_time;
2170         st->st_dev = file->srv->dev;
2171
2172         return 0;
2173
2174 }
2175
2176 /*
2177  * Routine to open a directory
2178  * We accept the URL syntax explained in smbc_parse_path(), above.
2179  */
2180
2181 static void
2182 smbc_remove_dir(SMBCFILE *dir)
2183 {
2184         struct smbc_dir_list *d,*f;
2185
2186         d = dir->dir_list;
2187         while (d) {
2188
2189                 f = d; d = d->next;
2190
2191                 SAFE_FREE(f->dirent);
2192                 SAFE_FREE(f);
2193
2194         }
2195
2196         dir->dir_list = dir->dir_end = dir->dir_next = NULL;
2197
2198 }
2199
2200 static int
2201 add_dirent(SMBCFILE *dir,
2202            const char *name,
2203            const char *comment,
2204            uint32 type)
2205 {
2206         struct smbc_dirent *dirent;
2207         int size;
2208         int name_length = (name == NULL ? 0 : strlen(name));
2209         int comment_len = (comment == NULL ? 0 : strlen(comment));
2210
2211         /*
2212          * Allocate space for the dirent, which must be increased by the
2213          * size of the name and the comment and 1 each for the null terminator.
2214          */
2215
2216         size = sizeof(struct smbc_dirent) + name_length + comment_len + 2;
2217
2218         dirent = SMB_MALLOC(size);
2219
2220         if (!dirent) {
2221
2222                 dir->dir_error = ENOMEM;
2223                 return -1;
2224
2225         }
2226
2227         ZERO_STRUCTP(dirent);
2228
2229         if (dir->dir_list == NULL) {
2230
2231                 dir->dir_list = SMB_MALLOC_P(struct smbc_dir_list);
2232                 if (!dir->dir_list) {
2233
2234                         SAFE_FREE(dirent);
2235                         dir->dir_error = ENOMEM;
2236                         return -1;
2237
2238                 }
2239                 ZERO_STRUCTP(dir->dir_list);
2240
2241                 dir->dir_end = dir->dir_next = dir->dir_list;
2242         }
2243         else {
2244
2245                 dir->dir_end->next = SMB_MALLOC_P(struct smbc_dir_list);
2246
2247                 if (!dir->dir_end->next) {
2248
2249                         SAFE_FREE(dirent);
2250                         dir->dir_error = ENOMEM;
2251                         return -1;
2252
2253                 }
2254                 ZERO_STRUCTP(dir->dir_end->next);
2255
2256                 dir->dir_end = dir->dir_end->next;
2257         }
2258
2259         dir->dir_end->next = NULL;
2260         dir->dir_end->dirent = dirent;
2261
2262         dirent->smbc_type = type;
2263         dirent->namelen = name_length;
2264         dirent->commentlen = comment_len;
2265         dirent->dirlen = size;
2266
2267         /*
2268          * dirent->namelen + 1 includes the null (no null termination needed)
2269          * Ditto for dirent->commentlen.
2270          * The space for the two null bytes was allocated.
2271          */
2272         strncpy(dirent->name, (name?name:""), dirent->namelen + 1);
2273         dirent->comment = (char *)(&dirent->name + dirent->namelen + 1);
2274         strncpy(dirent->comment, (comment?comment:""), dirent->commentlen + 1);
2275
2276         return 0;
2277
2278 }
2279
2280 static void
2281 list_unique_wg_fn(const char *name,
2282                   uint32 type,
2283                   const char *comment,
2284                   void *state)
2285 {
2286         SMBCFILE *dir = (SMBCFILE *)state;
2287         struct smbc_dir_list *dir_list;
2288         struct smbc_dirent *dirent;
2289         int dirent_type;
2290         int do_remove = 0;
2291
2292         dirent_type = dir->dir_type;
2293
2294         if (add_dirent(dir, name, comment, dirent_type) < 0) {
2295
2296                 /* An error occurred, what do we do? */
2297                 /* FIXME: Add some code here */
2298         }
2299
2300         /* Point to the one just added */
2301         dirent = dir->dir_end->dirent;
2302
2303         /* See if this was a duplicate */
2304         for (dir_list = dir->dir_list;
2305              dir_list != dir->dir_end;
2306              dir_list = dir_list->next) {
2307                 if (! do_remove &&
2308                     strcmp(dir_list->dirent->name, dirent->name) == 0) {
2309                         /* Duplicate.  End end of list need to be removed. */
2310                         do_remove = 1;
2311                 }
2312
2313                 if (do_remove && dir_list->next == dir->dir_end) {
2314                         /* Found the end of the list.  Remove it. */
2315                         dir->dir_end = dir_list;
2316                         free(dir_list->next);
2317                         free(dirent);
2318                         dir_list->next = NULL;
2319                         break;
2320                 }
2321         }
2322 }
2323
2324 static void
2325 list_fn(const char *name,
2326         uint32 type,
2327         const char *comment,
2328         void *state)
2329 {
2330         SMBCFILE *dir = (SMBCFILE *)state;
2331         int dirent_type;
2332
2333         /*
2334          * We need to process the type a little ...
2335          *
2336          * Disk share     = 0x00000000
2337          * Print share    = 0x00000001
2338          * Comms share    = 0x00000002 (obsolete?)
2339          * IPC$ share     = 0x00000003
2340          *
2341          * administrative shares:
2342          * ADMIN$, IPC$, C$, D$, E$ ...  are type |= 0x80000000
2343          */
2344
2345         if (dir->dir_type == SMBC_FILE_SHARE) {
2346
2347                 switch (type) {
2348                 case 0 | 0x80000000:
2349                 case 0:
2350                         dirent_type = SMBC_FILE_SHARE;
2351                         break;
2352
2353                 case 1:
2354                         dirent_type = SMBC_PRINTER_SHARE;
2355                         break;
2356
2357                 case 2:
2358                         dirent_type = SMBC_COMMS_SHARE;
2359                         break;
2360
2361                 case 3 | 0x80000000:
2362                 case 3:
2363                         dirent_type = SMBC_IPC_SHARE;
2364                         break;
2365
2366                 default:
2367                         dirent_type = SMBC_FILE_SHARE; /* FIXME, error? */
2368                         break;
2369                 }
2370         }
2371         else {
2372                 dirent_type = dir->dir_type;
2373         }
2374
2375         if (add_dirent(dir, name, comment, dirent_type) < 0) {
2376
2377                 /* An error occurred, what do we do? */
2378                 /* FIXME: Add some code here */
2379
2380         }
2381 }
2382
2383 static void
2384 dir_list_fn(const char *mnt,
2385             file_info *finfo,
2386             const char *mask,
2387             void *state)
2388 {
2389
2390         if (add_dirent((SMBCFILE *)state, finfo->name, "",
2391                        (finfo->mode&aDIR?SMBC_DIR:SMBC_FILE)) < 0) {
2392
2393                 /* Handle an error ... */
2394
2395                 /* FIXME: Add some code ... */
2396
2397         }
2398
2399 }
2400
2401 static int
2402 net_share_enum_rpc(struct cli_state *cli,
2403                    void (*fn)(const char *name,
2404                               uint32 type,
2405                               const char *comment,
2406                               void *state),
2407                    void *state)
2408 {
2409         int i;
2410         WERROR result;
2411         ENUM_HND enum_hnd;
2412         uint32 info_level = 1;
2413         uint32 preferred_len = 0xffffffff;
2414         uint32 type;
2415         SRV_SHARE_INFO_CTR ctr;
2416         fstring name = "";
2417         fstring comment = "";
2418         void *mem_ctx;
2419         struct rpc_pipe_client *pipe_hnd;
2420         NTSTATUS nt_status;
2421
2422         /* Open the server service pipe */
2423         pipe_hnd = cli_rpc_pipe_open_noauth(cli, PI_SRVSVC, &nt_status);
2424         if (!pipe_hnd) {
2425                 DEBUG(1, ("net_share_enum_rpc pipe open fail!\n"));
2426                 return -1;
2427         }
2428
2429         /* Allocate a context for parsing and for the entries in "ctr" */
2430         mem_ctx = talloc_init("libsmbclient: net_share_enum_rpc");
2431         if (mem_ctx == NULL) {
2432                 DEBUG(0, ("out of memory for net_share_enum_rpc!\n"));
2433                 cli_rpc_pipe_close(pipe_hnd);
2434                 return -1;
2435         }
2436
2437         /* Issue the NetShareEnum RPC call and retrieve the response */
2438         init_enum_hnd(&enum_hnd, 0);
2439         result = rpccli_srvsvc_net_share_enum(pipe_hnd,
2440                                               mem_ctx,
2441                                               info_level,
2442                                               &ctr,
2443                                               preferred_len,
2444                                               &enum_hnd);
2445
2446         /* Was it successful? */
2447         if (!W_ERROR_IS_OK(result) || ctr.num_entries == 0) {
2448                 /*  Nope.  Go clean up. */
2449                 goto done;
2450         }
2451
2452         /* For each returned entry... */
2453         for (i = 0; i < ctr.num_entries; i++) {
2454
2455                 /* pull out the share name */
2456                 rpcstr_pull_unistr2_fstring(
2457                         name, &ctr.share.info1[i].info_1_str.uni_netname);
2458
2459                 /* pull out the share's comment */
2460                 rpcstr_pull_unistr2_fstring(
2461                         comment, &ctr.share.info1[i].info_1_str.uni_remark);
2462
2463                 /* Get the type value */
2464                 type = ctr.share.info1[i].info_1.type;
2465
2466                 /* Add this share to the list */
2467                 (*fn)(name, type, comment, state);
2468         }
2469
2470 done:
2471         /* Close the server service pipe */
2472         cli_rpc_pipe_close(pipe_hnd);
2473
2474         /* Free all memory which was allocated for this request */
2475         TALLOC_FREE(mem_ctx);
2476
2477         /* Tell 'em if it worked */
2478         return W_ERROR_IS_OK(result) ? 0 : -1;
2479 }
2480
2481
2482
2483 static SMBCFILE *
2484 smbc_opendir_ctx(SMBCCTX *context,
2485                  const char *fname)
2486 {
2487         fstring server, share, user, password, options;
2488         pstring workgroup;
2489         pstring path;
2490         uint16 mode;
2491         char *p;
2492         SMBCSRV *srv  = NULL;
2493         SMBCFILE *dir = NULL;
2494         struct in_addr rem_ip;
2495
2496         if (!context || !context->internal ||
2497             !context->internal->_initialized) {
2498                 DEBUG(4, ("no valid context\n"));
2499                 errno = EINVAL + 8192;
2500                 return NULL;
2501
2502         }
2503
2504         if (!fname) {
2505                 DEBUG(4, ("no valid fname\n"));
2506                 errno = EINVAL + 8193;
2507                 return NULL;
2508         }
2509
2510         if (smbc_parse_path(context, fname,
2511                             workgroup, sizeof(workgroup),
2512                             server, sizeof(server),
2513                             share, sizeof(share),
2514                             path, sizeof(path),
2515                             user, sizeof(user),
2516                             password, sizeof(password),
2517                             options, sizeof(options))) {
2518                 DEBUG(4, ("no valid path\n"));
2519                 errno = EINVAL + 8194;
2520                 return NULL;
2521         }
2522
2523         DEBUG(4, ("parsed path: fname='%s' server='%s' share='%s' "
2524                   "path='%s' options='%s'\n",
2525                   fname, server, share, path, options));
2526
2527         /* Ensure the options are valid */
2528         if (smbc_check_options(server, share, path, options)) {
2529                 DEBUG(4, ("unacceptable options (%s)\n", options));
2530                 errno = EINVAL + 8195;
2531                 return NULL;
2532         }
2533
2534         if (user[0] == (char)0) fstrcpy(user, context->user);
2535
2536         dir = SMB_MALLOC_P(SMBCFILE);
2537
2538         if (!dir) {
2539
2540                 errno = ENOMEM;
2541                 return NULL;
2542
2543         }
2544
2545         ZERO_STRUCTP(dir);
2546
2547         dir->cli_fd   = 0;
2548         dir->fname    = SMB_STRDUP(fname);
2549         dir->srv      = NULL;
2550         dir->offset   = 0;
2551         dir->file     = False;
2552         dir->dir_list = dir->dir_next = dir->dir_end = NULL;
2553
2554         if (server[0] == (char)0) {
2555
2556                 int i;
2557                 int count;
2558                 int max_lmb_count;
2559                 struct ip_service *ip_list;
2560                 struct ip_service server_addr;
2561                 struct user_auth_info u_info;
2562                 struct cli_state *cli;
2563
2564                 if (share[0] != (char)0 || path[0] != (char)0) {
2565
2566                         errno = EINVAL + 8196;
2567                         if (dir) {
2568                                 SAFE_FREE(dir->fname);
2569                                 SAFE_FREE(dir);
2570                         }
2571                         return NULL;
2572                 }
2573
2574                 /* Determine how many local master browsers to query */
2575                 max_lmb_count = (context->options.browse_max_lmb_count == 0
2576                                  ? INT_MAX
2577                                  : context->options.browse_max_lmb_count);
2578
2579                 pstrcpy(u_info.username, user);
2580                 pstrcpy(u_info.password, password);
2581
2582                 /*
2583                  * We have server and share and path empty but options
2584                  * requesting that we scan all master browsers for their list
2585                  * of workgroups/domains.  This implies that we must first try
2586                  * broadcast queries to find all master browsers, and if that
2587                  * doesn't work, then try our other methods which return only
2588                  * a single master browser.
2589                  */
2590
2591                 ip_list = NULL;
2592                 if (!name_resolve_bcast(MSBROWSE, 1, &ip_list, &count)) {
2593
2594                         SAFE_FREE(ip_list);
2595
2596                         if (!find_master_ip(workgroup, &server_addr.ip)) {
2597
2598                                 if (dir) {
2599                                         SAFE_FREE(dir->fname);
2600                                         SAFE_FREE(dir);
2601                                 }
2602                                 errno = ENOENT;
2603                                 return NULL;
2604                         }
2605
2606                         ip_list = &server_addr;
2607                         count = 1;
2608                 }
2609
2610                 for (i = 0; i < count && i < max_lmb_count; i++) {
2611                         DEBUG(99, ("Found master browser %d of %d: %s\n",
2612                                    i+1, MAX(count, max_lmb_count),
2613                                    inet_ntoa(ip_list[i].ip)));
2614
2615                         cli = get_ipc_connect_master_ip(&ip_list[i],
2616                                                         workgroup, &u_info);
2617                         /* cli == NULL is the master browser refused to talk or
2618                            could not be found */
2619                         if ( !cli )
2620                                 continue;
2621
2622                         fstrcpy(server, cli->desthost);
2623                         cli_shutdown(cli);
2624
2625                         DEBUG(4, ("using workgroup %s %s\n",
2626                                   workgroup, server));
2627
2628                         /*
2629                          * For each returned master browser IP address, get a
2630                          * connection to IPC$ on the server if we do not
2631                          * already have one, and determine the
2632                          * workgroups/domains that it knows about.
2633                          */
2634
2635                         srv = smbc_server(context, True, server, "IPC$",
2636                                           workgroup, user, password);
2637                         if (!srv) {
2638                                 continue;
2639                         }
2640
2641                         dir->srv = srv;
2642                         dir->dir_type = SMBC_WORKGROUP;
2643
2644                         /* Now, list the stuff ... */
2645
2646                         if (!cli_NetServerEnum(&srv->cli,
2647                                                workgroup,
2648                                                SV_TYPE_DOMAIN_ENUM,
2649                                                list_unique_wg_fn,
2650                                                (void *)dir)) {
2651                                 continue;
2652                         }
2653                 }
2654
2655                 SAFE_FREE(ip_list);
2656         } else {
2657                 /*
2658                  * Server not an empty string ... Check the rest and see what
2659                  * gives
2660                  */
2661                 if (*share == '\0') {
2662                         if (*path != '\0') {
2663
2664                                 /* Should not have empty share with path */
2665                                 errno = EINVAL + 8197;
2666                                 if (dir) {
2667                                         SAFE_FREE(dir->fname);
2668                                         SAFE_FREE(dir);
2669                                 }
2670                                 return NULL;
2671
2672                         }
2673
2674                         /*
2675                          * We don't know if <server> is really a server name
2676                          * or is a workgroup/domain name.  If we already have
2677                          * a server structure for it, we'll use it.
2678                          * Otherwise, check to see if <server><1D>,
2679                          * <server><1B>, or <server><20> translates.  We check
2680                          * to see if <server> is an IP address first.
2681                          */
2682
2683                         /*
2684                          * See if we have an existing server.  Do not
2685                          * establish a connection if one does not already
2686                          * exist.
2687                          */
2688                         srv = smbc_server(context, False, server, "IPC$",
2689                                           workgroup, user, password);
2690
2691                         /*
2692                          * If no existing server and not an IP addr, look for
2693                          * LMB or DMB
2694                          */
2695                         if (!srv &&
2696                             !is_ipaddress(server) &&
2697                             (resolve_name(server, &rem_ip, 0x1d) ||   /* LMB */
2698                              resolve_name(server, &rem_ip, 0x1b) )) { /* DMB */
2699
2700                                 fstring buserver;
2701
2702                                 dir->dir_type = SMBC_SERVER;
2703
2704                                 /*
2705                                  * Get the backup list ...
2706                                  */
2707                                 if (!name_status_find(server, 0, 0,
2708                                                       rem_ip, buserver)) {
2709
2710                                         DEBUG(0, ("Could not get name of "
2711                                                   "local/domain master browser "
2712                                                   "for server %s\n", server));
2713                                         if (dir) {
2714                                                 SAFE_FREE(dir->fname);
2715                                                 SAFE_FREE(dir);
2716                                         }
2717                                         errno = EPERM;
2718                                         return NULL;
2719
2720                                 }
2721
2722                                 /*
2723                                  * Get a connection to IPC$ on the server if
2724                                  * we do not already have one
2725                                  */
2726                                 srv = smbc_server(context, True,
2727                                                   buserver, "IPC$",
2728                                                   workgroup, user, password);
2729                                 if (!srv) {
2730                                         DEBUG(0, ("got no contact to IPC$\n"));
2731                                         if (dir) {
2732                                                 SAFE_FREE(dir->fname);
2733                                                 SAFE_FREE(dir);
2734                                         }
2735                                         return NULL;
2736
2737                                 }
2738
2739                                 dir->srv = srv;
2740
2741                                 /* Now, list the servers ... */
2742                                 if (!cli_NetServerEnum(&srv->cli, server,
2743                                                        0x0000FFFE, list_fn,
2744                                                        (void *)dir)) {
2745
2746                                         if (dir) {
2747                                                 SAFE_FREE(dir->fname);
2748                                                 SAFE_FREE(dir);
2749                                         }
2750                                         return NULL;
2751                                 }
2752                         } else if (srv ||
2753                                    (resolve_name(server, &rem_ip, 0x20))) {
2754
2755                                 /* If we hadn't found the server, get one now */
2756                                 if (!srv) {
2757                                         srv = smbc_server(context, True,
2758                                                           server, "IPC$",
2759                                                           workgroup,
2760                                                           user, password);
2761                                 }
2762
2763                                 if (!srv) {
2764                                         if (dir) {
2765                                                 SAFE_FREE(dir->fname);
2766                                                 SAFE_FREE(dir);
2767                                         }
2768                                         return NULL;
2769
2770                                 }
2771
2772                                 dir->dir_type = SMBC_FILE_SHARE;
2773                                 dir->srv = srv;
2774
2775                                 /* List the shares ... */
2776
2777                                 if (net_share_enum_rpc(
2778                                             &srv->cli,
2779                                             list_fn,
2780                                             (void *) dir) < 0 &&
2781                                     cli_RNetShareEnum(
2782                                             &srv->cli,
2783                                             list_fn,
2784                                             (void *)dir) < 0) {
2785
2786                                         errno = cli_errno(&srv->cli);
2787                                         if (dir) {
2788                                                 SAFE_FREE(dir->fname);
2789                                                 SAFE_FREE(dir);
2790                                         }
2791                                         return NULL;
2792
2793                                 }
2794                         } else {
2795                                 /* Neither the workgroup nor server exists */
2796                                 errno = ECONNREFUSED;
2797                                 if (dir) {
2798                                         SAFE_FREE(dir->fname);
2799                                         SAFE_FREE(dir);
2800                                 }
2801                                 return NULL;
2802                         }
2803
2804                 }
2805                 else {
2806                         /*
2807                          * The server and share are specified ... work from
2808                          * there ...
2809                          */
2810                         pstring targetpath;
2811                         struct cli_state *targetcli;
2812
2813                         /* We connect to the server and list the directory */
2814                         dir->dir_type = SMBC_FILE_SHARE;
2815
2816                         srv = smbc_server(context, True, server, share,
2817                                           workgroup, user, password);
2818
2819                         if (!srv) {
2820
2821                                 if (dir) {
2822                                         SAFE_FREE(dir->fname);
2823                                         SAFE_FREE(dir);
2824                                 }
2825                                 return NULL;
2826
2827                         }
2828
2829                         dir->srv = srv;
2830
2831                         /* Now, list the files ... */
2832
2833                         p = path + strlen(path);
2834                         pstrcat(path, "\\*");
2835
2836                         if (!cli_resolve_path("", &srv->cli, path,
2837                                               &targetcli, targetpath))
2838                         {
2839                                 d_printf("Could not resolve %s\n", path);
2840                                 if (dir) {
2841                                         SAFE_FREE(dir->fname);
2842                                         SAFE_FREE(dir);
2843                                 }
2844                                 return NULL;
2845                         }
2846
2847                         if (cli_list(targetcli, targetpath,
2848                                      aDIR | aSYSTEM | aHIDDEN,
2849                                      dir_list_fn, (void *)dir) < 0) {
2850
2851                                 if (dir) {
2852                                         SAFE_FREE(dir->fname);
2853                                         SAFE_FREE(dir);
2854                                 }
2855                                 errno = smbc_errno(context, targetcli);
2856
2857                                 if (errno == EINVAL) {
2858                                     /*
2859                                      * See if they asked to opendir something
2860                                      * other than a directory.  If so, the
2861                                      * converted error value we got would have
2862                                      * been EINVAL rather than ENOTDIR.
2863                                      */
2864                                     *p = '\0'; /* restore original path */
2865
2866                                     if (smbc_getatr(context, srv, path,
2867                                                     &mode, NULL,
2868                                                     NULL, NULL, NULL,
2869                                                     NULL) &&
2870                                         ! IS_DOS_DIR(mode)) {
2871
2872                                         /* It is.  Correct the error value */
2873                                         errno = ENOTDIR;
2874                                     }
2875                                 }
2876
2877                                 return NULL;
2878
2879                         }
2880                 }
2881
2882         }
2883
2884         DLIST_ADD(context->internal->_files, dir);
2885         return dir;
2886
2887 }
2888
2889 /*
2890  * Routine to close a directory
2891  */
2892
2893 static int
2894 smbc_closedir_ctx(SMBCCTX *context,
2895                   SMBCFILE *dir)
2896 {
2897
2898         if (!context || !context->internal ||
2899             !context->internal->_initialized) {
2900
2901                 errno = EINVAL;
2902                 return -1;
2903
2904         }
2905
2906         if (!dir || !DLIST_CONTAINS(context->internal->_files, dir)) {
2907
2908                 errno = EBADF;
2909                 return -1;
2910
2911         }
2912
2913         smbc_remove_dir(dir); /* Clean it up */
2914
2915         DLIST_REMOVE(context->internal->_files, dir);
2916
2917         if (dir) {
2918
2919                 SAFE_FREE(dir->fname);
2920                 SAFE_FREE(dir);    /* Free the space too */
2921         }
2922
2923         return 0;
2924
2925 }
2926
2927 static void
2928 smbc_readdir_internal(SMBCCTX * context,
2929                       struct smbc_dirent *dest,
2930                       struct smbc_dirent *src,
2931                       int max_namebuf_len)
2932 {
2933         if (context->options.urlencode_readdir_entries) {
2934
2935                 /* url-encode the name.  get back remaining buffer space */
2936                 max_namebuf_len =
2937                         smbc_urlencode(dest->name, src->name, max_namebuf_len);
2938
2939                 /* We now know the name length */
2940                 dest->namelen = strlen(dest->name);
2941
2942                 /* Save the pointer to the beginning of the comment */
2943                 dest->comment = dest->name + dest->namelen + 1;
2944
2945                 /* Copy the comment */
2946                 strncpy(dest->comment, src->comment, max_namebuf_len - 1);
2947                 dest->comment[max_namebuf_len - 1] = '\0';
2948
2949                 /* Save other fields */
2950                 dest->smbc_type = src->smbc_type;
2951                 dest->commentlen = strlen(dest->comment);
2952                 dest->dirlen = ((dest->comment + dest->commentlen + 1) -
2953                                 (char *) dest);
2954         } else {
2955
2956                 /* No encoding.  Just copy the entry as is. */
2957                 memcpy(dest, src, src->dirlen);
2958                 dest->comment = (char *)(&dest->name + src->namelen + 1);
2959         }
2960
2961 }
2962
2963 /*
2964  * Routine to get a directory entry
2965  */
2966
2967 struct smbc_dirent *
2968 smbc_readdir_ctx(SMBCCTX *context,
2969                  SMBCFILE *dir)
2970 {
2971         int maxlen;
2972         struct smbc_dirent *dirp, *dirent;
2973
2974         /* Check that all is ok first ... */
2975
2976         if (!context || !context->internal ||
2977             !context->internal->_initialized) {
2978
2979                 errno = EINVAL;
2980                 DEBUG(0, ("Invalid context in smbc_readdir_ctx()\n"));
2981                 return NULL;
2982
2983         }
2984
2985         if (!dir || !DLIST_CONTAINS(context->internal->_files, dir)) {
2986
2987                 errno = EBADF;
2988                 DEBUG(0, ("Invalid dir in smbc_readdir_ctx()\n"));
2989                 return NULL;
2990
2991         }
2992
2993         if (dir->file != False) { /* FIXME, should be dir, perhaps */
2994
2995                 errno = ENOTDIR;
2996                 DEBUG(0, ("Found file vs directory in smbc_readdir_ctx()\n"));
2997                 return NULL;
2998
2999         }
3000
3001         if (!dir->dir_next) {
3002                 return NULL;
3003         }
3004
3005         dirent = dir->dir_next->dirent;
3006         if (!dirent) {
3007
3008                 errno = ENOENT;
3009                 return NULL;
3010
3011         }
3012
3013         dirp = (struct smbc_dirent *)context->internal->_dirent;
3014         maxlen = (sizeof(context->internal->_dirent) -
3015                   sizeof(struct smbc_dirent));
3016
3017         smbc_readdir_internal(context, dirp, dirent, maxlen);
3018
3019         dir->dir_next = dir->dir_next->next;
3020
3021         return dirp;
3022 }
3023
3024 /*
3025  * Routine to get directory entries
3026  */
3027
3028 static int
3029 smbc_getdents_ctx(SMBCCTX *context,
3030                   SMBCFILE *dir,
3031                   struct smbc_dirent *dirp,
3032                   int count)
3033 {
3034         int rem = count;
3035         int reqd;
3036         int maxlen;
3037         char *ndir = (char *)dirp;
3038         struct smbc_dir_list *dirlist;
3039
3040         /* Check that all is ok first ... */
3041
3042         if (!context || !context->internal ||
3043             !context->internal->_initialized) {
3044
3045                 errno = EINVAL;
3046                 return -1;
3047
3048         }
3049
3050         if (!dir || !DLIST_CONTAINS(context->internal->_files, dir)) {
3051
3052                 errno = EBADF;
3053                 return -1;
3054
3055         }
3056
3057         if (dir->file != False) { /* FIXME, should be dir, perhaps */
3058
3059                 errno = ENOTDIR;
3060                 return -1;
3061
3062         }
3063
3064         /*
3065          * Now, retrieve the number of entries that will fit in what was passed
3066          * We have to figure out if the info is in the list, or we need to
3067          * send a request to the server to get the info.
3068          */
3069
3070         while ((dirlist = dir->dir_next)) {
3071                 struct smbc_dirent *dirent;
3072
3073                 if (!dirlist->dirent) {
3074
3075                         errno = ENOENT;  /* Bad error */
3076                         return -1;
3077
3078                 }
3079
3080                 /* Do urlencoding of next entry, if so selected */
3081                 dirent = (struct smbc_dirent *)context->internal->_dirent;
3082                 maxlen = (sizeof(context->internal->_dirent) -
3083                           sizeof(struct smbc_dirent));
3084                 smbc_readdir_internal(context, dirent, dirlist->dirent, maxlen);
3085
3086                 reqd = dirent->dirlen;
3087
3088                 if (rem < reqd) {
3089
3090                         if (rem < count) { /* We managed to copy something */
3091
3092                                 errno = 0;
3093                                 return count - rem;
3094
3095                         }
3096                         else { /* Nothing copied ... */
3097
3098                                 errno = EINVAL;  /* Not enough space ... */
3099                                 return -1;
3100
3101                         }
3102
3103                 }
3104
3105                 memcpy(ndir, dirent, reqd); /* Copy the data in ... */
3106
3107                 ((struct smbc_dirent *)ndir)->comment =
3108                         (char *)(&((struct smbc_dirent *)ndir)->name +
3109                                  dirent->namelen +
3110                                  1);
3111
3112                 ndir += reqd;
3113
3114                 rem -= reqd;
3115
3116                 dir->dir_next = dirlist = dirlist -> next;
3117         }
3118
3119         if (rem == count)
3120                 return 0;
3121         else
3122                 return count - rem;
3123
3124 }
3125
3126 /*
3127  * Routine to create a directory ...
3128  */
3129
3130 static int
3131 smbc_mkdir_ctx(SMBCCTX *context,
3132                const char *fname,
3133                mode_t mode)
3134 {
3135         SMBCSRV *srv;
3136         fstring server;
3137         fstring share;
3138         fstring user;
3139         fstring password;
3140         fstring workgroup;
3141         pstring path, targetpath;
3142         struct cli_state *targetcli;
3143
3144         if (!context || !context->internal ||
3145             !context->internal->_initialized) {
3146
3147                 errno = EINVAL;
3148                 return -1;
3149
3150         }
3151
3152         if (!fname) {
3153
3154                 errno = EINVAL;
3155                 return -1;
3156
3157         }
3158
3159         DEBUG(4, ("smbc_mkdir(%s)\n", fname));
3160
3161         if (smbc_parse_path(context, fname,
3162                             workgroup, sizeof(workgroup),
3163                             server, sizeof(server),
3164                             share, sizeof(share),
3165                             path, sizeof(path),
3166                             user, sizeof(user),
3167                             password, sizeof(password),
3168                             NULL, 0)) {
3169                 errno = EINVAL;
3170                 return -1;
3171         }
3172
3173         if (user[0] == (char)0) fstrcpy(user, context->user);
3174
3175         srv = smbc_server(context, True,
3176                           server, share, workgroup, user, password);
3177
3178         if (!srv) {
3179
3180                 return -1;  /* errno set by smbc_server */
3181
3182         }
3183
3184         /*d_printf(">>>mkdir: resolving %s\n", path);*/
3185         if (!cli_resolve_path( "", &srv->cli, path, &targetcli, targetpath))
3186         {
3187                 d_printf("Could not resolve %s\n", path);
3188                 return -1;
3189         }
3190         /*d_printf(">>>mkdir: resolved path as %s\n", targetpath);*/
3191
3192         if (!cli_mkdir(targetcli, targetpath)) {
3193
3194                 errno = smbc_errno(context, targetcli);
3195                 return -1;
3196
3197         }
3198
3199         return 0;
3200
3201 }
3202
3203 /*
3204  * Our list function simply checks to see if a directory is not empty
3205  */
3206
3207 static int smbc_rmdir_dirempty = True;
3208
3209 static void
3210 rmdir_list_fn(const char *mnt,
3211               file_info *finfo,
3212               const char *mask,
3213               void *state)
3214 {
3215         if (strncmp(finfo->name, ".", 1) != 0 &&
3216             strncmp(finfo->name, "..", 2) != 0) {
3217
3218                 smbc_rmdir_dirempty = False;
3219         }
3220 }
3221
3222 /*
3223  * Routine to remove a directory
3224  */
3225
3226 static int
3227 smbc_rmdir_ctx(SMBCCTX *context,
3228                const char *fname)
3229 {
3230         SMBCSRV *srv;
3231         fstring server;
3232         fstring share;
3233         fstring user;
3234         fstring password;
3235         fstring workgroup;
3236         pstring path;
3237         pstring targetpath;
3238         struct cli_state *targetcli;
3239
3240         if (!context || !context->internal ||
3241             !context->internal->_initialized) {
3242
3243                 errno = EINVAL;
3244                 return -1;
3245
3246         }
3247
3248         if (!fname) {
3249
3250                 errno = EINVAL;
3251                 return -1;
3252
3253         }
3254
3255         DEBUG(4, ("smbc_rmdir(%s)\n", fname));
3256
3257         if (smbc_parse_path(context, fname,
3258                             workgroup, sizeof(workgroup),
3259                             server, sizeof(server),
3260                             share, sizeof(share),
3261                             path, sizeof(path),
3262                             user, sizeof(user),
3263                             password, sizeof(password),
3264                             NULL, 0))
3265         {
3266                 errno = EINVAL;
3267                 return -1;
3268         }
3269
3270         if (user[0] == (char)0) fstrcpy(user, context->user);
3271
3272         srv = smbc_server(context, True,
3273                           server, share, workgroup, user, password);
3274
3275         if (!srv) {
3276
3277                 return -1;  /* errno set by smbc_server */
3278
3279         }
3280
3281         /*d_printf(">>>rmdir: resolving %s\n", path);*/
3282         if (!cli_resolve_path( "", &srv->cli, path, &targetcli, targetpath))
3283         {
3284                 d_printf("Could not resolve %s\n", path);
3285                 return -1;
3286         }
3287         /*d_printf(">>>rmdir: resolved path as %s\n", targetpath);*/
3288
3289
3290         if (!cli_rmdir(targetcli, targetpath)) {
3291
3292                 errno = smbc_errno(context, targetcli);
3293
3294                 if (errno == EACCES) {  /* Check if the dir empty or not */
3295
3296                         /* Local storage to avoid buffer overflows */
3297                         pstring lpath;
3298
3299                         smbc_rmdir_dirempty = True;  /* Make this so ... */
3300
3301                         pstrcpy(lpath, targetpath);
3302                         pstrcat(lpath, "\\*");
3303
3304                         if (cli_list(targetcli, lpath,
3305                                      aDIR | aSYSTEM | aHIDDEN,
3306                                      rmdir_list_fn, NULL) < 0) {
3307
3308                                 /* Fix errno to ignore latest error ... */
3309                                 DEBUG(5, ("smbc_rmdir: "
3310                                           "cli_list returned an error: %d\n",
3311                                           smbc_errno(context, targetcli)));
3312                                 errno = EACCES;
3313
3314                         }
3315
3316                         if (smbc_rmdir_dirempty)
3317                                 errno = EACCES;
3318                         else
3319                                 errno = ENOTEMPTY;
3320
3321                 }
3322
3323                 return -1;
3324
3325         }
3326
3327         return 0;
3328
3329 }
3330
3331 /*
3332  * Routine to return the current directory position
3333  */
3334
3335 static off_t
3336 smbc_telldir_ctx(SMBCCTX *context,
3337                  SMBCFILE *dir)
3338 {
3339         off_t ret_val; /* Squash warnings about cast */
3340
3341         if (!context || !context->internal ||
3342             !context->internal->_initialized) {
3343
3344                 errno = EINVAL;
3345                 return -1;
3346
3347         }
3348
3349         if (!dir || !DLIST_CONTAINS(context->internal->_files, dir)) {
3350
3351                 errno = EBADF;
3352                 return -1;
3353
3354         }
3355
3356         if (dir->file != False) { /* FIXME, should be dir, perhaps */
3357
3358                 errno = ENOTDIR;
3359                 return -1;
3360
3361         }
3362
3363         /*
3364          * We return the pointer here as the offset
3365          */
3366         ret_val = (off_t)(long)dir->dir_next;
3367         return ret_val;
3368
3369 }
3370
3371 /*
3372  * A routine to run down the list and see if the entry is OK
3373  */
3374
3375 struct smbc_dir_list *
3376 smbc_check_dir_ent(struct smbc_dir_list *list,
3377                    struct smbc_dirent *dirent)
3378 {
3379
3380         /* Run down the list looking for what we want */
3381
3382         if (dirent) {
3383
3384                 struct smbc_dir_list *tmp = list;
3385
3386                 while (tmp) {
3387
3388                         if (tmp->dirent == dirent)
3389                                 return tmp;
3390
3391                         tmp = tmp->next;
3392
3393                 }
3394
3395         }
3396
3397         return NULL;  /* Not found, or an error */
3398
3399 }
3400
3401
3402 /*
3403  * Routine to seek on a directory
3404  */
3405
3406 static int
3407 smbc_lseekdir_ctx(SMBCCTX *context,
3408                   SMBCFILE *dir,
3409                   off_t offset)
3410 {
3411         long int l_offset = offset;  /* Handle problems of size */
3412         struct smbc_dirent *dirent = (struct smbc_dirent *)l_offset;
3413         struct smbc_dir_list *list_ent = (struct smbc_dir_list *)NULL;
3414
3415         if (!context || !context->internal ||
3416             !context->internal->_initialized) {
3417
3418                 errno = EINVAL;
3419                 return -1;
3420
3421         }
3422
3423         if (dir->file != False) { /* FIXME, should be dir, perhaps */
3424
3425                 errno = ENOTDIR;
3426                 return -1;
3427
3428         }
3429
3430         /* Now, check what we were passed and see if it is OK ... */
3431
3432         if (dirent == NULL) {  /* Seek to the begining of the list */
3433
3434                 dir->dir_next = dir->dir_list;
3435                 return 0;
3436
3437         }
3438
3439         /* Now, run down the list and make sure that the entry is OK       */
3440         /* This may need to be changed if we change the format of the list */
3441
3442         if ((list_ent = smbc_check_dir_ent(dir->dir_list, dirent)) == NULL) {
3443
3444                 errno = EINVAL;   /* Bad entry */
3445                 return -1;
3446
3447         }
3448
3449         dir->dir_next = list_ent;
3450
3451         return 0;
3452
3453 }
3454
3455 /*
3456  * Routine to fstat a dir
3457  */
3458
3459 static int
3460 smbc_fstatdir_ctx(SMBCCTX *context,
3461                   SMBCFILE *dir,
3462                   struct stat *st)
3463 {
3464
3465         if (!context || !context->internal ||
3466             !context->internal->_initialized) {
3467
3468                 errno = EINVAL;
3469                 return -1;
3470
3471         }
3472
3473         /* No code yet ... */
3474
3475         return 0;
3476
3477 }
3478
3479 static int
3480 smbc_chmod_ctx(SMBCCTX *context,
3481                const char *fname,
3482                mode_t newmode)
3483 {
3484         SMBCSRV *srv;
3485         fstring server;
3486         fstring share;
3487         fstring user;
3488         fstring password;
3489         fstring workgroup;
3490         pstring path;
3491         uint16 mode;
3492
3493         if (!context || !context->internal ||
3494             !context->internal->_initialized) {
3495
3496                 errno = EINVAL;  /* Best I can think of ... */
3497                 return -1;
3498
3499         }
3500
3501         if (!fname) {
3502
3503                 errno = EINVAL;
3504                 return -1;
3505
3506         }
3507
3508         DEBUG(4, ("smbc_chmod(%s, 0%3o)\n", fname, newmode));
3509
3510         if (smbc_parse_path(context, fname,
3511                             workgroup, sizeof(workgroup),
3512                             server, sizeof(server),
3513                             share, sizeof(share),
3514                             path, sizeof(path),
3515                             user, sizeof(user),
3516                             password, sizeof(password),
3517                             NULL, 0)) {
3518                 errno = EINVAL;
3519                 return -1;
3520         }
3521
3522         if (user[0] == (char)0) fstrcpy(user, context->user);
3523
3524         srv = smbc_server(context, True,
3525                           server, share, workgroup, user, password);
3526
3527         if (!srv) {
3528                 return -1;  /* errno set by smbc_server */
3529         }
3530
3531         mode = 0;
3532
3533         if (!(newmode & (S_IWUSR | S_IWGRP | S_IWOTH))) mode |= aRONLY;
3534         if ((newmode & S_IXUSR) && lp_map_archive(-1)) mode |= aARCH;
3535         if ((newmode & S_IXGRP) && lp_map_system(-1)) mode |= aSYSTEM;
3536         if ((newmode & S_IXOTH) && lp_map_hidden(-1)) mode |= aHIDDEN;
3537
3538         if (!cli_setatr(&srv->cli, path, mode, 0)) {
3539                 errno = smbc_errno(context, &srv->cli);
3540                 return -1;
3541         }
3542
3543         return 0;
3544 }
3545
3546 static int
3547 smbc_utimes_ctx(SMBCCTX *context,
3548                 const char *fname,
3549                 struct timeval *tbuf)
3550 {
3551         SMBCSRV *srv;
3552         fstring server;
3553         fstring share;
3554         fstring user;
3555         fstring password;
3556         fstring workgroup;
3557         pstring path;
3558         time_t a_time;
3559         time_t m_time;
3560
3561         if (!context || !context->internal ||
3562             !context->internal->_initialized) {
3563
3564                 errno = EINVAL;  /* Best I can think of ... */
3565                 return -1;
3566
3567         }
3568
3569         if (!fname) {
3570
3571                 errno = EINVAL;
3572                 return -1;
3573
3574         }
3575
3576         if (tbuf == NULL) {
3577                 a_time = m_time = time(NULL);
3578         } else {
3579                 a_time = tbuf[0].tv_sec;
3580                 m_time = tbuf[1].tv_sec;
3581         }
3582
3583         if (DEBUGLVL(4))
3584         {
3585                 char *p;
3586                 char atimebuf[32];
3587                 char mtimebuf[32];
3588
3589                 strncpy(atimebuf, ctime(&a_time), sizeof(atimebuf) - 1);
3590                 atimebuf[sizeof(atimebuf) - 1] = '\0';
3591                 if ((p = strchr(atimebuf, '\n')) != NULL) {
3592                         *p = '\0';
3593                 }
3594
3595                 strncpy(mtimebuf, ctime(&m_time), sizeof(mtimebuf) - 1);
3596                 mtimebuf[sizeof(mtimebuf) - 1] = '\0';
3597                 if ((p = strchr(mtimebuf, '\n')) != NULL) {
3598                         *p = '\0';
3599                 }
3600
3601                 dbgtext("smbc_utimes(%s, atime = %s mtime = %s)\n",
3602                         fname, atimebuf, mtimebuf);
3603         }
3604
3605         if (smbc_parse_path(context, fname,
3606                             workgroup, sizeof(workgroup),
3607                             server, sizeof(server),
3608                             share, sizeof(share),
3609                             path, sizeof(path),
3610                             user, sizeof(user),
3611                             password, sizeof(password),
3612                             NULL, 0)) {
3613                 errno = EINVAL;
3614                 return -1;
3615         }
3616
3617         if (user[0] == (char)0) fstrcpy(user, context->user);
3618
3619         srv = smbc_server(context, True,
3620                           server, share, workgroup, user, password);
3621
3622         if (!srv) {
3623                 return -1;      /* errno set by smbc_server */
3624         }
3625
3626         if (!smbc_setatr(context, srv, path, 0, a_time, m_time, 0)) {
3627                 return -1;      /* errno set by smbc_setatr */
3628         }
3629
3630         return 0;
3631 }
3632
3633
3634 /* The MSDN is contradictory over the ordering of ACE entries in an ACL.
3635    However NT4 gives a "The information may have been modified by a
3636    computer running Windows NT 5.0" if denied ACEs do not appear before
3637    allowed ACEs. */
3638
3639 static int
3640 ace_compare(SEC_ACE *ace1,
3641             SEC_ACE *ace2)
3642 {
3643         if (sec_ace_equal(ace1, ace2))
3644                 return 0;
3645
3646         if (ace1->type != ace2->type)
3647                 return ace2->type - ace1->type;
3648
3649         if (sid_compare(&ace1->trustee, &ace2->trustee))
3650                 return sid_compare(&ace1->trustee, &ace2->trustee);
3651
3652         if (ace1->flags != ace2->flags)
3653                 return ace1->flags - ace2->flags;
3654
3655         if (ace1->info.mask != ace2->info.mask)
3656                 return ace1->info.mask - ace2->info.mask;
3657
3658         if (ace1->size != ace2->size)
3659                 return ace1->size - ace2->size;
3660
3661         return memcmp(ace1, ace2, sizeof(SEC_ACE));
3662 }
3663
3664
3665 static void
3666 sort_acl(SEC_ACL *the_acl)
3667 {
3668         uint32 i;
3669         if (!the_acl) return;
3670
3671         qsort(the_acl->ace, the_acl->num_aces, sizeof(the_acl->ace[0]),
3672               QSORT_CAST ace_compare);
3673
3674         for (i=1;i<the_acl->num_aces;) {
3675                 if (sec_ace_equal(&the_acl->ace[i-1], &the_acl->ace[i])) {
3676                         int j;
3677                         for (j=i; j<the_acl->num_aces-1; j++) {
3678                                 the_acl->ace[j] = the_acl->ace[j+1];
3679                         }
3680                         the_acl->num_aces--;
3681                 } else {
3682                         i++;
3683                 }
3684         }
3685 }
3686
3687 /* convert a SID to a string, either numeric or username/group */
3688 static void
3689 convert_sid_to_string(struct cli_state *ipc_cli,
3690                       POLICY_HND *pol,
3691                       fstring str,
3692                       BOOL numeric,
3693                       DOM_SID *sid)
3694 {
3695         char **domains = NULL;
3696         char **names = NULL;
3697         uint32 *types = NULL;
3698         struct rpc_pipe_client *pipe_hnd = find_lsa_pipe_hnd(ipc_cli);
3699         sid_to_string(str, sid);
3700
3701         if (numeric) {
3702                 return;     /* no lookup desired */
3703         }
3704
3705         if (!pipe_hnd) {
3706                 return;
3707         }
3708
3709         /* Ask LSA to convert the sid to a name */
3710
3711         if (!NT_STATUS_IS_OK(rpccli_lsa_lookup_sids(pipe_hnd, ipc_cli->mem_ctx,
3712                                                  pol, 1, sid, &domains,
3713                                                  &names, &types)) ||
3714             !domains || !domains[0] || !names || !names[0]) {
3715                 return;
3716         }
3717
3718         /* Converted OK */
3719
3720         slprintf(str, sizeof(fstring) - 1, "%s%s%s",
3721                  domains[0], lp_winbind_separator(),
3722                  names[0]);
3723 }
3724
3725 /* convert a string to a SID, either numeric or username/group */
3726 static BOOL
3727 convert_string_to_sid(struct cli_state *ipc_cli,
3728                       POLICY_HND *pol,
3729                       BOOL numeric,
3730                       DOM_SID *sid,
3731                       const char *str)
3732 {
3733         uint32 *types = NULL;
3734         DOM_SID *sids = NULL;
3735         BOOL result = True;
3736         struct rpc_pipe_client *pipe_hnd = find_lsa_pipe_hnd(ipc_cli);
3737
3738         if (!pipe_hnd) {
3739                 return False;
3740         }
3741
3742         if (numeric) {
3743                 if (strncmp(str, "S-", 2) == 0) {
3744                         return string_to_sid(sid, str);
3745                 }
3746
3747                 result = False;
3748                 goto done;
3749         }
3750
3751         if (!NT_STATUS_IS_OK(rpccli_lsa_lookup_names(pipe_hnd, ipc_cli->mem_ctx,
3752                                                   pol, 1, &str, NULL, &sids,
3753                                                   &types))) {
3754                 result = False;
3755                 goto done;
3756         }
3757
3758         sid_copy(sid, &sids[0]);
3759  done:
3760
3761         return result;
3762 }
3763
3764
3765 /* parse an ACE in the same format as print_ace() */
3766 static BOOL
3767 parse_ace(struct cli_state *ipc_cli,
3768           POLICY_HND *pol,
3769           SEC_ACE *ace,
3770           BOOL numeric,
3771           char *str)
3772 {
3773         char *p;
3774         const char *cp;
3775         fstring tok;
3776         unsigned int atype;
3777         unsigned int aflags;
3778         unsigned int amask;
3779         DOM_SID sid;
3780         SEC_ACCESS mask;
3781         const struct perm_value *v;
3782         struct perm_value {
3783                 const char *perm;
3784                 uint32 mask;
3785         };
3786
3787         /* These values discovered by inspection */
3788         static const struct perm_value special_values[] = {
3789                 { "R", 0x00120089 },
3790                 { "W", 0x00120116 },
3791                 { "X", 0x001200a0 },
3792                 { "D", 0x00010000 },
3793                 { "P", 0x00040000 },
3794                 { "O", 0x00080000 },
3795                 { NULL, 0 },
3796         };
3797
3798         static const struct perm_value standard_values[] = {
3799                 { "READ",   0x001200a9 },
3800                 { "CHANGE", 0x001301bf },
3801                 { "FULL",   0x001f01ff },
3802                 { NULL, 0 },
3803         };
3804
3805
3806         ZERO_STRUCTP(ace);
3807         p = strchr_m(str,':');
3808         if (!p) return False;
3809         *p = '\0';
3810         p++;
3811         /* Try to parse numeric form */
3812
3813         if (sscanf(p, "%i/%i/%i", &atype, &aflags, &amask) == 3 &&
3814             convert_string_to_sid(ipc_cli, pol, numeric, &sid, str)) {
3815                 goto done;
3816         }
3817
3818         /* Try to parse text form */
3819
3820         if (!convert_string_to_sid(ipc_cli, pol, numeric, &sid, str)) {
3821                 return False;
3822         }
3823
3824         cp = p;
3825         if (!next_token(&cp, tok, "/", sizeof(fstring))) {
3826                 return False;
3827         }
3828
3829         if (StrnCaseCmp(tok, "ALLOWED", strlen("ALLOWED")) == 0) {
3830                 atype = SEC_ACE_TYPE_ACCESS_ALLOWED;
3831         } else if (StrnCaseCmp(tok, "DENIED", strlen("DENIED")) == 0) {
3832                 atype = SEC_ACE_TYPE_ACCESS_DENIED;
3833         } else {
3834                 return False;
3835         }
3836
3837         /* Only numeric form accepted for flags at present */
3838
3839         if (!(next_token(&cp, tok, "/", sizeof(fstring)) &&
3840               sscanf(tok, "%i", &aflags))) {
3841                 return False;
3842         }
3843
3844         if (!next_token(&cp, tok, "/", sizeof(fstring))) {
3845                 return False;
3846         }
3847
3848         if (strncmp(tok, "0x", 2) == 0) {
3849                 if (sscanf(tok, "%i", &amask) != 1) {
3850                         return False;
3851                 }
3852                 goto done;
3853         }
3854
3855         for (v = standard_values; v->perm; v++) {
3856                 if (strcmp(tok, v->perm) == 0) {
3857                         amask = v->mask;
3858                         goto done;
3859                 }
3860         }
3861
3862         p = tok;
3863
3864         while(*p) {
3865                 BOOL found = False;
3866
3867                 for (v = special_values; v->perm; v++) {
3868                         if (v->perm[0] == *p) {
3869                                 amask |= v->mask;
3870                                 found = True;
3871                         }
3872                 }
3873
3874                 if (!found) return False;
3875                 p++;
3876         }
3877
3878         if (*p) {
3879                 return False;
3880         }
3881
3882  done:
3883         mask.mask = amask;
3884         init_sec_ace(ace, &sid, atype, mask, aflags);
3885         return True;
3886 }
3887
3888 /* add an ACE to a list of ACEs in a SEC_ACL */
3889 static BOOL
3890 add_ace(SEC_ACL **the_acl,
3891         SEC_ACE *ace,
3892         TALLOC_CTX *ctx)
3893 {
3894         SEC_ACL *newacl;
3895         SEC_ACE *aces;
3896
3897         if (! *the_acl) {
3898                 (*the_acl) = make_sec_acl(ctx, 3, 1, ace);
3899                 return True;
3900         }
3901
3902         aces = SMB_CALLOC_ARRAY(SEC_ACE, 1+(*the_acl)->num_aces);
3903         memcpy(aces, (*the_acl)->ace, (*the_acl)->num_aces * sizeof(SEC_ACE));
3904         memcpy(aces+(*the_acl)->num_aces, ace, sizeof(SEC_ACE));
3905         newacl = make_sec_acl(ctx, (*the_acl)->revision,
3906                               1+(*the_acl)->num_aces, aces);
3907         SAFE_FREE(aces);
3908         (*the_acl) = newacl;
3909         return True;
3910 }
3911
3912
3913 /* parse a ascii version of a security descriptor */
3914 static SEC_DESC *
3915 sec_desc_parse(TALLOC_CTX *ctx,
3916                struct cli_state *ipc_cli,
3917                POLICY_HND *pol,
3918                BOOL numeric,
3919                char *str)
3920 {
3921         const char *p = str;
3922         fstring tok;
3923         SEC_DESC *ret;
3924         size_t sd_size;
3925         DOM_SID *grp_sid=NULL;
3926         DOM_SID *owner_sid=NULL;
3927         SEC_ACL *dacl=NULL;
3928         int revision=1;
3929
3930         while (next_token(&p, tok, "\t,\r\n", sizeof(tok))) {
3931
3932                 if (StrnCaseCmp(tok,"REVISION:", 9) == 0) {
3933                         revision = strtol(tok+9, NULL, 16);
3934                         continue;
3935                 }
3936
3937                 if (StrnCaseCmp(tok,"OWNER:", 6) == 0) {
3938                         owner_sid = SMB_CALLOC_ARRAY(DOM_SID, 1);
3939                         if (!owner_sid ||
3940                             !convert_string_to_sid(ipc_cli, pol,
3941                                                    numeric,
3942                                                    owner_sid, tok+6)) {
3943                                 DEBUG(5, ("Failed to parse owner sid\n"));
3944                                 return NULL;
3945                         }
3946                         continue;
3947                 }
3948
3949                 if (StrnCaseCmp(tok,"OWNER+:", 7) == 0) {
3950                         owner_sid = SMB_CALLOC_ARRAY(DOM_SID, 1);
3951                         if (!owner_sid ||
3952                             !convert_string_to_sid(ipc_cli, pol,
3953                                                    False,
3954                                                    owner_sid, tok+7)) {
3955                                 DEBUG(5, ("Failed to parse owner sid\n"));
3956                                 return NULL;
3957                         }
3958                         continue;
3959                 }
3960
3961                 if (StrnCaseCmp(tok,"GROUP:", 6) == 0) {
3962                         grp_sid = SMB_CALLOC_ARRAY(DOM_SID, 1);
3963                         if (!grp_sid ||
3964                             !convert_string_to_sid(ipc_cli, pol,
3965                                                    numeric,
3966                                                    grp_sid, tok+6)) {
3967                                 DEBUG(5, ("Failed to parse group sid\n"));
3968                                 return NULL;
3969                         }
3970                         continue;
3971                 }
3972
3973                 if (StrnCaseCmp(tok,"GROUP+:", 7) == 0) {
3974                         grp_sid = SMB_CALLOC_ARRAY(DOM_SID, 1);
3975                         if (!grp_sid ||
3976                             !convert_string_to_sid(ipc_cli, pol,
3977                                                    False,
3978                                                    grp_sid, tok+6)) {
3979                                 DEBUG(5, ("Failed to parse group sid\n"));
3980                                 return NULL;
3981                         }
3982                         continue;
3983                 }
3984
3985                 if (StrnCaseCmp(tok,"ACL:", 4) == 0) {
3986                         SEC_ACE ace;
3987                         if (!parse_ace(ipc_cli, pol, &ace, numeric, tok+4)) {
3988                                 DEBUG(5, ("Failed to parse ACL %s\n", tok));
3989                                 return NULL;
3990                         }
3991                         if(!add_ace(&dacl, &ace, ctx)) {
3992                                 DEBUG(5, ("Failed to add ACL %s\n", tok));
3993                                 return NULL;
3994                         }
3995                         continue;
3996                 }
3997
3998                 if (StrnCaseCmp(tok,"ACL+:", 5) == 0) {
3999                         SEC_ACE ace;
4000                         if (!parse_ace(ipc_cli, pol, &ace, False, tok+5)) {
4001                                 DEBUG(5, ("Failed to parse ACL %s\n", tok));
4002                                 return NULL;
4003                         }
4004                         if(!add_ace(&dacl, &ace, ctx)) {
4005                                 DEBUG(5, ("Failed to add ACL %s\n", tok));
4006                                 return NULL;
4007                         }
4008                         continue;
4009                 }
4010
4011                 DEBUG(5, ("Failed to parse security descriptor\n"));
4012                 return NULL;
4013         }
4014
4015         ret = make_sec_desc(ctx, revision, SEC_DESC_SELF_RELATIVE,
4016                             owner_sid, grp_sid, NULL, dacl, &sd_size);
4017
4018         SAFE_FREE(grp_sid);
4019         SAFE_FREE(owner_sid);
4020
4021         return ret;
4022 }
4023
4024
4025 /* Obtain the current dos attributes */
4026 static DOS_ATTR_DESC *
4027 dos_attr_query(SMBCCTX *context,
4028                TALLOC_CTX *ctx,
4029                const char *filename,
4030                SMBCSRV *srv)
4031 {
4032         time_t m_time = 0, a_time = 0, c_time = 0;
4033         SMB_OFF_T size = 0;
4034         uint16 mode = 0;
4035         SMB_INO_T inode = 0;
4036         DOS_ATTR_DESC *ret;
4037
4038         ret = TALLOC_P(ctx, DOS_ATTR_DESC);
4039         if (!ret) {
4040                 errno = ENOMEM;
4041                 return NULL;
4042         }
4043
4044         /* Obtain the DOS attributes */
4045         if (!smbc_getatr(context, srv, CONST_DISCARD(char *, filename),
4046                          &mode, &size,
4047                          &c_time, &a_time, &m_time, &inode)) {
4048
4049                 errno = smbc_errno(context, &srv->cli);
4050                 DEBUG(5, ("dos_attr_query Failed to query old attributes\n"));
4051                 return NULL;
4052
4053         }
4054
4055         ret->mode = mode;
4056         ret->size = size;
4057         ret->a_time = a_time;
4058         ret->c_time = c_time;
4059         ret->m_time = m_time;
4060         ret->inode = inode;
4061
4062         return ret;
4063 }
4064
4065
4066 /* parse a ascii version of a security descriptor */
4067 static void
4068 dos_attr_parse(SMBCCTX *context,
4069                DOS_ATTR_DESC *dad,
4070                SMBCSRV *srv,
4071                char *str)
4072 {
4073         const char *p = str;
4074         fstring tok;
4075
4076         while (next_token(&p, tok, "\t,\r\n", sizeof(tok))) {
4077
4078                 if (StrnCaseCmp(tok, "MODE:", 5) == 0) {
4079                         dad->mode = strtol(tok+5, NULL, 16);
4080                         continue;
4081                 }
4082
4083                 if (StrnCaseCmp(tok, "SIZE:", 5) == 0) {
4084                         dad->size = (SMB_OFF_T)atof(tok+5);
4085                         continue;
4086                 }
4087
4088                 if (StrnCaseCmp(tok, "A_TIME:", 7) == 0) {
4089                         dad->a_time = (time_t)strtol(tok+7, NULL, 10);
4090                         continue;
4091                 }
4092
4093                 if (StrnCaseCmp(tok, "C_TIME:", 7) == 0) {
4094                         dad->c_time = (time_t)strtol(tok+7, NULL, 10);
4095                         continue;
4096                 }
4097
4098                 if (StrnCaseCmp(tok, "M_TIME:", 7) == 0) {
4099                         dad->m_time = (time_t)strtol(tok+7, NULL, 10);
4100                         continue;
4101                 }
4102
4103                 if (StrnCaseCmp(tok, "INODE:", 6) == 0) {
4104                         dad->inode = (SMB_INO_T)atof(tok+6);
4105                         continue;
4106                 }
4107         }
4108 }
4109
4110 /*****************************************************
4111  Retrieve the acls for a file.
4112 *******************************************************/
4113
4114 static int
4115 cacl_get(SMBCCTX *context,
4116          TALLOC_CTX *ctx,
4117          SMBCSRV *srv,
4118          struct cli_state *ipc_cli,
4119          POLICY_HND *pol,
4120          char *filename,
4121          char *attr_name,
4122          char *buf,
4123          int bufsize)
4124 {
4125         uint32 i;
4126         int n = 0;
4127         int n_used;
4128         BOOL all;
4129         BOOL all_nt;
4130         BOOL all_nt_acls;
4131         BOOL all_dos;
4132         BOOL some_nt;
4133         BOOL some_dos;
4134         BOOL exclude_nt_revision = False;
4135         BOOL exclude_nt_owner = False;
4136         BOOL exclude_nt_group = False;
4137         BOOL exclude_nt_acl = False;
4138         BOOL exclude_dos_mode = False;
4139         BOOL exclude_dos_size = False;
4140         BOOL exclude_dos_ctime = False;
4141         BOOL exclude_dos_atime = False;
4142         BOOL exclude_dos_mtime = False;
4143         BOOL exclude_dos_inode = False;
4144         BOOL numeric = True;
4145         BOOL determine_size = (bufsize == 0);
4146         int fnum = -1;
4147         SEC_DESC *sd;
4148         fstring sidstr;
4149         fstring name_sandbox;
4150         char *name;
4151         char *pExclude;
4152         char *p;
4153         time_t m_time = 0, a_time = 0, c_time = 0;
4154         SMB_OFF_T size = 0;
4155         uint16 mode = 0;
4156         SMB_INO_T ino = 0;
4157         struct cli_state *cli = &srv->cli;
4158
4159         /* Copy name so we can strip off exclusions (if any are specified) */
4160         strncpy(name_sandbox, attr_name, sizeof(name_sandbox) - 1);
4161
4162         /* Ensure name is null terminated */
4163         name_sandbox[sizeof(name_sandbox) - 1] = '\0';
4164
4165         /* Play in the sandbox */
4166         name = name_sandbox;
4167
4168         /* If there are any exclusions, point to them and mask them from name */
4169         if ((pExclude = strchr(name, '!')) != NULL)
4170         {
4171                 *pExclude++ = '\0';
4172         }
4173
4174         all = (StrnCaseCmp(name, "system.*", 8) == 0);
4175         all_nt = (StrnCaseCmp(name, "system.nt_sec_desc.*", 20) == 0);
4176         all_nt_acls = (StrnCaseCmp(name, "system.nt_sec_desc.acl.*", 24) == 0);
4177         all_dos = (StrnCaseCmp(name, "system.dos_attr.*", 17) == 0);
4178         some_nt = (StrnCaseCmp(name, "system.nt_sec_desc.", 19) == 0);
4179         some_dos = (StrnCaseCmp(name, "system.dos_attr.", 16) == 0);
4180         numeric = (* (name + strlen(name) - 1) != '+');
4181
4182         /* Look for exclusions from "all" requests */
4183         if (all || all_nt || all_dos) {
4184
4185                 /* Exclusions are delimited by '!' */
4186                 for (;
4187                      pExclude != NULL;
4188                      pExclude = (p == NULL ? NULL : p + 1)) {
4189
4190                 /* Find end of this exclusion name */
4191                 if ((p = strchr(pExclude, '!')) != NULL)
4192                 {
4193                     *p = '\0';
4194                 }
4195
4196                 /* Which exclusion name is this? */
4197                 if (StrCaseCmp(pExclude, "nt_sec_desc.revision") == 0) {
4198                     exclude_nt_revision = True;
4199                 }
4200                 else if (StrCaseCmp(pExclude, "nt_sec_desc.owner") == 0) {
4201                     exclude_nt_owner = True;
4202                 }
4203                 else if (StrCaseCmp(pExclude, "nt_sec_desc.group") == 0) {
4204                     exclude_nt_group = True;
4205                 }
4206                 else if (StrCaseCmp(pExclude, "nt_sec_desc.acl") == 0) {
4207                     exclude_nt_acl = True;
4208                 }
4209                 else if (StrCaseCmp(pExclude, "dos_attr.mode") == 0) {
4210                     exclude_dos_mode = True;
4211                 }
4212                 else if (StrCaseCmp(pExclude, "dos_attr.size") == 0) {
4213                     exclude_dos_size = True;
4214                 }
4215                 else if (StrCaseCmp(pExclude, "dos_attr.c_time") == 0) {
4216                     exclude_dos_ctime = True;
4217                 }
4218                 else if (StrCaseCmp(pExclude, "dos_attr.a_time") == 0) {
4219                     exclude_dos_atime = True;
4220                 }
4221                 else if (StrCaseCmp(pExclude, "dos_attr.m_time") == 0) {
4222                     exclude_dos_mtime = True;
4223                 }
4224                 else if (StrCaseCmp(pExclude, "dos_attr.inode") == 0) {
4225                     exclude_dos_inode = True;
4226                 }
4227                 else {
4228                     DEBUG(5, ("cacl_get received unknown exclusion: %s\n",
4229                               pExclude));
4230                     errno = ENOATTR;
4231                     return -1;
4232                 }
4233             }
4234         }
4235
4236         n_used = 0;
4237
4238         /*
4239          * If we are (possibly) talking to an NT or new system and some NT
4240          * attributes have been requested...
4241          */
4242         if (ipc_cli && (all || some_nt || all_nt_acls)) {
4243                 /* Point to the portion after "system.nt_sec_desc." */
4244                 name += 19;     /* if (all) this will be invalid but unused */
4245
4246                 /* ... then obtain any NT attributes which were requested */
4247                 fnum = cli_nt_create(cli, filename, CREATE_ACCESS_READ);
4248
4249                 if (fnum == -1) {
4250                         DEBUG(5, ("cacl_get failed to open %s: %s\n",
4251                                   filename, cli_errstr(cli)));
4252                         errno = 0;
4253                         return -1;
4254                 }
4255
4256                 sd = cli_query_secdesc(cli, fnum, ctx);
4257
4258                 if (!sd) {
4259                         DEBUG(5,
4260                               ("cacl_get Failed to query old descriptor\n"));
4261                         errno = 0;
4262                         return -1;
4263                 }
4264
4265                 cli_close(cli, fnum);
4266
4267                 if (! exclude_nt_revision) {
4268                         if (all || all_nt) {
4269                                 if (determine_size) {
4270                                         p = talloc_asprintf(ctx,
4271                                                             "REVISION:%d",
4272                                                             sd->revision);
4273                                         if (!p) {
4274                                                 errno = ENOMEM;
4275                                                 return -1;
4276                                         }
4277                                         n = strlen(p);
4278                                 } else {
4279                                         n = snprintf(buf, bufsize,
4280                                                      "REVISION:%d",
4281                                                      sd->revision);
4282                                 }
4283                         } else if (StrCaseCmp(name, "revision") == 0) {
4284                                 if (determine_size) {
4285                                         p = talloc_asprintf(ctx, "%d",
4286                                                             sd->revision);
4287                                         if (!p) {
4288                                                 errno = ENOMEM;
4289                                                 return -1;
4290                                         }
4291                                         n = strlen(p);
4292                                 } else {
4293                                         n = snprintf(buf, bufsize, "%d",
4294                                                      sd->revision);
4295                                 }
4296                         }
4297
4298                         if (!determine_size && n > bufsize) {
4299                                 errno = ERANGE;
4300                                 return -1;
4301                         }
4302                         buf += n;
4303                         n_used += n;
4304                         bufsize -= n;
4305                 }
4306
4307                 if (! exclude_nt_owner) {
4308                         /* Get owner and group sid */
4309                         if (sd->owner_sid) {
4310                                 convert_sid_to_string(ipc_cli, pol,
4311                                                       sidstr,
4312                                                       numeric,
4313                                                       sd->owner_sid);
4314                         } else {
4315                                 fstrcpy(sidstr, "");
4316                         }
4317
4318                         if (all || all_nt) {
4319                                 if (determine_size) {
4320                                         p = talloc_asprintf(ctx, ",OWNER:%s",
4321                                                             sidstr);
4322                                         if (!p) {
4323                                                 errno = ENOMEM;
4324                                                 return -1;
4325                                         }
4326                                         n = strlen(p);
4327                                 } else {
4328                                         n = snprintf(buf, bufsize,
4329                                                      ",OWNER:%s", sidstr);
4330                                 }
4331                         } else if (StrnCaseCmp(name, "owner", 5) == 0) {
4332                                 if (determine_size) {
4333                                         p = talloc_asprintf(ctx, "%s", sidstr);
4334                                         if (!p) {
4335                                                 errno = ENOMEM;
4336                                                 return -1;
4337                                         }
4338                                         n = strlen(p);
4339                                 } else {
4340                                         n = snprintf(buf, bufsize, "%s",
4341                                                      sidstr);
4342                                 }
4343                         }
4344
4345                         if (!determine_size && n > bufsize) {
4346                                 errno = ERANGE;
4347                                 return -1;
4348                         }
4349                         buf += n;
4350                         n_used += n;
4351                         bufsize -= n;
4352                 }
4353
4354                 if (! exclude_nt_group) {
4355                         if (sd->grp_sid) {
4356                                 convert_sid_to_string(ipc_cli, pol,
4357                                                       sidstr, numeric,
4358                                                       sd->grp_sid);
4359                         } else {
4360                                 fstrcpy(sidstr, "");
4361                         }
4362
4363                         if (all || all_nt) {
4364                                 if (determine_size) {
4365                                         p = talloc_asprintf(ctx, ",GROUP:%s",
4366                                                             sidstr);
4367                                         if (!p) {
4368                                                 errno = ENOMEM;
4369                                                 return -1;
4370                                         }
4371                                         n = strlen(p);
4372                                 } else {
4373                                         n = snprintf(buf, bufsize,
4374                                                      ",GROUP:%s", sidstr);
4375                                 }
4376                         } else if (StrnCaseCmp(name, "group", 5) == 0) {
4377                                 if (determine_size) {
4378                                         p = talloc_asprintf(ctx, "%s", sidstr);
4379                                         if (!p) {
4380                                                 errno = ENOMEM;
4381                                                 return -1;
4382                                         }
4383                                         n = strlen(p);
4384                                 } else {
4385                                         n = snprintf(buf, bufsize,
4386                                                      "%s", sidstr);
4387                                 }
4388                         }
4389
4390                         if (!determine_size && n > bufsize) {
4391                                 errno = ERANGE;
4392                                 return -1;
4393                         }
4394                         buf += n;
4395                         n_used += n;
4396                         bufsize -= n;
4397                 }
4398
4399                 if (! exclude_nt_acl) {
4400                         /* Add aces to value buffer  */
4401                         for (i = 0; sd->dacl && i < sd->dacl->num_aces; i++) {
4402
4403                                 SEC_ACE *ace = &sd->dacl->ace[i];
4404                                 convert_sid_to_string(ipc_cli, pol,
4405                                                       sidstr, numeric,
4406                                                       &ace->trustee);
4407
4408                                 if (all || all_nt) {
4409                                         if (determine_size) {
4410                                                 p = talloc_asprintf(
4411                                                         ctx,
4412                                                         ",ACL:"
4413                                                         "%s:%d/%d/0x%08x",
4414                                                         sidstr,
4415                                                         ace->type,
4416                                                         ace->flags,
4417                                                         ace->info.mask);
4418                                                 if (!p) {
4419                                                         errno = ENOMEM;
4420                                                         return -1;
4421                                                 }
4422                                                 n = strlen(p);
4423                                         } else {
4424                                                 n = snprintf(
4425                                                         buf, bufsize,
4426                                                         ",ACL:%s:%d/%d/0x%08x",
4427                                                         sidstr,
4428                                                         ace->type,
4429                                                         ace->flags,
4430                                                         ace->info.mask);
4431                                         }
4432                                 } else if ((StrnCaseCmp(name, "acl", 3) == 0 &&
4433                                             StrCaseCmp(name+3, sidstr) == 0) ||
4434                                            (StrnCaseCmp(name, "acl+", 4) == 0 &&
4435                                             StrCaseCmp(name+4, sidstr) == 0)) {
4436                                         if (determine_size) {
4437                                                 p = talloc_asprintf(
4438                                                         ctx,
4439                                                         "%d/%d/0x%08x",
4440                                                         ace->type,
4441                                                         ace->flags,
4442                                                         ace->info.mask);
4443                                                 if (!p) {
4444                                                         errno = ENOMEM;
4445                                                         return -1;
4446                                                 }
4447                                                 n = strlen(p);
4448                                         } else {
4449                                                 n = snprintf(buf, bufsize,
4450                                                              "%d/%d/0x%08x",
4451                                                              ace->type,
4452                                                              ace->flags,
4453                                                              ace->info.mask);
4454                                         }
4455                                 } else if (all_nt_acls) {
4456                                         if (determine_size) {
4457                                                 p = talloc_asprintf(
4458                                                         ctx,
4459                                                         "%s%s:%d/%d/0x%08x",
4460                                                         i ? "," : "",
4461                                                         sidstr,
4462                                                         ace->type,
4463                                                         ace->flags,
4464                                                         ace->info.mask);
4465                                                 if (!p) {
4466                                                         errno = ENOMEM;
4467                                                         return -1;
4468                                                 }
4469                                                 n = strlen(p);
4470                                         } else {
4471                                                 n = snprintf(buf, bufsize,
4472                                                              "%s%s:%d/%d/0x%08x",
4473                                                              i ? "," : "",
4474                                                              sidstr,
4475                                                              ace->type,
4476                                                              ace->flags,
4477                                                              ace->info.mask);
4478                                         }
4479                                 }
4480                                 if (n > bufsize) {
4481                                         errno = ERANGE;
4482                                         return -1;
4483                                 }
4484                                 buf += n;
4485                                 n_used += n;
4486                                 bufsize -= n;
4487                         }
4488                 }
4489
4490                 /* Restore name pointer to its original value */
4491                 name -= 19;
4492         }
4493
4494         if (all || some_dos) {
4495                 /* Point to the portion after "system.dos_attr." */
4496                 name += 16;     /* if (all) this will be invalid but unused */
4497
4498                 /* Obtain the DOS attributes */
4499                 if (!smbc_getatr(context, srv, filename, &mode, &size,
4500                                  &c_time, &a_time, &m_time, &ino)) {
4501
4502                         errno = smbc_errno(context, &srv->cli);
4503                         return -1;
4504
4505                 }
4506
4507                 if (! exclude_dos_mode) {
4508                         if (all || all_dos) {
4509                                 if (determine_size) {
4510                                         p = talloc_asprintf(ctx,
4511                                                             "%sMODE:0x%x",
4512                                                             (ipc_cli &&
4513                                                              (all || some_nt)
4514                                                              ? ","
4515                                                              : ""),
4516                                                             mode);
4517                                         if (!p) {
4518                                                 errno = ENOMEM;
4519                                                 return -1;
4520                                         }
4521                                         n = strlen(p);
4522                                 } else {
4523                                         n = snprintf(buf, bufsize,
4524                                                      "%sMODE:0x%x",
4525                                                      (ipc_cli &&
4526                                                       (all || some_nt)
4527                                                       ? ","
4528                                                       : ""),
4529                                                      mode);
4530                                 }
4531                         } else if (StrCaseCmp(name, "mode") == 0) {
4532                                 if (determine_size) {
4533                                         p = talloc_asprintf(ctx, "0x%x", mode);
4534                                         if (!p) {
4535                                                 errno = ENOMEM;
4536                                                 return -1;
4537                                         }
4538                                         n = strlen(p);
4539                                 } else {
4540                                         n = snprintf(buf, bufsize,
4541                                                      "0x%x", mode);
4542                                 }
4543                         }
4544
4545                         if (!determine_size && n > bufsize) {
4546                                 errno = ERANGE;
4547                                 return -1;
4548                         }
4549                         buf += n;
4550                         n_used += n;
4551                         bufsize -= n;
4552                 }
4553
4554                 if (! exclude_dos_size) {
4555                         if (all || all_dos) {
4556                                 if (determine_size) {
4557                                         p = talloc_asprintf(
4558                                                 ctx,
4559                                                 ",SIZE:%.0f",
4560                                                 (double)size);
4561                                         if (!p) {
4562                                                 errno = ENOMEM;
4563                                                 return -1;
4564                                         }
4565                                         n = strlen(p);
4566                                 } else {
4567                                         n = snprintf(buf, bufsize,
4568                                                      ",SIZE:%.0f",
4569                                                      (double)size);
4570                                 }
4571                         } else if (StrCaseCmp(name, "size") == 0) {
4572                                 if (determine_size) {
4573                                         p = talloc_asprintf(
4574                                                 ctx,
4575                                                 "%.0f",
4576                                                 (double)size);
4577                                         if (!p) {
4578                                                 errno = ENOMEM;
4579                                                 return -1;
4580                                         }
4581                                         n = strlen(p);
4582                                 } else {
4583                                         n = snprintf(buf, bufsize,
4584                                                      "%.0f",
4585                                                      (double)size);
4586                                 }
4587                         }
4588
4589                         if (!determine_size && n > bufsize) {
4590                                 errno = ERANGE;
4591                                 return -1;
4592                         }
4593                         buf += n;
4594                         n_used += n;
4595                         bufsize -= n;
4596                 }
4597
4598                 if (! exclude_dos_ctime) {
4599                         if (all || all_dos) {
4600                                 if (determine_size) {
4601                                         p = talloc_asprintf(ctx,
4602                                                             ",C_TIME:%lu",
4603                                                             c_time);
4604                                         if (!p) {
4605                                                 errno = ENOMEM;
4606                                                 return -1;
4607                                         }
4608                                         n = strlen(p);
4609                                 } else {
4610                                         n = snprintf(buf, bufsize,
4611                                                      ",C_TIME:%lu", c_time);
4612                                 }
4613                         } else if (StrCaseCmp(name, "c_time") == 0) {
4614                                 if (determine_size) {
4615                                         p = talloc_asprintf(ctx, "%lu", c_time);
4616                                         if (!p) {
4617                                                 errno = ENOMEM;
4618                                                 return -1;
4619                                         }
4620                                         n = strlen(p);
4621                                 } else {
4622                                         n = snprintf(buf, bufsize,
4623                                                      "%lu", c_time);
4624                                 }
4625                         }
4626
4627                         if (!determine_size && n > bufsize) {
4628                                 errno = ERANGE;
4629                                 return -1;
4630                         }
4631                         buf += n;
4632                         n_used += n;
4633                         bufsize -= n;
4634                 }
4635
4636                 if (! exclude_dos_atime) {
4637                         if (all || all_dos) {
4638                                 if (determine_size) {
4639                                         p = talloc_asprintf(ctx,
4640                                                             ",A_TIME:%lu",
4641                                                             a_time);
4642                                         if (!p) {
4643                                                 errno = ENOMEM;
4644                                                 return -1;
4645                                         }
4646                                         n = strlen(p);
4647                                 } else {
4648                                         n = snprintf(buf, bufsize,
4649                                                      ",A_TIME:%lu", a_time);
4650                                 }
4651                         } else if (StrCaseCmp(name, "a_time") == 0) {
4652                                 if (determine_size) {
4653                                         p = talloc_asprintf(ctx, "%lu", a_time);
4654                                         if (!p) {
4655                                                 errno = ENOMEM;
4656                                                 return -1;
4657                                         }
4658                                         n = strlen(p);
4659                                 } else {
4660                                         n = snprintf(buf, bufsize,
4661                                                      "%lu", a_time);
4662                                 }
4663                         }
4664
4665                         if (!determine_size && n > bufsize) {
4666                                 errno = ERANGE;
4667                                 return -1;
4668                         }
4669                         buf += n;
4670                         n_used += n;
4671                         bufsize -= n;
4672                 }
4673
4674                 if (! exclude_dos_mtime) {
4675                         if (all || all_dos) {
4676                                 if (determine_size) {
4677                                         p = talloc_asprintf(ctx,
4678                                                             ",M_TIME:%lu",
4679                                                             m_time);
4680                                         if (!p) {
4681                                                 errno = ENOMEM;
4682                                                 return -1;
4683                                         }
4684                                         n = strlen(p);
4685                                 } else {
4686                                         n = snprintf(buf, bufsize,
4687                                                      ",M_TIME:%lu", m_time);
4688                                 }
4689                         } else if (StrCaseCmp(name, "m_time") == 0) {
4690                                 if (determine_size) {
4691                                         p = talloc_asprintf(ctx, "%lu", m_time);
4692                                         if (!p) {
4693                                                 errno = ENOMEM;
4694                                                 return -1;
4695                                         }
4696                                         n = strlen(p);
4697                                 } else {
4698                                         n = snprintf(buf, bufsize,
4699                                                      "%lu", m_time);
4700                                 }
4701                         }
4702
4703                         if (!determine_size && n > bufsize) {
4704                                 errno = ERANGE;
4705                                 return -1;
4706                         }
4707                         buf += n;
4708                         n_used += n;
4709                         bufsize -= n;
4710                 }
4711
4712                 if (! exclude_dos_inode) {
4713                         if (all || all_dos) {
4714                                 if (determine_size) {
4715                                         p = talloc_asprintf(
4716                                                 ctx,
4717                                                 ",INODE:%.0f",
4718                                                 (double)ino);
4719                                         if (!p) {
4720                                                 errno = ENOMEM;
4721                                                 return -1;
4722                                         }
4723                                         n = strlen(p);
4724                                 } else {
4725                                         n = snprintf(buf, bufsize,
4726                                                      ",INODE:%.0f",
4727                                                      (double) ino);
4728                                 }
4729                         } else if (StrCaseCmp(name, "inode") == 0) {
4730                                 if (determine_size) {
4731                                         p = talloc_asprintf(
4732                                                 ctx,
4733                                                 "%.0f",
4734                                                 (double) ino);
4735                                         if (!p) {
4736                                                 errno = ENOMEM;
4737                                                 return -1;
4738                                         }
4739                                         n = strlen(p);
4740                                 } else {
4741                                         n = snprintf(buf, bufsize,
4742                                                      "%.0f",
4743                                                      (double) ino);
4744                                 }
4745                         }
4746
4747                         if (!determine_size && n > bufsize) {
4748                                 errno = ERANGE;
4749                                 return -1;
4750                         }
4751                         buf += n;
4752                         n_used += n;
4753                         bufsize -= n;
4754                 }
4755
4756                 /* Restore name pointer to its original value */
4757                 name -= 16;
4758         }
4759
4760         if (n_used == 0) {
4761                 errno = ENOATTR;
4762                 return -1;
4763         }
4764
4765         return n_used;
4766 }
4767
4768
4769 /*****************************************************
4770 set the ACLs on a file given an ascii description
4771 *******************************************************/
4772 static int
4773 cacl_set(TALLOC_CTX *ctx,
4774          struct cli_state *cli,
4775          struct cli_state *ipc_cli,
4776          POLICY_HND *pol,
4777          const char *filename,
4778          const char *the_acl,
4779          int mode,
4780          int flags)
4781 {
4782         int fnum;
4783         int err = 0;
4784         SEC_DESC *sd = NULL, *old;
4785         SEC_ACL *dacl = NULL;
4786         DOM_SID *owner_sid = NULL;
4787         DOM_SID *grp_sid = NULL;
4788         uint32 i, j;
4789         size_t sd_size;
4790         int ret = 0;
4791         char *p;
4792         BOOL numeric = True;
4793
4794         /* the_acl will be null for REMOVE_ALL operations */
4795         if (the_acl) {
4796                 numeric = ((p = strchr(the_acl, ':')) != NULL &&
4797                            p > the_acl &&
4798                            p[-1] != '+');
4799
4800                 /* if this is to set the entire ACL... */
4801                 if (*the_acl == '*') {
4802                         /* ... then increment past the first colon */
4803                         the_acl = p + 1;
4804                 }
4805
4806                 sd = sec_desc_parse(ctx, ipc_cli, pol, numeric,
4807                                     CONST_DISCARD(char *, the_acl));
4808
4809                 if (!sd) {
4810                         errno = EINVAL;
4811                         return -1;
4812                 }
4813         }
4814
4815         /* The desired access below is the only one I could find that works
4816            with NT4, W2KP and Samba */
4817
4818         fnum = cli_nt_create(cli, filename, CREATE_ACCESS_READ);
4819
4820         if (fnum == -1) {
4821                 DEBUG(5, ("cacl_set failed to open %s: %s\n",
4822                           filename, cli_errstr(cli)));
4823                 errno = 0;
4824                 return -1;
4825         }
4826
4827         old = cli_query_secdesc(cli, fnum, ctx);
4828
4829         if (!old) {
4830                 DEBUG(5, ("cacl_set Failed to query old descriptor\n"));
4831                 errno = 0;
4832                 return -1;
4833         }
4834
4835         cli_close(cli, fnum);
4836
4837         switch (mode) {
4838         case SMBC_XATTR_MODE_REMOVE_ALL:
4839                 old->dacl->num_aces = 0;
4840                 SAFE_FREE(old->dacl->ace);
4841                 SAFE_FREE(old->dacl);
4842                 old->off_dacl = 0;
4843                 dacl = old->dacl;
4844                 break;
4845
4846         case SMBC_XATTR_MODE_REMOVE:
4847                 for (i=0;sd->dacl && i<sd->dacl->num_aces;i++) {
4848                         BOOL found = False;
4849
4850                         for (j=0;old->dacl && j<old->dacl->num_aces;j++) {
4851                                 if (sec_ace_equal(&sd->dacl->ace[i],
4852                                                   &old->dacl->ace[j])) {
4853                                         uint32 k;
4854                                         for (k=j; k<old->dacl->num_aces-1;k++) {
4855                                                 old->dacl->ace[k] =
4856                                                         old->dacl->ace[k+1];
4857                                         }
4858                                         old->dacl->num_aces--;
4859                                         if (old->dacl->num_aces == 0) {
4860                                                 SAFE_FREE(old->dacl->ace);
4861                                                 SAFE_FREE(old->dacl);
4862                                                 old->off_dacl = 0;
4863                                         }
4864                                         found = True;
4865                                         dacl = old->dacl;
4866                                         break;
4867                                 }
4868                         }
4869
4870                         if (!found) {
4871                                 err = ENOATTR;
4872                                 ret = -1;
4873                                 goto failed;
4874                         }
4875                 }
4876                 break;
4877
4878         case SMBC_XATTR_MODE_ADD:
4879                 for (i=0;sd->dacl && i<sd->dacl->num_aces;i++) {
4880                         BOOL found = False;
4881
4882                         for (j=0;old->dacl && j<old->dacl->num_aces;j++) {
4883                                 if (sid_equal(&sd->dacl->ace[i].trustee,
4884                                               &old->dacl->ace[j].trustee)) {
4885                                         if (!(flags & SMBC_XATTR_FLAG_CREATE)) {
4886                                                 err = EEXIST;
4887                                                 ret = -1;
4888                                                 goto failed;
4889                                         }
4890                                         old->dacl->ace[j] = sd->dacl->ace[i];
4891                                         ret = -1;
4892                                         found = True;
4893                                 }
4894                         }
4895
4896                         if (!found && (flags & SMBC_XATTR_FLAG_REPLACE)) {
4897                                 err = ENOATTR;
4898                                 ret = -1;
4899                                 goto failed;
4900                         }
4901
4902                         for (i=0;sd->dacl && i<sd->dacl->num_aces;i++) {
4903                                 add_ace(&old->dacl, &sd->dacl->ace[i], ctx);
4904                         }
4905                 }
4906                 dacl = old->dacl;
4907                 break;
4908
4909         case SMBC_XATTR_MODE_SET:
4910                 old = sd;
4911                 owner_sid = old->owner_sid;
4912                 grp_sid = old->grp_sid;
4913                 dacl = old->dacl;
4914                 break;
4915
4916         case SMBC_XATTR_MODE_CHOWN:
4917                 owner_sid = sd->owner_sid;
4918                 break;
4919
4920         case SMBC_XATTR_MODE_CHGRP:
4921                 grp_sid = sd->grp_sid;
4922                 break;
4923         }
4924
4925         /* Denied ACE entries must come before allowed ones */
4926         sort_acl(old->dacl);
4927
4928         /* Create new security descriptor and set it */
4929         sd = make_sec_desc(ctx, old->revision, SEC_DESC_SELF_RELATIVE,
4930                            owner_sid, grp_sid, NULL, dacl, &sd_size);
4931
4932         fnum = cli_nt_create(cli, filename,
4933                              WRITE_DAC_ACCESS | WRITE_OWNER_ACCESS);
4934
4935         if (fnum == -1) {
4936                 DEBUG(5, ("cacl_set failed to open %s: %s\n",
4937                           filename, cli_errstr(cli)));
4938                 errno = 0;
4939                 return -1;
4940         }
4941
4942         if (!cli_set_secdesc(cli, fnum, sd)) {
4943                 DEBUG(5, ("ERROR: secdesc set failed: %s\n", cli_errstr(cli)));
4944                 ret = -1;
4945         }
4946
4947         /* Clean up */
4948
4949  failed:
4950         cli_close(cli, fnum);
4951
4952         if (err != 0) {
4953                 errno = err;
4954         }
4955
4956         return ret;
4957 }
4958
4959
4960 static int
4961 smbc_setxattr_ctx(SMBCCTX *context,
4962                   const char *fname,
4963                   const char *name,
4964                   const void *value,
4965                   size_t size,
4966                   int flags)
4967 {
4968         int ret;
4969         int ret2;
4970         SMBCSRV *srv;
4971         SMBCSRV *ipc_srv;
4972         fstring server;
4973         fstring share;
4974         fstring user;
4975         fstring password;
4976         fstring workgroup;
4977         pstring path;
4978         TALLOC_CTX *ctx;
4979         POLICY_HND pol;
4980         DOS_ATTR_DESC *dad;
4981
4982         if (!context || !context->internal ||
4983             !context->internal->_initialized) {
4984
4985                 errno = EINVAL;  /* Best I can think of ... */
4986                 return -1;
4987
4988         }
4989
4990         if (!fname) {
4991
4992                 errno = EINVAL;
4993                 return -1;
4994
4995         }
4996
4997         DEBUG(4, ("smbc_setxattr(%s, %s, %.*s)\n",
4998                   fname, name, (int) size, (const char*)value));
4999
5000         if (smbc_parse_path(context, fname,
5001                             workgroup, sizeof(workgroup),
5002                             server, sizeof(server),
5003                             share, sizeof(share),
5004                             path, sizeof(path),
5005                             user, sizeof(user),
5006                             password, sizeof(password),
5007                             NULL, 0)) {
5008                 errno = EINVAL;
5009                 return -1;
5010         }
5011
5012         if (user[0] == (char)0) fstrcpy(user, context->user);
5013
5014         srv = smbc_server(context, True,
5015                           server, share, workgroup, user, password);
5016         if (!srv) {
5017                 return -1;  /* errno set by smbc_server */
5018         }
5019
5020         if (! srv->no_nt_session) {
5021                 ipc_srv = smbc_attr_server(context, server, share,
5022                                            workgroup, user, password,
5023                                            &pol);
5024                 srv->no_nt_session = True;
5025         } else {
5026                 ipc_srv = NULL;
5027         }
5028
5029         ctx = talloc_init("smbc_setxattr");
5030         if (!ctx) {
5031                 errno = ENOMEM;
5032                 return -1;
5033         }
5034
5035         /*
5036          * Are they asking to set the entire set of known attributes?
5037          */
5038         if (StrCaseCmp(name, "system.*") == 0 ||
5039             StrCaseCmp(name, "system.*+") == 0) {
5040                 /* Yup. */
5041                 char *namevalue =
5042                         talloc_asprintf(ctx, "%s:%s",
5043                                         name+7, (const char *) value);
5044                 if (! namevalue) {
5045                         errno = ENOMEM;
5046                         ret = -1;
5047                         return -1;
5048                 }
5049
5050                 if (ipc_srv) {
5051                         ret = cacl_set(ctx, &srv->cli,
5052                                        &ipc_srv->cli, &pol, path,
5053                                        namevalue,
5054                                        (*namevalue == '*'
5055                                         ? SMBC_XATTR_MODE_SET
5056                                         : SMBC_XATTR_MODE_ADD),
5057                                        flags);
5058                 } else {
5059                         ret = 0;
5060                 }
5061
5062                 /* get a DOS Attribute Descriptor with current attributes */
5063                 dad = dos_attr_query(context, ctx, path, srv);
5064                 if (dad) {
5065                         /* Overwrite old with new, using what was provided */
5066                         dos_attr_parse(context, dad, srv, namevalue);
5067
5068                         /* Set the new DOS attributes */
5069                         if (! smbc_setatr(context, srv, path,
5070                                           dad->c_time,
5071                                           dad->a_time,
5072                                           dad->m_time,
5073                                           dad->mode)) {
5074
5075                                 /* cause failure if NT failed too */
5076                                 dad = NULL;
5077                         }
5078                 }
5079
5080                 /* we only fail if both NT and DOS sets failed */
5081                 if (ret < 0 && ! dad) {
5082                         ret = -1; /* in case dad was null */
5083                 }
5084                 else {
5085                         ret = 0;
5086                 }
5087
5088                 talloc_destroy(ctx);
5089                 return ret;
5090         }
5091
5092         /*
5093          * Are they asking to set an access control element or to set
5094          * the entire access control list?
5095          */
5096         if (StrCaseCmp(name, "system.nt_sec_desc.*") == 0 ||
5097             StrCaseCmp(name, "system.nt_sec_desc.*+") == 0 ||
5098             StrCaseCmp(name, "system.nt_sec_desc.revision") == 0 ||
5099             StrnCaseCmp(name, "system.nt_sec_desc.acl", 22) == 0 ||
5100             StrnCaseCmp(name, "system.nt_sec_desc.acl+", 23) == 0) {
5101
5102                 /* Yup. */
5103                 char *namevalue =
5104                         talloc_asprintf(ctx, "%s:%s",
5105                                         name+19, (const char *) value);
5106
5107                 if (! ipc_srv) {
5108                         ret = -1; /* errno set by smbc_server() */
5109                 }
5110                 else if (! namevalue) {
5111                         errno = ENOMEM;
5112                         ret = -1;
5113                 } else {
5114                         ret = cacl_set(ctx, &srv->cli,
5115                                        &ipc_srv->cli, &pol, path,
5116                                        namevalue,
5117                                        (*namevalue == '*'
5118                                         ? SMBC_XATTR_MODE_SET
5119                                         : SMBC_XATTR_MODE_ADD),
5120                                        flags);
5121                 }
5122                 talloc_destroy(ctx);
5123                 return ret;
5124         }
5125
5126         /*
5127          * Are they asking to set the owner?
5128          */
5129         if (StrCaseCmp(name, "system.nt_sec_desc.owner") == 0 ||
5130             StrCaseCmp(name, "system.nt_sec_desc.owner+") == 0) {
5131
5132                 /* Yup. */
5133                 char *namevalue =
5134                         talloc_asprintf(ctx, "%s:%s",
5135                                         name+19, (const char *) value);
5136
5137                 if (! ipc_srv) {
5138
5139                         ret = -1; /* errno set by smbc_server() */
5140                 }
5141                 else if (! namevalue) {
5142                         errno = ENOMEM;
5143                         ret = -1;
5144                 } else {
5145                         ret = cacl_set(ctx, &srv->cli,
5146                                        &ipc_srv->cli, &pol, path,
5147                                        namevalue, SMBC_XATTR_MODE_CHOWN, 0);
5148                 }
5149                 talloc_destroy(ctx);
5150                 return ret;
5151         }
5152
5153         /*
5154          * Are they asking to set the group?
5155          */
5156         if (StrCaseCmp(name, "system.nt_sec_desc.group") == 0 ||
5157             StrCaseCmp(name, "system.nt_sec_desc.group+") == 0) {
5158
5159                 /* Yup. */
5160                 char *namevalue =
5161                         talloc_asprintf(ctx, "%s:%s",
5162                                         name+19, (const char *) value);
5163
5164                 if (! ipc_srv) {
5165                         /* errno set by smbc_server() */
5166                         ret = -1;
5167                 }
5168                 else if (! namevalue) {
5169                         errno = ENOMEM;
5170                         ret = -1;
5171                 } else {
5172                         ret = cacl_set(ctx, &srv->cli,
5173                                        &ipc_srv->cli, &pol, path,
5174                                        namevalue, SMBC_XATTR_MODE_CHOWN, 0);
5175                 }
5176                 talloc_destroy(ctx);
5177                 return ret;
5178         }
5179
5180         /*
5181          * Are they asking to set a DOS attribute?
5182          */
5183         if (StrCaseCmp(name, "system.dos_attr.*") == 0 ||
5184             StrCaseCmp(name, "system.dos_attr.mode") == 0 ||
5185             StrCaseCmp(name, "system.dos_attr.c_time") == 0 ||
5186             StrCaseCmp(name, "system.dos_attr.a_time") == 0 ||
5187             StrCaseCmp(name, "system.dos_attr.m_time") == 0) {
5188
5189                 /* get a DOS Attribute Descriptor with current attributes */
5190                 dad = dos_attr_query(context, ctx, path, srv);
5191                 if (dad) {
5192                         char *namevalue =
5193                                 talloc_asprintf(ctx, "%s:%s",
5194                                                 name+16, (const char *) value);
5195                         if (! namevalue) {
5196                                 errno = ENOMEM;
5197                                 ret = -1;
5198                         } else {
5199                                 /* Overwrite old with provided new params */
5200                                 dos_attr_parse(context, dad, srv, namevalue);
5201
5202                                 /* Set the new DOS attributes */
5203                                 ret2 = smbc_setatr(context, srv, path,
5204                                                    dad->c_time,
5205                                                    dad->a_time,
5206                                                    dad->m_time,
5207                                                    dad->mode);
5208
5209                                 /* ret2 has True (success) / False (failure) */
5210                                 if (ret2) {
5211                                         ret = 0;
5212                                 } else {
5213                                         ret = -1;
5214                                 }
5215                         }
5216                 } else {
5217                         ret = -1;
5218                 }
5219
5220                 talloc_destroy(ctx);
5221                 return ret;
5222         }
5223
5224         /* Unsupported attribute name */
5225         talloc_destroy(ctx);
5226         errno = EINVAL;
5227         return -1;
5228 }
5229
5230 static int
5231 smbc_getxattr_ctx(SMBCCTX *context,
5232                   const char *fname,
5233                   const char *name,
5234                   const void *value,
5235                   size_t size)
5236 {
5237         int ret;
5238         SMBCSRV *srv;
5239         SMBCSRV *ipc_srv;
5240         fstring server;
5241         fstring share;
5242         fstring user;
5243         fstring password;
5244         fstring workgroup;
5245         pstring path;
5246         TALLOC_CTX *ctx;
5247         POLICY_HND pol;
5248
5249
5250         if (!context || !context->internal ||
5251             !context->internal->_initialized) {
5252
5253                 errno = EINVAL;  /* Best I can think of ... */
5254                 return -1;
5255
5256         }
5257
5258         if (!fname) {
5259
5260                 errno = EINVAL;
5261                 return -1;
5262
5263         }
5264
5265         DEBUG(4, ("smbc_getxattr(%s, %s)\n", fname, name));
5266
5267         if (smbc_parse_path(context, fname,
5268                             workgroup, sizeof(workgroup),
5269                             server, sizeof(server),
5270                             share, sizeof(share),
5271                             path, sizeof(path),
5272                             user, sizeof(user),
5273                             password, sizeof(password),
5274                             NULL, 0)) {
5275                 errno = EINVAL;
5276                 return -1;
5277         }
5278
5279         if (user[0] == (char)0) fstrcpy(user, context->user);
5280
5281         srv = smbc_server(context, True,
5282                           server, share, workgroup, user, password);
5283         if (!srv) {
5284                 return -1;  /* errno set by smbc_server */
5285         }
5286
5287         if (! srv->no_nt_session) {
5288                 ipc_srv = smbc_attr_server(context, server, share,
5289                                            workgroup, user, password,
5290                                            &pol);
5291                 if (! ipc_srv) {
5292                         srv->no_nt_session = True;
5293                 }
5294         } else {
5295                 ipc_srv = NULL;
5296         }
5297
5298         ctx = talloc_init("smbc:getxattr");
5299         if (!ctx) {
5300                 errno = ENOMEM;
5301                 return -1;
5302         }
5303
5304         /* Are they requesting a supported attribute? */
5305         if (StrCaseCmp(name, "system.*") == 0 ||
5306             StrnCaseCmp(name, "system.*!", 9) == 0 ||
5307             StrCaseCmp(name, "system.*+") == 0 ||
5308             StrnCaseCmp(name, "system.*+!", 10) == 0 ||
5309             StrCaseCmp(name, "system.nt_sec_desc.*") == 0 ||
5310             StrnCaseCmp(name, "system.nt_sec_desc.*!", 21) == 0 ||
5311             StrCaseCmp(name, "system.nt_sec_desc.*+") == 0 ||
5312             StrnCaseCmp(name, "system.nt_sec_desc.*+!", 22) == 0 ||
5313             StrCaseCmp(name, "system.nt_sec_desc.revision") == 0 ||
5314             StrCaseCmp(name, "system.nt_sec_desc.owner") == 0 ||
5315             StrCaseCmp(name, "system.nt_sec_desc.owner+") == 0 ||
5316             StrCaseCmp(name, "system.nt_sec_desc.group") == 0 ||
5317             StrCaseCmp(name, "system.nt_sec_desc.group+") == 0 ||
5318             StrnCaseCmp(name, "system.nt_sec_desc.acl", 22) == 0 ||
5319             StrnCaseCmp(name, "system.nt_sec_desc.acl+", 23) == 0 ||
5320             StrCaseCmp(name, "system.dos_attr.*") == 0 ||
5321             StrnCaseCmp(name, "system.dos_attr.*!", 18) == 0 ||
5322             StrCaseCmp(name, "system.dos_attr.mode") == 0 ||
5323             StrCaseCmp(name, "system.dos_attr.size") == 0 ||
5324             StrCaseCmp(name, "system.dos_attr.c_time") == 0 ||
5325             StrCaseCmp(name, "system.dos_attr.a_time") == 0 ||
5326             StrCaseCmp(name, "system.dos_attr.m_time") == 0 ||
5327             StrCaseCmp(name, "system.dos_attr.inode") == 0) {
5328
5329                 /* Yup. */
5330                 ret = cacl_get(context, ctx, srv,
5331                                ipc_srv == NULL ? NULL : &ipc_srv->cli,
5332                                &pol, path,
5333                                CONST_DISCARD(char *, name),
5334                                CONST_DISCARD(char *, value), size);
5335                 if (ret < 0 && errno == 0) {
5336                         errno = smbc_errno(context, &srv->cli);
5337                 }
5338                 talloc_destroy(ctx);
5339                 return ret;
5340         }
5341
5342         /* Unsupported attribute name */
5343         talloc_destroy(ctx);
5344         errno = EINVAL;
5345         return -1;
5346 }
5347
5348
5349 static int
5350 smbc_removexattr_ctx(SMBCCTX *context,
5351                      const char *fname,
5352                      const char *name)
5353 {
5354         int ret;
5355         SMBCSRV *srv;
5356         SMBCSRV *ipc_srv;
5357         fstring server;
5358         fstring share;
5359         fstring user;
5360         fstring password;
5361         fstring workgroup;
5362         pstring path;
5363         TALLOC_CTX *ctx;
5364         POLICY_HND pol;
5365
5366         if (!context || !context->internal ||
5367             !context->internal->_initialized) {
5368
5369                 errno = EINVAL;  /* Best I can think of ... */
5370                 return -1;
5371
5372         }
5373
5374         if (!fname) {
5375
5376                 errno = EINVAL;
5377                 return -1;
5378
5379         }
5380
5381         DEBUG(4, ("smbc_removexattr(%s, %s)\n", fname, name));
5382
5383         if (smbc_parse_path(context, fname,
5384                             workgroup, sizeof(workgroup),
5385                             server, sizeof(server),
5386                             share, sizeof(share),
5387                             path, sizeof(path),
5388                             user, sizeof(user),
5389                             password, sizeof(password),
5390                             NULL, 0)) {
5391                 errno = EINVAL;
5392                 return -1;
5393         }
5394
5395         if (user[0] == (char)0) fstrcpy(user, context->user);
5396
5397         srv = smbc_server(context, True,
5398                           server, share, workgroup, user, password);
5399         if (!srv) {
5400                 return -1;  /* errno set by smbc_server */
5401         }
5402
5403         if (! srv->no_nt_session) {
5404                 ipc_srv = smbc_attr_server(context, server, share,
5405                                            workgroup, user, password,
5406                                            &pol);
5407                 srv->no_nt_session = True;
5408         } else {
5409                 ipc_srv = NULL;
5410         }
5411
5412         if (! ipc_srv) {
5413                 return -1; /* errno set by smbc_attr_server */
5414         }
5415
5416         ctx = talloc_init("smbc_removexattr");
5417         if (!ctx) {
5418                 errno = ENOMEM;
5419                 return -1;
5420         }
5421
5422         /* Are they asking to set the entire ACL? */
5423         if (StrCaseCmp(name, "system.nt_sec_desc.*") == 0 ||
5424             StrCaseCmp(name, "system.nt_sec_desc.*+") == 0) {
5425
5426                 /* Yup. */
5427                 ret = cacl_set(ctx, &srv->cli,
5428                                &ipc_srv->cli, &pol, path,
5429                                NULL, SMBC_XATTR_MODE_REMOVE_ALL, 0);
5430                 talloc_destroy(ctx);
5431                 return ret;
5432         }
5433
5434         /*
5435          * Are they asking to remove one or more spceific security descriptor
5436          * attributes?
5437          */
5438         if (StrCaseCmp(name, "system.nt_sec_desc.revision") == 0 ||
5439             StrCaseCmp(name, "system.nt_sec_desc.owner") == 0 ||
5440             StrCaseCmp(name, "system.nt_sec_desc.owner+") == 0 ||
5441             StrCaseCmp(name, "system.nt_sec_desc.group") == 0 ||
5442             StrCaseCmp(name, "system.nt_sec_desc.group+") == 0 ||
5443             StrnCaseCmp(name, "system.nt_sec_desc.acl", 22) == 0 ||
5444             StrnCaseCmp(name, "system.nt_sec_desc.acl+", 23) == 0) {
5445
5446                 /* Yup. */
5447                 ret = cacl_set(ctx, &srv->cli,
5448                                &ipc_srv->cli, &pol, path,
5449                                name + 19, SMBC_XATTR_MODE_REMOVE, 0);
5450                 talloc_destroy(ctx);
5451                 return ret;
5452         }
5453
5454         /* Unsupported attribute name */
5455         talloc_destroy(ctx);
5456         errno = EINVAL;
5457         return -1;
5458 }
5459
5460 static int
5461 smbc_listxattr_ctx(SMBCCTX *context,
5462                    const char *fname,
5463                    char *list,
5464                    size_t size)
5465 {
5466         /*
5467          * This isn't quite what listxattr() is supposed to do.  This returns
5468          * the complete set of attribute names, always, rather than only those
5469          * attribute names which actually exist for a file.  Hmmm...
5470          */
5471         const char supported[] =
5472                 "system.*\0"
5473                 "system.*+\0"
5474                 "system.nt_sec_desc.revision\0"
5475                 "system.nt_sec_desc.owner\0"
5476                 "system.nt_sec_desc.owner+\0"
5477                 "system.nt_sec_desc.group\0"
5478                 "system.nt_sec_desc.group+\0"
5479                 "system.nt_sec_desc.acl.*\0"
5480                 "system.nt_sec_desc.acl\0"
5481                 "system.nt_sec_desc.acl+\0"
5482                 "system.nt_sec_desc.*\0"
5483                 "system.nt_sec_desc.*+\0"
5484                 "system.dos_attr.*\0"
5485                 "system.dos_attr.mode\0"
5486                 "system.dos_attr.c_time\0"
5487                 "system.dos_attr.a_time\0"
5488                 "system.dos_attr.m_time\0"
5489                 ;
5490
5491         if (size == 0) {
5492                 return sizeof(supported);
5493         }
5494
5495         if (sizeof(supported) > size) {
5496                 errno = ERANGE;
5497                 return -1;
5498         }
5499
5500         /* this can't be strcpy() because there are embedded null characters */
5501         memcpy(list, supported, sizeof(supported));
5502         return sizeof(supported);
5503 }
5504
5505
5506 /*
5507  * Open a print file to be written to by other calls
5508  */
5509
5510 static SMBCFILE *
5511 smbc_open_print_job_ctx(SMBCCTX *context,
5512                         const char *fname)
5513 {
5514         fstring server;
5515         fstring share;
5516         fstring user;
5517         fstring password;
5518         pstring path;
5519
5520         if (!context || !context->internal ||
5521             !context->internal->_initialized) {
5522
5523                 errno = EINVAL;
5524                 return NULL;
5525
5526         }
5527
5528         if (!fname) {
5529
5530                 errno = EINVAL;
5531                 return NULL;
5532
5533         }
5534
5535         DEBUG(4, ("smbc_open_print_job_ctx(%s)\n", fname));
5536
5537         if (smbc_parse_path(context, fname,
5538                             NULL, 0,
5539                             server, sizeof(server),
5540                             share, sizeof(share),
5541                             path, sizeof(path),
5542                             user, sizeof(user),
5543                             password, sizeof(password),
5544                             NULL, 0)) {
5545                 errno = EINVAL;
5546                 return NULL;
5547         }
5548
5549         /* What if the path is empty, or the file exists? */
5550
5551         return context->open(context, fname, O_WRONLY, 666);
5552
5553 }
5554
5555 /*
5556  * Routine to print a file on a remote server ...
5557  *
5558  * We open the file, which we assume to be on a remote server, and then
5559  * copy it to a print file on the share specified by printq.
5560  */
5561
5562 static int
5563 smbc_print_file_ctx(SMBCCTX *c_file,
5564                     const char *fname,
5565                     SMBCCTX *c_print,
5566                     const char *printq)
5567 {
5568         SMBCFILE *fid1;
5569         SMBCFILE *fid2;
5570         int bytes;
5571         int saverr;
5572         int tot_bytes = 0;
5573         char buf[4096];
5574
5575         if (!c_file || !c_file->internal->_initialized || !c_print ||
5576             !c_print->internal->_initialized) {
5577
5578                 errno = EINVAL;
5579                 return -1;
5580
5581         }
5582
5583         if (!fname && !printq) {
5584
5585                 errno = EINVAL;
5586                 return -1;
5587
5588         }
5589
5590         /* Try to open the file for reading ... */
5591
5592         if ((long)(fid1 = c_file->open(c_file, fname, O_RDONLY, 0666)) < 0) {
5593
5594                 DEBUG(3, ("Error, fname=%s, errno=%i\n", fname, errno));
5595                 return -1;  /* smbc_open sets errno */
5596
5597         }
5598
5599         /* Now, try to open the printer file for writing */
5600
5601         if ((long)(fid2 = c_print->open_print_job(c_print, printq)) < 0) {
5602
5603                 saverr = errno;  /* Save errno */
5604                 c_file->close_fn(c_file, fid1);
5605                 errno = saverr;
5606                 return -1;
5607
5608         }
5609
5610         while ((bytes = c_file->read(c_file, fid1, buf, sizeof(buf))) > 0) {
5611
5612                 tot_bytes += bytes;
5613
5614                 if ((c_print->write(c_print, fid2, buf, bytes)) < 0) {
5615
5616                         saverr = errno;
5617                         c_file->close_fn(c_file, fid1);
5618                         c_print->close_fn(c_print, fid2);
5619                         errno = saverr;
5620
5621                 }
5622
5623         }
5624
5625         saverr = errno;
5626
5627         c_file->close_fn(c_file, fid1);  /* We have to close these anyway */
5628         c_print->close_fn(c_print, fid2);
5629
5630         if (bytes < 0) {
5631
5632                 errno = saverr;
5633                 return -1;
5634
5635         }
5636
5637         return tot_bytes;
5638
5639 }
5640
5641 /*
5642  * Routine to list print jobs on a printer share ...
5643  */
5644
5645 static int
5646 smbc_list_print_jobs_ctx(SMBCCTX *context,
5647                          const char *fname,
5648                          smbc_list_print_job_fn fn)
5649 {
5650         SMBCSRV *srv;
5651         fstring server;
5652         fstring share;
5653         fstring user;
5654         fstring password;
5655         fstring workgroup;
5656         pstring path;
5657
5658         if (!context || !context->internal ||
5659             !context->internal->_initialized) {
5660
5661                 errno = EINVAL;
5662                 return -1;
5663
5664         }
5665
5666         if (!fname) {
5667
5668                 errno = EINVAL;
5669                 return -1;
5670
5671         }
5672
5673         DEBUG(4, ("smbc_list_print_jobs(%s)\n", fname));
5674
5675         if (smbc_parse_path(context, fname,
5676                             workgroup, sizeof(workgroup),
5677                             server, sizeof(server),
5678                             share, sizeof(share),
5679                             path, sizeof(path),
5680                             user, sizeof(user),
5681                             password, sizeof(password),
5682                             NULL, 0)) {
5683                 errno = EINVAL;
5684                 return -1;
5685         }
5686
5687         if (user[0] == (char)0) fstrcpy(user, context->user);
5688
5689         srv = smbc_server(context, True,
5690                           server, share, workgroup, user, password);
5691
5692         if (!srv) {
5693
5694                 return -1;  /* errno set by smbc_server */
5695
5696         }
5697
5698         if (cli_print_queue(&srv->cli,
5699                             (void (*)(struct print_job_info *))fn) < 0) {
5700
5701                 errno = smbc_errno(context, &srv->cli);
5702                 return -1;
5703
5704         }
5705
5706         return 0;
5707
5708 }
5709
5710 /*
5711  * Delete a print job from a remote printer share
5712  */
5713
5714 static int
5715 smbc_unlink_print_job_ctx(SMBCCTX *context,
5716                           const char *fname,
5717                           int id)
5718 {
5719         SMBCSRV *srv;
5720         fstring server;
5721         fstring share;
5722         fstring user;
5723         fstring password;
5724         fstring workgroup;
5725         pstring path;
5726         int err;
5727
5728         if (!context || !context->internal ||
5729             !context->internal->_initialized) {
5730
5731                 errno = EINVAL;
5732                 return -1;
5733
5734         }
5735
5736         if (!fname) {
5737
5738                 errno = EINVAL;
5739                 return -1;
5740
5741         }
5742
5743         DEBUG(4, ("smbc_unlink_print_job(%s)\n", fname));
5744
5745         if (smbc_parse_path(context, fname,
5746                             workgroup, sizeof(workgroup),
5747                             server, sizeof(server),
5748                             share, sizeof(share),
5749                             path, sizeof(path),
5750                             user, sizeof(user),
5751                             password, sizeof(password),
5752                             NULL, 0)) {
5753                 errno = EINVAL;
5754                 return -1;
5755         }
5756
5757         if (user[0] == (char)0) fstrcpy(user, context->user);
5758
5759         srv = smbc_server(context, True,
5760                           server, share, workgroup, user, password);
5761
5762         if (!srv) {
5763
5764                 return -1;  /* errno set by smbc_server */
5765
5766         }
5767
5768         if ((err = cli_printjob_del(&srv->cli, id)) != 0) {
5769
5770                 if (err < 0)
5771                         errno = smbc_errno(context, &srv->cli);
5772                 else if (err == ERRnosuchprintjob)
5773                         errno = EINVAL;
5774                 return -1;
5775
5776         }
5777
5778         return 0;
5779
5780 }
5781
5782 /*
5783  * Get a new empty handle to fill in with your own info
5784  */
5785 SMBCCTX *
5786 smbc_new_context(void)
5787 {
5788         SMBCCTX *context;
5789
5790         context = SMB_MALLOC_P(SMBCCTX);
5791         if (!context) {
5792                 errno = ENOMEM;
5793                 return NULL;
5794         }
5795
5796         ZERO_STRUCTP(context);
5797
5798         context->internal = SMB_MALLOC_P(struct smbc_internal_data);
5799         if (!context->internal) {
5800                 SAFE_FREE(context);
5801                 errno = ENOMEM;
5802                 return NULL;
5803         }
5804
5805         ZERO_STRUCTP(context->internal);
5806
5807
5808         /* ADD REASONABLE DEFAULTS */
5809         context->debug            = 0;
5810         context->timeout          = 20000; /* 20 seconds */
5811
5812         context->options.browse_max_lmb_count      = 3;    /* # LMBs to query */
5813         context->options.urlencode_readdir_entries = False;/* backward compat */
5814         context->options.one_share_per_server      = False;/* backward compat */
5815
5816         context->open                              = smbc_open_ctx;
5817         context->creat                             = smbc_creat_ctx;
5818         context->read                              = smbc_read_ctx;
5819         context->write                             = smbc_write_ctx;
5820         context->close_fn                          = smbc_close_ctx;
5821         context->unlink                            = smbc_unlink_ctx;
5822         context->rename                            = smbc_rename_ctx;
5823         context->lseek                             = smbc_lseek_ctx;
5824         context->stat                              = smbc_stat_ctx;
5825         context->fstat                             = smbc_fstat_ctx;
5826         context->opendir                           = smbc_opendir_ctx;
5827         context->closedir                          = smbc_closedir_ctx;
5828         context->readdir                           = smbc_readdir_ctx;
5829         context->getdents                          = smbc_getdents_ctx;
5830         context->mkdir                             = smbc_mkdir_ctx;
5831         context->rmdir                             = smbc_rmdir_ctx;
5832         context->telldir                           = smbc_telldir_ctx;
5833         context->lseekdir                          = smbc_lseekdir_ctx;
5834         context->fstatdir                          = smbc_fstatdir_ctx;
5835         context->chmod                             = smbc_chmod_ctx;
5836         context->utimes                            = smbc_utimes_ctx;
5837         context->setxattr                          = smbc_setxattr_ctx;
5838         context->getxattr                          = smbc_getxattr_ctx;
5839         context->removexattr                       = smbc_removexattr_ctx;
5840         context->listxattr                         = smbc_listxattr_ctx;
5841         context->open_print_job                    = smbc_open_print_job_ctx;
5842         context->print_file                        = smbc_print_file_ctx;
5843         context->list_print_jobs                   = smbc_list_print_jobs_ctx;
5844         context->unlink_print_job                  = smbc_unlink_print_job_ctx;
5845
5846         context->callbacks.check_server_fn         = smbc_check_server;
5847         context->callbacks.remove_unused_server_fn = smbc_remove_unused_server;
5848
5849         smbc_default_cache_functions(context);
5850
5851         return context;
5852 }
5853
5854 /*
5855  * Free a context
5856  *
5857  * Returns 0 on success. Otherwise returns 1, the SMBCCTX is _not_ freed
5858  * and thus you'll be leaking memory if not handled properly.
5859  *
5860  */
5861 int
5862 smbc_free_context(SMBCCTX *context,
5863                   int shutdown_ctx)
5864 {
5865         if (!context) {
5866                 errno = EBADF;
5867                 return 1;
5868         }
5869
5870         if (shutdown_ctx) {
5871                 SMBCFILE * f;
5872                 DEBUG(1,("Performing aggressive shutdown.\n"));
5873
5874                 f = context->internal->_files;
5875                 while (f) {
5876                         context->close_fn(context, f);
5877                         f = f->next;
5878                 }
5879                 context->internal->_files = NULL;
5880
5881                 /* First try to remove the servers the nice way. */
5882                 if (context->callbacks.purge_cached_fn(context)) {
5883                         SMBCSRV * s;
5884                         SMBCSRV * next;
5885                         DEBUG(1, ("Could not purge all servers, "
5886                                   "Nice way shutdown failed.\n"));
5887                         s = context->internal->_servers;
5888                         while (s) {
5889                                 DEBUG(1, ("Forced shutdown: %p (fd=%d)\n",
5890                                           s, s->cli.fd));
5891                                 cli_shutdown(&s->cli);
5892                                 context->callbacks.remove_cached_srv_fn(context,
5893                                                                         s);
5894                                 next = s->next;
5895                                 DLIST_REMOVE(context->internal->_servers, s);
5896                                 SAFE_FREE(s);
5897                                 s = next;
5898                         }
5899                         context->internal->_servers = NULL;
5900                 }
5901         }
5902         else {
5903                 /* This is the polite way */
5904                 if (context->callbacks.purge_cached_fn(context)) {
5905                         DEBUG(1, ("Could not purge all servers, "
5906                                   "free_context failed.\n"));
5907                         errno = EBUSY;
5908                         return 1;
5909                 }
5910                 if (context->internal->_servers) {
5911                         DEBUG(1, ("Active servers in context, "
5912                                   "free_context failed.\n"));
5913                         errno = EBUSY;
5914                         return 1;
5915                 }
5916                 if (context->internal->_files) {
5917                         DEBUG(1, ("Active files in context, "
5918                                   "free_context failed.\n"));
5919                         errno = EBUSY;
5920                         return 1;
5921                 }
5922         }
5923
5924         /* Things we have to clean up */
5925         SAFE_FREE(context->workgroup);
5926         SAFE_FREE(context->netbios_name);
5927         SAFE_FREE(context->user);
5928
5929         DEBUG(3, ("Context %p succesfully freed\n", context));
5930         SAFE_FREE(context->internal);
5931         SAFE_FREE(context);
5932         return 0;
5933 }
5934
5935
5936 /*
5937  * Each time the context structure is changed, we have binary backward
5938  * compatibility issues.  Instead of modifying the public portions of the
5939  * context structure to add new options, instead, we put them in the internal
5940  * portion of the context structure and provide a set function for these new
5941  * options.
5942  */
5943 void
5944 smbc_option_set(SMBCCTX *context,
5945                 char *option_name,
5946                 void *option_value)
5947 {
5948         if (strcmp(option_name, "debug_stderr") == 0) {
5949                 /*
5950                  * Log to standard error instead of standard output.
5951                  */
5952                 context->internal->_debug_stderr = True;
5953         }
5954 }
5955
5956
5957 /*
5958  * Initialise the library etc
5959  *
5960  * We accept a struct containing handle information.
5961  * valid values for info->debug from 0 to 100,
5962  * and insist that info->fn must be non-null.
5963  */
5964 SMBCCTX *
5965 smbc_init_context(SMBCCTX *context)
5966 {
5967         pstring conf;
5968         int pid;
5969         char *user = NULL;
5970         char *home = NULL;
5971
5972         if (!context || !context->internal) {
5973                 errno = EBADF;
5974                 return NULL;
5975         }
5976
5977         /* Do not initialise the same client twice */
5978         if (context->internal->_initialized) {
5979                 return 0;
5980         }
5981
5982         if (!context->callbacks.auth_fn ||
5983             context->debug < 0 ||
5984             context->debug > 100) {
5985
5986                 errno = EINVAL;
5987                 return NULL;
5988
5989         }
5990
5991         if (!smbc_initialized) {
5992                 /*
5993                  * Do some library-wide intializations the first time we get
5994                  * called
5995                  */
5996                 BOOL conf_loaded = False;
5997
5998                 /* Set this to what the user wants */
5999                 DEBUGLEVEL = context->debug;
6000
6001                 load_case_tables();
6002
6003                 setup_logging("libsmbclient", True);
6004                 if (context->internal->_debug_stderr) {
6005                         dbf = x_stderr;
6006                         x_setbuf(x_stderr, NULL);
6007                 }
6008
6009                 /* Here we would open the smb.conf file if needed ... */
6010
6011                 in_client = True; /* FIXME, make a param */
6012
6013                 home = getenv("HOME");
6014                 if (home) {
6015                         slprintf(conf, sizeof(conf), "%s/.smb/smb.conf", home);
6016                         if (lp_load(conf, True, False, False, True)) {
6017                                 conf_loaded = True;
6018                         } else {
6019                                 DEBUG(5, ("Could not load config file: %s\n",
6020                                           conf));
6021                         }
6022                 }
6023
6024                 if (!conf_loaded) {
6025                         /*
6026                          * Well, if that failed, try the dyn_CONFIGFILE
6027                          * Which points to the standard locn, and if that
6028                          * fails, silently ignore it and use the internal
6029                          * defaults ...
6030                          */
6031
6032                         if (!lp_load(dyn_CONFIGFILE, True, False, False, False)) {
6033                                 DEBUG(5, ("Could not load config file: %s\n",
6034                                           dyn_CONFIGFILE));
6035                         } else if (home) {
6036                                 /*
6037                                  * We loaded the global config file.  Now lets
6038                                  * load user-specific modifications to the
6039                                  * global config.
6040                                  */
6041                                 slprintf(conf, sizeof(conf),
6042                                          "%s/.smb/smb.conf.append", home);
6043                                 if (!lp_load(conf, True, False, False, False)) {
6044                                         DEBUG(10,
6045                                               ("Could not append config file: "
6046                                                "%s\n",
6047                                                conf));
6048                                 }
6049                         }
6050                 }
6051
6052                 load_interfaces();  /* Load the list of interfaces ... */
6053
6054                 reopen_logs();  /* Get logging working ... */
6055
6056                 /*
6057                  * Block SIGPIPE (from lib/util_sock.c: write())
6058                  * It is not needed and should not stop execution
6059                  */
6060                 BlockSignals(True, SIGPIPE);
6061
6062                 /* Done with one-time initialisation */
6063                 smbc_initialized = 1;
6064
6065         }
6066
6067         if (!context->user) {
6068                 /*
6069                  * FIXME: Is this the best way to get the user info?
6070                  */
6071                 user = getenv("USER");
6072                 /* walk around as "guest" if no username can be found */
6073                 if (!user) context->user = SMB_STRDUP("guest");
6074                 else context->user = SMB_STRDUP(user);
6075         }
6076
6077         if (!context->netbios_name) {
6078                 /*
6079                  * We try to get our netbios name from the config. If that
6080                  * fails we fall back on constructing our netbios name from
6081                  * our hostname etc
6082                  */
6083                 if (global_myname()) {
6084                         context->netbios_name = SMB_STRDUP(global_myname());
6085                 }
6086                 else {
6087                         /*
6088                          * Hmmm, I want to get hostname as well, but I am too
6089                          * lazy for the moment
6090                          */
6091                         pid = sys_getpid();
6092                         context->netbios_name = SMB_MALLOC(17);
6093                         if (!context->netbios_name) {
6094                                 errno = ENOMEM;
6095                                 return NULL;
6096                         }
6097                         slprintf(context->netbios_name, 16,
6098                                  "smbc%s%d", context->user, pid);
6099                 }
6100         }
6101
6102         DEBUG(1, ("Using netbios name %s.\n", context->netbios_name));
6103
6104         if (!context->workgroup) {
6105                 if (lp_workgroup()) {
6106                         context->workgroup = SMB_STRDUP(lp_workgroup());
6107                 }
6108                 else {
6109                         /* TODO: Think about a decent default workgroup */
6110                         context->workgroup = SMB_STRDUP("samba");
6111                 }
6112         }
6113
6114         DEBUG(1, ("Using workgroup %s.\n", context->workgroup));
6115
6116         /* shortest timeout is 1 second */
6117         if (context->timeout > 0 && context->timeout < 1000)
6118                 context->timeout = 1000;
6119
6120         /*
6121          * FIXME: Should we check the function pointers here?
6122          */
6123
6124         context->internal->_initialized = True;
6125
6126         return context;
6127 }
6128
6129
6130 /* Return the verion of samba, and thus libsmbclient */
6131 const char *
6132 smbc_version(void)
6133 {
6134         return samba_version_string();
6135 }