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